BinaryExpressionNode< AVariableManager > Class Template Reference

BinaryExpressionNode Node which connects two expression nodes with an arithemtic operation. More...

#include <CutNodes.h>

Inheritance diagram for BinaryExpressionNode< AVariableManager >:

Public Types
typedef AVariableManager::Var	Var
	Template argument dependent Variable type definition.

Public Member Functions
AVariableManager::VarVariant	evaluate (const Object *p) const override
	Evaluation of the child nodes and return result as a variant<double, int, bool> apply arithmetic operation to the evaluations.
void	print () const override
	Print node.
std::string	decompile () const override
	Decompile Node back to a string.
	~BinaryExpressionNode ()
	Destructor.

Private Types
typedef AVariableManager::Object	Object
	Template argument dependent Particle type definition.

Private Member Functions
	BinaryExpressionNode (Nodetuple left_node, Nodetuple right_node, ArithmeticOperation aoperation)
	Constructor.

Private Attributes
std::unique_ptr< const AbstractExpressionNode< AVariableManager > >	m_left_enode
	left expression node
std::unique_ptr< const AbstractExpressionNode< AVariableManager > >	m_right_enode
	right expression node
ArithmeticOperation	m_aoperation
	arithmetic operation to be applied to the evaluations of left and right expressions

Friends
class	NodeFactory

Detailed Description

template<class AVariableManager>
class Belle2::BinaryExpressionNode< AVariableManager >

BinaryExpressionNode Node which connects two expression nodes with an arithemtic operation.

Definition at line 726 of file CutNodes.h.

Member Typedef Documentation

Object

typedef AVariableManager::Object Object

private

Template argument dependent Particle type definition.

Definition at line 730 of file CutNodes.h.

Var

typedef AVariableManager::Var Var

inherited

Template argument dependent Variable type definition.

Definition at line 75 of file AbstractNodes.h.

Constructor & Destructor Documentation

~BinaryExpressionNode()

~BinaryExpressionNode ( )

inline

Destructor.

Definition at line 862 of file CutNodes.h.

{}

BinaryExpressionNode()

BinaryExpressionNode ( Nodetuple  left_node, Nodetuple  right_node, ArithmeticOperation  aoperation  )

inlineexplicitprivate

Constructor.

Parameters

left_node	(const boost::python::tuple&): tuple containing an expression node
right_node	(const boost::python::tuple&): tuple containing an expression node
aoperation	(ArithmeticOperator): arithmetic operator enum value

Definition at line 872 of file CutNodes.h.

                                                                                                             : m_left_enode{NodeFactory::compile_expression_node<AVariableManager>(left_node)},
      m_right_enode{NodeFactory::compile_expression_node<AVariableManager>(right_node)},  m_aoperation{aoperation}
    {
    }

Member Function Documentation

decompile()

std::string decompile ( ) const

inlineoverridevirtual

Decompile Node back to a string.

decompile(compile) should give the same result.

Implements AbstractExpressionNode< AVariableManager >.

Definition at line 850 of file CutNodes.h.

    {
      std::stringstream stringstream;
      stringstream << m_left_enode->decompile();
      injectArithmeticOperatorToStream(stringstream, m_aoperation);
      stringstream << m_right_enode->decompile();
 
      return stringstream.str();
    }

evaluate()

AVariableManager::VarVariant evaluate ( const Object *  p ) const

inlineoverridevirtual

Evaluation of the child nodes and return result as a variant<double, int, bool> apply arithmetic operation to the evaluations.

Parameters

p	pointer to the object, that should be checked.

Implements AbstractExpressionNode< AVariableManager >.

