dynamic array class More...

#include "random.h"
#include "classdesc.h"
#include <assert.h>
#include <cmath>
#include <limits>
#include <set>
#include <vector>
#include <iostream>
#include <iterator>
#include <pack_base.h>
#include <TCL_obj_base.h>

Include dependency graph for arrays.h:

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

Go to the source code of this file.

Classes
class	ecolab::array_ns::array< T >

class	ecolab::array_ns::unop< E, Op >

class	ecolab::array_ns::binop< E1, E2, Op >

class	ecolab::array_ns::RVindex< E, I >

class	ecolab::array_ns::LVindex< E, I >

struct	ecolab::array_ns::is_expression< T >

struct	ecolab::array_ns::is_expression< array< T > >

struct	ecolab::array_ns::is_expression< unop< T, Op > >

struct	ecolab::array_ns::is_expression< binop< E1, E2, Op > >

struct	ecolab::array_ns::one_is_expression< E1, E2 >

struct	ecolab::array_ns::both_are_expressions< E1, E2 >

struct	ecolab::array_ns::is_scalar< T >

struct	ecolab::array_ns::is_scalar< bool >

struct	ecolab::array_ns::is_scalar< char >

struct	ecolab::array_ns::is_scalar< short >

struct	ecolab::array_ns::is_scalar< int >

struct	ecolab::array_ns::is_scalar< long >

struct	ecolab::array_ns::is_scalar< unsigned char >

struct	ecolab::array_ns::is_scalar< unsigned short >

struct	ecolab::array_ns::is_scalar< unsigned int >

struct	ecolab::array_ns::is_scalar< unsigned long >

struct	ecolab::array_ns::is_scalar< float >

struct	ecolab::array_ns::is_scalar< double >

struct	ecolab::array_ns::is_integer< T >

struct	ecolab::array_ns::is_integer< bool >

struct	ecolab::array_ns::is_integer< char >

struct	ecolab::array_ns::is_integer< short >

struct	ecolab::array_ns::is_integer< int >

struct	ecolab::array_ns::is_integer< long >

struct	ecolab::array_ns::is_integer< unsigned char >

struct	ecolab::array_ns::is_integer< unsigned short >

struct	ecolab::array_ns::is_integer< unsigned int >

struct	ecolab::array_ns::is_integer< unsigned long >

struct	ecolab::array_ns::is_float< T >

struct	ecolab::array_ns::is_float< float >

struct	ecolab::array_ns::is_float< double >

struct	ecolab::array_ns::is_expression_and_scalar< E1, E2 >

struct	ecolab::array_ns::enable_if_c< bool, type >

struct	ecolab::array_ns::enable_if_c< false, T >

struct	ecolab::array_ns::enable_if< Cond, T >

struct	ecolab::array_ns::dummy< int >

struct	ecolab::array_ns::tt< T, bool, bool >

struct	ecolab::array_ns::tt< E, true, false >

struct	ecolab::array_ns::tt< S, false, true >

struct	ecolab::array_ns::traits< T >

struct	ecolab::array_ns::result< E1, E2 >

struct	ecolab::array_ns::result< void, T >

struct	ecolab::array_ns::result< T, void >

struct	ecolab::array_ns::result< void, void >

struct	ecolab::array_ns::result< bool, bool >

struct	ecolab::array_ns::Neg< T >

struct	ecolab::array_ns::Not< T >

struct	ecolab::array_ns::Add< E1, E2 >

struct	ecolab::array_ns::Sub< E1, E2 >

struct	ecolab::array_ns::Mul< E1, E2 >

struct	ecolab::array_ns::Div< E1, E2 >

struct	ecolab::array_ns::Mod< E1, E2 >

struct	ecolab::array_ns::Eq< E1, E2 >

struct	ecolab::array_ns::Neq< E1, E2 >

struct	ecolab::array_ns::Gt< E1, E2 >

struct	ecolab::array_ns::Gte< E1, E2 >

struct	ecolab::array_ns::Lt< E1, E2 >

struct	ecolab::array_ns::Lte< E1, E2 >

struct	ecolab::array_ns::And< E1, E2 >

struct	ecolab::array_ns::Or< E1, E2 >

struct	ecolab::array_ns::Pow< E1, E2 >

struct	ecolab::array_ns::Exp< T >

struct	ecolab::array_ns::Log< T >

struct	ecolab::array_ns::Log10< T >

struct	ecolab::array_ns::Sin< T >

