Generic expression where a binary operator is applied to two expressions. More...

#include <STK_BinaryOperators.h>

Inheritance diagram for STK::BinaryOperator< FunctorOp, Lhs, Rhs >:

Public Types
enum	{ isRes0D_ = hidden::Traits<BinaryOperator>::isRes0D_ , isRes1D_ = hidden::Traits<BinaryOperator>::isRes1D_ , isRes2D_ = hidden::Traits<BinaryOperator>::isRes2D_ , is1D1D_ = hidden::Traits<BinaryOperator>::is1D1D_ , structure_ = hidden::Traits<BinaryOperator>::structure_ , orient_ = hidden::Traits<BinaryOperator>::orient_ , sizeRows_ = hidden::Traits<BinaryOperator>::sizeRows_ , sizeCols_ = hidden::Traits<BinaryOperator>::sizeCols_ , storage_ = hidden::Traits<BinaryOperator>::storage_ , isValid_ =( isRes0D_ \|\| isRes1D_ \|\| isRes2D_ \|\| is1D1D_) }

typedef hidden::BinaryEltImpl< FunctorOp, Lhs, Rhs, Lhs::structure_, Rhs::structure_ >	EltImpl

typedef hidden::BinaryRowsImpl< Lhs, Rhs, EltImpl::sizeRows_, EltImpl::useForRows_ >	RowsImpl

typedef hidden::BinaryColsImpl< Lhs, Rhs, EltImpl::sizeCols_, EltImpl::useForCols_ >	ColsImpl

typedef hidden::Traits< BinaryOperator >::TypeConst	TypeConst

typedef hidden::Traits< BinaryOperator >::Type	Type

typedef TRange< sizeRows_ >	RowRange
	Type of the Range for the rows.

typedef TRange< sizeCols_ >	ColRange
	Type of the Range for the columns.

Public Types inherited from STK::ExprBase< BinaryOperator< FunctorOp, Lhs, Rhs > >
enum

typedef ITContainer< BinaryOperator< FunctorOp, Lhs, Rhs >, structure_ >	Base

typedef hidden::Traits< BinaryOperator< FunctorOp, Lhs, Rhs > >::Type	Type

typedef hidden::Traits< BinaryOperator< FunctorOp, Lhs, Rhs > >::TypeConst	TypeConst

Public Member Functions
	BinaryOperator (Lhs const &lhs, Rhs const &rhs, FunctorOp const &func=FunctorOp())
	default constructor

Lhs const &	lhs () const

Rhs const &	rhs () const

FunctorOp const &	functor () const

TypeConst	elt2Impl (int i, int j) const

TypeConst	elt1Impl (int i) const

TypeConst	elt0Impl () const

RowRange const &	rowsImpl () const

ColRange const &	colsImpl () const

Public Member Functions inherited from STK::ExprBase< BinaryOperator< FunctorOp, Lhs, Rhs > >
Visitor::TypeConst	visit (Visitor &visitor) const
	Visit the container using a constant visitor.

int	count () const
	compute the value of non-zero element in an expression.

bool const	any () const
	check if there is any non-zero element in an expression.

bool const	all () const
	check if all the elements in an expression are not zero.

int	nbAvailableValues () const

Type const	minElt (int &row, int &col) const

Type const	minElt (int &pos) const

Type const	minElt () const

Type const	minEltSafe (int &row, int &col) const

Type const	minEltSafe (int &pos) const

Type const	minEltSafe () const

Type const	maxElt (int &row, int &col) const

Type const	maxElt (int &pos) const

Type const	maxElt () const

Type const	maxEltSafe (int &row, int &col) const

Type const	maxEltSafe (int &pos) const

Type const	maxEltSafe () const

Type const	sum () const

Type const	sumSafe () const

Type const	norm () const

Type const	normSafe () const

Type const	norm2 () const

Type const	norm2Safe () const

Type const	normInf () const

Type const	mean () const

Type const	meanSafe () const

Type const	variance () const

Type const	variance (Type const &mean) const

