LinkMatrixSparse.hpp File Reference

#include "gstlearn_export.hpp"
#include "Basic/VectorNumT.hpp"

Classes
class	QChol
class	cs_MG
class	cs_MGS

Functions
GSTLEARN_EXPORT cs *	cs_spfree2 (cs *A)
	TODO : cs_*2 functions to be removed (encapsulation) More...
GSTLEARN_EXPORT css *	cs_sfree2 (css *S)
GSTLEARN_EXPORT csn *	cs_nfree2 (csn *N)
GSTLEARN_EXPORT cs *	cs_spalloc2 (int m, int n, int nzmax, int values, int triplet)
GSTLEARN_EXPORT int	cs_entry2 (cs *T, int i, int j, double x)
GSTLEARN_EXPORT cs *	cs_triplet2 (const cs *T)
GSTLEARN_EXPORT cs *	cs_transpose2 (const cs *A, int values)
GSTLEARN_EXPORT cs *	cs_multiply2 (const cs *A, const cs *B)
GSTLEARN_EXPORT int	cs_print2 (const cs *A, int brief)
GSTLEARN_EXPORT void	cs_add_cste (cs *A, double value)
GSTLEARN_EXPORT void	cs_set_cste (const cs *A, double value)
GSTLEARN_EXPORT void	cs_vector_tMx (const cs *A, int nout, const double *x, double *y)
GSTLEARN_EXPORT void	cs_vector_xM (const cs *A, int nout, const double *x, double *y)
GSTLEARN_EXPORT void	cs_vector_Mx (const cs *A, int nout, const double *x, double *y)
GSTLEARN_EXPORT void	cs_vector_xtM (const cs *A, int nout, const double *x, double *y)
GSTLEARN_EXPORT void	cs_mulvec_uptri (const cs *A, int nout, const double *x, double *y, int flag_diag)
GSTLEARN_EXPORT void	cs_mulvec_lowtri (const cs *A, int nout, const double *x, double *y, int flag_diag)
GSTLEARN_EXPORT cs *	cs_matvecR (const cs *A, const double *x, int oper)
GSTLEARN_EXPORT cs *	cs_matvecL (const cs *A, const double *x, int oper)
GSTLEARN_EXPORT cs *	cs_matvecnorm (const cs *A, const double *x, int oper)
GSTLEARN_EXPORT void	cs_matvecnorm_inplace (cs *A, const double *x, int oper)
GSTLEARN_EXPORT double *	cs_col_sumrow (const cs *A, int *ncol, int *nrow)
GSTLEARN_EXPORT double	cs_maxsumabscol (const cs *A)
GSTLEARN_EXPORT void	cs_print_only (const char *title, const cs *A, int nlimit)
GSTLEARN_EXPORT void	cs_print_nice (const char *title, const cs *A, int maxrow=-1, int maxcol=-1)
GSTLEARN_EXPORT void	cs_print_dim (const char *title, const cs *A)
GSTLEARN_EXPORT void	cs_print_short (const char *title, const cs *L, int nmax)
GSTLEARN_EXPORT void	cs_print_file (const char *radix, int rank, const cs *A)
GSTLEARN_EXPORT cs *	cs_compress (cs *A)
GSTLEARN_EXPORT void	cs_force_dimension (cs *T, int nrow, int ncol)
GSTLEARN_EXPORT cs *	cs_diag (VectorDouble diag, double tol=EPSILON10)
GSTLEARN_EXPORT int	_cs_findColor (const cs *Q, int imesh, int ncolor, VectorInt &colors, VectorInt &temp)
GSTLEARN_EXPORT cs *	cs_extract_submatrix_by_color (const cs *C, const VectorInt &colors, int ref_color, int row_ok, int col_ok)
GSTLEARN_EXPORT VectorDouble	csd_extract_diag_VD (const cs *C, int oper_choice=1)
GSTLEARN_EXPORT cs *	cs_prod_norm_diagonal (int mode, const cs *B, VectorDouble diag)
GSTLEARN_EXPORT MatrixSparse *	cs_arrays_to_sparse (int n, int nrow, int ncol, const double *rows, const double *cols, const double *vals)
GSTLEARN_EXPORT MatrixSparse *	cs_vectors_to_sparse (int nrow, int ncol, const VectorDouble &rows, const VectorDouble &cols, const VectorDouble &values)
GSTLEARN_EXPORT int	cs_lsolve_lowtri (const cs *L, const double *x, double *y)
GSTLEARN_EXPORT int	cs_lsolve_uptri (const cs *L, const double *x, double *y)
GSTLEARN_EXPORT cs *	cs_invert (const cs *A, int order, double epsilon=EPSILON6)
GSTLEARN_EXPORT cs_MGS *	cs_multigrid_manage (cs_MGS *mgs, int mode, int nlevels, int path_type)
GSTLEARN_EXPORT void	cs_multigrid_params (cs_MGS *mgs, int flag_cg, int type_coarse, int ngc, int nmg, int ngs, double tolgc, double tolnmg)
GSTLEARN_EXPORT void	cs_multigrid_print (cs_MGS *mgs)
GSTLEARN_EXPORT int	cs_multigrid_get_nlevels (cs_MGS *mgs)
GSTLEARN_EXPORT int	cs_multigrid_setup (cs_MGS *mgs, QChol *Qctt, int flag_sel, int verbose, double **sel)
GSTLEARN_EXPORT int	cs_multigrid_process (cs_MGS *mgs, QChol *qctt, int verbose, double *x, double *b, double *work)
GSTLEARN_EXPORT void	cs_multigrid_coarse2fine (cs_MGS *mgs, double *z, double *work)
GSTLEARN_EXPORT int	qchol_cholesky (int verbose, QChol *QC)
GSTLEARN_EXPORT void	cs_chol_invert (QChol *qctt, double *xcr, double *rhs, double *work)
GSTLEARN_EXPORT void	cs_chol_simulate (QChol *qctt, double *simu, double *work)
GSTLEARN_EXPORT NF_Triplet	csToTriplet (const cs *A, int shiftRow=0, int shiftCol=0, double tol=EPSILON10)
GSTLEARN_EXPORT String	toStringDim (const String &title, const cs *A)
GSTLEARN_EXPORT String	toStringRange (const String &title, const cs *C)
GSTLEARN_EXPORT bool	cs_isSymmetric (const cs *A, bool verbose=false, bool detail=false)
GSTLEARN_EXPORT bool	cs_isDiagonalDominant (cs *A, bool verbose=false, bool detail=false)
GSTLEARN_EXPORT bool	cs_isDefinitePositive (cs *A, bool verbose=false)
GSTLEARN_EXPORT cs *	cs_extract_submatrix (cs *C, int row_from, int row_length, int col_from, int col_length)
GSTLEARN_EXPORT void	cs_print_range (const char *title, const cs *C)
GSTLEARN_EXPORT cs *	cs_eye (int number, double value)
GSTLEARN_EXPORT cs *	cs_eye_tab (int number, double *values)
GSTLEARN_EXPORT cs *	cs_extract_diag (const cs *C, int oper_choice=1)
GSTLEARN_EXPORT void	cs_diag_suppress (cs *C)
GSTLEARN_EXPORT double *	csd_extract_diag (const cs *C, int oper_choice=1)
GSTLEARN_EXPORT int	cs_sort_i (cs *C)
GSTLEARN_EXPORT void	cs_rowcol (const cs *A, int *nrows, int *ncols, int *count, double *percent)
GSTLEARN_EXPORT cs *	cs_duplicate (const cs *b1)
GSTLEARN_EXPORT cs *	cs_multiply_and_release (cs *b1, const cs *b2, int flag_rel)
GSTLEARN_EXPORT cs *	cs_add_and_release (cs *b1, const cs *b2, double alpha, double beta, int flag_rel)
GSTLEARN_EXPORT cs *	cs_normalize_by_diag_and_release (cs *Q, int flag_rel)
GSTLEARN_EXPORT cs *	cs_prod_norm (int mode, const cs *A, const cs *IhH)
GSTLEARN_EXPORT cs *	cs_prod_norm_single (int mode, const cs *B)
GSTLEARN_EXPORT cs *	cs_prod_norm_and_release (cs *b1, cs *lambda, int flag_rel)
GSTLEARN_EXPORT int	cs_coarsening (const cs *Q, int type, int **indCo, cs **L)
GSTLEARN_EXPORT cs *	cs_interpolate (const cs *AA, const cs *LL, int *indCo)
GSTLEARN_EXPORT cs *	cs_triangle (cs *A, int flag_upper, int flag_diag)
GSTLEARN_EXPORT int	cs_scale (const cs *C)
GSTLEARN_EXPORT int	cs_get_nrow (const cs *A)
GSTLEARN_EXPORT int	cs_get_ncol (const cs *A)
GSTLEARN_EXPORT int	cs_get_ncell (const cs *A)
GSTLEARN_EXPORT bool	cs_exist (const cs *A, int row, int col)
GSTLEARN_EXPORT double	cs_get_value (const cs *A, int row, int col)
GSTLEARN_EXPORT void	cs_set_value (const cs *A, int row, int col, double value)
GSTLEARN_EXPORT void	cs_add_value (const cs *A, int row, int col, double value)
GSTLEARN_EXPORT double *	cs_toArray (const cs *A)
GSTLEARN_EXPORT cs *	cs_strip (cs *A, double eps, int hypothesis=3, bool verbose=false)
GSTLEARN_EXPORT int	cs_nnz (const cs *A)
GSTLEARN_EXPORT cs *	cs_glue (const cs *A1, const cs *A2, bool shiftRow, bool shiftCol)
GSTLEARN_EXPORT void	cs_set_status_update_nonzero_value (int status=2)
GSTLEARN_EXPORT int	cs_get_status_update_nonzero_value ()

