FEDRA emulsion software from the OPERA Collaboration
Classes | Functions
BinaryOperators.hh File Reference
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

class  AddOp< T >
 
class  DivOp< T >
 
class  MinOp< T >
 
class  MulOp< T >
 

Functions

template<class A , class B , class T , unsigned int D>
Expr< BinaryOp< MulOp< T >, Constant< A >, Expr< B, T, D >, T >, T, D > operator* (const A &lhs, const Expr< B, T, D > &rhs)
 
template<class A , class B , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< MulOp< T >, Constant< A >, Expr< B, T, D, D2 >, T >, T, D, D2 > operator* (const A &lhs, const Expr< B, T, D, D2 > &rhs)
 
template<class A , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< MulOp< T >, Constant< A >, SMatrix< T, D, D2 >, T >, T, D, D2 > operator* (const A &lhs, const SMatrix< T, D, D2 > &rhs)
 
template<class A , class T , unsigned int D>
Expr< BinaryOp< MulOp< T >, Constant< A >, SVector< T, D >, T >, T, D > operator* (const A &lhs, const SVector< T, D > &rhs)
 
template<class A , class B , class T , unsigned int D>
Expr< BinaryOp< MulOp< T >, Expr< A, T, D >, Expr< B, T, D >, T >, T, D > operator* (const Expr< A, T, D > &lhs, const Expr< B, T, D > &rhs)
 
template<class A , class T , unsigned int D>
Expr< BinaryOp< MulOp< T >, Expr< A, T, D >, SVector< T, D >, T >, T, D > operator* (const Expr< A, T, D > &lhs, const SVector< T, D > &rhs)
 
template<class A , class B , class T , unsigned int D>
Expr< BinaryOp< MulOp< T >, Expr< B, T, D >, Constant< A >, T >, T, D > operator* (const Expr< B, T, D > &lhs, const A &rhs)
 
template<class A , class B , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< MulOp< T >, Expr< B, T, D, D2 >, Constant< A >, T >, T, D, D2 > operator* (const Expr< B, T, D, D2 > &lhs, const A &rhs)
 
template<class A , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< MulOp< T >, SMatrix< T, D, D2 >, Constant< A >, T >, T, D, D2 > operator* (const SMatrix< T, D, D2 > &lhs, const A &rhs)
 
template<class A , class T , unsigned int D>
Expr< BinaryOp< MulOp< T >, SVector< T, D >, Constant< A >, T >, T, D > operator* (const SVector< T, D > &lhs, const A &rhs)
 
template<class A , class T , unsigned int D>
Expr< BinaryOp< MulOp< T >, SVector< T, D >, Expr< A, T, D >, T >, T, D > operator* (const SVector< T, D > &lhs, const Expr< A, T, D > &rhs)
 
template<class T , unsigned int D>
Expr< BinaryOp< MulOp< T >, SVector< T, D >, SVector< T, D >, T >, T, D > operator* (const SVector< T, D > &lhs, const SVector< T, D > &rhs)
 
template<class A , class B , class T , unsigned int D>
Expr< BinaryOp< AddOp< T >, Constant< A >, Expr< B, T, D >, T >, T, D > operator+ (const A &lhs, const Expr< B, T, D > &rhs)
 
template<class A , class B , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< AddOp< T >, Constant< A >, Expr< B, T, D, D2 >, T >, T, D, D2 > operator+ (const A &lhs, const Expr< B, T, D, D2 > &rhs)
 
template<class A , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< AddOp< T >, Constant< A >, SMatrix< T, D, D2 >, T >, T, D, D2 > operator+ (const A &lhs, const SMatrix< T, D, D2 > &rhs)
 
template<class A , class T , unsigned int D>
Expr< BinaryOp< AddOp< T >, Constant< A >, SVector< T, D >, T >, T, D > operator+ (const A &lhs, const SVector< T, D > &rhs)
 
template<class A , class B , class T , unsigned int D>
Expr< BinaryOp< AddOp< T >, Expr< A, T, D >, Expr< B, T, D >, T >, T, D > operator+ (const Expr< A, T, D > &lhs, const Expr< B, T, D > &rhs)
 
template<class A , class T , unsigned int D>
Expr< BinaryOp< AddOp< T >, Expr< A, T, D >, SVector< T, D >, T >, T, D > operator+ (const Expr< A, T, D > &lhs, const SVector< T, D > &rhs)
 
template<class A , class B , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< AddOp< T >, Expr< A, T, D, D2 >, Expr< B, T, D, D2 >, T >, T, D, D2 > operator+ (const Expr< A, T, D, D2 > &lhs, const Expr< B, T, D, D2 > &rhs)
 
template<class A , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< AddOp< T >, Expr< A, T, D, D2 >, SMatrix< T, D, D2 >, T >, T, D, D2 > operator+ (const Expr< A, T, D, D2 > &lhs, const SMatrix< T, D, D2 > &rhs)
 
template<class A , class B , class T , unsigned int D>
Expr< BinaryOp< AddOp< T >, Expr< B, T, D >, Constant< A >, T >, T, D > operator+ (const Expr< B, T, D > &lhs, const A &rhs)
 
template<class A , class B , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< AddOp< T >, Expr< B, T, D, D2 >, Constant< A >, T >, T, D, D2 > operator+ (const Expr< B, T, D, D2 > &lhs, const A &rhs)
 
template<class A , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< AddOp< T >, SMatrix< T, D, D2 >, Constant< A >, T >, T, D, D2 > operator+ (const SMatrix< T, D, D2 > &lhs, const A &rhs)
 
template<class A , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< AddOp< T >, SMatrix< T, D, D2 >, Expr< A, T, D, D2 >, T >, T, D, D2 > operator+ (const SMatrix< T, D, D2 > &lhs, const Expr< A, T, D, D2 > &rhs)
 
template<class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< AddOp< T >, SMatrix< T, D, D2 >, SMatrix< T, D, D2 >, T >, T, D, D2 > operator+ (const SMatrix< T, D, D2 > &lhs, const SMatrix< T, D, D2 > &rhs)
 
template<class A , class T , unsigned int D>
Expr< BinaryOp< AddOp< T >, SVector< T, D >, Constant< A >, T >, T, D > operator+ (const SVector< T, D > &lhs, const A &rhs)
 
template<class A , class T , unsigned int D>
Expr< BinaryOp< AddOp< T >, SVector< T, D >, Expr< A, T, D >, T >, T, D > operator+ (const SVector< T, D > &lhs, const Expr< A, T, D > &rhs)
 
