Variable.hpp

#pragma once
#include <cmath>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <memory>
#include <Eigen/Core>

namespace creativity { namespace data {

std::string to_string(double d);

#define CREATE_SHARED_WRAPPER(C) template <class... Args> static std::shared_ptr<C> create(Args... args) { return std::shared_ptr<C>(new C(std::forward<Args>(args)...)); }

class Variable : public std::enable_shared_from_this<Variable> {
    public:
        virtual ~Variable() = default;

        virtual std::string name() const = 0;

        virtual std::string nameBracketed(const std::string &bracketL = "(", const std::string &bracketR = ")") const;

        virtual void populate(Eigen::Ref<Eigen::VectorXd> column, unsigned int offset = 0, unsigned int trim = 0) const = 0;

        Eigen::VectorXd values(unsigned int rows = 0, unsigned int offset = 0, unsigned int trim = 0) const;

        virtual unsigned int size() const = 0;

        class SizeError : public std::logic_error {
            public:
                SizeError();
                SizeError(const std::string &why);
        };
};

class ConstantVariable final : public Variable {
    protected:
        ConstantVariable() = default;
        ConstantVariable(double c);
    public:
        CREATE_SHARED_WRAPPER(ConstantVariable)

        
        virtual void populate(Eigen::Ref<Eigen::VectorXd> column, unsigned int offset = 0, unsigned int trim = 0) const override;

        virtual std::string name() const override;

        virtual std::string nameBracketed(const std::string& = "(", const std::string& = ")") const override;

        const double& value() const;

        unsigned int size() const override;

    private:
        double c_ = 1.0;
};

class SimpleVariable : public Variable {
    protected:
        SimpleVariable() = delete;

        SimpleVariable(const std::string &name, const Eigen::Ref<const Eigen::VectorXd> values);

    public:
        CREATE_SHARED_WRAPPER(SimpleVariable)

        
        virtual void populate(Eigen::Ref<Eigen::VectorXd> column, unsigned int offset = 0, unsigned int trim = 0) const override;
        virtual std::string name() const override;
        virtual std::string nameBracketed(const std::string& = "(", const std::string& = ")") const override;
        unsigned int size() const override;

    protected:
        const std::string name_;
        Eigen::VectorXd col_;
};

class BinaryExpr : public Variable {
    public:
        virtual unsigned int size() const override;

    protected:
        BinaryExpr() = delete;

        BinaryExpr(const std::shared_ptr<const Variable> &left, const std::shared_ptr<const Variable> &right);

        std::shared_ptr<const Variable> left_;
        std::shared_ptr<const Variable> right_;
};

class UnaryExpr : public Variable {
    public:
        virtual unsigned int size() const override;

    protected:
        UnaryExpr() = delete;

        UnaryExpr(const std::shared_ptr<const Variable> &var);

        std::shared_ptr<const Variable> var_;
};


class Multiplication : public BinaryExpr {
    protected:
        using BinaryExpr::BinaryExpr;

    public:
        CREATE_SHARED_WRAPPER(Multiplication)

        
        virtual void populate(Eigen::Ref<Eigen::VectorXd> column, unsigned int offset = 0, unsigned int trim = 0) const override;

        virtual std::string name() const override;
};

class Addition : public BinaryExpr {
    protected:
        using BinaryExpr::BinaryExpr;

    public:
        CREATE_SHARED_WRAPPER(Addition)

        
        virtual void populate(Eigen::Ref<Eigen::VectorXd> column, unsigned int offset = 0, unsigned int trim = 0) const override;

        virtual std::string name() const override;
};

class Division : public BinaryExpr {
    protected:
        using BinaryExpr::BinaryExpr;

    public:
        CREATE_SHARED_WRAPPER(Division)

        
        virtual void populate(Eigen::Ref<Eigen::VectorXd> column, unsigned int offset = 0, unsigned int trim = 0) const override;

