ROOT  6.07/01
Reference Guide
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
Classes | Namespaces | Functions
BinaryOperators.h File Reference
#include "Math/BinaryOpPolicy.h"
#include "Math/Expression.h"
Include dependency graph for BinaryOperators.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

class  ROOT::Math::SVector< T, D >
 SVector: a generic fixed size Vector class. More...
 
class  ROOT::Math::SMatrix< T, D1, D2, R >
 SMatrix: a generic fixed size D1 x D2 Matrix class. More...
 
class  ROOT::Math::AddOp< T >
 Addition Operation Class. More...
 
class  ROOT::Math::MinOp< T >
 Subtraction Operation Class. More...
 
class  ROOT::Math::MulOp< T >
 Multiplication (element-wise) Operation Class. More...
 
class  ROOT::Math::DivOp< T >
 Division (element-wise) Operation Class. More...
 

Namespaces

 ROOT
 Namespace for new ROOT classes and functions.
 
 ROOT::Math
 

Functions

template<class T , unsigned int D>
VecExpr< BinaryOp< AddOp< T >
, SVector< T, D >, SVector< T,
D >, T >, T, D > 		ROOT::Math::operator+ (const SVector< T, D > &lhs, const SVector< T, D > &rhs)
 Addition of two vectors v3 = v1+v2 returning a vector expression. More...
 
template<class A , class T , unsigned int D>
VecExpr< BinaryOp< AddOp< T >
, VecExpr< A, T, D >, SVector
< T, D >, T >, T, D > 		ROOT::Math::operator+ (const VecExpr< A, T, D > &lhs, const SVector< T, D > &rhs)
 
template<class A , class T , unsigned int D>
VecExpr< BinaryOp< AddOp< T >
, SVector< T, D >, VecExpr< A,
T, D >, T >, T, D > 		ROOT::Math::operator+ (const SVector< T, D > &lhs, const VecExpr< A, T, D > &rhs)
 
template<class A , class B , class T , unsigned int D>
VecExpr< BinaryOp< AddOp< T >
, VecExpr< A, T, D >, VecExpr
< B, T, D >, T >, T, D > 		ROOT::Math::operator+ (const VecExpr< A, T, D > &lhs, const VecExpr< B, T, D > &rhs)
 
template<class A , class T , unsigned int D>
VecExpr< BinaryOpCopyR< AddOp
< T >, SVector< T, D >
, Constant< A >, T >, T, D > 		ROOT::Math::operator+ (const SVector< T, D > &lhs, const A &rhs)
 Addition of a scalar to a each vector element: v2(i) = v1(i) + a returning a vector expression. More...
 
template<class A , class T , unsigned int D>
VecExpr< BinaryOpCopyL< AddOp
< T >, Constant< A >, SVector
< T, D >, T >, T, D > 		ROOT::Math::operator+ (const A &lhs, const SVector< T, D > &rhs)
 Addition of a scalar to each vector element v2(i) = a + v1(i) returning a vector expression. More...
 
template<class A , class B , class T , unsigned int D>
VecExpr< BinaryOpCopyR< AddOp
< T >, VecExpr< B, T, D >
, Constant< A >, T >, T, D > 		ROOT::Math::operator+ (const VecExpr< B, T, D > &lhs, const A &rhs)
 
template<class A , class B , class T , unsigned int D>
VecExpr< BinaryOpCopyL< AddOp
< T >, Constant< A >, VecExpr
< B, T, D >, T >, T, D > 		ROOT::Math::operator+ (const A &lhs, const VecExpr< B, T, D > &rhs)
 
template<class T , unsigned int D, unsigned int D2, class R1 , class R2 >
Expr< BinaryOp< AddOp< T >
, SMatrix< T, D, D2, R1 >
, SMatrix< T, D, D2, R2 >, T >
, T, D, D2, typename AddPolicy
< T, D, D2, R1, R2 >::RepType > 		ROOT::Math::operator+ (const SMatrix< T, D, D2, R1 > &lhs, const SMatrix< T, D, D2, R2 > &rhs)
 Addition of two matrices C = A+B returning a matrix expression. More...
 
