Description

Numcxx template library.

untility functions

Classes
class	Geometry
	Class collecting data for the description of piecewise linear geometries. More...

class	SimpleGrid
	Class containing data for simple grid data structure. More...

class	TArray
	TArray is the common template base class for arrays and dense matrices of the numcxx project. More...

class	TArray1
	One dimensional array class. More...

class	TArray2
	Two-dimensional array class. More...

class	TLinOperator
	Base class for linear operators (matrices, sparse matrices) More...

class	TLinSolver
	Base class for linear solvers and preconditioners. More...

class	TMatrix
	Dense matrix class. More...

class	TPreconILU
	ILU preconditioner class. More...

class	TPreconJacobi
	Jacobi preconditioner class. More...

class	TSolverLapackLU
	Lapack LU factorization class. More...

class	TSolverUMFPACK
	Bridge class for using umfpack as solver for vmatrix. More...

class	TSparseMatrix
	Sparse matrix class using CRS storage scheme. More...

Typedefs
using	index = unsigned int

using	DArray1 = TArray1< double >

using	DArray2 = TArray2< double >

using	DMatrix = TMatrix< double >

using	DSparseMatrix = TSparseMatrix< double >

using	DSolverLapackLU = TSolverLapackLU< double >

using	DSolverUMFPACK = TSolverUMFPACK< double >

using	DPreconJacobi = TPreconJacobi< double >

using	DPreconILU = TPreconILU< double >

using	IArray1 = TArray1< int >

using	IArray2 = TArray2< int >

Functions
template<typename A , typename B , typename = typename std::enable_if<std::is_base_of<ExpressionBase,A>::value, A>::type, typename = typename std::enable_if<std::is_base_of<ExpressionBase,B>::value, B>::type>
const AdditionExpression< A, B >	operator+ (const A &a, const B &b)

template<typename A , typename B , typename = typename std::enable_if<std::is_base_of<ExpressionBase,A>::value, A>::type, typename = typename std::enable_if<std::is_base_of<ExpressionBase,B>::value, B>::type>
const SubtractionExpression< A, B >	operator- (const A &a, const B &b)

template<typename A , typename B , typename = typename std::enable_if<std::is_fundamental<A>::value, A>::type, typename = typename std::enable_if<std::is_base_of<ExpressionBase,B>::value, B>::type>
const LeftScalarMultiplicationExpression< A, B >	operator* (const A &a, const B &b)

template<typename A , typename B , typename = typename std::enable_if<std::is_base_of<ExpressionBase,A>::value, A>::type, typename = typename std::enable_if<std::is_fundamental<B>::value, B>::type>
const RightScalarMultiplicationExpression< A, B >	operator* (const A &a, const B &b)

template<typename A , typename B , typename = typename std::enable_if<std::is_base_of<ExpressionBase,A>::value, A>::type, typename = typename std::enable_if<std::is_fundamental<B>::value, B>::type>
const RightScalarAdditionExpression< A, B >	operator+ (const A &a, const B &b)

template<typename A , typename B , typename = typename std::enable_if<std::is_fundamental<A>::value, A>::type, typename = typename std::enable_if<std::is_base_of<ExpressionBase,B>::value, B>::type>
const LeftScalarAdditionExpression< A, B >	operator+ (const A &a, const B &b)

template<typename A , typename B , typename = typename std::enable_if<std::is_base_of<ExpressionBase,A>::value, A>::type, typename = typename std::enable_if<std::is_fundamental<B>::value, B>::type>
const RightScalarSubtractionExpression< A, B >	operator- (const A &a, const B &b)

template<typename A , typename B , typename = typename std::enable_if<std::is_fundamental<A>::value, A>::type, typename = typename std::enable_if<std::is_base_of<ExpressionBase,B>::value, B>::type>
const LeftScalarSubtractionExpression< A, B >	operator- (const A &a, const B &b)

template<typename A , typename B , typename = typename std::enable_if<std::is_base_of<ExpressionBase,A>::value, A>::type, typename = typename std::enable_if<std::is_fundamental<B>::value, B>::type>
const RightScalarDivisionExpression< A, B >	operator/ (const A &a, const B &b)