struct	ecolab::array_ns::Cos< T >

struct	ecolab::array_ns::Tan< T >

struct	ecolab::array_ns::Asin< T >

struct	ecolab::array_ns::Acos< T >

struct	ecolab::array_ns::Atan< T >

struct	ecolab::array_ns::Atan2< E1, E2 >

struct	ecolab::array_ns::Sinh< T >

struct	ecolab::array_ns::Cosh< T >

struct	ecolab::array_ns::Tanh< T >

struct	ecolab::array_ns::Sqrt< T >

struct	ecolab::array_ns::Abs< T >

struct	ecolab::array_ns::Sgn< T >

struct	ecolab::array_ns::Ceil< T >

struct	ecolab::array_ns::Floor< T >

struct	ecolab::array_ns::Ldexp< E1, E2 >

struct	ecolab::array_ns::Fmod< E1, E2 >

struct	ecolab::array_ns::Max< E1, E2 >

struct	ecolab::array_ns::Min< E1, E2 >

class	ecolab::array_ns::RVindex< E, I >

class	ecolab::array_ns::LVindex< E, I >

struct	ecolab::array_ns::is_expression< RVindex< E, I > >

struct	ecolab::array_ns::is_expression< LVindex< E, I > >

class	ecolab::array_ns::unop< E, Op >

class	ecolab::array_ns::binop< E1, E2, Op >

class	ecolab::array_ns::binop< E1, double, Div< E1, double > >

class	ecolab::array_ns::binop< E1, float, Div< E1, float > >

class	ecolab::array_ns::array_data< T >

class	ecolab::array_ns::array< T >

class	ecolab::array_ns::Cmp< T >

struct	classdesc_access::access_pack< ecolab::array_ns::array< T > >

struct	classdesc_access::access_unpack< ecolab::array_ns::array< T > >

struct	classdesc_access::access_TCL_obj< ecolab::array_ns::array< T > >

struct	classdesc::tn< ecolab::array< T > >

Namespaces
	ecolab
	_OPENMP

	array_ns
	Namespace for array functionality.

	classdesc_access
	Contains access_* structs, and nothing else. These structs are used to gain access to private members.

	classdesc
	Contains definitions related to classdesc functionality.

Macros
#define	RESULTIII(T1, T2, R)

#define	RESULTBI(T1)

#define	RESULTBF(T1)

#define	RESULTIFF(T1, T2, R)

#define	RESULTFIF(T1, T2, R)

#define	RESULTFFF(T1, T2, R) template <> struct result<T1,T2> {typedef R value_type;};

Functions
	ecolab::array_ns::RESULTBI (char)

	ecolab::array_ns::RESULTBI (short)

	ecolab::array_ns::RESULTBI (int)

	ecolab::array_ns::RESULTBI (long)

	ecolab::array_ns::RESULTBF (float)

	ecolab::array_ns::RESULTBF (double)

	ecolab::array_ns::RESULTIII (char, char, char)

	ecolab::array_ns::RESULTIII (short, short, short)

	ecolab::array_ns::RESULTIII (char, short, short)

	ecolab::array_ns::RESULTIII (short, char, short)

	ecolab::array_ns::RESULTIII (int, int, int)

	ecolab::array_ns::RESULTIII (short, int, int)

	ecolab::array_ns::RESULTIII (int, short, int)

	ecolab::array_ns::RESULTIII (char, int, int)

	ecolab::array_ns::RESULTIII (int, char, int)

	ecolab::array_ns::RESULTIII (long, long, long)

	ecolab::array_ns::RESULTIII (int, long, long)

	ecolab::array_ns::RESULTIII (long, int, long)

	ecolab::array_ns::RESULTIII (short, long, long)

	ecolab::array_ns::RESULTIII (long, short, long)

	ecolab::array_ns::RESULTIII (char, long, long)

	ecolab::array_ns::RESULTIII (long, char, long)

	ecolab::array_ns::RESULTFFF (float, float, float)

	ecolab::array_ns::RESULTIFF (long, float, float)

	ecolab::array_ns::RESULTFIF (float, long, float)

	ecolab::array_ns::RESULTIFF (int, float, float)

	ecolab::array_ns::RESULTFIF (float, int, float)

	ecolab::array_ns::RESULTIFF (short, float, float)

	ecolab::array_ns::RESULTFIF (float, short, float)

	ecolab::array_ns::RESULTIFF (char, float, float)

	ecolab::array_ns::RESULTFIF (float, char, float)

	ecolab::array_ns::RESULTFFF (double, double, double)

	ecolab::array_ns::RESULTFFF (float, double, double)

	ecolab::array_ns::RESULTFFF (double, float, double)

	ecolab::array_ns::RESULTIFF (long, double, double)

	ecolab::array_ns::RESULTFIF (double, long, double)

	ecolab::array_ns::RESULTIFF (int, double, double)

	ecolab::array_ns::RESULTFIF (double, int, double)

	ecolab::array_ns::RESULTIFF (short, double, double)

	ecolab::array_ns::RESULTFIF (double, short, double)

	ecolab::array_ns::RESULTIFF (char, double, double)

	ecolab::array_ns::RESULTFIF (double, char, double)

