WorkPiece.h

Go to the documentation of this file.

#ifndef WORKPIECE_H_
#define WORKPIECE_H_
 
#include<iostream>
#include<vector>
#include<map>
#include<string>
#include<sstream>
#include<cassert>
#include<memory>
#include<string>
 
#include "boost/any.hpp"
#include "boost/optional.hpp"
 
#include <Eigen/Dense>
 
#include "MUQ/config.h"
 
#include "MUQ/Modeling/WorkPiece.h"
 
#if MUQ_HAS_SUNDIALS==1
// Sundials includes
#include <nvector/nvector_serial.h>
#include <sundials/sundials_dense.h> // definitions DlsMat DENSE_ELEM
#endif
 
namespace muq {
  namespace Modeling {
 
    // Forward declaration of WorkGraphPiece
    class WorkGraphPiece;
    class WorkGraph;
 
    template <typename T>
      using ref_vector = std::vector<std::reference_wrapper<const T>>;
 
    class WorkPiece {
 
      // Make WorkGraphPiece a friend so it can access WorkPiece's outputs directly
      friend class WorkGraphPiece;
      friend class WorkGraph;
 
    protected:
 
      enum Fix {
    Inputs,
    Outputs };
 
    public:
 
      WorkPiece();
 
 
      WorkPiece(int const num, WorkPiece::Fix const fix = WorkPiece::Fix::Inputs);
 
 
      WorkPiece(int const numIns, int const numOuts);
 
 
      WorkPiece(std::vector<std::string> const& types, WorkPiece::Fix const fix = WorkPiece::Fix::Inputs);
 
 
      WorkPiece(std::map<unsigned int, std::string> const& types, WorkPiece::Fix const fix = WorkPiece::Fix::Inputs);
 
 
      WorkPiece(std::map<unsigned int, std::string> const& types, int const num, WorkPiece::Fix const fixTypes = WorkPiece::Fix::Inputs, WorkPiece::Fix const fixNum = WorkPiece::Fix::Inputs);
 
 
      WorkPiece(std::vector<std::string> const& types, int const num);
 
 
      WorkPiece(int const num, std::vector<std::string> const& types);
 
 
      WorkPiece(std::map<unsigned int, std::string> const& inTypes, int const numIns, int const numOuts);
 
 
      WorkPiece(int const numIns, std::map<unsigned int, std::string> const& outTypes, int const numOuts);
 
 
      WorkPiece(std::vector<std::string> const& inTypes, std::vector<std::string> const& outTypes);
 
 
      WorkPiece(std::map<unsigned int, std::string> const& inTypes, std::vector<std::string> const& outTypes);
 
 
      WorkPiece(std::map<unsigned int, std::string> const& inTypes, int const num, std::vector<std::string> const& outTypes);
 
 
      WorkPiece(std::vector<std::string> const& inTypes, std::map<unsigned int, std::string> const& outTypes);
 
 
      WorkPiece(std::vector<std::string> const& inTypes, std::map<unsigned int, std::string> const& outTypes, int const num);
 
 
      WorkPiece(std::map<unsigned int, std::string> const& inTypes, std::map<unsigned int, std::string> const& outTypes);
 
 
      WorkPiece(std::map<unsigned int, std::string> const& inTypes, int const numIn, std::map<unsigned int, std::string> const& outTypes);
 
 
      WorkPiece(std::map<unsigned int, std::string> const& inTypes, std::map<unsigned int, std::string> const& outTypes, int const numOut);
 
 
      WorkPiece(std::map<unsigned int, std::string> const& inTypes, int const numIn, std::map<unsigned int, std::string> const& outTypes, int const numOut);
 
      virtual ~WorkPiece() {}
 
 
      std::vector<boost::any> const& Evaluate(std::vector<boost::any> const& ins);
 
 
      std::vector<boost::any> const& Evaluate(ref_vector<boost::any> const& ins);
 
 
      std::vector<boost::any> const& Evaluate();
 
 
      template<typename... Args>
    std::vector<boost::any> const& Evaluate(Args... args) {
    // clear the outputs
    Clear();
 
    // create the reference input vector
    ref_vector<boost::any> inputs;
    inputs.reserve(numInputs<0? 0 : numInputs);
 
    // begin calling the EvaluateRecursive with the first input
    return EvaluateRecursive(inputs, args...);
      }
 