Function Documentation

_cs_findColor()

GSTLEARN_EXPORT int _cs_findColor	(	const cs *	Q,
		int	imesh,
		int	ncolor,
		VectorInt &	colors,
		VectorInt &	temp
	)

cs_add_and_release()

GSTLEARN_EXPORT cs* cs_add_and_release	(	cs *	b1,
		const cs *	b2,
		double	alpha,
		double	beta,
		int	flag_rel
	)

cs_add_cste()

GSTLEARN_EXPORT void cs_add_cste	(	cs *	A,
		double	value
	)

cs_add_value()

GSTLEARN_EXPORT void cs_add_value	(	const cs *	A,
		int	row,
		int	col,
		double	value
	)

cs_arrays_to_sparse()

GSTLEARN_EXPORT MatrixSparse* cs_arrays_to_sparse	(	int	n,
		int	nrow,
		int	ncol,
		const double *	rows,
		const double *	cols,
		const double *	vals
	)

cs_chol_invert()

GSTLEARN_EXPORT void cs_chol_invert	(	QChol *	qctt,
		double *	xcr,
		double *	rhs,
		double *	work
	)

Inversion using Cholesky

Parameters

[in]	qctt	Qchol structure
[in,out]	xcr	Current vector
[in]	rhs	Current R.H.S. vector
[out]	work	Working array