template<class T , unsigned int D>
Expr< BinaryOp< AddOp< T >, SVector< T, D >, SVector< T, D >, T >, T, D > operator+ (const SVector< T, D > &lhs, const SVector< T, D > &rhs)
 
template<class A , class B , class T , unsigned int D>
Expr< BinaryOp< MinOp< T >, Constant< A >, Expr< B, T, D >, T >, T, D > operator- (const A &lhs, const Expr< B, T, D > &rhs)
 
template<class A , class B , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< MinOp< T >, Constant< A >, Expr< B, T, D, D2 >, T >, T, D, D2 > operator- (const A &lhs, const Expr< B, T, D, D2 > &rhs)
 
template<class A , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< MinOp< T >, Constant< A >, SMatrix< T, D, D2 >, T >, T, D, D2 > operator- (const A &lhs, const SMatrix< T, D, D2 > &rhs)
 
template<class A , class T , unsigned int D>
Expr< BinaryOp< MinOp< T >, Constant< A >, SVector< T, D >, T >, T, D > operator- (const A &lhs, const SVector< T, D > &rhs)
 
template<class A , class B , class T , unsigned int D>
Expr< BinaryOp< MinOp< T >, Expr< A, T, D >, Expr< B, T, D >, T >, T, D > operator- (const Expr< A, T, D > &lhs, const Expr< B, T, D > &rhs)
 
template<class A , class T , unsigned int D>
Expr< BinaryOp< MinOp< T >, Expr< A, T, D >, SVector< T, D >, T >, T, D > operator- (const Expr< A, T, D > &lhs, const SVector< T, D > &rhs)
 
template<class A , class B , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< MinOp< T >, Expr< A, T, D, D2 >, Expr< B, T, D, D2 >, T >, T, D, D2 > operator- (const Expr< A, T, D, D2 > &lhs, const Expr< B, T, D, D2 > &rhs)
 
template<class A , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< MinOp< T >, Expr< A, T, D, D2 >, SMatrix< T, D, D2 >, T >, T, D, D2 > operator- (const Expr< A, T, D, D2 > &lhs, const SMatrix< T, D, D2 > &rhs)
 
template<class A , class B , class T , unsigned int D>
Expr< BinaryOp< MinOp< T >, Expr< B, T, D >, Constant< A >, T >, T, D > operator- (const Expr< B, T, D > &lhs, const A &rhs)
 
template<class A , class B , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< MinOp< T >, Expr< B, T, D, D2 >, Constant< A >, T >, T, D, D2 > operator- (const Expr< B, T, D, D2 > &lhs, const A &rhs)
 
template<class A , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< MinOp< T >, SMatrix< T, D, D2 >, Constant< A >, T >, T, D, D2 > operator- (const SMatrix< T, D, D2 > &lhs, const A &rhs)
 
template<class A , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< MinOp< T >, SMatrix< T, D, D2 >, Expr< A, T, D, D2 >, T >, T, D, D2 > operator- (const SMatrix< T, D, D2 > &lhs, const Expr< A, T, D, D2 > &rhs)
 
template<class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< MinOp< T >, SMatrix< T, D, D2 >, SMatrix< T, D, D2 >, T >, T, D, D2 > operator- (const SMatrix< T, D, D2 > &lhs, const SMatrix< T, D, D2 > &rhs)
 
template<class A , class T , unsigned int D>
Expr< BinaryOp< MinOp< T >, SVector< T, D >, Constant< A >, T >, T, D > operator- (const SVector< T, D > &lhs, const A &rhs)
 
template<class A , class T , unsigned int D>
Expr< BinaryOp< MinOp< T >, SVector< T, D >, Expr< A, T, D >, T >, T, D > operator- (const SVector< T, D > &lhs, const Expr< A, T, D > &rhs)
 
template<class T , unsigned int D>
Expr< BinaryOp< MinOp< T >, SVector< T, D >, SVector< T, D >, T >, T, D > operator- (const SVector< T, D > &lhs, const SVector< T, D > &rhs)
 
template<class A , class B , class T , unsigned int D>
Expr< BinaryOp< DivOp< T >, Constant< A >, Expr< B, T, D >, T >, T, D > operator/ (const A &lhs, const Expr< B, T, D > &rhs)
 
template<class A , class B , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< DivOp< T >, Constant< A >, Expr< B, T, D, D2 >, T >, T, D, D2 > operator/ (const A &lhs, const Expr< B, T, D, D2 > &rhs)
 
template<class A , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< DivOp< T >, Constant< A >, SMatrix< T, D, D2 >, T >, T, D, D2 > operator/ (const A &lhs, const SMatrix< T, D, D2 > &rhs)
 
template<class A , class T , unsigned int D>
Expr< BinaryOp< DivOp< T >, Constant< A >, SVector< T, D >, T >, T, D > operator/ (const A &lhs, const SVector< T, D > &rhs)
 
template<class A , class B , class T , unsigned int D>
Expr< BinaryOp< DivOp< T >, Expr< A, T, D >, Expr< B, T, D >, T >, T, D > operator/ (const Expr< A, T, D > &lhs, const Expr< B, T, D > &rhs)
 
template<class A , class T , unsigned int D>
Expr< BinaryOp< DivOp< T >, Expr< A, T, D >, SVector< T, D >, T >, T, D > operator/ (const Expr< A, T, D > &lhs, const SVector< T, D > &rhs)
 
template<class A , class B , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< DivOp< T >, Expr< A, T, D, D2 >, Expr< B, T, D, D2 >, T >, T, D, D2 > operator/ (const Expr< A, T, D, D2 > &lhs, const Expr< B, T, D, D2 > &rhs)
 
template<class A , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< DivOp< T >, Expr< A, T, D, D2 >, SMatrix< T, D, D2 >, T >, T, D, D2 > operator/ (const Expr< A, T, D, D2 > &lhs, const SMatrix< T, D, D2 > &rhs)
 
template<class A , class B , class T , unsigned int D>
Expr< BinaryOp< DivOp< T >, Expr< B, T, D >, Constant< A >, T >, T, D > operator/ (const Expr< B, T, D > &lhs, const A &rhs)
 
template<class A , class B , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< DivOp< T >, Expr< B, T, D, D2 >, Constant< A >, T >, T, D, D2 > operator/ (const Expr< B, T, D, D2 > &lhs, const A &rhs)
 
template<class A , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< DivOp< T >, SMatrix< T, D, D2 >, Constant< A >, T >, T, D, D2 > operator/ (const SMatrix< T, D, D2 > &lhs, const A &rhs)
 
