NGSolve  5.3
Classes | Typedefs | Functions | Variables
ngstd Namespace Reference

namespace for standard data types and algorithms. More...

Classes

class  AutoDiffDiff
 Datatype for automatic differentiation. More...
 
class  AutoDiffRec
 
class  AutoDiffRec< 0, SCAL >
 
class  AutoDiffRec< 1, SCAL >
 
class  AutoDiffVec
 Datatype for automatic differentiation. More...
 
class  AutoPtr
 Pointer to object. More...
 
class  BaseStatusHandler
 Access to statusbar. More...
 
class  BlockAllocator
 Optimized memory handler. More...
 
class  Cl_Switch
 
class  Cl_Switch< 0 >
 
class  Cl_Switch<-1 >
 
class  EvalFunction
 Numerical expression parser. More...
 
class  GenericVariable
 
class  MemoryUsage
 Reports amount of used memory. More...
 
class  ParallelFunction
 
class  ParallelValue
 

Typedefs

template<int D, typename SCAL = double>
using AutoDiff = AutoDiffRec< D, SCAL >
 

Functions

template<int D, typename SCAL >
ostream & operator<< (ostream &ost, const AutoDiffDiff< D, SCAL > &x)
 Prints AudoDiffDiff.
 
template<int D, typename SCAL >
AutoDiffDiff< D, SCAL > operator+ (const AutoDiffDiff< D, SCAL > &x, const AutoDiffDiff< D, SCAL > &y) throw ()
 
template<int D, typename SCAL >
AutoDiffDiff< D, SCAL > operator- (const AutoDiffDiff< D, SCAL > &x, const AutoDiffDiff< D, SCAL > &y) throw ()
 
template<int D, typename SCAL , typename SCAL2 , typename std::enable_if< std::is_convertible< SCAL2, SCAL >::value, int >::type = 0>
AutoDiffDiff< D, SCAL > operator+ (SCAL2 x, const AutoDiffDiff< D, SCAL > &y) throw ()
 
template<int D, typename SCAL , typename SCAL2 , typename std::enable_if< std::is_convertible< SCAL2, SCAL >::value, int >::type = 0>
AutoDiffDiff< D, SCAL > operator+ (const AutoDiffDiff< D, SCAL > &y, SCAL2 x) throw ()
 
template<int D, typename SCAL >
AutoDiffDiff< D, SCAL > operator- (const AutoDiffDiff< D, SCAL > &x) throw ()
 
template<int D, typename SCAL , typename SCAL2 , typename std::enable_if< std::is_convertible< SCAL2, SCAL >::value, int >::type = 0>
AutoDiffDiff< D, SCAL > operator- (const AutoDiffDiff< D, SCAL > &x, SCAL2 y) throw ()
 
template<int D, typename SCAL , typename SCAL2 , typename std::enable_if< std::is_convertible< SCAL2, SCAL >::value, int >::type = 0>
AutoDiffDiff< D, SCAL > operator- (SCAL2 x, const AutoDiffDiff< D, SCAL > &y) throw ()
 
template<int D, typename SCAL , typename SCAL2 , typename std::enable_if< std::is_convertible< SCAL2, SCAL >::value, int >::type = 0>
AutoDiffDiff< D, SCAL > operator* (SCAL2 x, const AutoDiffDiff< D, SCAL > &y) throw ()
 
template<int D, typename SCAL , typename SCAL2 , typename std::enable_if< std::is_convertible< SCAL2, SCAL >::value, int >::type = 0>
AutoDiffDiff< D, SCAL > operator* (const AutoDiffDiff< D, SCAL > &y, SCAL2 x) throw ()
 
template<int D, typename SCAL >
AutoDiffDiff< D, SCAL > operator* (const AutoDiffDiff< D, SCAL > &x, const AutoDiffDiff< D, SCAL > &y) throw ()
 
template<int D, typename SCAL >
AutoDiffDiff< D, SCAL > Inv (const AutoDiffDiff< D, SCAL > &x)
 
template<int D, typename SCAL >
AutoDiffDiff< D, SCAL > operator/ (const AutoDiffDiff< D, SCAL > &x, const AutoDiffDiff< D, SCAL > &y)
 
template<int D, typename SCAL , typename SCAL2 , typename std::enable_if< std::is_convertible< SCAL2, SCAL >::value, int >::type = 0>
AutoDiffDiff< D, SCAL > operator/ (const AutoDiffDiff< D, SCAL > &x, SCAL2 y)
 