Type const	varianceSafe () const

Type const	varianceSafe (Type const &mean) const

Type const	wsum (ExprBase< Rhs > const &weights) const

hidden::Traits< BinaryOperator< FunctorOp, Lhs, Rhs > >::Type const	wsum (ExprBase< Rhs > const &weights) const

Type const	wsumSafe (ExprBase< Rhs > const &weights) const

hidden::Traits< BinaryOperator< FunctorOp, Lhs, Rhs > >::Type const	wsumSafe (ExprBase< Rhs > const &weights) const

Type const	wnorm (ExprBase< Rhs > const &weights) const

hidden::Traits< BinaryOperator< FunctorOp, Lhs, Rhs > >::Type const	wnorm (ExprBase< Rhs > const &weights) const

Type const	wnormSafe (ExprBase< Rhs > const &weights) const

hidden::Traits< BinaryOperator< FunctorOp, Lhs, Rhs > >::Type const	wnormSafe (ExprBase< Rhs > const &weights) const

Type const	wnorm2 (ExprBase< Rhs > const &weights) const

hidden::Traits< BinaryOperator< FunctorOp, Lhs, Rhs > >::Type const	wnorm2 (ExprBase< Rhs > const &weights) const

Type const	wnorm2Safe (ExprBase< Rhs > const &weights) const

hidden::Traits< BinaryOperator< FunctorOp, Lhs, Rhs > >::Type const	wnorm2Safe (ExprBase< Rhs > const &weights) const

Type const	wmean (ExprBase< Rhs > const &weights) const

hidden::Traits< BinaryOperator< FunctorOp, Lhs, Rhs > >::Type const	wmean (ExprBase< Rhs > const &weights) const

Type const	wmeanSafe (ExprBase< Rhs > const &weights) const

hidden::Traits< BinaryOperator< FunctorOp, Lhs, Rhs > >::Type const	wmeanSafe (ExprBase< Rhs > const &weights) const

Type const	wvariance (ExprBase< Rhs > const &weights) const

Type const	wvariance (Type const &mean, ExprBase< Rhs > const &weights) const

hidden::Traits< BinaryOperator< FunctorOp, Lhs, Rhs > >::Type const	wvariance (ExprBase< Rhs > const &weights) const

hidden::Traits< BinaryOperator< FunctorOp, Lhs, Rhs > >::Type const	wvariance (Type const &mean, ExprBase< Rhs > const &weights) const

Type const	wvarianceSafe (ExprBase< Rhs > const &weights) const

Type const	wvarianceSafe (Type const &mean, ExprBase< Rhs > const &weights) const

hidden::Traits< BinaryOperator< FunctorOp, Lhs, Rhs > >::Type const	wvarianceSafe (ExprBase< Rhs > const &weights) const

hidden::Traits< BinaryOperator< FunctorOp, Lhs, Rhs > >::Type const	wvarianceSafe (Type const &mean, ExprBase< Rhs > const &weights) const

hidden::OperatorSelector< BinaryOperator< FunctorOp, Lhs, Rhs >, Rhs, Arrays::equalOp_ >::Result const	operator== (ExprBase< Rhs > const &other) const

UnaryOperator< EqualWithOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	operator== (Type const &value) const

hidden::OperatorSelector< BinaryOperator< FunctorOp, Lhs, Rhs >, Rhs, Arrays::notEqualOp_ >::Result const	operator!= (ExprBase< Rhs > const &other) const

UnaryOperator< NotEqualWithOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	operator!= (Type const &value) const

hidden::OperatorSelector< BinaryOperator< FunctorOp, Lhs, Rhs >, Rhs, Arrays::greaterThanOp_ >::Result const	operator> (ExprBase< Rhs > const &other) const

UnaryOperator< GreaterThanOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	operator> (Type const &value) const

hidden::OperatorSelector< BinaryOperator< FunctorOp, Lhs, Rhs >, Rhs, Arrays::lessThanOp_ >::Result const	operator< (ExprBase< Rhs > const &other) const