template<class E1 , class E2 >
enable_if< both_are_expressions< E1, E2 >, array< typename result< typename E1::value_type, typename E2::value_type >::value_type > >::T	ecolab::array_ns::both_are_expressions_ns::operator<< (const E1 &e1, const E2 &e2)

template<class E1 , class E2 >
enable_if< is_expression< E1 >, typename enable_if< is_scalar< E2 >, array< typename result< typename E1::value_type, E2 >::value_type > >::T >::T	ecolab::array_ns::expression_scalar_ns::operator<< (const E1 &e1, const E2 &e2)

template<class E1 , class E2 >
enable_if< is_scalar< E1 >, typename enable_if< is_expression< E2 >, array< typename result< E1, typename E2::value_type >::value_type > >::T >::T	ecolab::array_ns::scalar_expression_ns::operator<< (const E1 &e1, const E2 &e2)


template<class E >
E::value_type &	ecolab::array_ns::at (E &x, size_t i, typename enable_if< is_expression< E >, int >::T dum=0)

template<class E >
E::value_type	ecolab::array_ns::at (const E &x, size_t i, typename enable_if< is_expression< E >, int >::T dum=0)

template<class S >
S &	ecolab::array_ns::at (S &x, size_t i, typename enable_if< is_scalar< S >, int >::T dum=0)

template<class S >
S	ecolab::array_ns::at (S x, size_t i, typename enable_if< is_scalar< S >, int >::T dum=0)

Variables
urand	ecolab::array_urand

gaussrand	ecolab::array_grand

enum	array_dir_t { upwards, downwards }

template<class E >
enable_if< is_expression< E >, size_t >::T	ecolab::array_ns::len (const E &x, dummy< 0 > d=0)

template<class S >
enable_if< is_scalar< S >, size_t >::T	ecolab::array_ns::len (const S &x, dummy< 1 > d=0)

template<class E1 , class E2 >
void	ecolab::array_ns::conformance_check (const E1 &e1, const E2 &e2)

template<class E >
enable_if< is_expression< E >, unop< E, Neg< typename E::value_type > > >::T	ecolab::array_ns::operator- (const E &e)

template<class E >
enable_if< is_expression< E >, unop< E, Not< typename E::value_type > > >::T	ecolab::array_ns::operator! (const E &e)

template<class E1 , class E2 >
enable_if< one_is_expression< E1, E2 >, binop< E1, E2, Add< E1, E2 > > >::T	ecolab::array_ns::operator+ (const E1 &e1, const E2 &e2)

template<class E1 , class E2 >
enable_if< one_is_expression< E1, E2 >, binop< E1, E2, Sub< E1, E2 > > >::T	ecolab::array_ns::operator- (const E1 &e1, const E2 &e2)

template<class E1 , class E2 >
enable_if< one_is_expression< E1, E2 >, binop< E1, E2, Mul< E1, E2 > > >::T	ecolab::array_ns::operator* (const E1 &e1, const E2 &e2)

template<class E1 , class E2 >
enable_if< one_is_expression< E1, E2 >, binop< E1, E2, Div< E1, E2 > > >::T	ecolab::array_ns::operator/ (const E1 &e1, const E2 &e2)

template<class E1 , class E2 >
enable_if< one_is_expression< E1, E2 >, binop< E1, E2, Mod< E1, E2 > > >::T	ecolab::array_ns::operator% (const E1 &e1, const E2 &e2)

template<class E1 , class E2 >
enable_if< one_is_expression< E1, E2 >, binop< E1, E2, Eq< E1, E2 > > >::T	ecolab::array_ns::operator== (const E1 &e1, const E2 &e2)