template<int D, typename SCAL , typename SCAL2 , typename std::enable_if< std::is_convertible< SCAL2, SCAL >::value, int >::type = 0>
AutoDiffDiff< D, SCAL > operator/ (SCAL2 x, const AutoDiffDiff< D, SCAL > &y)
 
template<int D, typename SCAL >
AutoDiffDiff< D, SCAL > sqrt (const AutoDiffDiff< D, SCAL > &x)
 
template<int D, typename SCAL >
INLINE AutoDiffDiff< D, SCAL > exp (AutoDiffDiff< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffDiff< D, SCAL > pow (AutoDiffDiff< D, SCAL > x, AutoDiffDiff< D, SCAL > y)
 
template<int D, typename SCAL >
INLINE AutoDiffDiff< D, SCAL > log (AutoDiffDiff< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffDiff< D, SCAL > sin (AutoDiffDiff< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffDiff< D, SCAL > cos (AutoDiffDiff< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffDiff< D, SCAL > tan (AutoDiffDiff< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffDiff< D, SCAL > atan (AutoDiffDiff< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffDiff< D, SCAL > atan2 (AutoDiffDiff< D, SCAL > x, AutoDiffDiff< D, SCAL > y)
 
template<int D, typename SCAL >
INLINE AutoDiffDiff< D, SCAL > acos (AutoDiffDiff< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffDiff< D, SCAL > asin (AutoDiffDiff< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffDiff< D, SCAL > sinh (AutoDiffDiff< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffDiff< D, SCAL > cosh (AutoDiffDiff< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffDiff< D, SCAL > floor (const AutoDiffDiff< D, SCAL > &x)
 
template<int D, typename SCAL >
INLINE AutoDiffDiff< D, SCAL > ceil (const AutoDiffDiff< D, SCAL > &x)
 
template<int D, typename SCAL , typename TB , typename TC >
auto IfPos (AutoDiffDiff< D, SCAL > a, TB b, TC c) -> decltype(IfPos(a.Value(), b, c))
 
template<int D, typename SCAL >
INLINE AutoDiffDiff< D, SCAL > IfPos (SCAL a, AutoDiffDiff< D, SCAL > b, AutoDiffDiff< D, SCAL > c)
 
template<int D, typename SCAL , typename TC >
INLINE AutoDiffDiff< D, SCAL > IfPos (SCAL a, AutoDiffDiff< D, SCAL > b, TC c)
 
template<int D, typename SCAL >
ostream & operator<< (ostream &ost, const AutoDiffVec< D, SCAL > &x)
 prints AutoDiffVec
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCAL > operator+ (const AutoDiffVec< D, SCAL > &x, const AutoDiffVec< D, SCAL > &y) throw ()
 AutoDiffVec plus AutoDiffVec.
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCAL > operator- (const AutoDiffVec< D, SCAL > &x, const AutoDiffVec< D, SCAL > &y) throw ()
 AutoDiffVec minus AutoDiffVec.
 
template<int D, typename SCAL , typename SCAL2 , typename std::enable_if< std::is_convertible< SCAL2, SCAL >::value, int >::type = 0>
INLINE AutoDiffVec< D, SCAL > operator+ (SCAL2 x, const AutoDiffVec< D, SCAL > &y) throw ()
 double plus AutoDiffVec
 
template<int D, typename SCAL , typename SCAL2 , typename std::enable_if< std::is_convertible< SCAL2, SCAL >::value, int >::type = 0>
INLINE AutoDiffVec< D, SCAL > operator+ (const AutoDiffVec< D, SCAL > &y, SCAL2 x) throw ()
 AutoDiffVec plus double.
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCAL > operator- (const AutoDiffVec< D, SCAL > &x) throw ()
 minus AutoDiffVec
 
template<int D, typename SCAL , typename SCAL2 , typename std::enable_if< std::is_convertible< SCAL2, SCAL >::value, int >::type = 0>
INLINE AutoDiffVec< D, SCAL > operator- (const AutoDiffVec< D, SCAL > &x, SCAL2 y) throw ()
 AutoDiffVec minus double.
 
template<int D, typename SCAL , typename SCAL2 , typename std::enable_if< std::is_convertible< SCAL2, SCAL >::value, int >::type = 0>
INLINE AutoDiffVec< D, SCAL > operator- (SCAL2 x, const AutoDiffVec< D, SCAL > &y) throw ()
 
template<int D, typename SCAL , typename SCAL2 , typename std::enable_if< std::is_convertible< SCAL2, SCAL >::value, int >::type = 0>
INLINE AutoDiffVec< D, SCAL > operator* (SCAL2 x, const AutoDiffVec< D, SCAL > &y) throw ()
 double times AutoDiffVec
 
template<int D, typename SCAL , typename SCAL2 , typename std::enable_if< std::is_convertible< SCAL2, SCAL >::value, int >::type = 0>
INLINE AutoDiffVec< D, SCAL > operator* (const AutoDiffVec< D, SCAL > &y, SCAL2 x) throw ()
 AutoDiffVec times double.
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCAL > operator* (const AutoDiffVec< D, SCAL > &x, const AutoDiffVec< D, SCAL > &y) throw ()
 AutoDiffVec times AutoDiffVec.
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCAL > sqr (const AutoDiffVec< D, SCAL > &x) throw ()
 AutoDiffVec times AutoDiffVec.
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCAL > Inv (const AutoDiffVec< D, SCAL > &x)
 Inverse of AutoDiffVec.
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCAL > operator/ (const AutoDiffVec< D, SCAL > &x, const AutoDiffVec< D, SCAL > &y)
 AutoDiffVec div AutoDiffVec.
 
template<int D, typename SCAL , typename SCAL2 , typename std::enable_if< std::is_convertible< SCAL2, SCAL >::value, int >::type = 0>
INLINE AutoDiffVec< D, SCAL > operator/ (const AutoDiffVec< D, SCAL > &x, SCAL2 y)
 AutoDiffVec div double.
 
template<int D, typename SCAL , typename SCAL2 , typename std::enable_if< std::is_convertible< SCAL2, SCAL >::value, int >::type = 0>
INLINE AutoDiffVec< D, SCAL > operator/ (SCAL2 x, const AutoDiffVec< D, SCAL > &y)
 double div AutoDiffVec
 
template<int D, typename SCAL , typename SCAL2 >
INLINE AutoDiffVec< D, SCAL > & operator+= (AutoDiffVec< D, SCAL > &x, SCAL2 y) throw ()
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCAL > & operator+= (AutoDiffVec< D, SCAL > &x, AutoDiffVec< D, SCAL > y)
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCAL > & operator-= (AutoDiffVec< D, SCAL > &x, AutoDiffVec< D, SCAL > y)
 
template<int D, typename SCAL , typename SCAL2 >
INLINE AutoDiffVec< D, SCAL > & operator-= (AutoDiffVec< D, SCAL > &x, SCAL2 y)
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCAL > & operator*= (AutoDiffVec< D, SCAL > &x, AutoDiffVec< D, SCAL > y)
 
template<int D, typename SCAL , typename SCAL2 >
INLINE AutoDiffVec< D, SCAL > & operator*= (AutoDiffVec< D, SCAL > &x, SCAL2 y)
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCAL > & operator/= (AutoDiffVec< D, SCAL > &x, SCAL y)
 
template<int D, typename SCAL >
INLINE bool operator== (AutoDiffVec< D, SCAL > x, SCAL val2)
 
template<int D, typename SCAL >
INLINE bool operator!= (AutoDiffVec< D, SCAL > x, SCAL val2) throw ()
 
template<int D, typename SCAL >
INLINE bool operator< (AutoDiffVec< D, SCAL > x, SCAL val2) throw ()
 
template<int D, typename SCAL >
INLINE bool operator> (AutoDiffVec< D, SCAL > x, SCAL val2) throw ()
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCAL > fabs (const AutoDiffVec< D, SCAL > &x)
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCAL > sqrt (const AutoDiffVec< D, SCAL > &x)
 
template<int D, typename SCAL >
AutoDiffVec< D, SCAL > log (AutoDiffVec< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCAL > exp (AutoDiffVec< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCAL > pow (AutoDiffVec< D, SCAL > x, AutoDiffVec< D, SCAL > y)
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCAL > sin (AutoDiffVec< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCAL > cos (AutoDiffVec< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCAL > tan (AutoDiffVec< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCAL > sinh (AutoDiffVec< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCAL > cosh (AutoDiffVec< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCAL > floor (const AutoDiffVec< D, SCAL > &x)
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCAL > ceil (const AutoDiffVec< D, SCAL > &x)
 
template<int D, typename SCAL >
AutoDiffVec< D, SCAL > atan (AutoDiffVec< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCAL > atan2 (AutoDiffVec< D, SCAL > x, AutoDiffVec< D, SCAL > y)
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCAL > acos (AutoDiffVec< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCAL > asin (AutoDiffVec< D, SCAL > x)
 
template<int D, typename SCAL , typename TB , typename TC >
auto IfPos (AutoDiffVec< D, SCAL > a, TB b, TC c)
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCAL > IfPos (SCAL a, AutoDiffVec< D, SCAL > b, AutoDiffVec< D, SCAL > c)
 
template<int D, typename SCAL , typename TC >
INLINE AutoDiffVec< D, SCAL > IfPos (SCAL a, AutoDiffVec< D, SCAL > b, TC c)
 
template<int D, typename SCAL >
ostream & operator<< (ostream &ost, AutoDiffRec< D, SCAL > ad)
 
template<int D, typename SCAL , typename SCAL2 , typename std::enable_if< std::is_convertible< SCAL2, SCAL >::value, int >::type = 0>
INLINE AutoDiffRec< D, SCAL > operator+ (SCAL2 a, AutoDiffRec< D, SCAL > b)
 
template<int D, typename SCAL , typename SCAL2 , typename std::enable_if< std::is_convertible< SCAL2, SCAL >::value, int >::type = 0>
INLINE AutoDiffRec< D, SCAL > operator+ (AutoDiffRec< D, SCAL > a, SCAL2 b)
 
template<int D, typename SCAL >
INLINE AutoDiffRec< D, SCAL > operator+ (AutoDiffRec< D, SCAL > a, AutoDiffRec< D, SCAL > b)
 
template<int D, typename SCAL , typename SCAL2 , typename std::enable_if< std::is_convertible< SCAL2, SCAL >::value, int >::type = 0>
INLINE AutoDiffRec< D, SCAL > operator- (SCAL2 b, AutoDiffRec< D, SCAL > a)
 
template<int D, typename SCAL , typename SCAL2 , typename std::enable_if< std::is_convertible< SCAL2, SCAL >::value, int >::type = 0>
INLINE AutoDiffRec< D, SCAL > operator- (AutoDiffRec< D, SCAL > a, SCAL2 b)
 
template<int D, typename SCAL >
INLINE AutoDiffRec< D, SCAL > operator- (AutoDiffRec< D, SCAL > a, AutoDiffRec< D, SCAL > b)
 
template<int D, typename SCAL >
INLINE AutoDiffRec< D, SCAL > operator- (AutoDiffRec< D, SCAL > a)
 minus AutoDiff
 
template<int D, typename SCAL >
INLINE AutoDiffRec< D, SCAL > operator* (AutoDiffRec< D, SCAL > a, AutoDiffRec< D, SCAL > b)
 
template<int D, typename SCAL , typename SCAL1 , typename std::enable_if< std::is_convertible< SCAL1, SCAL >::value, int >::type = 0>
INLINE AutoDiffRec< D, SCAL > operator* (AutoDiffRec< D, SCAL > b, SCAL1 a)
 
template<int D, typename SCAL , typename SCAL1 , typename std::enable_if< std::is_convertible< SCAL1, SCAL >::value, int >::type = 0>
INLINE AutoDiffRec< D, SCAL > operator* (SCAL1 a, AutoDiffRec< D, SCAL > b)
 
template<int D, typename SCAL >
INLINE AutoDiffRec< D, SCAL > & operator+= (AutoDiffRec< D, SCAL > &a, AutoDiffRec< D, SCAL > b)
 
template<int D, typename SCAL >
INLINE AutoDiffRec< D, SCAL > & operator-= (AutoDiffRec< D, SCAL > &a, double b)
 
template<int D, typename SCAL >
INLINE AutoDiffRec< D, SCAL > & operator-= (AutoDiffRec< D, SCAL > &a, AutoDiffRec< D, SCAL > b)
 
template<int D, typename SCAL >
INLINE AutoDiffRec< D, SCAL > & operator*= (AutoDiffRec< D, SCAL > &a, AutoDiffRec< D, SCAL > b)
 
template<int D, typename SCAL , typename SCAL2 >
INLINE AutoDiffRec< D, SCAL > & operator*= (AutoDiffRec< D, SCAL > &b, SCAL2 a)
 
template<typename SCAL >
auto Inv1 (SCAL x)
 Inverse of AutoDiffRec.
 
template<int D, typename SCAL >
INLINE AutoDiffRec< D, SCAL > Inv1 (AutoDiffRec< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffRec< D, SCAL > operator/ (const AutoDiffRec< D, SCAL > &x, const AutoDiffRec< D, SCAL > &y)
 AutoDiffRec div AutoDiffRec.
 
template<int D, typename SCAL , typename SCAL2 , typename std::enable_if< std::is_convertible< SCAL2, SCAL >::value, int >::type = 0>
INLINE AutoDiffRec< D, SCAL > operator/ (const AutoDiffRec< D, SCAL > &x, SCAL2 y)
 AutoDiffVec div double.
 
template<int D, typename SCAL , typename SCAL2 , typename std::enable_if< std::is_convertible< SCAL2, SCAL >::value, int >::type = 0>
INLINE AutoDiffRec< D, SCAL > operator/ (SCAL2 x, const AutoDiffRec< D, SCAL > &y)
 double div AutoDiffVec
 
template<int D, typename SCAL >
INLINE bool operator== (AutoDiffRec< D, SCAL > x, SCAL val2)
 
template<int D, typename SCAL >
INLINE bool operator!= (AutoDiffRec< D, SCAL > x, SCAL val2) throw ()
 
template<int D, typename SCAL >
INLINE bool operator< (AutoDiffRec< D, SCAL > x, SCAL val2) throw ()
 
template<int D, typename SCAL >
INLINE bool operator> (AutoDiffRec< D, SCAL > x, SCAL val2) throw ()
 
template<int D, typename SCAL >
INLINE AutoDiffRec< D, SCAL > fabs (const AutoDiffRec< D, SCAL > &x)
 
template<int D, typename SCAL >
INLINE auto sqrt (const AutoDiffRec< D, SCAL > &x)
 
template<int D, typename SCAL >
auto log (AutoDiffRec< D, SCAL > x)
 
template<int D, typename SCAL >
auto exp (AutoDiffRec< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffRec< D, SCAL > pow (AutoDiffRec< D, SCAL > x, AutoDiffRec< D, SCAL > y)
 
template<int D, typename SCAL >
auto sin (AutoDiffRec< D, SCAL > x)
 
template<int D, typename SCAL >
auto cos (AutoDiffRec< D, SCAL > x)
 
template<int D, typename SCAL >
auto tan (AutoDiffRec< D, SCAL > x)
 
template<int D, typename SCAL >
auto sinh (AutoDiffRec< D, SCAL > x)
 
template<int D, typename SCAL >
auto cosh (AutoDiffRec< D, SCAL > x)
 
template<int D, typename SCAL >
auto floor (AutoDiffRec< D, SCAL > x)
 
template<int D, typename SCAL >
auto ceil (AutoDiffRec< D, SCAL > x)
 
template<int D, typename SCAL >
auto atan (AutoDiffRec< D, SCAL > x)
 
template<int D, typename SCAL >
auto atan2 (AutoDiffRec< D, SCAL > x, AutoDiffRec< D, SCAL > y)
 
template<int D, typename SCAL >
auto acos (AutoDiffRec< D, SCAL > x)
 
template<int D, typename SCAL >
auto asin (AutoDiffRec< D, SCAL > x)
 
template<int D, typename SCAL , typename TB , typename TC >
auto IfPos (AutoDiffRec< D, SCAL > a, TB b, TC c)
 
template<int D, typename SCAL >
INLINE AutoDiffRec< D, SCAL > IfPos (SCAL a, AutoDiffRec< D, SCAL > b, AutoDiffRec< D, SCAL > c)
 
template<int D, typename SCAL , typename TC >
INLINE AutoDiffRec< D, SCAL > IfPos (SCAL a, AutoDiffRec< D, SCAL > b, TC c)
 
template<>
std::complex< double > GenericVariable::Value< std::complex< double > > (int i) const
 
ostream & operator<< (ostream &ost, const GenericVariable &var)
 
NGS_DLL_HEADER bool StringFitsPattern (const string &str, const string &pattern)
 
template<class T >
INLINE T min2 (T a, T b)
 min of 2 values
 
template<class T >
INLINE T max2 (T a, T b)
 max of 2 values
 
template<class T >
INLINE T min3 (T a, T b, T c)
 min of 3 values
 
template<class T >
INLINE T max3 (T a, T b, T c)
 max of 3 values
 
template<class T >
INLINE int sgn (T a)
 sign of value (+1, 0, -1)
 
template<class T >
INLINE T sqr (const T a)
 square element
 
template<class T >
INLINE T pow3 (const T a)
 element to the third power
 
template<class T >
void SaveBin (ostream &ost, const T &val)
 
template<class T >
void LoadBin (istream &ist, T &val)
 
template<int NUM, typename FUNC >
INLINE void Iterate (FUNC f)
 
template<int NUM, typename FUNC >
INLINE void Switch (size_t nr, FUNC f)
 

Variables

NGS_DLL_HEADER int printmessage_importance
 
const NGS_DLL_HEADER std::string ngsolve_version
 
const char dirslash = '/'
 

Detailed Description

namespace for standard data types and algorithms.

Generic container classes: FlatArray, Array, ArrayMem

Specific data types Exception, BlockAllocator, AutoPtr, EvalFunction, AutoDiff, AutoDiffDiff