UnaryOperator< LessThanOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	operator< (Type const &value) const

hidden::OperatorSelector< BinaryOperator< FunctorOp, Lhs, Rhs >, Rhs, Arrays::greaterThanOrEqualOp_ >::Result const	operator>= (ExprBase< Rhs > const &other) const

UnaryOperator< GeqThanOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	operator>= (Type const &value) const

hidden::OperatorSelector< BinaryOperator< FunctorOp, Lhs, Rhs >, Rhs, Arrays::lessThanOrEqualOp_ >::Result const	operator<= (ExprBase< Rhs > const &other) const

UnaryOperator< LeqThanOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	operator<= (Type const &value) const

hidden::OperatorSelector< BinaryOperator< FunctorOp, Lhs, Rhs >, Rhs, Arrays::sumOp_ >::Result const	operator+ (ExprBase< Rhs > const &other) const

UnaryOperator< SumWithOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	operator+ (Type const &value) const

hidden::OperatorSelector< BinaryOperator< FunctorOp, Lhs, Rhs >, Rhs, Arrays::differenceOp_ >::Result const	operator- (ExprBase< Rhs > const &other) const

UnaryOperator< OppositeOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	operator- () const

UnaryOperator< DifferenceWithOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	operator- (Type const &value) const

hidden::OperatorSelector< BinaryOperator< FunctorOp, Lhs, Rhs >, Rhs, Arrays::productOp_ >::Result const	prod (ExprBase< Rhs > const &other) const

hidden::OperatorSelector< BinaryOperator< FunctorOp, Lhs, Rhs >, Rhs, Arrays::divisionOp_ >::Result const	operator/ (ExprBase< Rhs > const &other) const

UnaryOperator< DivisionWithOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	operator/ (Type const &value) const

hidden::OperatorSelector< BinaryOperator< FunctorOp, Lhs, Rhs >, Rhs, Arrays::moduloOp_ >::Result const	operator% (ExprBase< Rhs > const &other) const

UnaryOperator< ModuloWithOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	operator% (Type const &value) const

hidden::OperatorSelector< BinaryOperator< FunctorOp, Lhs, Rhs >, Rhs, Arrays::minOp_ >::Result const	min (ExprBase< Rhs > const &other) const

UnaryOperator< MinWithOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	min (Type const &value) const

hidden::OperatorSelector< BinaryOperator< FunctorOp, Lhs, Rhs >, Rhs, Arrays::maxOp_ >::Result const	max (ExprBase< Rhs > const &other) const

UnaryOperator< MaxWithOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	max (Type const &value) const

hidden::OperatorSelector< BinaryOperator< FunctorOp, Lhs, Rhs >, Rhs, Arrays::logicalAndOp_ >::Result const	operator&& (ExprBase< Rhs > const &other) const

UnaryOperator< LogicalAndWithOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	operator&& (Type const &value) const

hidden::OperatorSelector< BinaryOperator< FunctorOp, Lhs, Rhs >, Rhs, Arrays::logicalOrOp_ >::Result const	operator\|\| (ExprBase< Rhs > const &other) const

UnaryOperator< LogicalOrWithOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	operator\|\| (Type const &value) const

hidden::OperatorSelector< BinaryOperator< FunctorOp, Lhs, Rhs >, Rhs, Arrays::bitwiseAndOp_ >::Result const	operator& (ExprBase< Rhs > const &other) const

UnaryOperator< BitwiseAndWithOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	operator& (Type const &value) const

hidden::OperatorSelector< BinaryOperator< FunctorOp, Lhs, Rhs >, Rhs, Arrays::bitwiseOrOp_ >::Result const	operator\| (ExprBase< Rhs > const &other) const

UnaryOperator< BitwiseOrWithOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	operator\| (Type const &value) const

hidden::OperatorSelector< BinaryOperator< FunctorOp, Lhs, Rhs >, Rhs, Arrays::bitwiseXorOp_ >::Result const	operator^ (ExprBase< Rhs > const &other) const