template<class A , class T , unsigned int D, unsigned int D2, class R1 , class R2 >
Expr< BinaryOp< AddOp< T >
, Expr< A, T, D, D2, R1 >
, SMatrix< T, D, D2, R2 >, T >
, T, D, D2, typename AddPolicy
< T, D, D2, R1, R2 >::RepType > 		ROOT::Math::operator+ (const Expr< A, T, D, D2, R1 > &lhs, const SMatrix< T, D, D2, R2 > &rhs)
 
template<class A , class T , unsigned int D, unsigned int D2, class R1 , class R2 >
Expr< BinaryOp< AddOp< T >
, SMatrix< T, D, D2, R1 >
, Expr< A, T, D, D2, R2 >, T >
, T, D, D2, typename AddPolicy
< T, D, D2, R1, R2 >::RepType > 		ROOT::Math::operator+ (const SMatrix< T, D, D2, R1 > &lhs, const Expr< A, T, D, D2, R2 > &rhs)
 
template<class A , class B , class T , unsigned int D, unsigned int D2, class R1 , class R2 >
Expr< BinaryOp< AddOp< T >
, Expr< A, T, D, D2, R1 >
, Expr< B, T, D, D2, R2 >, T >
, T, D, D2, typename AddPolicy
< T, D, D2, R1, R2 >::RepType > 		ROOT::Math::operator+ (const Expr< A, T, D, D2, R1 > &lhs, const Expr< B, T, D, D2, R2 > &rhs)
 
template<class A , class T , unsigned int D, unsigned int D2, class R >
Expr< BinaryOpCopyR< AddOp< T >
, SMatrix< T, D, D2, R >
, Constant< A >, T >, T, D, D2,
R > 		ROOT::Math::operator+ (const SMatrix< T, D, D2, R > &lhs, const A &rhs)
 Addition element by element of matrix and a scalar C(i,j) = A(i,j) + s returning a matrix expression. More...
 
template<class A , class T , unsigned int D, unsigned int D2, class R >
Expr< BinaryOpCopyL< AddOp< T >
, Constant< A >, SMatrix< T, D,
D2, R >, T >, T, D, D2, R > 		ROOT::Math::operator+ (const A &lhs, const SMatrix< T, D, D2, R > &rhs)
 Addition element by element of matrix and a scalar C(i,j) = s + A(i,j) returning a matrix expression. More...
 
template<class A , class B , class T , unsigned int D, unsigned int D2, class R >
Expr< BinaryOpCopyR< AddOp< T >
, Expr< B, T, D, D2, R >
, Constant< A >, T >, T, D, D2,
R > 		ROOT::Math::operator+ (const Expr< B, T, D, D2, R > &lhs, const A &rhs)
 
template<class A , class B , class T , unsigned int D, unsigned int D2, class R >
Expr< BinaryOpCopyL< AddOp< T >
, Constant< A >, Expr< B, T, D,
D2, R >, T >, T, D, D2, R > 		ROOT::Math::operator+ (const A &lhs, const Expr< B, T, D, D2, R > &rhs)
 
template<class T , unsigned int D>
VecExpr< BinaryOp< MinOp< T >
, SVector< T, D >, SVector< T,
D >, T >, T, D > 		ROOT::Math::operator- (const SVector< T, D > &lhs, const SVector< T, D > &rhs)
 Vector Subtraction: v3 = v1 - v2 returning a vector expression. More...
 
template<class A , class T , unsigned int D>
VecExpr< BinaryOp< MinOp< T >
, VecExpr< A, T, D >, SVector
< T, D >, T >, T, D > 		ROOT::Math::operator- (const VecExpr< A, T, D > &lhs, const SVector< T, D > &rhs)
 
template<class A , class T , unsigned int D>
VecExpr< BinaryOp< MinOp< T >
, SVector< T, D >, VecExpr< A,
T, D >, T >, T, D > 		ROOT::Math::operator- (const SVector< T, D > &lhs, const VecExpr< A, T, D > &rhs)
 
template<class A , class B , class T , unsigned int D>
VecExpr< BinaryOp< MinOp< T >
, VecExpr< A, T, D >, VecExpr
< B, T, D >, T >, T, D > 		ROOT::Math::operator- (const VecExpr< A, T, D > &lhs, const VecExpr< B, T, D > &rhs)
 
