BinaryFunctionExpression.h

Go to the documentation of this file.

// ========================================================================= //
// This file is part of MyraMath, copyright (c) 2014-2019 by Ryan A Chilton  //
// and distributed by MyraCore, LLC. See LICENSE.txt for license terms.      //
// ========================================================================= //

#ifndef MYRAMATH_EXPRESSION_BINARYFUNCTIONEXPRESSION_H
#define MYRAMATH_EXPRESSION_BINARYFUNCTIONEXPRESSION_H

#include <myramath/expression/ExpressionBase.h>
#include <myramath/expression/Index2string.h>

#include <myramath/utility/eprintf.h>

namespace myra {
namespace detail {

// Implementation detail for composing Expression's using binary functions, think f(A,B)
template<class Function,int Arity> class BinaryFunctionExpression : public ExpressionBase<Arity,typename Function::Output>
  {
  public:

    // Reflect types from underlying Function.
    typedef typename Function::InputA InputA;
    typedef typename Function::InputB InputB;
    typedef typename Function::Output Output;

    // Constructor, requires Function f and input Expression's (A,B).
    BinaryFunctionExpression(const Function& in_f, const Expression<Arity,InputA>& in_A, const Expression<Arity,InputB>& in_B)
      : f(in_f), A(in_A), B(in_B)
      {
      // Verify that A and B are the same size.
      Index<Arity> A_size = A.size();
      Index<Arity> B_size = B.size();
      if (A_size != B_size) 
        {
        std::string A_string = Index2string(A_size);
        std::string B_string = Index2string(B_size);
        throw eprintf("BinaryFunctionExpression: size mismatch forming f(A,B) [%s != %s]", A_string.c_str(), B_string.c_str() );
        }
      }

  protected:

    // Size inspector.
    virtual Index<Arity> size() const
      { return A.size(); }
  
    // Given an Index i, returns f(A(i),B(i))
    virtual Output evaluate(Index<Arity> i) const
      { return f.evaluate( A.evaluate(i), B.evaluate(i) ); }

    // Virtual copy constructor.
    virtual ExpressionBase<Arity,Output>* clone() const
      { return new BinaryFunctionExpression<Function,Arity>(f,A,B); }

  private:

    // Underlying Function instance.
    Function f;
    
    // Underlying input Expression's.
    Expression<Arity,InputA> A;
    Expression<Arity,InputB> B;

  };

// Helper factory function, returns f(A,B).
template<class Function, int Arity>
BinaryFunctionExpression<Function,Arity>
make_BinaryFunctionExpression(const Function& f, const Expression<Arity,typename Function::InputA>& A, const Expression<Arity,typename Function::InputB>& B)
  { return BinaryFunctionExpression<Function,Arity>(f,A,B); }

} // namespace detail

} // namespace myra

#endif