UnaryOperator< BitwiseXorWithOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	operator^ (Type const &value) const

UnaryOperator< IsNaOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	isNA () const

UnaryOperator< NegOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	neg () const

UnaryOperator< IsFiniteOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	isFinite () const

UnaryOperator< IsInfiniteOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	isInfinite () const

UnaryOperator< AbsOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	abs () const

UnaryOperator< ExpOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	exp () const

UnaryOperator< LogOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	log () const

UnaryOperator< SqrtOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	sqrt () const

UnaryOperator< CosOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	cos () const

UnaryOperator< SinOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	sin () const

UnaryOperator< AcosOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	acos () const

UnaryOperator< AsinOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	asin () const

UnaryOperator< TanOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	tan () const

UnaryOperator< InverseOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	inverse () const

UnaryOperator< SquareOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	square () const

UnaryOperator< CubeOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	cube () const

UnaryOperator< ProductWithOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	operator* (Type const &value) const

hidden::ProductSelector< BinaryOperator< FunctorOp, Lhs, Rhs >, Rhs, hidden::Traits< BinaryOperator< FunctorOp, Lhs, Rhs > >::structure_, hidden::Traits< Rhs >::structure_ >::ProductType const	operator* (ExprBase< Rhs > const &other) const

UnaryOperator< PowOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	pow (Type const &value) const

UnaryOperator< SafeInverseOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	safeInverse (Type const &value) const

UnaryOperator< SafeOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > > const	safe (Type const value=Type()) const

UnaryOperator< CastOp< Type, OtherType >, BinaryOperator< FunctorOp, Lhs, Rhs > > const	cast () const

UnaryOperator< Law::PdfOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	pdf (Law::IUnivLaw< Type > const &law) const
	compute pdf values to this using distribution law given by user

UnaryOperator< Law::LogPdfOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	lpdf (Law::IUnivLaw< Type > const &law) const
	compute log-pdf values to this using distribution law given by user

UnaryOperator< Law::CdfOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	cdf (Law::IUnivLaw< Type > const &law) const
	compute cumulative distribution function of this using distribution law given by user

UnaryOperator< Law::LogCdfOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	lcdf (Law::IUnivLaw< Type > const &law) const
	compute log-cumulative distribution function of this using distribution law given by user

UnaryOperator< Law::CdfcOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	cdfc (Law::IUnivLaw< Type > const &law) const
	compute complementary cumulative distribution function of this using distribution law given by user

UnaryOperator< Law::LogCdfcOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	lcdfc (Law::IUnivLaw< Type > const &law) const
	compute complementary cumulative distribution function of this using distribution law given by user

UnaryOperator< Law::IcdfOp< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > >	icdf (Law::IUnivLaw< Type > const &law) const
	compute inverse cumulative distribution function using distribution law given by user

UnaryOperator< OtherOperator< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > > const	funct0 () const

UnaryOperator< OtherOperator< Type >, BinaryOperator< FunctorOp, Lhs, Rhs > > const	funct1 (Type const value) const

TransposeOperator< BinaryOperator< FunctorOp, Lhs, Rhs > > const	transpose () const

DiagonalizeOperator< BinaryOperator< FunctorOp, Lhs, Rhs > > const	diagonalize () const

DiagonalGetterOperator< BinaryOperator< FunctorOp, Lhs, Rhs > > const	getDiagonal () const

UpperTriangularizeOperator< BinaryOperator< FunctorOp, Lhs, Rhs > > const	upperTriangularize () const

LowerTriangularizeOperator< BinaryOperator< FunctorOp, Lhs, Rhs > > const	lowerTriangularize () const

SymmetrizeOperator< BinaryOperator< FunctorOp, Lhs, Rhs > > const	symmetrize () const

UpperSymmetrizeOperator< BinaryOperator< FunctorOp, Lhs, Rhs > > const	upperSymmetrize () const

LowerSymmetrizeOperator< BinaryOperator< FunctorOp, Lhs, Rhs > > const	lowerSymmetrize () const