template<class E1 , class E2 >
enable_if< one_is_expression< E1, E2 >, binop< E1, E2, Neq< E1, E2 > > >::T	ecolab::array_ns::operator!= (const E1 &e1, const E2 &e2)

template<class E1 , class E2 >
enable_if< one_is_expression< E1, E2 >, binop< E1, E2, Gt< E1, E2 > > >::T	ecolab::array_ns::operator> (const E1 &e1, const E2 &e2)

template<class E1 , class E2 >
enable_if< one_is_expression< E1, E2 >, binop< E1, E2, Gte< E1, E2 > > >::T	ecolab::array_ns::operator>= (const E1 &e1, const E2 &e2)

template<class E1 , class E2 >
enable_if< one_is_expression< E1, E2 >, binop< E1, E2, Lt< E1, E2 > > >::T	ecolab::array_ns::operator< (const E1 &e1, const E2 &e2)

template<class E1 , class E2 >
enable_if< one_is_expression< E1, E2 >, binop< E1, E2, Lte< E1, E2 > > >::T	ecolab::array_ns::operator<= (const E1 &e1, const E2 &e2)

template<class E1 , class E2 >
enable_if< one_is_expression< E1, E2 >, binop< E1, E2, And< E1, E2 > > >::T	ecolab::array_ns::operator && (const E1 &e1, const E2 &e2)

template<class E1 , class E2 >
enable_if< one_is_expression< E1, E2 >, binop< E1, E2, Or< E1, E2 > > >::T	ecolab::array_ns::operator\|\| (const E1 &e1, const E2 &e2)

template<class E1 , class E2 >
bool	ecolab::array_ns::eq (const E1 &e1, const E2 &e2)

template<class E1 , class E2 >
binop< E1, E2, Pow< E1, E2 > >	ecolab::array_ns::pow (const E1 &e1, const E2 &e2)

template<class E >
unop< E, Exp< typename E::value_type > >	ecolab::array_ns::exp (const E &e)

template<class E >
unop< E, Log< typename E::value_type > >	ecolab::array_ns::log (const E &e)

template<class E >
unop< E, Log10< typename E::value_type > >	ecolab::array_ns::log10 (const E &e)

template<class E >
unop< E, Sin< typename E::value_type > >	ecolab::array_ns::sin (const E &e)

template<class E >
unop< E, Cos< typename E::value_type > >	ecolab::array_ns::cos (const E &e)

template<class E >
unop< E, Tan< typename E::value_type > >	ecolab::array_ns::tan (const E &e)

template<class E >
unop< E, Asin< typename E::value_type > >	ecolab::array_ns::asin (const E &e)

template<class E >
unop< E, Acos< typename E::value_type > >	ecolab::array_ns::acos (const E &e)

template<class E >
unop< E, Atan< typename E::value_type > >	ecolab::array_ns::atan (const E &e)

template<class E1 , class E2 >
binop< E1, E2, Atan2< E1, E2 > >	ecolab::array_ns::atan2 (const E1 &e1, const E2 &e2)

template<class E >
unop< E, Sinh< typename E::value_type > >	ecolab::array_ns::sinh (const E &e)

template<class E >
unop< E, Cosh< typename E::value_type > >	ecolab::array_ns::cosh (const E &e)

template<class E >
unop< E, Tanh< typename E::value_type > >	ecolab::array_ns::tanh (const E &e)

template<class E >
unop< E, Sqrt< typename E::value_type > >	ecolab::array_ns::sqrt (const E &e)

template<class E >
unop< E, Abs< typename E::value_type > >	ecolab::array_ns::fabs (const E &e)

template<class E >
unop< E, Abs< typename E::value_type > >	ecolab::array_ns::abs (const E &e)

template<class E >
unop< E, Sgn< typename E::value_type > >	ecolab::array_ns::sign (const E &e)

template<class E >
unop< E, Ceil< typename E::value_type > >	ecolab::array_ns::ceil (const E &e)

template<class E >
unop< E, Floor< typename E::value_type > >	ecolab::array_ns::floor (const E &e)

template<class E1 , class E2 >
binop< E1, E2, Ldexp< E1, E2 > >	ecolab::array_ns::ldexp (const E1 &e1, const E2 &e2)

template<class E1 , class E2 >
binop< E1, E2, Fmod< E1, E2 > >	ecolab::array_ns::fmod (const E1 &e1, const E2 &e2)