template<typename A , typename B , typename = typename std::enable_if<std::is_base_of<MatrixExpressionBase,A>::value, A>::type, typename = typename std::enable_if<std::is_base_of<ExpressionBase,B>::value, B>::type>
const LeftMatrixMultiplicationExpression< A, B >	operator* (const A &a, const B &b)

template<typename A , typename B , typename = typename std::enable_if<std::is_base_of<SparseMatrixExpressionBase,A>::value, A>::type, typename = typename std::enable_if<std::is_base_of<ExpressionBase,B>::value, B>::type>
const LeftSparseMatrixMultiplicationExpression< A, B >	operator* (const A &a, const B &b)

template<typename T >
std::ostream &	operator<< (std::ostream &s, TArray< T > &A)

template<typename T , typename EXPR , typename = typename std::enable_if<std::is_class<EXPR>::value, EXPR>::type>
TArray< T > &	assign (TArray< T > &A, const EXPR &expr, const EXPR *x=0)

template<typename T , typename VAL , typename = typename std::enable_if<!std::is_class<VAL>::value, VAL>::type>
TArray< T > &	assign (TArray< T > &A, const VAL &a)

template<typename T , typename EXPR , typename = typename std::enable_if<std::is_class<EXPR>::value, EXPR>::type>
void	xadd (TArray< T > &A, const EXPR &expr, const EXPR *x=0)

template<typename T , typename VAL , typename = typename std::enable_if<!std::is_class<VAL>::value, VAL>::type>
void	xadd (TArray< T > &A, const VAL &a)

template<typename T , typename EXPR , typename = typename std::enable_if<std::is_class<EXPR>::value, EXPR>::type>
void	xsub (TArray< T > &A, const EXPR &expr, const EXPR *x=0)

template<typename T , typename VAL , typename = typename std::enable_if<!std::is_class<VAL>::value, VAL>::type>
void	xsub (TArray< T > &A, const VAL &a)

template<typename T , typename EXPR , typename = typename std::enable_if<std::is_class<EXPR>::value, EXPR>::type>
void	xmul (TArray< T > &A, const EXPR &expr, const EXPR *x=0)

template<typename T , typename VAL , typename = typename std::enable_if<!std::is_class<VAL>::value, VAL>::type>
void	xmul (TArray< T > &A, const VAL &a)

template<typename T , typename EXPR , typename = typename std::enable_if<std::is_class<EXPR>::value, EXPR>::type>
void	xdiv (TArray< T > &A, const EXPR &expr, const EXPR *x=0)

template<typename T , typename VAL , typename = typename std::enable_if<!std::is_class<VAL>::value, VAL>::type>
void	xdiv (TArray< T > &A, const VAL &a)

void	dgemm_ (char TRANSA, char TRANSB, int M, int N, int K, double ALPHA, const double A, int LDA, double B, int LDB, double BETA, double C, int *LDC)

void	sgemm_ (char TRANSA, char TRANSB, int M, int N, int K, float ALPHA, const float A, int LDA, float B, int LDB, float BETA, float C, int *LDC)

template<typename T >
std::ostream &	operator<< (std::ostream &s, TSolverLapackLU< T > &LU)

void	sgetrf_ (int n, int m, float a, int lda, int ipiv, int info)

void	sgetrs_ (char trans, int n, const int nrhs, float a, int lda, int ipiv, float b, int ldb, int *info)

void	sgetri_ (int n, float a, int lda, int ipiv, float work, int lwork, int *info)

void	dgetrf_ (int n, int m, double a, int lda, int ipiv, int info)

void	dgetrs_ (char trans, int n, const int nrhs, double a, int lda, int ipiv, double b, int ldb, int *info)

void	dgetri_ (int n, double a, int lda, int ipiv, double work, int lwork, int *info)

template<typename A >
TArray1< typename A::value_type >	arrayexpr (const A &a)
	Evaluate expression as array. More...

template<typename A >
A::value_type	normi (const A &a)
	Maximum norm of array or expression. More...

template<typename A >
A::value_type	norm1 (const A &a)
	Sum norm of array or expression. More...

template<typename A >
A::value_type	norm2 (const A &a)
	Euklidean norm of array or expression. More...

template<typename A >
A::value_type	norm (const A &a)
	Euklidean norm of array or expression. More...

