aDiff.h File Reference

The description of a algoritmic differentiation data type using the forward method – header file. More...

#include <cstdlib>
#include <type_traits>
#include <array>
#include <iostream>
#include <cassert>
#include "core/baseType.h"
#include "core/vector.h"
#include "core/util.h"

Include dependency graph for aDiff.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	AD
class	olb::util::ADf< T, DIM >
	Definition of a description of a algoritmic differentiation data type using the forward method. More...
struct	olb::util::is_adf< T >
struct	olb::util::is_adf< ADf< S, DIM > >

Namespaces
namespace	olb
	Top level namespace for all of OpenLB.
namespace	olb::util

Functions
template<class T , unsigned DIM>
std::ostream &	olb::util::operator<< (std::ostream &os, const ADf< T, DIM > &o)
template<class T , unsigned DIM>
std::istream &	olb::util::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 >	olb::util::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 >	olb::util::operator+ (const ADf< T, DIM > &a, const U &b)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	olb::util::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 >	olb::util::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 >	olb::util::operator- (const ADf< T, DIM > &a, const U &b)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	olb::util::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 >	olb::util::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 >	olb::util::operator* (const ADf< T, DIM > &a, const U &b)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	olb::util::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 >	olb::util::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 >	olb::util::operator/ (const ADf< T, DIM > &a, const U &b)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	olb::util::operator/ (const ADf< T, DIM > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	olb::util::operator+ (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	olb::util::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 >	olb::util::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 >	olb::util::pow (const ADf< T, DIM > &a, const U &b)
template<class T , unsigned DIM>
ADf< T, DIM >	olb::util::pow (const ADf< T, DIM > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
ADf< T, DIM >	olb::util::pow (const ADf< T, DIM > &a, int b)
template<class T , unsigned DIM>
ADf< T, DIM >	olb::util::sqr (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	olb::util::exp (const ADf< T, DIM > &a)
template<unsigned DIM>
ADf< float, DIM >	olb::util::expf (const ADf< float, DIM > &a)
template<unsigned DIM>
ADf< long double, DIM >	olb::util::expl (const ADf< long double, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	olb::util::log (const ADf< T, DIM > &a)
template<unsigned DIM>
ADf< float, DIM >	olb::util::logf (const ADf< float, DIM > &a)
template<unsigned DIM>
ADf< long double, DIM >	olb::util::logl (const ADf< long double, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	olb::util::log10 (const ADf< T, DIM > &a)
template<unsigned DIM>
ADf< float, DIM >	olb::util::log10f (const ADf< float, DIM > &a)
template<unsigned DIM>
ADf< long double, DIM >	olb::util::log10l (const ADf< long double, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	olb::util::log2 (const ADf< T, DIM > &a)
template<unsigned DIM>
ADf< float, DIM >	olb::util::log2f (const ADf< float, DIM > &a)
template<unsigned DIM>
ADf< long double, DIM >	olb::util::log2l (const ADf< long double, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	olb::util::log1p (const ADf< T, DIM > &a)
template<unsigned DIM>
ADf< float, DIM >	olb::util::log1pf (const ADf< float, DIM > &a)
template<unsigned DIM>
ADf< long double, DIM >	olb::util::log1pl (const ADf< long double, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	olb::util::sqrt (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	olb::util::sin (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	olb::util::cos (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	olb::util::tan (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	olb::util::asin (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	olb::util::acos (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	olb::util::atan (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	olb::util::atan2 (const T &y, const ADf< T, DIM > &x)
template<class T , unsigned DIM>
ADf< T, DIM >	olb::util::atan2 (const ADf< T, DIM > &y, const T &x)
template<class T , unsigned DIM>
ADf< T, DIM >	olb::util::atan2 (const ADf< T, DIM > &y, const ADf< T, DIM > &x)
template<class T , unsigned DIM>
ADf< T, DIM >	olb::util::sinh (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	olb::util::cosh (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	olb::util::tanh (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	olb::util::asinh (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	olb::util::acosh (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	olb::util::atanh (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	olb::util::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 >	olb::util::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 >	olb::util::fmod (const U &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
constexpr bool	olb::util::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	olb::util::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	olb::util::operator== (const U &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
constexpr bool	olb::util::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	olb::util::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	olb::util::operator!= (const U &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
constexpr bool	olb::util::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	olb::util::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	olb::util::operator> (const U &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
constexpr bool	olb::util::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	olb::util::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	olb::util::operator>= (const U &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
constexpr bool	olb::util::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	olb::util::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	olb::util::operator< (const U &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
constexpr bool	olb::util::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	olb::util::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	olb::util::operator<= (const U &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
ADf< T, DIM >	olb::util::floor (const ADf< T, DIM > &a)
template<unsigned DIM>
ADf< float, DIM >	olb::util::floorf (const ADf< float, DIM > &a)
template<unsigned DIM>
ADf< long double, DIM >	olb::util::floorl (const ADf< long double, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	olb::util::ceil (const ADf< T, DIM > &a)
template<unsigned DIM>
ADf< float, DIM >	olb::util::ceilf (const ADf< float, DIM > &a)
template<unsigned DIM>
ADf< long double, DIM >	olb::util::ceill (const ADf< long double, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	olb::util::round (const ADf< T, DIM > &a)
template<unsigned DIM>
ADf< float, DIM >	olb::util::roundf (const ADf< float, DIM > &a)
template<unsigned DIM>
ADf< long double, DIM >	olb::util::roundl (const ADf< long double, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	olb::util::lround (const ADf< T, DIM > &a)
template<unsigned DIM>
ADf< float, DIM >	olb::util::lroundf (const ADf< float, DIM > &a)
template<unsigned DIM>
ADf< long double, DIM >	olb::util::lroundl (const ADf< long double, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	olb::util::llround (const ADf< T, DIM > &a)
template<unsigned DIM>
ADf< float, DIM >	olb::util::llroundf (const ADf< float, DIM > &a)
template<unsigned DIM>
ADf< long double, DIM >	olb::util::llroundl (const ADf< long double, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	olb::util::fabs (const ADf< T, DIM > &a)
template<unsigned DIM>
ADf< float, DIM >	olb::util::fabsf (const ADf< float, DIM > &a)
template<unsigned DIM>
ADf< long double, DIM >	olb::util::fabsl (const ADf< long double, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	olb::util::abs (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	olb::util::labs (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
ADf< T, DIM >	olb::util::llabs (const ADf< T, DIM > &a)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	olb::util::max (const olb::BaseType< ADf< T, DIM > > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	olb::util::max (const ADf< T, DIM > &a, const olb::BaseType< ADf< T, DIM > > &b)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	olb::util::max (const ADf< T, DIM > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	olb::util::min (const olb::BaseType< ADf< T, DIM > > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	olb::util::min (const ADf< T, DIM > &a, const olb::BaseType< ADf< T, DIM > > &b)
template<class T , unsigned DIM>
constexpr ADf< T, DIM >	olb::util::min (const ADf< T, DIM > &a, const ADf< T, DIM > &b)
template<class T , unsigned DIM>
bool	olb::util::nearZero (const ADf< T, DIM > &a)
template<typename T >
constexpr void	olb::util::throwADfException (T arg)

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

Detailed Description

The description of a algoritmic differentiation data type using the forward method – header file.

Definition in file aDiff.h.