        virtual std::string name() const override;
};

class Power : public UnaryExpr {
    protected:
        Power() = delete;

        Power(const std::shared_ptr<const Variable> &var, double power);

    public:
        CREATE_SHARED_WRAPPER(Power)

        
        virtual void populate(Eigen::Ref<Eigen::VectorXd> column, unsigned int offset = 0, unsigned int trim = 0) const override;

        virtual std::string name() const override;

    protected:
        double power_;
};

class Exponential : public UnaryExpr {
    protected:
        Exponential(double base, const std::shared_ptr<const Variable> &var);

        Exponential(const std::shared_ptr<const Variable> &var);

    public:
        CREATE_SHARED_WRAPPER(Exponential)

        
        virtual void populate(Eigen::Ref<Eigen::VectorXd> column, unsigned int offset = 0, unsigned int trim = 0) const override;

        virtual std::string name() const override;

        virtual std::string nameBracketed(const std::string &bracketL = "(", const std::string &bracketR = ")") const override;

    protected:
        double base_;
};

class Logarithm : public UnaryExpr {
    protected:
        using UnaryExpr::UnaryExpr;

    public:
        CREATE_SHARED_WRAPPER(Logarithm)

        
        virtual void populate(Eigen::Ref<Eigen::VectorXd> column, unsigned int offset = 0, unsigned int trim = 0) const override;

        virtual std::string name() const override;

        virtual std::string nameBracketed(const std::string& = "(", const std::string& = ")") const override;
};

#undef CREATE_SHARED_WRAPPER

std::shared_ptr<Multiplication> operator* (const std::shared_ptr<const Variable> &left, const std::shared_ptr<const Variable> &right);
std::shared_ptr<Multiplication> operator* (const std::shared_ptr<const Variable> &v, double c);
std::shared_ptr<Multiplication> operator* (double c, const std::shared_ptr<const Variable> &v);
std::shared_ptr<Multiplication> operator- (const std::shared_ptr<const Variable> &v);
std::shared_ptr<Addition> operator+ (const std::shared_ptr<const Variable> &left, const std::shared_ptr<const Variable> &right);
std::shared_ptr<Addition> operator+ (const std::shared_ptr<const Variable> &v, double c);
std::shared_ptr<Addition> operator+ (double c, const std::shared_ptr<const Variable> &v);
std::shared_ptr<Addition> operator- (const std::shared_ptr<const Variable> &left, const std::shared_ptr<const Variable> &right);
std::shared_ptr<Addition> operator- (const std::shared_ptr<const Variable> &v, double c);
std::shared_ptr<Addition> operator- (double c, const std::shared_ptr<const Variable> &v);
std::shared_ptr<Division> operator/ (const std::shared_ptr<const Variable> &numerator, const std::shared_ptr<const Variable> &denominator);
std::shared_ptr<Division> operator/ (const std::shared_ptr<const Variable> &v, double c);
std::shared_ptr<Division> operator/ (double c, const std::shared_ptr<const Variable> &v);
std::shared_ptr<Power> operator^ (const std::shared_ptr<const Variable> &val, double pow);
std::shared_ptr<Exponential> operator^ (double base, const std::shared_ptr<const Variable> &val);

}}

namespace std {
shared_ptr<creativity::data::Exponential>
exp(const shared_ptr<const creativity::data::Variable> &var);
shared_ptr<creativity::data::Exponential>
exp2(const shared_ptr<const creativity::data::Variable> &var);
shared_ptr<creativity::data::Logarithm>
log(const shared_ptr<const creativity::data::Variable> &var);
shared_ptr<creativity::data::Power>
sqrt(const shared_ptr<const creativity::data::Variable> &var);
shared_ptr<creativity::data::Power>
pow(const shared_ptr<const creativity::data::Variable> &var, double power);
shared_ptr<creativity::data::Exponential>
pow(double base, const shared_ptr<const creativity::data::Variable> &var);
}