LinkMatrixSparse.hpp File Reference

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

Classes
class	Triplet
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 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_tmulvec (const cs *A, int nout, const double *x, double *y)
GSTLEARN_EXPORT void	cs_mulvec (const cs *A, int nout, const double *x, double *y)
GSTLEARN_EXPORT void	cs_vecmult (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, double *x, int oper)
GSTLEARN_EXPORT cs *	cs_matvecL (const cs *A, 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 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 double *	cs_col_sumrow (const cs *A, int *ncol, int *nrow)
GSTLEARN_EXPORT double	cs_maxsumabscol (const cs *A)
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, 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 VectorInt	cs_color_coding (cs *Q, int start, int *ncolor)
GSTLEARN_EXPORT cs *	cs_extract_submatrix_by_color (cs *C, const VectorInt &colors, int ref_color, int row_ok, int col_ok)
GSTLEARN_EXPORT VectorDouble	csd_extract_diag_VD (cs *C, int mode)
GSTLEARN_EXPORT cs *	cs_prod_norm_diagonal (int mode, cs *B, VectorDouble diag)
GSTLEARN_EXPORT cs *	cs_arrays_to_sparse (int n, int nrow, int ncol, const double *rows, const double *cols, const double *vals)
GSTLEARN_EXPORT cs *	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 Triplet	csToTriplet (const cs *A, bool flag_from_1=false)
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_by_ranks (cs *C, int *row_array, int *col_array)
GSTLEARN_EXPORT void	cs_sparse_to_triplet (const cs *A, int flag_from_1, int *number, int **cols, int **rows, double **vals)
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 (cs *C, int mode)
GSTLEARN_EXPORT void	cs_diag_suppress (cs *C)
GSTLEARN_EXPORT double *	csd_extract_diag (cs *C, int mode)
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, cs *b2, int flag_rel)
GSTLEARN_EXPORT cs *	cs_add_and_release (cs *b1, 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, cs *A, cs *IhH)
GSTLEARN_EXPORT cs *	cs_prod_norm_single (int mode, cs *B)
GSTLEARN_EXPORT cs *	cs_prod_norm_and_release (cs *b1, cs *lambda, int flag_rel)
GSTLEARN_EXPORT int	cs_coarsening (cs *Q, int type, int **indCo, cs **L)
GSTLEARN_EXPORT cs *	cs_interpolate (cs *AA, cs *LL, int *indCo)
GSTLEARN_EXPORT cs *	cs_triangle (cs *A, int flag_upper, int flag_diag)
GSTLEARN_EXPORT void	cs_keypair (const char *key, cs *A, int flag_from_1)
GSTLEARN_EXPORT int	cs_scale (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 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 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)

Function Documentation

cs_add_and_release()

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

cs_add_cste()

GSTLEARN_EXPORT void cs_add_cste	(	cs *	A,
		double	value
	)

cs_arrays_to_sparse()

GSTLEARN_EXPORT cs* 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	(	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_color_coding()

GSTLEARN_EXPORT VectorInt cs_color_coding	(	cs *	Q,
		int	start,
		int *	ncols
	)

Creating the color coding for mesh nodes

Returns

Error return code

Parameters

[in]	Q	cs structure
[in]	start	Starting value for colors ranking (usually 0 or 1)
[out]	ncols	Number of colors

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_extract_diag()

GSTLEARN_EXPORT cs* cs_extract_diag	(	cs *	C,
		int	mode
	)

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	(	cs *	C,
		const VectorInt &	colors,
		int	ref_color,
		int	row_ok,
		int	col_ok
	)

cs_extract_submatrix_by_ranks()

GSTLEARN_EXPORT cs* cs_extract_submatrix_by_ranks	(	cs *	C,
		int *	row_array,
		int *	col_array
	)

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_value()

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

cs_interpolate()

GSTLEARN_EXPORT cs* cs_interpolate	(	cs *	AA,
		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_keypair()

GSTLEARN_EXPORT void cs_keypair	(	const char *	key,
		cs *	A,
		int	flag_from_1
	)

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,
		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,
		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,
		cs *	b2,
		int	flag_rel
	)

cs_mulvec()

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

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_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,
		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,
		cs *	A,
		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,
		cs *	B,
		VectorDouble	diag
	)

cs_prod_norm_single()

GSTLEARN_EXPORT cs* cs_prod_norm_single	(	int	mode,
		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

(

cs *

C

)

cs_set_value()

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

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_sparse_to_triplet()

GSTLEARN_EXPORT void cs_sparse_to_triplet	(	const cs *	A,
		int	flag_from_1,
		int *	number,
		int **	cols,
		int **	rows,
		double **	vals
	)

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_tmulvec()

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

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_vecmult()

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

cs_vectors_to_sparse()

GSTLEARN_EXPORT cs* 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	(	cs *	C,
		int	mode
	)

csd_extract_diag_VD()

GSTLEARN_EXPORT VectorDouble csd_extract_diag_VD	(	cs *	C,
		int	mode
	)

csToTriplet()

GSTLEARN_EXPORT Triplet csToTriplet	(	const cs *	A,
		bool	flag_from_1 = false
	)

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
	)