template<typename A , typename B >
A::value_type	dot (const A &a, const B &b)
	Dot product of array or expression. More...

template<typename A >
A::value_type	min (const A &a)
	Minimum of of array or expression. More...

template<typename A >
A::value_type	max (const A &a)
	Maximum of array or expression. More...

template<typename A >
A::value_type	sum (const A &a)
	Sum of array or expression. More...

template<typename T >
std::shared_ptr< TArray1< T > >	linspace (T x0, T x1, int n)
	Create array of $n$ equally spaced entries. More...

double	cpu_clock ()
	cpu time in seconds More...

double	wall_clock ()
	wall clock time in seconds More...

template<typename T >
void	savetxt (const std::string fname, const TArray< T > &a)

template<typename T >
void	savetxt (const std::ostream s, const TArray< T > &a)

double	norm1 (const std::shared_ptr< DArray1 > a)

double	norm2 (const std::shared_ptr< DArray1 > a)

double	normi (const std::shared_ptr< DArray1 > a)

template<typename T >
void	savetxt (std::ostream &s, const TArray< T > &a)

void	print_triangulateio (triangle::triangulateio *in)

double	dist (const numcxx::DArray2 &points, int p1, int p2)

Typedef Documentation

using numcxx::index = typedef unsigned int

Definition at line 21 of file numcxx.hxx.

typedef TArray1< double > numcxx::DArray1

Examples:: 45-convdiff1d.cxx.

Definition at line 38 of file numcxx.hxx.

typedef TArray2< double > numcxx::DArray2

Definition at line 39 of file numcxx.hxx.

using numcxx::DMatrix = typedef TMatrix<double>

Definition at line 40 of file numcxx.hxx.

using numcxx::DSparseMatrix = typedef TSparseMatrix<double>

Definition at line 41 of file numcxx.hxx.

using numcxx::DSolverLapackLU = typedef TSolverLapackLU<double>

Definition at line 42 of file numcxx.hxx.

using numcxx::DSolverUMFPACK = typedef TSolverUMFPACK<double>

Definition at line 43 of file numcxx.hxx.

using numcxx::DPreconJacobi = typedef TPreconJacobi<double>

Definition at line 44 of file numcxx.hxx.

using numcxx::DPreconILU = typedef TPreconILU<double>

Definition at line 45 of file numcxx.hxx.

using numcxx::IArray1 = typedef TArray1<int>

Definition at line 46 of file numcxx.hxx.

using numcxx::IArray2 = typedef TArray2<int>

Definition at line 47 of file numcxx.hxx.

Function Documentation

template<typename A , typename B , typename = typename std::enable_if<std::is_base_of<ExpressionBase,A>::value, A>::type, typename = typename std::enable_if<std::is_base_of<ExpressionBase,B>::value, B>::type>

const AdditionExpression<A,B> numcxx::operator+	(	const A &	a,
		const B &	b
	)

Definition at line 80 of file expression.ixx.

   {
     return AdditionExpression<A,B>(a, b);
   }

Here is the call graph for this function:

template<typename A , typename B , typename = typename std::enable_if<std::is_base_of<ExpressionBase,A>::value, A>::type, typename = typename std::enable_if<std::is_base_of<ExpressionBase,B>::value, B>::type>

const SubtractionExpression<A,B> numcxx::operator-	(	const A &	a,
		const B &	b
	)

Definition at line 105 of file expression.ixx.

   {
     return SubtractionExpression<A,B>(a, b);
   }

Here is the call graph for this function:

template<typename A , typename B , typename = typename std::enable_if<std::is_fundamental<A>::value, A>::type, typename = typename std::enable_if<std::is_base_of<ExpressionBase,B>::value, B>::type>

const LeftScalarMultiplicationExpression<A,B> numcxx::operator*	(	const A &	a,
		const B &	b
	)

Definition at line 129 of file expression.ixx.

   {
     return LeftScalarMultiplicationExpression<A,B>(a, b);
   }

Here is the call graph for this function:

template<typename A , typename B , typename = typename std::enable_if<std::is_base_of<ExpressionBase,A>::value, A>::type, typename = typename std::enable_if<std::is_fundamental<B>::value, B>::type>

