evalOp.h

Go to the documentation of this file.

/*
  @copyright Steve Keen 2013
  @author Russell Standish
  This file is part of Minsky.

  Minsky is free software: you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.

  Minsky is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with Minsky.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef EVALOP_H
#define EVALOP_H

#include <ecolab.h>
#include <xml_pack_base.h>
#include <xml_unpack_base.h>

#include "variableValue.h"
#include "operation.h"
#include "group.h"
#include "polyPackBase.h"

#include <vector>
#include <cairo/cairo.h>

#include <arrays.h>

// override EcoLab's default CLASSDESC_ACCESS macro
#include "classdesc_access.h"


namespace minsky
{
  using namespace ecolab;
  using namespace classdesc;
  using namespace std;

  struct EvalOpBase: public classdesc::PolyBase<minsky::OperationType::Type>,
                     //                     virtual public classdesc::PolyPackBase,
                     public OperationType
  {
    typedef OperationType::Type Type;

    // value used for the time operator
    static double t;
    static std::string timeUnit;

    int out=-1;
    std::vector<unsigned> in1;
    struct Support
    {
      double weight;
      unsigned idx;
      Support() {}
      Support(double weight, unsigned idx): weight(weight), idx(idx) {}
    };
    std::vector<std::vector<Support>> in2;
    bool flow1=true, flow2=true, xflow=true; 

    std::shared_ptr<OperationBase> state;
    [[noreturn]] void throw_error(const std::string& msg) const {
      if (state) state->throw_error(msg);
      else throw std::runtime_error(msg);
    }
    virtual ~EvalOpBase() {}

    virtual void deriv(double df[], std::size_t n, const double ds[], 
                       const double sv[], const double fv[])=0;

    virtual void eval(double fv[]=ValueVector::flowVars.data(), std::size_t n=ValueVector::flowVars.size(), 
                      const double sv[]=ValueVector::stockVars.data())=0;
 

    virtual void setTensorParams(const VariableValue&,const OperationBase&) {}
  };

  struct ScalarEvalOp: public EvalOpBase
  {
    std::shared_ptr<VariableValue> result; 
    virtual int numArgs() const =0;

    static ScalarEvalOp* create(Type op/*=numOps*/, const ItemPtr& state);

    void deriv(double df[], std::size_t n, const double ds[], 
                       const double sv[], const double fv[]) override;

    void eval(double fv[], std::size_t, const double sv[]) override;
 
    virtual double evaluate(double in1=0, double in2=0) const=0;
    virtual double d1(double x1=0, double x2=0) const=0;
    virtual double d2(double x1=0, double x2=0) const=0;
  };
  
  template <minsky::OperationType::Type T>
  struct EvalOp: public classdesc::Poly<EvalOp<T>, ScalarEvalOp>
  {
    OperationType::Type type() const  override {return T;}
    int numArgs() const override {
      return OperationTypeInfo::numArguments<T>();
    }
    double evaluate(double in1=0, double in2=0) const override;
    double d1(double x1=0, double x2=0) const override;
    double d2(double x1=0, double x2=0) const override;
  };

 struct ConstantEvalOp: public EvalOp<minsky::OperationType::constant>
  {
    double value;
    double evaluate(double in1=0, double in2=0) const override;
 };

  struct EvalOpPtr: public classdesc::shared_ptr<EvalOpBase>, 
                    public OperationType
  {
    EvalOpPtr() {}
    EvalOpPtr(EvalOpBase* e): classdesc::shared_ptr<EvalOpBase>(e) {}
    EvalOpPtr(OperationType::Type op):
      classdesc::shared_ptr<EvalOpBase>(ScalarEvalOp::create(op,nullptr)) {}
    EvalOpPtr(OperationType::Type op,
              const ItemPtr& state,
              const std::shared_ptr<VariableValue>& to,
              const VariableValue& from1={}, 
              const VariableValue& from2={});
  };

  struct EvalOpVector: public vector<EvalOpPtr>
    {
      // override push_back for diagnostic purposes
//       void push_back(const EvalOpPtr& x) {
//         vector<EvalOpPtr>::push_back(x);
//         for (std::size_t i=0; i<x->in1.size(); ++i)
//           if (auto s=dynamic_cast<ScalarEvalOp*>(x.get()))
//           {
//             cout << OperationType::typeName(s->type())<<"(";
//             if (s->numArgs()>0)
//               cout << s->in1[i]<<(s->flow1?"":"s");
//             if (s->numArgs()>1)
//               for (auto& i: s->in2[i])
//                 cout<<","<<i.idx<<"("<<i.weight<<")"<<(s->flow2?"":"s");
//             cout <<")->"<<s->out+i<<endl;
//           }
//       }
  };

  struct FlowVarsResized: public std::exception
  {
    const char* what() const noexcept {return "FlowVars unexpectedly resized";}
  };
}

#include "evalOp.cd"
#endif