template<class E1 , class E2 >
enable_if< one_is_expression< E1, E2 >, binop< E1, E2, Max< E1, E2 > > >::T	ecolab::array_ns::max (const E1 &e1, const E2 &e2)

template<class E1 , class E2 >
enable_if< one_is_expression< E1, E2 >, binop< E1, E2, Min< E1, E2 > > >::T	ecolab::array_ns::min (const E1 &e1, const E2 &e2)

template<class T >
void	ecolab::array_ns::asg (T *dt, size_t sz, T x)

template<class T >
void	ecolab::array_ns::asg_plus (T *dt, size_t sz, T x)

template<class T >
void	ecolab::array_ns::asg_minus (T *dt, size_t sz, T x)

template<class T >
void	ecolab::array_ns::asg_mul (T *dt, size_t sz, T x)

template<class T >
void	ecolab::array_ns::asg_div (T *dt, size_t sz, T x)

template<class T >
enable_if< is_integer< T >, void >::T	ecolab::array_ns::asg_mod (T *dt, size_t sz, T x)

template<class T >
enable_if< is_integer< T >, void >::T	ecolab::array_ns::asg_and (T *dt, size_t sz, T x)

template<class T >
enable_if< is_integer< T >, void >::T	ecolab::array_ns::asg_or (T *dt, size_t sz, T x)

template<class T , class U >
void	ecolab::array_ns::asg_v (T *dt, size_t sz, const U &x)

template<class T , class U >
void	ecolab::array_ns::asg_plus_v (T *dt, size_t sz, const U &x)

template<class T , class U >
void	ecolab::array_ns::asg_minus_v (T *dt, size_t sz, const U &x)

template<class T , class U >
void	ecolab::array_ns::asg_mul_v (T *dt, size_t sz, const U &x)

template<class T , class U >
void	ecolab::array_ns::asg_div_v (T *dt, size_t sz, const U &x)

template<class T , class U >
void	ecolab::array_ns::asg_mod_v (T *dt, size_t sz, const U &x)

template<class T , class U >
void	ecolab::array_ns::asg_and_v (T *dt, size_t sz, const U &x)

template<class T , class U >
void	ecolab::array_ns::asg_or_v (T *dt, size_t sz, const U &x)

template<class E >
enable_if< is_expression< E >, array< size_t > >::T	ecolab::array_ns::pos (const E &x, dummy< 0 > d=0)

template<class S >
enable_if< is_scalar< S >, size_t >::T	ecolab::array_ns::pos (const S &x, dummy< 1 > d=1)

template<class E >
enable_if< is_expression< E >, array< bool > >::T	ecolab::array_ns::operator && (bool x, const E &e)

template<class T , class E >
enable_if< is_expression< E >, array< bool > >::T	ecolab::array_ns::operator && (T *x, const E &e)

template<class E >
enable_if< is_expression< E >, array< bool > >::T	ecolab::array_ns::operator\|\| (bool x, const E &e)

template<class E >
enable_if< is_expression< E >, typename E::value_type >::T	ecolab::array_ns::max (const E &x)
	maximum value of a vector expression $\max_i x_i$

template<class E >
enable_if< is_expression< E >, typename E::value_type >::T	ecolab::array_ns::min (const E &x)
	minimum value of a vector expression $\min_i x_i$

template<class E >
enable_if< is_expression< E >, typename result< typename E::value_type, typename E::value_type >::value_type >::T	ecolab::array_ns::sum (const E &x)
	sum of a vector expression $\sum_i x_i$

template<class E , class M >
enable_if< is_expression< E >, typename result< typename E::value_type, typename E::value_type >::value_type >::T	ecolab::array_ns::sum (const E &x, const M &mask)

template<class E >
enable_if< is_expression< E >, typename E::value_type >::T	ecolab::array_ns::prod (const E &x)
	product of a vector expression $\prod_i x_i$

template<class E , class M >
enable_if< is_expression< E >, typename E::value_type >::T	ecolab::array_ns::prod (const E &x, const M &mask)
	product of a vector expression $\prod_i x_i$

template<class E >
bool	ecolab::array_ns::any (const E &x)
	true iff any element x is true

template<class E >
bool	ecolab::array_ns::all (const E &x)
	true iff all elements of x are true

template<class E1 , class E2 , class E3 >
enable_if< is_expression< E1 >, array< typename result< E2, E3 >::value_type > >::T	ecolab::array_ns::merge (const E1 &mask, const E2 &x, const E3 &y)
	merge two vectors: r[i] = mask[i]? x[i]: y[i]