const RightScalarMultiplicationExpression<A,B> numcxx::operator*	(	const A &	a,
		const B &	b
	)

Definition at line 154 of file expression.ixx.

   {
     return RightScalarMultiplicationExpression<A,B>(a, b);
   }

Here is the call graph for this function:

template<typename A , typename B , typename = typename std::enable_if<std::is_base_of<ExpressionBase,A>::value, A>::type, typename = typename std::enable_if<std::is_fundamental<B>::value, B>::type>

const RightScalarAdditionExpression<A,B> numcxx::operator+	(	const A &	a,
		const B &	b
	)

Definition at line 180 of file expression.ixx.

   {
     return RightScalarAdditionExpression<A,B>(a, b);
   }

Here is the call graph for this function:

template<typename A , typename B , typename = typename std::enable_if<std::is_fundamental<A>::value, A>::type, typename = typename std::enable_if<std::is_base_of<ExpressionBase,B>::value, B>::type>

const LeftScalarAdditionExpression<A,B> numcxx::operator+	(	const A &	a,
		const B &	b
	)

Definition at line 204 of file expression.ixx.

   {
     return LeftScalarAdditionExpression<A,B>(a, b);
   }

Here is the call graph for this function:

template<typename A , typename B , typename = typename std::enable_if<std::is_base_of<ExpressionBase,A>::value, A>::type, typename = typename std::enable_if<std::is_fundamental<B>::value, B>::type>

const RightScalarSubtractionExpression<A,B> numcxx::operator-	(	const A &	a,
		const B &	b
	)

Definition at line 228 of file expression.ixx.

   {
     return RightScalarSubtractionExpression<A,B>(a, b);
   }

Here is the call graph for this function:

template<typename A , typename B , typename = typename std::enable_if<std::is_fundamental<A>::value, A>::type, typename = typename std::enable_if<std::is_base_of<ExpressionBase,B>::value, B>::type>

const LeftScalarSubtractionExpression<A,B> numcxx::operator-	(	const A &	a,
		const B &	b
	)

Definition at line 252 of file expression.ixx.

   {
     return LeftScalarSubtractionExpression<A,B>(a, b);
   }

Here is the call graph for this function:

template<typename A , typename B , typename = typename std::enable_if<std::is_base_of<ExpressionBase,A>::value, A>::type, typename = typename std::enable_if<std::is_fundamental<B>::value, B>::type>

const RightScalarDivisionExpression<A,B> numcxx::operator/	(	const A &	a,
		const B &	b
	)

Definition at line 276 of file expression.ixx.

   {
     return RightScalarDivisionExpression<A,B>(a, b);
   }

Here is the call graph for this function:

template<typename A , typename B , typename = typename std::enable_if<std::is_base_of<MatrixExpressionBase,A>::value, A>::type, typename = typename std::enable_if<std::is_base_of<ExpressionBase,B>::value, B>::type>

const LeftMatrixMultiplicationExpression<A,B> numcxx::operator*	(	const A &	a,
		const B &	b
	)

Definition at line 306 of file expression.ixx.

   {
     return LeftMatrixMultiplicationExpression<A,B>(a, b);
   }

Here is the call graph for this function:

template<typename A , typename B , typename = typename std::enable_if<std::is_base_of<SparseMatrixExpressionBase,A>::value, A>::type, typename = typename std::enable_if<std::is_base_of<ExpressionBase,B>::value, B>::type>

const LeftSparseMatrixMultiplicationExpression<A,B> numcxx::operator*	(	const A &	a,
		const B &	b
	)

Definition at line 340 of file expression.ixx.

   {
     return LeftSparseMatrixMultiplicationExpression<A,B>(a, b);
   }

template<typename T >

std::ostream & numcxx::operator<<	(	std::ostream &	s,
		TArray< T > &	A
	)

inline

Definition at line 328 of file tarray.ixx.

   {
     if (A.ndim()==1)
       for (index i=0;i<A.size();i++) s <<"[" << i << "]: " <<A(i) << std::endl << std::flush;
     else
     {
       s << "    ";
       for (index j=0;j<A.shape(1);j++) 
         s << "[" << j << "]     ";
       s<< "\n";
       for (index i=0;i<A.shape(0);i++) 
       {
         s << "[" << i << "]: ";
         for (index j=0;j<A.shape(1);j++) 
           s << A(i,j) << "   ";
         s<< "\n";
       }
     }
     return s;
   }