SubVectorOperator< BinaryOperator< FunctorOp, Lhs, Rhs >, Size_ > const	sub (TRange< Size_ > const &I) const

SubOperator< BinaryOperator< FunctorOp, Lhs, Rhs >, SizeRows_, SizeCols_ > const	sub (TRange< SizeRows_ > const &I, TRange< SizeCols_ > const &J) const

ColOperator< BinaryOperator< FunctorOp, Lhs, Rhs > > const	col (int j) const

SubOperator< BinaryOperator< FunctorOp, Lhs, Rhs >, sizeRows_, Size_ > const	col (TRange< Size_ > const &J) const

RowOperator< BinaryOperator< FunctorOp, Lhs, Rhs > > const	row (int i) const

SubOperator< BinaryOperator< FunctorOp, Lhs, Rhs >, Size_, sizeCols_ > const	row (TRange< Size_ > const &I) const

hidden::Promote< Type, typenameRhs::Type >::result_type const	dot (ExprBase< Rhs > const &other) const

hidden::Promote< Type, typenameRhs::Type >::result_type const	dotSafe (ExprBase< Rhs > const &other) const

Protected Attributes
Lhs const &	lhs_

Rhs const &	rhs_

FunctorOp const	functor_

Additional Inherited Members
Static Public Member Functions inherited from STK::TRef< 1 >
static bool	isRef ()

Protected Member Functions inherited from STK::ExprBase< BinaryOperator< FunctorOp, Lhs, Rhs > >
	ExprBase ()
	Default constructor.

	~ExprBase ()
	destructor

Detailed Description

template<typename FunctorOp, typename Lhs, typename Rhs>
class STK::BinaryOperator< FunctorOp, Lhs, Rhs >

Generic expression where a binary operator is applied to two expressions.

Template Parameters

FunctorOp	template functor implementing the binary operator
Lhs	left-hand side type
Rhs	right-hand side type

This class represents an expression where a binary operator is applied to two expressions. It is the return type of binary operators, by which we mean only those binary operators where both the left-hand side and the right-hand side are expressions. For example, the return type of matrix1+matrix2 is a BinaryOperator. The return type of number+matrix is a unary operator.

Most of the time, this is the only way that it is used, so you typically don't have to name BinaryOperator types explicitly.

Definition at line 116 of file STK_BinaryOperators.h.

Member Typedef Documentation

◆ ColRange

template<typename FunctorOp , typename Lhs , typename Rhs >

typedef TRange<sizeCols_> STK::BinaryOperator< FunctorOp, Lhs, Rhs >::ColRange

Type of the Range for the columns.

Definition at line 146 of file STK_BinaryOperators.h.

◆ ColsImpl

template<typename FunctorOp , typename Lhs , typename Rhs >

typedef hidden::BinaryColsImpl< Lhs, Rhs, EltImpl::sizeCols_, EltImpl::useForCols_ > STK::BinaryOperator< FunctorOp, Lhs, Rhs >::ColsImpl

Definition at line 122 of file STK_BinaryOperators.h.

◆ EltImpl

template<typename FunctorOp , typename Lhs , typename Rhs >

typedef hidden::BinaryEltImpl<FunctorOp, Lhs, Rhs, Lhs::structure_, Rhs::structure_> STK::BinaryOperator< FunctorOp, Lhs, Rhs >::EltImpl

Definition at line 120 of file STK_BinaryOperators.h.

◆ RowRange

template<typename FunctorOp , typename Lhs , typename Rhs >

typedef TRange<sizeRows_> STK::BinaryOperator< FunctorOp, Lhs, Rhs >::RowRange

Type of the Range for the rows.

Definition at line 144 of file STK_BinaryOperators.h.

◆ RowsImpl

template<typename FunctorOp , typename Lhs , typename Rhs >

typedef hidden::BinaryRowsImpl< Lhs, Rhs, EltImpl::sizeRows_, EltImpl::useForRows_ > STK::BinaryOperator< FunctorOp, Lhs, Rhs >::RowsImpl

