NGSolve 5.3
Classes | Typedefs | Enumerations | 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  EvalFunction
 Numerical expression parser. More...
 
class  GenericVariable
 
class  MemoryUsage
 Reports amount of used memory. More...
 

Typedefs

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

Enumerations

enum  { MPI_TAG_CMD = 110 }
 
enum  { MPI_TAG_SOLVE = 1110 }
 

Functions

template<int D, typename SCAL >
ostreamoperator<< (ostream &ost, const AutoDiffDiff< D, SCAL > &x)
 Prints AudoDiffDiff.
 
template<int D, typename SCAL >
AutoDiffDiff< D, SCALoperator+ (const AutoDiffDiff< D, SCAL > &x, const AutoDiffDiff< D, SCAL > &y) throw ()
 
template<int D, typename SCAL >
AutoDiffDiff< D, SCALoperator- (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, SCALoperator+ (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, SCALoperator+ (const AutoDiffDiff< D, SCAL > &y, SCAL2 x) throw ()
 
template<int D, typename SCAL >
AutoDiffDiff< D, SCALoperator- (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, SCALoperator- (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, SCALoperator- (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, SCALoperator* (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, SCALoperator* (const AutoDiffDiff< D, SCAL > &y, SCAL2 x) throw ()
 
template<int D, typename SCAL >
AutoDiffDiff< D, SCALoperator* (const AutoDiffDiff< D, SCAL > &x, const AutoDiffDiff< D, SCAL > &y) throw ()
 
template<int D, typename SCAL >
AutoDiffDiff< D, SCALInv (const AutoDiffDiff< D, SCAL > &x)
 
template<int D, typename SCAL >
AutoDiffDiff< D, SCALoperator/ (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, SCALoperator/ (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, SCALoperator/ (SCAL2 x, const AutoDiffDiff< D, SCAL > &y)
 
template<int D, typename SCAL >
AutoDiffDiff< D, SCALsqrt (const AutoDiffDiff< D, SCAL > &x)
 
template<int D, typename SCAL >
INLINE AutoDiffDiff< D, SCALexp (AutoDiffDiff< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffDiff< D, SCALpow (AutoDiffDiff< D, SCAL > x, AutoDiffDiff< D, SCAL > y)
 
template<int D, typename SCAL >
INLINE AutoDiffDiff< D, SCALlog (AutoDiffDiff< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffDiff< D, SCALsin (AutoDiffDiff< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffDiff< D, SCALcos (AutoDiffDiff< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffDiff< D, SCALtan (AutoDiffDiff< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffDiff< D, SCALatan (AutoDiffDiff< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffDiff< D, SCALatan2 (AutoDiffDiff< D, SCAL > x, AutoDiffDiff< D, SCAL > y)
 
template<int D, typename SCAL >
INLINE AutoDiffDiff< D, SCALacos (AutoDiffDiff< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffDiff< D, SCALasin (AutoDiffDiff< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffDiff< D, SCALsinh (AutoDiffDiff< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffDiff< D, SCALcosh (AutoDiffDiff< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffDiff< D, SCALerf (AutoDiffDiff< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffDiff< D, SCALfloor (const AutoDiffDiff< D, SCAL > &x)
 
template<int D, typename SCAL >
INLINE AutoDiffDiff< D, SCALceil (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, SCALIfPos (SCAL a, AutoDiffDiff< D, SCAL > b, AutoDiffDiff< D, SCAL > c)
 
template<int D, typename SCAL , typename TC >
INLINE AutoDiffDiff< D, SCALIfPos (SCAL a, AutoDiffDiff< D, SCAL > b, TC c)
 
template<int D, typename SCAL >
ostreamoperator<< (ostream &ost, const AutoDiffVec< D, SCAL > &x)
 prints AutoDiffVec
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCALoperator+ (const AutoDiffVec< D, SCAL > &x, const AutoDiffVec< D, SCAL > &y) throw ()
 AutoDiffVec plus AutoDiffVec.
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCALoperator- (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, SCALoperator+ (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, SCALoperator+ (const AutoDiffVec< D, SCAL > &y, SCAL2 x) throw ()
 AutoDiffVec plus double.
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCALoperator- (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, SCALoperator- (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, SCALoperator- (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, SCALoperator* (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, SCALoperator* (const AutoDiffVec< D, SCAL > &y, SCAL2 x) throw ()
 AutoDiffVec times double.
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCALoperator* (const AutoDiffVec< D, SCAL > &x, const AutoDiffVec< D, SCAL > &y) throw ()
 AutoDiffVec times AutoDiffVec.
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCALsqr (const AutoDiffVec< D, SCAL > &x) throw ()
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCALInv (const AutoDiffVec< D, SCAL > &x)
 Inverse of AutoDiffVec.
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCALoperator/ (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, SCALoperator/ (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, SCALoperator/ (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, SCALfabs (const AutoDiffVec< D, SCAL > &x)
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCALsqrt (const AutoDiffVec< D, SCAL > &x)
 
template<int D, typename SCAL >
AutoDiffVec< D, SCALlog (AutoDiffVec< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCALexp (AutoDiffVec< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCALpow (AutoDiffVec< D, SCAL > x, AutoDiffVec< D, SCAL > y)
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCALsin (AutoDiffVec< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCALcos (AutoDiffVec< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCALtan (AutoDiffVec< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCALsinh (AutoDiffVec< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCALcosh (AutoDiffVec< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCALerf (AutoDiffVec< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCALfloor (const AutoDiffVec< D, SCAL > &x)
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCALceil (const AutoDiffVec< D, SCAL > &x)
 
template<int D, typename SCAL >
AutoDiffVec< D, SCALatan (AutoDiffVec< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCALatan2 (AutoDiffVec< D, SCAL > x, AutoDiffVec< D, SCAL > y)
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCALacos (AutoDiffVec< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffVec< D, SCALasin (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, SCALIfPos (SCAL a, AutoDiffVec< D, SCAL > b, AutoDiffVec< D, SCAL > c)
 
template<int D, typename SCAL , typename TC >
INLINE AutoDiffVec< D, SCALIfPos (SCAL a, AutoDiffVec< D, SCAL > b, TC c)
 
template<int D, typename SCAL >
ostreamoperator<< (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, SCALoperator+ (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, SCALoperator+ (AutoDiffRec< D, SCAL > a, SCAL2 b)
 
template<int D, typename SCAL >
INLINE AutoDiffRec< D, SCALoperator+ (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, SCALoperator- (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, SCALoperator- (AutoDiffRec< D, SCAL > a, SCAL2 b)
 
template<int D, typename SCAL >
INLINE AutoDiffRec< D, SCALoperator- (AutoDiffRec< D, SCAL > a, AutoDiffRec< D, SCAL > b)
 
template<int D, typename SCAL >
INLINE AutoDiffRec< D, SCALoperator- (AutoDiffRec< D, SCAL > a)
 minus AutoDiff
 
template<int D, typename SCAL >
INLINE AutoDiffRec< D, SCALoperator* (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, SCALoperator* (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, SCALoperator* (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, SCALInv1 (AutoDiffRec< D, SCAL > x)
 
template<int D, typename SCAL >
INLINE AutoDiffRec< D, SCALoperator/ (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, SCALoperator/ (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, SCALoperator/ (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, SCALfabs (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, SCALpow (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 erf (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, SCALIfPos (SCAL a, AutoDiffRec< D, SCAL > b, AutoDiffRec< D, SCAL > c)
 
template<int D, typename SCAL , typename TC >
INLINE AutoDiffRec< D, SCALIfPos (SCAL a, AutoDiffRec< D, SCAL > b, TC c)
 
template<>
std::complex< doubleGenericVariable::Value< std::complex< double > > (int i) const
 
ostreamoperator<< (ostream &ost, const GenericVariable &var)
 
NGS_DLL_HEADER bool StringFitsPattern (const string &str, const string &pattern)
 

Variables

NGS_DLL_HEADER const 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