cs_chol_simulate()

GSTLEARN_EXPORT void cs_chol_simulate	(	QChol *	qctt,
		double *	simu,
		double *	work
	)

Simulate using Cholesky

Parameters

[in]	qctt	Qchol structure
[out]	simu	Simulated array
[out]	work	Working array

cs_coarsening()

GSTLEARN_EXPORT int cs_coarsening	(	const cs *	Q,
		int	type,
		int **	indCo,
		cs **	L
	)

cs_col_sumrow()

GSTLEARN_EXPORT double* cs_col_sumrow	(	const cs *	A,
		int *	ncol,
		int *	nrow
	)

cs_compress()

GSTLEARN_EXPORT cs* cs_compress

(

cs *

A

)

cs_diag()

GSTLEARN_EXPORT cs* cs_diag	(	VectorDouble	diag,
		double	tol = EPSILON10
	)

cs_diag_suppress()

GSTLEARN_EXPORT void cs_diag_suppress

(

cs *

C

)

cs_duplicate()

GSTLEARN_EXPORT cs* cs_duplicate

(

const cs *

b1

)

cs_entry2()

GSTLEARN_EXPORT int cs_entry2	(	cs *	T,
		int	i,
		int	j,
		double	x
	)

cs_exist()

GSTLEARN_EXPORT bool cs_exist	(	const cs *	A,
		int	row,
		int	col
	)