template<typename T , typename EXPR , typename = typename std::enable_if<std::is_class<EXPR>::value, EXPR>::type>

TArray<T>& numcxx::assign	(	TArray< T > &	A,
		const EXPR &	expr,
		const EXPR *	x = `0`
	)

inline

Definition at line 35 of file tarray.ixx.

   {
     A.resize( expr.size() );
     T *data=A.data();
     for(index i=0; i<expr.size(); i++ ) data[i] = expr[i];
     return A;
   }

Here is the call graph for this function:

template<typename T , typename VAL , typename = typename std::enable_if<!std::is_class<VAL>::value, VAL>::type>

TArray<T>& numcxx::assign	(	TArray< T > &	A,
		const VAL &	a
	)

inline

Definition at line 45 of file tarray.ixx.

   {
     T *data=A.data();
     for(index i=0; i<A.size(); i++ ) data[i] = a;
     return A;
   }

Here is the call graph for this function:

template<typename T , typename EXPR , typename = typename std::enable_if<std::is_class<EXPR>::value, EXPR>::type>

void numcxx::xadd	(	TArray< T > &	A,
		const EXPR &	expr,
		const EXPR *	x = `0`
	)

inline

Definition at line 54 of file tarray.ixx.

   {
     A.resize( expr.size() );
     T *data=A.data();
     for(index i=0; i<expr.size(); i++ ) data[i] += expr[i];
   }

Here is the call graph for this function:

template<typename T , typename VAL , typename = typename std::enable_if<!std::is_class<VAL>::value, VAL>::type>

void numcxx::xadd	(	TArray< T > &	A,
		const VAL &	a
	)

inline

Definition at line 64 of file tarray.ixx.

   {
     T *data=A.data();
     for(index i=0; i<A.size(); i++ )data[i] += a;
   }

Here is the call graph for this function:

template<typename T , typename EXPR , typename = typename std::enable_if<std::is_class<EXPR>::value, EXPR>::type>

void numcxx::xsub	(	TArray< T > &	A,
		const EXPR &	expr,
		const EXPR *	x = `0`
	)

inline

Definition at line 73 of file tarray.ixx.

   {
     A.resize( expr.size() );
     T *data=A.data();
     for(index i=0; i<expr.size(); i++ ) data[i] -= expr[i];
   }

Here is the call graph for this function:

template<typename T , typename VAL , typename = typename std::enable_if<!std::is_class<VAL>::value, VAL>::type>

void numcxx::xsub	(	TArray< T > &	A,
		const VAL &	a
	)

inline

Definition at line 83 of file tarray.ixx.

   {
     T *data=A.data();
     for(index i=0; i<A.size(); i++ )data[i] -= a;
   }

Here is the call graph for this function:

template<typename T , typename EXPR , typename = typename std::enable_if<std::is_class<EXPR>::value, EXPR>::type>

void numcxx::xmul	(	TArray< T > &	A,
		const EXPR &	expr,
		const EXPR *	x = `0`
	)

inline

Definition at line 92 of file tarray.ixx.

   {
     A.resize( expr.size() );
     T *data=A.data();
     for(index i=0; i<expr.size(); i++ ) data[i] *= expr[i];
   }

Here is the call graph for this function:

template<typename T , typename VAL , typename = typename std::enable_if<!std::is_class<VAL>::value, VAL>::type>

void numcxx::xmul	(	TArray< T > &	A,
		const VAL &	a
	)

inline

Definition at line 102 of file tarray.ixx.

   {
     T *data=A.data();
     for(index i=0; i<A.size(); i++ )data[i] *= a;
   }

Here is the call graph for this function:

template<typename T , typename EXPR , typename = typename std::enable_if<std::is_class<EXPR>::value, EXPR>::type>

void numcxx::xdiv	(	TArray< T > &	A,
		const EXPR &	expr,
		const EXPR *	x = `0`
	)

inline

