symbolic_functions.h

Go to the documentation of this file.

#ifndef CYCLUS_SRC_TOOLKIT_SYMBOLIC_FUNCTIONS_H_
#define CYCLUS_SRC_TOOLKIT_SYMBOLIC_FUNCTIONS_H_

#include <list>
#include <string>

#include <boost/shared_ptr.hpp>

namespace cyclus {
namespace toolkit {

// Forward declarations
class LinearFunction;
class ExponentialFunction;
class PiecewiseFunction;

/// Abstract base class for symbolic functions
class SymFunction {
 public:
  typedef boost::shared_ptr<SymFunction> Ptr;

  /// Virtual destructor for an abstract base class
  virtual ~SymFunction() {}

  /// Base class must define how to calculate demand (dbl argument)
  virtual double value(double x) = 0;

  /// Every function must print itself
  virtual std::string Print() = 0;
};

/// Linear functions
/// f(x) = slope_ * x + intercept_
class LinearFunction : public SymFunction {
 public:
  /// Constructor for a linear function
  /// @param s the slope
  /// @param i the intercept, with the default being 0
  LinearFunction(double s, double i = 0.0) : slope_(s), intercept_(i) {}

  /// Evaluation for an double argument
  virtual double value(double x);

  /// Print a string of the function
  virtual std::string Print();

 private:
  /// The slope
  double slope_;

  /// The intercept
  double intercept_;
};

/// Exponential functions
/// f(x) = constant_ * exp ( exponent_ * x ) + intercept_
class ExponentialFunction : public SymFunction {
 public:
  /// Constructor for an exponential function
  /// @param c the leading constant
  /// @param e the exponent multiplier
  /// @param i the intercept, with the default being 0
  ExponentialFunction(double c, double e, double i = 0.0)
      : constant_(c),
        exponent_(e),
        intercept_(i) {}

  /// Evaluation for a double argument
  virtual double value(double x);

  /// Print a string of the function
  virtual std::string Print();

 private:
  /// The constant factor
  double constant_;

  /// The exponent multiplier
  double exponent_;

  /// The intercept
  double intercept_;
};

/// Piecewise function
/// f(x) for all x in [lhs,rhs]
/// 0 otherwise
class PiecewiseFunction : public SymFunction {
  struct PiecewiseFunctionInfo {
    PiecewiseFunctionInfo(SymFunction::Ptr function_, double xoff_ = 0,
                          double yoff_ = 0)
        : function(function_),
          xoffset(xoff_),
          yoffset(yoff_) {}

    SymFunction::Ptr function;
    double xoffset, yoffset;
  };

 public:
  /// Evaluation for an double argument
  virtual double value(double x);

  /// Print a string of the function
  virtual std::string Print();

 private:
  std::list<PiecewiseFunctionInfo> functions_;

  friend class PiecewiseFunctionFactory;
};

}  // namespace toolkit
}  // namespace cyclus

#endif  // CYCLUS_SRC_TOOLKIT_SYMBOLIC_FUNCTIONS_H_