cs_extract_diag()

GSTLEARN_EXPORT cs* cs_extract_diag	(	const cs *	C,
		int	oper_choice = 1
	)

cs_extract_submatrix()

GSTLEARN_EXPORT cs* cs_extract_submatrix	(	cs *	C,
		int	row_from,
		int	row_length,
		int	col_from,
		int	col_length
	)

cs_extract_submatrix_by_color()

GSTLEARN_EXPORT cs* cs_extract_submatrix_by_color	(	const cs *	C,
		const VectorInt &	colors,
		int	ref_color,
		int	row_ok,
		int	col_ok
	)

cs_eye()

GSTLEARN_EXPORT cs* cs_eye	(	int	number,
		double	value
	)

cs_eye_tab()

GSTLEARN_EXPORT cs* cs_eye_tab	(	int	number,
		double *	values
	)

cs_force_dimension()

GSTLEARN_EXPORT void cs_force_dimension	(	cs *	T,
		int	nrow,
		int	ncol
	)

cs_get_ncell()

GSTLEARN_EXPORT int cs_get_ncell

(

const cs *

A

)

cs_get_ncol()

GSTLEARN_EXPORT int cs_get_ncol

(

const cs *

A

)

cs_get_nrow()

GSTLEARN_EXPORT int cs_get_nrow

(

const cs *

A

)

cs_get_status_update_nonzero_value()

GSTLEARN_EXPORT int cs_get_status_update_nonzero_value

(

)

cs_get_value()

GSTLEARN_EXPORT double cs_get_value	(	const cs *	A,
		int	row,
		int	col
	)

cs_glue()

GSTLEARN_EXPORT cs* cs_glue	(	const cs *	A1,
		const cs *	A2,
		bool	shiftRow,
		bool	shiftCol
	)

This method glues two sparse matrices into an output sparse matrix The second matrix is appended after addresses have been shifted either by row or by column

Parameters

A1	First sparse matrix
A2	Secon sparse matrix
shiftRow	Shift A2 addresses by the number of rows of A1
shiftCol	Shift A2 addresses by the number of columns of A1

Returns

The newly create sparse matrix

cs_interpolate()

GSTLEARN_EXPORT cs* cs_interpolate	(	const cs *	AA,
		const cs *	LL,
		int *	indCo
	)

cs_invert()

GSTLEARN_EXPORT cs* cs_invert	(	const cs *	A,
		int	order,
		double	epsilon = EPSILON6
	)

cs_isDefinitePositive()

GSTLEARN_EXPORT bool cs_isDefinitePositive	(	cs *	A,
		bool	verbose = false
	)

cs_isDiagonalDominant()

GSTLEARN_EXPORT bool cs_isDiagonalDominant	(	cs *	A,
		bool	verbose = false,
		bool	detail = false
	)

cs_isSymmetric()

GSTLEARN_EXPORT bool cs_isSymmetric	(	const cs *	A,
		bool	verbose = false,
		bool	detail = false
	)

cs_lsolve_lowtri()

GSTLEARN_EXPORT int cs_lsolve_lowtri	(	const cs *	L,
		const double *	x,
		double *	y
	)