template<class A , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< DivOp< T >, SMatrix< T, D, D2 >, Expr< A, T, D, D2 >, T >, T, D, D2 > operator/ (const SMatrix< T, D, D2 > &lhs, const Expr< A, T, D, D2 > &rhs)
 
template<class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< DivOp< T >, SMatrix< T, D, D2 >, SMatrix< T, D, D2 >, T >, T, D, D2 > operator/ (const SMatrix< T, D, D2 > &lhs, const SMatrix< T, D, D2 > &rhs)
 
template<class A , class T , unsigned int D>
Expr< BinaryOp< DivOp< T >, SVector< T, D >, Constant< A >, T >, T, D > operator/ (const SVector< T, D > &lhs, const A &rhs)
 
template<class A , class T , unsigned int D>
Expr< BinaryOp< DivOp< T >, SVector< T, D >, Expr< A, T, D >, T >, T, D > operator/ (const SVector< T, D > &lhs, const Expr< A, T, D > &rhs)
 
template<class T , unsigned int D>
Expr< BinaryOp< DivOp< T >, SVector< T, D >, SVector< T, D >, T >, T, D > operator/ (const SVector< T, D > &lhs, const SVector< T, D > &rhs)
 
template<class A , class B , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< MulOp< T >, Expr< A, T, D, D2 >, Expr< B, T, D, D2 >, T >, T, D, D2 > times (const Expr< A, T, D, D2 > &lhs, const Expr< B, T, D, D2 > &rhs)
 
template<class A , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< MulOp< T >, Expr< A, T, D, D2 >, SMatrix< T, D, D2 >, T >, T, D, D2 > times (const Expr< A, T, D, D2 > &lhs, const SMatrix< T, D, D2 > &rhs)
 
template<class A , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< MulOp< T >, SMatrix< T, D, D2 >, Expr< A, T, D, D2 >, T >, T, D, D2 > times (const SMatrix< T, D, D2 > &lhs, const Expr< A, T, D, D2 > &rhs)
 
template<class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< MulOp< T >, SMatrix< T, D, D2 >, SMatrix< T, D, D2 >, T >, T, D, D2 > times (const SMatrix< T, D, D2 > &lhs, const SMatrix< T, D, D2 > &rhs)
 

Function Documentation

◆ operator*() [1/12]

template<class A , class B , class T , unsigned int D>
Expr< BinaryOp< MulOp< T >, Constant< A >, Expr< B, T, D >, T >, T, D > operator* ( const A &  lhs,
const Expr< B, T, D > &  rhs 
)
inline
521 {
522 typedef BinaryOp<MulOp<T>, Constant<A>, Expr<B,T,D>, T> MulOpBinOp;
523
524 return Expr<MulOpBinOp,T,D>(MulOpBinOp(MulOp<T>(),Constant<A>(lhs),rhs));
525}
BinaryOp
Definition: Expression.hh:113
Constant
Definition: Expression.hh:172
Expr
Definition: Expression.hh:43
MulOp
Definition: BinaryOperators.hh:426

◆ operator*() [2/12]

template<class A , class B , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< MulOp< T >, Constant< A >, Expr< B, T, D, D2 >, T >, T, D, D2 > operator* ( const A &  lhs,
const Expr< B, T, D, D2 > &  rhs 
)
inline
615 {
616 typedef BinaryOp<MulOp<T>, Constant<A>, Expr<B,T,D,D2>, T> MulOpBinOp;
617
618 return Expr<MulOpBinOp,T,D,D2>(MulOpBinOp(MulOp<T>(),Constant<A>(lhs),rhs));
619}

◆ operator*() [3/12]

template<class A , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< MulOp< T >, Constant< A >, SMatrix< T, D, D2 >, T >, T, D, D2 > operator* ( const A &  lhs,
const SMatrix< T, D, D2 > &  rhs 
)
inline
592 {
593 typedef BinaryOp<MulOp<T>, Constant<A>, SMatrix<T,D,D2>, T> MulOpBinOp;
594
595 return Expr<MulOpBinOp,T,D,D2>(MulOpBinOp(MulOp<T>(),Constant<A>(lhs),rhs));
596}
SMatrix
Definition: SMatrix.hh:53

◆ operator*() [4/12]

template<class A , class T , unsigned int D>
Expr< BinaryOp< MulOp< T >, Constant< A >, SVector< T, D >, T >, T, D > operator* ( const A &  lhs,
const SVector< T, D > &  rhs 
)
inline
498 {
499 typedef BinaryOp<MulOp<T>, Constant<A>, SVector<T,D>, T> MulOpBinOp;
500
501 return Expr<MulOpBinOp,T,D>(MulOpBinOp(MulOp<T>(),Constant<A>(lhs),rhs));
502}
SVector
Definition: SVector.hh:51

◆ operator*() [5/12]

template<class A , class B , class T , unsigned int D>
Expr< BinaryOp< MulOp< T >, Expr< A, T, D >, Expr< B, T, D >, T >, T, D > operator* ( const Expr< A, T, D > &  lhs,
const Expr< B, T, D > &  rhs 
)
inline
475 {
476 typedef BinaryOp<MulOp<T>, Expr<A,T,D>, Expr<B,T,D>, T> MulOpBinOp;
477
478 return Expr<MulOpBinOp,T,D>(MulOpBinOp(MulOp<T>(),lhs,rhs));
479}

◆ operator*() [6/12]

template<class A , class T , unsigned int D>
Expr< BinaryOp< MulOp< T >, Expr< A, T, D >, SVector< T, D >, T >, T, D > operator* ( const Expr< A, T, D > &  lhs,
const SVector< T, D > &  rhs 
)
inline
451 {
452 typedef BinaryOp<MulOp<T>, Expr<A,T,D>, SVector<T,D>, T> MulOpBinOp;
453
454 return Expr<MulOpBinOp,T,D>(MulOpBinOp(MulOp<T>(),lhs,rhs));
455}

◆ operator*() [7/12]

template<class A , class B , class T , unsigned int D>
Expr< BinaryOp< MulOp< T >, Expr< B, T, D >, Constant< A >, T >, T, D > operator* ( const Expr< B, T, D > &  lhs,
const A &  rhs 
)
inline
510 {
511 typedef BinaryOp<MulOp<T>, Expr<B,T,D>, Constant<A>, T> MulOpBinOp;
512
513 return Expr<MulOpBinOp,T,D>(MulOpBinOp(MulOp<T>(),lhs,Constant<A>(rhs)));
514}

◆ operator*() [8/12]

