olb::util Namespace Reference

Namespaces
namespace	ADtape
namespace	tensorIndices2D
namespace	tensorIndices3D

Classes
class	ADf
	Definition of a description of a algoritmic differentiation data type using the forward method. More...
struct	BaseTypeHelper
struct	BaseTypeHelper< double >
struct	BaseTypeHelper< float >
struct	BaseTypeHelper< int >
struct	BaseTypeHelper< long double >
class	BisectStepper
	Propose successive test values of a scalar (e.g. Re) to check stability of a system. More...
class	CircularBuffer
	Simple circular buffer to compute average and other quantities over pre-defined temporal windows. More...
struct	ContainerCreator
	Creates a container of type C. More...
struct	ContainerCreator< std::array< T, SIZE > >
struct	ContainerCreator< std::vector< T > >
struct	ContainerCreator< Vector< T, SIZE > >
struct	divides
	Wrapper of function object std::divides. More...
class	ExponentialMovingAverage
	Exponential moving average. More...
struct	has_identity_functor
	Indicates existence of F::identity_functor_type typedef. More...
struct	has_identity_functor< F, std::void_t< typename F::identity_functor_type > >
	Indicates existence of F::identity_functor_type typedef. More...
struct	is_adf
struct	is_adf< ADf< S, DIM > >
class	KahanSummator
	Accurate summation of floating point numbers with the Kahan algorithm Reduces round-off effects which arise if the total sum is significantly larger than the single summands. More...
struct	maxOp
	Wrapper function object for util::max. More...
struct	maxOp< void >
struct	minOp
	Wrapper function object for util::min. More...
struct	minOp< void >
struct	minus
	Wrapper of function object std::minus with special handling for bool. More...
struct	multiplies
	Wrapper of function object std::multiplies. More...
class	Newton1D
	1D Newton simple scheme More...
struct	plus
	Wrapper of function object std::plus. More...
struct	power
	Power function object. More...
class	Randomizer
struct	TensorVal
	Compute number of elements of a symmetric d-dimensional tensor. More...
class	TimeIntegrator
	Integration with the trapezoid rule. More...
class	TimeIntegratorsArray
	Helper class that manages an array of time integrators. More...
class	Timer
	How to use in Code: More...
class	TrapezRuleInt1D
	Trapezoidal rule. More...
class	ValueTracer
	Check time-convergence of a scalar. More...

Typedefs
template<typename S >
using	StdVector = std::vector<S,std::allocator<S>>

Functions
Expr	sqrt (Expr x)
Expr	fabs (Expr x)
Expr	pow (Expr base, Expr exp)
Expr	exp (Expr x)
Expr	max (Expr a, Expr b)
Expr	min (Expr a, Expr b)
template<std::floating_point T>
cpu::simd::Pack< T >	sqrt (cpu::simd::Pack< T > value)
template<std::floating_point T>
cpu::simd::Pack< T >	fabs (cpu::simd::Pack< T > value)
template<std::floating_point T>
cpu::simd::Pack< T >	pow (cpu::simd::Pack< T > base, cpu::simd::Pack< T > exp)
template<std::floating_point T, cpu::simd::concepts::convertible_to_pack S>
cpu::simd::Pack< T >	pow (cpu::simd::Pack< T > base, S exp)
template<std::floating_point T>
cpu::simd::Pack< T >	min (cpu::simd::Pack< T > rhs, cpu::simd::Pack< T > lhs)
template<std::floating_point T>
cpu::simd::Pack< T >	max (cpu::simd::Pack< T > rhs, cpu::simd::Pack< T > lhs)
template<typename T >
T	norm (const std::vector< T > &a)
	l2 norm of a vector of arbitrary length
template<typename T >
int	sign (T val) any_platform
template<typename T >
bool	aligned_to_x (const std::vector< T > &vec)
template<typename T >
bool	aligned_to_y (const std::vector< T > &vec)
template<typename T >
bool	aligned_to_z (const std::vector< T > &vec)
template<typename T >
bool	aligned_to_grid (const std::vector< T > &vec)
bool	intersect (int x0, int x1, int y0, int y1, int x0_, int x1_, int y0_, int y1_, int &newX0, int &newX1, int &newY0, int &newY1)
bool	intersect (int x0, int x1, int y0, int y1, int z0, int z1, int x0_, int x1_, int y0_, int y1_, int z0_, int z1_, int &newX0, int &newX1, int &newY0, int &newY1, int &newZ0, int &newZ1)
bool	contained (int x, int y, int x0, int x1, int y0, int y1)
bool	contained (int x, int y, int z, int x0, int x1, int y0, int y1, int z0, int z1)
template<typename T >
any_platform T	sqr (T arg) any_platform
template<typename T >
any_platform T	cube (T arg)
template<typename ARRAY_LIKE , unsigned D>
auto	normSqr (const ARRAY_LIKE &u) any_platform
	Compute norm square of a d-dimensional vector.
template<unsigned D, typename ARRAY_LIKE >
auto	norm (const ARRAY_LIKE &u) any_platform
template<typename T , unsigned D>
T	normSqr (const T *u) any_platform
template<typename T >
T	normSqr (std::initializer_list< T > data)
template<typename T , unsigned D, typename IMPL >
T	normSqr (const ScalarVector< T, D, IMPL > &u) any_platform
	Compute norm square of a d-dimensional vector.
template<typename T , int d>
T	scalarProduct (const Vector< T, d > &u1, const Vector< T, d > &u2) any_platform
template<typename T >
T	scalarProduct (const std::vector< T > &u1, const std::vector< T > &u2)
template<typename DESCRIPTOR , unsigned iVel, int value>
constexpr auto	populationsContributingToVelocity () any_platform
	Return array of population indices where c[iVel] == value.
template<typename DESCRIPTOR , int... NORMAL>
constexpr auto	populationsContributingToDirection () any_platform
	Return array of population indices where c[iPop][iD] == NORMAL[iD].
template<typename DESCRIPTORBASE >
int	findVelocity (const int v[DESCRIPTORBASE::d]) any_platform
template<typename DESCRIPTOR , int direction, int orientation>
constexpr auto	subIndexOutgoing () any_platform
	Compute opposites of wall-incoming population indices.
template<typename DESCRIPTOR , int direction, int orientation>
constexpr auto	subIndexOutgoingRemaining () any_platform
template<typename DESCRIPTOR , int plane, int normal1, int normal2>
constexpr auto	subIndexOutgoing3DonEdges () any_platform
template<typename DESCRIPTOR , int normalX, int normalY>
constexpr auto	subIndexOutgoing2DonCorners () any_platform
template<typename DESCRIPTOR , int normalX, int normalY, int normalZ>
constexpr auto	subIndexOutgoing3DonCorners () any_platform
template<typename DESCRIPTORBASE >
std::vector< int >	remainingIndexes (const std::vector< int > &indices)
	finds all the remaining indexes of a lattice given some other indexes
template<typename T , typename DESCRIPTOR >
int	get_nearest_link (const std::vector< T > &vec)
	Util Function for Wall Model of Malaspinas get link with smallest angle to a vector.
template<typename T , typename DESCRIPTOR >
any_platform T	densityFromPressure (T latticePressure)
	compute lattice density from lattice pressure
template<typename T , typename DESCRIPTOR >
any_platform T	pressureFromDensity (T latticeDensity)
	compute lattice pressure from lattice density
template<typename T >
bool	nearZero (T a) any_platform
	return true if a is close to zero
template<typename T >
bool	nearZero (T a, T epsilon) any_platform
template<typename T , typename U = T, typename W = T>
bool	approxEqual (T a, U b, W epsilon) any_platform
template<typename T , typename U = T>
bool	approxEqual (T a, U b) any_platform
template<unsigned D, typename F >
void	forEachOffset (F fn) any_platform
template<typename S , unsigned D, typename F1 , typename F2 >
bool	distance (S &distance, const Vector< S, D > &origin, const Vector< S, D > &direction, S precision, S pitch, F1 isInside, F2 isInsideBoundingBox)
template<typename S , unsigned D, typename F1 , typename F2 >
bool	distance (S &distance, const Vector< S, D > &origin, const Vector< S, D > &direction, S precision, F1 sdf, F2 isInsideBoundingBox, const unsigned maxIt=1e6)
template<typename S , unsigned D, bool normalizeDirection = true>
bool	distance (S &distance, const Vector< S, D > &origin, const Vector< S, D > &direction, S precision, std::function< S(const Vector< S, D > &)> sdf, S maxDistance, const unsigned maxIt=1e6)
template<typename S , unsigned D, typename F1 , typename F2 >
bool	bisectDistance (S &distance, const Vector< S, D > &origin, const Vector< S, D > &direction, S pitch, S precision, F1 isInside, F2 isInsideBoundingBox)
	Using a bisect to find the unsigned distance (false if distance was not found, true if distance was found)
template<typename S , unsigned D, typename F1 >
Vector< S, D >	surfaceNormal (const Vector< S, D > &pos, const S meshSize, F1 sdf)
template<typename SAD >
void	iniDiagonal (SAD *a, int dim)
	The variables of an array are set to be the differential variables.
template<typename C >
void	iniDiagonal (C &a)
template<typename T , typename TAD >
void	copyDerivatives (T *target, const TAD *source, int length)
	Copy the derivatives from an ADf array into an array.
template<typename T , typename S , template< typename > typename C>
C< T >	copyAs (const C< S > &input)
	copy vector with specified typecast
template<typename S >
ADf< S, 1 >	iniAD (const S source)
	copy value and initialize derivative
template<unsigned n, typename S >
ADf< S, n > *	iniAD (const S *source)
	copy array values and initialize derivatives
template<unsigned n, typename S , template< typename > typename C>
C< ADf< S, n > >	iniAD (const C< S > &source)
	copy values and initialize derivatives
template<typename S , typename F >
auto	derivativeFAD (F f, const S input)
	Compute derivatives of a function f: S -> T via forward AD Signature is "V f(U)" so f is expected to accept and return a single value.
template<unsigned sourceDIM, typename S , typename F >
auto	derivativeFAD (F f, const S *input)
	Compute derivatives of a function f: S^sourceDIM -> T via forward AD Signature is "V f(U*)" so f is expected to return a single value.
template<unsigned sourceDIM, typename T , typename S , typename F >
void	derivativeFAD (F f, T *output, const S *input, unsigned targetDIM)
	Compute derivatives of a function f: S^sourceDIM -> T^targetDIM via forward AD Signature of f is "void f(V*, U*)", it is expected to modify the first argument in-place.