template<class A , class T , unsigned int D>
VecExpr< BinaryOpCopyR< MinOp
< T >, SVector< T, D >
, Constant< A >, T >, T, D > 		ROOT::Math::operator- (const SVector< T, D > &lhs, const A &rhs)
 Subtraction of a scalar from each vector element: v2(i) = v1(i) - a returning a vector expression. More...
 
template<class A , class T , unsigned int D>
VecExpr< BinaryOpCopyL< MinOp
< T >, Constant< A >, SVector
< T, D >, T >, T, D > 		ROOT::Math::operator- (const A &lhs, const SVector< T, D > &rhs)
 Subtraction scalar vector (for each vector element) v2(i) = a - v1(i) returning a vector expression. More...
 
template<class A , class B , class T , unsigned int D>
VecExpr< BinaryOpCopyR< MinOp
< T >, VecExpr< B, T, D >
, Constant< A >, T >, T, D > 		ROOT::Math::operator- (const VecExpr< B, T, D > &lhs, const A &rhs)
 
template<class A , class B , class T , unsigned int D>
VecExpr< BinaryOpCopyL< MinOp
< T >, Constant< A >, VecExpr
< B, T, D >, T >, T, D > 		ROOT::Math::operator- (const A &lhs, const VecExpr< B, T, D > &rhs)
 
template<class T , unsigned int D, unsigned int D2, class R1 , class R2 >
Expr< BinaryOp< MinOp< T >
, SMatrix< T, D, D2, R1 >
, SMatrix< T, D, D2, R2 >, T >
, T, D, D2, typename AddPolicy
< T, D, D2, R1, R2 >::RepType > 		ROOT::Math::operator- (const SMatrix< T, D, D2, R1 > &lhs, const SMatrix< T, D, D2, R2 > &rhs)
 Subtraction of two matrices C = A-B returning a matrix expression. More...
 
template<class A , class T , unsigned int D, unsigned int D2, class R1 , class R2 >
Expr< BinaryOp< MinOp< T >
, Expr< A, T, D, D2, R1 >
, SMatrix< T, D, D2, R2 >, T >
, T, D, D2, typename AddPolicy
< T, D, D2, R1, R2 >::RepType > 		ROOT::Math::operator- (const Expr< A, T, D, D2, R1 > &lhs, const SMatrix< T, D, D2, R2 > &rhs)
 
template<class A , class T , unsigned int D, unsigned int D2, class R1 , class R2 >
Expr< BinaryOp< MinOp< T >
, SMatrix< T, D, D2, R1 >
, Expr< A, T, D, D2, R2 >, T >
, T, D, D2, typename AddPolicy
< T, D, D2, R1, R2 >::RepType > 		ROOT::Math::operator- (const SMatrix< T, D, D2, R1 > &lhs, const Expr< A, T, D, D2, R2 > &rhs)
 
template<class A , class B , class T , unsigned int D, unsigned int D2, class R1 , class R2 >
Expr< BinaryOp< MinOp< T >
, Expr< A, T, D, D2, R1 >
, Expr< B, T, D, D2, R2 >, T >
, T, D, D2, typename AddPolicy
< T, D, D2, R1, R2 >::RepType > 		ROOT::Math::operator- (const Expr< A, T, D, D2, R1 > &lhs, const Expr< B, T, D, D2, R2 > &rhs)
 
template<class A , class T , unsigned int D, unsigned int D2, class R >
Expr< BinaryOpCopyR< MinOp< T >
, SMatrix< T, D, D2, R >
, Constant< A >, T >, T, D, D2,
R > 		ROOT::Math::operator- (const SMatrix< T, D, D2, R > &lhs, const A &rhs)
 Subtraction of a scalar and a matrix (element wise) B(i,j) = A(i,j) - s returning a matrix expression. More...
 
template<class A , class T , unsigned int D, unsigned int D2, class R >
Expr< BinaryOpCopyL< MinOp< T >
, Constant< A >, SMatrix< T, D,
D2, R >, T >, T, D, D2, R > 		ROOT::Math::operator- (const A &lhs, const SMatrix< T, D, D2, R > &rhs)
 Subtraction of a scalar and a matrix (element wise) B(i,j) = s - A(i,j) returning a matrix expression. More...
 