  //     /// Evaluate the Jacobian of this muq::Modeling::WorkPiece using references to the inputs
  //     /**
    //  This function takes a vector of inputs to the muq::Modeling::WorkPiece, which must match WorkPiece::numInputs and WorkPiece::inputTypes if they are specified.  It then calls WorkPiece::JacobianImpl(), which computes the Jacobian.  The Jacobian must be implemented by a child class, unless both the input and the output are Eigen::VectorXd's.  In this case, we default to finite difference.
    //  @param[in] wrtIn The input number we are taking the Jacobian with respect to
    //  @param[in] wrtOut The output number we are taking the Jacobian with respect to
    //  @param[in] ins A vector of inputs
    //  \return The Jacobian of this muq::Modeling::WorkPiece
  //     */
  //     boost::any Jacobian(unsigned int const wrtIn, unsigned int const wrtOut, std::vector<boost::any> const& ins);
  //
  //     /// Evaluate the Jacobian of this muq::Modeling::WorkPiece using references to the inputs
  //     /**
    //  This function takes the references to the inputs to the muq::Modeling::WorkPiece, which must match WorkPiece::numInputs and WorkPiece::inputTypes if they are specified.  It then calls WorkPiece::JacobianImpl(), which computes the Jacobian.  The Jacobian must be implemented by a child class, unless both the input and the output are Eigen::VectorXd's.  In this case, we default to finite difference.
  //
    //  References are used for efficiency in the muq::Modeling::WorkGraph.
    //  @param[in] wrtIn The input number we are taking the Jacobian with respect to
    //  @param[in] wrtOut The output number we are taking the Jacobian with respect to
    //  @param[in] ins A vector of references to the inputs
    //  \return The Jacobian of this muq::Modeling::WorkPiece
  //     */
  //     boost::any Jacobian(unsigned int const wrtIn, unsigned int const wrtOut, ref_vector<boost::any> const& ins);
  //
  //     /// Evaluate the Jacobian of this muq::Modeling::WorkPiece using multiple arguments
  //     /**
    //  This function allows the user to compute the Jacobian of an output with respect to one of the inputs.  If both the input and the output type is an Eigen::VectorXd and the user has not implemented the Jacobian, we default to finite difference.
    //  @param[in] wrtIn The input number we are taking the Jacobian with respect to
    //  @param[in] wrtOut The output number we are taking the Jacobian with respect to
    //  @param[in] args The inputs (may be more than one)
    //  \return The Jacobian of this muq::Modeling::WorkPiece
  //      */
  //     template<typename... Args>
    // boost::any Jacobian(unsigned int const wrtIn, unsigned int const wrtOut, Args... args) {
    // // make sure the input and output number are valid
    // assert(numInputs<0 || wrtIn<numInputs);
    // assert(numOutputs<0 || wrtOut<numOutputs);
  //
    // // clear the outputs and derivative information
    // ClearDerivatives();
  //
    // // create the reference input vector
    // ref_vector<boost::any> inputs;
    // inputs.reserve(numInputs<0? 0 : numInputs);
  //
    // // begin calling the JacobianRecursive with the first input
    // return JacobianRecursive(wrtIn, wrtOut, inputs, args...);
  //     }
  //
  //     /// Compute the Jacobian using finite differences
  //     /**
    //  Assume the input and output type are Eigen::VectorXd.
    //  @param[in] wrtIn The input number we are taking the Jacobian with respect to
    //  @param[in] wrtOut The output number we are taking the Jacobian with respect to
    //  @param[in] args The inputs (may be more than one)
    //  @param[in] refTol Scaled value for the finite difference step size (defaults to 1e-4)
    //  @param[in] minTol Minimum value for the finite difference step size (defaults to 1e-6)
  //      */
  //     void JacobianByFD(unsigned int const wrtIn, unsigned int const wrtOut, ref_vector<boost::any> const& inputs, double const relTol = 1.0e-4, const double minTol = 1.0e-6);
  //
  //     /// Evaluate the action of the Jacobian of this muq::Modeling::WorkPiece using references to the inputs
  //     /**
    //  This function takes a vector of inputs to the muq::Modeling::WorkPiece, which must match WorkPiece::numInputs and WorkPiece::inputTypes if they are specified.  It then calls WorkPiece::JacobianActionImpl(), which computes the action of the Jacobian.  The Jacobian must be implemented by a child class, unless the input and the output and the vector the Jacobian is action on are Eigen::VectorXd's.  In this case, we call WorkPiece::Jacobian() and apply it to the vector.
    //  @param[in] wrtIn The input number we are taking the Jacobian with respect to
    //  @param[in] wrtOut The output number we are taking the Jacobian with respect to
    //  @param[in] vec We want to apply the Jacobian to this vector
    //  @param[in] ins A vector of inputs
    //  \return The Jacobian of this muq::Modeling::WorkPiece
  //     */
  //     boost::any JacobianAction(unsigned int const wrtIn, unsigned int const wrtOut, boost::any const& vec, std::vector<boost::any> const& ins);
  //
  //     /// Evaluate the action of the Jacobian of this muq::Modeling::WorkPiece using references to the inputs
  //     /**
    //  References are used for efficiency in the muq::Modeling::WorkGraph.
    //  @param[in] wrtIn The input number we are taking the Jacobian with respect to
    //  @param[in] wrtOut The output number we are taking the Jacobian with respect to
    //  @param[in] vec We want to apply the Jacobian to this vector
    //  @param[in] ins A vector of references to the inputs
    //  \return The Jacobian of this muq::Modeling::WorkPiece
  //     */
  //     boost::any JacobianAction(unsigned int const wrtIn, unsigned int const wrtOut, boost::any const& vec, ref_vector<boost::any> const& ins);
  //
  //     /// Evaluate the action of the Jacobian of this muq::Modeling::WorkPiece using multiple arguments
  //     /**
    //  This function allows the user to compute the action of the Jacobian of an output with respect to one of the inputs.  If the vector given to this function, the input type and the output type is an Eigen::VectorXd and the user has not implemented the Jacobian action, we call muq::Modeling::Jacobian and apply it to the given vector
    //  @param[in] wrtIn The input number we are taking the Jacobian with respect to
    //  @param[in] wrtOut The output number we are taking the Jacobian with respect to
    //  @param[in] vec We want to apply the Jacobian to this vector
    //  @param[in] args The inputs (may be more than one)
    //  \return The action of the Jacobian of this muq::Modeling::WorkPiece on vec
  //      */
  //     template<typename... Args>
    // boost::any JacobianAction(unsigned int const wrtIn, unsigned int const wrtOut, boost::any const& vec, Args... args) {
    // // make sure the input and output number are valid
    // assert(numInputs<0 || wrtIn<numInputs);
    // assert(numOutputs<0 || wrtOut<numOutputs);
  //
    // // clear the outputs and derivative information
    // ClearDerivatives();
  //
    // // create the reference input vector
    // ref_vector<boost::any> inputs;
    // inputs.reserve(numInputs<0? 0 : numInputs);
  //
    // // begin calling the JacobianActionRecursive with the first input
    // return JacobianActionRecursive(wrtIn, wrtOut, vec, inputs, args...);
  //     }
  //
  //     /// Compute the action of the Jacobian using finite differences
  //     /**
    //  Assume the input and output type are Eigen::VectorXd.
    //  @param[in] wrtIn The input number we are taking the Jacobian with respect to
    //  @param[in] wrtOut The output number we are taking the Jacobian with respect to
    //  @param[in] vec We want to apply the Jacobian to this vector
    //  @param[in] args The inputs (may be more than one)
  //      */
  //     void JacobianActionByFD(unsigned int const wrtIn, unsigned int const wrtOut, boost::any const& vec, ref_vector<boost::any> const& input);
  //
  //     /// Evaluate the action of the Jacobian transpose of this muq::Modeling::WorkPiece using references to the inputs
  //     /**
    //  This function takes a vector of inputs to the muq::Modeling::WorkPiece, which must match WorkPiece::numInputs and WorkPiece::inputTypes if they are specified.  It then calls WorkPiece::JacobianTransposeActionImpl(), which computes the action of the Jacobian transpose.  The Jacobian must be implemented by a child class, unless the input and the output and the vector the Jacobian transpose is action on are Eigen::VectorXd's.  In this case, we call WorkPiece::Jacobian() and apply it to the vector.
    //  @param[in] wrtIn The input number we are taking the Jacobian with respect to
    //  @param[in] wrtOut The output number we are taking the Jacobian with respect to
    //  @param[in] vec We want to apply the Jacobian to this vector
    //  @param[in] ins A vector of inputs
    //  \return The Jacobian of this muq::Modeling::WorkPiece
  //     */
  //     boost::any JacobianTransposeAction(unsigned int const wrtIn, unsigned int const wrtOut, boost::any const& vec, std::vector<boost::any> const& ins);
  //
  //     /// Evaluate the action of the Jacobian transpose of this muq::Modeling::WorkPiece using references to the inputs
  //     /**
    //  References are used for efficiency in the muq::Modeling::WorkGraph.
    //  @param[in] wrtIn The input number we are taking the Jacobian with respect to
    //  @param[in] wrtOut The output number we are taking the Jacobian with respect to
    //  @param[in] vec We want to apply the Jacobian to this vector
    //  @param[in] ins A vector of references to the inputs
    //  \return The Jacobian of this muq::Modeling::WorkPiece
  //     */
  //     boost::any JacobianTransposeAction(unsigned int const wrtIn, unsigned int const wrtOut, boost::any const& vec, ref_vector<boost::any> const& ins);
  //
  //     /// Evaluate the action of the Jacobian transpose of this muq::Modeling::WorkPiece using multiple arguments
  //     /**
    //  This function allows the user to compute the action of the Jacobian transpose of an output with respect to one of the inputs.  If the vector given to this function, the input type and the output type is an Eigen::VectorXd and the user has not implemented the Jacobian transpose action, we call muq::Modeling::Jacobian and apply it to the given vector
    //  @param[in] wrtIn The input number we are taking the Jacobian with respect to
    //  @param[in] wrtOut The output number we are taking the Jacobian with respect to
    //  @param[in] vec We want to apply the Jacobian transpose to this vector
    //  @param[in] args The inputs (may be more than one)
    //  \return The action of the Jacobian transpose of this muq::Modeling::WorkPiece on vec
  //      */
  //     template<typename... Args>
    // boost::any JacobianTransposeAction(unsigned int const wrtIn, unsigned int const wrtOut, boost::any const& vec, Args... args) {
    // // make sure the input and output number are valid
    // assert(numInputs<0 || wrtIn<numInputs);
    // assert(numOutputs<0 || wrtOut<numOutputs);
  //
    // // clear the outputs and derivative information
    // ClearDerivatives();
  //
    // // create the reference input vector
    // ref_vector<boost::any> inputs;
    // inputs.reserve(numInputs<0? 0 : numInputs);
  //
    // // begin calling the JacobianTransposeActionRecursive with the first input
    // return JacobianTransposeActionRecursive(wrtIn, wrtOut, vec, inputs, args...);
  //     }
  //
  //     /// Compute the action of the Jacobian transpose using finite differences
  //     /**
    //  Assume the input and output type are Eigen::VectorXd.
    //  @param[in] wrtIn The input number we are taking the Jacobian with respect to
    //  @param[in] wrtOut The output number we are taking the Jacobian with respect to
    //  @param[in] vec We want to apply the Jacobian transpose to this vector
    //  @param[in] args The inputs (may be more than one)
  //      */
  //     void JacobianTransposeActionByFD(unsigned int const wrtIn, unsigned int const wrtOut, boost::any const& vec, ref_vector<boost::any> const& inputs);
 
 
      std::string const& Name();
 