cs_lsolve_uptri()

GSTLEARN_EXPORT int cs_lsolve_uptri	(	const cs *	L,
		const double *	x,
		double *	y
	)

cs_matvecL()

GSTLEARN_EXPORT cs* cs_matvecL	(	const cs *	A,
		const double *	x,
		int	oper
	)

cs_matvecnorm()

GSTLEARN_EXPORT cs* cs_matvecnorm	(	const cs *	A,
		const double *	x,
		int	oper
	)

cs_matvecnorm_inplace()

GSTLEARN_EXPORT void cs_matvecnorm_inplace	(	cs *	A,
		const double *	x,
		int	oper
	)

cs_matvecR()

GSTLEARN_EXPORT cs* cs_matvecR	(	const cs *	A,
		const double *	x,
		int	oper
	)

cs_maxsumabscol()

GSTLEARN_EXPORT double cs_maxsumabscol

(

const cs *

A

)

Compute the max along the lines of the sum of the absolute values along the columns

cs_multigrid_coarse2fine()

GSTLEARN_EXPORT void cs_multigrid_coarse2fine	(	cs_MGS *	mgs,
		double *	z,
		double *	work
	)

Convert results from coarsest to final scale

Parameters

[in]	mgs	cs_MGS structure
[in,out]	z	Input vector
[out]	work	Working array

Remarks

Arguments 'z' and 'work' maust be dimensioned to the finest size

cs_multigrid_get_nlevels()

GSTLEARN_EXPORT int cs_multigrid_get_nlevels

(

cs_MGS *

mgs

)

Returns the number of multigrid levels

Parameters

[in]

mgs

cs_MGS structure

cs_multigrid_manage()

GSTLEARN_EXPORT cs_MGS * cs_multigrid_manage	(	cs_MGS *	mgs,
		int	mode,
		int	nlevels,
		int	path_type
	)

Allocate the structure for the multigrid manipulation

Parameters

[in]	mgs	cs_MGS structure
[in]	mode	1 for allocation; -1 for deallocation
[in]	nlevels	Number of levels of the multigrid (only for mode > 0)
[in]	path_type	Type of the Path (1:V; 2:W, 3:F) (only for mode > 0)

cs_multigrid_params()

GSTLEARN_EXPORT void cs_multigrid_params	(	cs_MGS *	mgs,
		int	flag_cg,
		int	type_coarse,
		int	ngc,
		int	nmg,
		int	ngs,
		double	tolcg,
		double	tolnmg
	)

Define the parameters for the multigrid manipulation

Parameters

[in]	mgs	cs_MGS structure
[in]	flag_cg	1 for Conjugate-Gradient use; 0 otherwise
[in]	type_coarse	Type of coarsening algorithm
[in]	ngc	Maximum number of Conjugate-Gradient iterations
[in]	nmg	Maximum number of mutligrid iterations
[in]	ngs	Number of Gauss-Siedel relaxation cycles
[in]	tolcg	Tolerance for the Conjugate-Gradient algorithm
[in]	tolnmg	Tolerance for the Multigrid algorithm

cs_multigrid_print()

GSTLEARN_EXPORT void cs_multigrid_print

(

cs_MGS *

mgs

)

Print the cs_MGS structure

Parameters

[in]

mgs

cs_MGS structure

cs_multigrid_process()

GSTLEARN_EXPORT int cs_multigrid_process	(	cs_MGS *	mgs,
		QChol *	qctt,
		int	verbose,
		double *	x0,
		double *	b,
		double *	work
	)

Perform the multigrid kriging

Returns

Error return code

Parameters

[in]	mgs	cs_MGS structure
[in]	qctt	QChol matrix of the upper level
[in]	verbose	Verbose flag
[in]	x0	Input vector
[in]	b	R.H.S. vector
[out]	work	Working array

cs_multigrid_setup()

GSTLEARN_EXPORT int cs_multigrid_setup	(	cs_MGS *	mgs,
		QChol *	qctt,
		int	flag_sel,
		int	verbose,
		double **	sel_arg
	)