template<class A , class B , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< MulOp< T >, Expr< B, T, D, D2 >, Constant< A >, T >, T, D, D2 > operator* ( const Expr< B, T, D, D2 > &  lhs,
const A &  rhs 
)
inline
604 {
605 typedef BinaryOp<MulOp<T>, Expr<B,T,D,D2>, Constant<A>, T> MulOpBinOp;
606
607 return Expr<MulOpBinOp,T,D,D2>(MulOpBinOp(MulOp<T>(),lhs,Constant<A>(rhs)));
608}

◆ operator*() [9/12]

template<class A , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< MulOp< T >, SMatrix< T, D, D2 >, Constant< A >, T >, T, D, D2 > operator* ( const SMatrix< T, D, D2 > &  lhs,
const A &  rhs 
)
inline
581 {
582 typedef BinaryOp<MulOp<T>, SMatrix<T,D,D2>, Constant<A>, T> MulOpBinOp;
583
584 return Expr<MulOpBinOp,T,D,D2>(MulOpBinOp(MulOp<T>(),lhs,Constant<A>(rhs)));
585}

◆ operator*() [10/12]

template<class A , class T , unsigned int D>
Expr< BinaryOp< MulOp< T >, SVector< T, D >, Constant< A >, T >, T, D > operator* ( const SVector< T, D > &  lhs,
const A &  rhs 
)
inline
487 {
488 typedef BinaryOp<MulOp<T>, SVector<T,D>, Constant<A>, T> MulOpBinOp;
489
490 return Expr<MulOpBinOp,T,D>(MulOpBinOp(MulOp<T>(),lhs,Constant<A>(rhs)));
491}

◆ operator*() [11/12]

template<class A , class T , unsigned int D>
Expr< BinaryOp< MulOp< T >, SVector< T, D >, Expr< A, T, D >, T >, T, D > operator* ( const SVector< T, D > &  lhs,
const Expr< A, T, D > &  rhs 
)
inline
463 {
464 typedef BinaryOp<MulOp<T>, SVector<T,D>, Expr<A,T,D>, T> MulOpBinOp;
465
466 return Expr<MulOpBinOp,T,D>(MulOpBinOp(MulOp<T>(),lhs,rhs));
467}

◆ operator*() [12/12]

template<class T , unsigned int D>
Expr< BinaryOp< MulOp< T >, SVector< T, D >, SVector< T, D >, T >, T, D > operator* ( const SVector< T, D > &  lhs,
const SVector< T, D > &  rhs 
)
inline
439 {
440 typedef BinaryOp<MulOp<T>, SVector<T,D>, SVector<T,D>, T> MulOpBinOp;
441
442 return Expr<MulOpBinOp,T,D>(MulOpBinOp(MulOp<T>(),lhs,rhs));
443}

◆ operator+() [1/16]

template<class A , class B , class T , unsigned int D>
Expr< BinaryOp< AddOp< T >, Constant< A >, Expr< B, T, D >, T >, T, D > operator+ ( const A &  lhs,
const Expr< B, T, D > &  rhs 
)
inline
121 {
122 typedef BinaryOp<AddOp<T>, Constant<A>, Expr<B,T,D>, T> AddOpBinOp;
123
124 return Expr<AddOpBinOp,T,D>(AddOpBinOp(AddOp<T>(),Constant<A>(lhs),rhs));
125}
AddOp
Definition: BinaryOperators.hh:26

◆ operator+() [2/16]

template<class A , class B , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< AddOp< T >, Constant< A >, Expr< B, T, D, D2 >, T >, T, D, D2 > operator+ ( const A &  lhs,
const Expr< B, T, D, D2 > &  rhs 
)
inline
215 {
216 typedef BinaryOp<AddOp<T>, Constant<A>, Expr<B,T,D,D2>, T> AddOpBinOp;
217
218 return Expr<AddOpBinOp,T,D,D2>(AddOpBinOp(AddOp<T>(),Constant<A>(lhs),rhs));
219}

◆ operator+() [3/16]

template<class A , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< AddOp< T >, Constant< A >, SMatrix< T, D, D2 >, T >, T, D, D2 > operator+ ( const A &  lhs,
const SMatrix< T, D, D2 > &  rhs 
)
inline
192 {
193 typedef BinaryOp<AddOp<T>, Constant<A>, SMatrix<T,D,D2>, T> AddOpBinOp;
194
195 return Expr<AddOpBinOp,T,D,D2>(AddOpBinOp(AddOp<T>(),Constant<A>(lhs),rhs));
196}

◆ operator+() [4/16]

template<class A , class T , unsigned int D>
Expr< BinaryOp< AddOp< T >, Constant< A >, SVector< T, D >, T >, T, D > operator+ ( const A &  lhs,
const SVector< T, D > &  rhs 
)
inline
98 {
99 typedef BinaryOp<AddOp<T>, Constant<A>, SVector<T,D>, T> AddOpBinOp;
100
101 return Expr<AddOpBinOp,T,D>(AddOpBinOp(AddOp<T>(),Constant<A>(lhs),rhs));
102}

◆ operator+() [5/16]

template<class A , class B , class T , unsigned int D>
Expr< BinaryOp< AddOp< T >, Expr< A, T, D >, Expr< B, T, D >, T >, T, D > operator+ ( const Expr< A, T, D > &  lhs,
const Expr< B, T, D > &  rhs 
)
inline
75 {
76 typedef BinaryOp<AddOp<T>, Expr<A,T,D>, Expr<B,T,D>, T> AddOpBinOp;
77
78 return Expr<AddOpBinOp,T,D>(AddOpBinOp(AddOp<T>(),lhs,rhs));
79}

◆ operator+() [6/16]

template<class A , class T , unsigned int D>
Expr< BinaryOp< AddOp< T >, Expr< A, T, D >, SVector< T, D >, T >, T, D > operator+ ( const Expr< A, T, D > &  lhs,
const SVector< T, D > &  rhs 
)
inline
51 {
52 typedef BinaryOp<AddOp<T>, Expr<A,T,D>, SVector<T,D>, T> AddOpBinOp;
53
54 return Expr<AddOpBinOp,T,D>(AddOpBinOp(AddOp<T>(),lhs,rhs));
55}

◆ operator+() [7/16]

template<class A , class B , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< AddOp< T >, Expr< A, T, D, D2 >, Expr< B, T, D, D2 >, T >, T, D, D2 > operator+ ( const Expr< A, T, D, D2 > &  lhs,
const Expr< B, T, D, D2 > &  rhs 
)
inline
169 {
170 typedef BinaryOp<AddOp<T>, Expr<A,T,D,D2>, Expr<B,T,D,D2>, T> AddOpBinOp;
171
172 return Expr<AddOpBinOp,T,D,D2>(AddOpBinOp(AddOp<T>(),lhs,rhs));
173}