template<class A , class B , class T , unsigned int D, unsigned int D2, class R >
Expr< BinaryOpCopyR< MinOp< T >
, Expr< B, T, D, D2, R >
, Constant< A >, T >, T, D, D2,
R > 		ROOT::Math::operator- (const Expr< B, T, D, D2, R > &lhs, const A &rhs)
 
template<class A , class B , class T , unsigned int D, unsigned int D2, class R >
Expr< BinaryOpCopyL< MinOp< T >
, Constant< A >, Expr< B, T, D,
D2, R >, T >, T, D, D2, R > 		ROOT::Math::operator- (const A &lhs, const Expr< B, T, D, D2, R > &rhs)
 
template<class T , unsigned int D>
VecExpr< BinaryOp< MulOp< T >
, SVector< T, D >, SVector< T,
D >, T >, T, D > 		ROOT::Math::operator* (const SVector< T, D > &lhs, const SVector< T, D > &rhs)
 Element by element vector product v3(i) = v1(i)*v2(i) returning a vector expression. More...
 
template<class A , class T , unsigned int D>
VecExpr< BinaryOp< MulOp< T >
, Expr< A, T, D >, SVector< T,
D >, T >, T, D > 		ROOT::Math::operator* (const VecExpr< A, T, D > &lhs, const SVector< T, D > &rhs)
 
template<class A , class T , unsigned int D>
VecExpr< BinaryOp< MulOp< T >
, SVector< T, D >, VecExpr< A,
T, D >, T >, T, D > 		ROOT::Math::operator* (const SVector< T, D > &lhs, const VecExpr< A, T, D > &rhs)
 
template<class A , class B , class T , unsigned int D>
VecExpr< BinaryOp< MulOp< T >
, VecExpr< A, T, D >, VecExpr
< B, T, D >, T >, T, D > 		ROOT::Math::operator* (const VecExpr< A, T, D > &lhs, const VecExpr< B, T, D > &rhs)
 
template<class A , class T , unsigned int D>
VecExpr< BinaryOpCopyR< MulOp
< T >, SVector< T, D >
, Constant< A >, T >, T, D > 		ROOT::Math::operator* (const SVector< T, D > &lhs, const A &rhs)
 
template<class A , class T , unsigned int D>
VecExpr< BinaryOpCopyL< MulOp
< T >, Constant< A >, SVector
< T, D >, T >, T, D > 		ROOT::Math::operator* (const A &lhs, const SVector< T, D > &rhs)
 
template<class A , class B , class T , unsigned int D>
VecExpr< BinaryOpCopyR< MulOp
< T >, VecExpr< B, T, D >
, Constant< A >, T >, T, D > 		ROOT::Math::operator* (const VecExpr< B, T, D > &lhs, const A &rhs)
 
template<class A , class B , class T , unsigned int D>
VecExpr< BinaryOpCopyL< MulOp
< T >, Constant< A >, VecExpr
< B, T, D >, T >, T, D > 		ROOT::Math::operator* (const A &lhs, const VecExpr< B, T, D > &rhs)
 
template<class T , unsigned int D, unsigned int D2, class R1 , class R2 >
Expr< BinaryOp< MulOp< T >
, SMatrix< T, D, D2, R1 >
, SMatrix< T, D, D2, R2 >, T >
, T, D, D2, typename AddPolicy
< T, D, D2, R1, R2 >::RepType > 		ROOT::Math::Times (const SMatrix< T, D, D2, R1 > &lhs, const SMatrix< T, D, D2, R2 > &rhs)
 Element by element matrix multiplication C(i,j) = A(i,j)*B(i,j) returning a matrix expression. More...
 
template<class A , class T , unsigned int D, unsigned int D2, class R1 , class R2 >
Expr< BinaryOp< MulOp< T >
, Expr< A, T, D, D2, R1 >
, SMatrix< T, D, D2, R2 >, T >
, T, D, D2, typename AddPolicy
< T, D, D2, R1, R2 >::RepType > 		ROOT::Math::Times (const Expr< A, T, D, D2, R1 > &lhs, const SMatrix< T, D, D2, R2 > &rhs)
 
template<class A , class T , unsigned int D, unsigned int D2, class R1 , class R2 >
Expr< BinaryOp< MulOp< T >
, SMatrix< T, D, D2, R1 >
, Expr< A, T, D, D2, R2 >, T >
, T, D, D2, typename AddPolicy
< T, D, D2, R1, R2 >::RepType > 		ROOT::Math::Times (const SMatrix< T, D, D2, R1 > &lhs, const Expr< A, T, D, D2, R2 > &rhs)
 