Definition at line 121 of file STK_BinaryOperators.h.

◆ Type

template<typename FunctorOp , typename Lhs , typename Rhs >

typedef hidden::Traits<BinaryOperator>::Type STK::BinaryOperator< FunctorOp, Lhs, Rhs >::Type

Definition at line 125 of file STK_BinaryOperators.h.

◆ TypeConst

template<typename FunctorOp , typename Lhs , typename Rhs >

typedef hidden::Traits<BinaryOperator>::TypeConst STK::BinaryOperator< FunctorOp, Lhs, Rhs >::TypeConst

Definition at line 124 of file STK_BinaryOperators.h.

Member Enumeration Documentation

◆ anonymous enum

template<typename FunctorOp , typename Lhs , typename Rhs >

anonymous enum

Enumerator
isRes0D_
isRes1D_
isRes2D_
is1D1D_
structure_
orient_
sizeRows_
sizeCols_
storage_
isValid_

Definition at line 127 of file STK_BinaryOperators.h.

    {
      isRes0D_   = hidden::Traits<BinaryOperator>::isRes0D_,
      isRes1D_   = hidden::Traits<BinaryOperator>::isRes1D_,
      isRes2D_   = hidden::Traits<BinaryOperator>::isRes2D_,
      is1D1D_    = hidden::Traits<BinaryOperator>::is1D1D_,
 
      structure_ = hidden::Traits<BinaryOperator>::structure_,
      orient_    = hidden::Traits<BinaryOperator>::orient_,
      sizeRows_  = hidden::Traits<BinaryOperator>::sizeRows_,
      sizeCols_  = hidden::Traits<BinaryOperator>::sizeCols_,
      storage_   = hidden::Traits<BinaryOperator>::storage_,
 
      // All the valid cases for binary operators
      isValid_ =( isRes0D_ || isRes1D_  || isRes2D_ || is1D1D_)
    };

Constructor & Destructor Documentation

◆ BinaryOperator()

template<typename FunctorOp , typename Lhs , typename Rhs >

STK::BinaryOperator< FunctorOp, Lhs, Rhs >::BinaryOperator	(	Lhs const &	lhs,
		Rhs const &	rhs,
		FunctorOp const &	func = `FunctorOp()`
	)

inline

default constructor

Definition at line 150 of file STK_BinaryOperators.h.

                         : lhs_(lhs), rhs_(rhs), functor_(func)
    {
      // FIXME : not safe. Add more test in the 1D case at compile time (and runtime ?)
      STK_STATIC_ASSERT_BINARY_OPERATOR_MISMATCH( isValid_ );
      STK_STATIC_ASSERT_COLS_DIMENSIONS_MISMATCH(!( (int(Lhs::sizeCols_) != UnknownSize)
                                                &&  (int(Rhs::sizeCols_) != UnknownSize)
                                                &&  (int(Lhs::sizeCols_) != int(Rhs::sizeCols_))
                                                &&  (isRes2D_)
                                                 ));
      STK_STATIC_ASSERT_ROWS_DIMENSIONS_MISMATCH(!( (int(Lhs::sizeRows_) != UnknownSize)
                                                &&  (int(Rhs::sizeRows_) != UnknownSize)
                                                &&  (int(Lhs::sizeRows_) != int(Rhs::sizeRows_))
                                                &&  (isRes2D_)
                                                 ));
#ifdef STK_BOUNDS_CHECK
      if ((lhs.rows() != rhs.rows()) && (isRes2D_))
      { STKRUNTIME_ERROR_2ARG(BinaryOperator, lhs.rows(), rhs.rows(), Rows range mismatch in BinaryOperator);}
      if (( lhs.cols() != rhs.cols()) && (isRes2D_))
      { STKRUNTIME_ERROR_2ARG(BinaryOperator, lhs.cols(), rhs.cols(), Columns range mismatch in BinaryOperator);}
#endif
    }