◆ operator+() [8/16]

template<class A , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< AddOp< T >, Expr< A, T, D, D2 >, SMatrix< T, D, D2 >, T >, T, D, D2 > operator+ ( const Expr< A, T, D, D2 > &  lhs,
const SMatrix< T, D, D2 > &  rhs 
)
inline
145 {
146 typedef BinaryOp<AddOp<T>, Expr<A,T,D,D2>, SMatrix<T,D,D2>, T> AddOpBinOp;
147
148 return Expr<AddOpBinOp,T,D,D2>(AddOpBinOp(AddOp<T>(),lhs,rhs));
149}

◆ operator+() [9/16]

template<class A , class B , class T , unsigned int D>
Expr< BinaryOp< AddOp< T >, Expr< B, T, D >, Constant< A >, T >, T, D > operator+ ( const Expr< B, T, D > &  lhs,
const A &  rhs 
)
inline
110 {
111 typedef BinaryOp<AddOp<T>, Expr<B,T,D>, Constant<A>, T> AddOpBinOp;
112
113 return Expr<AddOpBinOp,T,D>(AddOpBinOp(AddOp<T>(),lhs,Constant<A>(rhs)));
114}

◆ operator+() [10/16]

template<class A , class B , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< AddOp< T >, Expr< B, T, D, D2 >, Constant< A >, T >, T, D, D2 > operator+ ( const Expr< B, T, D, D2 > &  lhs,
const A &  rhs 
)
inline
204 {
205 typedef BinaryOp<AddOp<T>, Expr<B,T,D,D2>, Constant<A>, T> AddOpBinOp;
206
207 return Expr<AddOpBinOp,T,D,D2>(AddOpBinOp(AddOp<T>(),lhs,Constant<A>(rhs)));
208}

◆ operator+() [11/16]

template<class A , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< AddOp< T >, SMatrix< T, D, D2 >, Constant< A >, T >, T, D, D2 > operator+ ( const SMatrix< T, D, D2 > &  lhs,
const A &  rhs 
)
inline
181 {
182 typedef BinaryOp<AddOp<T>, SMatrix<T,D,D2>, Constant<A>, T> AddOpBinOp;
183
184 return Expr<AddOpBinOp,T,D,D2>(AddOpBinOp(AddOp<T>(),lhs,Constant<A>(rhs)));
185}

◆ operator+() [12/16]

template<class A , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< AddOp< T >, SMatrix< T, D, D2 >, Expr< A, T, D, D2 >, T >, T, D, D2 > operator+ ( const SMatrix< T, D, D2 > &  lhs,
const Expr< A, T, D, D2 > &  rhs 
)
inline
157 {
158 typedef BinaryOp<AddOp<T>, SMatrix<T,D,D2>, Expr<A,T,D,D2>, T> AddOpBinOp;
159
160 return Expr<AddOpBinOp,T,D,D2>(AddOpBinOp(AddOp<T>(),lhs,rhs));
161}

◆ operator+() [13/16]

template<class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< AddOp< T >, SMatrix< T, D, D2 >, SMatrix< T, D, D2 >, T >, T, D, D2 > operator+ ( const SMatrix< T, D, D2 > &  lhs,
const SMatrix< T, D, D2 > &  rhs 
)
inline
133 {
134 typedef BinaryOp<AddOp<T>, SMatrix<T,D,D2>, SMatrix<T,D,D2>, T> AddOpBinOp;
135
136 return Expr<AddOpBinOp,T,D,D2>(AddOpBinOp(AddOp<T>(),lhs,rhs));
137}

◆ operator+() [14/16]

template<class A , class T , unsigned int D>
Expr< BinaryOp< AddOp< T >, SVector< T, D >, Constant< A >, T >, T, D > operator+ ( const SVector< T, D > &  lhs,
const A &  rhs 
)
inline
87 {
88 typedef BinaryOp<AddOp<T>, SVector<T,D>, Constant<A>, T> AddOpBinOp;
89
90 return Expr<AddOpBinOp,T,D>(AddOpBinOp(AddOp<T>(),lhs,Constant<A>(rhs)));
91}

◆ operator+() [15/16]

template<class A , class T , unsigned int D>
Expr< BinaryOp< AddOp< T >, SVector< T, D >, Expr< A, T, D >, T >, T, D > operator+ ( const SVector< T, D > &  lhs,
const Expr< A, T, D > &  rhs 
)
inline
63 {
64 typedef BinaryOp<AddOp<T>, SVector<T,D>, Expr<A,T,D>, T> AddOpBinOp;
65
66 return Expr<AddOpBinOp,T,D>(AddOpBinOp(AddOp<T>(),lhs,rhs));
67}

◆ operator+() [16/16]

template<class T , unsigned int D>
Expr< BinaryOp< AddOp< T >, SVector< T, D >, SVector< T, D >, T >, T, D > operator+ ( const SVector< T, D > &  lhs,
const SVector< T, D > &  rhs 
)
inline
39 {
40 typedef BinaryOp<AddOp<T>, SVector<T,D>, SVector<T,D>, T> AddOpBinOp;
41
42 return Expr<AddOpBinOp,T,D>(AddOpBinOp(AddOp<T>(),lhs,rhs));
43}

◆ operator-() [1/16]

template<class A , class B , class T , unsigned int D>
Expr< BinaryOp< MinOp< T >, Constant< A >, Expr< B, T, D >, T >, T, D > operator- ( const A &  lhs,
const Expr< B, T, D > &  rhs 
)
inline
321 {
322 typedef BinaryOp<MinOp<T>, Constant<A>, Expr<B,T,D>, T> MinOpBinOp;
323
324 return Expr<MinOpBinOp,T,D>(MinOpBinOp(MinOp<T>(),Constant<A>(lhs),rhs));
325}
MinOp
Definition: BinaryOperators.hh:226

◆ operator-() [2/16]

template<class A , class B , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< MinOp< T >, Constant< A >, Expr< B, T, D, D2 >, T >, T, D, D2 > operator- ( const A &  lhs,
const Expr< B, T, D, D2 > &  rhs 
)
inline
415 {
416 typedef BinaryOp<MinOp<T>, Constant<A>, Expr<B,T,D,D2>, T> MinOpBinOp;
417
418 return Expr<MinOpBinOp,T,D,D2>(MinOpBinOp(MinOp<T>(),Constant<A>(lhs),rhs));
419}

◆ operator-() [3/16]