template<class A , class B , class T , unsigned int D, unsigned int D2, class R1 , class R2 >
Expr< BinaryOp< MulOp< T >
, Expr< A, T, D, D2, R1 >
, Expr< B, T, D, D2, R2 >, T >
, T, D, D2, typename AddPolicy
< T, D, D2, R1, R2 >::RepType > 		ROOT::Math::Times (const Expr< A, T, D, D2, R1 > &lhs, const Expr< B, T, D, D2, R2 > &rhs)
 
template<class A , class T , unsigned int D, unsigned int D2, class R >
Expr< BinaryOpCopyR< MulOp< T >
, SMatrix< T, D, D2, R >
, Constant< A >, T >, T, D, D2,
R > 		ROOT::Math::operator* (const SMatrix< T, D, D2, R > &lhs, const A &rhs)
 Multiplication (element wise) of a matrix and a scalar, B(i,j) = A(i,j) * s returning a matrix expression. More...
 
template<class A , class T , unsigned int D, unsigned int D2, class R >
Expr< BinaryOpCopyL< MulOp< T >
, Constant< A >, SMatrix< T, D,
D2, R >, T >, T, D, D2, R > 		ROOT::Math::operator* (const A &lhs, const SMatrix< T, D, D2, R > &rhs)
 Multiplication (element wise) of a matrix and a scalar, B(i,j) = s * A(i,j) returning a matrix expression. More...
 
template<class A , class B , class T , unsigned int D, unsigned int D2, class R >
Expr< BinaryOpCopyR< MulOp< T >
, Expr< B, T, D, D2, R >
, Constant< A >, T >, T, D, D2,
R > 		ROOT::Math::operator* (const Expr< B, T, D, D2, R > &lhs, const A &rhs)
 
template<class A , class B , class T , unsigned int D, unsigned int D2, class R >
Expr< BinaryOpCopyL< MulOp< T >
, Constant< A >, Expr< B, T, D,
D2, R >, T >, T, D, D2, R > 		ROOT::Math::operator* (const A &lhs, const Expr< B, T, D, D2, R > &rhs)
 
template<class T , unsigned int D>
VecExpr< BinaryOp< DivOp< T >
, SVector< T, D >, SVector< T,
D >, T >, T, D > 		ROOT::Math::operator/ (const SVector< T, D > &lhs, const SVector< T, D > &rhs)
 Element by element division of vectors of the same dimension: v3(i) = v1(i)/v2(i) returning a vector expression. More...
 
template<class A , class T , unsigned int D>
VecExpr< BinaryOp< DivOp< T >
, VecExpr< A, T, D >, SVector
< T, D >, T >, T, D > 		ROOT::Math::operator/ (const VecExpr< A, T, D > &lhs, const SVector< T, D > &rhs)
 
template<class A , class T , unsigned int D>
VecExpr< BinaryOp< DivOp< T >
, SVector< T, D >, VecExpr< A,
T, D >, T >, T, D > 		ROOT::Math::operator/ (const SVector< T, D > &lhs, const VecExpr< A, T, D > &rhs)
 
template<class A , class B , class T , unsigned int D>
VecExpr< BinaryOp< DivOp< T >
, VecExpr< A, T, D >, VecExpr
< B, T, D >, T >, T, D > 		ROOT::Math::operator/ (const VecExpr< A, T, D > &lhs, const VecExpr< B, T, D > &rhs)
 
template<class A , class T , unsigned int D>
VecExpr< BinaryOpCopyR< DivOp
< T >, SVector< T, D >
, Constant< A >, T >, T, D > 		ROOT::Math::operator/ (const SVector< T, D > &lhs, const A &rhs)
 Division of the vector element by a scalar value: v2(i) = v1(i)/a returning a vector expression. More...
 
template<class A , class T , unsigned int D>
VecExpr< BinaryOpCopyL< DivOp
< T >, Constant< A >, SVector
< T, D >, T >, T, D > 		ROOT::Math::operator/ (const A &lhs, const SVector< T, D > &rhs)
 Division of a scalar value by the vector element: v2(i) = a/v1(i) returning a vector expression. More...
 
