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:

Classes
class	ROOT::Math::AddOp< T >
	Addition Operation Class. More...
class	ROOT::Math::DivOp< T >
	Division (element-wise) Operation Class. More...
class	ROOT::Math::MinOp< T >
	Subtraction Operation Class. More...
class	ROOT::Math::MulOp< T >
	Multiplication (element-wise) Operation Class. More...

Namespaces
namespace	ROOT
	tbb::task_arena is an alias of tbb::interface7::task_arena, which doesn't allow to forward declare tbb::task_arena without forward declaring tbb::interface7
namespace	ROOT::Math

Functions
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 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 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.
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 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.
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< 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 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 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.
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 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.
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 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 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 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, 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 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.
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.
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 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 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 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 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.
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 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.
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.
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.
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 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 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 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, 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 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.
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.
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 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 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 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 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.
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 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.
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.
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.
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 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 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 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, 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)
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.
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.
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 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 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.
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.
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.
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 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 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 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, 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 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 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.