template<class E1 , class E2 >
enable_if< both_are_expressions< E1, E2 >, array< typename E1::value_type > >::T	ecolab::array_ns::pack (const E1 &e, const E2 &mask, long ntrue=-1)
	pack vector (remove elements where mask[i] is false

template<class E >
enable_if< is_expression< E >, array< size_t > >::T	ecolab::array_ns::enumerate (const E &x)
	running sum of x considered as a boolean mask

template<class E >
std::ostream &	ecolab::array_ns::put (std::ostream &o, const E &x)

template<class T >
std::ostream &	ecolab::array_ns::operator<< (std::ostream &o, const array< T > &x)

template<class T , class Op >
std::ostream &	ecolab::array_ns::operator<< (std::ostream &o, const unop< T, Op > &x)
	ostream putter

template<class E1 , class E2 , class Op >
std::ostream &	ecolab::array_ns::operator<< (std::ostream &o, const binop< E1, E2, Op > &x)

template<class T >
std::istream &	ecolab::array_ns::get (std::istream &s, T &x)
	istream getter

template<class T >
std::istream &	ecolab::array_ns::operator>> (std::istream &i, array< T > &x)

array< int >	ecolab::array_ns::pcoord (int n)
	[0...n-1]

array< int >	ecolab::array_ns::gen_index (const array< int > &x)

void	ecolab::array_ns::fillrand (array< double > &x)
	fill array with uniformly random numbers from [0,1)

void	ecolab::array_ns::fillgrand (array< double > &x)
	fill array with gaussian random numbers from $N(0,1)\propto\exp(-x^2/2)$

void	ecolab::array_ns::fillprand (array< double > &x)
	fill array with exponential random numbers $x\leftarrow-\ln\xi,\,\xi\in [0,1)$

void	ecolab::array_ns::fill_unique_rand (array< int > &x, unsigned max)
	fill with uniform numbers drawn from [0...max] without replacement

void	ecolab::array_ns::lgspread (array< double > &a, const array< double > &s)
	Multiplicative process $a\leftarrow a(1+\xi s),\, \xi\in N(0,1)$ .

void	ecolab::array_ns::gspread (array< double > &a, const array< double > &s)
	Additive process $a\leftarrow a+s\xi,\, \xi\in N(0,1)$ .

template<class E >
void	ecolab::array_ns::lgspread (array< double > &a, const E &s)
	Multiplicative process $a\leftarrow a(1+\xi s),\, \xi\in N(0,1)$ .

template<class E >
void	ecolab::array_ns::gspread (array< double > &a, const E &s)
	Additive process $a\leftarrow a+\xi s,\, \xi\in N(0,1)$ .

template<class T >
enable_if< is_expression< T >, array< int > >::T	ecolab::array_ns::rank (const T &x, enum array_dir_t dir=upwards)
	rank elements

Detailed Description

dynamic array class

Macro Definition Documentation

◆ RESULTBF

#define RESULTBF ( T1 )

Value:

template <> struct result<T1,bool> {typedef T1 value_type;}; \

template <> struct result<bool,T1> {typedef T1 value_type;}; \

◆ RESULTBI

#define RESULTBI ( T1 )

Value:

template <> struct result<T1,bool> {typedef T1 value_type;};        \
    template <> struct result<bool,T1> {typedef T1 value_type;};        \
    template <> struct result<bool,unsigned T1> {typedef unsigned T1 value_type;}; \
    template <> struct result<unsigned T1, bool> {typedef unsigned T1 value_type;}; \

◆ RESULTFIF

#define RESULTFIF	(	T1,
		T2,
		R
	)

Value:

template <> struct result<T1,T2> {typedef R value_type;}; \

template <> struct result<T1,unsigned T2> {typedef R value_type;}; \

◆ RESULTIFF

#define RESULTIFF	(	T1,
		T2,
		R
	)

Value:

template <> struct result<T1,T2> {typedef R value_type;}; \

template <> struct result<unsigned T1, T2> {typedef R value_type;}; \

◆ RESULTIII

#define RESULTIII	(	T1,
		T2,
		R
	)

Value:

template <> struct result<T1,T2> {typedef R value_type;};           \
    template <> struct result<T1,unsigned T2> {typedef R value_type;};  \
    template <> struct result<unsigned T1, T2> {typedef R value_type;}; \
    template <> struct result<unsigned T1,unsigned T2>{typedef unsigned R value_type;};