template<class A , class B , class T , unsigned int D>
VecExpr< BinaryOpCopyR< DivOp
< T >, VecExpr< B, T, D >
, Constant< A >, T >, T, D > 		ROOT::Math::operator/ (const VecExpr< B, T, D > &lhs, const A &rhs)
 
template<class A , class B , class T , unsigned int D>
VecExpr< BinaryOpCopyL< DivOp
< T >, Constant< A >, VecExpr
< B, T, D >, T >, T, D > 		ROOT::Math::operator/ (const A &lhs, const VecExpr< B, T, D > &rhs)
 
template<class T , unsigned int D, unsigned int D2, class R1 , class R2 >
Expr< BinaryOp< DivOp< T >
, SMatrix< T, D, D2, R1 >
, SMatrix< T, D, D2, R2 >, T >
, T, D, D2, typename AddPolicy
< T, D, D2, R1, R2 >::RepType > 		ROOT::Math::Div (const SMatrix< T, D, D2, R1 > &lhs, const SMatrix< T, D, D2, R2 > &rhs)
 Division (element wise) of two matrices of the same dimensions: C(i,j) = A(i,j) / B(i,j) returning a matrix expression. More...
 
template<class A , class T , unsigned int D, unsigned int D2, class R1 , class R2 >
Expr< BinaryOp< DivOp< T >
, Expr< A, T, D, D2, R1 >
, SMatrix< T, D, D2, R2 >, T >
, T, D, D2, typename AddPolicy
< T, D, D2, R1, R2 >::RepType > 		ROOT::Math::Div (const Expr< A, T, D, D2, R1 > &lhs, const SMatrix< T, D, D2, R2 > &rhs)
 
template<class A , class T , unsigned int D, unsigned int D2, class R1 , class R2 >
Expr< BinaryOp< DivOp< T >
, SMatrix< T, D, D2, R1 >
, Expr< A, T, D, D2, R2 >, T >
, T, D, D2, typename AddPolicy
< T, D, D2, R1, R2 >::RepType > 		ROOT::Math::Div (const SMatrix< T, D, D2, R1 > &lhs, const Expr< A, T, D, D2, R2 > &rhs)
 
template<class A , class B , class T , unsigned int D, unsigned int D2, class R1 , class R2 >
Expr< BinaryOp< DivOp< T >
, Expr< A, T, D, D2, R1 >
, Expr< B, T, D, D2, R2 >, T >
, T, D, D2, typename AddPolicy
< T, D, D2, R1, R2 >::RepType > 		ROOT::Math::Div (const Expr< A, T, D, D2, R1 > &lhs, const Expr< B, T, D, D2, R2 > &rhs)
 
template<class A , class T , unsigned int D, unsigned int D2, class R >
Expr< BinaryOpCopyR< DivOp< T >
, SMatrix< T, D, D2, R >
, Constant< A >, T >, T, D, D2,
R > 		ROOT::Math::operator/ (const SMatrix< T, D, D2, R > &lhs, const A &rhs)
 Division (element wise) of a matrix and a scalar, B(i,j) = A(i,j) / s returning a matrix expression. More...
 
template<class A , class T , unsigned int D, unsigned int D2, class R >
Expr< BinaryOpCopyL< DivOp< T >
, Constant< A >, SMatrix< T, D,
D2, R >, T >, T, D, D2, R > 		ROOT::Math::operator/ (const A &lhs, const SMatrix< T, D, D2, R > &rhs)
 Division (element wise) of a matrix and a scalar, B(i,j) = s / A(i,j) returning a matrix expression. More...
 
template<class A , class B , class T , unsigned int D, unsigned int D2, class R >
Expr< BinaryOpCopyR< DivOp< T >
, Expr< B, T, D, D2, R >
, Constant< A >, T >, T, D, D2,
R > 		ROOT::Math::operator/ (const Expr< B, T, D, D2, R > &lhs, const A &rhs)
 
template<class A , class B , class T , unsigned int D, unsigned int D2, class R >
Expr< BinaryOpCopyL< DivOp< T >
, Constant< A >, Expr< B, T, D,
D2, R >, T >, T, D, D2, R > 		ROOT::Math::operator/ (const A &lhs, const Expr< B, T, D, D2, R > &rhs)