expression.h
Go to the documentation of this file.
#ifndef _RHEOLEF_EXPRESSION_H
#define _RHEOLEF_EXPRESSION_H
//
// This file is part of Rheolef.
//
// Copyright (C) 2000-2009 Pierre Saramito
//
// Rheolef is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// Rheolef is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Rheolef; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
// ==========================================================================
// author: Pierre.Saramito@imag.fr
// date: 25 march 2013
namespace rheolef {
} // namespace rheolef
/*
This file "expression.h" focuses on operators between fields
since the field return value (scalar,vector,tensor) is not known
at compile time, operators try to infer it when the return type
or a second argument is known at compile time
optherwise, the return value is undeterminated_basic<T> that
will be solved at run time from the field::valued_tag() method.
OVERVIEW:
0. error utilities
1. unary operations
1.1. unary function helper
1.2. unary operators: +x -x
1.3. unary standard maths: sin(x), cos(x), ...
1.4. unary extensions: tr(x), trans(x), norm(x) norm2(x)
2. binary operations
2.1. binary function helper
2.2. binary operators: x+y, x-y, x*y, x/y
2.3. binary standard maths: pow(x,y), atan2(x,y),...
2.4. binary extensions: dot(x,y), ddot(x,y)
3. binders
3.1. binder_first
3.2. binder_second
3.3. swapper
*/
#include "rheolef/promote.h"
#include "rheolef/undeterminated.h"
#include "rheolef/space_constant.h"
namespace rheolef { namespace details {
// ===========================================================================
// part 0. error utilities
// ===========================================================================
template<class Op, class T1, class T2, class R>
struct binop_error {};
template <class T> struct is_error: std::false_type {};
template<class Op, class T1, class T2, class R>
struct is_error<binop_error<Op,T1,T2,R> >: std::true_type {};
} // namespace details
template<class Op, class T1, class T2, class R>
struct float_traits<details::binop_error<Op,T1,T2,R> > { typedef typename float_traits<R>::type type; };
// ===========================================================================
// part 1. unary operations
// ===========================================================================
namespace details {
// ---------------------------------------------------------------------------
// chap 1.1. unary function helper
// ---------------------------------------------------------------------------
// defualt is STL class-functions
template<class Function>
struct generic_unary_traits {
template <class Arg>
struct result_hint {
typedef typename function_traits<Function>::result_type type;
};
template <class Arg, class Result>
struct hint {
typedef typename function_traits<Function>::result_type result_type;
typedef typename std::decay<typename function_traits<Function>::template arg<0>::type>::type
argument_type;
};
static space_constant::valued_type
valued_tag (space_constant::valued_type) {
return space_constant::valued_tag_traits<typename function_traits<Function>::result_type>::value;
}
};
// ----------------------------------------------------------------------------
// chap 1.2. unary operators: +x -x
// ----------------------------------------------------------------------------
// +x
// ------
struct unary_plus {
template <class T> T operator() (const T& a) const { return +a; }
};
template<>
struct generic_unary_traits<unary_plus> {
template <class Arg>
struct result_hint {
typedef Arg type;
};
template <class Arg, class Result>
struct hint {
typedef typename promote<Arg,Result>::type result_type;
typedef result_type argument_type;
};
static space_constant::valued_type
valued_tag (space_constant::valued_type tag) {
return tag;
}
};
// ------
// -x
// ------
struct negate {
template <class T> T operator() (const T& a) const { return -a; }
};
template<>
struct generic_unary_traits<negate> {
template <class Arg>
struct result_hint {
typedef Arg type;
};
template <class Arg, class Result>
struct hint {
typedef typename promote<Arg,Result>::type result_type;
typedef result_type argument_type;
};
static space_constant::valued_type
valued_tag (space_constant::valued_type tag) {
return tag;
}
};
// ----------------------------------------------------------------------------
// chap 1.3. unary standard maths: sin(x), cos(x), ...
// ----------------------------------------------------------------------------
// specialization for is scalar generic functions, as details::sin_, details::cos_, etc
#define _RHEOLEF_generic_unary_scalar(F) \
struct F##_ { \
template<class T> \
T operator() (const T& x) const { return F(x); } \
}; \
template<> \
struct generic_unary_traits<F##_> { \
template <class Arg> \
struct result_hint { \
typedef typename scalar_traits<Arg>::type type; \
}; \
template <class Arg, class Result> \
struct hint { \
typedef typename promote< \
typename scalar_traits<Arg>::type \
,typename scalar_traits<Result>::type>::type S; \
typedef S result_type; \
typedef S argument_type; \
}; \
static space_constant::valued_type \
valued_tag (space_constant::valued_type) { \
return space_constant::scalar; \
} \
};
// std::cmath
_RHEOLEF_generic_unary_scalar(cos)
_RHEOLEF_generic_unary_scalar(sin)
_RHEOLEF_generic_unary_scalar(tan)
_RHEOLEF_generic_unary_scalar(acos)
_RHEOLEF_generic_unary_scalar(asin)
_RHEOLEF_generic_unary_scalar(atan)
_RHEOLEF_generic_unary_scalar(cosh)
_RHEOLEF_generic_unary_scalar(sinh)
_RHEOLEF_generic_unary_scalar(tanh)
_RHEOLEF_generic_unary_scalar(exp)
_RHEOLEF_generic_unary_scalar(log)
_RHEOLEF_generic_unary_scalar(log10)
_RHEOLEF_generic_unary_scalar(sqrt)
_RHEOLEF_generic_unary_scalar(abs)
_RHEOLEF_generic_unary_scalar(fabs)
_RHEOLEF_generic_unary_scalar(floor)
_RHEOLEF_generic_unary_scalar(ceil)
// rheolef extension:
_RHEOLEF_generic_unary_scalar(sqr)
#undef _RHEOLEF_generic_unary_scalar
// ----------------------------------------------------------------------------
// chap 1.4. unary extensions: tr(x), norm(x) norm2(x)
// ----------------------------------------------------------------------------
// tr(tau)
// ----------
struct tr_ {
template <class T> T operator() (const tensor_basic<T>& a) const { return tr(a); }
};
template<>
struct generic_unary_traits<tr_> {
template <class A1>
struct result_hint {
typedef typename scalar_traits<A1>::type type;
};
template <class A1, class R>
struct hint {
typedef typename result_hint<A1>::type result_type;
typedef tensor_basic<result_type> argument_type;
};
static space_constant::valued_type
valued_tag (space_constant::valued_type tag) {
return space_constant::scalar;
}
};
// ----------
// trans(tau)
// ----------
struct trans_ {
template <class T> tensor_basic<T> operator() (const tensor_basic<T>& a) const { return trans(a); }
};
template<>
struct generic_unary_traits<trans_> {
template <class A1>
struct result_hint {
typedef tensor_basic<typename scalar_traits<A1>::type> type;
};
template <class A1, class R>
struct hint {
typedef typename promote<typename scalar_traits<A1>::type,typename scalar_traits<R>::type>::type S;
typedef tensor_basic<S> argument_type;
typedef tensor_basic<S> result_type;
};
static space_constant::valued_type
valued_tag (space_constant::valued_type tag) {
return space_constant::unsymmetric_tensor;
}
};
// ----------
// norm(x)
// ----------
struct norm_ {
template<class T>
typename float_traits<T>::type operator() (const T& x) const { return fabs(x); }
template<class T>
typename float_traits<T>::type operator() (const point_basic<T>& x) const { return norm(x); }
template<class T>
typename float_traits<T>::type operator() (const tensor_basic<T>& x) const { return norm(x); }
};
template<>
struct generic_unary_traits<norm_> {
template <class Arg>
struct result_hint {
typedef typename float_traits<Arg>::type type;
};
template <class A1, class R>
struct hint {
typedef typename result_hint<A1>::type result_type;
typedef A1 argument_type;
};
static space_constant::valued_type
valued_tag (space_constant::valued_type tag) {
return space_constant::scalar;
}
};
// ----------
// norm2(x)
// ----------
struct norm2_ {
template<class T>
typename float_traits<T>::type operator() (const T& x) const { return sqr(x); }
template<class T>
typename float_traits<T>::type operator() (const point_basic<T>& x) const { return norm2(x); }
template<class T>
typename float_traits<T>::type operator() (const tensor_basic<T>& x) const { return norm2(x); }
};
template<>
struct generic_unary_traits<norm2_> {
template <class Arg>
struct result_hint {
typedef typename float_traits<Arg>::type type;
};
template <class A1, class R>
struct hint {
typedef typename result_hint<A1>::type result_type;
typedef A1 argument_type;
};
static space_constant::valued_type
valued_tag (space_constant::valued_type tag) {
return space_constant::scalar;
}
};
// ===========================================================================
// part 2. binary operations
// ===========================================================================
// ---------------------------------------------------------------------------
// chap 2.1. binary function helper
// ---------------------------------------------------------------------------
template<class Function>
struct generic_binary_traits {
template <class Arg1, class Arg2>
struct result_hint {
typedef typename function_traits<Function>::result_type type;
};
template <class Arg1, class Arg2, class Result>
struct hint {
typedef typename std::decay<typename function_traits<Function>::template arg<0>::type>::type
first_argument_type;
typedef typename std::decay<typename function_traits<Function>::template arg<1>::type>::type
second_argument_type;
typedef typename std::decay<typename function_traits<Function>::result_type>::type
result_type;
};
static space_constant::valued_type
valued_tag (space_constant::valued_type, space_constant::valued_type) {
return space_constant::valued_tag_traits<typename function_traits<Function>::result_type>::value;
}
};
// ----------------------------------------------------------------------------
// chap 2.2. binary operators: x+y, x-y, x*y, x/y
// ----------------------------------------------------------------------------
// x+y
// --------
struct plus; // foward declaration
// result type
// -----------
template <class A1, class A2, class Sfinae = void>
struct plus_result {
typedef binop_error<details::plus,A1,A2,undeterminated_basic<Float> > type;
};
// s+s -> s
template <class A1, class A2>
struct plus_result<A1,A2,
typename std::enable_if<
is_rheolef_arithmetic<A1>::value &&
is_rheolef_arithmetic<A2>::value
>::type>
{
typedef typename promote<A1,A2>::type type;
};
// v+v -> v, t+t -> t
template <class A>
struct plus_result<A,A,
typename std::enable_if<
! is_rheolef_arithmetic<A>::value>::type>
{
typedef A type;
};
struct plus {
template <class T1, class T2>
typename plus_result<T1,T2>::type operator() (const T1& a, const T2& b) const { return a+b; }
};
template<>
struct generic_binary_traits<plus> {
// --------------------------
// hint interface
// --------------------------
template <class A1, class A2, class R>
struct hint {
typedef A1 first_argument_type;
typedef A2 second_argument_type;
typedef R result_type;
};
// two types are known
// --------------------------
// a1+a2 -> ? : deduce r
template <class A1, class A2, class R>
struct hint<A1,A2,undeterminated_basic<R> > {
typedef A1 first_argument_type;
typedef A2 second_argument_type;
typedef typename plus_result<A1,A2>::type result_type;
};
// ?+a2 -> r : deduce a1
template <class A1, class A2, class R>
struct hint<undeterminated_basic<A1>,A2,R> {
typedef typename std::conditional<
details::is_equal<A2,R>::value,
R,
binop_error<details::plus,A1,A2,R>
>::type first_argument_type;
typedef A2 second_argument_type;
typedef R result_type;
};
// a1+? -> r : deduce a2
template <class A1, class A2, class R>
struct hint<A1,undeterminated_basic<A2>,R> {
typedef A1 first_argument_type;
typedef typename std::conditional<
details::is_equal<A1,R>::value,
R,
binop_error<details::plus,A1,A2,R> >::type
second_argument_type;
typedef R result_type;
};
// ?+? -> r : deduce a1,a2
template <class A1, class A2, class R>
struct hint<undeterminated_basic<A1>,undeterminated_basic<A2>,R> {
typedef R first_argument_type;
typedef R second_argument_type;
typedef R result_type;
};
// a1+? -> ? : deduce a2,r
template <class A1, class A2, class R>
struct hint<A1,undeterminated_basic<A2>,undeterminated_basic<R> > {
typedef A1 first_argument_type;
typedef A1 second_argument_type;
typedef A1 result_type;
};
// ?+a2 -> ? : deduce a2,r
template <class A1, class A2, class R>
struct hint<undeterminated_basic<A1>,A2, undeterminated_basic<R> > {
typedef A2 first_argument_type;
typedef A2 second_argument_type;
typedef A2 result_type;
};
// ?+? -> ? : deduce a1, a2,r
template <class A1, class A2, class R>
struct hint<undeterminated_basic<A1>, undeterminated_basic<A2>, undeterminated_basic<R> > {
typedef undeterminated_basic<A1> first_argument_type;
typedef undeterminated_basic<A2> second_argument_type;
typedef undeterminated_basic<R> result_type;
};
static space_constant::valued_type
valued_tag (space_constant::valued_type tag1, space_constant::valued_type tag2) {
return (tag2 == space_constant::last_valued) ? tag1 : tag2;
}
typedef std::true_type is_symmetric;
template <class Arg1, class Arg2>
struct result_hint {
typedef typename hint<Arg1,Arg2,undeterminated_basic<Float> >::result_type type;
};
};
// --------
// x-y
// --------
struct minus {
template <class T1, class T2>
typename plus_result<T1,T2>::type operator() (const T1& a, const T2& b) const { return a-b; }
};
template<>
struct generic_binary_traits<minus> {
template <class A1, class A2, class R>
struct hint : generic_binary_traits<plus>::template hint<A1,A2,R> {};
template <class A1, class A2>
struct result_hint {
typedef typename hint<A1,A2,undeterminated_basic<Float> >::result_type type;
};
static space_constant::valued_type
valued_tag (space_constant::valued_type tag1, space_constant::valued_type tag2) {
return (tag2 == space_constant::last_valued) ? tag1 : tag2;
}
typedef std::false_type is_symmetric;
};
// --------
// x*y
// --------
/*
result: when arg1 & arg2 are given
1\2 s v t t3 t4
s s v t t3 t4
v v E E E E
t t v t E E
t3 t3 t t3 E E
t4 t4 E E E E
arg1: deduced when arg2 & result are known
2\r s v t t3 t4
s s v t t3 t4
v E (st)t3 E E
t E E (st)t3 E st: indetermine'
t3 E E E s E
t4 E E E E s
arg2: deduced when arg1 & result are known
1\r s v t t3 t4
s s v t t3 t4
v E s E E E
t E v (st)E E st: indetermine'
t3 E E v (st) E
t4 E E E E E
il n'y a que deux cas ou l'arg1 est indetermine' :
quand arg2=v et res_t=v alors arg1=s ou t
quand arg2=t et res_t=t alors arg1=s ou t
dans tous les autres cas, on deduit l'arg1
il n'y a qu'un cas ou l'arg2 est indetermine' :
quand arg1=t et res_t=t alors arg2=s ou t
dans tous les autres cas, on deduit l'arg2
*/
struct multiplies; // foward declaration
// result type
// -----------
// s*s -> s
template <class A1, class A2>
struct multiplies_result {
typedef typename promote<A1,A2>::type type;
};
// s*v -> v
template <class S>
struct multiplies_result<S, point_basic<S> > {
typedef point_basic<S> type;
};
// s*t -> t
template <class S>
struct multiplies_result<S, tensor_basic<S> > {
typedef tensor_basic<S> type;
};
// v*s -> v
template <class S>
struct multiplies_result<point_basic<S>, S> {
typedef point_basic<S> type;
};
// v*v -> err
template <class S1, class S2>
struct multiplies_result<point_basic<S1>, point_basic<S2> > {
typedef typename promote<S1,S2>::type S;
typedef binop_error<details::multiplies,point_basic<S1>,point_basic<S2>,undeterminated_basic<S> > type;
};
// v*t -> err
template <class S1, class S2>
struct multiplies_result<point_basic<S1>, tensor_basic<S2> > {
typedef typename promote<S1,S2>::type S;
typedef binop_error<details::multiplies,point_basic<S1>,tensor_basic<S2>,undeterminated_basic<S> > type;
};
// t*s -> t
template <class S>
struct multiplies_result<tensor_basic<S>, S> {
typedef tensor_basic<S> type;
};
// t*v -> v
template <class S1, class S2>
struct multiplies_result<tensor_basic<S1>, point_basic<S2> > {
typedef typename promote<S1,S2>::type S;
typedef point_basic<S> type;
};
// t*t -> t
template <class S1, class S2>
struct multiplies_result<tensor_basic<S1>, tensor_basic<S2> > {
typedef typename promote<S1,S2>::type S;
typedef tensor_basic<S> type;
};
// s*t3 -> t3
template <class S>
struct multiplies_result<S, tensor3_basic<S> > {
typedef tensor3_basic<S> type;
};
// t*s -> t
template <class S>
struct multiplies_result<tensor3_basic<S>, S> {
typedef tensor3_basic<S> type;
};
// t3*v -> t
template <class S1, class S2>
struct multiplies_result<tensor3_basic<S1>, point_basic<S2> > {
typedef typename promote<S1,S2>::type S;
typedef tensor_basic<S> type;
};
// t3*t -> t3
template <class S1, class S2>
struct multiplies_result<tensor3_basic<S1>, tensor_basic<S2> > {
typedef typename promote<S1,S2>::type S;
typedef tensor3_basic<S> type;
};
// v*t3 -> err
template <class S1, class S2>
struct multiplies_result<point_basic<S1>, tensor3_basic<S2> > {
typedef typename promote<S1,S2>::type S;
typedef binop_error<details::multiplies,point_basic<S1>,tensor3_basic<S2>,undeterminated_basic<S> > type;
};
// t*t3 -> err
template <class S1, class S2>
struct multiplies_result<tensor_basic<S1>, tensor3_basic<S2> > {
typedef typename promote<S1,S2>::type S;
typedef binop_error<details::multiplies,tensor_basic<S1>,tensor3_basic<S2>,undeterminated_basic<S> > type;
};
// t3*t3 -> err
template <class S1, class S2>
struct multiplies_result<tensor3_basic<S1>, tensor3_basic<S2> > {
typedef typename promote<S1,S2>::type S;
typedef binop_error<details::multiplies,tensor3_basic<S1>,tensor3_basic<S2>,undeterminated_basic<S> > type;
};
// s*t4 -> t4
template <class S>
struct multiplies_result<S, tensor4_basic<S> > {
typedef tensor4_basic<S> type;
};
// t4*s -> t4
template <class S>
struct multiplies_result<tensor4_basic<S>, S> {
typedef tensor4_basic<S> type;
};
// v*t4 -> err
template <class S1, class S2>
struct multiplies_result<point_basic<S1>, tensor4_basic<S2> > {
typedef typename promote<S1,S2>::type S;
typedef binop_error<details::multiplies,point_basic<S1>,tensor4_basic<S2>,undeterminated_basic<S> > type;
};
// t*t4 -> err
template <class S1, class S2>
struct multiplies_result<tensor_basic<S1>, tensor4_basic<S2> > {
typedef typename promote<S1,S2>::type S;
typedef binop_error<details::multiplies,tensor_basic<S1>,tensor4_basic<S2>,undeterminated_basic<S> > type;
};
// t3*t4 -> err
template <class S1, class S2>
struct multiplies_result<tensor3_basic<S1>, tensor4_basic<S2> > {
typedef typename promote<S1,S2>::type S;
typedef binop_error<details::multiplies,tensor3_basic<S1>,tensor4_basic<S2>,undeterminated_basic<S> > type;
};
// t4*v -> err
template <class S1, class S2>
struct multiplies_result<tensor4_basic<S1>, point_basic<S2> > {
typedef typename promote<S1,S2>::type S;
typedef binop_error<details::multiplies,tensor4_basic<S1>,point_basic<S2>,undeterminated_basic<S> > type;
};
// t4*t -> err
template <class S1, class S2>
struct multiplies_result<tensor4_basic<S1>, tensor_basic<S2> > {
typedef typename promote<S1,S2>::type S;
typedef binop_error<details::multiplies,tensor4_basic<S1>,tensor_basic<S2>,undeterminated_basic<S> > type;
};
// t4*t3 -> err
template <class S1, class S2>
struct multiplies_result<tensor4_basic<S1>, tensor3_basic<S2> > {
typedef typename promote<S1,S2>::type S;
typedef binop_error<details::multiplies,tensor4_basic<S1>,tensor3_basic<S2>,undeterminated_basic<S> > type;
};
// t4*t4 -> err
template <class S1, class S2>
struct multiplies_result<tensor4_basic<S1>, tensor4_basic<S2> > {
typedef typename promote<S1,S2>::type S;
typedef binop_error<details::multiplies,tensor4_basic<S1>,tensor4_basic<S2>,undeterminated_basic<S> > type;
};
struct multiplies {
template <class T1, class T2>
typename multiplies_result<T1,T2>::type
operator() (const T1& a, const T2& b) const { return a*b; }
};
template<>
struct generic_binary_traits<multiplies> {
static space_constant::valued_type
valued_tag (space_constant::valued_type tag1, space_constant::valued_type tag2) {
return space_constant::multiplies_result_tag(tag1,tag2);
}
// --------------------------
// hint arg1 type
// --------------------------
// ?*s=s => a1=s
template <class A2, class R, class Sfinae = void>
struct first_argument_hint {
typedef typename promote<A2,R>::type type;
};
// ?*s=v => a1=v
template <class A2, class R>
struct first_argument_hint<A2,point_basic<R> > {
typedef point_basic<typename promote<A2,R>::type> type;
};
// ?*s=t => a1=t
template <class A2, class R>
struct first_argument_hint<A2,tensor_basic<R> > {
typedef tensor_basic<typename promote<A2,R>::type> type;
};
// ?*s=t3 => a1=t3
template <class A2, class R>
struct first_argument_hint<A2,tensor3_basic<R> > {
typedef tensor3_basic<typename promote<A2,R>::type> type;
};
// ?*s=t4 => a1=t4
template <class A2, class R>
struct first_argument_hint<A2,tensor4_basic<R>,
typename std::enable_if<is_rheolef_arithmetic<A2>::value>::type> {
typedef tensor4_basic<typename promote<A2,R>::type> type;
};
// ?*v=s => a1=err
template <class A2, class R>
struct first_argument_hint<point_basic<A2>,R> {
typedef binop_error<details::multiplies,undeterminated_basic<A2>,point_basic<A2>,R> type;
};
// ?*v=v => a1={s,t}=undeterminated
template <class A2, class R>
struct first_argument_hint<point_basic<A2>,point_basic<R> > {
typedef undeterminated_basic<typename promote<A2,R>::type> type;
};
// ?*v=t => a1=t3
template <class A2, class R>
struct first_argument_hint<point_basic<A2>,tensor_basic<R> > {
typedef tensor3_basic<typename promote<A2,R>::type> type;
};
// ?*v=t3 => a1=err
template <class A2, class R>
struct first_argument_hint<point_basic<A2>,tensor3_basic<R> > {
typedef binop_error<details::multiplies,undeterminated_basic<A2>,point_basic<A2>,tensor3_basic<R> > type;
};
// ?*v=t4 => a1=err
template <class A2, class R>
struct first_argument_hint<point_basic<A2>,tensor4_basic<R> > {
typedef binop_error<details::multiplies,undeterminated_basic<A2>,point_basic<A2>,tensor4_basic<R> > type;
};
// ?*t=s => a1=err
template <class A2, class R>
struct first_argument_hint<tensor_basic<A2>,R> {
typedef binop_error<details::multiplies,undeterminated_basic<A2>,tensor_basic<A2>,R> type;
};
// ?*t=v => a1=err
template <class A2, class R>
struct first_argument_hint<tensor_basic<A2>,point_basic<R> > {
typedef binop_error<details::multiplies,undeterminated_basic<A2>,tensor_basic<A2>,point_basic<R> > type;
};
// ?*t=t => a1={s,t}=undeterminated
template <class A2, class R>
struct first_argument_hint<tensor_basic<A2>,tensor_basic<R> > {
typedef undeterminated_basic<typename promote<A2,R>::type> type;
};
// ?*t=t3 => a1=t3
template <class A2, class R>
struct first_argument_hint<tensor_basic<A2>,tensor3_basic<R> > {
typedef tensor3_basic<typename promote<A2,R>::type> type;
};
// ?*t3=s => a1=err
template <class A2, class R>
struct first_argument_hint<tensor3_basic<A2>,R> {
typedef binop_error<details::multiplies,undeterminated_basic<A2>,tensor3_basic<A2>,R> type;
};
// ?*t3=v => a1=err
template <class A2, class R>
struct first_argument_hint<tensor3_basic<A2>,point_basic<R> > {
typedef binop_error<details::multiplies,undeterminated_basic<A2>,tensor3_basic<A2>,point_basic<R> > type;
};
// ?*t3=t => a1=err
template <class A2, class R>
struct first_argument_hint<tensor3_basic<A2>,tensor_basic<R> > {
typedef binop_error<details::multiplies,undeterminated_basic<A2>,tensor3_basic<A2>,tensor_basic<R> > type;
};
// ?*t3=t3 => a1=s
template <class A2, class R>
struct first_argument_hint<tensor3_basic<A2>,tensor3_basic<R> > {
typedef typename promote<A2,R>::type type;
};
// ?*t4=s => a1=E
template <class A2, class R>
struct first_argument_hint<tensor4_basic<A2>,R,
typename std::enable_if<is_rheolef_arithmetic<R>::value>::type> {
typedef typename promote<A2,R>::type S;
typedef binop_error<details::multiplies,undeterminated_basic<S>,tensor4_basic<A2>,R> type;
};
// ?*t4=v => a1=E
template <class A2, class R>
struct first_argument_hint<tensor4_basic<A2>,point_basic<R> > {
typedef typename promote<A2,R>::type S;
typedef binop_error<details::multiplies,undeterminated_basic<S>,tensor4_basic<A2>,point_basic<R> > type;
};
// ?*t4=t => a1=E
template <class A2, class R>
struct first_argument_hint<tensor4_basic<A2>,tensor_basic<R> > {
typedef typename promote<A2,R>::type S;
typedef binop_error<details::multiplies,undeterminated_basic<S>,tensor4_basic<A2>,tensor_basic<R> > type;
};
// ?*t4=t3 => a1=E
template <class A2, class R>
struct first_argument_hint<tensor4_basic<A2>,tensor3_basic<R> > {
typedef typename promote<A2,R>::type S;
typedef binop_error<details::multiplies,undeterminated_basic<S>,tensor4_basic<A2>,tensor3_basic<R> > type;
};
// ?*t4=t4 => a1=s
template <class A2, class R>
struct first_argument_hint<tensor4_basic<A2>,tensor4_basic<R> > {
typedef typename promote<A2,R>::type type;
};
// --------------------------
// hint arg2 type
// --------------------------
// s*?=s => a2=s
template <class A1, class R, class Sfinae = void>
struct second_argument_hint {
typedef typename promote<A1,R>::type type;
};
// s*?=v => a2=v
template <class A1, class R>
struct second_argument_hint<A1,point_basic<R> > {
typedef point_basic<typename promote<A1,R>::type> type;
};
// s*?=t => a2=t
template <class A1, class R>
struct second_argument_hint<A1,tensor_basic<R> > {
typedef tensor_basic<typename promote<A1,R>::type> type;
};
// s*?=t3 => a2=t3
template <class A1, class R>
struct second_argument_hint<A1,tensor3_basic<R> > {
typedef tensor3_basic<typename promote<A1,R>::type> type;
};
// s*?=t4 => a2=t4
template <class A1, class R>
struct second_argument_hint<A1,tensor4_basic<R>,
typename std::enable_if<is_rheolef_arithmetic<A1>::value>::type> {
typedef tensor4_basic<typename promote<A1,R>::type> type;
};
// v*?=s => a2=err
template <class A1, class R>
struct second_argument_hint<point_basic<A1>,R> {
typedef binop_error<details::multiplies,point_basic<A1>,undeterminated_basic<A1>,R> type;
};
// v*?=v => a2=s
template <class A1, class R>
struct second_argument_hint<point_basic<A1>,point_basic<R> > {
typedef typename promote<A1,R>::type type;
};
// v*?=t => a2=err
template <class A1, class R>
struct second_argument_hint<point_basic<A1>,tensor_basic<R> > {
typedef binop_error<details::multiplies,tensor_basic<A1>,undeterminated_basic<A1>,tensor_basic<R> > type;
};
// t*?=s => a2=err
template <class A1, class R>
struct second_argument_hint<tensor_basic<A1>,R> {
typedef binop_error<details::multiplies,tensor_basic<A1>,undeterminated_basic<A1>,R> type;
};
// t*?=v => a2=v
template <class A1, class R>
struct second_argument_hint<tensor_basic<A1>,point_basic<R> > {
typedef point_basic<typename promote<A1,R>::type> type;
};
// t*?=t => a2={s,t}=undeterminated
template <class A1, class R>
struct second_argument_hint<tensor_basic<A1>,tensor_basic<R> > {
typedef undeterminated_basic<typename promote<A1,R>::type> type;
};
// v*?=t3 => a2=err
template <class A1, class R>
struct second_argument_hint<point_basic<A1>,tensor3_basic<R> > {
typedef binop_error<details::multiplies,point_basic<A1>,undeterminated_basic<A1>,tensor3_basic<R> > type;
};
// t*?=t3 => a2=err
template <class A1, class R>
struct second_argument_hint<tensor_basic<A1>,tensor3_basic<R> > {
typedef binop_error<details::multiplies,tensor_basic<A1>,undeterminated_basic<A1>,tensor3_basic<R> > type;
};
// t3*?=s => a2=err
template <class A1, class R>
struct second_argument_hint<tensor3_basic<A1>,R > {
typedef binop_error<details::multiplies,tensor3_basic<A1>,undeterminated_basic<A1>,R> type;
};
// t3*?=v => a2=err
template <class A1, class R>
struct second_argument_hint<tensor3_basic<A1>,point_basic<R> > {
typedef binop_error<details::multiplies,tensor3_basic<A1>,undeterminated_basic<A1>,point_basic<R> > type;
};
// t3*?=t => a2=v
template <class A1, class R>
struct second_argument_hint<tensor3_basic<A1>,tensor_basic<R> > {
typedef point_basic<typename promote<A1,R>::type> type;
};
// t3*?=t3 => a2={st}
template <class A1, class R>
struct second_argument_hint<tensor3_basic<A1>,tensor3_basic<R> > {
typedef undeterminated_basic<typename promote<A1,R>::type> type;
};
// t4*?=s => a2=err
template <class A1, class R>
struct second_argument_hint<tensor4_basic<A1>,R,
typename std::enable_if<is_rheolef_arithmetic<R>::value>::type> {
typedef binop_error<details::multiplies,tensor4_basic<A1>,undeterminated_basic<A1>,R> type;
};
// t4*?=v => a2=err
template <class A1, class R>
struct second_argument_hint<tensor4_basic<A1>,point_basic<R> > {
typedef binop_error<details::multiplies,tensor4_basic<A1>,undeterminated_basic<A1>,point_basic<R> > type;
};
// t4*?=t => a2=err
template <class A1, class R>
struct second_argument_hint<tensor4_basic<A1>,tensor_basic<R> > {
typedef binop_error<details::multiplies,tensor4_basic<A1>,undeterminated_basic<A1>,tensor_basic<R> > type;
};
// t4*?=t3 => a2=err
template <class A1, class R>
struct second_argument_hint<tensor4_basic<A1>,tensor3_basic<R> > {
typedef binop_error<details::multiplies,tensor4_basic<A1>,undeterminated_basic<A1>,tensor3_basic<R> > type;
};
// t4*?=t4 => a2=err
template <class A1, class R>
struct second_argument_hint<tensor4_basic<A1>,tensor4_basic<R> > {
typedef typename promote<A1,R>::type S;
typedef S type;
};
// --------------------------
// hint interface
// --------------------------
template <class A1, class A2, class R>
struct hint {
typedef A1 first_argument_type;
typedef A2 second_argument_type;
typedef R result_type;
};
// two types are known
// --------------------------
// a1*a2 -> ? : deduce r
template <class A1, class A2, class R>
struct hint<A1,A2,undeterminated_basic<R> > {
typedef A1 first_argument_type;
typedef A2 second_argument_type;
typedef typename multiplies_result<A1,A2>::type result_type;
};
// ?*a2 -> r : deduce a1
template <class A1, class A2, class R>
struct hint<undeterminated_basic<A1>,A2,R> {
// TODO: promote scalar_type of first arg: tensor<Float>*point<complex> -> point<complex>
// promote_valued<Arg,Scalar>::type
// e.g. promote_valued<point_basic<Float>,complex<Float> >::type -> point_basic<cmplex<Float>>
typedef typename first_argument_hint<A2,R>::type first_argument_type;
typedef A2 second_argument_type;
typedef R result_type;
};
// a1*? -> r : deduce a2
template <class A1, class A2, class R>
struct hint<A1,undeterminated_basic<A2>,R> {
typedef A1 first_argument_type;
typedef typename second_argument_hint<A1,R>::type second_argument_type;
typedef R result_type;
};
// only one type is known
// -----------------------
// ?*? -> s : deduce a1=a2=s
template <class A1, class A2, class R>
struct hint<undeterminated_basic<A1>,undeterminated_basic<A2>,R> {
typedef A1 first_argument_type;
typedef A2 second_argument_type;
typedef R result_type;
};
// ?*? -> v : deduce (a1,a2)={(s,v),(v,s),(t,v)}=?
template <class A1, class A2, class R>
struct hint<undeterminated_basic<A1>,undeterminated_basic<A2>,point_basic<R> > {
typedef undeterminated_basic<A1> first_argument_type;
typedef undeterminated_basic<A2> second_argument_type;
typedef point_basic<R> result_type;
};
// ?*? -> t : deduce (a1,a2)={(s,t),(t,s),(t,t)}=?
template <class A1, class A2, class R>
struct hint<undeterminated_basic<A1>,undeterminated_basic<A2>,tensor_basic<R> > {
typedef undeterminated_basic<A1> first_argument_type;
typedef undeterminated_basic<A2> second_argument_type;
typedef tensor_basic<R> result_type;
};
// ?*? -> t3 : deduce (a1,a2)={(s,t3),(t3,s),(t3,t)}=?
template <class A1, class A2, class R>
struct hint<undeterminated_basic<A1>,undeterminated_basic<A2>,tensor3_basic<R> > {
typedef undeterminated_basic<A1> first_argument_type;
typedef undeterminated_basic<A2> second_argument_type;
typedef tensor3_basic<R> result_type;
};
// ?*? -> t4 : deduce (a1,a2)={(s,t4),(t4,s)}=?
template <class A1, class A2, class R>
struct hint<undeterminated_basic<A1>,undeterminated_basic<A2>,tensor4_basic<R> > {
typedef undeterminated_basic<A1> first_argument_type;
typedef undeterminated_basic<A2> second_argument_type;
typedef tensor4_basic<R> result_type;
};
// s*? -> ? : deduce (a2,r)={(s,s),(v,v),(t,t)}=?
template <class A1, class A2, class R>
struct hint<A1,undeterminated_basic<A2>,undeterminated_basic<R> > {
typedef A1 first_argument_type;
typedef undeterminated_basic<A2> second_argument_type;
typedef undeterminated_basic<R> result_type;
};
// v*? -> ? : deduce (a2,r)=(s,v)
template <class A1, class A2, class R>
struct hint<point_basic<A1>,undeterminated_basic<A2>,undeterminated_basic<R> > {
typedef point_basic<A1> first_argument_type;
typedef A2 second_argument_type;
typedef point_basic<R> result_type;
};
// t*? -> ? : deduce (a2,r)={(v,v),(t,t),(s,t)}=?
template <class A1, class A2, class R>
struct hint<tensor_basic<A1>,undeterminated_basic<A2>,undeterminated_basic<R> > {
typedef tensor_basic<A1> first_argument_type;
typedef undeterminated_basic<A2> second_argument_type;
typedef undeterminated_basic<R> result_type;
};
// t3*? -> ? : deduce (a2,r)={(s,t3),(v,t),(t3,t3)}=?
template <class A1, class A2, class R>
struct hint<tensor3_basic<A1>,undeterminated_basic<A2>,undeterminated_basic<R> > {
typedef tensor3_basic<A1> first_argument_type;
typedef undeterminated_basic<A2> second_argument_type;
typedef undeterminated_basic<R> result_type;
};
// ?*s -> ? : deduce (a1,r)={(s,s),(v,v),(t,t)}=?
template <class A1, class A2, class R>
struct hint<undeterminated_basic<A1>,A2,undeterminated_basic<R> > {
typedef undeterminated_basic<A1> first_argument_type;
typedef A2 second_argument_type;
typedef undeterminated_basic<R> result_type;
};
// ?*v -> ? : deduce (a1,r)={(s,v),(t,v)}=?
template <class A1, class A2, class R>
struct hint<undeterminated_basic<A1>,point_basic<A2>,undeterminated_basic<R> > {
typedef undeterminated_basic<A1> first_argument_type;
typedef point_basic<A2> second_argument_type;
typedef undeterminated_basic<R> result_type;
};
// ?*t -> ? : deduce (a1,r)={(s,t),(t,t)}=?
template <class A1, class A2, class R>
struct hint<undeterminated_basic<A1>,tensor_basic<A2>,undeterminated_basic<R> > {
typedef undeterminated_basic<A1> first_argument_type;
typedef tensor_basic<A2> second_argument_type;
typedef undeterminated_basic<R> result_type;
};
// ?*t3 -> ? : deduce (a1,r)=(s,t3)
template <class A1, class A2, class R>
struct hint<undeterminated_basic<A1>,tensor3_basic<A2>,undeterminated_basic<R> > {
typedef A1 first_argument_type;
typedef tensor3_basic<A2> second_argument_type;
typedef tensor3_basic<R> result_type;
};
// ?*t4 -> ? : deduce (a1,r)=(s,t4)
template <class A1, class A2, class R>
struct hint<undeterminated_basic<A1>,tensor4_basic<A2>,undeterminated_basic<R> > {
typedef A1 first_argument_type;
typedef tensor4_basic<A2> second_argument_type;
typedef tensor4_basic<R> result_type;
};
// t4*? -> ? : deduce (a2,r)=(s,t4)
template <class A1, class A2, class R>
struct hint<tensor4_basic<A1>,undeterminated_basic<A2>,undeterminated_basic<R> > {
typedef tensor4_basic<A2> first_argument_type;
typedef A2 second_argument_type;
typedef tensor4_basic<R> result_type;
};
// none types are known
// -----------------------
// ?*? -> ? : deduce (a1,a2,r)=?
template <class A1, class A2, class R>
struct hint<undeterminated_basic<A1>,undeterminated_basic<A2>,undeterminated_basic<R> > {
typedef undeterminated_basic<A1> first_argument_type;
typedef undeterminated_basic<A2> second_argument_type;
typedef undeterminated_basic<R> result_type;
};
// short interface
template <class Arg1, class Arg2>
struct result_hint {
typedef typename hint<Arg1,Arg2,undeterminated_basic<Float> >::result_type type;
};
typedef std::false_type is_symmetric; // tensor*vector do not commute
}; // generic_binary_traits<multiplies>
// --------
// x/y
// --------
struct divides; // foward declaration
template <class T1, class T2, class Sfinae = void>
struct divides_result {
typedef undeterminated_basic<typename promote<typename scalar_traits<T1>::type,typename scalar_traits<T2>::type>::type> type;
};
// s/s -> s
template <class T1, class T2>
struct divides_result<T1,T2,
typename std::enable_if<
is_rheolef_arithmetic<T1>::value &&
is_rheolef_arithmetic<T2>::value
>::type>
{
typedef typename promote<T1,T2>::type type;
};
// undef/undef -> undef
template <class T1, class T2>
struct divides_result<T1,T2,
typename std::enable_if<
is_undeterminated<T1>::value &&
is_undeterminated<T2>::value
>::type>
{
typedef undeterminated_basic <typename promote<T1,T2>::type> type;
};
// v/v -> err ; t/t -> err
template <class T>
struct divides_result<T,T,
typename std::enable_if<
! is_rheolef_arithmetic<T>::value
&& ! is_undeterminated<T>::value
>::type>
{
typedef typename scalar_traits<T>::type S;
typedef binop_error<details::divides,T,T,undeterminated_basic<S> > type;
};
template <class T>
struct divides_result<point_basic<T>,T> {
typedef point_basic<T> type;
};
template <class T>
struct divides_result<tensor_basic<T>,T> {
typedef tensor_basic<T> type;
};
template <class T>
struct divides_result<T, point_basic<T> > {
typedef binop_error<details::divides,T,point_basic<T>,undeterminated_basic<T> > type;
};
template <class T>
struct divides_result<T, tensor_basic<T> > {
typedef binop_error<details::divides,T,tensor_basic<T>,undeterminated_basic<T> > type;
};
template <class T1, class T2>
struct divides_result<point_basic<T1>, tensor_basic<T2> > {
typedef typename promote<T1,T2>::type S;
typedef binop_error<details::divides,point_basic<T1>,tensor_basic<T2>,undeterminated_basic<S> > type;
};
template <class T1, class T2>
struct divides_result<tensor_basic<T1>, point_basic<T2> > {
typedef typename promote<T1,T2>::type S;
typedef binop_error<details::divides,tensor_basic<T1>,point_basic<T2>,undeterminated_basic<S> > type;
};
template <class T>
struct divides_result<tensor3_basic<T>,T> {
typedef tensor3_basic<T> type;
};
template <class T>
struct divides_result<tensor4_basic<T>,T> {
typedef tensor4_basic<T> type;
};
template <class T>
struct divides_result<T, tensor3_basic<T> > {
typedef binop_error<details::divides,T,tensor3_basic<T>,undeterminated_basic<T> > type;
};
template <class T1, class T2>
struct divides_result<point_basic<T1>, tensor3_basic<T2> > {
typedef typename promote<T1,T2>::type S;
typedef binop_error<details::divides,point_basic<T1>,tensor3_basic<T2>,undeterminated_basic<S> > type;
};
template <class T1, class T2>
struct divides_result<tensor_basic<T1>, tensor3_basic<T2> > {
typedef typename promote<T1,T2>::type S;
typedef binop_error<details::divides,tensor_basic<T1>,tensor3_basic<T2>,undeterminated_basic<S> > type;
};
template <class T1, class T2>
struct divides_result<tensor3_basic<T1>, point_basic<T2> > {
typedef typename promote<T1,T2>::type S;
typedef binop_error<details::divides,tensor3_basic<T1>,point_basic<T2>,undeterminated_basic<S> > type;
};
template <class T1, class T2>
struct divides_result<tensor3_basic<T1>, tensor_basic<T2> > {
typedef typename promote<T1,T2>::type S;
typedef binop_error<details::divides,tensor3_basic<T1>,tensor_basic<T2>,undeterminated_basic<S> > type;
};
template <class T>
struct divides_result<T, tensor4_basic<T> > {
typedef binop_error<details::divides,T,tensor4_basic<T>,undeterminated_basic<T> > type;
};
template <class T1, class T2>
struct divides_result<point_basic<T1>, tensor4_basic<T2> > {
typedef typename promote<T1,T2>::type S;
typedef binop_error<details::divides,point_basic<T1>,tensor4_basic<T2>,undeterminated_basic<S> > type;
};
template <class T1, class T2>
struct divides_result<tensor_basic<T1>, tensor4_basic<T2> > {
typedef typename promote<T1,T2>::type S;
typedef binop_error<details::divides,tensor_basic<T1>,tensor4_basic<T2>,undeterminated_basic<S> > type;
};
template <class T1, class T2>
struct divides_result<tensor3_basic<T1>, tensor4_basic<T2> > {
typedef typename promote<T1,T2>::type S;
typedef binop_error<details::divides,tensor3_basic<T1>,tensor4_basic<T2>,undeterminated_basic<S> > type;
};
struct divides {
template <class T1, class T2>
typename divides_result<T1,T2>::type
operator() (const T1& a, const T2& b) const { return a/b; }
};
template<>
struct generic_binary_traits<divides> {
template <class Arg1, class Arg2>
struct result_hint {
typedef typename divides_result<Arg1,Arg2>::type type;
};
template <class Arg1, class Arg2, class Result>
struct hint {
typedef Arg1 first_argument_type;
typedef Arg2 second_argument_type;
typedef Result result_type;
};
// two types are known
// --------------------------
// a1/a2 -> ? : deduce r=a1 when a2=s (error otherwise)
template <class A1, class A2, class R>
struct hint<A1,A2,undeterminated_basic<R> > {
typedef A1 first_argument_type;
typedef A2 second_argument_type;
typedef typename divides_result<A1,A2>::type result_type;
};
// ?/a2 -> r : deduce a1=r when a2=s (error otherwise)
template <class A1, class A2, class R>
struct hint<undeterminated_basic<A1>,A2,R> {
typedef typename scalar_traits<A2>::type S2;
typedef typename std::conditional<
details::is_scalar<A2>::value,
R,
binop_error<details::divides,A1,A2,R> >::type first_argument_type;
typedef A2 second_argument_type;
typedef R result_type;
};
// a1/? -> r : deduce a2=s when a1=r (error otherwise)
template <class A1, class A2, class R>
struct hint<A1,undeterminated_basic<A2>,R> {
typedef typename promote<
typename scalar_traits<A1>::type,
typename scalar_traits<R>::type>::type S;
typedef A1 first_argument_type;
typedef typename std::conditional<
details::is_equal<A1,R>::value,
S,
binop_error<details::divides,A1,A2,R> >::type second_argument_type;
typedef R result_type;
};
// two types are unknown
// --------------------------
// ?/? -> r : deduce a1=r and a2=s
template <class A1, class A2, class R>
struct hint<undeterminated_basic<A1>,undeterminated_basic<A2>,R> {
typedef R first_argument_type;
typedef typename scalar_traits<A2>::type second_argument_type;
typedef R result_type;
};
// a1/? -> ? : deduce r=a1 and a2=s
template <class A1, class A2, class R>
struct hint<A1,undeterminated_basic<A2>,undeterminated_basic<R> > {
typedef A1 first_argument_type;
typedef typename scalar_traits<A2>::type second_argument_type;
typedef A1 result_type;
};
// ?/a2 -> ? : deduce r=a1=? and a2=s
template <class A1, class A2, class R>
struct hint<undeterminated_basic<A1>,A2,undeterminated_basic<R> > {
typedef typename scalar_traits<A2>::type S2;
typedef typename std::conditional<
details::is_scalar<A2>::value,
undeterminated_basic<A1>,
binop_error<details::divides,A1,A2,R> >::type first_argument_type;
typedef A2 second_argument_type;
typedef first_argument_type result_type;
};
// three types are unknown
// -----------------------
// ?/? -> ? : deduce a1=r=? and a2=s
template <class A1, class A2, class R>
struct hint<undeterminated_basic<A1>,undeterminated_basic<A2>,undeterminated_basic<R> > {
typedef undeterminated_basic<A1> first_argument_type;
typedef A2 second_argument_type;
typedef undeterminated_basic<R> result_type;
};
static space_constant::valued_type
valued_tag (space_constant::valued_type tag1, space_constant::valued_type tag2) {
return space_constant::divides_result_tag(tag1,tag2);
}
typedef std::false_type is_symmetric;
};
// ----------------------------------------------------------------------------
// chap 2.3. binary standard maths: pow(x,y), atan2(x,y),...
// ----------------------------------------------------------------------------
// specialization for scalar generic functions, as details::pow_, details::atan2_, etc
//ICI
template<class F>
struct scalar_binary_traits {
static space_constant::valued_type
valued_tag (space_constant::valued_type tag1, space_constant::valued_type tag2) {
return space_constant::scalar;
}
template <class Arg1, class Arg2>
struct result_hint {
typedef typename promote<typename scalar_traits<Arg1>::type, typename scalar_traits<Arg2>::type>::type type;
};
template <class A1, class A2, class R>
struct hint {
typedef typename scalar_traits<A1>::type S1;
typedef typename scalar_traits<A2>::type S2;
typedef typename scalar_traits<R>::type S;
typedef typename details::and_type<
details::or_type<
details::is_scalar<A1>
,is_undeterminated<A1>
>
,details::or_type<
details::is_scalar<A2>
,is_undeterminated<A2>
>
,details::or_type<
details::is_scalar<R>
,is_undeterminated<R>
>
>::type is_good;
typedef typename std::conditional<
is_undeterminated<A1>::value
,typename std::conditional<
is_good::value
,S1
,binop_error<F,A1,A2,R>
>::type
,A1
>::type first_argument_type;
typedef typename std::conditional<
is_undeterminated<A2>::value
,typename std::conditional<
is_good::value
,S2
,binop_error<F,A1,A2,R>
>::type
,A2
>::type second_argument_type;
typedef typename std::conditional<
is_undeterminated<R>::value
,typename std::conditional<
is_good::value
,S
,binop_error<F,A1,A2,R>
>::type
,R
>::type result_type;
};
typedef std::false_type is_symmetric;
};
#define _RHEOLEF_generic_binary_scalar(F) \
struct F##_ { \
template<class A1, class A2> \
typename promote<A1,A2>::type \
operator() (const A1& x, const A2& y) const { \
typedef typename promote<A1,A2>::type R; \
return F(R(x),R(y)); } \
}; \
template<> \
struct generic_binary_traits<F##_> : scalar_binary_traits<F##_> {}; \
_RHEOLEF_generic_binary_scalar(atan2)
_RHEOLEF_generic_binary_scalar(pow)
_RHEOLEF_generic_binary_scalar(fmod)
_RHEOLEF_generic_binary_scalar(min)
_RHEOLEF_generic_binary_scalar(max)
#undef _RHEOLEF_generic_binary_scalar
// ----------------------------------------------------------------------------
// chap 2.4. binary extensions: dot(x,y), ddot(x,y)
// ----------------------------------------------------------------------------
// dot(x,y)
// ------------
struct dot_ {
template<class T>
T operator() (const point_basic<T>& x, const point_basic<T>& y) const { return dot(x,y); }
};
template<>
struct generic_binary_traits<dot_> {
static space_constant::valued_type
valued_tag (space_constant::valued_type tag1, space_constant::valued_type tag2) {
return space_constant::scalar;
}
template <class Arg1, class Arg2>
struct result_hint {
typedef typename promote<typename float_traits<Arg1>::type, typename float_traits<Arg2>::type>::type type;
};
template <class A1, class A2, class R>
struct hint {
typedef typename scalar_traits<A1>::type S1;
typedef typename scalar_traits<A2>::type S2;
typedef typename scalar_traits<R>::type S;
typedef typename details::and_type<
details::or_type<
details::is_point<A1>
,is_undeterminated<A1>
>
,details::or_type<
details::is_point<A2>
,is_undeterminated<A2>
>
,details::or_type<
details::is_scalar<R>
,is_undeterminated<R>
>
>::type is_good;
typedef typename std::conditional<
is_undeterminated<A1>::value
,typename std::conditional<
is_good::value
,point_basic<S1>
,binop_error<details::dot_,A1,A2,R>
>::type
,A1
>::type first_argument_type;
typedef typename std::conditional<
is_undeterminated<A2>::value
,typename std::conditional<
is_good::value
,point_basic<S2>
,binop_error<details::dot_,A1,A2,R>
>::type
,A2
>::type second_argument_type;
typedef typename std::conditional<
is_undeterminated<R>::value
,typename std::conditional<
is_good::value
,S
,binop_error<details::dot_,A1,A2,R>
>::type
,R
>::type result_type;
};
typedef std::true_type is_symmetric;
};
// ------------
// ddot(x,y)
// ------------
/*
result: when arg1 & arg2 are given
1\2 t t4
t s t
t4 t E
*/
struct ddot_;
template <class A1, class A2>
struct ddot_result {
typedef typename promote<typename float_traits<A1>::type, typename float_traits<A2>::type>::type S;
typedef binop_error<ddot_,A1,A2,undeterminated_basic<S> > type;
};
template <class A1, class A2>
struct ddot_result<tensor_basic<A1>,tensor_basic<A2> > {
typedef typename promote<typename float_traits<A1>::type, typename float_traits<A2>::type>::type S;
typedef S type;
};
template <class A1, class A2>
struct ddot_result<tensor4_basic<A1>,tensor_basic<A2> > {
typedef typename promote<typename float_traits<A1>::type, typename float_traits<A2>::type>::type S;
typedef tensor_basic<S> type;
};
template <class A1, class A2>
struct ddot_result<tensor_basic<A1>,tensor4_basic<A2> > {
typedef typename promote<typename float_traits<A1>::type, typename float_traits<A2>::type>::type S;
typedef tensor_basic<S> type;
};
struct ddot_ {
template<class A1, class A2>
typename ddot_result<A1,A2>::type
operator() (const A1& x, const A2& y) const { return ddot(x,y); }
};
template<>
struct generic_binary_traits<ddot_> {
static space_constant::valued_type
valued_tag (space_constant::valued_type tag1, space_constant::valued_type tag2) {
return space_constant::scalar;
}
template <class A1, class A2, class R>
struct hint {
typedef binop_error<ddot_,A1,A2,R> T;
typedef typename std::conditional<is_undeterminated<A1>::value,T,A1>::type first_argument_type;
typedef typename std::conditional<is_undeterminated<A2>::value,T,A2>::type second_argument_type;
typedef typename std::conditional<is_undeterminated<R>::value, T,R> ::type result_type;
};
// a:b -> ?
template <class A1, class A2, class R>
struct hint<A1,A2,undeterminated_basic<R> > {
typedef typename ddot_result<A1,A2>::type result_type;
typedef typename std::conditional<
is_undeterminated<A1>::value
&& is_error<result_type>::value
,result_type
,A1>::type first_argument_type;
typedef typename std::conditional<
is_undeterminated<A2>::value
&& is_error<result_type>::value
,result_type
,A2>::type second_argument_type;
};
// ====================
// A1 xor A2 is unknown
// ====================
// ?:t -> s => a=t
template <class A1, class A2, class R>
struct hint<undeterminated_basic<A1>,tensor_basic<A2>,R> {
typedef binop_error<ddot_,A1,A2,R> E;
typedef typename std::conditional<is_scalar<R>::value,tensor_basic<A1>,E>::type
first_argument_type;
typedef tensor_basic<A2> second_argument_type;
typedef R result_type;
};
// t:? -> s => b=t
template <class A1, class A2, class R>
struct hint<tensor_basic<A1>,undeterminated_basic<A2>,R> {
typedef binop_error<ddot_,A1,A2,R> E;
typedef tensor_basic<A1> first_argument_type;
typedef typename std::conditional<is_scalar<R>::value,tensor_basic<A2>,E>::type
second_argument_type;
typedef R result_type;
};
// ?:t4 -> t => a=t
template <class A1, class A2, class R>
struct hint<undeterminated_basic<A1>,tensor4_basic<A2>,tensor_basic<R> > {
typedef tensor_basic<A1> first_argument_type;
typedef tensor4_basic<A2> second_argument_type;
typedef tensor_basic<R> result_type;
};
// t4:? -> t => b=t
template <class A1, class A2, class R>
struct hint<tensor4_basic<A1>,undeterminated_basic<A2>,tensor_basic<R> > {
typedef tensor4_basic<A1> first_argument_type;
typedef tensor_basic<A2> second_argument_type;
typedef tensor_basic<R> result_type;
};
// =====================
// A1 and A2 are unknown
// =====================
// ?:? -> s => a=b=t
template <class A1, class A2, class R>
struct hint<undeterminated_basic<A1>,undeterminated_basic<A2>,R> {
typedef binop_error<ddot_,A1,A2,R> E;
typedef typename std::conditional<is_scalar<R>::value,tensor_basic<A1>,E>::type
first_argument_type;
typedef typename std::conditional<is_scalar<R>::value,tensor_basic<A2>,E>::type
second_argument_type;
typedef R result_type;
};
// ?:? -> t => (a,b)={(t,t4),(t4,t)}
// =====================
// A1 and R are unknown
// =====================
// ?:t -> ? => (a,r)={(t,s),(t4,t)}
template <class A1, class A2, class R>
struct hint<undeterminated_basic<A1>,tensor_basic<A2>,undeterminated_basic<R> > {
typedef undeterminated_basic<A1> first_argument_type;
typedef tensor_basic<A2> second_argument_type;
typedef undeterminated_basic<R> result_type;
};
// ?:t4 -> ? => (a,r)=(t,t)
template <class A1, class A2, class R>
struct hint<undeterminated_basic<A1>,tensor4_basic<A2>,undeterminated_basic<R> > {
typedef tensor_basic<A1> first_argument_type;
typedef tensor4_basic<A2> second_argument_type;
typedef tensor_basic<R> result_type;
};
// =====================
// A2 and R are unknown
// =====================
// t:? -> ? => (b,r)={(t,s),(t4,t)}
template <class A1, class A2, class R>
struct hint<tensor_basic<A1>,undeterminated_basic<A2>,undeterminated_basic<R> > {
typedef tensor_basic<A1> first_argument_type;
typedef undeterminated_basic<A2> second_argument_type;
typedef undeterminated_basic<R> result_type;
};
// t4:? -> ? => (b,r)=(t,t)
template <class A1, class A2, class R>
struct hint<tensor4_basic<A1>,undeterminated_basic<A2>,undeterminated_basic<R> > {
typedef tensor4_basic<A1> first_argument_type;
typedef tensor_basic<A2> second_argument_type;
typedef tensor_basic<R> result_type;
};
// ========================
// A1, A2 and R are unknown
// ========================
// ?:? -> ? => a,b,r=?
template <class A1, class A2, class R>
struct hint<undeterminated_basic<A1>,undeterminated_basic<A2>,undeterminated_basic<R> > {
typedef undeterminated_basic<A1> first_argument_type;
typedef undeterminated_basic<A2> second_argument_type;
typedef undeterminated_basic<R> result_type;
};
// short interface
template <class Arg1, class Arg2>
struct result_hint {
typedef typename hint<Arg1,Arg2,undeterminated_basic<Float> >::result_type type;
};
typedef std::true_type is_symmetric;
};
// ===========================================================================
// part 3. binders
// ===========================================================================
// similar to std::binder1st, std::binder2nd, but for generic operators
// ----------------------------------------------------------------------------
// chap 3.1. binder_first
// ----------------------------------------------------------------------------
template<class BinaryFunction, class A1>
struct binder_first {
binder_first (const BinaryFunction& f, const A1& x1) : _f(f), _x1(x1) {}
template<class A2>
typename generic_binary_traits<BinaryFunction>::template result_hint<A1,A2>::type
operator() (const A2& x2) const { return _f(_x1,x2); }
protected:
BinaryFunction _f;
A1 _x1;
};
template<class BinaryFunction, class A1>
struct generic_unary_traits<binder_first<BinaryFunction,A1> > {
template <class A2>
struct result_hint {
typedef typename generic_binary_traits<BinaryFunction>::template result_hint<A1,A2>::type type;
};
template <class A2, class Result>
struct hint {
typedef Result result_type;
typedef A2 argument_type;
};
// result unknown:
template <class A2, class T>
struct hint<A2,undeterminated_basic<T> > {
typedef typename result_hint<A2>::type result_type;
typedef A1 argument_type;
};
// A2 unknown:
template <class R, class T>
struct hint<undeterminated_basic<T>,R> {
typedef R result_type;
typedef typename generic_binary_traits<BinaryFunction>::template hint<A1,undeterminated_basic<T>,R>::second_argument_type
argument_type;
};
// A2 & R unknown:
template <class T1, class T>
struct hint<undeterminated_basic<T1>,undeterminated_basic<T> > {
typedef typename generic_binary_traits<BinaryFunction>::template hint<A1,undeterminated_basic<T1>,undeterminated_basic<T> >::second_argument_type
argument_type;
typedef typename generic_binary_traits<BinaryFunction>::template hint<A1,undeterminated_basic<T>,undeterminated_basic<T> >::result_type
result_type;
};
static space_constant::valued_type
valued_tag (space_constant::valued_type arg_tag) {
static const space_constant::valued_type arg1_tag = space_constant::valued_tag_traits<A1>::value;
return generic_binary_traits<BinaryFunction>::valued_tag (arg1_tag, arg_tag) ;
}
};
// ----------------------------------------------------------------------------
// chap 3.2. binder_second
// ----------------------------------------------------------------------------
template<class BinaryFunction, class A2>
struct binder_second {
binder_second (const BinaryFunction& f, const A2& x2) : _f(f), _x2(x2) {}
template<class A1>
typename generic_binary_traits<BinaryFunction>::template result_hint<A1,A2>::type
operator() (const A1& x1) const { return _f(x1,_x2); }
protected:
BinaryFunction _f;
A2 _x2;
};
template<class BinaryFunction, class A2>
struct generic_unary_traits<binder_second<BinaryFunction,A2> > {
template <class A1>
struct result_hint {
typedef typename generic_binary_traits<BinaryFunction>::template result_hint<A1,A2>::type type;
};
template <class A1, class Result>
struct hint {
typedef Result result_type;
typedef A1 argument_type;
};
// result unknown:
template <class A1, class T>
struct hint<A1,undeterminated_basic<T> > {
typedef typename result_hint<A1>::type result_type;
typedef A1 argument_type;
};
// A1 unknown:
template <class R, class T>
struct hint<undeterminated_basic<T>,R> {
typedef R result_type;
typedef typename generic_binary_traits<BinaryFunction>::template hint<undeterminated_basic<T>,A2,R>::first_argument_type
argument_type;
};
// A1 & R unknown:
template <class T1, class T>
struct hint<undeterminated_basic<T1>,undeterminated_basic<T> > {
typedef typename generic_binary_traits<BinaryFunction>::template hint<undeterminated_basic<T1>,A2,undeterminated_basic<T> >::first_argument_type
argument_type;
typedef typename generic_binary_traits<BinaryFunction>::template hint<undeterminated_basic<T>,A2,undeterminated_basic<T> >::result_type
result_type;
};
static space_constant::valued_type
valued_tag (space_constant::valued_type arg_tag) {
static const space_constant::valued_type arg2_tag = space_constant::valued_tag_traits<A2>::value;
return generic_binary_traits<BinaryFunction>::valued_tag (arg_tag, arg2_tag) ;
}
};
// ---------------------------------------------------------------------------
// chap 3.3. binary swapper
// ---------------------------------------------------------------------------
// as details::mutiplies, for field_vf_bind_bf
// swap is equivalet to binder_second, but with a field instead of a constant
template<class BinaryFunction>
struct swapper {
swapper (const BinaryFunction& f) : _f(f) {}
template<class A1, class A2>
typename generic_binary_traits<BinaryFunction>::template result_hint<A2,A1>::type
operator() (const A1& x1, const A2& x2) const { return _f(x2,x1); }
protected:
BinaryFunction _f;
};
template<class BinaryFunction>
struct generic_binary_traits<swapper<BinaryFunction> > {
template <class A1, class A2>
struct result_hint : generic_binary_traits<BinaryFunction>::template result_hint<A2,A1> {};
template <class A1, class A2, class Result>
struct hint {
typedef typename generic_binary_traits<BinaryFunction>::template hint<A2,A1,Result> base;
typedef typename base::second_argument_type first_argument_type;
typedef typename base::first_argument_type second_argument_type;
typedef typename base::result_type result_type;
};
static space_constant::valued_type
valued_tag (space_constant::valued_type arg1_tag, space_constant::valued_type arg2_tag) {
return generic_binary_traits<BinaryFunction>::valued_tag (arg2_tag, arg1_tag) ;
}
};
// ---------------------------------------------------------------------------
// chap 3.4. unary & binary function wrapper, for compose
// ---------------------------------------------------------------------------
// TODO: use std::function<F> ?
template<class Function>
struct function_wrapper {
typedef Function type;
};
template<class Result, class Arg>
struct function_wrapper<Result(Arg)> {
typedef std::function<Result(Arg)> type;
};
template<class Result, class Arg1, class Arg2>
struct function_wrapper<Result(Arg1,Arg2)> {
typedef std::function<Result(Arg1,Arg2)> type;
};
template<class Function>
inline
Function
function_wrap (Function f)
{
return f;
}
template<class Result, class Arg>
inline
std::pointer_to_unary_function<Arg,Result>
function_wrap (Result(*f)(Arg))
{
return std::ptr_fun(f);
}
template<class Result, class Arg1, class Arg2>
inline
std::pointer_to_binary_function<Arg1,Arg2,Result>
function_wrap (Result(*f)(Arg1,Arg2))
{
return std::ptr_fun(f);
}
}} // namespace rheolef::details
#endif // _RHEOLEF_EXPRESSION_H
rheolef::details::generic_binary_traits< ddot_ >::hint< tensor4_basic< A1 >, undeterminated_basic< A2 >, undeterminated_basic< R > >::result_type
tensor_basic< R > result_type
Definition: expression.h:1656
rheolef::details::divides_result< T, T, typename std::enable_if< ! is_rheolef_arithmetic< T >::value &&! is_undeterminated< T >::value >::type >::S
scalar_traits< T >::type S
Definition: expression.h:1191
rheolef::details::generic_binary_traits< multiplies >::is_symmetric
std::false_type is_symmetric
Definition: expression.h:1152
rheolef::details::binder_second::operator()
generic_binary_traits< BinaryFunction >::template result_hint< A1, A2 >::type operator()(const A1 &x1) const
Definition: expression.h:1739
rheolef::details::generic_binary_traits< ddot_ >::hint< tensor4_basic< A1 >, undeterminated_basic< A2 >, tensor_basic< R > >::second_argument_type
tensor_basic< A2 > second_argument_type
Definition: expression.h:1607
rheolef::details::generic_unary_traits::result_hint::type
function_traits< Function >::result_type type
Definition: expression.h:190
rheolef::details::divides_result< tensor_basic< T1 >, tensor3_basic< T2 > >::type
binop_error< details::divides, tensor_basic< T1 >, tensor3_basic< T2 >, undeterminated_basic< S > > type
Definition: expression.h:1240
rheolef::details::generic_binary_traits< multiplies >::second_argument_hint< tensor3_basic< A1 >, point_basic< R > >::type
binop_error< details::multiplies, tensor3_basic< A1 >, undeterminated_basic< A1 >, point_basic< R > > type
Definition: expression.h:957
rheolef::details::generic_unary_traits< binder_second< BinaryFunction, A2 > >::hint::result_type
Result result_type
Definition: expression.h:1752
rheolef::details::generic_binary_traits< multiplies >::second_argument_hint< tensor4_basic< A1 >, tensor4_basic< R > >::type
S type
Definition: expression.h:994
rheolef::details::generic_binary_traits< multiplies >::hint< undeterminated_basic< A1 >, undeterminated_basic< A2 >, tensor4_basic< R > >::result_type
tensor4_basic< R > result_type
Definition: expression.h:1066
rheolef::details::scalar_binary_traits
Definition: expression.h:1369
rheolef::details::minus::operator()
plus_result< T1, T2 >::type operator()(const T1 &a, const T2 &b) const
Definition: expression.h:545
rheolef::details::ddot_result::S
promote< typename float_traits< A1 >::type, typename float_traits< A2 >::type >::type S
Definition: expression.h:1524
rheolef::details::binder_second
Definition: expression.h:1735
rheolef::details::generic_binary_traits< ddot_ >::hint< undeterminated_basic< A1 >, undeterminated_basic< A2 >, R >::E
binop_error< ddot_, A1, A2, R > E
Definition: expression.h:1616
rheolef::details::swapper
Definition: expression.h:1788
rheolef::details::divides_result< point_basic< T1 >, tensor3_basic< T2 > >::type
binop_error< details::divides, point_basic< T1 >, tensor3_basic< T2 >, undeterminated_basic< S > > type
Definition: expression.h:1235
rheolef::details::divides
Definition: expression.h:1271
rheolef::details::generic_binary_traits< minus >::result_hint::type
hint< A1, A2, undeterminated_basic< Float > >::result_type type
Definition: expression.h:554
rheolef::space_constant::last_valued
@ last_valued
Definition: space_constant.h:143
rheolef::details::multiplies_result< tensor_basic< S1 >, point_basic< S2 > >::type
point_basic< S > type
Definition: expression.h:644
rheolef::details::generic_binary_traits< multiplies >::hint< undeterminated_basic< A1 >, tensor4_basic< A2 >, undeterminated_basic< R > >::second_argument_type
tensor4_basic< A2 > second_argument_type
Definition: expression.h:1128
rheolef::details::generic_binary_traits< ddot_ >::hint::first_argument_type
std::conditional< is_undeterminated< A1 >::value, T, A1 >::type first_argument_type
Definition: expression.h:1556
rheolef::details::binder_first::_f
BinaryFunction _f
Definition: expression.h:1690
rheolef::details::generic_binary_traits< multiplies >::hint< tensor3_basic< A1 >, undeterminated_basic< A2 >, undeterminated_basic< R > >::first_argument_type
tensor3_basic< A1 > first_argument_type
Definition: expression.h:1092
rheolef::details::generic_unary_traits< binder_first< BinaryFunction, A1 > >::hint< undeterminated_basic< T1 >, undeterminated_basic< T > >::result_type
generic_binary_traits< BinaryFunction >::template hint< A1, undeterminated_basic< T >, undeterminated_basic< T > >::result_type result_type
Definition: expression.h:1723
rheolef::details::generic_binary_traits< multiplies >::second_argument_hint< tensor4_basic< A1 >, tensor3_basic< R > >::type
binop_error< details::multiplies, tensor4_basic< A1 >, undeterminated_basic< A1 >, tensor3_basic< R > > type
Definition: expression.h:988
rheolef::details::generic_binary_traits< multiplies >::hint< A1, undeterminated_basic< A2 >, R >::second_argument_type
second_argument_hint< A1, R >::type second_argument_type
Definition: expression.h:1028
rheolef::details::generic_binary_traits< multiplies >::hint< undeterminated_basic< A1 >, A2, undeterminated_basic< R > >::result_type
undeterminated_basic< R > result_type
Definition: expression.h:1101
rheolef::details::generic_binary_traits< multiplies >::first_argument_hint< tensor4_basic< A2 >, tensor_basic< R > >::type
binop_error< details::multiplies, undeterminated_basic< S >, tensor4_basic< A2 >, tensor_basic< R > > type
Definition: expression.h:867
rheolef::details::generic_binary_traits< divides >::hint< undeterminated_basic< A1 >, A2, undeterminated_basic< R > >::second_argument_type
A2 second_argument_type
Definition: expression.h:1345
rheolef::details::generic_binary_traits< multiplies >::second_argument_hint< tensor3_basic< A1 >, tensor_basic< R > >::type
point_basic< typename promote< A1, R >::type > type
Definition: expression.h:962
rheolef::details::multiplies_result< tensor3_basic< S1 >, tensor_basic< S2 > >::S
promote< S1, S2 >::type S
Definition: expression.h:671
rheolef::details::generic_binary_traits< divides >::hint< undeterminated_basic< A1 >, undeterminated_basic< A2 >, undeterminated_basic< R > >::first_argument_type
undeterminated_basic< A1 > first_argument_type
Definition: expression.h:1353
rheolef::details::generic_binary_traits< swapper< BinaryFunction > >::hint::second_argument_type
base::first_argument_type second_argument_type
Definition: expression.h:1805
rheolef::float_traits
helper for std::complex<T>: get basic T type
Definition: Float.h:93
rheolef::details::generic_binary_traits< multiplies >::hint< undeterminated_basic< A1 >, undeterminated_basic< A2 >, point_basic< R > >::result_type
point_basic< R > result_type
Definition: expression.h:1045
rheolef::details::generic_binary_traits< ddot_ >::hint< undeterminated_basic< A1 >, tensor4_basic< A2 >, tensor_basic< R > >::second_argument_type
tensor4_basic< A2 > second_argument_type
Definition: expression.h:1600
rheolef::details::multiplies_result< tensor3_basic< S1 >, tensor3_basic< S2 > >::type
binop_error< details::multiplies, tensor3_basic< S1 >, tensor3_basic< S2 >, undeterminated_basic< S > > type
Definition: expression.h:690
rheolef::details::ddot_result
Definition: expression.h:1523
rheolef::details::binder_first::_x1
A1 _x1
Definition: expression.h:1691
rheolef::details::generic_unary_traits< norm2_ >::hint::argument_type
A1 argument_type
Definition: expression.h:392
rheolef::details::divides_result< tensor_basic< T1 >, point_basic< T2 > >::S
promote< T1, T2 >::type S
Definition: expression.h:1217
rheolef::details::divides_result< tensor_basic< T >, T >::type
tensor_basic< T > type
Definition: expression.h:1200
rheolef::details::generic_binary_traits< multiplies >::hint< undeterminated_basic< A1 >, A2, undeterminated_basic< R > >::second_argument_type
A2 second_argument_type
Definition: expression.h:1100
rheolef::details::generic_binary_traits< multiplies >::first_argument_hint< point_basic< A2 >, tensor4_basic< R > >::type
binop_error< details::multiplies, undeterminated_basic< A2 >, point_basic< A2 >, tensor4_basic< R > > type
Definition: expression.h:808
rheolef::details::generic_binary_traits< ddot_ >::hint< undeterminated_basic< A1 >, tensor4_basic< A2 >, tensor_basic< R > >::first_argument_type
tensor_basic< A1 > first_argument_type
Definition: expression.h:1599
rheolef::point_basic
Definition: point.h:87
rheolef::details::generic_unary_traits::result_hint
Definition: expression.h:189
rheolef::details::or_type
Definition: field_expr_utilities.h:58
rheolef::details::multiplies_result< tensor_basic< S1 >, tensor4_basic< S2 > >::type
binop_error< details::multiplies, tensor_basic< S1 >, tensor4_basic< S2 >, undeterminated_basic< S > > type
Definition: expression.h:712
rheolef::details::generic_unary_traits< trans_ >::result_hint::type
tensor_basic< typename scalar_traits< A1 >::type > type
Definition: expression.h:332
rheolef::details::divides_result< point_basic< T1 >, tensor_basic< T2 > >::S
promote< T1, T2 >::type S
Definition: expression.h:1212
rheolef::details::generic_binary_traits< plus >::hint< A1, undeterminated_basic< A2 >, R >::second_argument_type
std::conditional< details::is_equal< A1, R >::value, R, binop_error< details::plus, A1, A2, R > >::type second_argument_type
Definition: expression.h:499
rheolef::details::generic_unary_traits< negate >::valued_tag
static space_constant::valued_type valued_tag(space_constant::valued_type tag)
Definition: expression.h:245
rheolef::tensor4_basic
Definition: tensor4.h:80
rheolef::details::generic_binary_traits< multiplies >::hint< tensor4_basic< A1 >, undeterminated_basic< A2 >, undeterminated_basic< R > >::first_argument_type
tensor4_basic< A2 > first_argument_type
Definition: expression.h:1134
rheolef::details::divides_result< T, T, typename std::enable_if< ! is_rheolef_arithmetic< T >::value &&! is_undeterminated< T >::value >::type >::type
binop_error< details::divides, T, T, undeterminated_basic< S > > type
Definition: expression.h:1192
rheolef::details::divides_result< point_basic< T >, T >::type
point_basic< T > type
Definition: expression.h:1196
rheolef::details::generic_unary_traits< binder_second< BinaryFunction, A2 > >::result_hint::type
generic_binary_traits< BinaryFunction >::template result_hint< A1, A2 >::type type
Definition: expression.h:1748
rheolef::details::generic_binary_traits< divides >::hint< A1, A2, undeterminated_basic< R > >::result_type
divides_result< A1, A2 >::type result_type
Definition: expression.h:1295
rheolef::details::generic_binary_traits< ddot_ >::hint::second_argument_type
std::conditional< is_undeterminated< A2 >::value, T, A2 >::type second_argument_type
Definition: expression.h:1557
rheolef::details::generic_binary_traits< multiplies >::second_argument_hint< point_basic< A1 >, point_basic< R > >::type
promote< A1, R >::type type
Definition: expression.h:917
rheolef::details::generic_binary_traits< divides >::hint< undeterminated_basic< A1 >, undeterminated_basic< A2 >, undeterminated_basic< R > >::result_type
undeterminated_basic< R > result_type
Definition: expression.h:1355
rheolef::details::generic_binary_traits< ddot_ >::hint< tensor4_basic< A1 >, undeterminated_basic< A2 >, undeterminated_basic< R > >::first_argument_type
tensor4_basic< A1 > first_argument_type
Definition: expression.h:1654
rheolef::details::generic_binary_traits< swapper< BinaryFunction > >::hint::result_type
base::result_type result_type
Definition: expression.h:1806
rheolef::details::generic_unary_traits< binder_second< BinaryFunction, A2 > >::hint< A1, undeterminated_basic< T > >::argument_type
A1 argument_type
Definition: expression.h:1759
rheolef::details::generic_unary_traits< binder_first< BinaryFunction, A1 > >::hint< A2, undeterminated_basic< T > >::result_type
result_hint< A2 >::type result_type
Definition: expression.h:1707
rheolef::details::generic_unary_traits< unary_plus >::hint::result_type
promote< Arg, Result >::type result_type
Definition: expression.h:219
rheolef::details::generic_unary_traits::hint
Definition: expression.h:193
rheolef::details::generic_binary_traits< multiplies >::result_hint::type
hint< Arg1, Arg2, undeterminated_basic< Float > >::result_type type
Definition: expression.h:1150
rheolef::details::generic_binary_traits< multiplies >::hint< undeterminated_basic< A1 >, undeterminated_basic< A2 >, undeterminated_basic< R > >::result_type
undeterminated_basic< R > result_type
Definition: expression.h:1145
rheolef::details::multiplies_result< point_basic< S1 >, tensor4_basic< S2 > >::type
binop_error< details::multiplies, point_basic< S1 >, tensor4_basic< S2 >, undeterminated_basic< S > > type
Definition: expression.h:706
rheolef::details::generic_binary_traits< multiplies >::first_argument_hint< tensor3_basic< A2 >, tensor_basic< R > >::type
binop_error< details::multiplies, undeterminated_basic< A2 >, tensor3_basic< A2 >, tensor_basic< R > > type
Definition: expression.h:843
rheolef::Function
rheolef::std Function
rheolef::details::generic_binary_traits< divides >::hint< A1, undeterminated_basic< A2 >, R >::first_argument_type
A1 first_argument_type
Definition: expression.h:1314
rheolef::details::generic_binary_traits< multiplies >::hint< undeterminated_basic< A1 >, undeterminated_basic< A2 >, tensor_basic< R > >::first_argument_type
undeterminated_basic< A1 > first_argument_type
Definition: expression.h:1050
rheolef::details::generic_binary_traits< minus >::is_symmetric
std::false_type is_symmetric
Definition: expression.h:560
rheolef::details::generic_binary_traits< multiplies >::first_argument_hint< tensor4_basic< A2 >, tensor_basic< R > >::S
promote< A2, R >::type S
Definition: expression.h:866
rheolef::details::multiplies_result< tensor_basic< S >, S >::type
tensor_basic< S > type
Definition: expression.h:638
rheolef::details::generic_binary_traits< multiplies >::hint< A1, undeterminated_basic< A2 >, undeterminated_basic< R > >::result_type
undeterminated_basic< R > result_type
Definition: expression.h:1073
rheolef::details::norm2_::operator()
float_traits< T >::type operator()(const T &x) const
Definition: expression.h:377
rheolef::details::ddot_result< tensor_basic< A1 >, tensor_basic< A2 > >::S
promote< typename float_traits< A1 >::type, typename float_traits< A2 >::type >::type S
Definition: expression.h:1529
rheolef::details::generic_binary_traits< ddot_ >::hint< undeterminated_basic< A1 >, tensor4_basic< A2 >, undeterminated_basic< R > >::second_argument_type
tensor4_basic< A2 > second_argument_type
Definition: expression.h:1638
rheolef::details::generic_binary_traits< multiplies >::hint< undeterminated_basic< A1 >, tensor4_basic< A2 >, undeterminated_basic< R > >::result_type
tensor4_basic< R > result_type
Definition: expression.h:1129
rheolef::details::generic_binary_traits< multiplies >::hint< undeterminated_basic< A1 >, tensor3_basic< A2 >, undeterminated_basic< R > >::first_argument_type
A1 first_argument_type
Definition: expression.h:1120
rheolef::details::generic_binary_traits< plus >::hint< undeterminated_basic< A1 >, undeterminated_basic< A2 >, undeterminated_basic< R > >::first_argument_type
undeterminated_basic< A1 > first_argument_type
Definition: expression.h:526
rheolef::details::generic_binary_traits< multiplies >::valued_tag
static space_constant::valued_type valued_tag(space_constant::valued_type tag1, space_constant::valued_type tag2)
Definition: expression.h:753
rheolef::details::multiplies_result< tensor3_basic< S1 >, point_basic< S2 > >::type
tensor_basic< S > type
Definition: expression.h:666
rheolef::details::negate::operator()
T operator()(const T &a) const
Definition: expression.h:231
rheolef::details::scalar_binary_traits::hint::first_argument_type
std::conditional< is_undeterminated< A1 >::value,typename std::conditional< is_good::value,S1,binop_error< F, A1, A2, R > >::type,A1 >::type first_argument_type
Definition: expression.h:1405
rheolef::details::scalar_binary_traits::hint::is_good
details::and_type< details::or_type< details::is_scalar< A1 >,is_undeterminated< A1 > >,details::or_type< details::is_scalar< A2 >,is_undeterminated< A2 > >,details::or_type< details::is_scalar< R >,is_undeterminated< R > > >::type is_good
Definition: expression.h:1396
rheolef::details::generic_binary_traits< multiplies >::hint< tensor_basic< A1 >, undeterminated_basic< A2 >, undeterminated_basic< R > >::result_type
undeterminated_basic< R > result_type
Definition: expression.h:1087
rheolef::details::generic_binary_traits< divides >::hint< undeterminated_basic< A1 >, A2, undeterminated_basic< R > >::result_type
first_argument_type result_type
Definition: expression.h:1346
rheolef::details::multiplies_result::type
promote< A1, A2 >::type type
Definition: expression.h:606
rheolef::details::generic_binary_traits< ddot_ >::hint< undeterminated_basic< A1 >, tensor_basic< A2 >, R >::first_argument_type
std::conditional< is_scalar< R >::value, tensor_basic< A1 >, E >::type first_argument_type
Definition: expression.h:1583
rheolef::details::generic_binary_traits< multiplies >::hint< undeterminated_basic< A1 >, undeterminated_basic< A2 >, tensor3_basic< R > >::result_type
tensor3_basic< R > result_type
Definition: expression.h:1059
rheolef::details::generic_binary_traits< multiplies >::hint< undeterminated_basic< A1 >, point_basic< A2 >, undeterminated_basic< R > >::second_argument_type
point_basic< A2 > second_argument_type
Definition: expression.h:1107
rheolef::details::swapper::_f
BinaryFunction _f
Definition: expression.h:1794
rheolef::details::multiplies_result< tensor_basic< S1 >, tensor_basic< S2 > >::S
promote< S1, S2 >::type S
Definition: expression.h:649
rheolef::details::generic_binary_traits< plus >::hint< undeterminated_basic< A1 >, A2, R >::second_argument_type
A2 second_argument_type
Definition: expression.h:488
rheolef::details::generic_binary_traits< multiplies >::hint< undeterminated_basic< A1 >, A2, R >::second_argument_type
A2 second_argument_type
Definition: expression.h:1021
rheolef::details::generic_binary_traits< divides >::hint< A1, A2, undeterminated_basic< R > >::first_argument_type
A1 first_argument_type
Definition: expression.h:1293
rheolef::details::multiplies_result< tensor4_basic< S1 >, tensor3_basic< S2 > >::S
promote< S1, S2 >::type S
Definition: expression.h:735
rheolef::details::generic_binary_traits< ddot_ >::is_symmetric
std::true_type is_symmetric
Definition: expression.h:1673
rheolef::details::generic_binary_traits< multiplies >::hint< undeterminated_basic< A1 >, tensor_basic< A2 >, undeterminated_basic< R > >::result_type
undeterminated_basic< R > result_type
Definition: expression.h:1115
rheolef::details::generic_binary_traits< multiplies >::hint< undeterminated_basic< A1 >, undeterminated_basic< A2 >, R >::second_argument_type
A2 second_argument_type
Definition: expression.h:1037
rheolef::details::binder_first::binder_first
binder_first(const BinaryFunction &f, const A1 &x1)
Definition: expression.h:1685
rheolef::details::generic_binary_traits< ddot_ >::hint< tensor4_basic< A1 >, undeterminated_basic< A2 >, tensor_basic< R > >::first_argument_type
tensor4_basic< A1 > first_argument_type
Definition: expression.h:1606
rheolef::details::generic_binary_traits< dot_ >::hint::S2
scalar_traits< A2 >::type S2
Definition: expression.h:1466
rheolef::value
rheolef::std value
rheolef::details::generic_unary_traits::hint::result_type
function_traits< Function >::result_type result_type
Definition: expression.h:194
rheolef::details::generic_binary_traits< ddot_ >::hint< undeterminated_basic< A1 >, tensor_basic< A2 >, undeterminated_basic< R > >::first_argument_type
undeterminated_basic< A1 > first_argument_type
Definition: expression.h:1630
rheolef::details::generic_binary_traits< multiplies >::second_argument_hint< tensor_basic< A1 >, tensor_basic< R > >::type
undeterminated_basic< typename promote< A1, R >::type > type
Definition: expression.h:937
rheolef::details::generic_unary_traits< norm2_ >::valued_tag
static space_constant::valued_type valued_tag(space_constant::valued_type tag)
Definition: expression.h:395
rheolef::details::generic_binary_traits< multiplies >::hint< undeterminated_basic< A1 >, undeterminated_basic< A2 >, tensor_basic< R > >::second_argument_type
undeterminated_basic< A2 > second_argument_type
Definition: expression.h:1051
rheolef::details::generic_binary_traits
Definition: expression.h:406
rheolef::details::generic_binary_traits< ddot_ >::hint< undeterminated_basic< A1 >, undeterminated_basic< A2 >, undeterminated_basic< R > >::result_type
undeterminated_basic< R > result_type
Definition: expression.h:1666
rheolef::details::generic_unary_traits< binder_first< BinaryFunction, A1 > >::hint< A2, undeterminated_basic< T > >::argument_type
A1 argument_type
Definition: expression.h:1708
rheolef::tensor_basic
Definition: tensor.h:90
rheolef::details::multiplies_result< tensor4_basic< S1 >, tensor4_basic< S2 > >::S
promote< S1, S2 >::type S
Definition: expression.h:741
rheolef::details::generic_binary_traits< ddot_ >::hint< A1, A2, undeterminated_basic< R > >::second_argument_type
std::conditional< is_undeterminated< A2 >::value &&is_error< result_type >::value,result_type,A2 >::type second_argument_type
Definition: expression.h:1573
rheolef::details::generic_binary_traits< dot_ >::hint::S1
scalar_traits< A1 >::type S1
Definition: expression.h:1465
mkgeo_ball.f
f
Definition: mkgeo_ball.sh:221
rheolef::details::minus
Definition: expression.h:543
rheolef::details::generic_unary_traits< norm2_ >::hint::result_type
result_hint< A1 >::type result_type
Definition: expression.h:391
rheolef::details::binder_second::binder_second
binder_second(const BinaryFunction &f, const A2 &x2)
Definition: expression.h:1736
rheolef::details::multiplies_result< point_basic< S1 >, tensor_basic< S2 > >::S
promote< S1, S2 >::type S
Definition: expression.h:632
rheolef::details::unary_plus::operator()
T operator()(const T &a) const
Definition: expression.h:209
rheolef::details::generic_binary_traits< multiplies >::hint< tensor3_basic< A1 >, undeterminated_basic< A2 >, undeterminated_basic< R > >::second_argument_type
undeterminated_basic< A2 > second_argument_type
Definition: expression.h:1093
rheolef::details::generic_binary_traits< multiplies >::first_argument_hint< tensor4_basic< A2 >, point_basic< R > >::type
binop_error< details::multiplies, undeterminated_basic< S >, tensor4_basic< A2 >, point_basic< R > > type
Definition: expression.h:861
rheolef::details::multiplies_result< tensor4_basic< S1 >, tensor4_basic< S2 > >::type
binop_error< details::multiplies, tensor4_basic< S1 >, tensor4_basic< S2 >, undeterminated_basic< S > > type
Definition: expression.h:742
rheolef::details::generic_binary_traits< multiplies >::hint< A1, undeterminated_basic< A2 >, R >::first_argument_type
A1 first_argument_type
Definition: expression.h:1027
rheolef::pow
space_mult_list< T, M > pow(const space_basic< T, M > &X, size_t n)
Definition: space_mult.h:120
rheolef::details::generic_unary_traits< negate >::hint::result_type
promote< Arg, Result >::type result_type
Definition: expression.h:241
rheolef::details::generic_binary_traits< plus >::is_symmetric
std::true_type is_symmetric
Definition: expression.h:534
rheolef::details::generic_unary_traits< negate >::result_hint::type
Arg type
Definition: expression.h:237
rheolef::details::multiplies_result< S, tensor4_basic< S > >::type
tensor4_basic< S > type
Definition: expression.h:695
rheolef::details::generic_binary_traits< ddot_ >::hint< undeterminated_basic< A1 >, tensor_basic< A2 >, undeterminated_basic< R > >::result_type
undeterminated_basic< R > result_type
Definition: expression.h:1632
rheolef::details::generic_unary_traits< binder_first< BinaryFunction, A1 > >::hint::argument_type
A2 argument_type
Definition: expression.h:1702
rheolef::details::divides_result< T, point_basic< T > >::type
binop_error< details::divides, T, point_basic< T >, undeterminated_basic< T > > type
Definition: expression.h:1204
rheolef::details::generic_binary_traits< multiplies >::hint< A1, undeterminated_basic< A2 >, undeterminated_basic< R > >::second_argument_type
undeterminated_basic< A2 > second_argument_type
Definition: expression.h:1072
rheolef::details::multiplies_result< point_basic< S1 >, tensor3_basic< S2 > >::S
promote< S1, S2 >::type S
Definition: expression.h:677
rheolef::details::generic_binary_traits< multiplies >::hint< undeterminated_basic< A1 >, point_basic< A2 >, undeterminated_basic< R > >::first_argument_type
undeterminated_basic< A1 > first_argument_type
Definition: expression.h:1106
rheolef::details::result_type
Definition: space_constant.h:339
rheolef::details::divides_result< point_basic< T1 >, tensor_basic< T2 > >::type
binop_error< details::divides, point_basic< T1 >, tensor_basic< T2 >, undeterminated_basic< S > > type
Definition: expression.h:1213
rheolef::space_constant::valued_type
valued_type
Definition: space_constant.h:135
rheolef::details::generic_unary_traits< binder_second< BinaryFunction, A2 > >::valued_tag
static space_constant::valued_type valued_tag(space_constant::valued_type arg_tag)
Definition: expression.h:1777
rheolef::details::generic_binary_traits< multiplies >::first_argument_hint< tensor_basic< A2 >, tensor3_basic< R > >::type
tensor3_basic< typename promote< A2, R >::type > type
Definition: expression.h:828
rheolef::undeterminated_basic
helper for generic field value_type: T, point_basic<T> or tensor_basic<T>
Definition: undeterminated.h:32
rheolef::details::generic_binary_traits< multiplies >::first_argument_hint< tensor4_basic< A2 >, tensor4_basic< R > >::type
promote< A2, R >::type type
Definition: expression.h:878
rheolef::details::multiplies_result< point_basic< S1 >, point_basic< S2 > >::S
promote< S1, S2 >::type S
Definition: expression.h:626
rheolef::details::function_wrap
Function function_wrap(Function f)
Definition: expression.h:1833
rheolef::details::divides_result< tensor3_basic< T1 >, tensor4_basic< T2 > >::S
promote< T1, T2 >::type S
Definition: expression.h:1268
rheolef::details::generic_binary_traits< ddot_ >::hint< undeterminated_basic< A1 >, undeterminated_basic< A2 >, R >::second_argument_type
std::conditional< is_scalar< R >::value, tensor_basic< A2 >, E >::type second_argument_type
Definition: expression.h:1620
rheolef::details::generic_binary_traits< multiplies >::second_argument_hint< point_basic< A1 >, tensor3_basic< R > >::type
binop_error< details::multiplies, point_basic< A1 >, undeterminated_basic< A1 >, tensor3_basic< R > > type
Definition: expression.h:942
rheolef::details::generic_unary_traits< binder_first< BinaryFunction, A1 > >::result_hint::type
generic_binary_traits< BinaryFunction >::template result_hint< A1, A2 >::type type
Definition: expression.h:1697
rheolef::details::generic_binary_traits< multiplies >::first_argument_hint< tensor3_basic< A2 >, tensor3_basic< R > >::type
promote< A2, R >::type type
Definition: expression.h:848
rheolef::details::generic_binary_traits< plus >::hint< A1, undeterminated_basic< A2 >, undeterminated_basic< R > >::result_type
A1 result_type
Definition: expression.h:514
rheolef::details::scalar_binary_traits::valued_tag
static space_constant::valued_type valued_tag(space_constant::valued_type tag1, space_constant::valued_type tag2)
Definition: expression.h:1371
rheolef::details::binder_first
Definition: expression.h:1684
rheolef::details::generic_unary_traits< binder_second< BinaryFunction, A2 > >::hint::argument_type
A1 argument_type
Definition: expression.h:1753
rheolef::details::generic_binary_traits< ddot_ >::hint< undeterminated_basic< A1 >, tensor_basic< A2 >, R >::second_argument_type
tensor_basic< A2 > second_argument_type
Definition: expression.h:1584
rheolef::details::generic_unary_traits< norm_ >::valued_tag
static space_constant::valued_type valued_tag(space_constant::valued_type tag)
Definition: expression.h:368
rheolef::details::scalar_binary_traits::hint
Definition: expression.h:1379
rheolef::details::generic_binary_traits< ddot_ >::hint< A1, A2, undeterminated_basic< R > >::result_type
ddot_result< A1, A2 >::type result_type
Definition: expression.h:1563
rheolef::details::is_error
Definition: expression.h:168
rheolef::details::multiplies_result< tensor_basic< S1 >, tensor3_basic< S2 > >::S
promote< S1, S2 >::type S
Definition: expression.h:683
rheolef::norm
T norm(const vec< T, M > &x)
norm(x): see the expression page for the full documentation
Definition: vec.h:387
rheolef::details::generic_binary_traits< multiplies >::first_argument_hint< A2, tensor_basic< R > >::type
tensor_basic< typename promote< A2, R >::type > type
Definition: expression.h:772
rheolef::details::generic_binary_traits< ddot_ >::hint< tensor_basic< A1 >, undeterminated_basic< A2 >, R >::first_argument_type
tensor_basic< A1 > first_argument_type
Definition: expression.h:1591
rheolef::details::generic_binary_traits< plus >::hint< undeterminated_basic< A1 >, A2, undeterminated_basic< R > >::result_type
A2 result_type
Definition: expression.h:521
rheolef::details::generic_binary_traits< swapper< BinaryFunction > >::valued_tag
static space_constant::valued_type valued_tag(space_constant::valued_type arg1_tag, space_constant::valued_type arg2_tag)
Definition: expression.h:1809
rheolef::details::generic_unary_traits< binder_second< BinaryFunction, A2 > >::hint< A1, undeterminated_basic< T > >::result_type
result_hint< A1 >::type result_type
Definition: expression.h:1758
rheolef::details::generic_binary_traits< ddot_ >::hint< undeterminated_basic< A1 >, tensor4_basic< A2 >, undeterminated_basic< R > >::result_type
tensor_basic< R > result_type
Definition: expression.h:1639
rheolef::details::generic_binary_traits::hint
Definition: expression.h:412
rheolef::details::generic_unary_traits< binder_second< BinaryFunction, A2 > >::hint< undeterminated_basic< T >, R >::argument_type
generic_binary_traits< BinaryFunction >::template hint< undeterminated_basic< T >, A2, R >::first_argument_type argument_type
Definition: expression.h:1766
rheolef::details::generic_binary_traits< divides >::valued_tag
static space_constant::valued_type valued_tag(space_constant::valued_type tag1, space_constant::valued_type tag2)
Definition: expression.h:1358
rheolef::details::generic_binary_traits< multiplies >::hint::second_argument_type
A2 second_argument_type
Definition: expression.h:1002
rheolef::details::binder_second::_x2
A2 _x2
Definition: expression.h:1742
rheolef::details::generic_unary_traits< unary_plus >::hint::argument_type
result_type argument_type
Definition: expression.h:220
rheolef::details::multiplies_result< tensor_basic< S1 >, point_basic< S2 > >::S
promote< S1, S2 >::type S
Definition: expression.h:643
rheolef::details::function_wrapper< Result(Arg1, Arg2)>::type
std::function< Result(Arg1, Arg2)> type
Definition: expression.h:1827
rheolef::details::plus::operator()
plus_result< T1, T2 >::type operator()(const T1 &a, const T2 &b) const
Definition: expression.h:458
rheolef::details::generic_binary_traits< multiplies >::hint< undeterminated_basic< A1 >, A2, undeterminated_basic< R > >::first_argument_type
undeterminated_basic< A1 > first_argument_type
Definition: expression.h:1099
rheolef::details::multiplies_result< tensor_basic< S1 >, tensor4_basic< S2 > >::S
promote< S1, S2 >::type S
Definition: expression.h:711
rheolef::details::generic_unary_traits< binder_first< BinaryFunction, A1 > >::valued_tag
static space_constant::valued_type valued_tag(space_constant::valued_type arg_tag)
Definition: expression.h:1726
rheolef::norm2
T norm2(const vec< T, M > &x)
norm2(x): see the expression page for the full documentation
Definition: vec.h:379
rheolef::details::generic_binary_traits< plus >::hint< undeterminated_basic< A1 >, A2, undeterminated_basic< R > >::first_argument_type
A2 first_argument_type
Definition: expression.h:519
rheolef::details::multiplies_result< tensor3_basic< S1 >, point_basic< S2 > >::S
promote< S1, S2 >::type S
Definition: expression.h:665
rheolef::details::multiplies::operator()
multiplies_result< T1, T2 >::type operator()(const T1 &a, const T2 &b) const
Definition: expression.h:748
rheolef::details::generic_binary_traits< multiplies >::second_argument_hint< point_basic< A1 >, tensor_basic< R > >::type
binop_error< details::multiplies, tensor_basic< A1 >, undeterminated_basic< A1 >, tensor_basic< R > > type
Definition: expression.h:922
rheolef::details::generic_binary_traits::hint::second_argument_type
std::decay< typename function_traits< Function >::template arg< 1 >::type >::type second_argument_type
Definition: expression.h:416
rheolef::details::generic_binary_traits< divides >::hint< A1, undeterminated_basic< A2 >, undeterminated_basic< R > >::first_argument_type
A1 first_argument_type
Definition: expression.h:1333
rheolef::details::_RHEOLEF_generic_unary_scalar
_RHEOLEF_generic_unary_scalar(cos) _RHEOLEF_generic_unary_scalar(sin) _RHEOLEF_generic_unary_scalar(tan) _RHEOLEF_generic_unary_scalar(acos) _RHEOLEF_generic_unary_scalar(asin) _RHEOLEF_generic_unary_scalar(atan) _RHEOLEF_generic_unary_scalar(cosh) _RHEOLEF_generic_unary_scalar(sinh) _RHEOLEF_generic_unary_scalar(tanh) _RHEOLEF_generic_unary_scalar(exp) _RHEOLEF_generic_unary_scalar(log) _RHEOLEF_generic_unary_scalar(log10) _RHEOLEF_generic_unary_scalar(sqrt) _RHEOLEF_generic_unary_scalar(abs) _RHEOLEF_generic_unary_scalar(fabs) _RHEOLEF_generic_unary_scalar(floor) _RHEOLEF_generic_unary_scalar(ceil) _RHEOLEF_generic_unary_scalar(sqr) struct tr_
Definition: expression.h:278
rheolef::details::generic_binary_traits< multiplies >::hint< point_basic< A1 >, undeterminated_basic< A2 >, undeterminated_basic< R > >::result_type
point_basic< R > result_type
Definition: expression.h:1080
rheolef::details::trans_::operator()
tensor_basic< T > operator()(const tensor_basic< T > &a) const
Definition: expression.h:326
rheolef::details::generic_binary_traits< multiplies >::hint< point_basic< A1 >, undeterminated_basic< A2 >, undeterminated_basic< R > >::second_argument_type
A2 second_argument_type
Definition: expression.h:1079
rheolef::details::generic_unary_traits< trans_ >::hint::result_type
tensor_basic< S > result_type
Definition: expression.h:338
rheolef::details::generic_binary_traits< divides >::hint< undeterminated_basic< A1 >, undeterminated_basic< A2 >, undeterminated_basic< R > >::second_argument_type
A2 second_argument_type
Definition: expression.h:1354
rheolef::details::multiplies_result< tensor4_basic< S1 >, point_basic< S2 > >::S
promote< S1, S2 >::type S
Definition: expression.h:723
rheolef::details::norm_::operator()
float_traits< T >::type operator()(const T &x) const
Definition: expression.h:350
rheolef::details::generic_binary_traits< plus >::hint< undeterminated_basic< A1 >, undeterminated_basic< A2 >, undeterminated_basic< R > >::second_argument_type
undeterminated_basic< A2 > second_argument_type
Definition: expression.h:527
rheolef::details::generic_binary_traits< multiplies >::hint< undeterminated_basic< A1 >, tensor3_basic< A2 >, undeterminated_basic< R > >::second_argument_type
tensor3_basic< A2 > second_argument_type
Definition: expression.h:1121
rheolef::details::multiplies_result< tensor4_basic< S1 >, tensor_basic< S2 > >::S
promote< S1, S2 >::type S
Definition: expression.h:729
rheolef::details::generic_binary_traits< divides >::hint< A1, undeterminated_basic< A2 >, undeterminated_basic< R > >::second_argument_type
scalar_traits< A2 >::type second_argument_type
Definition: expression.h:1334
rheolef::details::multiplies_result< tensor4_basic< S >, S >::type
tensor4_basic< S > type
Definition: expression.h:700
rheolef::details::and_type
Definition: field_expr_utilities.h:81
rheolef::details::generic_binary_traits< divides >::hint< undeterminated_basic< A1 >, A2, undeterminated_basic< R > >::S2
scalar_traits< A2 >::type S2
Definition: expression.h:1340
rheolef::details::function_wrapper::type
Function type
Definition: expression.h:1819
rheolef::space_constant::scalar
@ scalar
Definition: space_constant.h:136
rheolef::details::multiplies_result< tensor3_basic< S1 >, tensor_basic< S2 > >::type
tensor3_basic< S > type
Definition: expression.h:672
rheolef::details::divides_result< T1, T2, typename std::enable_if< is_undeterminated< T1 >::value &&is_undeterminated< T2 >::value >::type >::type
undeterminated_basic< typename promote< T1, T2 >::type > type
Definition: expression.h:1181
rheolef::details::generic_binary_traits< divides >::hint< A1, undeterminated_basic< A2 >, R >::second_argument_type
std::conditional< details::is_equal< A1, R >::value, S, binop_error< details::divides, A1, A2, R > >::type second_argument_type
Definition: expression.h:1318
rheolef::details::generic_unary_traits< tr_ >::result_hint::type
scalar_traits< A1 >::type type
Definition: expression.h:310
rheolef::details::generic_binary_traits< plus >::hint::first_argument_type
A1 first_argument_type
Definition: expression.h:467
rheolef::details::generic_binary_traits< multiplies >::hint< undeterminated_basic< A1 >, tensor_basic< A2 >, undeterminated_basic< R > >::second_argument_type
tensor_basic< A2 > second_argument_type
Definition: expression.h:1114
rheolef::details::generic_binary_traits< divides >::hint< undeterminated_basic< A1 >, undeterminated_basic< A2 >, R >::second_argument_type
scalar_traits< A2 >::type second_argument_type
Definition: expression.h:1327
rheolef::details::generic_binary_traits< multiplies >::second_argument_hint< tensor3_basic< A1 >, tensor3_basic< R > >::type
undeterminated_basic< typename promote< A1, R >::type > type
Definition: expression.h:967
rheolef::details::divides_result< tensor3_basic< T1 >, tensor4_basic< T2 > >::type
binop_error< details::divides, tensor3_basic< T1 >, tensor4_basic< T2 >, undeterminated_basic< S > > type
Definition: expression.h:1269
rheolef::details::plus
Definition: expression.h:456
rheolef::details::generic_binary_traits< multiplies >::first_argument_hint< A2, point_basic< R > >::type
point_basic< typename promote< A2, R >::type > type
Definition: expression.h:767
rheolef::details::generic_binary_traits< multiplies >::second_argument_hint< A1, tensor3_basic< R > >::type
tensor3_basic< typename promote< A1, R >::type > type
Definition: expression.h:901
rheolef::details::generic_unary_traits< negate >::hint::argument_type
result_type argument_type
Definition: expression.h:242
rheolef::BinaryFunction
rheolef::std BinaryFunction
rheolef::details::ddot_
Definition: expression.h:1542
rheolef::details::generic_binary_traits< plus >::valued_tag
static space_constant::valued_type valued_tag(space_constant::valued_type tag1, space_constant::valued_type tag2)
Definition: expression.h:531
rheolef::details::norm_
Definition: expression.h:348
rheolef::details::function_traits
Definition: field_expr_utilities.h:188
rheolef::details::generic_unary_traits< trans_ >::hint::S
promote< typename scalar_traits< A1 >::type, typename scalar_traits< R >::type >::type S
Definition: expression.h:336
rheolef::details::generic_binary_traits< dot_ >::is_symmetric
std::true_type is_symmetric
Definition: expression.h:1510
rheolef::details::generic_binary_traits< multiplies >::second_argument_hint< A1, tensor4_basic< R >, typename std::enable_if< is_rheolef_arithmetic< A1 >::value >::type >::type
tensor4_basic< typename promote< A1, R >::type > type
Definition: expression.h:907
rheolef::details::multiplies_result< tensor_basic< S1 >, tensor_basic< S2 > >::type
tensor_basic< S > type
Definition: expression.h:650
rheolef::details::unary_plus
Definition: expression.h:208
rheolef::details::generic_binary_traits< multiplies >::second_argument_hint< tensor4_basic< A1 >, point_basic< R > >::type
binop_error< details::multiplies, tensor4_basic< A1 >, undeterminated_basic< A1 >, point_basic< R > > type
Definition: expression.h:978
rheolef::details::divides_result< point_basic< T1 >, tensor4_basic< T2 > >::type
binop_error< details::divides, point_basic< T1 >, tensor4_basic< T2 >, undeterminated_basic< S > > type
Definition: expression.h:1259
rheolef::ddot
T ddot(const tensor_basic< T > &a, const tensor_basic< T > &b)
ddot(x,y): see the expression page for the full documentation
Definition: tensor.cc:278
a
Definition: diffusion_isotropic.h:25
rheolef::details::generic_binary_traits< ddot_ >::hint< tensor_basic< A1 >, undeterminated_basic< A2 >, R >::second_argument_type
std::conditional< is_scalar< R >::value, tensor_basic< A2 >, E >::type second_argument_type
Definition: expression.h:1593
rheolef::details::is_scalar
Definition: space_constant.h:42
rheolef::details::generic_binary_traits< multiplies >::hint< tensor3_basic< A1 >, undeterminated_basic< A2 >, undeterminated_basic< R > >::result_type
undeterminated_basic< R > result_type
Definition: expression.h:1094
rheolef::details::generic_unary_traits< trans_ >::valued_tag
static space_constant::valued_type valued_tag(space_constant::valued_type tag)
Definition: expression.h:341
rheolef::details::generic_binary_traits< divides >::is_symmetric
std::false_type is_symmetric
Definition: expression.h:1361
rheolef::details::generic_unary_traits::valued_tag
static space_constant::valued_type valued_tag(space_constant::valued_type)
Definition: expression.h:199
rheolef::type
rheolef::std type
rheolef::details::generic_binary_traits< ddot_ >::hint< undeterminated_basic< A1 >, tensor4_basic< A2 >, undeterminated_basic< R > >::first_argument_type
tensor_basic< A1 > first_argument_type
Definition: expression.h:1637
rheolef::details::scalar_binary_traits::result_hint::type
promote< typename scalar_traits< Arg1 >::type, typename scalar_traits< Arg2 >::type >::type type
Definition: expression.h:1376
rheolef::exp
tensor_basic< T > exp(const tensor_basic< T > &a, size_t d)
Definition: tensor-exp.cc:92
rheolef::details::divides_result< tensor3_basic< T1 >, point_basic< T2 > >::S
promote< T1, T2 >::type S
Definition: expression.h:1244
rheolef::details::generic_binary_traits< multiplies >::first_argument_hint< tensor4_basic< A2 >, R, typename std::enable_if< is_rheolef_arithmetic< R >::value >::type >::S
promote< A2, R >::type S
Definition: expression.h:854
rheolef::details::generic_binary_traits< plus >::hint< undeterminated_basic< A1 >, A2, undeterminated_basic< R > >::second_argument_type
A2 second_argument_type
Definition: expression.h:520
rheolef::details::multiplies_result< point_basic< S1 >, tensor4_basic< S2 > >::S
promote< S1, S2 >::type S
Definition: expression.h:705
rheolef::details::generic_binary_traits::result_hint::type
function_traits< Function >::result_type type
Definition: expression.h:409
rheolef::details::generic_binary_traits< multiplies >::hint< tensor_basic< A1 >, undeterminated_basic< A2 >, undeterminated_basic< R > >::first_argument_type
tensor_basic< A1 > first_argument_type
Definition: expression.h:1085
rheolef::details::generic_binary_traits< divides >::hint::result_type
Result result_type
Definition: expression.h:1286
rheolef::details::generic_binary_traits< multiplies >::first_argument_hint::type
promote< A2, R >::type type
Definition: expression.h:762
rheolef::details::generic_binary_traits< dot_ >::hint::S
scalar_traits< R >::type S
Definition: expression.h:1467
rheolef::details::generic_binary_traits< multiplies >::hint< undeterminated_basic< A1 >, undeterminated_basic< A2 >, tensor4_basic< R > >::second_argument_type
undeterminated_basic< A2 > second_argument_type
Definition: expression.h:1065
rheolef::details::generic_unary_traits::hint::argument_type
std::decay< typename function_traits< Function >::template arg< 0 >::type >::type argument_type
Definition: expression.h:196
rheolef::details::generic_unary_traits< tr_ >::hint::argument_type
tensor_basic< result_type > argument_type
Definition: expression.h:315
rheolef::details::generic_binary_traits< multiplies >::second_argument_hint< A1, point_basic< R > >::type
point_basic< typename promote< A1, R >::type > type
Definition: expression.h:891
rheolef::details::multiplies_result< point_basic< S >, S >::type
point_basic< S > type
Definition: expression.h:621
rheolef::details::generic_binary_traits< divides >::hint< undeterminated_basic< A1 >, A2, undeterminated_basic< R > >::first_argument_type
std::conditional< details::is_scalar< A2 >::value, undeterminated_basic< A1 >, binop_error< details::divides, A1, A2, R > >::type first_argument_type
Definition: expression.h:1344
rheolef::details::generic_unary_traits< trans_ >::hint::argument_type
tensor_basic< S > argument_type
Definition: expression.h:337
rheolef::details::multiplies
Definition: expression.h:745
rheolef::tensor3_basic
Definition: tensor3.h:73
rheolef::details::generic_binary_traits< multiplies >::second_argument_hint< tensor4_basic< A1 >, tensor4_basic< R > >::S
promote< A1, R >::type S
Definition: expression.h:993
rheolef::space_constant::unsymmetric_tensor
@ unsymmetric_tensor
Definition: space_constant.h:139
rheolef::details::generic_binary_traits< plus >::result_hint::type
hint< Arg1, Arg2, undeterminated_basic< Float > >::result_type type
Definition: expression.h:537
rheolef::details::generic_binary_traits< multiplies >::hint< undeterminated_basic< A1 >, undeterminated_basic< A2 >, tensor3_basic< R > >::first_argument_type
undeterminated_basic< A1 > first_argument_type
Definition: expression.h:1057
rheolef::details::generic_binary_traits< multiplies >::hint< undeterminated_basic< A1 >, undeterminated_basic< A2 >, tensor_basic< R > >::result_type
tensor_basic< R > result_type
Definition: expression.h:1052
rheolef::details::scalar_binary_traits::hint::S2
scalar_traits< A2 >::type S2
Definition: expression.h:1381
rheolef::details::generic_binary_traits::result_hint
Definition: expression.h:408
rheolef::details::scalar_binary_traits::result_hint
Definition: expression.h:1375
rheolef::details::divides_result< T, tensor_basic< T > >::type
binop_error< details::divides, T, tensor_basic< T >, undeterminated_basic< T > > type
Definition: expression.h:1208
rheolef::details::generic_binary_traits< ddot_ >::hint< undeterminated_basic< A1 >, undeterminated_basic< A2 >, undeterminated_basic< R > >::second_argument_type
undeterminated_basic< A2 > second_argument_type
Definition: expression.h:1665
rheolef::details::multiplies_result< S, tensor3_basic< S > >::type
tensor3_basic< S > type
Definition: expression.h:655
rheolef::details::multiplies_result< tensor4_basic< S1 >, tensor3_basic< S2 > >::type
binop_error< details::multiplies, tensor4_basic< S1 >, tensor3_basic< S2 >, undeterminated_basic< S > > type
Definition: expression.h:736
rheolef::details::divides_result< T1, T2, typename std::enable_if< is_rheolef_arithmetic< T1 >::value &&is_rheolef_arithmetic< T2 >::value >::type >::type
promote< T1, T2 >::type type
Definition: expression.h:1171
rheolef::details::generic_binary_traits< multiplies >::hint< tensor_basic< A1 >, undeterminated_basic< A2 >, undeterminated_basic< R > >::second_argument_type
undeterminated_basic< A2 > second_argument_type
Definition: expression.h:1086
rheolef::details::generic_binary_traits< dot_ >::hint::first_argument_type
std::conditional< is_undeterminated< A1 >::value,typename std::conditional< is_good::value,point_basic< S1 >,binop_error< details::dot_, A1, A2, R > >::type,A1 >::type first_argument_type
Definition: expression.h:1490
rheolef::details::divides_result< tensor3_basic< T >, T >::type
tensor3_basic< T > type
Definition: expression.h:1222
rheolef
This file is part of Rheolef.
Definition: compiler_eigen.h:37
rheolef::float_traits::type
T type
Definition: Float.h:94
rheolef::details::trans_
Definition: expression.h:325
rheolef::space_constant::multiplies_result_tag
valued_type multiplies_result_tag(space_constant::valued_type tag1, space_constant::valued_type tag2)
Definition: space_constant.cc:410
rheolef::details::generic_binary_traits< divides >::hint< A1, A2, undeterminated_basic< R > >::second_argument_type
A2 second_argument_type
Definition: expression.h:1294
rheolef::details::generic_binary_traits< ddot_ >::hint::T
binop_error< ddot_, A1, A2, R > T
Definition: expression.h:1555
rheolef::details::generic_unary_traits< unary_plus >::result_hint::type
Arg type
Definition: expression.h:215
rheolef::details::generic_binary_traits< dot_ >::hint::is_good
details::and_type< details::or_type< details::is_point< A1 >,is_undeterminated< A1 > >,details::or_type< details::is_point< A2 >,is_undeterminated< A2 > >,details::or_type< details::is_scalar< R >,is_undeterminated< R > > >::type is_good
Definition: expression.h:1481
rheolef::details::generic_binary_traits< dot_ >::result_hint::type
promote< typename float_traits< Arg1 >::type, typename float_traits< Arg2 >::type >::type type
Definition: expression.h:1461
rheolef::details::generic_binary_traits::hint::first_argument_type
std::decay< typename function_traits< Function >::template arg< 0 >::type >::type first_argument_type
Definition: expression.h:414
rheolef::details::generic_binary_traits< multiplies >::hint< A1, undeterminated_basic< A2 >, undeterminated_basic< R > >::first_argument_type
A1 first_argument_type
Definition: expression.h:1071
rheolef::details::generic_binary_traits< multiplies >::hint::first_argument_type
A1 first_argument_type
Definition: expression.h:1001
rheolef::details::multiplies_result< tensor_basic< S1 >, tensor3_basic< S2 > >::type
binop_error< details::multiplies, tensor_basic< S1 >, tensor3_basic< S2 >, undeterminated_basic< S > > type
Definition: expression.h:684
rheolef::details::generic_binary_traits< ddot_ >::hint< undeterminated_basic< A1 >, tensor_basic< A2 >, R >::E
binop_error< ddot_, A1, A2, R > E
Definition: expression.h:1581
rheolef::details::generic_binary_traits< multiplies >::second_argument_hint< tensor_basic< A1 >, point_basic< R > >::type
point_basic< typename promote< A1, R >::type > type
Definition: expression.h:932
rheolef::details::scalar_binary_traits::hint::result_type
std::conditional< is_undeterminated< R >::value,typename std::conditional< is_good::value,S,binop_error< F, A1, A2, R > >::type,R >::type result_type
Definition: expression.h:1423
rheolef::details::divides_result< tensor_basic< T1 >, tensor4_basic< T2 > >::type
binop_error< details::divides, tensor_basic< T1 >, tensor4_basic< T2 >, undeterminated_basic< S > > type
Definition: expression.h:1264
rheolef::details::multiplies_result
Definition: expression.h:605
rheolef::details::generic_binary_traits< divides >::hint< undeterminated_basic< A1 >, A2, R >::S2
scalar_traits< A2 >::type S2
Definition: expression.h:1300
rheolef::details::plus_result< A1, A2, typename std::enable_if< is_rheolef_arithmetic< A1 >::value &&is_rheolef_arithmetic< A2 >::value >::type >::type
promote< A1, A2 >::type type
Definition: expression.h:446
rheolef::promote_not_specialized_for_this_case
Definition: promote.h:26
rheolef::details::binop_error
Definition: expression.h:166
rheolef::details::generic_binary_traits< dot_ >::hint::second_argument_type
std::conditional< is_undeterminated< A2 >::value,typename std::conditional< is_good::value,point_basic< S2 >,binop_error< details::dot_, A1, A2, R > >::type,A2 >::type second_argument_type
Definition: expression.h:1499
rheolef::details::divides_result< tensor_basic< T1 >, tensor4_basic< T2 > >::S
promote< T1, T2 >::type S
Definition: expression.h:1263
rheolef::details::ddot_result< tensor4_basic< A1 >, tensor_basic< A2 > >::type
tensor_basic< S > type
Definition: expression.h:1535
rheolef::details::generic_binary_traits< ddot_ >::hint< A1, A2, undeterminated_basic< R > >::first_argument_type
std::conditional< is_undeterminated< A1 >::value &&is_error< result_type >::value,result_type,A1 >::type first_argument_type
Definition: expression.h:1568
rheolef::details::generic_binary_traits< multiplies >::hint< undeterminated_basic< A1 >, undeterminated_basic< A2 >, tensor3_basic< R > >::second_argument_type
undeterminated_basic< A2 > second_argument_type
Definition: expression.h:1058
rheolef::details::generic_binary_traits< multiplies >::first_argument_hint< point_basic< A2 >, tensor_basic< R > >::type
tensor3_basic< typename promote< A2, R >::type > type
Definition: expression.h:798
rheolef::details::divides_result< point_basic< T1 >, tensor3_basic< T2 > >::S
promote< T1, T2 >::type S
Definition: expression.h:1234
rheolef::details::generic_binary_traits< swapper< BinaryFunction > >::hint::first_argument_type
base::second_argument_type first_argument_type
Definition: expression.h:1804
rheolef::details::generic_unary_traits
Definition: expression.h:187
rheolef::details::generic_binary_traits< multiplies >::hint< A1, A2, undeterminated_basic< R > >::result_type
multiplies_result< A1, A2 >::type result_type
Definition: expression.h:1012
rheolef::details::generic_binary_traits< plus >::hint< A1, undeterminated_basic< A2 >, R >::first_argument_type
A1 first_argument_type
Definition: expression.h:494
rheolef::details::generic_binary_traits< ddot_ >::result_hint::type
hint< Arg1, Arg2, undeterminated_basic< Float > >::result_type type
Definition: expression.h:1671
rheolef::details::generic_binary_traits< multiplies >::hint< undeterminated_basic< A1 >, tensor4_basic< A2 >, undeterminated_basic< R > >::first_argument_type
A1 first_argument_type
Definition: expression.h:1127
rheolef::details::ddot_result< tensor_basic< A1 >, tensor4_basic< A2 > >::S
promote< typename float_traits< A1 >::type, typename float_traits< A2 >::type >::type S
Definition: expression.h:1539
rheolef::details::generic_binary_traits< ddot_ >::hint< tensor4_basic< A1 >, undeterminated_basic< A2 >, tensor_basic< R > >::result_type
tensor_basic< R > result_type
Definition: expression.h:1608
rheolef::details::plus_result
Definition: expression.h:435
rheolef::details::generic_binary_traits< divides >::hint::second_argument_type
Arg2 second_argument_type
Definition: expression.h:1285
rheolef::details::generic_binary_traits< ddot_ >::hint< tensor4_basic< A1 >, undeterminated_basic< A2 >, undeterminated_basic< R > >::second_argument_type
tensor_basic< A2 > second_argument_type
Definition: expression.h:1655
rheolef::details::generic_binary_traits< multiplies >::hint< undeterminated_basic< A1 >, undeterminated_basic< A2 >, tensor4_basic< R > >::first_argument_type
undeterminated_basic< A1 > first_argument_type
Definition: expression.h:1064
rheolef::details::scalar_binary_traits::hint::second_argument_type
std::conditional< is_undeterminated< A2 >::value,typename std::conditional< is_good::value,S2,binop_error< F, A1, A2, R > >::type,A2 >::type second_argument_type
Definition: expression.h:1414
rheolef::details::generic_binary_traits< multiplies >::hint< undeterminated_basic< A1 >, undeterminated_basic< A2 >, point_basic< R > >::second_argument_type
undeterminated_basic< A2 > second_argument_type
Definition: expression.h:1044
rheolef::details::generic_binary_traits< multiplies >::first_argument_hint< A2, tensor3_basic< R > >::type
tensor3_basic< typename promote< A2, R >::type > type
Definition: expression.h:777
rheolef::details::generic_unary_traits< binder_second< BinaryFunction, A2 > >::hint< undeterminated_basic< T1 >, undeterminated_basic< T > >::result_type
generic_binary_traits< BinaryFunction >::template hint< undeterminated_basic< T >, A2, undeterminated_basic< T > >::result_type result_type
Definition: expression.h:1774
rheolef::details::multiplies_result< point_basic< S1 >, tensor3_basic< S2 > >::type
binop_error< details::multiplies, point_basic< S1 >, tensor3_basic< S2 >, undeterminated_basic< S > > type
Definition: expression.h:678
rheolef::space_constant::divides_result_tag
valued_type divides_result_tag(space_constant::valued_type tag1, space_constant::valued_type tag2)
Definition: space_constant.cc:421
rheolef::details::divides_result::type
undeterminated_basic< typename promote< typename scalar_traits< T1 >::type, typename scalar_traits< T2 >::type >::type > type
Definition: expression.h:1161
rheolef::details::divides_result< tensor3_basic< T1 >, tensor_basic< T2 > >::S
promote< T1, T2 >::type S
Definition: expression.h:1249
mkgeo_ball.b
b
Definition: mkgeo_ball.sh:152
rheolef::details::generic_binary_traits< ddot_ >::hint< tensor_basic< A1 >, undeterminated_basic< A2 >, undeterminated_basic< R > >::first_argument_type
tensor_basic< A1 > first_argument_type
Definition: expression.h:1647
rheolef::details::scalar_binary_traits::hint::S1
scalar_traits< A1 >::type S1
Definition: expression.h:1380
rheolef::details::binder_second::_f
BinaryFunction _f
Definition: expression.h:1741
rheolef::details::generic_binary_traits< multiplies >::hint< tensor4_basic< A1 >, undeterminated_basic< A2 >, undeterminated_basic< R > >::result_type
tensor4_basic< R > result_type
Definition: expression.h:1136
rheolef::details::generic_binary_traits< plus >::hint< undeterminated_basic< A1 >, undeterminated_basic< A2 >, undeterminated_basic< R > >::result_type
undeterminated_basic< R > result_type
Definition: expression.h:528
mkgeo_ball.a
a
Definition: mkgeo_ball.sh:151
rheolef::details::scalar_binary_traits::is_symmetric
std::false_type is_symmetric
Definition: expression.h:1425
rheolef::details::generic_unary_traits< norm2_ >::result_hint::type
float_traits< Arg >::type type
Definition: expression.h:387
rheolef::scalar_traits::type
T type
Definition: point.h:324
rheolef::details::generic_binary_traits< multiplies >::second_argument_hint< tensor_basic< A1 >, tensor3_basic< R > >::type
binop_error< details::multiplies, tensor_basic< A1 >, undeterminated_basic< A1 >, tensor3_basic< R > > type
Definition: expression.h:947
rheolef::details::plus_result::type
binop_error< details::plus, A1, A2, undeterminated_basic< Float > > type
Definition: expression.h:436
rheolef::details::generic_binary_traits< ddot_ >::hint< undeterminated_basic< A1 >, undeterminated_basic< A2 >, undeterminated_basic< R > >::first_argument_type
undeterminated_basic< A1 > first_argument_type
Definition: expression.h:1664
rheolef::details::generic_binary_traits< plus >::hint< A1, A2, undeterminated_basic< R > >::second_argument_type
A2 second_argument_type
Definition: expression.h:477
rheolef::details::ddot_result< tensor4_basic< A1 >, tensor_basic< A2 > >::S
promote< typename float_traits< A1 >::type, typename float_traits< A2 >::type >::type S
Definition: expression.h:1534
rheolef::details::multiplies_result< S, tensor_basic< S > >::type
tensor_basic< S > type
Definition: expression.h:616
rheolef::details::divides_result< T, tensor3_basic< T > >::type
binop_error< details::divides, T, tensor3_basic< T >, undeterminated_basic< T > > type
Definition: expression.h:1230
rheolef::details::generic_binary_traits< multiplies >::hint< undeterminated_basic< A1 >, undeterminated_basic< A2 >, R >::first_argument_type
A1 first_argument_type
Definition: expression.h:1036
rheolef::details::generic_binary_traits< multiplies >::first_argument_hint< tensor4_basic< A2 >, tensor3_basic< R > >::type
binop_error< details::multiplies, undeterminated_basic< S >, tensor4_basic< A2 >, tensor3_basic< R > > type
Definition: expression.h:873
rheolef::details::is_equal
Definition: space_constant.h:38
rheolef::details::negate
Definition: expression.h:230
rheolef::details::multiplies_result< point_basic< S1 >, tensor_basic< S2 > >::type
binop_error< details::multiplies, point_basic< S1 >, tensor_basic< S2 >, undeterminated_basic< S > > type
Definition: expression.h:633
rheolef::details::generic_binary_traits< multiplies >::first_argument_hint< tensor4_basic< A2 >, point_basic< R > >::S
promote< A2, R >::type S
Definition: expression.h:860
rheolef::details::generic_binary_traits< ddot_ >::valued_tag
static space_constant::valued_type valued_tag(space_constant::valued_type tag1, space_constant::valued_type tag2)
Definition: expression.h:1550
rheolef::details::generic_binary_traits< plus >::hint< A1, A2, undeterminated_basic< R > >::first_argument_type
A1 first_argument_type
Definition: expression.h:476
rheolef::details::ddot_result::type
binop_error< ddot_, A1, A2, undeterminated_basic< S > > type
Definition: expression.h:1525
rheolef::details::multiplies_result< tensor3_basic< S1 >, tensor4_basic< S2 > >::type
binop_error< details::multiplies, tensor3_basic< S1 >, tensor4_basic< S2 >, undeterminated_basic< S > > type
Definition: expression.h:718
rheolef::details::multiplies_result< tensor3_basic< S >, S >::type
tensor3_basic< S > type
Definition: expression.h:660
rheolef::details::generic_unary_traits< binder_first< BinaryFunction, A1 > >::hint< undeterminated_basic< T >, R >::argument_type
generic_binary_traits< BinaryFunction >::template hint< A1, undeterminated_basic< T >, R >::second_argument_type argument_type
Definition: expression.h:1715
rheolef::details::generic_binary_traits< multiplies >::hint< A1, A2, undeterminated_basic< R > >::second_argument_type
A2 second_argument_type
Definition: expression.h:1011
rheolef::details::generic_binary_traits< ddot_ >::hint< tensor_basic< A1 >, undeterminated_basic< A2 >, undeterminated_basic< R > >::result_type
undeterminated_basic< R > result_type
Definition: expression.h:1649
rheolef::details::generic_binary_traits< multiplies >::first_argument_hint< point_basic< A2 >, point_basic< R > >::type
undeterminated_basic< typename promote< A2, R >::type > type
Definition: expression.h:793
rheolef::details::_RHEOLEF_generic_binary_scalar
_RHEOLEF_generic_binary_scalar(atan2) _RHEOLEF_generic_binary_scalar(pow) _RHEOLEF_generic_binary_scalar(fmod) _RHEOLEF_generic_binary_scalar(min) _RHEOLEF_generic_binary_scalar(max) struct dot_
Definition: expression.h:1438
rheolef::details::is_point
Definition: space_constant.h:51
rheolef::details::generic_binary_traits< plus >::hint< A1, undeterminated_basic< A2 >, undeterminated_basic< R > >::first_argument_type
A1 first_argument_type
Definition: expression.h:512
rheolef::details::generic_binary_traits::hint::result_type
std::decay< typename function_traits< Function >::result_type >::type result_type
Definition: expression.h:418
rheolef::details::generic_binary_traits< multiplies >::second_argument_hint< A1, tensor_basic< R > >::type
tensor_basic< typename promote< A1, R >::type > type
Definition: expression.h:896
rheolef::details::generic_binary_traits< multiplies >::hint< undeterminated_basic< A1 >, tensor3_basic< A2 >, undeterminated_basic< R > >::result_type
tensor3_basic< R > result_type
Definition: expression.h:1122
rheolef::promote
Definition: promote.h:29
rheolef::details::multiplies_result< point_basic< S1 >, point_basic< S2 > >::type
binop_error< details::multiplies, point_basic< S1 >, point_basic< S2 >, undeterminated_basic< S > > type
Definition: expression.h:627
rheolef::details::divides_result< tensor4_basic< T >, T >::type
tensor4_basic< T > type
Definition: expression.h:1226
rheolef::details::generic_binary_traits< plus >::hint< A1, A2, undeterminated_basic< R > >::result_type
plus_result< A1, A2 >::type result_type
Definition: expression.h:478
rheolef::details::generic_unary_traits< tr_ >::valued_tag
static space_constant::valued_type valued_tag(space_constant::valued_type tag)
Definition: expression.h:318
rheolef::details::generic_binary_traits< multiplies >::first_argument_hint< point_basic< A2 >, tensor3_basic< R > >::type
binop_error< details::multiplies, undeterminated_basic< A2 >, point_basic< A2 >, tensor3_basic< R > > type
Definition: expression.h:803
rheolef::details::generic_binary_traits< plus >::hint< undeterminated_basic< A1 >, A2, R >::first_argument_type
std::conditional< details::is_equal< A2, R >::value, R, binop_error< details::plus, A1, A2, R > >::type first_argument_type
Definition: expression.h:487
rheolef::details::generic_binary_traits< multiplies >::hint< point_basic< A1 >, undeterminated_basic< A2 >, undeterminated_basic< R > >::first_argument_type
point_basic< A1 > first_argument_type
Definition: expression.h:1078
rheolef::details::generic_binary_traits< dot_ >::valued_tag
static space_constant::valued_type valued_tag(space_constant::valued_type tag1, space_constant::valued_type tag2)
Definition: expression.h:1456
rheolef::details::swapper::operator()
generic_binary_traits< BinaryFunction >::template result_hint< A2, A1 >::type operator()(const A1 &x1, const A2 &x2) const
Definition: expression.h:1792
rheolef::details::generic_binary_traits< divides >::hint< undeterminated_basic< A1 >, A2, R >::first_argument_type
std::conditional< details::is_scalar< A2 >::value, R, binop_error< details::divides, A1, A2, R > >::type first_argument_type
Definition: expression.h:1304
rheolef::details::generic_binary_traits< multiplies >::second_argument_hint< tensor4_basic< A1 >, tensor_basic< R > >::type
binop_error< details::multiplies, tensor4_basic< A1 >, undeterminated_basic< A1 >, tensor_basic< R > > type
Definition: expression.h:983
rheolef::details::divides_result< tensor_basic< T1 >, point_basic< T2 > >::type
binop_error< details::divides, tensor_basic< T1 >, point_basic< T2 >, undeterminated_basic< S > > type
Definition: expression.h:1218
rheolef::details::generic_binary_traits< divides >::hint< A1, undeterminated_basic< A2 >, undeterminated_basic< R > >::result_type
A1 result_type
Definition: expression.h:1335
rheolef::details::generic_unary_traits< binder_first< BinaryFunction, A1 > >::hint::result_type
Result result_type
Definition: expression.h:1701
rheolef::details::plus_result< A, A, typename std::enable_if< ! is_rheolef_arithmetic< A >::value >::type >::type
A type
Definition: expression.h:454
rheolef::details::scalar_binary_traits::hint::S
scalar_traits< R >::type S
Definition: expression.h:1382
rheolef::details::multiplies_result< tensor3_basic< S1 >, tensor3_basic< S2 > >::S
promote< S1, S2 >::type S
Definition: expression.h:689
rheolef::details::generic_binary_traits< multiplies >::hint< tensor4_basic< A1 >, undeterminated_basic< A2 >, undeterminated_basic< R > >::second_argument_type
A2 second_argument_type
Definition: expression.h:1135
rheolef::details::generic_binary_traits< plus >::hint< A1, undeterminated_basic< A2 >, undeterminated_basic< R > >::second_argument_type
A1 second_argument_type
Definition: expression.h:513
f
Definition: cavity_dg.h:29
rheolef::details::multiplies_result< S, point_basic< S > >::type
point_basic< S > type
Definition: expression.h:611
rheolef::trans
csr< T, sequential > trans(const csr< T, sequential > &a)
trans(a): see the form page for the full documentation
Definition: csr.h:455
rheolef::details::generic_binary_traits< multiplies >::hint< undeterminated_basic< A1 >, undeterminated_basic< A2 >, undeterminated_basic< R > >::first_argument_type
undeterminated_basic< A1 > first_argument_type
Definition: expression.h:1143
rheolef::details::generic_binary_traits< multiplies >::first_argument_hint< tensor_basic< A2 >, tensor_basic< R > >::type
undeterminated_basic< typename promote< A2, R >::type > type
Definition: expression.h:823
rheolef::details::divides_result< T, tensor4_basic< T > >::type
binop_error< details::divides, T, tensor4_basic< T >, undeterminated_basic< T > > type
Definition: expression.h:1254
rheolef::space_constant::valued_tag_traits
Definition: space_constant.h:161
rheolef::details::generic_binary_traits< divides >::result_hint::type
divides_result< Arg1, Arg2 >::type type
Definition: expression.h:1280
rheolef::details::divides_result< tensor_basic< T1 >, tensor3_basic< T2 > >::S
promote< T1, T2 >::type S
Definition: expression.h:1239
rheolef::details::generic_unary_traits< binder_first< BinaryFunction, A1 > >::hint< undeterminated_basic< T1 >, undeterminated_basic< T > >::argument_type
generic_binary_traits< BinaryFunction >::template hint< A1, undeterminated_basic< T1 >, undeterminated_basic< T > >::second_argument_type argument_type
Definition: expression.h:1721
rheolef::details::generic_binary_traits::valued_tag
static space_constant::valued_type valued_tag(space_constant::valued_type, space_constant::valued_type)
Definition: expression.h:421
rheolef::details::generic_binary_traits< divides >::hint< A1, undeterminated_basic< A2 >, R >::S
promote< typename scalar_traits< A1 >::type, typename scalar_traits< R >::type >::type S
Definition: expression.h:1313
rheolef::details::divides_result< point_basic< T1 >, tensor4_basic< T2 > >::S
promote< T1, T2 >::type S
Definition: expression.h:1258
rheolef::details::norm2_
Definition: expression.h:375
rheolef::details::generic_unary_traits< tr_ >::hint::result_type
result_hint< A1 >::type result_type
Definition: expression.h:314
rheolef::details::divides_result< tensor3_basic< T1 >, point_basic< T2 > >::type
binop_error< details::divides, tensor3_basic< T1 >, point_basic< T2 >, undeterminated_basic< S > > type
Definition: expression.h:1245
rheolef::details::generic_binary_traits< multiplies >::hint< undeterminated_basic< A1 >, undeterminated_basic< A2 >, point_basic< R > >::first_argument_type
undeterminated_basic< A1 > first_argument_type
Definition: expression.h:1043
rheolef::details::generic_binary_traits< ddot_ >::hint< undeterminated_basic< A1 >, undeterminated_basic< A2 >, R >::first_argument_type
std::conditional< is_scalar< R >::value, tensor_basic< A1 >, E >::type first_argument_type
Definition: expression.h:1618
rheolef::details::divides_result< tensor3_basic< T1 >, tensor_basic< T2 > >::type
binop_error< details::divides, tensor3_basic< T1 >, tensor_basic< T2 >, undeterminated_basic< S > > type
Definition: expression.h:1250
rheolef::details::multiplies_result< tensor4_basic< S1 >, tensor_basic< S2 > >::type
binop_error< details::multiplies, tensor4_basic< S1 >, tensor_basic< S2 >, undeterminated_basic< S > > type
Definition: expression.h:730
rheolef::details::multiplies_result< tensor3_basic< S1 >, tensor4_basic< S2 > >::S
promote< S1, S2 >::type S
Definition: expression.h:717
rheolef::details::generic_binary_traits< multiplies >::hint< undeterminated_basic< A1 >, point_basic< A2 >, undeterminated_basic< R > >::result_type
undeterminated_basic< R > result_type
Definition: expression.h:1108
rheolef::std
Definition: vec_expr_v2.h:391
rheolef::details::generic_binary_traits< multiplies >::first_argument_hint< A2, tensor4_basic< R >, typename std::enable_if< is_rheolef_arithmetic< A2 >::value >::type >::type
tensor4_basic< typename promote< A2, R >::type > type
Definition: expression.h:783
rheolef::details::ddot_result< tensor_basic< A1 >, tensor_basic< A2 > >::type
S type
Definition: expression.h:1530
rheolef::details::generic_binary_traits< multiplies >::hint< A1, A2, undeterminated_basic< R > >::first_argument_type
A1 first_argument_type
Definition: expression.h:1010
rheolef::details::divides::operator()
divides_result< T1, T2 >::type operator()(const T1 &a, const T2 &b) const
Definition: expression.h:1274
rheolef::details::function_wrapper
Definition: expression.h:1818
rheolef::details::divides_result
Definition: expression.h:1160
rheolef::details::generic_binary_traits< multiplies >::first_argument_hint< tensor4_basic< A2 >, tensor3_basic< R > >::S
promote< A2, R >::type S
Definition: expression.h:872
rheolef::details::generic_binary_traits< multiplies >::hint< undeterminated_basic< A1 >, undeterminated_basic< A2 >, undeterminated_basic< R > >::second_argument_type
undeterminated_basic< A2 > second_argument_type
Definition: expression.h:1144
rheolef::details::swapper::swapper
swapper(const BinaryFunction &f)
Definition: expression.h:1789
rheolef::details::generic_binary_traits< multiplies >::second_argument_hint::type
promote< A1, R >::type type
Definition: expression.h:886
rheolef::details::dot
rheolef::details::is_vec dot
rheolef::details::generic_binary_traits< divides >::hint< undeterminated_basic< A1 >, A2, R >::second_argument_type
A2 second_argument_type
Definition: expression.h:1305
rheolef::details::ddot_result< tensor_basic< A1 >, tensor4_basic< A2 > >::type
tensor_basic< S > type
Definition: expression.h:1540
rheolef::details::generic_binary_traits< multiplies >::hint< undeterminated_basic< A1 >, A2, R >::first_argument_type
first_argument_hint< A2, R >::type first_argument_type
Definition: expression.h:1020
rheolef::details::generic_binary_traits< minus >::valued_tag
static space_constant::valued_type valued_tag(space_constant::valued_type tag1, space_constant::valued_type tag2)
Definition: expression.h:557
rheolef::details::binder_first::operator()
generic_binary_traits< BinaryFunction >::template result_hint< A1, A2 >::type operator()(const A2 &x2) const
Definition: expression.h:1688
rheolef::details::generic_unary_traits< norm_ >::hint::result_type
result_hint< A1 >::type result_type
Definition: expression.h:364
rheolef::details::generic_binary_traits< ddot_ >::hint< tensor_basic< A1 >, undeterminated_basic< A2 >, undeterminated_basic< R > >::second_argument_type
undeterminated_basic< A2 > second_argument_type
Definition: expression.h:1648
rheolef::details::generic_unary_traits< unary_plus >::valued_tag
static space_constant::valued_type valued_tag(space_constant::valued_type tag)
Definition: expression.h:223
rheolef::details::generic_binary_traits< multiplies >::hint< undeterminated_basic< A1 >, tensor_basic< A2 >, undeterminated_basic< R > >::first_argument_type
undeterminated_basic< A1 > first_argument_type
Definition: expression.h:1113
rheolef::details::generic_unary_traits< norm_ >::result_hint::type
float_traits< Arg >::type type
Definition: expression.h:360
rheolef::is_undeterminated
Definition: undeterminated.h:39
rheolef::details::generic_unary_traits< norm_ >::hint::argument_type
A1 argument_type
Definition: expression.h:365
rheolef::details::generic_unary_traits< binder_second< BinaryFunction, A2 > >::hint< undeterminated_basic< T1 >, undeterminated_basic< T > >::argument_type
generic_binary_traits< BinaryFunction >::template hint< undeterminated_basic< T1 >, A2, undeterminated_basic< T > >::first_argument_type argument_type
Definition: expression.h:1772
rheolef::details::generic_binary_traits< divides >::hint::first_argument_type
Arg1 first_argument_type
Definition: expression.h:1284
rheolef::details::generic_binary_traits< dot_ >::hint::result_type
std::conditional< is_undeterminated< R >::value,typename std::conditional< is_good::value,S,binop_error< details::dot_, A1, A2, R > >::type,R >::type result_type
Definition: expression.h:1508
T
Expr1::float_type T
Definition: field_expr.h:218
rheolef::details::generic_binary_traits< ddot_ >::hint< undeterminated_basic< A1 >, tensor_basic< A2 >, undeterminated_basic< R > >::second_argument_type
tensor_basic< A2 > second_argument_type
Definition: expression.h:1631
rheolef::details::generic_binary_traits< ddot_ >::hint< tensor_basic< A1 >, undeterminated_basic< A2 >, R >::E
binop_error< ddot_, A1, A2, R > E
Definition: expression.h:1590
rheolef::details::generic_binary_traits< multiplies >::first_argument_hint< tensor_basic< A2 >, point_basic< R > >::type
binop_error< details::multiplies, undeterminated_basic< A2 >, tensor_basic< A2 >, point_basic< R > > type
Definition: expression.h:818
rheolef::details::generic_binary_traits< plus >::hint::second_argument_type
A2 second_argument_type
Definition: expression.h:468
rheolef::details::function_wrapper< Result(Arg)>::type
std::function< Result(Arg)> type
Definition: expression.h:1823
rheolef::details::ddot_::operator()
ddot_result< A1, A2 >::type operator()(const A1 &x, const A2 &y) const
Definition: expression.h:1545
rheolef::details::generic_binary_traits< swapper< BinaryFunction > >::hint::base
generic_binary_traits< BinaryFunction >::template hint< A2, A1, Result > base
Definition: expression.h:1803
rheolef::tr
U tr(const tensor_basic< U > &a, size_t d=3)
rheolef::details::multiplies_result< tensor4_basic< S1 >, point_basic< S2 > >::type
binop_error< details::multiplies, tensor4_basic< S1 >, point_basic< S2 >, undeterminated_basic< S > > type
Definition: expression.h:724
rheolef::float_traits< details::binop_error< Op, T1, T2, R > >::type
float_traits< R >::type type
Definition: expression.h:176
rheolef::details::generic_binary_traits< multiplies >::first_argument_hint< tensor3_basic< A2 >, point_basic< R > >::type
binop_error< details::multiplies, undeterminated_basic< A2 >, tensor3_basic< A2 >, point_basic< R > > type
Definition: expression.h:838
rheolef::details::generic_binary_traits< ddot_ >::hint< undeterminated_basic< A1 >, tensor4_basic< A2 >, tensor_basic< R > >::result_type
tensor_basic< R > result_type
Definition: expression.h:1601