Function Documentation

◆ abs()

template<class E >

unop<E,Abs<typename E::value_type> > ecolab::array_ns::abs ( const E & e )

elementwise absolute value abs(x) $=|x|$

References ecolab::array_ns::abs().

Referenced by ecolab::array_ns::abs().

◆ acos()

template<class E >

unop<E,Acos<typename E::value_type> > ecolab::array_ns::acos ( const E & e )

elementwise arccosine

References ecolab::array_ns::acos().

Referenced by ecolab::array_ns::acos().

◆ asin()

template<class E >

unop<E,Asin<typename E::value_type> > ecolab::array_ns::asin ( const E & e )

elementwise arcsine

References ecolab::array_ns::asin().

Referenced by ecolab::array_ns::asin().

◆ at()

template<class E >

E::value_type& ecolab::array_ns::at	(	E &	x,
		size_t	i,
		typename enable_if< is_expression< E >, int >::T	dum = `0`
	)

at(x,i) = x[i] is an expression, otherwise just x

◆ atan()

template<class E >

unop<E,Atan<typename E::value_type> > ecolab::array_ns::atan ( const E & e )

elementwise arctangent

References ecolab::array_ns::atan().

Referenced by ecolab::array_ns::atan().

◆ atan2()

template<class E1 , class E2 >

binop<E1,E2,Atan2<E1,E2> > ecolab::array_ns::atan2	(	const E1 &	e1,
		const E2 &	e2
	)

elementwise atan2(x,y) $=\tan^{-1}(x/y)\in[-\pi/2,\pi/2]$

References ecolab::array_ns::atan2().

Referenced by ecolab::array_ns::atan2().

◆ ceil()

template<class E >

unop<E,Ceil<typename E::value_type> > ecolab::array_ns::ceil ( const E & e )

elementwise ceil(x) $=\lceil x\rceil$

References ecolab::array_ns::ceil().

Referenced by ecolab::array_ns::ceil().

◆ cos()

template<class E >

unop<E,Cos<typename E::value_type> > ecolab::array_ns::cos ( const E & e )

elementwise cosine

References ecolab::array_ns::cos().

Referenced by ecolab::array_ns::cos().

◆ cosh()

template<class E >

unop<E,Cosh<typename E::value_type> > ecolab::array_ns::cosh ( const E & e )

elementwise hyperbolic cosine

References ecolab::array_ns::cosh().

Referenced by ecolab::array_ns::cosh().

◆ eq()

template<class E1 , class E2 >

bool ecolab::array_ns::eq	(	const E1 &	e1,
		const E2 &	e2
	)

Convenience function for testing equality between two expressions Equivalent to all(e1==e2)

References ecolab::array_ns::eq().

Referenced by ecolab::array_ns::eq().

◆ exp()

template<class E >

unop<E,Exp<typename E::value_type> > ecolab::array_ns::exp ( const E & e )

elementwise exponential

References ecolab::array_ns::exp().

Referenced by ecolab::array_ns::exp().

◆ fabs()

template<class E >

unop<E,Abs<typename E::value_type> > ecolab::array_ns::fabs ( const E & e )

elementwise absolute value fabs(x) $=|x|$

References ecolab::array_ns::fabs().

Referenced by ecolab::array_ns::fabs().

◆ floor()

template<class E >

unop<E,Floor<typename E::value_type> > ecolab::array_ns::floor ( const E & e )

elementwise floor(x) $=\lfloor x\rfloor$

References ecolab::array_ns::floor().

Referenced by ecolab::array_ns::floor().

◆ fmod()

template<class E1 , class E2 >

binop<E1,E2,Fmod<E1,E2> > ecolab::array_ns::fmod	(	const E1 &	e1,
		const E2 &	e2
	)

elementwise fmod(x,y) = floating point remainder of x/y

References ecolab::array_ns::fmod().

Referenced by ecolab::array_ns::fmod().

◆ gen_index()

array<int> ecolab::array_ns::gen_index ( const array< int > & x )

inline

For an integer array x, return the inverse of the running sum.

Let s[i] = {j=0}^{i} x[j] be the running sum of x. Then s's inverse r satisfies r[s[i]-1] = i.

For instance, if x=(1,2,3,1), the running sum is (1,3,6,7), the inverse of which is (0,1,1,2,2,2,3).

References ecolab::array_ns::gen_index().

Referenced by ecolab::array_ns::gen_index().

