TernaryFunctionExpression.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_TERNARYFUNCTIONEXPRESSION_H
#define MYRAMATH_EXPRESSION_TERNARYFUNCTIONEXPRESSION_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 ternary functions, think f(A,B,C)
template<class Function,int Arity> class TernaryFunctionExpression : 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::InputC InputC;
    typedef typename Function::Output Output;

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

  protected:

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

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

  private:

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

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

} // namespace detail

} // namespace myra

#endif