Definition at line 737 of file CutNodes.h.

    {
      typename AVariableManager::VarVariant l_val, r_val, ret;
      l_val = m_left_enode->evaluate(p);
      r_val = m_right_enode->evaluate(p);
      switch (m_aoperation) {
        case ArithmeticOperation::PLUS:
          if (std::holds_alternative<int>(l_val) && std::holds_alternative<int>(r_val)) {
            ret = std::get<int>(l_val) + std::get<int>(r_val);
            return ret;
          } else if (std::holds_alternative<double>(l_val) && std::holds_alternative<double>(r_val)) {
            ret = std::get<double>(l_val) + std::get<double>(r_val);
            return ret;
          } else if (std::holds_alternative<double>(l_val) && std::holds_alternative<int>(r_val)) {
            ret = std::get<double>(l_val) + std::get<int>(r_val);
            return ret;
          } else if (std::holds_alternative<int>(l_val) && std::holds_alternative<double>(r_val)) {
            ret = std::get<int>(l_val) + std::get<double>(r_val);
            return ret;
          } else {
            throw std::runtime_error("Invalid datatypes in plus operation.");
          }
          break;
        case ArithmeticOperation::MINUS:
          if (std::holds_alternative<int>(l_val) && std::holds_alternative<int>(r_val)) {
            ret = std::get<int>(l_val) - std::get<int>(r_val);
            return ret;
          } else if (std::holds_alternative<double>(l_val) && std::holds_alternative<double>(r_val)) {
            ret = std::get<double>(l_val) - std::get<double>(r_val);
            return ret;
          } else if (std::holds_alternative<double>(l_val) && std::holds_alternative<int>(r_val)) {
            ret = std::get<double>(l_val) - std::get<int>(r_val);
            return ret;
          } else if (std::holds_alternative<int>(l_val) && std::holds_alternative<double>(r_val)) {
            ret = std::get<int>(l_val) - std::get<double>(r_val);
            return ret;
          } else {
            throw std::runtime_error("Invalid datatypes in minus operation.");
          }
          break;
        case ArithmeticOperation::PRODUCT:
          if (std::holds_alternative<int>(l_val) && std::holds_alternative<int>(r_val)) {
            ret = std::get<int>(l_val) * std::get<int>(r_val);
            return ret;
          } else if (std::holds_alternative<double>(l_val) && std::holds_alternative<double>(r_val)) {
            ret = std::get<double>(l_val) * std::get<double>(r_val);
            return ret;
          } else if (std::holds_alternative<double>(l_val) && std::holds_alternative<int>(r_val)) {
            ret = std::get<double>(l_val) * std::get<int>(r_val);
            return ret;
          } else if (std::holds_alternative<int>(l_val) && std::holds_alternative<double>(r_val)) {
            ret = std::get<int>(l_val) * std::get<double>(r_val);
            return ret;
          } else {
            throw std::runtime_error("Invalid datatypes in product operation.");
          }
          break;
        case ArithmeticOperation::DIVISION:
          if (std::holds_alternative<int>(l_val) && std::holds_alternative<int>(r_val)) {
            // Always do double division
            double d = std::get<int>(r_val);
            ret = std::get<int>(l_val) / d;
            return ret;
          } else if (std::holds_alternative<double>(l_val) && std::holds_alternative<double>(r_val)) {
            ret = std::get<double>(l_val) / std::get<double>(r_val);
            return ret;
          } else if (std::holds_alternative<double>(l_val) && std::holds_alternative<int>(r_val)) {
            ret = std::get<double>(l_val) / std::get<int>(r_val);
            return ret;
          } else if (std::holds_alternative<int>(l_val) && std::holds_alternative<double>(r_val)) {
            ret = std::get<int>(l_val) / std::get<double>(r_val);
            return ret;
          } else {
            throw std::runtime_error("Invalid datatypes in division operation.");
          }
          break;
        case ArithmeticOperation::POWER:
          if (std::holds_alternative<int>(l_val) && std::holds_alternative<int>(r_val)) {
            ret = std::pow(std::get<int>(l_val), std::get<int>(r_val));
            return ret;
          } else if (std::holds_alternative<double>(l_val) && std::holds_alternative<double>(r_val)) {
            ret = std::pow(std::get<double>(l_val), std::get<double>(r_val));
            return ret;
          } else if (std::holds_alternative<double>(l_val) && std::holds_alternative<int>(r_val)) {
            ret = std::pow(std::get<double>(l_val), std::get<int>(r_val));
            return ret;
          } else if (std::holds_alternative<int>(l_val) && std::holds_alternative<double>(r_val)) {
            ret = std::pow(std::get<int>(l_val), std::get<double>(r_val));
            return ret;
          } else {
            throw std::runtime_error("Invalid datatypes in power operation.");
          }
          break;
        default:
          throw std::runtime_error("Operation not valid");
      }
      ret = false;
      return ret;
    }

print()

void print ( ) const

inlineoverridevirtual

Print node.

Implements AbstractExpressionNode< AVariableManager >.

Definition at line 839 of file CutNodes.h.

    {
      m_left_enode->print();
      injectArithmeticOperatorToStream(std::cout, m_aoperation);
      m_right_enode->print();
    }

Friends And Related Function Documentation

NodeFactory

friend class NodeFactory

friend

Definition at line 865 of file CutNodes.h.

Member Data Documentation

m_aoperation

ArithmeticOperation m_aoperation

private

arithmetic operation to be applied to the evaluations of left and right expressions

Definition at line 878 of file CutNodes.h.

m_left_enode

std::unique_ptr<const AbstractExpressionNode<AVariableManager> > m_left_enode

private

left expression node

Definition at line 876 of file CutNodes.h.

m_right_enode

std::unique_ptr<const AbstractExpressionNode<AVariableManager> > m_right_enode

private

right expression node

Definition at line 877 of file CutNodes.h.

---

The documentation for this class was generated from the following file:

• framework/utilities/include/CutNodes.h