template<class A , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< MinOp< T >, Constant< A >, SMatrix< T, D, D2 >, T >, T, D, D2 > operator- ( const A &  lhs,
const SMatrix< T, D, D2 > &  rhs 
)
inline
392 {
393 typedef BinaryOp<MinOp<T>, Constant<A>, SMatrix<T,D,D2>, T> MinOpBinOp;
394
395 return Expr<MinOpBinOp,T,D,D2>(MinOpBinOp(MinOp<T>(),Constant<A>(lhs),rhs));
396}

◆ operator-() [4/16]

template<class A , class T , unsigned int D>
Expr< BinaryOp< MinOp< T >, Constant< A >, SVector< T, D >, T >, T, D > operator- ( const A &  lhs,
const SVector< T, D > &  rhs 
)
inline
298 {
299 typedef BinaryOp<MinOp<T>, Constant<A>, SVector<T,D>, T> MinOpBinOp;
300
301 return Expr<MinOpBinOp,T,D>(MinOpBinOp(MinOp<T>(),Constant<A>(lhs),rhs));
302}

◆ operator-() [5/16]

template<class A , class B , class T , unsigned int D>
Expr< BinaryOp< MinOp< T >, Expr< A, T, D >, Expr< B, T, D >, T >, T, D > operator- ( const Expr< A, T, D > &  lhs,
const Expr< B, T, D > &  rhs 
)
inline
275 {
276 typedef BinaryOp<MinOp<T>, Expr<A,T,D>, Expr<B,T,D>, T> MinOpBinOp;
277
278 return Expr<MinOpBinOp,T,D>(MinOpBinOp(MinOp<T>(),lhs,rhs));
279}

◆ operator-() [6/16]

template<class A , class T , unsigned int D>
Expr< BinaryOp< MinOp< T >, Expr< A, T, D >, SVector< T, D >, T >, T, D > operator- ( const Expr< A, T, D > &  lhs,
const SVector< T, D > &  rhs 
)
inline
251 {
252 typedef BinaryOp<MinOp<T>, Expr<A,T,D>, SVector<T,D>, T> MinOpBinOp;
253
254 return Expr<MinOpBinOp,T,D>(MinOpBinOp(MinOp<T>(),lhs,rhs));
255}

◆ operator-() [7/16]

template<class A , class B , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< MinOp< T >, Expr< A, T, D, D2 >, Expr< B, T, D, D2 >, T >, T, D, D2 > operator- ( const Expr< A, T, D, D2 > &  lhs,
const Expr< B, T, D, D2 > &  rhs 
)
inline
369 {
370 typedef BinaryOp<MinOp<T>, Expr<A,T,D,D2>, Expr<B,T,D,D2>, T> MinOpBinOp;
371
372 return Expr<MinOpBinOp,T,D,D2>(MinOpBinOp(MinOp<T>(),lhs,rhs));
373}

◆ operator-() [8/16]

template<class A , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< MinOp< T >, Expr< A, T, D, D2 >, SMatrix< T, D, D2 >, T >, T, D, D2 > operator- ( const Expr< A, T, D, D2 > &  lhs,
const SMatrix< T, D, D2 > &  rhs 
)
inline
345 {
346 typedef BinaryOp<MinOp<T>, Expr<A,T,D,D2>, SMatrix<T,D,D2>, T> MinOpBinOp;
347
348 return Expr<MinOpBinOp,T,D,D2>(MinOpBinOp(MinOp<T>(),lhs,rhs));
349}

◆ operator-() [9/16]

template<class A , class B , class T , unsigned int D>
Expr< BinaryOp< MinOp< T >, Expr< B, T, D >, Constant< A >, T >, T, D > operator- ( const Expr< B, T, D > &  lhs,
const A &  rhs 
)
inline
310 {
311 typedef BinaryOp<MinOp<T>, Expr<B,T,D>, Constant<A>, T> MinOpBinOp;
312
313 return Expr<MinOpBinOp,T,D>(MinOpBinOp(MinOp<T>(),lhs,Constant<A>(rhs)));
314}

◆ operator-() [10/16]

template<class A , class B , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< MinOp< T >, Expr< B, T, D, D2 >, Constant< A >, T >, T, D, D2 > operator- ( const Expr< B, T, D, D2 > &  lhs,
const A &  rhs 
)
inline
404 {
405 typedef BinaryOp<MinOp<T>, Expr<B,T,D,D2>, Constant<A>, T> MinOpBinOp;
406
407 return Expr<MinOpBinOp,T,D,D2>(MinOpBinOp(MinOp<T>(),lhs,Constant<A>(rhs)));
408}

◆ operator-() [11/16]

template<class A , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< MinOp< T >, SMatrix< T, D, D2 >, Constant< A >, T >, T, D, D2 > operator- ( const SMatrix< T, D, D2 > &  lhs,
const A &  rhs 
)
inline
381 {
382 typedef BinaryOp<MinOp<T>, SMatrix<T,D,D2>, Constant<A>, T> MinOpBinOp;
383
384 return Expr<MinOpBinOp,T,D,D2>(MinOpBinOp(MinOp<T>(),lhs,Constant<A>(rhs)));
385}

◆ operator-() [12/16]

template<class A , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< MinOp< T >, SMatrix< T, D, D2 >, Expr< A, T, D, D2 >, T >, T, D, D2 > operator- ( const SMatrix< T, D, D2 > &  lhs,
const Expr< A, T, D, D2 > &  rhs 
)
inline
357 {
358 typedef BinaryOp<MinOp<T>, SMatrix<T,D,D2>, Expr<A,T,D,D2>, T> MinOpBinOp;
359
360 return Expr<MinOpBinOp,T,D,D2>(MinOpBinOp(MinOp<T>(),lhs,rhs));
361}

◆ operator-() [13/16]

template<class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< MinOp< T >, SMatrix< T, D, D2 >, SMatrix< T, D, D2 >, T >, T, D, D2 > operator- ( const SMatrix< T, D, D2 > &  lhs,
const SMatrix< T, D, D2 > &  rhs 
)
inline
333 {
334 typedef BinaryOp<MinOp<T>, SMatrix<T,D,D2>, SMatrix<T,D,D2>, T> MinOpBinOp;
335
336 return Expr<MinOpBinOp,T,D,D2>(MinOpBinOp(MinOp<T>(),lhs,rhs));
337}

◆ operator-() [14/16]

