1.3.2
CCC
 
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 MatrixSparsecs_arrays_to_sparse (int n, int nrow, int ncol, const double *rows, const double *cols, const double *vals)
 
GSTLEARN_EXPORT MatrixSparsecs_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_MGScs_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]qcttQchol structure
[in,out]xcrCurrent vector
[in]rhsCurrent R.H.S. vector
[out]workWorking array

◆ cs_chol_simulate()

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

Simulate using Cholesky

Parameters
[in]qcttQchol structure
[out]simuSimulated array
[out]workWorking 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
A1First sparse matrix
A2Secon sparse matrix
shiftRowShift A2 addresses by the number of rows of A1
shiftColShift 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]mgscs_MGS structure
[in,out]zInput vector
[out]workWorking 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]mgscs_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]mgscs_MGS structure
[in]mode1 for allocation; -1 for deallocation
[in]nlevelsNumber of levels of the multigrid (only for mode > 0)
[in]path_typeType 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]mgscs_MGS structure
[in]flag_cg1 for Conjugate-Gradient use; 0 otherwise
[in]type_coarseType of coarsening algorithm
[in]ngcMaximum number of Conjugate-Gradient iterations
[in]nmgMaximum number of mutligrid iterations
[in]ngsNumber of Gauss-Siedel relaxation cycles
[in]tolcgTolerance for the Conjugate-Gradient algorithm
[in]tolnmgTolerance for the Multigrid algorithm

◆ cs_multigrid_print()

GSTLEARN_EXPORT void cs_multigrid_print ( cs_MGS mgs)

Print the cs_MGS structure

Parameters
[in]mgscs_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]mgscs_MGS structure
[in]qcttQChol matrix of the upper level
[in]verboseVerbose flag
[in]x0Input vector
[in]bR.H.S. vector
[out]workWorking 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]mgscs_MGS structure
[in]qcttQChol matrix of the upper level
[in]flag_selIf 1, an output selection is created
[in]verboseVerbose flag
[out]sel_argVector 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
status0 (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
AInput sparse matrix
epsTolerance on absolute value of the input sparse matrix elements
hypothesisStripping hypothesis
verboseVerbose 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]verboseVerbose flag
[in]QCQChol 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 
)