◆ ldexp()

template<class E1 , class E2 >

binop<E1,E2,Ldexp<E1,E2> > ecolab::array_ns::ldexp	(	const E1 &	e1,
		const E2 &	e2
	)

elementwise ldexp(x,n) $=x\times2^n$

References ecolab::array_ns::ldexp().

Referenced by ecolab::array_ns::ldexp().

◆ len()

template<class E >

enable_if< is_expression<E>, size_t >::T ecolab::array_ns::len	(	const E &	x,
		dummy< 0 >	d = `0`
	)

len(x)==x.size() if x is an expression, otherwise 1

◆ log()

template<class E >

unop<E,Log<typename E::value_type> > ecolab::array_ns::log ( const E & e )

elementwise natural logarithm

References ecolab::array_ns::log().

Referenced by ecolab::array_ns::log().

◆ log10()

template<class E >

unop<E,Log10<typename E::value_type> > ecolab::array_ns::log10 ( const E & e )

elementwise common logarithm

References ecolab::array_ns::log10().

Referenced by ecolab::array_ns::log10().

◆ max()

template<class E1 , class E2 >

enable_if< one_is_expression<E1,E2>, binop<E1,E2,Max<E1,E2> > >::T ecolab::array_ns::max	(	const E1 &	e1,
		const E2 &	e2
	)

elementwise maximum of x and y

References ecolab::array_ns::max().

Referenced by ecolab::array_ns::max().

◆ min()

template<class E1 , class E2 >

enable_if< one_is_expression<E1,E2>, binop<E1,E2,Min<E1,E2> > >::T ecolab::array_ns::min	(	const E1 &	e1,
		const E2 &	e2
	)

elementwise minimum of x and y

References ecolab::array_ns::min().

Referenced by ecolab::array_ns::min().

◆ pow()

template<class E1 , class E2 >

binop<E1,E2,Pow<E1,E2> > ecolab::array_ns::pow	(	const E1 &	e1,
		const E2 &	e2
	)

pow(x,y) elementwise $x^y$

References ecolab::array_ns::pow().

Referenced by ecolab::array_ns::pow().

◆ sign()

template<class E >

unop<E,Sgn<typename E::value_type> > ecolab::array_ns::sign ( const E & e )

elementwise signum sign(x) $=\left\{ \begin{array}{ll} 1& x\geq0\\ -1&x<0\\ \end{array}\right.$

References ecolab::array_ns::sign().

Referenced by ecolab::array_ns::sign().

◆ sin()

template<class E >

unop<E,Sin<typename E::value_type> > ecolab::array_ns::sin ( const E & e )

elementwise sine

References ecolab::array_ns::sin().

Referenced by ecolab::array_ns::sin().

◆ sinh()

template<class E >

unop<E,Sinh<typename E::value_type> > ecolab::array_ns::sinh ( const E & e )

elementwise hyperbolic sine

References ecolab::array_ns::sinh().

Referenced by ecolab::array_ns::sinh().

◆ sqrt()

template<class E >

unop<E,Sqrt<typename E::value_type> > ecolab::array_ns::sqrt ( const E & e )

elementwise square root

References ecolab::array_ns::sqrt().

Referenced by ecolab::array_ns::sqrt().

◆ tan()

template<class E >

unop<E,Tan<typename E::value_type> > ecolab::array_ns::tan ( const E & e )

elementwise tangent

References ecolab::array_ns::tan().

Referenced by ecolab::array_ns::tan().

◆ tanh()

template<class E >

unop<E,Tanh<typename E::value_type> > ecolab::array_ns::tanh ( const E & e )

elementwise hyperbolic tangent

References ecolab::array_ns::tanh().

Referenced by ecolab::array_ns::tanh().

Classes

Namespaces

Macros

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ RESULTBF

◆ RESULTBI

◆ RESULTFIF

◆ RESULTIFF

◆ RESULTIII

Function Documentation

◆ abs()

◆ acos()

◆ asin()

◆ at()

◆ atan()

◆ atan2()

◆ ceil()

◆ cos()

◆ cosh()

◆ eq()

◆ exp()

◆ fabs()

◆ floor()

◆ fmod()

◆ gen_index()

◆ ldexp()

◆ len()

◆ log()

◆ log10()

◆ max()

◆ min()

◆ pow()

◆ sign()

◆ sin()

◆ sinh()

◆ sqrt()

◆ tan()

◆ tanh()