Setup the Multigrid system

Returns

Error return code

Parameters

[in]	mgs	cs_MGS structure
[in]	qctt	QChol matrix of the upper level
[in]	flag_sel	If 1, an output selection is created
[in]	verbose	Verbose flag
[out]	sel_arg	Vector of selection (in double as used in db)

cs_multiply2()

GSTLEARN_EXPORT cs* cs_multiply2	(	const cs *	A,
		const cs *	B
	)

cs_multiply_and_release()

GSTLEARN_EXPORT cs* cs_multiply_and_release	(	cs *	b1,
		const cs *	b2,
		int	flag_rel
	)

cs_mulvec_lowtri()

GSTLEARN_EXPORT void cs_mulvec_lowtri	(	const cs *	A,
		int	nout,
		const double *	x,
		double *	y,
		int	flag_diag
	)

cs_mulvec_uptri()

GSTLEARN_EXPORT void cs_mulvec_uptri	(	const cs *	A,
		int	nout,
		const double *	x,
		double *	y,
		int	flag_diag
	)

cs_nfree2()

GSTLEARN_EXPORT csn* cs_nfree2

(

csn *

N

)

cs_nnz()

GSTLEARN_EXPORT int cs_nnz

(

const cs *

A

)

cs_normalize_by_diag_and_release()

GSTLEARN_EXPORT cs* cs_normalize_by_diag_and_release	(	cs *	Q,
		int	flag_rel
	)

cs_print2()

GSTLEARN_EXPORT int cs_print2	(	const cs *	A,
		int	brief
	)

cs_print_dim()

GSTLEARN_EXPORT void cs_print_dim	(	const char *	title,
		const cs *	A
	)

cs_print_file()

GSTLEARN_EXPORT void cs_print_file	(	const char *	radix,
		int	rank,
		const cs *	A
	)

cs_print_nice()

GSTLEARN_EXPORT void cs_print_nice	(	const char *	title,
		const cs *	A,
		int	maxrow = -1,
		int	maxcol = -1
	)

cs_print_only()

GSTLEARN_EXPORT void cs_print_only	(	const char *	title,
		const cs *	A,
		int	nlimit
	)

cs_print_range()

GSTLEARN_EXPORT void cs_print_range	(	const char *	title,
		const cs *	C
	)

cs_print_short()

GSTLEARN_EXPORT void cs_print_short	(	const char *	title,
		const cs *	L,
		int	nmax
	)

cs_prod_norm()

GSTLEARN_EXPORT cs* cs_prod_norm	(	int	mode,
		const cs *	A,
		const cs *	IhH
	)

cs_prod_norm_and_release()

GSTLEARN_EXPORT cs* cs_prod_norm_and_release	(	cs *	b1,
		cs *	lambda,
		int	flag_rel
	)

cs_prod_norm_diagonal()

GSTLEARN_EXPORT cs* cs_prod_norm_diagonal	(	int	mode,
		const cs *	B,
		VectorDouble	diag
	)

cs_prod_norm_single()

GSTLEARN_EXPORT cs* cs_prod_norm_single	(	int	mode,
		const cs *	B
	)

cs_rowcol()

GSTLEARN_EXPORT void cs_rowcol	(	const cs *	A,
		int *	nrows,
		int *	ncols,
		int *	count,
		double *	percent
	)

cs_scale()

GSTLEARN_EXPORT int cs_scale

(

const cs *

C

)

cs_set_cste()

GSTLEARN_EXPORT void cs_set_cste	(	const cs *	A,
		double	value
	)

cs_set_status_update_nonzero_value()

GSTLEARN_EXPORT void cs_set_status_update_nonzero_value

(

int

status

)

Define the status when modifying the value of a nonzero element of the sparse matrix

Parameters

status

0 (no test); 1 (warning issued); 2 (throw issued)

cs_set_value()

