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 }