Definition at line 111 of file tarray.ixx.

   {
     A.resize( expr.size() );
     T *data=A.data();
     for(index i=0; i<expr.size(); i++ ) data[i] /= expr[i];
   }

Here is the call graph for this function:

template<typename T , typename VAL , typename = typename std::enable_if<!std::is_class<VAL>::value, VAL>::type>

void numcxx::xdiv	(	TArray< T > &	A,
		const VAL &	a
	)

inline

Definition at line 121 of file tarray.ixx.

   {
     T *data=A.data();
     for(index i=0; i<A.size(); i++ )data[i] /= a;
   }

Here is the call graph for this function:

void numcxx::dgemm_	(	char *	TRANSA,
		char *	TRANSB,
		int *	M,
		int *	N,
		int *	K,
		double *	ALPHA,
		const double *	A,
		int *	LDA,
		double *	B,
		int *	LDB,
		double *	BETA,
		double *	C,
		int *	LDC
	)

void numcxx::sgemm_	(	char *	TRANSA,
		char *	TRANSB,
		int *	M,
		int *	N,
		int *	K,
		float *	ALPHA,
		const float *	A,
		int *	LDA,
		float *	B,
		int *	LDB,
		float *	BETA,
		float *	C,
		int *	LDC
	)

template<typename T >

std::ostream& numcxx::operator<<	(	std::ostream &	s,
		TSolverLapackLU< T > &	LU
	)

inline

Definition at line 69 of file tsolver-lapacklu.hxx.

   {
     s << "LU:" << std::endl;
     s << LU.LU() << std::endl;
     s << "IPiv:" << std::endl;
     s << LU.IPiv() << std::endl;
   }

Here is the call graph for this function:

void numcxx::sgetrf_	(	int *	n,
		int *	m,
		float *	a,
		int *	lda,
		int *	ipiv,
		int *	info
	)

void numcxx::sgetrs_	(	char *	trans,
		int *	n,
		const int *	nrhs,
		float *	a,
		int *	lda,
		int *	ipiv,
		float *	b,
		int *	ldb,
		int *	info
	)

void numcxx::sgetri_	(	int *	n,
		float *	a,
		int *	lda,
		int *	ipiv,
		float *	work,
		int *	lwork,
		int *	info
	)

void numcxx::dgetrf_	(	int *	n,
		int *	m,
		double *	a,
		int *	lda,
		int *	ipiv,
		int *	info
	)

void numcxx::dgetrs_	(	char *	trans,
		int *	n,
		const int *	nrhs,
		double *	a,
		int *	lda,
		int *	ipiv,
		double *	b,
		int *	ldb,
		int *	info
	)

void numcxx::dgetri_	(	int *	n,
		double *	a,
		int *	lda,
		int *	ipiv,
		double *	work,
		int *	lwork,
		int *	info
	)

template<typename A >

TArray1< typename A::value_type > numcxx::arrayexpr ( const A & a )

inline

Evaluate expression as array.

This shall help with the issue with type inference for expression templates For two vectors A,B of type TArray<double>,

auto C=A+B

results in C being an instannce of AdditionExpression<TArray<double>,TArray<double>> which will not behave like an array. Operators like << are not defined, and, more dangerously, subsequent operations using C may create wrong results, similar to the situation described in https://eigen.tuxfamily.org/dox/TopicPitfalls.html.

The best solution is to avoid auto altogther in code with expression templates. Just write

TArray<double> C=A+B

arrayexpr provides an (more or less experimental) alternative by using move semantics for constructing and returning an array. So another safe way would be to write

auto C=arrayexpr(A+B)

resulting in C being detected as of type TArray<double>

Returns: Array of corresponding result type of expression

Examples:: 10-numcxx-expressions.cxx.

Definition at line 19 of file util.ixx.

   {
     TArray1<typename A::value_type> v=a;
     return std::move(v);
   }

template<typename A >

A::value_type numcxx::normi ( const A & a )

inline

Maximum norm of array or expression.

Returns: Maximum ( $l^\infty$) norm.

Examples:: 13-numcxx-lapack.cxx, 14-numcxx-lapack-sharedptr.cxx, 15-numcxx-umfpack.cxx, and 16-numcxx-umfpack-sharedptr.cxx.