GSTLEARN_EXPORT void cs_set_value	(	const cs *	A,
		int	row,
		int	col,
		double	value
	)

cs_sfree2()

GSTLEARN_EXPORT css* cs_sfree2

(

css *

S

)

cs_sort_i()

GSTLEARN_EXPORT int cs_sort_i

(

cs *

C

)

cs_spalloc2()

GSTLEARN_EXPORT cs* cs_spalloc2	(	int	m,
		int	n,
		int	nzmax,
		int	values,
		int	triplet
	)

cs_spfree2()

GSTLEARN_EXPORT cs* cs_spfree2

(

cs *

A

)

TODO : cs_*2 functions to be removed (encapsulation)

cs_strip()

GSTLEARN_EXPORT cs* cs_strip	(	cs *	A,
		double	eps,
		int	hypothesis,
		bool	verbose
	)

Strip off elements of the input Sparse Matrix whose absolute value is smaller than eps. Return a new compressed sparse matrix. Consequently, strip off the vector P[in/out] which contains the order of the samples

Parameters

A	Input sparse matrix
eps	Tolerance on absolute value of the input sparse matrix elements
hypothesis	Stripping hypothesis
verbose	Verbose flag

Returns

A pointer to the new sparse matrix (it must be freed by calling function)

Note

Note that in the current version, the input matrix A is also modified

cs_toArray()

GSTLEARN_EXPORT double* cs_toArray

(

const cs *

A

)

cs_transpose2()

GSTLEARN_EXPORT cs* cs_transpose2	(	const cs *	A,
		int	values
	)

cs_triangle()

GSTLEARN_EXPORT cs* cs_triangle	(	cs *	A,
		int	flag_upper,
		int	flag_diag
	)

cs_triplet2()

GSTLEARN_EXPORT cs* cs_triplet2

(

const cs *

T

)

cs_vector_Mx()

GSTLEARN_EXPORT void cs_vector_Mx	(	const cs *	A,
		int	nout,
		const double *	x,
		double *	y
	)

cs_vector_tMx()

GSTLEARN_EXPORT void cs_vector_tMx	(	const cs *	A,
		int	nout,
		const double *	x,
		double *	y
	)

cs_vector_xM()

GSTLEARN_EXPORT void cs_vector_xM	(	const cs *	A,
		int	nout,
		const double *	x,
		double *	y
	)

cs_vector_xtM()

GSTLEARN_EXPORT void cs_vector_xtM	(	const cs *	A,
		int	nout,
		const double *	x,
		double *	y
	)

cs_vectors_to_sparse()

GSTLEARN_EXPORT MatrixSparse* cs_vectors_to_sparse	(	int	nrow,
		int	ncol,
		const VectorDouble &	rows,
		const VectorDouble &	cols,
		const VectorDouble &	values
	)

csd_extract_diag()

GSTLEARN_EXPORT double* csd_extract_diag	(	const cs *	C,
		int	oper_choice = 1
	)

csd_extract_diag_VD()

GSTLEARN_EXPORT VectorDouble csd_extract_diag_VD	(	const cs *	C,
		int	oper_choice = 1
	)

csToTriplet()

GSTLEARN_EXPORT NF_Triplet csToTriplet	(	const cs *	A,
		int	shiftRow = 0,
		int	shiftCol = 0,
		double	tol = EPSILON10
	)

qchol_cholesky()

GSTLEARN_EXPORT int qchol_cholesky	(	int	verbose,
		QChol *	QC
	)

Finalize the construction of the QChol structure. Perform the Cholesky decomposition

Returns

Error return code

Parameters

[in]	verbose	Verbose flag
[in]	QC	QChol structure to be finalized

Remarks

In case of problem the message is issued in this function

If the decomposition is already performed, nothing is done

toStringDim()

GSTLEARN_EXPORT String toStringDim	(	const String &	title,
		const cs *	A
	)

toStringRange()

GSTLEARN_EXPORT String toStringRange	(	const String &	title,
		const cs *	C
	)