      void SetName(std::string const& newName);
 
 
      std::string InputType(unsigned int inputNum, bool const demangle = true) const;
 
      int InputSize(unsigned int inputNum) const;
 
      void SetInputSize(unsigned int inputNum, int newSize);
 
 
      std::string OutputType(unsigned int outputNum, bool const demangle = true) const;
 
      std::map<unsigned int, std::string> OutputTypes() const;
 
      std::map<unsigned int, std::string> InputTypes() const;
 
 
      unsigned int ID() const;
 
      virtual double GetRunTime(const std::string& method="Evaluate") const;
 
      virtual unsigned long int GetNumCalls(const std::string& method = "Evaluate") const;
 
      virtual void ResetCallTime();
 
 
      int numInputs;
 
      int numOutputs;
 
      static ref_vector<const boost::any> ToRefVector(std::vector<boost::any> const& anyVec);
      static ref_vector<const Eigen::VectorXd> ToRefVector(std::vector<Eigen::VectorXd> const& anyVec);
 
    protected:
 
 
      bool CheckInputType(unsigned int const inputNum, std::string const& type) const;
 
 
      bool CheckOutputType(unsigned int const outputNum, std::string const& type) const;
 
 
 
      std::vector<std::string> Types(std::vector<boost::any> const& vec) const;
 
 
      bool clearOutputs = true;
 
 
      std::vector<boost::any> outputs = std::vector<boost::any>(0);
 
 
      std::map<unsigned int, std::string> inputTypes;
 
 
      std::map<unsigned int, std::string> outputTypes;
 