template<class T , unsigned DIM>
std::ostream &	operator<< (std::ostream &os, const ADf< T, DIM > &o)
template<class T , unsigned DIM>
std::istream &	operator>> (std::istream &is, ADf< T, DIM > &in)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr ADf< T, DIM >	operator+ (const U &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr ADf< T, DIM >	operator+ (const ADf< T, DIM > &a, const U &b)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	operator+ (const ADf< T, DIM > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr ADf< T, DIM >	operator- (const U &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr ADf< T, DIM >	operator- (const ADf< T, DIM > &a, const U &b)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	operator- (const ADf< T, DIM > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr ADf< T, DIM >	operator* (const U &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr ADf< T, DIM >	operator* (const ADf< T, DIM > &a, const U &b)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	operator* (const ADf< T, DIM > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr ADf< T, DIM >	operator/ (const U &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr ADf< T, DIM >	operator/ (const ADf< T, DIM > &a, const U &b)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	operator/ (const ADf< T, DIM > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	operator+ (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	operator- (const ADf< T, DIM > &a)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
ADf< T, DIM >	pow (const U &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
ADf< T, DIM >	pow (const ADf< T, DIM > &a, const U &b)
template<class T , unsigned DIM>
ADf< T, DIM >	pow (const ADf< T, DIM > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
ADf< T, DIM >	pow (const ADf< T, DIM > &a, int b)
template<class T , unsigned DIM>
ADf< T, DIM >	sqr (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	exp (const ADf< T, DIM > &a)
template<unsigned DIM>
ADf< float, DIM >	expf (const ADf< float, DIM > &a)
template<unsigned DIM>
ADf< long double, DIM >	expl (const ADf< long double, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	log (const ADf< T, DIM > &a)
template<unsigned DIM>
ADf< float, DIM >	logf (const ADf< float, DIM > &a)
template<unsigned DIM>
ADf< long double, DIM >	logl (const ADf< long double, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	log10 (const ADf< T, DIM > &a)
template<unsigned DIM>
ADf< float, DIM >	log10f (const ADf< float, DIM > &a)
template<unsigned DIM>
ADf< long double, DIM >	log10l (const ADf< long double, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	log2 (const ADf< T, DIM > &a)
template<unsigned DIM>
ADf< float, DIM >	log2f (const ADf< float, DIM > &a)
template<unsigned DIM>
ADf< long double, DIM >	log2l (const ADf< long double, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	log1p (const ADf< T, DIM > &a)
template<unsigned DIM>
ADf< float, DIM >	log1pf (const ADf< float, DIM > &a)
template<unsigned DIM>
ADf< long double, DIM >	log1pl (const ADf< long double, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	sqrt (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	sin (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	cos (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	tan (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	asin (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	acos (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	atan (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	atan2 (const T &y, const ADf< T, DIM > &x)
template<class T , unsigned DIM>
ADf< T, DIM >	atan2 (const ADf< T, DIM > &y, const T &x)
template<class T , unsigned DIM>
ADf< T, DIM >	atan2 (const ADf< T, DIM > &y, const ADf< T, DIM > &x)
template<class T , unsigned DIM>
ADf< T, DIM >	sinh (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	cosh (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	tanh (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	asinh (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	acosh (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	atanh (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	fmod (const ADf< T, DIM > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
ADf< T, DIM >	fmod (const ADf< T, DIM > &a, const U &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
ADf< T, DIM >	fmod (const U &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
constexpr bool	operator== (const ADf< T, DIM > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr bool	operator== (const ADf< T, DIM > &a, const U &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr bool	operator== (const U &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
constexpr bool	operator!= (const ADf< T, DIM > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr bool	operator!= (const ADf< T, DIM > &a, const U &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr bool	operator!= (const U &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
constexpr bool	operator> (const ADf< T, DIM > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr bool	operator> (const ADf< T, DIM > &a, const U &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr bool	operator> (const U &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
constexpr bool	operator>= (const ADf< T, DIM > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr bool	operator>= (const ADf< T, DIM > &a, const U &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr bool	operator>= (const U &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
constexpr bool	operator< (const ADf< T, DIM > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr bool	operator< (const ADf< T, DIM > &a, const U &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr bool	operator< (const U &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
constexpr bool	operator<= (const ADf< T, DIM > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr bool	operator<= (const ADf< T, DIM > &a, const U &b)
template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>
constexpr bool	operator<= (const U &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
ADf< T, DIM >	floor (const ADf< T, DIM > &a)
template<unsigned DIM>
ADf< float, DIM >	floorf (const ADf< float, DIM > &a)
template<unsigned DIM>
ADf< long double, DIM >	floorl (const ADf< long double, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	ceil (const ADf< T, DIM > &a)
template<unsigned DIM>
ADf< float, DIM >	ceilf (const ADf< float, DIM > &a)
template<unsigned DIM>
ADf< long double, DIM >	ceill (const ADf< long double, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	round (const ADf< T, DIM > &a)
template<unsigned DIM>
ADf< float, DIM >	roundf (const ADf< float, DIM > &a)
template<unsigned DIM>
ADf< long double, DIM >	roundl (const ADf< long double, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	lround (const ADf< T, DIM > &a)
template<unsigned DIM>
ADf< float, DIM >	lroundf (const ADf< float, DIM > &a)
template<unsigned DIM>
ADf< long double, DIM >	lroundl (const ADf< long double, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	llround (const ADf< T, DIM > &a)
template<unsigned DIM>
ADf< float, DIM >	llroundf (const ADf< float, DIM > &a)
template<unsigned DIM>
ADf< long double, DIM >	llroundl (const ADf< long double, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	fabs (const ADf< T, DIM > &a)
template<unsigned DIM>
ADf< float, DIM >	fabsf (const ADf< float, DIM > &a)
template<unsigned DIM>
ADf< long double, DIM >	fabsl (const ADf< long double, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	abs (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	labs (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	llabs (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	max (const olb::BaseType< ADf< T, DIM > > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	max (const ADf< T, DIM > &a, const olb::BaseType< ADf< T, DIM > > &b)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	max (const ADf< T, DIM > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	min (const olb::BaseType< ADf< T, DIM > > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	min (const ADf< T, DIM > &a, const olb::BaseType< ADf< T, DIM > > &b)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	min (const ADf< T, DIM > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
bool	nearZero (const ADf< T, DIM > &a)
template<typename T >
constexpr void	throwADfException (T arg)
template<class TAPE >
auto	sqrt (const util::ADtape::ActiveType< TAPE > &a)
template<typename T , typename S >
auto	fmod_pos (T a, S b)
	Variant of fmod (floating point modulo) that always returns positive values.
template<typename T >
void	kahanSum (T output[2], T summand)
	Accurate summation of floating point numbers with the Kahan algorithm.
template<typename T >
void	kahanSum (T &output0, T &output1, T summand)
template<typename K >
K	crossSum (K k)
	Compute cross sum of an integer.
template<typename T , unsigned D>
decltype(Vector< decltype(util::sqrt(T())), D >())	degreeToRadian (const Vector< T, D > &angle)
template<typename T >
decltype(util::sqrt(T()))	degreeToRadian (T angle)
template<typename T , unsigned D>
decltype(Vector< decltype(util::sqrt(T())), D >())	radianToDegree (const Vector< T, D > &angle)
template<typename T >
decltype(util::sqrt(T()))	radianToDegree (T angle)
template<typename T , unsigned D>
Vector< T, utilities::dimensions::convert< D >::matrix >	calculateRotationMatrix (const Vector< T, utilities::dimensions::convert< D >::rotation > &angle) any_platform
template<typename T >
Vector< T, 4 >	inverseRotation (const Vector< T, 4 > &m) any_platform
template<typename T >
Vector< T, 9 >	inverseRotation (const Vector< T, 9 > &m) any_platform
template<typename T , unsigned D>
Vector< T, D >	matrixVectorProduct (const Vector< T, utilities::dimensions::convert< D >::matrix > &M, const Vector< T, D > &b) any_platform
	Compute v=M b.
template<typename T , unsigned D>
Vector< T, utilities::dimensions::convert< D >::matrix >	matrixMatrixProduct (const Vector< T, utilities::dimensions::convert< D >::matrix > &A, const Vector< T, utilities::dimensions::convert< D >::matrix > &B) any_platform
	Compute C=AB for square matrices.
template<typename T , unsigned D>
Vector< T, utilities::dimensions::convert< D >::matrix >	invertRotationMatrix (const Vector< T, utilities::dimensions::convert< D >::matrix > &rotationMatrix)
template<typename T , unsigned D>
Vector< T, utilities::dimensions::convert< D >::matrix >	calculateInverseRotationMatrix (const Vector< T, utilities::dimensions::convert< D >::rotation > &angle)
template<typename T , unsigned D, bool OUTPUT_USES_ROTATION_CENTER_AS_ORIGIN = false>
Vector< T, D >	executeRotation (const Vector< T, D > &input, const Vector< T, utilities::dimensions::convert< D >::matrix > &rotationMatrix, const Vector< T, D > &rotationCenter=Vector< T, D >(0.))
	Rotates the input around the rotationCenter with a given rotationMatrix.
template<typename T , unsigned D, bool OUTPUT_USES_ROTATION_CENTER_AS_ORIGIN = false>
Vector< T, D >	invertRotation (const Vector< T, D > &input, const Vector< T, utilities::dimensions::convert< D >::matrix > &rotationMatrix, const Vector< T, D > &rotationCenter=Vector< T, D >(0.))
	Rotates the input around the rotationCenter with a given rotationMatrix in the opposite direction.
template<typename T , unsigned D>
constexpr Vector< T, D >	calculateLocalVelocity (const Vector< T, D > &rotationCenter, const Vector< T, D > &velocity, const Vector< T, utilities::dimensions::convert< D >::rotation > &angularVelocity, const Vector< T, D > &position)
	Calculate local velocity.
template<typename T >
constexpr Matrix< T, 3, 3 >	rotateMofi (const Vector< T, 3 > &mofi, const Vector< T, 9 > &rotationMatrix)
	Rotate moment of inertia (mofi)
template<typename T >
int	evaluateIntegration (std::vector< T > &testValues, bool print=false)
template<typename T >
constexpr auto	determinant (const Matrix< T, 2, 2 > &m)
template<typename T >
constexpr auto	determinant (const Matrix< T, 3, 3 > &m)
template<typename T >
auto	solveLinearSystem (const Matrix< T, 2, 2 > &a, const Vector< T, 2 > &rhs)
	Solve a * x = rhs.
template<typename T >
auto	solveLinearSystem (const Matrix< T, 3, 3 > &a, const Vector< T, 3 > &rhs)
	Solve (a0 a1 a2) x = rhs.
template<typename T >
T	euklidN2 (const T x[], int dim)
	Squared Euclidean norm of an array.
template<typename T >
T	euklidDistance2 (const T x[], const T y[], int dim)
	Squared Euclidean distance between two arrays.
template<typename T >
T	euklidN (const T x[], int dim)
	Euclidean norm of an array.
template<typename T >
T	euklidDistance (const T x[], const T y[], int dim)
	Euclidean distance between two arrays.
template<typename C >
auto	euklidN2 (const C &x)
	Squared Euclidean norm for Container-type array.
template<typename C >
auto	euklidDistance2 (const C &x, const C &y)
	Squared Euclidean distance for Container-type array.
template<typename C >
auto	euklidN (const C &x)
	Euclidean norm for Container-type array.
template<typename C >
auto	euklidDistance (const C &x, const C &y)
	Euclidean distance for Container-type array.
template<typename T >
any_platform constexpr T	max (T a, meta::id_t< T > b)
template<typename T >
constexpr T	max (std::initializer_list< T > ilist)
template<typename T >
any_platform constexpr T	min (T a, meta::id_t< T > b)
template<typename T >
constexpr T	min (std::initializer_list< T > ilist)
template<typename T , typename S >
any_platform auto	pow (T x, S y) -> std::enable_if_t< std::is_floating_point_v< T > &&std::is_floating_point_v< S >, decltype(std::pow(x, y))>
template<typename T , typename S >
any_platform std::enable_if_t< std::is_integral_v< T > &&std::is_integral_v< S >, double >	pow (T x, S y)
any_platform float	powf (float base, float exp)
any_platform float	powf (int base, int exp)
long double	powl (long double base, long double exp)
template<typename T , typename S >
any_platform auto	fmod (T x, S y) -> std::enable_if_t< std::is_floating_point_v< T > &&std::is_floating_point_v< S >, decltype(std::fmod(x, y))>
template<typename T , typename S >
any_platform std::enable_if_t< std::is_integral_v< S > &&std::is_floating_point_v< T >, T >	fmod (T x, S y)
template<typename T , typename S >
any_platform std::enable_if_t< std::is_integral_v< T > &&std::is_floating_point_v< S >, S >	fmod (T x, S y)
any_platform float	fmodf (float x, float y)
any_platform float	fmodf (int x, int y)
long double	fmodl (long double x, long double y)
template<typename T >
any_platform std::enable_if_t< std::is_floating_point_v< T >, T >	exp (T x)
template<typename T >
any_platform std::enable_if_t< std::is_integral_v< T >, double >	exp (T arg)
any_platform float	expf (float arg)
any_platform float	expf (int arg)
long double	expl (long double arg)
template<typename T >
any_platform std::enable_if_t< std::is_floating_point_v< T >, T >	log (T x)
template<typename T >
any_platform std::enable_if_t< std::is_integral_v< T >, double >	log (T arg)
any_platform float	logf (float arg)
any_platform float	logf (int arg)
long double	logl (long double arg)
template<typename T >
any_platform std::enable_if_t< std::is_floating_point_v< T >, T >	log10 (T x)
template<typename T >
any_platform std::enable_if_t< std::is_integral_v< T >, double >	log10 (T arg)
any_platform float	log10f (float arg)
any_platform float	log10f (int arg)
long double	log10l (long double arg)
template<typename T >
any_platform std::enable_if_t< std::is_floating_point_v< T >, T >	log2 (T x)
template<typename T >
any_platform std::enable_if_t< std::is_integral_v< T >, double >	log2 (T arg)
any_platform float	log2f (float arg)
any_platform float	log2f (int arg)
long double	log2l (long double arg)
template<typename T >
any_platform std::enable_if_t< std::is_floating_point_v< T >, T >	log1p (T x)
template<typename T >
any_platform std::enable_if_t< std::is_integral_v< T >, double >	log1p (T arg)
any_platform float	log1pf (float arg)
any_platform float	log1pf (int arg)
long double	log1pl (long double arg)
template<typename T >
any_platform std::enable_if_t< std::is_floating_point_v< T >, T >	sqrt (T x)
template<typename T >
any_platform std::enable_if_t< std::is_integral_v< T >, double >	sqrt (T arg)
any_platform float	sqrtf (float arg)
any_platform float	sqrtf (int arg)
long double	sqrtl (long double arg)
any_platform float	sinf (float x)
any_platform float	sinf (int x)
template<typename T >
any_platform std::enable_if_t< std::is_floating_point_v< T >, T >	sin (T x)
template<typename T >
any_platform std::enable_if_t< std::is_integral_v< T >, double >	sin (T x)
long double	sinl (long double arg)
any_platform float	sinhf (float x)
any_platform float	sinhf (int x)
template<typename T >
any_platform std::enable_if_t< std::is_floating_point_v< T >, T >	sinh (T x)
template<typename T >
any_platform std::enable_if_t< std::is_integral_v< T >, double >	sinh (T x)
long double	sinhl (long double arg)
any_platform float	cosf (float x)
any_platform float	cosf (int x)
template<typename T >
any_platform std::enable_if_t< std::is_floating_point_v< T >, T >	cos (T x)
template<typename T >
any_platform std::enable_if_t< std::is_integral_v< T >, double >	cos (T x)
long double	cosl (long double arg)
any_platform float	coshf (float x)
any_platform float	coshf (int x)
template<typename T >
any_platform std::enable_if_t< std::is_floating_point_v< T >, T >	cosh (T x)
template<typename T >
any_platform std::enable_if_t< std::is_integral_v< T >, double >	cosh (T x)
long double	coshl (long double arg)
any_platform float	tanf (float x)
any_platform float	tanf (int x)
template<typename T >
any_platform std::enable_if_t< std::is_floating_point_v< T >, T >	tan (T x)
template<typename T >
any_platform std::enable_if_t< std::is_integral_v< T >, double >	tan (T x)
long double	tanl (long double arg)
any_platform float	tanhf (float x)
any_platform float	tanhf (int x)
template<typename T >
any_platform std::enable_if_t< std::is_floating_point_v< T >, T >	tanh (T x)
template<typename T >
any_platform std::enable_if_t< std::is_integral_v< T >, double >	tanh (T x)
long double	tanhl (long double arg)
any_platform float	asinf (float x)
any_platform float	asinf (int x)
template<typename T >
any_platform std::enable_if_t< std::is_floating_point_v< T >, T >	asin (T x)
template<typename T >
any_platform std::enable_if_t< std::is_integral_v< T >, double >	asin (T x)
long double	asinl (long double arg)
any_platform float	asinhf (float x)
any_platform float	asinhf (int x)
template<typename T >
any_platform std::enable_if_t< std::is_floating_point_v< T >, T >	asinh (T x)
template<typename T >
any_platform std::enable_if_t< std::is_integral_v< T >, double >	asinh (T x)
long double	asinhl (long double arg)
any_platform float	acosf (float x)
any_platform float	acosf (int x)
template<typename T >
any_platform std::enable_if_t< std::is_floating_point_v< T >, T >	acos (T x)
template<typename T >
any_platform std::enable_if_t< std::is_integral_v< T >, double >	acos (T x)
long double	acosl (long double arg)
any_platform float	acoshf (float x)
any_platform float	acoshf (int x)
template<typename T >
any_platform std::enable_if_t< std::is_floating_point_v< T >, T >	acosh (T x)
template<typename T >
any_platform std::enable_if_t< std::is_integral_v< T >, double >	acosh (T x)
long double	acoshl (long double arg)
any_platform float	atanf (float x)
any_platform float	atanf (int x)
template<typename T >
any_platform std::enable_if_t< std::is_floating_point_v< T >, T >	atan (T x)
template<typename T >
any_platform std::enable_if_t< std::is_integral_v< T >, double >	atan (T x)
long double	atanl (long double arg)
template<typename T , typename S >
any_platform auto	atan2 (T x, S y) -> std::enable_if_t< std::is_floating_point_v< T > &&std::is_floating_point_v< S >, decltype(std::atan2(x, y))>
template<typename T , typename S >
any_platform std::enable_if_t< std::is_integral_v< S > &&std::is_floating_point_v< T >, T >	atan2 (T x, S y)
template<typename T , typename S >
any_platform std::enable_if_t< std::is_integral_v< T > &&std::is_floating_point_v< S >, S >	atan2 (T x, S y)
template<typename T , typename S >
any_platform std::enable_if_t< std::is_integral_v< T > &&std::is_integral_v< S >, double >	atan2 (T x, S y)
any_platform float	atan2f (float base, float exp)
any_platform float	atan2f (int base, int exp)
any_platform float	atanhf (float x)
any_platform float	atanhf (int x)
template<typename T >
any_platform std::enable_if_t< std::is_floating_point_v< T >, T >	atanh (T x)
template<typename T >
any_platform std::enable_if_t< std::is_integral_v< T >, double >	atanh (T x)
long double	atanhl (long double arg)
any_platform float	floorf (float x)
any_platform float	floorf (int x)
template<typename T >
any_platform std::enable_if_t< std::is_floating_point_v< T >, T >	floor (T x)
template<typename T >
any_platform std::enable_if_t< std::is_integral_v< T >, double >	floor (T x)
long double	floorl (long double arg)
any_platform float	ceilf (float x)
any_platform float	ceilf (int x)
template<typename T >
any_platform std::enable_if_t< std::is_floating_point_v< T >, T >	ceil (T x)
template<typename T >
any_platform std::enable_if_t< std::is_integral_v< T >, double >	ceil (T x)
long double	ceill (long double arg)
any_platform float	truncf (float x)
any_platform float	truncf (int x)
template<typename T >
any_platform std::enable_if_t< std::is_floating_point_v< T >, T >	trunc (T x)
template<typename T >
any_platform std::enable_if_t< std::is_integral_v< T >, double >	trunc (T x)
long double	truncl (long double arg)
any_platform float	roundf (float x)
any_platform float	roundf (int x)
template<typename T >
any_platform std::enable_if_t< std::is_floating_point_v< T >, T >	round (T x)
template<typename T >
any_platform std::enable_if_t< std::is_integral_v< T >, double >	round (T x)
long double	roundl (long double arg)
template<typename T >
std::enable_if_t< std::is_arithmetic_v< T >, long >	lround (T arg)
long	lroundf (float arg)
long	lroundl (long double arg)
template<typename T >
std::enable_if_t< std::is_arithmetic_v< T >, long long >	llround (T arg)
long long	llroundf (float arg)
long long	llroundl (long double arg)
any_platform float	fabsf (float x)
any_platform float	fabsf (int x)
template<typename T >
any_platform std::enable_if_t< std::is_floating_point_v< T >, T >	fabs (T x)
template<typename T >
any_platform std::enable_if_t< std::is_integral_v< T >, double >	fabs (T x)
template<typename T >
any_platform std::enable_if_t< std::is_floating_point_v< T >, T >	abs (T x)
template<typename T >
any_platform std::enable_if_t< std::is_integral_v< T >, T >	abs (T x)
long double	fabs (long double arg)
template<std::integral T>
any_platform bool	closeToZero (T x)
template<typename T >
any_platform bool	isnan (T arg)
template<typename T , typename DESCRIPTOR >
Timer< T > *	createTimer (XMLreader &param, const UnitConverter< T, DESCRIPTOR > &converter, size_t numLatticePoints)
template<class T >
void	copyN (T c[], const T a[], const unsigned dim) any_platform
template<class S , class T >
void	copyN (S c[], const T a[], const unsigned dim) any_platform
template<class T >
void	copy3 (T c[], const T a[])
template<typename T >
std::vector< T >	fromVector3 (const Vector< T, 3 > &vec)
template<typename T >
std::vector< T >	fromVector2 (const Vector< T, 2 > &vec)
template<typename T >
T	norm2 (const T *a, unsigned size)
	l2 norm to the power of 2 of a vector of arbitrary length
template<typename T >
T	norm2 (const std::vector< T > &a)
	l2 norm to the power of 2 of a vector of arbitrary length
template<typename T >
T	norm (const T *a, unsigned size)
	l2 norm of a vector of arbitrary length
template<typename T >
T	dotProduct3D (const Vector< T, 3 > &a, const Vector< T, 3 > &b)
	dot product, only valid in 3d
template<typename T >
T	dotProduct2D (const Vector< T, 2 > &a, const Vector< T, 2 > &b)
	dot product, only valid in 2d
template<typename T , unsigned D>
T	dotProduct (const Vector< T, D > &a, const Vector< T, D > &b)
	dot product
template<typename T , unsigned D>
Vector< T, D >	normalize (const Vector< T, D > &a)
template<typename T >
std::vector< T >	normalize (const std::vector< T > &a)
	returns a normalized vector, works for arbitrary lengths
template<typename T , unsigned Size>
Vector< T, Size >	floor (const Vector< T, Size > &a) any_platform
	applies floor to each component of a vector
template<typename T , unsigned Size>
Vector< T, Size >	ceil (const Vector< T, Size > &a) any_platform
	applies ceil to each component of a vector
template<typename T , typename S , unsigned Size>
Vector< T, Size >	fmod (const Vector< T, Size > &a, S b)
	applies fmod to each component of a vector
template<typename T , unsigned Size>
T	average (const Vector< T, Size > &a)
	computes the average of all elements
template<typename T , unsigned Size>
T	max_element (const Vector< T, Size > &a)
	finds maximum element of all elements
template<typename T , unsigned Size>
T	min_element (const Vector< T, Size > &a)
	finds minimum element of all elements
template<typename T , unsigned Size>
unsigned	maxElementPos (const Vector< T, Size > &a)
	finds position of maximum element of all elements
template<typename T , unsigned Size>
unsigned	minElementPos (const Vector< T, Size > &a)
	finds position of minimum element of all elements
template<typename T , unsigned Size>
T	maxElementAbs (const Vector< T, Size > &a)
	finds maximum element of all absolute elements
template<typename T , unsigned Size>
unsigned	maxElementAbsPos (const Vector< T, Size > &a)
	finds position of maximum element of all absolute elements
template<typename T , bool ensureAngularBounds = true>
T	angleBetweenVectors (const Vector< T, 2 > &a, const Vector< T, 2 > &b)
	Calculates angles between two 2D vectors.
template<typename T , bool ensureAngularBounds = true>
Vector< T, 3 >	angleBetweenVectors (const Vector< T, 3 > &a, const Vector< T, 3 > &b)
	Calculates angles between two 3D vectors.
template<typename T >
constexpr T	determinant (const Vector< T, 2 > &v0, const Vector< T, 2 > &v1)
template<typename T >
constexpr T	determinant (const Vector< T, 3 > &v0, const Vector< T, 3 > &v1, const Vector< T, 3 > &v2)
template<typename T >
Vector< T, 2 >	solveLinearSystem (const Vector< T, 2 > &a0, const Vector< T, 2 > &a1, const Vector< T, 2 > &rhs)
	Solve (a0 a1) x = rhs.
template<typename T >
Vector< T, 3 >	solveLinearSystem_help (const Vector< T, 3 > &a0, const Vector< T, 3 > &a1, const Vector< T, 3 > &a2, const Vector< T, 3 > &rhs, T det)
template<typename T >
Vector< T, 3 >	solveLinearSystem (const Vector< T, 3 > &a0, const Vector< T, 3 > &a1, const Vector< T, 3 > &a2, const Vector< T, 3 > &rhs)
	Solve (a0 a1 a2) x = rhs.
template<typename T >
std::vector< T >	assign (T a, T b)
template<typename T >
std::vector< T >	assign (T a, T b, T c)
template<typename U >
void	print (U data, const std::string &name="", OstreamManager clout=OstreamManager(std::cout,"print"), const char delimiter=',')
template<typename C , typename U >
bool	isContained (const C &c, U object)
	Check, if object is contained in iteratable container c.
template<unsigned DIM>
unsigned	serialSymmetricTensorIndex (unsigned i, unsigned j) any_platform
	Compute serial index of symmetric tensor.

Variables
template<class T >
constexpr bool	is_adf_v = is_adf<T>::value

Typedef Documentation

StdVector

template<typename S >

using olb::util::StdVector = std::vector<S,std::allocator<S>>

Definition at line 50 of file vectorHelpers.h.

Function Documentation

abs() [1/3]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::abs ( const ADf< T, DIM > & a )

inline

Definition at line 1019 of file aDiff.h.

{
  return fabs(a);
}

References fabs().

Here is the call graph for this function:

Here is the caller graph for this function:

abs() [2/3]

template<typename T >

any_platform std::enable_if_t< std::is_floating_point_v< T >, T > olb::util::abs ( T x )

inline

Definition at line 1583 of file omath.h.

{
#ifdef __CUDA_ARCH__
  if constexpr (std::is_same_v<T, float>) {
    return ::fabsf(x);
  }
  else if constexpr (std::is_same_v<T, double>) {
    return ::fabs(x);
  }
  else {
    return ::fabs(static_cast<double>(x));
    //libcu++ of cuda supports double and float. You will get warning in device code if you use in e.g. long double.
  }
#else  //__CUDA_ARCH__
  return std::abs(x);
#endif //__CUDA_ARCH__
}

abs() [3/3]

template<typename T >

any_platform std::enable_if_t< std::is_integral_v< T >, T > olb::util::abs ( T x )

inline

Definition at line 1602 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::abs(x);
#else  //__CUDA_ARCH__
  return std::abs(x);
#endif //__CUDA_ARCH__
}

acos() [1/3]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::acos ( const ADf< T, DIM > & a )

inline

Definition at line 605 of file aDiff.h.

{
  ADf<T,DIM> c(std::acos(a._v), a._d);
  T tmp(-T(1)/std::sqrt(T(1)-(a._v)*(a._v)));
  c._d*=tmp;
  return c;
}

Here is the caller graph for this function:

acos() [2/3]

template<typename T >

any_platform std::enable_if_t< std::is_floating_point_v< T >, T > olb::util::acos ( T x )

inline

Definition at line 1007 of file omath.h.

{
#ifdef __CUDA_ARCH__
  if constexpr (std::is_same_v<T, float>) {
    return ::acosf(x);
  }
  else if constexpr (std::is_same_v<T, double>) {
    return ::acos(x);
  }
  else {
    return ::acos(static_cast<double>(x));
    //libcu++ of cuda supports double and float. You will get warning in device code if you use in e.g. long double.
  }
#else  //__CUDA_ARCH__
  return std::acos(x);
#endif //__CUDA_ARCH__
}

acos() [3/3]

template<typename T >

any_platform std::enable_if_t< std::is_integral_v< T >, double > olb::util::acos ( T x )

inline

Definition at line 1026 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::acos(x);
#else  //__CUDA_ARCH__
  return std::acos(x);
#endif //__CUDA_ARCH__
}

acosf() [1/2]

any_platform float olb::util::acosf ( float x )

inline

Definition at line 988 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::acosf(x);
#else  //__CUDA_ARCH__
  return std::acos(x);
#endif //__CUDA_ARCH__
}

acosf() [2/2]

any_platform float olb::util::acosf ( int x )

inline

Definition at line 997 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::acosf(x);
#else  //__CUDA_ARCH__
  return std::acos(x);
#endif //__CUDA_ARCH__
}

acosh() [1/3]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::acosh ( const ADf< T, DIM > & a )

inline

Definition at line 675 of file aDiff.h.

{
  if (a._v >= 1) {
    return log( a + sqrt(a*a-1) );
  }
  else {
    ADf<T,DIM> c;
    c._v = std::acosh(a._v);
    c._d = ( std::numeric_limits<T>::quiet_NaN() );
    return c;
  }
}

References log(), and sqrt().

Here is the call graph for this function:

acosh() [2/3]

template<typename T >

any_platform std::enable_if_t< std::is_floating_point_v< T >, T > olb::util::acosh ( T x )

inline

Definition at line 1061 of file omath.h.

{
#ifdef __CUDA_ARCH__
  if constexpr (std::is_same_v<T, float>) {
    return ::acoshf(x);
  }
  else if constexpr (std::is_same_v<T, double>) {
    return ::acosh(x);
  }
  else {
    return ::acosh(static_cast<double>(x));
    //libcu++ of cuda supports double and float. You will get warning in device code if you use in e.g. long double.
  }
#else  //__CUDA_ARCH__
  return std::acosh(x);
#endif //__CUDA_ARCH__
}

acosh() [3/3]

template<typename T >

any_platform std::enable_if_t< std::is_integral_v< T >, double > olb::util::acosh ( T x )

inline

Definition at line 1080 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::acosh(x);
#else  //__CUDA_ARCH__
  return std::acosh(x);
#endif //__CUDA_ARCH__
}

acoshf() [1/2]

any_platform float olb::util::acoshf ( float x )

inline

Definition at line 1042 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::acoshf(x);
#else  //__CUDA_ARCH__
  return std::acosh(x);
#endif //__CUDA_ARCH__
}

acoshf() [2/2]

any_platform float olb::util::acoshf ( int x )

inline

Definition at line 1051 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::acoshf(x);
#else  //__CUDA_ARCH__
  return std::acosh(x);
#endif //__CUDA_ARCH__
}

acoshl()

long double olb::util::acoshl ( long double arg )

inline

Definition at line 1089 of file omath.h.

{
  return std::acoshl(arg);
  //cuda dose not support this function.
}

acosl()

long double olb::util::acosl ( long double arg )

inline

Definition at line 1035 of file omath.h.

{
  return acos(arg);
  //cuda dose not support this function.
}

References acos().

Here is the call graph for this function:

aligned_to_grid()

template<typename T >

bool olb::util::aligned_to_grid ( const std::vector< T > & vec )

inline

Definition at line 77 of file util.h.

{
  return (aligned_to_x<T>(vec) or
          aligned_to_y<T>(vec) or
          aligned_to_z<T>(vec));
}

References aligned_to_x(), aligned_to_y(), and aligned_to_z().

Here is the call graph for this function:

aligned_to_x()

template<typename T >

bool olb::util::aligned_to_x ( const std::vector< T > & vec )

inline

Definition at line 59 of file util.h.

{
  return (vec[0]!=0 and vec[1]==0 and vec[2]==0);
}

Here is the caller graph for this function:

aligned_to_y()

template<typename T >

bool olb::util::aligned_to_y ( const std::vector< T > & vec )

inline

Definition at line 65 of file util.h.

{
  return (vec[0]==0 and vec[1]!=0 and vec[2]==0);
}

Here is the caller graph for this function:

aligned_to_z()

template<typename T >

bool olb::util::aligned_to_z ( const std::vector< T > & vec )

inline

Definition at line 71 of file util.h.

{
  return (vec[0]==0 and vec[1]==0 and vec[2]!=0);
}

Here is the caller graph for this function:

angleBetweenVectors() [1/2]

template<typename T , bool ensureAngularBounds = true>

T olb::util::angleBetweenVectors	(	const Vector< T, 2 > &	a,
		const Vector< T, 2 > &	b )

Calculates angles between two 2D vectors.

Definition at line 291 of file vectorHelpers.h.

{
  if constexpr(ensureAngularBounds){
    return std::fmod(util::atan2(b[1]*a[0]-b[0]*a[1], a[0]*b[0]+a[1]*b[1]), M_PI);
  } else {
    return util::atan2(b[1]*a[0]-b[0]*a[1], a[0]*b[0]+a[1]*b[1]);
  }
}

References atan2(), and M_PI.

Here is the call graph for this function:

Here is the caller graph for this function:

angleBetweenVectors() [2/2]

template<typename T , bool ensureAngularBounds = true>

Vector< T, 3 > olb::util::angleBetweenVectors	(	const Vector< T, 3 > &	a,
		const Vector< T, 3 > &	b )

Calculates angles between two 3D vectors.

Definition at line 302 of file vectorHelpers.h.

{
  Vector<T,3> angles;
  angles[0] = angleBetweenVectors<T,ensureAngularBounds>(Vector<T,2>(a[1], a[2]), Vector<T,2>(b[1], b[2]));
  angles[1] = angleBetweenVectors<T,ensureAngularBounds>(Vector<T,2>(a[0], a[2]), Vector<T,2>(b[0], b[2]));
  angles[2] = angleBetweenVectors<T,ensureAngularBounds>(Vector<T,2>(a[0], a[1]), Vector<T,2>(b[0], b[1]));
  return angles;
}

References angleBetweenVectors().

Here is the call graph for this function:

approxEqual() [1/2]

template<typename T , typename U = T>

bool olb::util::approxEqual ( T a, U b )

inline

Definition at line 437 of file util.h.

{
  if (a==b) {
    return true;
  }
  if (nearZero(a) && nearZero(b)) {
    return true;
  }
  T EPSILON = std::numeric_limits<T>::epsilon()*4.*util::fabs(a);
  return approxEqual(a,b,EPSILON);
}

References approxEqual(), fabs(), and nearZero().

Here is the call graph for this function:

approxEqual() [2/2]

template<typename T , typename U = T, typename W = T>

bool olb::util::approxEqual ( T a, U b, W epsilon )

inline

Definition at line 428 of file util.h.

{
  if (a==b) {
    return true;
  }
  return nearZero<T>(a - b, epsilon);
}

References nearZero().

Here is the call graph for this function:

Here is the caller graph for this function:

asin() [1/3]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::asin ( const ADf< T, DIM > & a )

inline

Definition at line 596 of file aDiff.h.

{
  ADf<T,DIM> c(std::asin(a._v), a._d);
  T tmp(T(1)/std::sqrt(T(1)-(a._v)*(a._v)));
  c._d*=tmp;
  return c;
}

Here is the caller graph for this function:

asin() [2/3]

template<typename T >

any_platform std::enable_if_t< std::is_floating_point_v< T >, T > olb::util::asin ( T x )

inline

Definition at line 899 of file omath.h.

{
#ifdef __CUDA_ARCH__
  if constexpr (std::is_same_v<T, float>) {
    return ::asinf(x);
  }
  else if constexpr (std::is_same_v<T, double>) {
    return ::asin(x);
  }
  else {
    return ::asin(static_cast<double>(x));
    //libcu++ of cuda supports double and float. You will get warning in device code if you use in e.g. long double.
  }
#else  //__CUDA_ARCH__
  return std::asin(x);
#endif //__CUDA_ARCH__
}

asin() [3/3]

template<typename T >

any_platform std::enable_if_t< std::is_integral_v< T >, double > olb::util::asin ( T x )

inline

Definition at line 918 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::asin(x);
#else  //__CUDA_ARCH__
  return std::asin(x);
#endif //__CUDA_ARCH__
}

asinf() [1/2]

any_platform float olb::util::asinf ( float x )

inline

Definition at line 880 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::asinf(x);
#else  //__CUDA_ARCH__
  return std::asin(x);
#endif //__CUDA_ARCH__
}

asinf() [2/2]

any_platform float olb::util::asinf ( int x )

inline

Definition at line 889 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::asinf(x);
#else  //__CUDA_ARCH__
  return std::asin(x);
#endif //__CUDA_ARCH__
}

asinh() [1/3]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::asinh ( const ADf< T, DIM > & a )

inline

Definition at line 669 of file aDiff.h.

{
  return log( a + sqrt(a*a+1) );
}

References log(), and sqrt().

Here is the call graph for this function:

asinh() [2/3]

template<typename T >

any_platform std::enable_if_t< std::is_floating_point_v< T >, T > olb::util::asinh ( T x )

inline

Definition at line 953 of file omath.h.

{
#ifdef __CUDA_ARCH__
  if constexpr (std::is_same_v<T, float>) {
    return ::asinhf(x);
  }
  else if constexpr (std::is_same_v<T, double>) {
    return ::asinh(x);
  }
  else {
    return ::asinh(static_cast<double>(x));
    //libcu++ of cuda supports double and float. You will get warning in device code if you use in e.g. long double.
  }
#else  //__CUDA_ARCH__
  return std::asinh(x);
#endif //__CUDA_ARCH__
}

asinh() [3/3]

template<typename T >

any_platform std::enable_if_t< std::is_integral_v< T >, double > olb::util::asinh ( T x )

inline

Definition at line 972 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::asinh(x);
#else  //__CUDA_ARCH__
  return std::asinh(x);
#endif //__CUDA_ARCH__
}

asinhf() [1/2]

any_platform float olb::util::asinhf ( float x )

inline

Definition at line 934 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::asinhf(x);
#else  //__CUDA_ARCH__
  return std::asinh(x);
#endif //__CUDA_ARCH__
}

asinhf() [2/2]

any_platform float olb::util::asinhf ( int x )

inline

Definition at line 943 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::asinhf(x);
#else  //__CUDA_ARCH__
  return std::asinh(x);
#endif //__CUDA_ARCH__
}

asinhl()

long double olb::util::asinhl ( long double arg )

inline

Definition at line 981 of file omath.h.

{
  return std::asinhl(arg);
  //cuda dose not support this function.
}

asinl()

long double olb::util::asinl ( long double arg )

inline

Definition at line 927 of file omath.h.

{
  return asin(arg);
  //cuda dose not support this function.
}

References asin().

Here is the call graph for this function:

assign() [1/2]

template<typename T >

std::vector< T > olb::util::assign	(	T	a,
		T	b )

Definition at line 411 of file vectorHelpers.h.

{
  std::vector<T> v1;
  v1.push_back(a);
  v1.push_back(b);
  return v1;
}

assign() [2/2]

template<typename T >

std::vector< T > olb::util::assign	(	T	a,
		T	b,
		T	c )

Definition at line 420 of file vectorHelpers.h.

{
  std::vector<T> v1;
  v1.push_back(a);
  v1.push_back(b);
  v1.push_back(c);
  return v1;
}

atan() [1/3]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::atan ( const ADf< T, DIM > & a )

inline

Definition at line 614 of file aDiff.h.

{
  ADf<T,DIM> c(std::atan(a._v), a._d);
  T tmp(T(1)/(T(1)+(a._v)*(a._v)));
  c._d*=tmp;
  return c;
}

Here is the caller graph for this function:

atan() [2/3]

template<typename T >

any_platform std::enable_if_t< std::is_floating_point_v< T >, T > olb::util::atan ( T x )

inline

Definition at line 1115 of file omath.h.

{
#ifdef __CUDA_ARCH__
  if constexpr (std::is_same_v<T, float>) {
    return ::atanf(x);
  }
  else if constexpr (std::is_same_v<T, double>) {
    return ::atan(x);
  }
  else {
    return ::atan(static_cast<double>(x));
    //libcu++ of cuda supports double and float. You will get warning in device code if you use in e.g. long double.
  }
#else  //__CUDA_ARCH__
  return std::atan(x);
#endif //__CUDA_ARCH__
}

atan() [3/3]

template<typename T >

any_platform std::enable_if_t< std::is_integral_v< T >, double > olb::util::atan ( T x )

inline

Definition at line 1134 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::atan(x);
#else  //__CUDA_ARCH__
  return std::atan(x);
#endif //__CUDA_ARCH__
}

atan2() [1/7]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::atan2 ( const ADf< T, DIM > & y, const ADf< T, DIM > & x )

inline

Definition at line 641 of file aDiff.h.

{
  ADf<T,DIM> c(std::atan2(y._v, x._v));
  T tmpA(x._v / (x._v*x._v + y._v*y._v));
  T tmpB(-y._v / (x._v*x._v + y._v*y._v));
  c._d = tmpA*y._d + tmpB*x._d;
  return c;
}

atan2() [2/7]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::atan2 ( const ADf< T, DIM > & y, const T & x )

inline

Definition at line 632 of file aDiff.h.

{
  ADf<T,DIM> c(std::atan2(y._v, x));
  T tmpA(x / (x*x + y._v*y._v));
  c._d = tmpA*y._d;
  return c;
}

atan2() [3/7]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::atan2 ( const T & y, const ADf< T, DIM > & x )

inline

Definition at line 623 of file aDiff.h.

{
  ADf<T,DIM> c(std::atan2(y, x._v));
  T tmpB(-y / (x._v*x._v + y*y));
  c._d = tmpB*x._d;
  return c;
}

Here is the caller graph for this function:

atan2() [4/7]

template<typename T , typename S >

any_platform std::enable_if_t< std::is_integral_v< S > &&std::is_floating_point_v< T >, T > olb::util::atan2 ( T x, S y )

inline

Definition at line 1175 of file omath.h.

{
#ifdef __CUDA_ARCH__
  if constexpr (std::is_same_v<T, float>) {
    return ::atan2f(x, y);
  }
  else if constexpr (std::is_same_v<T, double>) {
    return ::atan2(x, y);
  }
  else {
    return ::atan2(static_cast<double>(x), y);
    //libcu++ of cuda supports double and float. You will get warning in device code if you use in e.g. long double.
  }
#else  //__CUDA_ARCH__
  return std::atan2(x, y);
#endif //__CUDA_ARCH__
}

atan2() [5/7]

template<typename T , typename S >

any_platform std::enable_if_t< std::is_integral_v< T > &&std::is_floating_point_v< S >, S > olb::util::atan2 ( T x, S y )

inline

Definition at line 1196 of file omath.h.

{
#ifdef __CUDA_ARCH__
  if constexpr (std::is_same_v<S, float>) {
    return ::atan2f(x, y);
  }
  else if constexpr (std::is_same_v<S, double>) {
    return ::atan2(x, y);
  }
  else {
    return ::atan2(x, static_cast<double>(y));
    //libcu++ of cuda supports double and float. You will get warning in device code if you use in e.g. long double.
  }
#else  //__CUDA_ARCH__
  return std::atan2(x, y);
#endif //__CUDA_ARCH__
}

atan2() [6/7]

template<typename T , typename S >

any_platform std::enable_if_t< std::is_integral_v< T > &&std::is_integral_v< S >, double > olb::util::atan2 ( T x, S y )

inline

Definition at line 1216 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::atan2(x, y);
#else  //__CUDA_ARCH__
  return std::atan2(x, y);
#endif //__CUDA_ARCH__
}

atan2() [7/7]

template<typename T , typename S >

any_platform auto olb::util::atan2 ( T x, S y ) -> std::enable_if_t<std::is_floating_point_v<T> && std::is_floating_point_v<S>, decltype(std::atan2(x, y))>

inline

Definition at line 1151 of file omath.h.

{
#ifdef __CUDA_ARCH__
  if constexpr (std::is_same_v<T, float> && std::is_same_v<S, float>) {
    return ::atan2f(x, y);
  }
  else if constexpr (std::is_same_v<T, double> && std::is_same_v<S, double>) {
    return ::atan2(x, y);
  }
  else {
    return ::atan2(static_cast<double>(x), static_cast<double>(y));
    //libcu++ of cuda supports double and float. You will get warning in device code if you use in e.g. long double.
  }
#else  // __CUDA_ARCH__
  return std::atan2(x, y);
#endif // __CUDA_ARCH__
}

atan2f() [1/2]

any_platform float olb::util::atan2f ( float base, float exp )

inline

Definition at line 1225 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::atan2f(base, exp);
#else  //__CUDA_ARCH__
  return std::atan2(base, exp);
#endif //__CUDA_ARCH__
}

References exp().

Here is the call graph for this function:

atan2f() [2/2]

any_platform float olb::util::atan2f ( int base, int exp )

inline

Definition at line 1234 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::atan2f(base, exp);
#else  //__CUDA_ARCH__
  return std::atan2(base, exp);
#endif //__CUDA_ARCH__
}

References exp().

Here is the call graph for this function:

atanf() [1/2]

any_platform float olb::util::atanf ( float x )

inline

Definition at line 1096 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::atanf(x);
#else  //__CUDA_ARCH__
  return std::atan(x);
#endif //__CUDA_ARCH__
}

atanf() [2/2]

any_platform float olb::util::atanf ( int x )

inline

Definition at line 1105 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::atanf(x);
#else  //__CUDA_ARCH__
  return std::atan(x);
#endif //__CUDA_ARCH__
}

atanh() [1/3]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::atanh ( const ADf< T, DIM > & a )

inline

Definition at line 689 of file aDiff.h.

{
  if (std::abs(a._v) < 1) {
    return 0.5 * log( (1+a) / (1-a) );
  }
  else {
    ADf<T,DIM> c;
    c._v = std::atanh(a._v);
    c._d = ( std::numeric_limits<T>::quiet_NaN() );
    return c;
  }
}

References log().

Here is the call graph for this function:

Here is the caller graph for this function:

atanh() [2/3]

template<typename T >

any_platform std::enable_if_t< std::is_floating_point_v< T >, T > olb::util::atanh ( T x )

inline

Definition at line 1263 of file omath.h.

{
#ifdef __CUDA_ARCH__
  if constexpr (std::is_same_v<T, float>) {
    return ::atanhf(x);
  }
  else if constexpr (std::is_same_v<T, double>) {
    return ::atanh(x);
  }
  else {
    return ::atanh(static_cast<double>(x));
    //libcu++ of cuda supports double and float. You will get warning in device code if you use in e.g. long double.
  }
#else  //__CUDA_ARCH__
  return std::atanh(x);
#endif //__CUDA_ARCH__
}

atanh() [3/3]

template<typename T >

any_platform std::enable_if_t< std::is_integral_v< T >, double > olb::util::atanh ( T x )

inline

Definition at line 1282 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::atanh(x);
#else  //__CUDA_ARCH__
  return std::atanh(x);
#endif //__CUDA_ARCH__
}

atanhf() [1/2]

any_platform float olb::util::atanhf ( float x )

inline

Definition at line 1244 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::atanhf(x);
#else  //__CUDA_ARCH__
  return std::atanh(x);
#endif //__CUDA_ARCH__
}

atanhf() [2/2]

any_platform float olb::util::atanhf ( int x )

inline

Definition at line 1253 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::atanhf(x);
#else  //__CUDA_ARCH__
  return std::atanh(x);
#endif //__CUDA_ARCH__
}

atanhl()

long double olb::util::atanhl ( long double arg )

inline

Definition at line 1291 of file omath.h.

{
  return atanh(arg);
  //cuda dose not support this function.
}

References atanh().

Here is the call graph for this function:

atanl()

long double olb::util::atanl ( long double arg )

inline

Definition at line 1143 of file omath.h.

{
  return atan(arg);
  //cuda dose not support this function.
}

References atan().

Here is the call graph for this function:

average()

template<typename T , unsigned Size>

T olb::util::average

(

const Vector< T, Size > &

a

)

computes the average of all elements

Definition at line 206 of file vectorHelpers.h.

{
  T sum = a[0];
  for (unsigned int iDim=1; iDim < Size; ++iDim) {
    sum += a[iDim];
  }
  return sum/Size;
}

Here is the caller graph for this function:

bisectDistance()

template<typename S , unsigned D, typename F1 , typename F2 >

bool olb::util::bisectDistance	(	S &	distance,
		const Vector< S, D > &	origin,
		const Vector< S, D > &	direction,
		S	pitch,
		S	precision,
		F1	isInside,
		F2	isInsideBoundingBox )

Using a bisect to find the unsigned distance (false if distance was not found, true if distance was found)

Parameters

distance	computed distance from origin to surface in direction
direction	is saved here
origin	the point we want to calculate the distance from
direction	the considered direction
pitch	a first guess for the distance, must be > 0 (if origin is inside origin + normalize(direction) * pitch should be outside and if origin is outside origin + normalize(direction) * pitch should be inside)
precision	when the change of the found distance reaches the defined precision, the iteration stops
isInside	function that defines if a point is inside or outside a geometry (usually the ()-operator of an Indicator)
isInsideBoundingBox	function that defines if a point is inside the enclosing bounding box (maybe needs at least one extra layer between geometry surface and bounding box surface)

Definition at line 168 of file indicatorBase.h.

{
  distance = S(0);
  Vector<S,D> dir = normalize(direction);
 
  // Check if origin is on surface
  bool isInsideDistance = isInside(origin + 5*precision*dir);
  bool isInsideOppDistance = isInside(origin - 5*precision*dir);
  if (isInsideDistance == !isInsideOppDistance) {
    return true;
  }
 
  Vector<S,D> startPoint = origin;
  S fixedDistance = S(0);
  S oldDistance = distance;
  std::function<Vector<S,D>()> calcCurrPoint = [&startPoint, &pitch, &dir]() {
    return startPoint + pitch * dir;
  };
  Vector<S,D> currPoint = calcCurrPoint();
 
  bool originValue = isInside(startPoint);
  bool currentValue = isInside(currPoint);
 
  // if aforementioned requirement for pitch is not given, try to find a proper pitch
  while (originValue == currentValue) {
    pitch *= 1.5;
    currPoint = calcCurrPoint();
    currentValue = isInside(currPoint);
 
    // if both points are outside the bounding box return false indicating that no distance was found
    if (!currentValue && !isInsideBoundingBox(startPoint) && !isInsideBoundingBox(currPoint)) {
      return false;
    }
  }
 
  for (unsigned iD=0; iD<D; ++iD) {
    if (!std::isfinite(currPoint[iD])) {
      return false;
    }
  }
 
  // if we have one point inside and another outside, we can keep halving the line from origin to currPoint until we find the wanted precision
  distance = norm(startPoint - currPoint);
  while ( util::abs(distance - oldDistance) > precision ) {
    pitch *= 0.5;
    currPoint = calcCurrPoint();
 
    // set distances
    oldDistance = distance;
    distance = norm(startPoint - currPoint);
 
    // if both points are outside or inside run take result of same function with different start point (= current point)
    currentValue = isInside(currPoint);
    if (currentValue == originValue) {
      startPoint = currPoint;
      fixedDistance += distance;
      // convert distances to distance to new start point
      oldDistance -= distance;
      distance = S(0);
    }
  }
  distance += fixedDistance;
 
  return true;
}

References abs(), distance(), norm(), and normalize().

Here is the call graph for this function:

calculateInverseRotationMatrix()

template<typename T , unsigned D>

Vector< T, utilities::dimensions::convert< D >::matrix > olb::util::calculateInverseRotationMatrix

(

const Vector< T, utilities::dimensions::convert< D >::rotation > &

angle

)

Definition at line 182 of file geometricOperations.h.

{
  return invertRotationMatrix<T, D>(calculateRotationMatrix<T, D>(angle));
}

References calculateRotationMatrix(), and invertRotationMatrix().

Here is the call graph for this function:

Here is the caller graph for this function:

calculateLocalVelocity()

template<typename T , unsigned D>

Vector< T, D > olb::util::calculateLocalVelocity ( const Vector< T, D > & rotationCenter, const Vector< T, D > & velocity, const Vector< T, utilities::dimensions::convert< D >::rotation > & angularVelocity, const Vector< T, D > & position )

constexpr

Calculate local velocity.

Definition at line 239 of file geometricOperations.h.

{
  if constexpr (D == 2) {
    // two dimensions: u = U + w x r = (Ux, Uy, 0) + (0,0,w) x (X,Y,0) = (Ux, Uy, 0) + (-w*Y, w*X, 0)
    return Vector<T, 2>(
        velocity[0] - angularVelocity[0] * (position[1] - rotationCenter[1]),
        velocity[1] + angularVelocity[0] * (position[0] - rotationCenter[0]));
  }
  else {
    // three dimensions: u = U + w x r = (Ux, Uy, Uz) + (wx,wy,wz) x (X,Y,Z) = (Ux, Uy, Uz) + (wy*Z-wz*Y, wz*X-wx*Z, wx*Y-wy*X)
    return velocity +
           crossProduct3D(angularVelocity, position - rotationCenter);
  }
  __builtin_unreachable();
}

References olb::crossProduct3D().

Here is the call graph for this function:

Here is the caller graph for this function:

calculateRotationMatrix()

template<typename T , unsigned D>

Vector< T, utilities::dimensions::convert< D >::matrix > olb::util::calculateRotationMatrix

(

const Vector< T, utilities::dimensions::convert< D >::rotation > &

angle

)

Definition at line 69 of file geometricOperations.h.

{
  Vector<T, utilities::dimensions::convert<D>::matrix> rotationMatrix;
 
  if constexpr (D == 2) {
    T const cos = util::cos(angle[0]);
    T const sin = util::sin(angle[0]);
 
    // row 1
    rotationMatrix[0] = cos;
    rotationMatrix[1] = -sin;
    // row 2
    rotationMatrix[2] = sin;
    rotationMatrix[3] = cos;
  }
  else {
    T const cos[3] = {util::cos(angle[0]), util::cos(angle[1]),
                      util::cos(angle[2])};
    T const sin[3] = {util::sin(angle[0]), util::sin(angle[1]),
                      util::sin(angle[2])};
 
    // |x0| / 0 1 2 \   |x1|
    // |y0| | 3 4 5 | = |x1|
    // |z0| \ 6 7 8 /   |x1|
 
    // row 1
    rotationMatrix[0] = cos[1] * cos[2];
    rotationMatrix[1] = sin[0] * sin[1] * cos[2] - cos[0] * sin[2];
    rotationMatrix[2] = cos[0] * sin[1] * cos[2] + sin[0] * sin[2];
    // row 2
    rotationMatrix[3] = cos[1] * sin[2];
    rotationMatrix[4] = sin[0] * sin[1] * sin[2] + cos[0] * cos[2];
    rotationMatrix[5] = cos[0] * sin[1] * sin[2] - sin[0] * cos[2];
    // row 3
    rotationMatrix[6] = -sin[1];
    rotationMatrix[7] = sin[0] * cos[1];
    rotationMatrix[8] = cos[0] * cos[1];
  }
 
  return rotationMatrix;
}

References cos(), and sin().

Here is the call graph for this function:

Here is the caller graph for this function:

ceil() [1/4]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::ceil ( const ADf< T, DIM > & a )

inline

Definition at line 900 of file aDiff.h.

{
  // Similar to floor
  ADf<T,DIM> c (std::ceil(a._v));
  if (a._v == c._v) {
#ifdef AdWarnings
    std::cout << "ADf WARNING: ceil(Adf) - ceil evaluated at non-differentiable point" << std::endl;
#endif
    for (unsigned i = 0; i < DIM; ++i) {
      c._d[i] = (a.d(i) == 0) ? T(0) : std::numeric_limits<T>::quiet_NaN();
    }
  }
  return c;
}

Here is the caller graph for this function:

ceil() [2/4]

template<typename T , unsigned Size>

Vector< T, Size > olb::util::ceil

(

const Vector< T, Size > &

a

)

applies ceil to each component of a vector

Definition at line 184 of file vectorHelpers.h.

{
  Vector<T,Size> out;
  for (unsigned int iDim=0; iDim < Size; ++iDim) {
    out[iDim] = util::ceil(a[iDim]);
  }
  return out;
}

References ceil().

Here is the call graph for this function:

ceil() [3/4]

template<typename T >

any_platform std::enable_if_t< std::is_floating_point_v< T >, T > olb::util::ceil ( T x )

inline

Definition at line 1372 of file omath.h.

{
#ifdef __CUDA_ARCH__
  if constexpr (std::is_same_v<T, float>) {
    return ::ceilf(x);
  }
  else if constexpr (std::is_same_v<T, double>) {
    return ::ceil(x);
  }
  else {
    return ::ceil(static_cast<double>(x));
    //libcu++ of cuda supports double and float. You will get warning in device code if you use in e.g. long double.
  }
#else  //__CUDA_ARCH__
  return std::ceil(x);
#endif //__CUDA_ARCH__
}

ceil() [4/4]

template<typename T >

any_platform std::enable_if_t< std::is_integral_v< T >, double > olb::util::ceil ( T x )

inline

Definition at line 1391 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::ceil(x);
#else  //__CUDA_ARCH__
  return std::ceil(x);
#endif //__CUDA_ARCH__
}

ceilf() [1/3]

template<unsigned DIM>

ADf< float, DIM > olb::util::ceilf ( const ADf< float, DIM > & a )

inline

Definition at line 916 of file aDiff.h.

{
  return ceil(a);
}

References ceil().

Here is the call graph for this function:

ceilf() [2/3]

any_platform float olb::util::ceilf ( float x )

inline

Definition at line 1353 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::ceilf(x);
#else  //__CUDA_ARCH__
  return std::ceil(x);
#endif //__CUDA_ARCH__
}

ceilf() [3/3]

any_platform float olb::util::ceilf ( int x )

inline

Definition at line 1362 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::ceilf(x);
#else  //__CUDA_ARCH__
  return std::ceil(x);
#endif //__CUDA_ARCH__
}

ceill() [1/2]

template<unsigned DIM>

ADf< long double, DIM > olb::util::ceill ( const ADf< long double, DIM > & a )

inline

Definition at line 922 of file aDiff.h.

{
  return ceil(a);
}

References ceil().

Here is the call graph for this function:

ceill() [2/2]

long double olb::util::ceill ( long double arg )

inline

Definition at line 1400 of file omath.h.

{
  return ceil(arg);
  //cuda dose not support this function.
}

References ceil().

Here is the call graph for this function:

closeToZero()

template<std::integral T>

any_platform bool olb::util::closeToZero

(

T

x

)

Definition at line 1614 of file omath.h.

{
  return fabs(x) <= std::numeric_limits<T>::epsilon();
}

References fabs().

Here is the call graph for this function:

contained() [1/2]

bool olb::util::contained ( int x, int y, int x0, int x1, int y0, int y1 )

inline

Definition at line 115 of file util.h.

{
  return x>=x0 && x<=x1 &&
         y>=y0 && y<=y1;
}

Here is the caller graph for this function:

contained() [2/2]

bool olb::util::contained ( int x, int y, int z, int x0, int x1, int y0, int y1, int z0, int z1 )

inline

Definition at line 122 of file util.h.

{
  return x>=x0 && x<=x1 &&
         y>=y0 && y<=y1 &&
         z>=z0 && z<=z1;
}

copy3()

template<class T >

void olb::util::copy3 ( T c[], const T a[] )

inline

Definition at line 69 of file vectorHelpers.h.

{
  for (unsigned i=0; i<3; i++) {
    c[i] = a[i];
  }
}

copyAs()

template<typename T , typename S , template< typename > typename C>

C< T > olb::util::copyAs

(

const C< S > &

input

)

copy vector with specified typecast

Definition at line 72 of file adHelpers.h.

                               {
  C<T> result = ContainerCreator<C<T>>::create(input.size());
 
  for(std::size_t it = 0; it < input.size(); ++it) {
    result[it] = T(input[it]);
  }
  return result;
}

Here is the caller graph for this function:

copyDerivatives()

template<typename T , typename TAD >

void olb::util::copyDerivatives	(	T *	target,
		const TAD *	source,
		int	length )

Copy the derivatives from an ADf array into an array.

Returns

target[j*dim+i] = source[j].d(i) = d/dx_i (s_j)

Parameters

length

= length of the array

Definition at line 61 of file adHelpers.h.

                                                               {
  for (int j = 0; j < length; ++j) {
    for (unsigned i = 0; i < TAD::dim; ++i) {
      target[j*(TAD::dim)+i] = source[j].d(i);
    }
  }
}

Here is the caller graph for this function:

copyN() [1/2]

template<class S , class T >

void olb::util::copyN ( S c[], const T a[], const unsigned dim )

inline

Definition at line 61 of file vectorHelpers.h.

{
  for (unsigned i=0; i<dim; i++) {
    c[i] = a[i];
  }
}

copyN() [2/2]

template<class T >

void olb::util::copyN ( T c[], const T a[], const unsigned dim )

inline

Definition at line 53 of file vectorHelpers.h.

{
  for (unsigned i=0; i<dim; i++) {
    c[i] = a[i];
  }
}

Here is the caller graph for this function:

cos() [1/3]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::cos ( const ADf< T, DIM > & a )

inline

Definition at line 578 of file aDiff.h.

{
  ADf<T,DIM> c(std::cos(a._v), a._d);
  T tmp(-std::sin(a._v));
  c._d*=tmp;
  return c;
}

Here is the caller graph for this function:

cos() [2/3]

template<typename T >

any_platform std::enable_if_t< std::is_floating_point_v< T >, T > olb::util::cos ( T x )

inline

Definition at line 683 of file omath.h.

{
#ifdef __CUDA_ARCH__
  if constexpr (std::is_same_v<T, float>) {
    return ::cosf(x);
  }
  else if constexpr (std::is_same_v<T, double>) {
    return ::cos(x);
  }
  else {
    return ::cos(static_cast<double>(x));
    //libcu++ of cuda supports double and float. You will get warning in device code if you use in e.g. long double.
  }
#else  //__CUDA_ARCH__
  return std::cos(x);
#endif //__CUDA_ARCH__
}

cos() [3/3]

template<typename T >

any_platform std::enable_if_t< std::is_integral_v< T >, double > olb::util::cos ( T x )

inline

Definition at line 702 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::cos(x);
#else  //__CUDA_ARCH__
  return std::cos(x);
#endif //__CUDA_ARCH__
}

cosf() [1/2]

any_platform float olb::util::cosf ( float x )

inline

Definition at line 664 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::cosf(x);
#else  //__CUDA_ARCH__
  return std::cos(x);
#endif //__CUDA_ARCH__
}

cosf() [2/2]

any_platform float olb::util::cosf ( int x )

inline

Definition at line 673 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::cosf(x);
#else  //__CUDA_ARCH__
  return std::cos(x);
#endif //__CUDA_ARCH__
}

cosh() [1/3]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::cosh ( const ADf< T, DIM > & a )

inline

Definition at line 657 of file aDiff.h.

{
  return 0.5*(exp(a)+exp(-a));
}

References exp().

Here is the call graph for this function:

Here is the caller graph for this function:

cosh() [2/3]

template<typename T >

any_platform std::enable_if_t< std::is_floating_point_v< T >, T > olb::util::cosh ( T x )

inline

Definition at line 738 of file omath.h.

{
#ifdef __CUDA_ARCH__
  if constexpr (std::is_same_v<T, float>) {
    return ::coshf(x);
  }
  else if constexpr (std::is_same_v<T, double>) {
    return ::cosh(x);
  }
  else {
    return ::cosh(static_cast<double>(x));
    //libcu++ of cuda supports double and float. You will get warning in device code if you use in e.g. long double.
  }
#else  //__CUDA_ARCH__
  return std::cosh(x);
#endif //__CUDA_ARCH__
}

cosh() [3/3]

template<typename T >

any_platform std::enable_if_t< std::is_integral_v< T >, double > olb::util::cosh ( T x )

inline

Definition at line 757 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::cosh(x);
#else  //__CUDA_ARCH__
  return std::cosh(x);
#endif //__CUDA_ARCH__
}

coshf() [1/2]

any_platform float olb::util::coshf ( float x )

inline

Definition at line 719 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::coshf(x);
#else  //__CUDA_ARCH__
  return std::cosh(x);
#endif //__CUDA_ARCH__
}

coshf() [2/2]

any_platform float olb::util::coshf ( int x )

inline

Definition at line 728 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::coshf(x);
#else  //__CUDA_ARCH__
  return std::cosh(x);
#endif //__CUDA_ARCH__
}

coshl()

long double olb::util::coshl ( long double arg )

inline

Definition at line 766 of file omath.h.

{
  return cosh(arg);
  //libcu++ of cuda dose not support long double. You will get warning in device code if you use.
}

References cosh().

Here is the call graph for this function:

cosl()

long double olb::util::cosl ( long double arg )

inline

Definition at line 711 of file omath.h.

{
  return cos(arg);
  //libcu++ of cuda dose not support long double. You will get warning in device code if you use.
}

References cos().

Here is the call graph for this function:

createTimer()

template<typename T , typename DESCRIPTOR >

Timer< T > * olb::util::createTimer	(	XMLreader &	param,
		const UnitConverter< T, DESCRIPTOR > &	converter,
		size_t	numLatticePoints )

Definition at line 260 of file timer.hh.

{
  OstreamManager clout(std::cout,"createTimer");
 
  // initialize parameters with some default values
  T physMaxT = T();
  T physStartT = T();
  int printModeSummary = 0;
 
  // fetch xml Data and error handling
  if ( ! param["Application"]["PhysParameters"]["PhysMaxTime"].read(physMaxT) ) {
    if ( ! param["Application"]["PhysParam"]["MaxTime"].read(physStartT) ) {
      clout << "PhysMaxTime not found" << std::endl;
    }
    else {
      clout << "Application::PhysParam::MaxTime needs to be renamed to Application::PhysParameters::PhysMaxTime" << std::endl;
    }
  }
  // read the variable for the mode of printSummary
  param.readOrWarn<int>("Output","Timer","PrintModeSummary", printModeSummary,true,false,false);
 
//  if ( ! param["Application"]["PhysParam"]["MaxStartTime"].read(physStartT) ) {
//    clout << "PhysStartTime not found" << std::endl;
//  }
 
  // variable processing according to the constructor
  int maxT = converter.getLatticeTime(physMaxT) + converter.getLatticeTime(physStartT);
 
  //return some default values that produce reasonable output (e.g.
  // zero); in best case there should be no output at all (TODO)
  return new Timer<T>(maxT, numLatticePoints, printModeSummary);
}

References olb::UnitConverter< T, DESCRIPTOR >::getLatticeTime(), and olb::XMLreader::readOrWarn().

Here is the call graph for this function:

crossSum()

template<typename K >

K olb::util::crossSum

(

K

k

)

Compute cross sum of an integer.

Template Parameters

K	integer type

Parameters

k	an integer

Returns

cross sum

Definition at line 103 of file calc.h.

                {
  if (k < 0) {
    k = -k;
  }
  K res (0);
  while (k > 0) {
    res += k % 10;
    k /= 10;
  }
  return res;
}

cube()

template<typename T >

any_platform T olb::util::cube

(

T

arg

)

Definition at line 138 of file util.h.

{
  return arg*arg*arg;
}

Here is the caller graph for this function:

degreeToRadian() [1/2]

template<typename T , unsigned D>

decltype(Vector< decltype(util::sqrt(T())), D >()) olb::util::degreeToRadian

(

const Vector< T, D > &

angle

)

Definition at line 42 of file geometricOperations.h.

{
  constexpr BaseType<decltype(util::sqrt(T()))> conversionFactor = M_PI / 180.;
  return conversionFactor * angle;
}

References M_PI, and sqrt().

Here is the call graph for this function:

Here is the caller graph for this function:

degreeToRadian() [2/2]

template<typename T >

decltype(util::sqrt(T())) olb::util::degreeToRadian

(

T

angle

)

Definition at line 49 of file geometricOperations.h.

{
  return degreeToRadian(Vector<T, 1>(angle))[0];
}

References degreeToRadian().

Here is the call graph for this function:

densityFromPressure()

template<typename T , typename DESCRIPTOR >

any_platform T olb::util::densityFromPressure

(

T

latticePressure

)

compute lattice density from lattice pressure

Definition at line 386 of file util.h.

{
  // rho = p / c_s^2 + 1
  return latticePressure * descriptors::invCs2<T,DESCRIPTOR>() + 1.0;
}

References olb::descriptors::invCs2().

Here is the call graph for this function:

Here is the caller graph for this function:

derivativeFAD() [1/3]

template<unsigned sourceDIM, typename S , typename F >

auto olb::util::derivativeFAD	(	F	f,
		const S *	input )

Compute derivatives of a function f: S^sourceDIM -> T via forward AD Signature is "V f(U*)" so f is expected to return a single value.

It must be (captured by) a lambda function that handles arbitrary types, so "auto f(auto x)" is to be written.

Definition at line 128 of file adHelpers.h.

                                         {
  using SAD = ADf<S,sourceDIM>;
  using T = decltype(f(input));
  using TAD = ADf<T,sourceDIM>;
 
  SAD inputAD[sourceDIM];
  util::copyN(inputAD, input, sourceDIM);
  util::iniDiagonal(inputAD, sourceDIM);
 
  TAD resultAD = f(inputAD);
  T* result = new T[sourceDIM];
  copyDerivatives(result, &resultAD, 1);
  return result;
}

References copyDerivatives(), copyN(), and iniDiagonal().

Here is the call graph for this function:

derivativeFAD() [2/3]

template<typename S , typename F >

auto olb::util::derivativeFAD	(	F	f,
		const S	input )

Compute derivatives of a function f: S -> T via forward AD Signature is "V f(U)" so f is expected to accept and return a single value.

It must be (captured by) a lambda function that handles arbitrary types, so "auto f(auto x)" is to be written.

Definition at line 115 of file adHelpers.h.

                                        {
  ADf<S,1> inputAD = input;
  inputAD.setDiffVariable(0);
 
  return f(inputAD).d(0);
}

References olb::util::ADf< T, DIM >::setDiffVariable().

Here is the call graph for this function:

derivativeFAD() [3/3]

template<unsigned sourceDIM, typename T , typename S , typename F >

void olb::util::derivativeFAD	(	F	f,
		T *	output,
		const S *	input,
		unsigned	targetDIM )

Compute derivatives of a function f: S^sourceDIM -> T^targetDIM via forward AD Signature of f is "void f(V*, U*)", it is expected to modify the first argument in-place.

f must be (captured by) a lambda function that handles arbitrary types, so "void f(auto y, auto x)" is to be written.

Definition at line 150 of file adHelpers.h.

                                                                        {
  using SAD = ADf<S,sourceDIM>;
  using TAD = ADf<T,sourceDIM>;
 
  SAD inputAD[sourceDIM];
  util::copyN(inputAD, input, sourceDIM);
  util::iniDiagonal(inputAD, sourceDIM);
  TAD outputAD[targetDIM];
 
  f(outputAD, inputAD);
  copyDerivatives(output, outputAD, targetDIM);
  return;
}

References copyDerivatives(), copyN(), and iniDiagonal().

Here is the call graph for this function:

determinant() [1/4]

template<typename T >

auto olb::util::determinant ( const Matrix< T, 2, 2 > & m )

constexpr

Definition at line 143 of file matrix.h.

{
  return determinant<T>(m[0], m[1]);
}

References determinant().

Here is the call graph for this function:

Here is the caller graph for this function:

determinant() [2/4]

template<typename T >

auto olb::util::determinant ( const Matrix< T, 3, 3 > & m )

constexpr

Definition at line 149 of file matrix.h.

{
  return determinant<T>(m[0], m[1], m[2]);
}

References determinant().

Here is the call graph for this function:

determinant() [3/4]

template<typename T >

T olb::util::determinant ( const Vector< T, 2 > & v0, const Vector< T, 2 > & v1 )

constexpr

Definition at line 312 of file vectorHelpers.h.

{
  return crossProduct2D(v0, v1);
}

References olb::crossProduct2D().

Here is the call graph for this function:

determinant() [4/4]

template<typename T >

T olb::util::determinant ( const Vector< T, 3 > & v0, const Vector< T, 3 > & v1, const Vector< T, 3 > & v2 )

constexpr

Definition at line 318 of file vectorHelpers.h.

{
  return v0[0]*v1[1]*v2[2] + v1[0]*v2[1]*v0[2] + v2[0]*v0[1]*v1[2]
    - v0[2]*v1[1]*v2[0] - v1[2]*v2[1]*v0[0] - v2[2]*v0[1]*v1[0];
}

distance() [1/3]

template<typename S , unsigned D, typename F1 , typename F2 >

bool olb::util::distance	(	S &	distance,
		const Vector< S, D > &	origin,
		const Vector< S, D > &	direction,
		S	precision,
		F1	sdf,
		F2	isInsideBoundingBox,
		const unsigned	maxIt = 1e6 )

Definition at line 95 of file indicatorBase.h.

{
  S signedDistance{sdf(origin)};
  Vector<S,D> currPos{origin};
  const Vector<S,D> dir{util::sign(signedDistance) * normalize(direction)};
 
  if (util::fabs(signedDistance) <= precision) {
    distance = util::fabs(signedDistance);
    return true;
  }
 
  distance = S{0};
  for(unsigned i=0; util::fabs(signedDistance) > precision && i<maxIt; ++i) {
    distance += signedDistance;
    currPos += signedDistance * dir;
    signedDistance = sdf(currPos);
    if (!isInsideBoundingBox(currPos)) {
      distance = S{0};
      return false;
    }
  }
 
  distance = util::fabs(distance);
  return true;
}

References distance(), fabs(), normalize(), and sign().

Here is the call graph for this function:

distance() [2/3]

template<typename S , unsigned D, typename F1 , typename F2 >

bool olb::util::distance	(	S &	distance,
		const Vector< S, D > &	origin,
		const Vector< S, D > &	direction,
		S	precision,
		S	pitch,
		F1	isInside,
		F2	isInsideBoundingBox )

Definition at line 36 of file indicatorBase.h.

{
  // Check if point is on surface
  bool isInsideDistance;
  bool isInsideOppDistance;
  Vector<S,D> currentPoint = origin + 10*precision*direction;
  isInside(&isInsideDistance, currentPoint.data());
  currentPoint = origin - 10*precision*direction;
  isInside(&isInsideOppDistance, currentPoint.data());
  if (isInsideDistance == !isInsideOppDistance) {
    distance = 0;
    return true;
  }
 
  bool originValue;
  bool currentValue;
 
  isInside(&originValue, origin.data());
 
  // start at origin and move into given direction
  currentPoint = origin;
  currentValue = originValue;
 
  while (currentValue == originValue && isInsideBoundingBox(currentPoint)) {
    currentPoint += direction;
    // update currentValue until the first point on the other side (inside/outside) is found
    isInside(&currentValue, currentPoint.data());
  }
 
  // return false if no point was found in given direction
  if (!isInsideBoundingBox(currentPoint) && !originValue) {
    return false;
  }
 
 
  while (pitch >= precision) {
    if (!isInsideBoundingBox(currentPoint) && originValue) {
      currentPoint -= pitch * direction;
      pitch *= 0.5;
    }
    else {
      isInside(&currentValue, currentPoint.data());
      if (currentValue == originValue) {
        currentPoint += pitch * direction;
        pitch *= 0.5;
      }
      else {
        currentPoint -= pitch * direction;
        pitch *= 0.5;
      }
    }
  }
 
  distance = norm(currentPoint - origin);
  return true;
}

References olb::Vector< T, Size >::data(), distance(), and norm().

Here is the call graph for this function:

Here is the caller graph for this function:

distance() [3/3]

template<typename S , unsigned D, bool normalizeDirection = true>

bool olb::util::distance	(	S &	distance,
		const Vector< S, D > &	origin,
		const Vector< S, D > &	direction,
		S	precision,
		std::function< S(const Vector< S, D > &)>	sdf,
		S	maxDistance,
		const unsigned	maxIt = 1e6 )

Definition at line 123 of file indicatorBase.h.

{
  S signedDistance{sdf(origin)};
  Vector<S,D> currPos{origin};
  Vector<S,D> dir;
  if constexpr(normalizeDirection) {
    dir = util::sign(signedDistance) * normalize(direction);
  }
  else {
    dir = util::sign(signedDistance) * direction;
  }
 
  if (util::fabs(signedDistance) <= precision) {
    distance = util::fabs(signedDistance);
    return true;
  }
 
  distance = S{0};
  for(unsigned i=0; util::fabs(signedDistance) > precision && i<maxIt; ++i) {
    distance += signedDistance;
    currPos += signedDistance * dir;
    signedDistance = sdf(currPos);
    if (signedDistance > maxDistance) {
      distance = S{0};
      return false;
    }
  }
 
  distance = util::fabs(distance);
  return true;
}

References distance(), fabs(), normalize(), and sign().

Here is the call graph for this function:

dotProduct()

template<typename T , unsigned D>

T olb::util::dotProduct	(	const Vector< T, D > &	a,
		const Vector< T, D > &	b )

dot product

Definition at line 143 of file vectorHelpers.h.

{
  if constexpr (D==2){
    return dotProduct2D(a, b);
  } else {
    return dotProduct3D(a, b);
  }
}

References dotProduct2D(), and dotProduct3D().

Here is the call graph for this function:

Here is the caller graph for this function:

dotProduct2D()

template<typename T >

T olb::util::dotProduct2D	(	const Vector< T, 2 > &	a,
		const Vector< T, 2 > &	b )

dot product, only valid in 2d

Definition at line 136 of file vectorHelpers.h.

{
  return a[0]*b[0] + a[1]*b[1];
}

Here is the caller graph for this function:

dotProduct3D()

template<typename T >

T olb::util::dotProduct3D	(	const Vector< T, 3 > &	a,
		const Vector< T, 3 > &	b )

dot product, only valid in 3d

Definition at line 129 of file vectorHelpers.h.

{
  return a[0]*b[0] + a[1]*b[1] + a[2]*b[2];
}

Here is the caller graph for this function:

euklidDistance() [1/2]

template<typename C >

auto olb::util::euklidDistance	(	const C &	x,
		const C &	y )

Euclidean distance for Container-type array.

Definition at line 97 of file norm.h.

{
  OLB_ASSERT((x.size() == y.size()), "Arrays must have same dimension");
  return euklidDistance(x.data(), y.data(), x.size());
}

References euklidDistance(), and OLB_ASSERT.

Here is the call graph for this function:

euklidDistance() [2/2]

template<typename T >

T olb::util::euklidDistance	(	const T	x[],
		const T	y[],
		int	dim )

Euclidean distance between two arrays.

Definition at line 67 of file norm.h.

{
  return olb::util::sqrt(euklidDistance2(x,y,dim));
}

References euklidDistance2(), and sqrt().

Here is the call graph for this function:

Here is the caller graph for this function:

euklidDistance2() [1/2]

template<typename C >

auto olb::util::euklidDistance2	(	const C &	x,
		const C &	y )

Squared Euclidean distance for Container-type array.

Definition at line 82 of file norm.h.

{
  OLB_ASSERT((x.size() == y.size()), "Arrays must have same dimension");
  return euklidDistance2(x.data(), y.data(), x.size());
}

References euklidDistance2(), and OLB_ASSERT.

Here is the call graph for this function:

euklidDistance2() [2/2]

template<typename T >

T olb::util::euklidDistance2	(	const T	x[],
		const T	y[],
		int	dim )

Squared Euclidean distance between two arrays.

Definition at line 48 of file norm.h.

{
  T euklid = 0;
  for (int iDim=0; iDim<dim; iDim++) {
    euklid += (x[iDim]-y[iDim])*(x[iDim]-y[iDim]);
  }
  return euklid;
}

Here is the caller graph for this function:

euklidN() [1/2]

template<typename C >

auto olb::util::euklidN

(

const C &

x

)

Euclidean norm for Container-type array.

Definition at line 90 of file norm.h.

{
  return euklidN(x.data(), x.size());
}

References euklidN().

Here is the call graph for this function:

euklidN() [2/2]

template<typename T >

T olb::util::euklidN	(	const T	x[],
		int	dim )

Euclidean norm of an array.

Definition at line 60 of file norm.h.

{
  return olb::util::sqrt(euklidN2(x,dim));
}

References euklidN2(), and sqrt().

Here is the call graph for this function:

Here is the caller graph for this function:

euklidN2() [1/2]

template<typename C >

auto olb::util::euklidN2

(

const C &

x

)

Squared Euclidean norm for Container-type array.

Definition at line 75 of file norm.h.

{
  return euklidN2(x.data(), x.size());
}

References euklidN2().

Here is the call graph for this function:

euklidN2() [2/2]

template<typename T >

T olb::util::euklidN2	(	const T	x[],
		int	dim )

Squared Euclidean norm of an array.

Definition at line 37 of file norm.h.

{
  T euklid = 0;
  for (int iDim=0; iDim<dim; iDim++) {
    euklid += x[iDim]*x[iDim];
  }
  return euklid;
}

Here is the caller graph for this function:

evaluateIntegration()

template<typename T >

int olb::util::evaluateIntegration	(	std::vector< T > &	testValues,
		bool	print = false )

Definition at line 34 of file integrationTestUtils.h.

                                                                     {
  OstreamManager clout( std::cout,"Integrationtest" );
  bool allPassed = true;
  for (int i=0; i<testValues.size(); i+=3){
    T val = testValues[i];
    T ref = testValues[i+1];
    T maxErr = testValues[i+2];
    T err = std::abs(ref-val)/ref;
    bool passed = err <= maxErr;
    if (print || !passed ){
      clout << std::setprecision(16);
      clout << "i:|"     << "Value:                 |"
                         << "Reference:             |"
                         << "Error:                 |"
                         << "MaxError:              |"
                         << "Passed:" <<  std::endl;
      clout << i << " |" << std::setw(22) << val
                 << " |" << std::setw(22) << ref
                 << " |" << std::setw(22) << err
                 << " |" << std::setw(22) << maxErr
                 << " |" << passed << std::endl;
      clout << std::setprecision(6);
    }
    if (!passed){ allPassed=false; };
  }
  if (allPassed){
    return 0;
  } else {
    return 1;
  }
}

References print().

Here is the call graph for this function:

executeRotation()

template<typename T , unsigned D, bool OUTPUT_USES_ROTATION_CENTER_AS_ORIGIN = false>

Vector< T, D > olb::util::executeRotation	(	const Vector< T, D > &	input,
		const Vector< T, utilities::dimensions::convert< D >::matrix > &	rotationMatrix,
		const Vector< T, D > &	rotationCenter = Vector<T, D>(0.) )

Rotates the input around the rotationCenter with a given rotationMatrix.

Definition at line 191 of file geometricOperations.h.

{
  const Vector<T, D> dist = input - rotationCenter;
  Vector<T, D>       rotated;
 
  if constexpr (D == 2) {
    rotated =
        Vector<T, 2>(dist[0] * rotationMatrix[0] + dist[1] * rotationMatrix[1],
                     dist[0] * rotationMatrix[2] + dist[1] * rotationMatrix[3]);
  }
  else {
    rotated =
        Vector<T, 3>(rotationMatrix[0] * dist[0] + rotationMatrix[1] * dist[1] +
                         rotationMatrix[2] * dist[2],
                     rotationMatrix[3] * dist[0] + rotationMatrix[4] * dist[1] +
                         rotationMatrix[5] * dist[2],
                     rotationMatrix[6] * dist[0] + rotationMatrix[7] * dist[1] +
                         rotationMatrix[8] * dist[2]);
  }
 
  if constexpr (!OUTPUT_USES_ROTATION_CENTER_AS_ORIGIN) {
    return rotationCenter + rotated;
  }
  else {
    return rotated;
  }
 
  __builtin_unreachable();
}

Here is the caller graph for this function:

exp() [1/4]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::exp ( const ADf< T, DIM > & a )

inline

Definition at line 455 of file aDiff.h.

{
  ADf<T,DIM> c(std::exp(a._v), a._d);
  c._d*=c._v;
  return c;
}

exp() [2/4]

Expr olb::util::exp

(

Expr

x

)

Definition at line 240 of file expr.cpp.

                 {
  Expr::increment(Expr::Op::Exp);
  return Expr(Expr::Op::Exp, x);
}

References olb::Expr::Exp, and olb::Expr::increment().

Here is the call graph for this function:

Here is the caller graph for this function:

exp() [3/4]

template<typename T >

any_platform std::enable_if_t< std::is_integral_v< T >, double > olb::util::exp ( T arg )

inline

Definition at line 248 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::exp(arg);
#else  //__CUDA_ARCH__
  return std::exp(arg);
#endif //__CUDA_ARCH__
}

exp() [4/4]

template<typename T >

any_platform std::enable_if_t< std::is_floating_point_v< T >, T > olb::util::exp ( T x )

inline

Definition at line 229 of file omath.h.

{
#ifdef __CUDA_ARCH__
  if constexpr (std::is_same_v<T, float>) {
    return ::expf(x);
  }
  else if constexpr (std::is_same_v<T, double>) {
    return ::exp(x);
  }
  else {
    return ::exp(static_cast<double>(x));
    //libcu++ of cuda supports double and float. You will get warning in device code if you use in e.g. long double.
  }
#else  //__CUDA_ARCH__
  return std::exp(x);
#endif //__CUDA_ARCH__
}

expf() [1/3]

template<unsigned DIM>

ADf< float, DIM > olb::util::expf ( const ADf< float, DIM > & a )

inline

Definition at line 463 of file aDiff.h.

{
  return exp(a);
}

References exp().

Here is the call graph for this function:

expf() [2/3]

any_platform float olb::util::expf ( float arg )

inline

Definition at line 257 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::expf(arg);
#else  //__CUDA_ARCH__
  return std::exp(arg);
#endif //__CUDA_ARCH__
}

expf() [3/3]

any_platform float olb::util::expf ( int arg )

inline

Definition at line 266 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::expf(arg);
#else  //__CUDA_ARCH__
  return std::exp(arg);
#endif //__CUDA_ARCH__
}

expl() [1/2]

template<unsigned DIM>

ADf< long double, DIM > olb::util::expl ( const ADf< long double, DIM > & a )

inline

Definition at line 469 of file aDiff.h.

{
  return exp(a);
}

References exp().

Here is the call graph for this function:

expl() [2/2]

long double olb::util::expl ( long double arg )

inline

Definition at line 275 of file omath.h.

{
  return exp(arg);
  //cuda dose not support this function.
}

References exp().

Here is the call graph for this function:

fabs() [1/6]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::fabs ( const ADf< T, DIM > & a )

inline

Definition at line 996 of file aDiff.h.

{
#ifdef AdWarnings
  if (a._v == T(0)) {
    std::cout << "ADf WARNING: fabs(Adf) - fabs evaluated at non-differentiable point" << std::endl;
  }
#endif
  return ADf<T,DIM>( util::sign(a._v) * a );
}

References sign().

Here is the call graph for this function:

fabs() [2/6]

template<std::floating_point T>

cpu::simd::Pack< T > olb::util::fabs

(

cpu::simd::Pack< T >

value

)

Definition at line 116 of file pack.h.

{
  return cpu::simd::fabs(value);
}

References olb::cpu::simd::fabs().

Here is the call graph for this function:

fabs() [3/6]

Expr olb::util::fabs

(

Expr

x

)

Definition at line 230 of file expr.cpp.

                  {
  Expr::increment(Expr::Op::Abs);
  return Expr(Expr::Op::Abs, x);
}

References olb::Expr::Abs, and olb::Expr::increment().

Here is the call graph for this function:

Here is the caller graph for this function:

fabs() [4/6]

long double olb::util::fabs ( long double arg )

inline

Definition at line 1611 of file omath.h.

{ return std::abs(arg); }

fabs() [5/6]

template<typename T >

any_platform std::enable_if_t< std::is_floating_point_v< T >, T > olb::util::fabs ( T x )

inline

Definition at line 1554 of file omath.h.

{
#ifdef __CUDA_ARCH__
  if constexpr (std::is_same_v<T, float>) {
    return ::fabsf(x);
  }
  else if constexpr (std::is_same_v<T, double>) {
    return ::fabs(x);
  }
  else {
    return ::fabs(static_cast<double>(x));
    //libcu++ of cuda supports double and float. You will get warning in device code if you use in e.g. long double.
  }
#else  //__CUDA_ARCH__
  return std::fabs(x);
#endif //__CUDA_ARCH__
}

fabs() [6/6]

template<typename T >

any_platform std::enable_if_t< std::is_integral_v< T >, double > olb::util::fabs ( T x )

inline

Definition at line 1573 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::fabs(x);
#else  //__CUDA_ARCH__
  return std::fabs(x);
#endif //__CUDA_ARCH__
}

fabsf() [1/3]

template<unsigned DIM>

ADf< float, DIM > olb::util::fabsf ( const ADf< float, DIM > & a )

inline

Definition at line 1007 of file aDiff.h.

{
  return fabs(a);
}

References fabs().

Here is the call graph for this function:

fabsf() [2/3]

any_platform float olb::util::fabsf ( float x )

inline

Definition at line 1535 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::fabsf(x);
#else  //__CUDA_ARCH__
  return std::abs(x);
#endif //__CUDA_ARCH__
}

fabsf() [3/3]

any_platform float olb::util::fabsf ( int x )

inline

Definition at line 1544 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::fabsf(x);
#else  //__CUDA_ARCH__
  return std::abs(x);
#endif //__CUDA_ARCH__
}

fabsl()

template<unsigned DIM>

ADf< long double, DIM > olb::util::fabsl ( const ADf< long double, DIM > & a )

inline

Definition at line 1013 of file aDiff.h.

{
  return fabs(a);
}

References fabs().

Here is the call graph for this function:

findVelocity()

template<typename DESCRIPTORBASE >

int olb::util::findVelocity

(

const int

v[DESCRIPTORBASE::d]

)

Definition at line 243 of file util.h.

{
  for (int iPop=0; iPop<DESCRIPTORBASE::q; ++iPop) {
    bool fit = true;
    for (int iD=0; iD<DESCRIPTORBASE::d; ++iD) {
      if (descriptors::c<DESCRIPTORBASE>(iPop,iD) != v[iD]) {
        fit = false;
        break;
      }
    }
    if (fit) {
      return iPop;
    }
  }
  return DESCRIPTORBASE::q;
}

References olb::descriptors::c().

Here is the call graph for this function:

Here is the caller graph for this function:

floor() [1/4]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::floor ( const ADf< T, DIM > & a )

inline

Definition at line 869 of file aDiff.h.

{
  ADf<T,DIM> c;
  if (a._v == std::floor(a._v)) {
    c._v = a._v;
#ifdef AdWarnings
    std::cout << "ADf WARNING: floor(Adf) - floor evaluated at non-differentiable point" << std::endl;
#endif
    for (unsigned i = 0; i < DIM; ++i) {
      c._d[i] = (a.d(i) == 0) ? T(0) : std::numeric_limits<T>::quiet_NaN();
    }
    return c;
  }
  c._v = std::floor(a._v);
  c._d = ( T(0) );
  return c;
}

Here is the caller graph for this function:

floor() [2/4]

template<typename T , unsigned Size>

Vector< T, Size > olb::util::floor

(

const Vector< T, Size > &

a

)

applies floor to each component of a vector

Definition at line 173 of file vectorHelpers.h.

{
  Vector<T,Size> out;
  for (unsigned int iDim=0; iDim < Size; ++iDim) {
    out[iDim] = util::floor(a[iDim]);
  }
  return out;
}

References floor().

Here is the call graph for this function:

floor() [3/4]

template<typename T >

any_platform std::enable_if_t< std::is_floating_point_v< T >, T > olb::util::floor ( T x )

inline

Definition at line 1318 of file omath.h.

{
#ifdef __CUDA_ARCH__
  if constexpr (std::is_same_v<T, float>) {
    return ::floorf(x);
  }
  else if constexpr (std::is_same_v<T, double>) {
    return ::floor(x);
  }
  else {
    return ::floor(static_cast<double>(x));
    //libcu++ of cuda supports double and float. You will get warning in device code if you use in e.g. long double.
  }
#else  //__CUDA_ARCH__
  return std::floor(x);
#endif //__CUDA_ARCH__
}

floor() [4/4]

template<typename T >

any_platform std::enable_if_t< std::is_integral_v< T >, double > olb::util::floor ( T x )

inline

Definition at line 1337 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::floor(x);
#else  //__CUDA_ARCH__
  return std::floor(x);
#endif //__CUDA_ARCH__
}

floorf() [1/3]

template<unsigned DIM>

ADf< float, DIM > olb::util::floorf ( const ADf< float, DIM > & a )

inline

Definition at line 888 of file aDiff.h.

{
  return floor(a);
}

References floor().

Here is the call graph for this function:

floorf() [2/3]

any_platform float olb::util::floorf ( float x )

inline

Definition at line 1299 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::floorf(x);
#else  //__CUDA_ARCH__
  return std::floor(x);
#endif //__CUDA_ARCH__
}

floorf() [3/3]

any_platform float olb::util::floorf ( int x )

inline

Definition at line 1308 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::floorf(x);
#else  //__CUDA_ARCH__
  return std::floor(x);
#endif //__CUDA_ARCH__
}

floorl() [1/2]

template<unsigned DIM>

ADf< long double, DIM > olb::util::floorl ( const ADf< long double, DIM > & a )

inline

Definition at line 894 of file aDiff.h.

{
  return floor(a);
}

References floor().

Here is the call graph for this function:

floorl() [2/2]

long double olb::util::floorl ( long double arg )

inline

Definition at line 1346 of file omath.h.

{
  return floor(arg);
  //cuda dose not support this function.
}

References floor().

Here is the call graph for this function:

fmod() [1/7]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::fmod ( const ADf< T, DIM > & a, const ADf< T, DIM > & b )

inline

Definition at line 703 of file aDiff.h.

{
  const T k = std::floor(T(a) / T(b));
  return ADf<T,DIM>(a - k * b);
}

Here is the caller graph for this function:

fmod() [2/7]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

ADf< T, DIM > olb::util::fmod ( const ADf< T, DIM > & a, const U & b )

inline

Definition at line 710 of file aDiff.h.

{
  return fmod(a, ADf<T,DIM>(b));
}

References fmod().

Here is the call graph for this function:

fmod() [3/7]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

ADf< T, DIM > olb::util::fmod ( const U & a, const ADf< T, DIM > & b )

inline

Definition at line 716 of file aDiff.h.

{
  return fmod( ADf<T,DIM>(a),b);
}

References fmod().

Here is the call graph for this function:

fmod() [4/7]

template<typename T , typename S , unsigned Size>

Vector< T, Size > olb::util::fmod	(	const Vector< T, Size > &	a,
		S	b )

applies fmod to each component of a vector

Definition at line 195 of file vectorHelpers.h.

{
  Vector<T,Size> out;
  for (unsigned int iDim=0; iDim < Size; ++iDim) {
    out[iDim] = util::fmod(a[iDim], b);
  }
  return out;
}

References fmod().

Here is the call graph for this function:

fmod() [5/7]

template<typename T , typename S >

any_platform std::enable_if_t< std::is_integral_v< S > &&std::is_floating_point_v< T >, T > olb::util::fmod ( T x, S y )

inline

Definition at line 164 of file omath.h.

{
#ifdef __CUDA_ARCH__
  if constexpr (std::is_same_v<T, float>) {
    return ::fmodf(x, y);
  }
  else if constexpr (std::is_same_v<T, double>) {
    return ::fmod(x, y);
  }
  else {
    return ::fmod(static_cast<double>(x), y);
    //libcu++ of cuda supports double and float. You will get warning in device code if you use in e.g. long double.
  }
#else  //__CUDA_ARCH__
  return std::fmod(x, y);
#endif //__CUDA_ARCH__
}

fmod() [6/7]

template<typename T , typename S >

any_platform std::enable_if_t< std::is_integral_v< T > &&std::is_floating_point_v< S >, S > olb::util::fmod ( T x, S y )

inline

Definition at line 185 of file omath.h.

{
#ifdef __CUDA_ARCH__
  if constexpr (std::is_same_v<S, float>) {
    return ::fmodf(x, y);
  }
  else if constexpr (std::is_same_v<S, double>) {
    return ::fmod(x, y);
  }
  else {
    return ::fmod(x, static_cast<double>(y));
    //libcu++ of cuda supports double and float. You will get warning in device code if you use in e.g. long double.
  }
#else  //__CUDA_ARCH__
  return std::fmod(x, y);
#endif //__CUDA_ARCH__
}

fmod() [7/7]

template<typename T , typename S >

any_platform auto olb::util::fmod ( T x, S y ) -> std::enable_if_t<std::is_floating_point_v<T> && std::is_floating_point_v<S>, decltype(std::fmod(x, y))>

inline

Definition at line 140 of file omath.h.

{
#ifdef __CUDA_ARCH__
  if constexpr (std::is_same_v<T, float> && std::is_same_v<S, float>) {
    return ::fmodf(x, y);
  }
  else if constexpr (std::is_same_v<T, double> && std::is_same_v<S, double>) {
    return ::fmod(x, y);
  }
  else {
    return ::fmod(static_cast<double>(x), static_cast<double>(y));
    //libcu++ of cuda supports double and float. You will get warning in device code if you use in e.g. long double.
  }
#else  //__CUDA_ARCH__
  return std::fmod(x, y);
#endif //__CUDA_ARCH__
}

fmod_pos()

template<typename T , typename S >

auto olb::util::fmod_pos ( T a, S b )

inline

Variant of fmod (floating point modulo) that always returns positive values.

Definition at line 39 of file calc.h.

                               {
  const auto res = util::fmod(a, b);
  if (res < 0) {
    return (res + b);
  } else {
    return res;
  }
}

References fmod().

Here is the call graph for this function:

Here is the caller graph for this function:

fmodf() [1/2]

any_platform float olb::util::fmodf ( float x, float y )

inline

Definition at line 203 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::fmodf(x, y);
#else  //__CUDA_ARCH__
  return std::fmod(x, y);
#endif //__CUDA_ARCH__
}

fmodf() [2/2]

any_platform float olb::util::fmodf ( int x, int y )

inline

Definition at line 212 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::fmodf(x, y);
#else  //__CUDA_ARCH__
  return std::fmod(x, y);
#endif //__CUDA_ARCH__
}

fmodl()

long double olb::util::fmodl ( long double x, long double y )

inline

Definition at line 221 of file omath.h.

{
  return fmod(x, y);
  //cuda dose not support this function.
}

References fmod().

Here is the call graph for this function:

forEachOffset()

template<unsigned D, typename F >

void olb::util::forEachOffset

(

F

fn

)

Definition at line 450 of file util.h.

                                      {
  for (int i = -1; i <= 1; ++i) {
    for (int j = -1; j <= 1; ++j) {
      if constexpr (D == 3) {
        for (int k = -1; k <= 1; ++k) { fn(i, j, k); }
      }
      else { fn(i, j); }
    }
  }
}

fromVector2()

template<typename T >

std::vector< T > olb::util::fromVector2

(

const Vector< T, 2 > &

vec

)

Definition at line 87 of file vectorHelpers.h.

{
  std::vector<T> v;
  v.push_back(vec[0]);
  v.push_back(vec[1]);
  return v;
}

fromVector3()

template<typename T >

std::vector< T > olb::util::fromVector3

(

const Vector< T, 3 > &

vec

)

Definition at line 78 of file vectorHelpers.h.

{
  std::vector<T> v;
  v.push_back(vec[0]);
  v.push_back(vec[1]);
  v.push_back(vec[2]);
  return v;
}

Here is the caller graph for this function:

get_nearest_link()

template<typename T , typename DESCRIPTOR >

int olb::util::get_nearest_link

(

const std::vector< T > &

vec

)

Util Function for Wall Model of Malaspinas get link with smallest angle to a vector.

Definition at line 360 of file util.h.

{
  T max=-1;
  int max_index = 0;
  for (int iQ=1; iQ<DESCRIPTOR::q; ++iQ) {
    std::vector<T> c_i(DESCRIPTOR::c[iQ], DESCRIPTOR::c[iQ]+3);
    T tmp = util::scalarProduct<T>(c_i, vec)/util::norm(c_i);
    if (tmp > max) {
      max = tmp;
      max_index = iQ;
    }
  }
  return max_index;
}

References norm(), and scalarProduct().

Here is the call graph for this function:

iniAD() [1/3]

template<unsigned n, typename S , template< typename > typename C>

C< ADf< S, n > > olb::util::iniAD

(

const C< S > &

source

)

copy values and initialize derivatives

Definition at line 101 of file adHelpers.h.

                                      {
  auto result = copyAs<ADf<S,n>,S,C> (source);
  util::iniDiagonal (result);
  return result;
}

References copyAs(), and iniDiagonal().

Here is the call graph for this function:

iniAD() [2/3]

template<unsigned n, typename S >

ADf< S, n > * olb::util::iniAD

(

const S *

source

)

copy array values and initialize derivatives

Definition at line 92 of file adHelpers.h.

                                 {
  ADf<S,n>* result = new ADf<S,n>[n];
  util::copyN (result, source, n);
  util::iniDiagonal (result, n);
  return result;
}

References copyN(), and iniDiagonal().

Here is the call graph for this function:

iniAD() [3/3]

template<typename S >

ADf< S, 1 > olb::util::iniAD

(

const S

source

)

copy value and initialize derivative

Definition at line 84 of file adHelpers.h.

                               {
  ADf<S,1> result(source);
  result.setDiffVariable(0);
  return result;
}

References olb::util::ADf< T, DIM >::setDiffVariable().

Here is the call graph for this function:

Here is the caller graph for this function:

iniDiagonal() [1/2]

template<typename C >

void olb::util::iniDiagonal

(

C &

a

)

Definition at line 49 of file adHelpers.h.

                       {
  for (unsigned i = 0; i < a.size(); ++i) {
    a[i].setDiffVariable(i);
  }
}

iniDiagonal() [2/2]

template<typename SAD >

void olb::util::iniDiagonal	(	SAD *	a,
		int	dim )

The variables of an array are set to be the differential variables.

--> d/di a_j = 1 if (i==j) else 0.

Definition at line 42 of file adHelpers.h.

                                  {
  for (int i = 0; i < dim; ++i) {
    a[i].setDiffVariable(i);
  }
}

Here is the caller graph for this function:

intersect() [1/2]

bool olb::util::intersect ( int x0, int x1, int y0, int y1, int x0_, int x1_, int y0_, int y1_, int & newX0, int & newX1, int & newY0, int & newY1 )

inline

Definition at line 85 of file util.h.

{
  newX0 = util::max(x0,x0_);
  newY0 = util::max(y0,y0_);
 
  newX1 = util::min(x1,x1_);
  newY1 = util::min(y1,y1_);
 
  return newX1>=newX0 && newY1>=newY0;
}

References max(), and min().

Here is the call graph for this function:

Here is the caller graph for this function:

intersect() [2/2]

bool olb::util::intersect ( int x0, int x1, int y0, int y1, int z0, int z1, int x0_, int x1_, int y0_, int y1_, int z0_, int z1_, int & newX0, int & newX1, int & newY0, int & newY1, int & newZ0, int & newZ1 )

inline

Definition at line 99 of file util.h.

{
  newX0 = util::max(x0,x0_);
  newY0 = util::max(y0,y0_);
  newZ0 = util::max(z0,z0_);
 
  newX1 = util::min(x1,x1_);
  newY1 = util::min(y1,y1_);
  newZ1 = util::min(z1,z1_);
 
  return newX1>=newX0 && newY1>=newY0 && newZ1>=newZ0;
}

References max(), and min().

Here is the call graph for this function:

inverseRotation() [1/2]

template<typename T >

Vector< T, 4 > olb::util::inverseRotation

(

const Vector< T, 4 > &

m

)

Definition at line 113 of file geometricOperations.h.

                                                               {
  return Vector{m[0], m[2],
                m[1], m[3]};
}

Here is the caller graph for this function:

inverseRotation() [2/2]

template<typename T >

Vector< T, 9 > olb::util::inverseRotation

(

const Vector< T, 9 > &

m

)

Definition at line 119 of file geometricOperations.h.

                                                               {
  return Vector{m[0], m[3], m[6],
                m[1], m[4], m[7],
                m[2], m[5], m[8]};
}

invertRotation()

template<typename T , unsigned D, bool OUTPUT_USES_ROTATION_CENTER_AS_ORIGIN = false>

Vector< T, D > olb::util::invertRotation	(	const Vector< T, D > &	input,
		const Vector< T, utilities::dimensions::convert< D >::matrix > &	rotationMatrix,
		const Vector< T, D > &	rotationCenter = Vector<T, D>(0.) )

Rotates the input around the rotationCenter with a given rotationMatrix in the opposite direction.

Definition at line 227 of file geometricOperations.h.

{
  const Vector<T, utilities::dimensions::convert<D>::matrix> invRotationMatrix =
      invertRotationMatrix<T, D>(rotationMatrix);
  return executeRotation(input, invRotationMatrix, rotationCenter);
}

References executeRotation(), and invertRotationMatrix().

Here is the call graph for this function:

invertRotationMatrix()

template<typename T , unsigned D>

Vector< T, utilities::dimensions::convert< D >::matrix > olb::util::invertRotationMatrix

(

const Vector< T, utilities::dimensions::convert< D >::matrix > &

rotationMatrix

)

Definition at line 158 of file geometricOperations.h.

{
  if constexpr (D == 2) {
    return Vector<T, 4>(rotationMatrix[0], rotationMatrix[2], rotationMatrix[1],
                        rotationMatrix[3]);
  }
  else {
 
    //Individual Entries ( source: https://doi.org/10.1016/j.compfluid.2018.02.027 )
    // |x0| / 0 3 6 \   |x1|
    // |y0| | 1 4 7 | = |x1|
    // |z0| \ 2 5 8 /   |x1|
 
    return Vector<T, 9>(rotationMatrix[0], rotationMatrix[3], rotationMatrix[6],
                        rotationMatrix[1], rotationMatrix[4], rotationMatrix[7],
                        rotationMatrix[2], rotationMatrix[5],
                        rotationMatrix[8]);
  }
  __builtin_unreachable();
}

References olb::Vector().

Here is the call graph for this function:

Here is the caller graph for this function:

isContained()

template<typename C , typename U >

bool olb::util::isContained	(	const C &	c,
		U	object )

Check, if object is contained in iteratable container c.

Definition at line 447 of file vectorHelpers.h.

                                       {
  return (std::find(c.begin(), c.end(), object) != c.end());
}

Here is the caller graph for this function:

isnan()

template<typename T >

any_platform bool olb::util::isnan ( T arg )

inline

Definition at line 1621 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::isnan(arg);
#else
  return std::isnan(arg);
#endif
}

Here is the caller graph for this function:

kahanSum() [1/2]

template<typename T >

void olb::util::kahanSum	(	T &	output0,
		T &	output1,
		T	summand )

Definition at line 59 of file calc.h.

{
  const T y {summand - output1};
  const T t {output0 + y};
  output1 = (t - output0) - y;
  output0 = t;
}

kahanSum() [2/2]

template<typename T >

void olb::util::kahanSum	(	T	output[2],
		T	summand )

Accurate summation of floating point numbers with the Kahan algorithm.

Definition at line 51 of file calc.h.

{
  const T y {summand - output[1]};
  const T t {output[0] + y};
  output[1] = (t - output[0]) - y;
  output[0] = t;
}

Here is the caller graph for this function:

labs()

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::labs ( const ADf< T, DIM > & a )

inline

Definition at line 1025 of file aDiff.h.

{
#ifdef AdWarnings
  std::cout << "ADf WARNING: ADf is not supporting integer types. Using abs() instead." << std::endl;
#endif
  return abs(a);
}

References abs().

Here is the call graph for this function:

Here is the caller graph for this function:

llabs()

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::llabs ( const ADf< T, DIM > & a )

inline

Definition at line 1034 of file aDiff.h.

{
  return labs(a);
}

References labs().

Here is the call graph for this function:

llround() [1/2]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::llround ( const ADf< T, DIM > & a )

inline

Definition at line 978 of file aDiff.h.

{
  return lround(a);
}

References lround().

Here is the call graph for this function:

Here is the caller graph for this function:

llround() [2/2]

template<typename T >

std::enable_if_t< std::is_arithmetic_v< T >, long long > olb::util::llround ( T arg )

inline

Definition at line 1525 of file omath.h.

{
  return std::llround(arg);
}

llroundf() [1/2]

template<unsigned DIM>

ADf< float, DIM > olb::util::llroundf ( const ADf< float, DIM > & a )

inline

Definition at line 984 of file aDiff.h.

{
  return llround(a);
}

References llround().

Here is the call graph for this function:

llroundf() [2/2]

long long olb::util::llroundf ( float arg )

inline

Definition at line 1530 of file omath.h.

{ return std::llroundf(arg); }

llroundl() [1/2]

template<unsigned DIM>

ADf< long double, DIM > olb::util::llroundl ( const ADf< long double, DIM > & a )

inline

Definition at line 990 of file aDiff.h.

{
  return llround(a);
}

References llround().

Here is the call graph for this function:

llroundl() [2/2]

long long olb::util::llroundl ( long double arg )

inline

Definition at line 1532 of file omath.h.

{ return std::llroundl(arg); }

log() [1/3]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::log ( const ADf< T, DIM > & a )

inline

Definition at line 475 of file aDiff.h.

{
  ADf<T,DIM> c(std::log(a._v), a._d);
  T tmp (T(1)/a._v);
  c._d*=tmp;
  return c;
}

Here is the caller graph for this function:

log() [2/3]

template<typename T >

any_platform std::enable_if_t< std::is_integral_v< T >, double > olb::util::log ( T arg )

inline

Definition at line 301 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::log(arg);
#else  //__CUDA_ARCH__
  return std::log(arg);
#endif //__CUDA_ARCH__
}

log() [3/3]

template<typename T >

any_platform std::enable_if_t< std::is_floating_point_v< T >, T > olb::util::log ( T x )

inline

Definition at line 282 of file omath.h.

{
#ifdef __CUDA_ARCH__
  if constexpr (std::is_same_v<T, float>) {
    return ::logf(x);
  }
  else if constexpr (std::is_same_v<T, double>) {
    return ::log(x);
  }
  else {
    return ::log(static_cast<double>(x));
    //libcu++ of cuda supports double and float. You will get warning in device code if you use in e.g. long double.
  }
#else  //__CUDA_ARCH__
  return std::log(x);
#endif //__CUDA_ARCH__
}

log10() [1/3]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::log10 ( const ADf< T, DIM > & a )

inline

Definition at line 496 of file aDiff.h.

{
  ADf<T,DIM> c(std::log10(a._v), a._d);
  T tmp (T(1)/(a._v*std::log(T(10))));
  c._d*=tmp;
  return c;
}

Here is the caller graph for this function:

log10() [2/3]

template<typename T >

any_platform std::enable_if_t< std::is_integral_v< T >, double > olb::util::log10 ( T arg )

inline

Definition at line 356 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::log10(arg);
#else  //__CUDA_ARCH__
  return std::log10(arg);
#endif //__CUDA_ARCH__
}

log10() [3/3]

template<typename T >

any_platform std::enable_if_t< std::is_floating_point_v< T >, T > olb::util::log10 ( T x )

inline

Definition at line 337 of file omath.h.

{
#ifdef __CUDA_ARCH__
  if constexpr (std::is_same_v<T, float>) {
    return ::log10f(x);
  }
  else if constexpr (std::is_same_v<T, double>) {
    return ::log10(x);
  }
  else {
    return ::log10(static_cast<double>(x));
    //libcu++ of cuda supports double and float. You will get warning in device code if you use in e.g. long double.
  }
#else  //__CUDA_ARCH__
  return std::log10(x);
#endif //__CUDA_ARCH__
}

log10f() [1/3]

template<unsigned DIM>

ADf< float, DIM > olb::util::log10f ( const ADf< float, DIM > & a )

inline

Definition at line 505 of file aDiff.h.

{
  return log10(a);
}

References log10().

Here is the call graph for this function:

log10f() [2/3]

any_platform float olb::util::log10f ( float arg )

inline

Definition at line 365 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::log10f(arg);
#else  //__CUDA_ARCH__
  return std::log10(arg);
#endif //__CUDA_ARCH__
}

log10f() [3/3]

any_platform float olb::util::log10f ( int arg )

inline

Definition at line 374 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::log10f(arg);
#else  //__CUDA_ARCH__
  return std::log10(arg);
#endif //__CUDA_ARCH__
}

log10l() [1/2]

template<unsigned DIM>

ADf< long double, DIM > olb::util::log10l ( const ADf< long double, DIM > & a )

inline

Definition at line 511 of file aDiff.h.

{
  return log10(a);
}

References log10().

Here is the call graph for this function:

log10l() [2/2]

long double olb::util::log10l ( long double arg )

inline

Definition at line 383 of file omath.h.

{
  return log10(arg);
  //libcu++ of cuda dose not support long double. You will get warning in device code if you use.
}

References log10().

Here is the call graph for this function:

log1p() [1/3]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::log1p ( const ADf< T, DIM > & a )

inline

Definition at line 538 of file aDiff.h.

{
  return log(a+T(1));
}

References log().

Here is the call graph for this function:

Here is the caller graph for this function:

log1p() [2/3]

template<typename T >

any_platform std::enable_if_t< std::is_integral_v< T >, double > olb::util::log1p ( T arg )

inline

Definition at line 465 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::log1p(arg);
#else  //__CUDA_ARCH__
  return std::log1p(arg);
#endif //__CUDA_ARCH__
}

log1p() [3/3]

template<typename T >

any_platform std::enable_if_t< std::is_floating_point_v< T >, T > olb::util::log1p ( T x )

inline

Definition at line 446 of file omath.h.

{
#ifdef __CUDA_ARCH__
  if constexpr (std::is_same_v<T, float>) {
    return ::log1pf(x);
  }
  else if constexpr (std::is_same_v<T, double>) {
    return ::log1p(x);
  }
  else {
    return ::log1p(static_cast<double>(x));
    //libcu++ of cuda supports double and float. You will get warning in device code if you use in e.g. long double.
  }
#else  //__CUDA_ARCH__
  return std::log1p(x);
#endif //__CUDA_ARCH__
}

log1pf() [1/3]

template<unsigned DIM>

ADf< float, DIM > olb::util::log1pf ( const ADf< float, DIM > & a )

inline

Definition at line 544 of file aDiff.h.

{
  return log1p(a);
}

References log1p().

Here is the call graph for this function:

log1pf() [2/3]

any_platform float olb::util::log1pf ( float arg )

inline

Definition at line 474 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::log1pf(arg);
#else  //__CUDA_ARCH__
  return std::log1p(arg);
#endif //__CUDA_ARCH__
}

log1pf() [3/3]

any_platform float olb::util::log1pf ( int arg )

inline

Definition at line 483 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::log1pf(arg);
#else  //__CUDA_ARCH__
  return std::log1p(arg);
#endif //__CUDA_ARCH__
}

log1pl() [1/2]

template<unsigned DIM>

ADf< long double, DIM > olb::util::log1pl ( const ADf< long double, DIM > & a )

inline

Definition at line 550 of file aDiff.h.

{
  return log1p(a);
}

References log1p().

Here is the call graph for this function:

log1pl() [2/2]

long double olb::util::log1pl ( long double arg )

inline

Definition at line 492 of file omath.h.

{
  return log1p(arg);
  //libcu++ of cuda dose not support long double. You will get warning in device code if you use.
}

References log1p().

Here is the call graph for this function:

log2() [1/3]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::log2 ( const ADf< T, DIM > & a )

inline

Definition at line 517 of file aDiff.h.

{
  ADf<T,DIM> c(std::log2(a._v), a._d);
  T tmp (T(1)/(a._v*std::log(T(2))));
  c._d*=tmp;
  return c;
}

Here is the caller graph for this function:

log2() [2/3]

template<typename T >

any_platform std::enable_if_t< std::is_integral_v< T >, double > olb::util::log2 ( T arg )

inline

Definition at line 411 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::log2(arg);
#else  //__CUDA_ARCH__
  return std::log2(arg);
#endif //__CUDA_ARCH__
}

log2() [3/3]

template<typename T >

any_platform std::enable_if_t< std::is_floating_point_v< T >, T > olb::util::log2 ( T x )

inline

Definition at line 392 of file omath.h.

{
#ifdef __CUDA_ARCH__
  if constexpr (std::is_same_v<T, float>) {
    return ::log2f(x);
  }
  else if constexpr (std::is_same_v<T, double>) {
    return ::log2(x);
  }
  else {
    return ::log2(static_cast<double>(x));
    //libcu++ of cuda supports double and float. You will get warning in device code if you use in e.g. long double.
  }
#else  //__CUDA_ARCH__
  return std::log2(x);
#endif //__CUDA_ARCH__
}

log2f() [1/3]

template<unsigned DIM>

ADf< float, DIM > olb::util::log2f ( const ADf< float, DIM > & a )

inline

Definition at line 526 of file aDiff.h.

{
  return log2(a);
}

References log2().

Here is the call graph for this function:

log2f() [2/3]

any_platform float olb::util::log2f ( float arg )

inline

Definition at line 420 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::log2f(arg);
#else  //__CUDA_ARCH__
  return std::log2(arg);
#endif //__CUDA_ARCH__
}

log2f() [3/3]

any_platform float olb::util::log2f ( int arg )

inline

Definition at line 429 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::log2f(arg);
#else  //__CUDA_ARCH__
  return std::log2(arg);
#endif //__CUDA_ARCH__
}

log2l() [1/2]

template<unsigned DIM>

ADf< long double, DIM > olb::util::log2l ( const ADf< long double, DIM > & a )

inline

Definition at line 532 of file aDiff.h.

{
  return log2(a);
}

References log2().

Here is the call graph for this function:

log2l() [2/2]

long double olb::util::log2l ( long double arg )

inline

Definition at line 438 of file omath.h.

{
  return log2(arg);
  //libcu++ of cuda dose not support long double. You will get warning in device code if you use.
}

References log2().

Here is the call graph for this function:

logf() [1/3]

template<unsigned DIM>

ADf< float, DIM > olb::util::logf ( const ADf< float, DIM > & a )

inline

Definition at line 484 of file aDiff.h.

{
  return log(a);
}

References log().

Here is the call graph for this function:

logf() [2/3]

any_platform float olb::util::logf ( float arg )

inline

Definition at line 310 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::logf(arg);
#else  //__CUDA_ARCH__
  return std::log(arg);
#endif //__CUDA_ARCH__
}

logf() [3/3]

any_platform float olb::util::logf ( int arg )

inline

Definition at line 319 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::logf(arg);
#else  //__CUDA_ARCH__
  return std::log(arg);
#endif //__CUDA_ARCH__
}

logl() [1/2]

template<unsigned DIM>

ADf< long double, DIM > olb::util::logl ( const ADf< long double, DIM > & a )

inline

Definition at line 490 of file aDiff.h.

{
  return log(a);
}

References log().

Here is the call graph for this function:

logl() [2/2]

long double olb::util::logl ( long double arg )

inline

Definition at line 328 of file omath.h.

{
  return log(arg);
  //cuda dose not support this function.
}

References log().

Here is the call graph for this function:

lround() [1/2]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::lround ( const ADf< T, DIM > & a )

inline

Definition at line 957 of file aDiff.h.

{
#ifdef AdWarnings
  std::cout << "ADf WARNING: ADf does not support integer types. Using round() instead." << std::endl;
#endif
  return round(a);
}

References round().

Here is the call graph for this function:

Here is the caller graph for this function:

lround() [2/2]

template<typename T >

std::enable_if_t< std::is_arithmetic_v< T >, long > olb::util::lround ( T arg )

inline

Definition at line 1515 of file omath.h.

{
  return std::lround(arg);
}

lroundf() [1/2]

template<unsigned DIM>

ADf< float, DIM > olb::util::lroundf ( const ADf< float, DIM > & a )

inline

Definition at line 966 of file aDiff.h.

{
  return lround(a);
}

References lround().

Here is the call graph for this function:

lroundf() [2/2]

long olb::util::lroundf ( float arg )

inline

Definition at line 1520 of file omath.h.

{ return std::lroundf(arg); }

lroundl() [1/2]

template<unsigned DIM>

ADf< long double, DIM > olb::util::lroundl ( const ADf< long double, DIM > & a )

inline

Definition at line 972 of file aDiff.h.

{
  return lround(a);
}

References lround().

Here is the call graph for this function:

lroundl() [2/2]

long olb::util::lroundl ( long double arg )

inline

Definition at line 1522 of file omath.h.

{ return std::lroundl(arg); }

matrixMatrixProduct()

template<typename T , unsigned D>

Vector< T, utilities::dimensions::convert< D >::matrix > olb::util::matrixMatrixProduct	(	const Vector< T, utilities::dimensions::convert< D >::matrix > &	A,
		const Vector< T, utilities::dimensions::convert< D >::matrix > &	B )

Compute C=AB for square matrices.

Definition at line 142 of file geometricOperations.h.

{
  Vector<T,utilities::dimensions::convert<D>::matrix> C{};
  for (unsigned i=0; i < D; ++i) {
    for (unsigned j=0; j < D; ++j) {
      for (unsigned k=0; k < D; ++k) {
        C[i*D + j] += A[i*D + k] * B[k*D + j];
      }
    }
  }
  return C;
}

matrixVectorProduct()

template<typename T , unsigned D>

Vector< T, D > olb::util::matrixVectorProduct	(	const Vector< T, utilities::dimensions::convert< D >::matrix > &	M,
		const Vector< T, D > &	b )

Compute v=M b.

Definition at line 127 of file geometricOperations.h.

{
  return Vector<T,D>([&](unsigned iD) -> T {
    T element{};
    for (unsigned jD=0; jD < D; ++jD) {
      element += M[iD*D + jD] * b[jD];
    }
    return element;
  });
}

Here is the caller graph for this function:

max() [1/7]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::max ( const ADf< T, DIM > & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 1056 of file aDiff.h.

{
  ADf<T,DIM> c((a + b + fabs(a - b) ) * T(0.5));
  return c;
}

References fabs().

Here is the call graph for this function:

max() [2/7]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::max ( const ADf< T, DIM > & a, const olb::BaseType< ADf< T, DIM > > & b )

inlineconstexpr

Definition at line 1048 of file aDiff.h.

{
  ADf<T,DIM> c(b);
  c = max(a, c);
  return c;
}

References max().

Here is the call graph for this function:

max() [3/7]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::max ( const olb::BaseType< ADf< T, DIM > > & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 1040 of file aDiff.h.

{
  ADf<T,DIM> c(a);
  c = max(c, b);
  return c;
}

References max().

Here is the call graph for this function:

max() [4/7]

template<std::floating_point T>

cpu::simd::Pack< T > olb::util::max	(	cpu::simd::Pack< T >	rhs,
		cpu::simd::Pack< T >	lhs )

Definition at line 140 of file pack.h.

{
  return cpu::simd::max(rhs, lhs);
}

References olb::cpu::simd::max().

Here is the call graph for this function:

max() [5/7]

Expr olb::util::max	(	Expr	a,
		Expr	b )

Definition at line 245 of file expr.cpp.

                         {
  throw std::domain_error("Invalid operator for Expr type: 'max'");
}

Here is the caller graph for this function:

max() [6/7]

template<typename T >

T olb::util::max ( std::initializer_list< T > ilist )

constexpr

Definition at line 48 of file oalgorithm.h.

                                              {
  return std::max(ilist);
}

max() [7/7]

template<typename T >

any_platform constexpr T olb::util::max ( T a, meta::id_t< T > b )

constexpr

Definition at line 39 of file oalgorithm.h.

                                                 {
#ifdef  __CUDA_ARCH__
  return ::max(a, b);
#else
  return std::max(a, b);
#endif
}

max_element()

template<typename T , unsigned Size>

T olb::util::max_element

(

const Vector< T, Size > &

a

)

finds maximum element of all elements

Definition at line 217 of file vectorHelpers.h.

{
  T max = a[0];
  for (unsigned int iDim=1; iDim < Size; ++iDim) {
    max = std::max(max,a[iDim]);
  }
  return max;
}

References max().

Here is the call graph for this function:

Here is the caller graph for this function:

maxElementAbs()

template<typename T , unsigned Size>

T olb::util::maxElementAbs

(

const Vector< T, Size > &

a

)

finds maximum element of all absolute elements

Definition at line 265 of file vectorHelpers.h.

{
  T maxAbs = a[0];
  for (unsigned int iDim=1; iDim < Size; ++iDim) {
    if (abs(a[iDim])>abs(maxAbs)){
      maxAbs = a[iDim];
    }
  }
  return maxAbs;
}

References abs().

Here is the call graph for this function:

Here is the caller graph for this function:

maxElementAbsPos()

template<typename T , unsigned Size>

unsigned olb::util::maxElementAbsPos

(

const Vector< T, Size > &

a

)

finds position of maximum element of all absolute elements

Definition at line 278 of file vectorHelpers.h.

{
  unsigned maxAbsPos = 0;
  for (unsigned int iDim=1; iDim < Size; ++iDim) {
    if (abs(a[iDim])>abs(a[maxAbsPos])){
      maxAbsPos = iDim;
    }
  }
  return maxAbsPos;
}

References abs().

Here is the call graph for this function:

Here is the caller graph for this function:

maxElementPos()

template<typename T , unsigned Size>

unsigned olb::util::maxElementPos

(

const Vector< T, Size > &

a

)

finds position of maximum element of all elements

Definition at line 239 of file vectorHelpers.h.

{
  unsigned maxPos = 0;
  for (unsigned int iDim=1; iDim < Size; ++iDim) {
    if (a[iDim]>a[maxPos]){
      maxPos = iDim;
    }
  }
  return maxPos;
}

min() [1/7]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::min ( const ADf< T, DIM > & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 1079 of file aDiff.h.

{
  ADf<T,DIM> c((a + b - fabs(a - b) ) * T(0.5));
  return c;
}

References fabs().

Here is the call graph for this function:

min() [2/7]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::min ( const ADf< T, DIM > & a, const olb::BaseType< ADf< T, DIM > > & b )

inlineconstexpr

Definition at line 1071 of file aDiff.h.

{
  ADf<T,DIM> c(b);
  c = min(a, c);
  return c;
}

References min().

Here is the call graph for this function:

min() [3/7]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::min ( const olb::BaseType< ADf< T, DIM > > & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 1063 of file aDiff.h.

{
  ADf<T,DIM> c(a);
  c = min(c, b);
  return c;
}

References min().

Here is the call graph for this function:

min() [4/7]

template<std::floating_point T>

cpu::simd::Pack< T > olb::util::min	(	cpu::simd::Pack< T >	rhs,
		cpu::simd::Pack< T >	lhs )

Definition at line 134 of file pack.h.

{
  return cpu::simd::min(rhs, lhs);
}

References olb::cpu::simd::min().

Here is the call graph for this function:

min() [5/7]

Expr olb::util::min	(	Expr	a,
		Expr	b )

Definition at line 249 of file expr.cpp.

                         {
  throw std::domain_error("Invalid operator for Expr type: 'min'");
}

Here is the caller graph for this function:

min() [6/7]

template<typename T >

T olb::util::min ( std::initializer_list< T > ilist )

inlineconstexpr

Definition at line 65 of file oalgorithm.h.

                                                       {
  return std::min(ilist);
}

min() [7/7]

template<typename T >

any_platform constexpr T olb::util::min ( T a, meta::id_t< T > b )

constexpr

Definition at line 56 of file oalgorithm.h.

                                                 {
#ifdef  __CUDA_ARCH__
  return ::min(a, b);
#else
  return std::min(a, b);
#endif
}

min_element()

template<typename T , unsigned Size>

T olb::util::min_element

(

const Vector< T, Size > &

a

)

finds minimum element of all elements

Definition at line 228 of file vectorHelpers.h.

{
  T min = a[0];
  for (unsigned int iDim=1; iDim < Size; ++iDim) {
    min = std::min(min,a[iDim]);
  }
  return min;
}

References min().

Here is the call graph for this function:

Here is the caller graph for this function:

minElementPos()

template<typename T , unsigned Size>

unsigned olb::util::minElementPos

(

const Vector< T, Size > &

a

)

finds position of minimum element of all elements

Definition at line 252 of file vectorHelpers.h.

{
  unsigned minPos = 0;
  for (unsigned int iDim=1; iDim < Size; ++iDim) {
    if (a[iDim]<a[minPos]){
      minPos = iDim;
    }
  }
  return minPos;
}

nearZero() [1/3]

template<class T , unsigned DIM>

bool olb::util::nearZero ( const ADf< T, DIM > & a )

inline

Definition at line 1087 of file aDiff.h.

{
  const T EPSILON = std::numeric_limits<T>::epsilon();
  if (a._v > -EPSILON && a._v < EPSILON) {
    return true;
  }
  else {
    return false;
  }
}

nearZero() [2/3]

template<typename T >

bool olb::util::nearZero ( T a )

inline

return true if a is close to zero

Definition at line 402 of file util.h.

{
  if (a==T()) {
    return true;
  }
  T EPSILON = std::numeric_limits<T>::epsilon();
  if (a > -EPSILON && a < EPSILON) {
    return true;
  }
  else {
    return false;
  }
}

Here is the caller graph for this function:

nearZero() [3/3]

template<typename T >

bool olb::util::nearZero ( T a, T epsilon )

inline

Definition at line 417 of file util.h.

{
  if (a > -epsilon && a < epsilon) {
    return true;
  }
  else {
    return false;
  }
}

norm() [1/3]

template<unsigned D, typename ARRAY_LIKE >

auto olb::util::norm

(

const ARRAY_LIKE &

u

)

Definition at line 155 of file util.h.

{
  return sqrt(normSqr<ARRAY_LIKE,D>(u));
}

References normSqr(), and sqrt().

Here is the call graph for this function:

norm() [2/3]

template<typename T >

T olb::util::norm

(

const std::vector< T > &

a

)

l2 norm of a vector of arbitrary length

Definition at line 122 of file vectorHelpers.h.

{
  return norm(a.data(), a.size());
}

References norm().

Here is the call graph for this function:

Here is the caller graph for this function:

norm() [3/3]

template<typename T >

T olb::util::norm	(	const T *	a,
		unsigned	size )

l2 norm of a vector of arbitrary length

Definition at line 115 of file vectorHelpers.h.

{
  return util::sqrt(norm2(a, size));
}

References norm2(), and sqrt().

Here is the call graph for this function:

norm2() [1/2]

template<typename T >

T olb::util::norm2

(

const std::vector< T > &

a

)

l2 norm to the power of 2 of a vector of arbitrary length

Definition at line 108 of file vectorHelpers.h.

{
  return norm2(a.data(), a.size());
}

References norm2().

Here is the call graph for this function:

norm2() [2/2]

template<typename T >

T olb::util::norm2	(	const T *	a,
		unsigned	size )

l2 norm to the power of 2 of a vector of arbitrary length

Definition at line 97 of file vectorHelpers.h.

{
  T v{};
  for (unsigned iD=0; iD<size; ++iD) {
    v += a[iD]*a[iD];
  }
  return v;
}

Here is the caller graph for this function:

normalize() [1/2]

template<typename T >

std::vector< T > olb::util::normalize

(

const std::vector< T > &

a

)

returns a normalized vector, works for arbitrary lengths

Definition at line 160 of file vectorHelpers.h.

{
  std::vector<T> out(a);
  T scale = norm(a);
  assert(scale>0);
  for (unsigned int iDim=0; iDim<a.size(); iDim++) {
    out[iDim] /= scale;
  }
  return out;
}

References norm().

Here is the call graph for this function:

normalize() [2/2]

template<typename T , unsigned D>

Vector< T, D > olb::util::normalize

(

const Vector< T, D > &

a

)

Definition at line 153 of file vectorHelpers.h.

{
  return a / norm(a);
}

References norm().

Here is the call graph for this function:

Here is the caller graph for this function:

normSqr() [1/4]

template<typename ARRAY_LIKE , unsigned D>

auto olb::util::normSqr

(

const ARRAY_LIKE &

u

)

Compute norm square of a d-dimensional vector.

Definition at line 145 of file util.h.

{
  auto uSqr = decltype(u[0]){};
  for (unsigned iD=0; iD < D; ++iD) {
    uSqr += u[iD]*u[iD];
  }
  return uSqr;
}

Here is the caller graph for this function:

normSqr() [2/4]

template<typename T , unsigned D, typename IMPL >

T olb::util::normSqr

(

const ScalarVector< T, D, IMPL > &

u

)

Compute norm square of a d-dimensional vector.

Definition at line 179 of file util.h.

{
  T uSqr = T();
  for (unsigned iD=0; iD < D; ++iD) {
    uSqr += u[iD]*u[iD];
  }
  return uSqr;
}

normSqr() [3/4]

template<typename T , unsigned D>

T olb::util::normSqr

(

const T *

u

)

Definition at line 161 of file util.h.

{
  auto uSqr = T{};
  for (unsigned iD=0; iD < D; ++iD) {
    uSqr += u[iD]*u[iD];
  }
  return uSqr;
}

normSqr() [4/4]

template<typename T >

T olb::util::normSqr

(

std::initializer_list< T >

data

)

Definition at line 171 of file util.h.

{
  return std::inner_product(data.begin(), data.end(), data.begin(), T(0));
}

operator!=() [1/3]

template<class T , unsigned DIM>

bool olb::util::operator!= ( const ADf< T, DIM > & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 762 of file aDiff.h.

{
  return a._v!=b._v;
}

operator!=() [2/3]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

bool olb::util::operator!= ( const ADf< T, DIM > & a, const U & b )

inlineconstexpr

Definition at line 768 of file aDiff.h.

{
  return a._v!=olb::BaseType<ADf<T,DIM>>(b);
}

operator!=() [3/3]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

bool olb::util::operator!= ( const U & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 774 of file aDiff.h.

{
  return olb::BaseType<ADf<T,DIM>>(a)!=b._v;
}

operator*() [1/3]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::operator* ( const ADf< T, DIM > & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 349 of file aDiff.h.

{
  return ADf<T,DIM>(a) *= b;
}

operator*() [2/3]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

ADf< T, DIM > olb::util::operator* ( const ADf< T, DIM > & a, const U & b )

inlineconstexpr

Definition at line 343 of file aDiff.h.

{
  return ADf<T,DIM>(a) *= olb::BaseType<ADf<T,DIM>>(b);
}

operator*() [3/3]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

ADf< T, DIM > olb::util::operator* ( const U & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 337 of file aDiff.h.

{
  return ADf<T,DIM>(b) *= olb::BaseType<ADf<T,DIM>>(a);
}

operator+() [1/4]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::operator+ ( const ADf< T, DIM > & a )

inlineconstexpr

Definition at line 375 of file aDiff.h.

{
  return ADf<T,DIM>(a);
}

operator+() [2/4]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::operator+ ( const ADf< T, DIM > & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 313 of file aDiff.h.

{
  return ADf<T,DIM>(a) += b;
}

operator+() [3/4]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

ADf< T, DIM > olb::util::operator+ ( const ADf< T, DIM > & a, const U & b )

inlineconstexpr

Definition at line 307 of file aDiff.h.

{
  return ADf<T,DIM>(a) += olb::BaseType<ADf<T,DIM>>(b);
}

operator+() [4/4]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

ADf< T, DIM > olb::util::operator+ ( const U & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 301 of file aDiff.h.

{
  return ADf<T,DIM>(b) += olb::BaseType<ADf<T,DIM>>(a);
}

operator-() [1/4]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::operator- ( const ADf< T, DIM > & a )

inlineconstexpr

Definition at line 381 of file aDiff.h.

{
  return ADf<T,DIM>(a) *= -1;
}

operator-() [2/4]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::operator- ( const ADf< T, DIM > & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 331 of file aDiff.h.

{
  return ADf<T,DIM>(a)-=b;
}

operator-() [3/4]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

ADf< T, DIM > olb::util::operator- ( const ADf< T, DIM > & a, const U & b )

inlineconstexpr

Definition at line 325 of file aDiff.h.

{
  return ADf<T,DIM>(a) -= olb::BaseType<ADf<T,DIM>>(b);
}

operator-() [4/4]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

ADf< T, DIM > olb::util::operator- ( const U & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 319 of file aDiff.h.

{
  return ADf<T,DIM>(-ADf<T,DIM>(b) + olb::BaseType<ADf<T,DIM>>(a));
}

operator/() [1/3]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::operator/ ( const ADf< T, DIM > & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 368 of file aDiff.h.

{
  return ADf<T,DIM>(a) /= b;
}

operator/() [2/3]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

ADf< T, DIM > olb::util::operator/ ( const ADf< T, DIM > & a, const U & b )

inlineconstexpr

Definition at line 361 of file aDiff.h.

{
  return ADf<T,DIM>(a) /= olb::BaseType<ADf<T,DIM>>(b);
}

operator/() [3/3]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

ADf< T, DIM > olb::util::operator/ ( const U & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 355 of file aDiff.h.

{
  return ADf<T,DIM>(a) /= b;
}

operator<() [1/3]

template<class T , unsigned DIM>

bool olb::util::operator< ( const ADf< T, DIM > & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 818 of file aDiff.h.

{
  return a._v<b._v;
}

operator<() [2/3]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

bool olb::util::operator< ( const ADf< T, DIM > & a, const U & b )

inlineconstexpr

Definition at line 824 of file aDiff.h.

{
  return a._v<olb::BaseType<ADf<T,DIM>>(b);
}

operator<() [3/3]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

bool olb::util::operator< ( const U & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 830 of file aDiff.h.

{
  return olb::BaseType<ADf<T,DIM>>(a)<b._v;
}

operator<<()

template<class T , unsigned DIM>

std::ostream & olb::util::operator<< ( std::ostream & os, const ADf< T, DIM > & o )

inline

Definition at line 277 of file aDiff.h.

{
  os << o._v;
  if constexpr (DIM>0) {
    os << o._d;
  }
  return os;
}

operator<=() [1/3]

template<class T , unsigned DIM>

bool olb::util::operator<= ( const ADf< T, DIM > & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 836 of file aDiff.h.

{
  return a._v<=b._v;
}

operator<=() [2/3]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

bool olb::util::operator<= ( const ADf< T, DIM > & a, const U & b )

inlineconstexpr

Definition at line 842 of file aDiff.h.

{
  return a._v<=olb::BaseType<ADf<T,DIM>>(b);
}

operator<=() [3/3]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

bool olb::util::operator<= ( const U & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 848 of file aDiff.h.

{
  return olb::BaseType<ADf<T,DIM>>(a)<=b._v;
}

operator==() [1/3]

template<class T , unsigned DIM>

bool olb::util::operator== ( const ADf< T, DIM > & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 744 of file aDiff.h.

{
  return a._v==b._v;
}

operator==() [2/3]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

bool olb::util::operator== ( const ADf< T, DIM > & a, const U & b )

inlineconstexpr

Definition at line 750 of file aDiff.h.

{
  return a._v==olb::BaseType<ADf<T,DIM>>(b);
}

operator==() [3/3]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

bool olb::util::operator== ( const U & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 756 of file aDiff.h.

{
  return olb::BaseType<ADf<T,DIM>>(a)==b._v;
}

operator>() [1/3]

template<class T , unsigned DIM>

bool olb::util::operator> ( const ADf< T, DIM > & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 781 of file aDiff.h.

{
  return a._v>b._v;
}

operator>() [2/3]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

bool olb::util::operator> ( const ADf< T, DIM > & a, const U & b )

inlineconstexpr

Definition at line 787 of file aDiff.h.

{
  return a._v>olb::BaseType<ADf<T,DIM>>(b);
}

operator>() [3/3]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

bool olb::util::operator> ( const U & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 793 of file aDiff.h.

{
  return olb::BaseType<ADf<T,DIM>>(a)>b._v;
}

operator>=() [1/3]

template<class T , unsigned DIM>

bool olb::util::operator>= ( const ADf< T, DIM > & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 799 of file aDiff.h.

{
  return a._v>=b._v;
}

operator>=() [2/3]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

bool olb::util::operator>= ( const ADf< T, DIM > & a, const U & b )

inlineconstexpr

Definition at line 805 of file aDiff.h.

{
  return a._v>=olb::BaseType<ADf<T,DIM>>(b);
}

operator>=() [3/3]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

bool olb::util::operator>= ( const U & a, const ADf< T, DIM > & b )

inlineconstexpr

Definition at line 811 of file aDiff.h.

{
  return olb::BaseType<ADf<T,DIM>>(a)>=b._v;
}

operator>>()

template<class T , unsigned DIM>

std::istream & olb::util::operator>> ( std::istream & is, ADf< T, DIM > & in )

inline

Definition at line 288 of file aDiff.h.

{
  is >> in._v;
  in._d = T{0};
  return is;
}

populationsContributingToDirection()

template<typename DESCRIPTOR , int... NORMAL>

auto olb::util::populationsContributingToDirection ( )

constexpr

Return array of population indices where c[iPop][iD] == NORMAL[iD].

Definition at line 232 of file util.h.

                                                                 {
  constexpr auto velocity_matches_direction = [](unsigned iPop) -> bool {
    return meta::indexed_pack_contains<NORMAL...>([iPop](unsigned iD, int x) -> bool {
      return x != 0 && x == descriptors::c<DESCRIPTOR>(iPop,iD);
    });
  };
  return meta::array_from_index_sequence(
    descriptors::filter_population_indices<DESCRIPTOR>(velocity_matches_direction));
};

References olb::meta::array_from_index_sequence(), olb::descriptors::c(), olb::descriptors::filter_population_indices(), and olb::meta::indexed_pack_contains().

Here is the call graph for this function:

Here is the caller graph for this function:

populationsContributingToVelocity()

template<typename DESCRIPTOR , unsigned iVel, int value>

auto olb::util::populationsContributingToVelocity ( )

constexpr

Return array of population indices where c[iVel] == value.

Definition at line 222 of file util.h.

                                                                {
  constexpr auto velocity_matches_value = [](unsigned iPop) -> bool {
    return descriptors::c<DESCRIPTOR>(iPop,iVel) == value;
  };
  return meta::array_from_index_sequence(
    descriptors::filter_population_indices<DESCRIPTOR>(velocity_matches_value));
};

References olb::meta::array_from_index_sequence(), olb::descriptors::c(), and olb::descriptors::filter_population_indices().

Here is the call graph for this function:

Here is the caller graph for this function:

pow() [1/9]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::pow ( const ADf< T, DIM > & a, const ADf< T, DIM > & b )

inline

Definition at line 415 of file aDiff.h.

{
  if (!util::nearZero(a._v)) {
    return exp(b*log(a));
  }
  else {
    ADf<T,DIM> c(std::pow(a._v, b._v), Vector<T,DIM> {std::numeric_limits<T>::quiet_NaN()});
#ifdef AdWarnings
    std::cout << "ADf WARNING: pow(Adf) - pow evaluated at non-differentiable point" << std::endl;
#endif
    if (std::isfinite(c._v)) {
      for (unsigned i = 0; i < DIM; ++i) {
        if (util::nearZero(a.d(i))) {
          c._d[i] = T(0);
        }
      }
    }
    return c;
  }
}

References exp(), log(), and nearZero().

Here is the call graph for this function:

pow() [2/9]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

ADf< T, DIM > olb::util::pow ( const ADf< T, DIM > & a, const U & b )

inline

Definition at line 405 of file aDiff.h.

{
  ADf<T,DIM> c(std::pow(a._v,T(b)), a._d);
  T tmp(T(b)*std::pow(a._v,b-T(1)));
  c._d*=tmp;
  return c;
}

pow() [3/9]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::pow ( const ADf< T, DIM > & a, int b )

inline

Definition at line 437 of file aDiff.h.

{
  ADf<T,DIM> c(std::pow(a._v,b), a._d);
  T tmp(b*std::pow(a._v, b-1));
  c._d*=tmp;
  return c;
}

pow() [4/9]

template<class T , unsigned DIM, typename U , typename std::enable_if< std::is_integral< U >::value|std::is_floating_point< U >::value, int >::type = 0>

ADf< T, DIM > olb::util::pow ( const U & a, const ADf< T, DIM > & b )

inline

Definition at line 396 of file aDiff.h.

{
  ADf<T,DIM> c(std::pow(T(a),b._v), b._d);
  T tmp(c._v*std::log(T(a)));
  c._d*=tmp;
  return c;
}

pow() [5/9]

template<std::floating_point T>

cpu::simd::Pack< T > olb::util::pow	(	cpu::simd::Pack< T >	base,
		cpu::simd::Pack< T >	exp )

Definition at line 122 of file pack.h.

{
  return cpu::simd::pow(base, exp);
}

References exp(), and olb::cpu::simd::pow().

Here is the call graph for this function:

pow() [6/9]

template<std::floating_point T, cpu::simd::concepts::convertible_to_pack S>

cpu::simd::Pack< T > olb::util::pow	(	cpu::simd::Pack< T >	base,
		S	exp )

Definition at line 128 of file pack.h.

{
  return cpu::simd::pow(base, cpu::simd::Pack<T>(exp));
}

References exp(), and olb::cpu::simd::pow().

Here is the call graph for this function:

pow() [7/9]

Expr olb::util::pow	(	Expr	base,
		Expr	exp )

Definition at line 235 of file expr.cpp.

                              {
  Expr::increment(Expr::Op::Pow);
  return Expr(base, Expr::Op::Pow, exp);
}

References exp(), olb::Expr::increment(), and olb::Expr::Pow.

Here is the call graph for this function:

pow() [8/9]

template<typename T , typename S >

any_platform std::enable_if_t< std::is_integral_v< T > &&std::is_integral_v< S >, double > olb::util::pow ( T x, S y )

inline

Definition at line 105 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::pow(x, y);
#else  //__CUDA_ARCH__
  return std::pow(x, y);
#endif //__CUDA_ARCH__
}

pow() [9/9]

template<typename T , typename S >

any_platform auto olb::util::pow ( T x, S y ) -> std::enable_if_t<std::is_floating_point_v<T> && std::is_floating_point_v<S>, decltype(std::pow(x, y))>

inline

Definition at line 40 of file omath.h.

{
#ifdef __CUDA_ARCH__
  if constexpr (std::is_same_v<T, float> && std::is_same_v<S, float>) {
    return ::powf(x, y);
  }
  else if constexpr (std::is_same_v<T, double> && std::is_same_v<S, double>) {
    return ::pow(x, y);
  }
  else {
    return ::pow(static_cast<double>(x), static_cast<double>(y));
    //libcu++ of cuda supports double and float. You will get warning in device code if you use in e.g. long double.
  }
#else  // __CUDA_ARCH__
  return std::pow(x, y);
#endif // __CUDA_ARCH__
}

powf() [1/2]

any_platform float olb::util::powf ( float base, float exp )

inline

Definition at line 114 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::powf(base, exp);
#else  //__CUDA_ARCH__
  return std::pow(base, exp);
#endif //__CUDA_ARCH__
}

References exp().

Here is the call graph for this function:

powf() [2/2]

any_platform float olb::util::powf ( int base, int exp )

inline

Definition at line 123 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::powf(base, exp);
#else  //__CUDA_ARCH__
  return std::pow(base, exp);
#endif //__CUDA_ARCH__
}

References exp().

Here is the call graph for this function:

powl()

long double olb::util::powl ( long double base, long double exp )

inline

Definition at line 132 of file omath.h.

{
  return pow(base, exp);
  //cuda dose not support this function.
}

References exp(), and pow().

Here is the call graph for this function:

pressureFromDensity()

template<typename T , typename DESCRIPTOR >

any_platform T olb::util::pressureFromDensity

(

T

latticeDensity

)

compute lattice pressure from lattice density

Definition at line 394 of file util.h.

{
  // p = (rho - 1) * c_s^2
  return (latticeDensity - 1.0) / descriptors::invCs2<T,DESCRIPTOR>();
}

References olb::descriptors::invCs2().

Here is the call graph for this function:

print()

template<typename U >

void olb::util::print	(	U	data,
		const std::string &	name = "",
		OstreamManager	clout = OstreamManager(std::cout,"print"),
		const char	delimiter = ',' )

Definition at line 431 of file vectorHelpers.h.

{
  static_assert(!std::is_integral<U>::value && !std::is_floating_point<U>::value, "passed integral or floating_point value to function print()");
  if (name != "") {
    clout << name << " = ";
  }
  for ( auto& element : data ) {
    clout << std::fixed << element << delimiter << ' ';
  }
  clout << std::endl;
}

Here is the caller graph for this function:

radianToDegree() [1/2]

template<typename T , unsigned D>

decltype(Vector< decltype(util::sqrt(T())), D >()) olb::util::radianToDegree

(

const Vector< T, D > &

angle

)

Definition at line 56 of file geometricOperations.h.

{
  constexpr BaseType<decltype(util::sqrt(T()))> conversionFactor = 180. / M_PI;
  return conversionFactor * angle;
}

References M_PI, and sqrt().

Here is the call graph for this function:

Here is the caller graph for this function:

radianToDegree() [2/2]

template<typename T >

decltype(util::sqrt(T())) olb::util::radianToDegree

(

T

angle

)

Definition at line 63 of file geometricOperations.h.

{
  return radianToDegree(Vector<T, 1>(angle))[0];
}

References radianToDegree().

Here is the call graph for this function:

remainingIndexes()

template<typename DESCRIPTORBASE >

std::vector< int > olb::util::remainingIndexes

(

const std::vector< int > &

indices

)

finds all the remaining indexes of a lattice given some other indexes

Definition at line 339 of file util.h.

{
  std::vector<int> remaining;
  for (int iPop = 0; iPop < DESCRIPTORBASE::q; ++iPop) {
    bool found = false;
    for (unsigned jPop = 0; jPop < indices.size(); ++jPop) {
      if (indices[jPop] == iPop) {
        found = true;
      }
    }
    if (!found) {
      remaining.push_back(iPop);
    }
  }
  return remaining;
}

rotateMofi()

template<typename T >

Matrix< T, 3, 3 > olb::util::rotateMofi ( const Vector< T, 3 > & mofi, const Vector< T, 9 > & rotationMatrix )

constexpr

Rotate moment of inertia (mofi)

Definition at line 261 of file geometricOperations.h.

{
  // I' = R(angle) * I * R(angle)^T
  // TODO: The inertia tensor is symmetric - make use of it
  T data[3][3] = {
      {mofi[0],    T {},    T {}},
      {   T {}, mofi[1],    T {}},
      {   T {},    T {}, mofi[2]}
  };
  Matrix<T, 3, 3>       inertiaTensor(data);
  const Matrix<T, 3, 3> _rotationMatrix(rotationMatrix);
  inertiaTensor =
      _rotationMatrix * inertiaTensor * (_rotationMatrix.transpose());
 
  return inertiaTensor;
}

References olb::Matrix< T, ROWS, COLS >::transpose().

Here is the call graph for this function:

round() [1/3]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::round ( const ADf< T, DIM > & a )

inline

Definition at line 928 of file aDiff.h.

{
  ADf<T,DIM> c (std::round(a._v));
  constexpr T EPSILON (std::numeric_limits<T>::epsilon());
  if (std::round(a._v - EPSILON) != std::round(a._v + EPSILON)) {
#ifdef AdWarnings
    std::cout << "ADf WARNING: round(Adf) - round evaluated at non-differentiable point" << std::endl;
#endif
    for (unsigned i = 0; i < DIM; ++i) {
      c._d[i] = (a.d(i) == 0) ? T(0) : std::numeric_limits<T>::quiet_NaN();
    }
  }
  return c;
}

Here is the caller graph for this function:

round() [2/3]

template<typename T >

any_platform std::enable_if_t< std::is_floating_point_v< T >, T > olb::util::round ( T x )

inline

Definition at line 1480 of file omath.h.

{
#ifdef __CUDA_ARCH__
  if constexpr (std::is_same_v<T, float>) {
    return ::roundf(x);
  }
  else if constexpr (std::is_same_v<T, double>) {
    return ::round(x);
  }
  else {
    return ::round(static_cast<double>(x));
    //libcu++ of cuda supports double and float. You will get warning in device code if you use in e.g. long double.
  }
#else  //__CUDA_ARCH__
  return std::round(x);
#endif //__CUDA_ARCH__
}

round() [3/3]

template<typename T >

any_platform std::enable_if_t< std::is_integral_v< T >, double > olb::util::round ( T x )

inline

Definition at line 1499 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::round(x);
#else  //__CUDA_ARCH__
  return std::round(x);
#endif //__CUDA_ARCH__
}

roundf() [1/3]

template<unsigned DIM>

ADf< float, DIM > olb::util::roundf ( const ADf< float, DIM > & a )

inline

Definition at line 944 of file aDiff.h.

{
  return round(a);
}

References round().

Here is the call graph for this function:

roundf() [2/3]

any_platform float olb::util::roundf ( float x )

inline

Definition at line 1461 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::roundf(x);
#else  //__CUDA_ARCH__
  return std::round(x);
#endif //__CUDA_ARCH__
}

roundf() [3/3]

any_platform float olb::util::roundf ( int x )

inline

Definition at line 1470 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::roundf(x);
#else  //__CUDA_ARCH__
  return std::round(x);
#endif //__CUDA_ARCH__
}

roundl() [1/2]

template<unsigned DIM>

ADf< long double, DIM > olb::util::roundl ( const ADf< long double, DIM > & a )

inline

Definition at line 950 of file aDiff.h.

{
  return round(a);
}

References round().

Here is the call graph for this function:

roundl() [2/2]

long double olb::util::roundl ( long double arg )

inline

Definition at line 1508 of file omath.h.

{
  return std::roundl(arg);
  //cuda dose not support this function.
}

scalarProduct() [1/2]

template<typename T >

T olb::util::scalarProduct	(	const std::vector< T > &	u1,
		const std::vector< T > &	u2 )

Definition at line 203 of file util.h.

{
  T prod = T();
  if (u1.size() == u2.size()) {
    for (unsigned iD=0; iD<u1.size(); ++iD) {
      prod += u1[iD]*u2[iD];
    }
  }
  return prod;
}

scalarProduct() [2/2]

template<typename T , int d>

T olb::util::scalarProduct	(	const Vector< T, d > &	u1,
		const Vector< T, d > &	u2 )

Definition at line 191 of file util.h.

{
  T prod = T();
  if (u1.size() == u2.size()) {
    for (unsigned iD=0; iD < u1.size(); ++iD) {
      prod += u1[iD]*u2[iD];
    }
  }
  return prod;
}

Here is the caller graph for this function:

serialSymmetricTensorIndex()

template<unsigned DIM>

unsigned olb::util::serialSymmetricTensorIndex	(	unsigned	i,
		unsigned	j )

Compute serial index of symmetric tensor.

Template Parameters

DIM	Spatial dimension

Parameters

i	First spatial index
j	Second spatial index

Returns

Serialized index, as it is used in computeStress

Definition at line 491 of file vectorHelpers.h.

{
  OLB_PRECONDITION(DIM > 1);
  OLB_PRECONDITION(DIM < 4);
  if constexpr (DIM==2) {
    return i+j;
  }
  else if constexpr (DIM==3) {
    const unsigned res = i+j;
    if ((i>0) && (j>0)) {
      return res+1;
    } else {
      return res;
    }
  }
  else {
    // other dimensions are not implemented
    exit(1);
  }
}

References OLB_PRECONDITION.

Here is the caller graph for this function:

sign()

template<typename T >

int olb::util::sign ( T val )

inline

Definition at line 53 of file util.h.

{
  return (0 < val) - (val < 0);
}

Here is the caller graph for this function:

sin() [1/3]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::sin ( const ADf< T, DIM > & a )

inline

Definition at line 569 of file aDiff.h.

{
  ADf<T,DIM> c(std::sin(a._v), a._d);
  T tmp(std::cos(a._v));
  c._d*=tmp;
  return c;
}

Here is the caller graph for this function:

sin() [2/3]

template<typename T >

any_platform std::enable_if_t< std::is_floating_point_v< T >, T > olb::util::sin ( T x )

inline

Definition at line 573 of file omath.h.

{
#ifdef __CUDA_ARCH__
  if constexpr (std::is_same_v<T, float>) {
    return ::sinf(x);
  }
  else if constexpr (std::is_same_v<T, double>) {
    return ::sin(x);
  }
  else {
    return ::sin(static_cast<double>(x));
    //libcu++ of cuda supports double and float. You will get warning in device code if you use in e.g. long double.
  }
#else  //__CUDA_ARCH__
  return std::sin(x);
#endif //__CUDA_ARCH__
}

sin() [3/3]

template<typename T >

any_platform std::enable_if_t< std::is_integral_v< T >, double > olb::util::sin ( T x )

inline

Definition at line 592 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::sin(x);
#else  //__CUDA_ARCH__
  return std::sin(x);
#endif //__CUDA_ARCH__
}

sinf() [1/2]

any_platform float olb::util::sinf ( float x )

inline

Definition at line 554 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::sinf(x);
#else  //__CUDA_ARCH__
  return std::sin(x);
#endif //__CUDA_ARCH__
}

sinf() [2/2]

any_platform float olb::util::sinf ( int x )

inline

Definition at line 563 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::sinf(x);
#else  //__CUDA_ARCH__
  return std::sin(x);
#endif //__CUDA_ARCH__
}

sinh() [1/3]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::sinh ( const ADf< T, DIM > & a )

inline

Definition at line 651 of file aDiff.h.

{
  return 0.5*(exp(a)-exp(-a));
}

References exp().

Here is the call graph for this function:

Here is the caller graph for this function:

sinh() [2/3]

template<typename T >

any_platform std::enable_if_t< std::is_floating_point_v< T >, T > olb::util::sinh ( T x )

inline

Definition at line 628 of file omath.h.

{
#ifdef __CUDA_ARCH__
  if constexpr (std::is_same_v<T, float>) {
    return ::sinhf(x);
  }
  else if constexpr (std::is_same_v<T, double>) {
    return ::sinh(x);
  }
  else {
    return ::sinh(static_cast<double>(x));
    //libcu++ of cuda supports double and float. You will get warning in device code if you use in e.g. long double.
  }
#else  //__CUDA_ARCH__
  return std::sinh(x);
#endif //__CUDA_ARCH__
}

sinh() [3/3]

template<typename T >

any_platform std::enable_if_t< std::is_integral_v< T >, double > olb::util::sinh ( T x )

inline

Definition at line 647 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::sinh(x);
#else  //__CUDA_ARCH__
  return std::sinh(x);
#endif //__CUDA_ARCH__
}

sinhf() [1/2]

any_platform float olb::util::sinhf ( float x )

inline

Definition at line 609 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::sinhf(x);
#else  //__CUDA_ARCH__
  return std::sinh(x);
#endif //__CUDA_ARCH__
}

sinhf() [2/2]

any_platform float olb::util::sinhf ( int x )

inline

Definition at line 618 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::sinhf(x);
#else  //__CUDA_ARCH__
  return std::sinh(x);
#endif //__CUDA_ARCH__
}

sinhl()

long double olb::util::sinhl ( long double arg )

inline

Definition at line 656 of file omath.h.

{
 
  return sinh(arg);
  //libcu++ of cuda dose not support long double. You will get warning in device code if you use.
}

References sinh().

Here is the call graph for this function:

sinl()

long double olb::util::sinl ( long double arg )

inline

Definition at line 601 of file omath.h.

{
  return sin(arg);
  //libcu++ of cuda dose not support long double. You will get warning in device code if you use.
}

References sin().

Here is the call graph for this function:

solveLinearSystem() [1/4]

template<typename T >

auto olb::util::solveLinearSystem	(	const Matrix< T, 2, 2 > &	a,
		const Vector< T, 2 > &	rhs )

Solve a * x = rhs.

Definition at line 158 of file matrix.h.

{
  return solveLinearSystem(a[0], a[1], rhs);
}

References solveLinearSystem().

Here is the call graph for this function:

Here is the caller graph for this function:

solveLinearSystem() [2/4]

template<typename T >

auto olb::util::solveLinearSystem	(	const Matrix< T, 3, 3 > &	a,
		const Vector< T, 3 > &	rhs )

Solve (a0 a1 a2) x = rhs.

Definition at line 167 of file matrix.h.

{
  return solveLinearSystem(a[0], a[1], a[2], rhs);
}

References solveLinearSystem().

Here is the call graph for this function:

solveLinearSystem() [3/4]

template<typename T >

Vector< T, 2 > olb::util::solveLinearSystem	(	const Vector< T, 2 > &	a0,
		const Vector< T, 2 > &	a1,
		const Vector< T, 2 > &	rhs )

Solve (a0 a1) x = rhs.

Definition at line 330 of file vectorHelpers.h.

{
  const T det = crossProduct2D(a0, a1);
  return Vector<T,2> (crossProduct2D(rhs, a1) / det, crossProduct2D(a0, rhs) / det);
}

References olb::crossProduct2D().

Here is the call graph for this function:

solveLinearSystem() [4/4]

template<typename T >

Vector< T, 3 > olb::util::solveLinearSystem	(	const Vector< T, 3 > &	a0,
		const Vector< T, 3 > &	a1,
		const Vector< T, 3 > &	a2,
		const Vector< T, 3 > &	rhs )

Solve (a0 a1 a2) x = rhs.

Definition at line 355 of file vectorHelpers.h.

{
  const T det = determinant(a0, a1, a2);
  return solveLinearSystem_help(a0, a1, a2, rhs, det);
}

References determinant(), and solveLinearSystem_help().

Here is the call graph for this function:

solveLinearSystem_help()

template<typename T >

Vector< T, 3 > olb::util::solveLinearSystem_help	(	const Vector< T, 3 > &	a0,
		const Vector< T, 3 > &	a1,
		const Vector< T, 3 > &	a2,
		const Vector< T, 3 > &	rhs,
		T	det )

Definition at line 338 of file vectorHelpers.h.

{
  Vector<T,3> res;
  res[0] = determinant(rhs, a1, a2) / det;
  res[1] = determinant(a0, rhs, a2) / det;
  res[2] = determinant(a0, a1, rhs) / det;
  return res;
}

References determinant().

Here is the call graph for this function:

Here is the caller graph for this function:

sqr() [1/2]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::sqr ( const ADf< T, DIM > & a )

inline

Definition at line 446 of file aDiff.h.

{
  ADf<T,DIM> c((a._v)*(a._v), a._d);
  T tmp(T(2)*a._v);
  c._d*=tmp;
  return c;
}

sqr() [2/2]

template<typename T >

any_platform T olb::util::sqr

(

T

arg

)

Definition at line 132 of file util.h.

{
  return arg*arg;
}

Here is the caller graph for this function:

sqrt() [1/6]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::sqrt ( const ADf< T, DIM > & a )

inline

Definition at line 556 of file aDiff.h.

{
  ADf<T,DIM> c(std::sqrt(a._v), a._d);
  T tmp(T(1.)/(c._v*T(2)));
  for (unsigned i = 0; i < DIM; ++i) {
    if (!util::nearZero(a.d(i))) {
      c._d[i] *= tmp;
    }
  }
  return c;
}

References nearZero().

Here is the call graph for this function:

sqrt() [2/6]

template<class TAPE >

auto olb::util::sqrt ( const util::ADtape::ActiveType< TAPE > & a )

inline

Definition at line 366 of file aDiffTape.h.

{
  return util::ADtape::sqrt(a);
}

References olb::util::ADtape::sqrt().

Here is the call graph for this function:

sqrt() [3/6]

template<std::floating_point T>

cpu::simd::Pack< T > olb::util::sqrt

(

cpu::simd::Pack< T >

value

)

Definition at line 110 of file pack.h.

{
  return value.sqrt();
}

sqrt() [4/6]

Expr olb::util::sqrt

(

Expr

x

)

Definition at line 225 of file expr.cpp.

                  {
  Expr::increment(Expr::Op::Sqrt);
  return Expr(Expr::Op::Sqrt, x);
}

References olb::Expr::increment(), and olb::Expr::Sqrt.

Here is the call graph for this function:

sqrt() [5/6]

template<typename T >

any_platform std::enable_if_t< std::is_integral_v< T >, double > olb::util::sqrt ( T arg )

inline

Definition at line 519 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::sqrt(arg);
#else  //__CUDA_ARCH__
  return std::sqrt(arg);
#endif //__CUDA_ARCH__
}

sqrt() [6/6]

template<typename T >

any_platform std::enable_if_t< std::is_floating_point_v< T >, T > olb::util::sqrt ( T x )

inline

Definition at line 500 of file omath.h.

{
#ifdef __CUDA_ARCH__
  if constexpr (std::is_same_v<T, float>) {
    return ::sqrtf(x);
  }
  else if constexpr (std::is_same_v<T, double>) {
    return ::sqrt(x);
  }
  else {
    return ::sqrt(static_cast<double>(x));
    //libcu++ of cuda supports double and float. You will get warning in device code if you use in e.g. long double.
  }
#else  //__CUDA_ARCH__
  return std::sqrt(x);
#endif //__CUDA_ARCH__
}

sqrtf() [1/2]

any_platform float olb::util::sqrtf ( float arg )

inline

Definition at line 528 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::sqrtf(arg);
#else  //__CUDA_ARCH__
  return std::sqrt(arg);
#endif //__CUDA_ARCH__
}

sqrtf() [2/2]

any_platform float olb::util::sqrtf ( int arg )

inline

Definition at line 537 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::sqrtf(arg);
#else  //__CUDA_ARCH__
  return std::sqrt(arg);
#endif //__CUDA_ARCH__
}

sqrtl()

long double olb::util::sqrtl ( long double arg )

inline

Definition at line 546 of file omath.h.

{
  return sqrt(arg);
  //libcu++ of cuda dose not support long double. You will get warning in device code if you use.
}

References sqrt().

Here is the call graph for this function:

subIndexOutgoing()

template<typename DESCRIPTOR , int direction, int orientation>

auto olb::util::subIndexOutgoing ( )

constexpr

Compute opposites of wall-incoming population indices.

Definition at line 262 of file util.h.

                                               {
  // Should be expressed in terms of populationsContributingToVelocity
  // but std::array / std::index_sequence distinction makes this ugly
  // To be revisitited
  constexpr auto velocity_matches_value = [](unsigned iPop) {
    return descriptors::c<DESCRIPTOR>(iPop,direction) == orientation;
  };
  constexpr auto opposite_population = [](unsigned iPop) {
    return descriptors::opposite<DESCRIPTOR>(iPop);
  };
  return meta::array_from_index_sequence(
    meta::map_index_sequence(opposite_population,
                             descriptors::filter_population_indices<DESCRIPTOR>(velocity_matches_value)));
}

References olb::meta::array_from_index_sequence(), olb::descriptors::c(), olb::descriptors::filter_population_indices(), olb::meta::map_index_sequence(), and olb::descriptors::opposite().

Here is the call graph for this function:

Here is the caller graph for this function:

subIndexOutgoing2DonCorners()

template<typename DESCRIPTOR , int normalX, int normalY>

auto olb::util::subIndexOutgoing2DonCorners ( )

constexpr

Definition at line 316 of file util.h.

                                                          {
  constexpr auto velocity_matches = [](unsigned iPop) {
    return ( descriptors::c<DESCRIPTOR>(iPop,0) * normalX
           + descriptors::c<DESCRIPTOR>(iPop,1) * normalY) < 0;
  };
  return meta::array_from_index_sequence(
    descriptors::filter_population_indices<DESCRIPTOR>(velocity_matches));
}

References olb::meta::array_from_index_sequence(), olb::descriptors::c(), and olb::descriptors::filter_population_indices().

Here is the call graph for this function:

Here is the caller graph for this function:

subIndexOutgoing3DonCorners()

template<typename DESCRIPTOR , int normalX, int normalY, int normalZ>

auto olb::util::subIndexOutgoing3DonCorners ( )

constexpr

Definition at line 327 of file util.h.

                                                          {
  constexpr auto velocity_matches = [](unsigned iPop) {
    return ( descriptors::c<DESCRIPTOR>(iPop,0) * normalX
           + descriptors::c<DESCRIPTOR>(iPop,1) * normalY
           + descriptors::c<DESCRIPTOR>(iPop,2) * normalZ) < 0;
  };
  return meta::array_from_index_sequence(
    descriptors::filter_population_indices<DESCRIPTOR>(velocity_matches));
}

References olb::meta::array_from_index_sequence(), olb::descriptors::c(), and olb::descriptors::filter_population_indices().

Here is the call graph for this function:

Here is the caller graph for this function:

subIndexOutgoing3DonEdges()

template<typename DESCRIPTOR , int plane, int normal1, int normal2>

auto olb::util::subIndexOutgoing3DonEdges ( )

constexpr

Definition at line 292 of file util.h.

                                                        {
  constexpr auto velocity_matches = [](unsigned iPop) {
           if constexpr (plane == 0) {
      return ( descriptors::c<DESCRIPTOR>(iPop,0) * 0
             + descriptors::c<DESCRIPTOR>(iPop,1) * (normal1 == 1 ? 1 : -1)
             + descriptors::c<DESCRIPTOR>(iPop,2) * (normal2 == 1 ? 1 : -1)) < 0;
    } else if constexpr (plane == 1) {
      return ( descriptors::c<DESCRIPTOR>(iPop,0) * (normal1 == 1 ? 1 : -1)
             + descriptors::c<DESCRIPTOR>(iPop,1) * 0
             + descriptors::c<DESCRIPTOR>(iPop,2) * (normal2 == 1 ? 1 : -1)) < 0;
    } else if constexpr (plane == 2) {
      return ( descriptors::c<DESCRIPTOR>(iPop,0) * (normal1 == 1 ? 1 : -1)
             + descriptors::c<DESCRIPTOR>(iPop,1) * (normal2 == 1 ? 1 : -1)
             + descriptors::c<DESCRIPTOR>(iPop,2) * 0) < 0;
    } else {
      return false;
    }
  };
  return meta::array_from_index_sequence(
    descriptors::filter_population_indices<DESCRIPTOR>(velocity_matches));
}

References olb::meta::array_from_index_sequence(), olb::descriptors::c(), and olb::descriptors::filter_population_indices().

Here is the call graph for this function:

Here is the caller graph for this function:

subIndexOutgoingRemaining()

template<typename DESCRIPTOR , int direction, int orientation>

auto olb::util::subIndexOutgoingRemaining ( )

constexpr

Definition at line 278 of file util.h.

                                                        {
  constexpr auto velocity_matches = [](unsigned iPop) {
    for (unsigned jPop : subIndexOutgoing<DESCRIPTOR,direction,orientation>()) {
      if (iPop == jPop) {
        return false;
      }
    }
    return true;
  };
  return meta::array_from_index_sequence(
    descriptors::filter_population_indices<DESCRIPTOR>(velocity_matches));
}

References olb::meta::array_from_index_sequence(), olb::descriptors::filter_population_indices(), and subIndexOutgoing().

Here is the call graph for this function:

Here is the caller graph for this function:

surfaceNormal()

template<typename S , unsigned D, typename F1 >

Vector< S, D > olb::util::surfaceNormal	(	const Vector< S, D > &	pos,
		const S	meshSize,
		F1	sdf )

Definition at line 236 of file indicatorBase.h.

{
  Vector<S,D> normal( S(0) );
 
  for (unsigned iD=0; iD<D; ++iD) {
    Vector<S,D> delta(S(0));
    delta[iD] = meshSize;
    normal[iD] = (sdf(pos+delta) - sdf(pos-delta)) / (2*meshSize);
  }
 
  return normal;
}

Here is the caller graph for this function:

tan() [1/3]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::tan ( const ADf< T, DIM > & a )

inline

Definition at line 587 of file aDiff.h.

{
  ADf<T,DIM> c(std::tan(a._v), a._d);
  T tmp(T(1)+c._v*c._v);
  c._d*=tmp;
  return c;
}

Here is the caller graph for this function:

tan() [2/3]

template<typename T >

any_platform std::enable_if_t< std::is_floating_point_v< T >, T > olb::util::tan ( T x )

inline

Definition at line 792 of file omath.h.

{
#ifdef __CUDA_ARCH__
  if constexpr (std::is_same_v<T, float>) {
    return ::tanf(x);
  }
  else if constexpr (std::is_same_v<T, double>) {
    return ::tan(x);
  }
  else {
    return ::tan(static_cast<double>(x));
    //libcu++ of cuda supports double and float. You will get warning in device code if you use in e.g. long double.
  }
#else  //__CUDA_ARCH__
  return std::tan(x);
#endif //__CUDA_ARCH__
}

tan() [3/3]

template<typename T >

any_platform std::enable_if_t< std::is_integral_v< T >, double > olb::util::tan ( T x )

inline

Definition at line 811 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::tan(x);
#else  //__CUDA_ARCH__
  return std::tan(x);
#endif //__CUDA_ARCH__
}

tanf() [1/2]

any_platform float olb::util::tanf ( float x )

inline

Definition at line 773 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::tanf(x);
#else  //__CUDA_ARCH__
  return std::tan(x);
#endif //__CUDA_ARCH__
}

tanf() [2/2]

any_platform float olb::util::tanf ( int x )

inline

Definition at line 782 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::tanf(x);
#else  //__CUDA_ARCH__
  return std::tan(x);
#endif //__CUDA_ARCH__
}

tanh() [1/3]

template<class T , unsigned DIM>

ADf< T, DIM > olb::util::tanh ( const ADf< T, DIM > & a )

inline

Definition at line 663 of file aDiff.h.

{
  return 1 - 2.0 / (exp(2*a) + 1);
}

References exp().

Here is the call graph for this function:

Here is the caller graph for this function:

tanh() [2/3]

template<typename T >

any_platform std::enable_if_t< std::is_floating_point_v< T >, T > olb::util::tanh ( T x )

inline

Definition at line 846 of file omath.h.

{
#ifdef __CUDA_ARCH__
  if constexpr (std::is_same_v<T, float>) {
    return ::tanhf(x);
  }
  else if constexpr (std::is_same_v<T, double>) {
    return ::tanh(x);
  }
  else {
    return ::tanh(static_cast<double>(x));
    //libcu++ of cuda supports double and float. You will get warning in device code if you use in e.g. long double.
  }
#else  //__CUDA_ARCH__
  return std::tanh(x);
#endif //__CUDA_ARCH__
}

tanh() [3/3]

template<typename T >

any_platform std::enable_if_t< std::is_integral_v< T >, double > olb::util::tanh ( T x )

inline

Definition at line 865 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::tanh(x);
#else  //__CUDA_ARCH__
  return std::tanh(x);
#endif //__CUDA_ARCH__
}

tanhf() [1/2]

any_platform float olb::util::tanhf ( float x )

inline

Definition at line 827 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::tanhf(x);
#else  //__CUDA_ARCH__
  return std::tanh(x);
#endif //__CUDA_ARCH__
}

tanhf() [2/2]

any_platform float olb::util::tanhf ( int x )

inline

Definition at line 836 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::tanhf(x);
#else  //__CUDA_ARCH__
  return std::tanh(x);
#endif //__CUDA_ARCH__
}

tanhl()

long double olb::util::tanhl ( long double arg )

inline

Definition at line 874 of file omath.h.

{
  return tanh(arg);
  //libcu++ of cuda dose not support long double. You will get warning in device code if you use.
}

References tanh().

Here is the call graph for this function:

tanl()

long double olb::util::tanl ( long double arg )

inline

Definition at line 820 of file omath.h.

{
  return tan(arg);
  //libcu++ of cuda dose not support long double. You will get warning in device code if you use.
}

References tan().

Here is the call graph for this function:

throwADfException()

template<typename T >

void olb::util::throwADfException ( T arg )

inlineconstexpr

Definition at line 1099 of file aDiff.h.

{
  static_assert(std::is_floating_point<T>::value,
                "The data type ADf has slipped in here. If you really want to use it here and lose all derivation information, then perform an explicit typecast.");
}

trunc() [1/2]

template<typename T >

any_platform std::enable_if_t< std::is_floating_point_v< T >, T > olb::util::trunc ( T x )

inline

Definition at line 1426 of file omath.h.

{
#ifdef __CUDA_ARCH__
  if constexpr (std::is_same_v<T, float>) {
    return ::truncf(x);
  }
  else if constexpr (std::is_same_v<T, double>) {
    return ::trunc(x);
  }
  else {
    return ::trunc(static_cast<double>(x));
    //libcu++ of cuda supports double and float. You will get warning in device code if you use in e.g. long double.
  }
#else  //__CUDA_ARCH__
  return std::trunc(x);
#endif //__CUDA_ARCH__
}

trunc() [2/2]

template<typename T >

any_platform std::enable_if_t< std::is_integral_v< T >, double > olb::util::trunc ( T x )

inline

Definition at line 1445 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::trunc(x);
#else  //__CUDA_ARCH__
  return std::trunc(x);
#endif //__CUDA_ARCH__
}

truncf() [1/2]

any_platform float olb::util::truncf ( float x )

inline

Definition at line 1407 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::truncf(x);
#else  //__CUDA_ARCH__
  return std::trunc(x);
#endif //__CUDA_ARCH__
}

truncf() [2/2]

any_platform float olb::util::truncf ( int x )

inline

Definition at line 1416 of file omath.h.

{
#ifdef __CUDA_ARCH__
  return ::truncf(x);
#else  //__CUDA_ARCH__
  return std::trunc(x);
#endif //__CUDA_ARCH__
}

truncl()

long double olb::util::truncl ( long double arg )

inline

Definition at line 1454 of file omath.h.

{
  return std::truncl(arg);
  //cuda dose not support this function.
}

Variable Documentation

is_adf_v

template<class T >

bool olb::util::is_adf_v = is_adf<T>::value

inlineconstexpr

Definition at line 124 of file aDiff.h.