Definition at line 26 of file util.ixx.

   {
     typename A::value_type norm=std::abs(a[0]);
     for(index i=1; i<a.size(); i++ )
     {
       typename A::value_type x=std::abs(a[i]);
       if (x>norm) norm=x;
     }
     return norm;
   }

Here is the call graph for this function:

template<typename A >

A::value_type numcxx::norm1 ( const A & a )

inline

Sum norm of array or expression.

Returns: Sum ( $l^1$) norm.

Definition at line 37 of file util.ixx.

   {
     typename A::value_type norm=std::abs(a[0]);
     for(index i=1; i<a.size(); i++ )
     {
       norm+=std::abs(a[i]);
     }
     return norm;
   }

Here is the call graph for this function:

template<typename A >

A::value_type numcxx::norm2 ( const A & a )

inline

Euklidean norm of array or expression.

Returns: Euklidean ( $l^2$) norm

Examples:: 46-nonlin-fvm.cxx.

Definition at line 47 of file util.ixx.

   {
     typename A::value_type norm=0.0;
     for(index i=0; i<a.size(); i++ )
     {
       typename A::value_type x=a[i];
       norm+=x*x;
     }
     return sqrt(norm);
   }

Here is the call graph for this function:

template<typename A >

A::value_type numcxx::norm ( const A & a )

inline

Euklidean norm of array or expression.

Returns: Euklidean ( $l^2$) norm

Examples:: 46-nonlin-fvm.cxx.

Definition at line 54 of file util.hxx.

54 { return norm2(a);}

numcxx::norm2

double norm2(const std::shared_ptr< DArray1 > a)

Definition: util.hxx:103

Here is the call graph for this function:

template<typename A , typename B >

A::value_type numcxx::dot	(	const A &	a,
		const B &	b
	)

inline

Dot product of array or expression.

Parameters

A	First argument.
B	Second argument.

Returns: Dot product

Definition at line 91 of file util.ixx.

   {
     typename A::value_type dot=0.0;
     for(index i=0; i<a.size(); i++ )
     {
       dot+=a[i]*b[i];
     }
     return dot;
   }    

template<typename A >

A::value_type numcxx::min ( const A & a )

inline

Minimum of of array or expression.

Returns: Minimum of all elements in array.

Examples:: 46-nonlin-fvm.cxx.

Definition at line 59 of file util.ixx.

   {
     typename A::value_type m=a[0];
     for(index i=1; i<a.size(); i++ )
     {
       typename A::value_type x=a[i];
       if (x<m) m=x;
     }
     return m;
   }

template<typename A >

A::value_type numcxx::max ( const A & a )

inline

Maximum of array or expression.

Returns: Maximum of all elements in array.

Definition at line 70 of file util.ixx.

   {
     typename A::value_type m=a[0];
     for(index i=1; i<a.size(); i++ )
     {
       typename A::value_type x=a[i];
       if (x>m) m=x;
     }
     return m;
   }

template<typename A >

A::value_type numcxx::sum ( const A & a )

inline

Sum of array or expression.

Returns: Sum of all elements in array.

Examples:: 01-c-style-stack.cxx, 02-c-style-heap.cxx, 03-cxx-style-ref.cxx, 04-cxx-style-sharedptr.cxx, 05-cxx-style-sharedptr2.cxx, 11-numcxx-ref.cxx, and 12-numcxx-sharedptr.cxx.

Definition at line 81 of file util.ixx.

   {
     typename A::value_type s=a[0];
     for(index i=1; i<a.size(); i++ )
     {
       s+=a[i];
     }
     return s;
   }

template<typename T >

std::shared_ptr< TArray1< T > > numcxx::linspace	(	T	x0,
		T	x1,
		int	n
	)

inline

Create array of $n$ equally spaced entries.

Examples:: 45-convdiff1d.cxx.

Definition at line 9 of file util.ixx.

   { 
     auto pX=std::make_shared<TArray1<T>>(n);
     auto &X=*pX;
     T h=1.0/(T)(n-1);
     T x=0.0;
     for (int i=0;i<n;i++,x+=h) X[i]=x;
     return pX;
   }

double numcxx::cpu_clock ( )

inline

cpu time in seconds