      std::map<unsigned int, int> inputSizes;
 
 
      std::map<unsigned int, std::string> Types(std::vector<std::string> const& typesVec) const;
 
 
      // The following variables keep track of how many times the Implemented functions, i.e. EvaluateImpl, GradientImpl,
      // etc... are called.
      unsigned long int numEvalCalls   = 0;
 
      // these variables keep track of the total wall-clock time spent in each of the Implemented functions.  They are in
      // units of milliseconds
      double evalTime   = 0;
 
      const unsigned int id;
 
      std::string name;
 
 
      virtual std::string CreateName() const;
 
    private:
 
 
      virtual void EvaluateImpl(ref_vector<boost::any> const& inputs) = 0;
 
 
      template<typename ith, typename... Args>
    std::vector<boost::any> const& EvaluateRecursive(ref_vector<boost::any> &inputs, ith const& in, Args... args) {
    const int inputNum = inputs.size();
 
    // we have not yet put all of the inputs into the map, the ith should be less than the total number
    assert(numInputs<0 || inputNum+1<numInputs);
 
    // check the input type
    assert(CheckInputType(inputNum, typeid(in).name()));
 
    // add the last input to the input vector
    const boost::any in_any(in);
    inputs.push_back(std::cref(in_any));
 
    // call with EvaluateRecursive with the remaining inputs
    return EvaluateRecursive(inputs, args...);
      }
 
 
      template<typename last>
    std::vector<boost::any> const& EvaluateRecursive(ref_vector<boost::any> &inputs, last const& in) {
 
    const int inputNum = inputs.size();
 
    // this is the last input, the last one should equal the total number of inputs
    assert(numInputs<0 || inputNum+1==numInputs);
 
    // check the input type
    assert(CheckInputType(inputNum, typeid(in).name()));
 
    // add the last input to the input vector
    const boost::any in_any(in);
    inputs.push_back(std::cref(in_any));
 
    return Evaluate(inputs);
      }
 