template<class A , class T , unsigned int D>
Expr< BinaryOp< MinOp< T >, SVector< T, D >, Constant< A >, T >, T, D > operator- ( const SVector< T, D > &  lhs,
const A &  rhs 
)
inline
287 {
288 typedef BinaryOp<MinOp<T>, SVector<T,D>, Constant<A>, T> MinOpBinOp;
289
290 return Expr<MinOpBinOp,T,D>(MinOpBinOp(MinOp<T>(),lhs,Constant<A>(rhs)));
291}

◆ operator-() [15/16]

template<class A , class T , unsigned int D>
Expr< BinaryOp< MinOp< T >, SVector< T, D >, Expr< A, T, D >, T >, T, D > operator- ( const SVector< T, D > &  lhs,
const Expr< A, T, D > &  rhs 
)
inline
263 {
264 typedef BinaryOp<MinOp<T>, SVector<T,D>, Expr<A,T,D>, T> MinOpBinOp;
265
266 return Expr<MinOpBinOp,T,D>(MinOpBinOp(MinOp<T>(),lhs,rhs));
267}

◆ operator-() [16/16]

template<class T , unsigned int D>
Expr< BinaryOp< MinOp< T >, SVector< T, D >, SVector< T, D >, T >, T, D > operator- ( const SVector< T, D > &  lhs,
const SVector< T, D > &  rhs 
)
inline
239 {
240 typedef BinaryOp<MinOp<T>, SVector<T,D>, SVector<T,D>, T> MinOpBinOp;
241
242 return Expr<MinOpBinOp,T,D>(MinOpBinOp(MinOp<T>(),lhs,rhs));
243}

◆ operator/() [1/16]

template<class A , class B , class T , unsigned int D>
Expr< BinaryOp< DivOp< T >, Constant< A >, Expr< B, T, D >, T >, T, D > operator/ ( const A &  lhs,
const Expr< B, T, D > &  rhs 
)
inline
721 {
722 typedef BinaryOp<DivOp<T>, Constant<A>, Expr<B,T,D>, T> DivOpBinOp;
723
724 return Expr<DivOpBinOp,T,D>(DivOpBinOp(DivOp<T>(),Constant<A>(lhs),rhs));
725}
DivOp
Definition: BinaryOperators.hh:626

◆ operator/() [2/16]

template<class A , class B , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< DivOp< T >, Constant< A >, Expr< B, T, D, D2 >, T >, T, D, D2 > operator/ ( const A &  lhs,
const Expr< B, T, D, D2 > &  rhs 
)
inline
815 {
816 typedef BinaryOp<DivOp<T>, Constant<A>, Expr<B,T,D,D2>, T> DivOpBinOp;
817
818 return Expr<DivOpBinOp,T,D,D2>(DivOpBinOp(DivOp<T>(),Constant<A>(lhs),rhs));
819}

◆ operator/() [3/16]

template<class A , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< DivOp< T >, Constant< A >, SMatrix< T, D, D2 >, T >, T, D, D2 > operator/ ( const A &  lhs,
const SMatrix< T, D, D2 > &  rhs 
)
inline
792 {
793 typedef BinaryOp<DivOp<T>, Constant<A>, SMatrix<T,D,D2>, T> DivOpBinOp;
794
795 return Expr<DivOpBinOp,T,D,D2>(DivOpBinOp(DivOp<T>(),Constant<A>(lhs),rhs));
796}

◆ operator/() [4/16]

template<class A , class T , unsigned int D>
Expr< BinaryOp< DivOp< T >, Constant< A >, SVector< T, D >, T >, T, D > operator/ ( const A &  lhs,
const SVector< T, D > &  rhs 
)
inline
698 {
699 typedef BinaryOp<DivOp<T>, Constant<A>, SVector<T,D>, T> DivOpBinOp;
700
701 return Expr<DivOpBinOp,T,D>(DivOpBinOp(DivOp<T>(),Constant<A>(lhs),rhs));
702}

◆ operator/() [5/16]

template<class A , class B , class T , unsigned int D>
Expr< BinaryOp< DivOp< T >, Expr< A, T, D >, Expr< B, T, D >, T >, T, D > operator/ ( const Expr< A, T, D > &  lhs,
const Expr< B, T, D > &  rhs 
)
inline
675 {
676 typedef BinaryOp<DivOp<T>, Expr<A,T,D>, Expr<B,T,D>, T> DivOpBinOp;
677
678 return Expr<DivOpBinOp,T,D>(DivOpBinOp(DivOp<T>(),lhs,rhs));
679}

◆ operator/() [6/16]

template<class A , class T , unsigned int D>
Expr< BinaryOp< DivOp< T >, Expr< A, T, D >, SVector< T, D >, T >, T, D > operator/ ( const Expr< A, T, D > &  lhs,
const SVector< T, D > &  rhs 
)
inline
651 {
652 typedef BinaryOp<DivOp<T>, Expr<A,T,D>, SVector<T,D>, T> DivOpBinOp;
653
654 return Expr<DivOpBinOp,T,D>(DivOpBinOp(DivOp<T>(),lhs,rhs));
655}

◆ operator/() [7/16]

template<class A , class B , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< DivOp< T >, Expr< A, T, D, D2 >, Expr< B, T, D, D2 >, T >, T, D, D2 > operator/ ( const Expr< A, T, D, D2 > &  lhs,
const Expr< B, T, D, D2 > &  rhs 
)
inline
769 {
770 typedef BinaryOp<DivOp<T>, Expr<A,T,D,D2>, Expr<B,T,D,D2>, T> DivOpBinOp;
771
772 return Expr<DivOpBinOp,T,D,D2>(DivOpBinOp(DivOp<T>(),lhs,rhs));
773}

◆ operator/() [8/16]

template<class A , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< DivOp< T >, Expr< A, T, D, D2 >, SMatrix< T, D, D2 >, T >, T, D, D2 > operator/ ( const Expr< A, T, D, D2 > &  lhs,
const SMatrix< T, D, D2 > &  rhs 
)
inline
745 {
746 typedef BinaryOp<DivOp<T>, Expr<A,T,D,D2>, SMatrix<T,D,D2>, T> DivOpBinOp;
747
748 return Expr<DivOpBinOp,T,D,D2>(DivOpBinOp(DivOp<T>(),lhs,rhs));
749}

◆ operator/() [9/16]

template<class A , class B , class T , unsigned int D>
Expr< BinaryOp< DivOp< T >, Expr< B, T, D >, Constant< A >, T >, T, D > operator/ ( const Expr< B, T, D > &  lhs,
const A &  rhs 
)
inline
710 {
711 typedef BinaryOp<DivOp<T>, Expr<B,T,D>, Constant<A>, T> DivOpBinOp;
712
713 return Expr<DivOpBinOp,T,D>(DivOpBinOp(DivOp<T>(),lhs,Constant<A>(rhs)));
714}