Examples:: 42-convtest-fem-sin.cxx, and 43-convtest-fvm-sin.cxx.

Definition at line 101 of file util.ixx.

   {
     return (double)std::clock()/(double)CLOCKS_PER_SEC;
   }

double numcxx::wall_clock ( )

inline

wall clock time in seconds

Definition at line 106 of file util.ixx.

   { 
     time_t t;
     t=time(&t);
     return ((double)t);
   }

template<typename T >

void numcxx::savetxt	(	const std::string	fname,
		const TArray< T > &	a
	)

inline

Definition at line 114 of file util.ixx.

   {
     std::filebuf fb;
     fb.open (fname,std::ios::out);
     std::ostream s(&fb);
     a.savetxt(s);
     fb.close();
   }

Here is the call graph for this function:

template<typename T >

void numcxx::savetxt	(	const std::ostream	s,
		const TArray< T > &	a
	)

inline

double numcxx::norm1 ( const std::shared_ptr< DArray1 > a )

inline

Definition at line 102 of file util.hxx.

102 {return norm1(*a);}

numcxx::norm1

double norm1(const std::shared_ptr< DArray1 > a)

Definition: util.hxx:102

Here is the call graph for this function:

double numcxx::norm2 ( const std::shared_ptr< DArray1 > a )

inline

Definition at line 103 of file util.hxx.

103 {return norm2(*a);}

numcxx::norm2

double norm2(const std::shared_ptr< DArray1 > a)

Definition: util.hxx:103

Here is the call graph for this function:

double numcxx::normi ( const std::shared_ptr< DArray1 > a )

inline

Definition at line 104 of file util.hxx.

104 {return normi(*a);}

numcxx::normi

double normi(const std::shared_ptr< DArray1 > a)

Definition: util.hxx:104

Here is the call graph for this function:

template<typename T >

void numcxx::savetxt	(	std::ostream &	s,
		const TArray< T > &	a
	)

inline

Definition at line 124 of file util.ixx.

   {
     a.savetxt(s);
   }

Here is the call graph for this function:

void numcxx::print_triangulateio ( triangle::triangulateio * in )

inline

Definition at line 21 of file simplegrid.cxx.

   {
     std::printf("pointlist=%p\n",in->pointlist);
     std::printf("pointattributelist=%p\n",in->pointattributelist);
     std::printf("pointmarkerlist=%p\n",in->pointmarkerlist);
     std::printf("numberofpoints=%d\n",in->numberofpoints);
     std::printf("numberofpointattributes=%d\n",in->numberofpointattributes);
     std::printf("trianglelist=%p\n",in->trianglelist);
     std::printf("triangleattributelist=%p\n",in->triangleattributelist);
     std::printf("trianglearealist=%p\n",in->trianglearealist);
     std::printf("neighborlist=%p\n",in->neighborlist);
     std::printf("numberoftriangles=%d\n",in->numberoftriangles);
     std::printf("numberofcorners=%d\n",in->numberofcorners);
     std::printf("numberoftriangleattributes=%d\n",in->numberoftriangleattributes);
     std::printf("segmentlist=%p\n",in->segmentlist);
     std::printf("segmentmarkerlist=%p\n",in->segmentmarkerlist);
     std::printf("numberofsegments=%d\n",in->numberofsegments);
     std::printf("holelist=%p\n",in->holelist);
     std::printf("numberofholes=%d\n",in->numberofholes);
     std::printf("regionlist=%p\n",in->regionlist);
     std::printf("numberofregions=%d\n",in->numberofregions);
     std::printf("edgelist=%p\n",in->edgelist);
     std::printf("edgemarkerlist=%p\n",in->edgemarkerlist);
     std::printf("normlist=%p\n",in->normlist);
     std::printf("numberofedges=%d\n",in->numberofedges);
   }

double numcxx::dist	(	const numcxx::DArray2 &	points,
		int	p1,
		int	p2
	)

inline

Definition at line 48 of file simplegrid.cxx.

   {
     double dx=points(p2,0)-points(p1,0);
     double dy=points(p2,1)-points(p1,1);
     return sqrt(dx*dx+dy*dy);
   }

Description

Classes

Typedefs

Functions

Typedef Documentation

Function Documentation