  //     /// User-implemented function that to compute the Jacobian
  //     /**
    //  If th user does not implement this function, the Jacobian cannot be computed.  However, if both the input and the output type are Eigen::VectorXd, we default to finite difference.
    //  @param[in] wrtIn The input number we are taking the Jacobian with respect to
    //  @param[in] wrtOut The output number we are taking the Jacobian with respect to
    //  @param[in] inputs The vector of references to the inputs
  //     */
  //     virtual void JacobianImpl(unsigned int const wrtIn, unsigned int const wrtOut, ref_vector<boost::any> const& inputs);
  //
  //     /// Creates WorkPiece::inputs when the WorkPiece::Jacobian is called with multiple arguments
  //     /**
    //  @param[in] wrtIn The input number we are taking the Jacobian with respect to
    //  @param[in] wrtOut The output number we are taking the Jacobian with respect to
    //  @param[in] inputs The growing vector of inputs
    //  @param[in] in The input corresponding to the \f$i^{th}\f$ input
    //  @param[in] args The remaining (greater than \f$i\f$) inputs
    //  \return The Jacobian of this muq::Modeling::WorkPiece
  //     */
  //     template<typename ith, typename... Args>
    // boost::any JacobianRecursive(unsigned int const wrtIn, unsigned int const wrtOut, ref_vector<boost::any> &inputs, ith const& in, Args... args) {
    // const int inputNum = inputs.size();
  //
    // // we have not yet put all of the inputs into the map, the ith should be less than the total number
    // assert(numInputs<0 || inputNum+1<numInputs);
  //
    // // check the input type
    // assert(CheckInputType(inputNum, typeid(in).name()));
  //
    // // add the last input to the input vector
    // const boost::any in_any(in);
    // inputs.push_back(std::cref(in_any));
  //
    // // call with JacobianRecursive with the remaining inputs
    // return JacobianRecursive(wrtIn, wrtOut, inputs, args...);
  //     }
  //
  //     /// Creates WorkPiece::inputs when the WorkPiece::Jacobian is called with multiple arguments
  //     /**
    //  @param[in] wrtIn The input number we are taking the Jacobian with respect to
    //  @param[in] wrtOut The output number we are taking the Jacobian with respect to
    //  @param[in] inputs The growing vector of inputs
    //  @param[in] in The input corresponding to the last input
    //  \return The Jacobian of this muq::Modeling::WorkPiece
  //     */
  //     template<typename last>
    // boost::any JacobianRecursive(unsigned int const wrtIn, unsigned int const wrtOut, ref_vector<boost::any> &inputs, last const& in) {
    // const int inputNum = inputs.size();
  //
    // // this is the last input, the last one should equal the total number of inputs
    // assert(numInputs<0 || inputNum+1==numInputs);
  //
    // // check the input type
    // assert(CheckInputType(inputNum, typeid(in).name()));
  //
    // // add the last input to the input vector
    // const boost::any in_any(in);
    // inputs.push_back(std::cref(in_any));
  //
    // return Jacobian(wrtIn, wrtOut, inputs);
  //     }
  //
  //     /// User-implemented function that to compute the action of the Jacobian
  //     /**
    //  @param[in] wrtIn The input number we are taking the Jacobian with respect to
    //  @param[in] wrtOut The output number we are taking the Jacobian with respect to
    //  @param[in] vec We want to apply the Jacobian to this vector
    //  @param[in] inputs The vector of references to the inputs
  //     */
  //     virtual void JacobianActionImpl(unsigned int const wrtIn, unsigned int const wrtOut, boost::any const& vec, ref_vector<boost::any> const& inputs);
  //
  //     /// Creates WorkPiece::inputs when the WorkPiece::JacobianAction is called with multiple arguments
  //     /**
    //  @param[in] wrtIn The input number we are taking the Jacobian with respect to
    //  @param[in] wrtOut The output number we are taking the Jacobian with respect to
    //  @param[in] vec We want to apply the Jacobian to this vector
    //  @param[in] inputs The growing vector of inputs
    //  @param[in] in The input corresponding to the \f$i^{th}\f$ input
    //  @param[in] args The remaining (greater than \f$i\f$) inputs
    //  \return The action of the Jacobian of this muq::Modeling::WorkPiece on vec
  //     */
  //     template<typename ith, typename... Args>
    // boost::any JacobianActionRecursive(unsigned int const wrtIn, unsigned int const wrtOut, boost::any const& vec, ref_vector<boost::any>& inputs, ith const& in, Args... args) {
    // const int inputNum = inputs.size();
  //
    // // we have not yet put all of the inputs into the map, the ith should be less than the total number
    // assert(numInputs<0 || inputNum+1<numInputs);
  //
    // // check the input type
    // assert(CheckInputType(inputNum, typeid(in).name()));
  //
    // // add the last input to the input vector
    // const boost::any in_any(in);
    // inputs.push_back(std::cref(in_any));
  //
    // // call with JacobianActionRecursive with the remaining inputs
    // return JacobianActionRecursive(wrtIn, wrtOut, vec, inputs, args...);
  //     }
  //
  //     /// Creates WorkPiece::inputs when the WorkPiece::JacobianAction is called with multiple arguments
  //     /**
    //  @param[in] wrtIn The input number we are taking the Jacobian with respect to
    //  @param[in] wrtOut The output number we are taking the Jacobian with respect to
    //  @param[in] vec We want to apply the Jacobian to this vector
    //  @param[in] inputs The growing vector of inputs
    //  @param[in] in The input corresponding to the last input
    //  \return The action of the Jacobian of this muq::Modeling::WorkPiece on vec
  //     */
  //     template<typename last>
    // boost::any JacobianActionRecursive(unsigned int const wrtIn, unsigned int const wrtOut, boost::any const& vec, ref_vector<boost::any>& inputs, last const& in) {
    // const int inputNum = inputs.size();
  //
    // // this is the last input, the last one should equal the total number of inputs
    // assert(numInputs<0 || inputNum+1==numInputs);
  //
    // // check the input type
    // assert(CheckInputType(inputNum, typeid(in).name()));
  //
    // // add the last input to the input vector
    // const boost::any in_any(in);
    // inputs.push_back(std::cref(in_any));
  //
    // return JacobianAction(wrtIn, wrtOut, vec, inputs);
  //     }
  //
  //     /// User-implemented function that to compute the action of the Jacobian transpose
  //     /**
    //  @param[in] wrtIn The input number we are taking the Jacobian with respect to
    //  @param[in] wrtOut The output number we are taking the Jacobian with respect to
    //  @param[in] vec We want to apply the Jacobian transpose to this vector
    //  @param[in] inputs The vector of references to the inputs
  //     */
  //     virtual void JacobianTransposeActionImpl(unsigned int const wrtIn, unsigned int const wrtOut, boost::any const& vec, ref_vector<boost::any> const& inputs);
  //
  //     /// Creates WorkPiece::inputs when the WorkPiece::JacobianTransposeAction is called with multiple arguments
  //     /**
    //  @param[in] wrtIn The input number we are taking the Jacobian with respect to
    //  @param[in] wrtOut The output number we are taking the Jacobian with respect to
    //  @param[in] vec We want to apply the Jacobian transpose on this vector
    //  @param[in] inputs The growing vector of inputs
    //  @param[in] in The input corresponding to the \f$i^{th}\f$ input
    //  @param[in] args The remaining (greater than \f$i\f$) inputs
    //  \return The action of the Jacobian of this muq::Modeling::WorkPiece on vec
  //     */
  //     template<typename ith, typename... Args>
    // boost::any JacobianTransposeActionRecursive(unsigned int const wrtIn, unsigned int const wrtOut, boost::any const& vec, ref_vector<boost::any>& inputs, ith const& in, Args... args) {
    // const int inputNum = inputs.size();
  //
    // // we have not yet put all of the inputs into the map, the ith should be less than the total number
    // assert(numInputs<0 || inputNum+1<numInputs);
  //
    // // check the input type
    // assert(CheckInputType(inputNum, typeid(in).name()));
  //
    // // add the last input to the input vector
    // const boost::any in_any(in);
    // inputs.push_back(std::cref(in_any));
  //
    // // call with JacobianTransposeActionRecursive with the remaining inputs
    // return JacobianTransposeActionRecursive(wrtIn, wrtOut, vec, inputs, args...);
  //     }
  //
  //     /// Creates WorkPiece::inputs when the WorkPiece::JacobianTransposeAction is called with multiple arguments
  //     /**
    //  @param[in] wrtIn The input number we are taking the Jacobian with respect to
    //  @param[in] wrtOut The output number we are taking the Jacobian with respect to
    //  @param[in] vec We want to apply the Jacobian transpose to this vector
    //  @param[in] inputs The growing vector of inputs
    //  @param[in] in The input corresponding to the last input
    //  \return The action of the Jacobian of this muq::Modeling::WorkPiece on vec
  //     */
  //     template<typename last>
    // boost::any JacobianTransposeActionRecursive(unsigned int const wrtIn, unsigned int const wrtOut, boost::any const& vec, ref_vector<boost::any>& inputs, last const& in) {
    // const int inputNum = inputs.size();
  //
    // // this is the last input, the last one should equal the total number of inputs
    // assert(numInputs<0 || inputNum+1==numInputs);
  //
    // // check the input type
    // assert(CheckInputType(inputNum, typeid(in).name()));
  //
    // // add the last input to the input vector
    // const boost::any in_any(in);
    // inputs.push_back(std::cref(in_any));
  //
    // return JacobianTransposeAction(wrtIn, wrtOut, vec, inputs);
  //     }
 
      void Clear();
 
 
      void DestroyAny(boost::any& obj) const;
 
 
      virtual void DestroyAnyImpl(boost::any& obj) const;
 
      static unsigned int CreateID();
 
 
   //const std::map<std::string, std::string> types;
    }; // class WorkPiece
  } // namespace Modeling
} // namespace muq
 
#endif