◆ operator/() [10/16]

template<class A , class B , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< DivOp< T >, Expr< B, T, D, D2 >, Constant< A >, T >, T, D, D2 > operator/ ( const Expr< B, T, D, D2 > &  lhs,
const A &  rhs 
)
inline
804 {
805 typedef BinaryOp<DivOp<T>, Expr<B,T,D,D2>, Constant<A>, T> DivOpBinOp;
806
807 return Expr<DivOpBinOp,T,D,D2>(DivOpBinOp(DivOp<T>(),lhs,Constant<A>(rhs)));
808}

◆ operator/() [11/16]

template<class A , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< DivOp< T >, SMatrix< T, D, D2 >, Constant< A >, T >, T, D, D2 > operator/ ( const SMatrix< T, D, D2 > &  lhs,
const A &  rhs 
)
inline
781 {
782 typedef BinaryOp<DivOp<T>, SMatrix<T,D,D2>, Constant<A>, T> DivOpBinOp;
783
784 return Expr<DivOpBinOp,T,D,D2>(DivOpBinOp(DivOp<T>(),lhs,Constant<A>(rhs)));
785}

◆ operator/() [12/16]

template<class A , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< DivOp< T >, SMatrix< T, D, D2 >, Expr< A, T, D, D2 >, T >, T, D, D2 > operator/ ( const SMatrix< T, D, D2 > &  lhs,
const Expr< A, T, D, D2 > &  rhs 
)
inline
757 {
758 typedef BinaryOp<DivOp<T>, SMatrix<T,D,D2>, Expr<A,T,D,D2>, T> DivOpBinOp;
759
760 return Expr<DivOpBinOp,T,D,D2>(DivOpBinOp(DivOp<T>(),lhs,rhs));
761}

◆ operator/() [13/16]

template<class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< DivOp< T >, SMatrix< T, D, D2 >, SMatrix< T, D, D2 >, T >, T, D, D2 > operator/ ( const SMatrix< T, D, D2 > &  lhs,
const SMatrix< T, D, D2 > &  rhs 
)
inline
733 {
734 typedef BinaryOp<DivOp<T>, SMatrix<T,D,D2>, SMatrix<T,D,D2>, T> DivOpBinOp;
735
736 return Expr<DivOpBinOp,T,D,D2>(DivOpBinOp(DivOp<T>(),lhs,rhs));
737}

◆ operator/() [14/16]

template<class A , class T , unsigned int D>
Expr< BinaryOp< DivOp< T >, SVector< T, D >, Constant< A >, T >, T, D > operator/ ( const SVector< T, D > &  lhs,
const A &  rhs 
)
inline
687 {
688 typedef BinaryOp<DivOp<T>, SVector<T,D>, Constant<A>, T> DivOpBinOp;
689
690 return Expr<DivOpBinOp,T,D>(DivOpBinOp(DivOp<T>(),lhs,Constant<A>(rhs)));
691}

◆ operator/() [15/16]

template<class A , class T , unsigned int D>
Expr< BinaryOp< DivOp< T >, SVector< T, D >, Expr< A, T, D >, T >, T, D > operator/ ( const SVector< T, D > &  lhs,
const Expr< A, T, D > &  rhs 
)
inline
663 {
664 typedef BinaryOp<DivOp<T>, SVector<T,D>, Expr<A,T,D>, T> DivOpBinOp;
665
666 return Expr<DivOpBinOp,T,D>(DivOpBinOp(DivOp<T>(),lhs,rhs));
667}

◆ operator/() [16/16]

template<class T , unsigned int D>
Expr< BinaryOp< DivOp< T >, SVector< T, D >, SVector< T, D >, T >, T, D > operator/ ( const SVector< T, D > &  lhs,
const SVector< T, D > &  rhs 
)
inline
639 {
640 typedef BinaryOp<DivOp<T>, SVector<T,D>, SVector<T,D>, T> DivOpBinOp;
641
642 return Expr<DivOpBinOp,T,D>(DivOpBinOp(DivOp<T>(),lhs,rhs));
643}

◆ times() [1/4]

template<class A , class B , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< MulOp< T >, Expr< A, T, D, D2 >, Expr< B, T, D, D2 >, T >, T, D, D2 > times ( const Expr< A, T, D, D2 > &  lhs,
const Expr< B, T, D, D2 > &  rhs 
)
inline
569 {
570 typedef BinaryOp<MulOp<T>, Expr<A,T,D,D2>, Expr<B,T,D,D2>, T> MulOpBinOp;
571
572 return Expr<MulOpBinOp,T,D,D2>(MulOpBinOp(MulOp<T>(),lhs,rhs));
573}

◆ times() [2/4]

template<class A , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< MulOp< T >, Expr< A, T, D, D2 >, SMatrix< T, D, D2 >, T >, T, D, D2 > times ( const Expr< A, T, D, D2 > &  lhs,
const SMatrix< T, D, D2 > &  rhs 
)
inline
545 {
546 typedef BinaryOp<MulOp<T>, Expr<A,T,D,D2>, SMatrix<T,D,D2>, T> MulOpBinOp;
547
548 return Expr<MulOpBinOp,T,D,D2>(MulOpBinOp(MulOp<T>(),lhs,rhs));
549}

◆ times() [3/4]

template<class A , class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< MulOp< T >, SMatrix< T, D, D2 >, Expr< A, T, D, D2 >, T >, T, D, D2 > times ( const SMatrix< T, D, D2 > &  lhs,
const Expr< A, T, D, D2 > &  rhs 
)
inline
557 {
558 typedef BinaryOp<MulOp<T>, SMatrix<T,D,D2>, Expr<A,T,D,D2>, T> MulOpBinOp;
559
560 return Expr<MulOpBinOp,T,D,D2>(MulOpBinOp(MulOp<T>(),lhs,rhs));
561}

◆ times() [4/4]

template<class T , unsigned int D, unsigned int D2>
Expr< BinaryOp< MulOp< T >, SMatrix< T, D, D2 >, SMatrix< T, D, D2 >, T >, T, D, D2 > times ( const SMatrix< T, D, D2 > &  lhs,
const SMatrix< T, D, D2 > &  rhs 
)
inline
533 {
534 typedef BinaryOp<MulOp<T>, SMatrix<T,D,D2>, SMatrix<T,D,D2>, T> MulOpBinOp;
535
536 return Expr<MulOpBinOp,T,D,D2>(MulOpBinOp(MulOp<T>(),lhs,rhs));
537}