Model.hpp

// Reaktoro is a unified framework for modeling chemically reactive systems.
//
// Copyright © 2014-2022 Allan Leal
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this library. If not, see <http://www.gnu.org/licenses/>.
 
#pragma once
 
// Reaktoro includes
#include <Reaktoro/Common/Algorithms.hpp>
#include <Reaktoro/Common/Memoization.hpp>
#include <Reaktoro/Common/TraitsUtils.hpp>
#include <Reaktoro/Common/Types.hpp>
#include <Reaktoro/Core/Data.hpp>
#include <Reaktoro/Core/Param.hpp>
 
namespace Reaktoro {
 
template<typename Signature>
class Model;
 
template<typename ResultRef, typename... Args>
using ModelEvaluator = Fn<void(ResultRef res, Args... args)>;
 
template<typename Result, typename... Args>
using ModelCalculator = Fn<Result(Args... args)>;
 
using ModelSerializer = Fn<Data()>;
 
template<typename Result, typename... Args>
class Model<Result(Args...)>
{
public:
    using ResultRef = Ref<Result>;
 
    Model()
    {}
 
    Model(const ModelEvaluator<ResultRef, Args...>& evalfn, const Vec<Param>& params = {}, const ModelSerializer& serializerfn = {})
    : m_params(params), m_serializerfn(serializerfn)
    {
        assert(evalfn);
 
        m_evalfn = [evalfn](ResultRef res, const Args&... args, const Vec<Param>& w)
        {
            evalfn(res, args...);
        };
 
        m_calcfn = [evalfn](const Args&... args, const Vec<Param>& w) -> Result
        {
            Result res;
            evalfn(res, args...);
            return res;
        };
    }
 
    Model(const ModelCalculator<Result, Args...>& calcfn, const Vec<Param>& params = {}, const ModelSerializer& serializerfn = {})
    : m_params(params), m_serializerfn(serializerfn)
    {
        assert(calcfn);
 
        m_evalfn = [calcfn](ResultRef res, const Args&... args, const Vec<Param>& w)
        {
            res = calcfn(args...);
        };
 
        m_calcfn = [calcfn](const Args&... args, const Vec<Param>& w) -> Result
        {
            return calcfn(args...);
        };
    }
 
    template<typename Fun, Requires<!isFunction<Fun>> = true>
    Model(const Fun& f)
    : Model(std::function(f))
    // : Model(asFunction(f))
    {}
 
    auto withMemoization() const -> Model
    {
        Model copy = *this;
        copy.m_evalfn = memoizeLastUsingRef<Result>(copy.m_evalfn); // Here, if `m_evalfn` did not consider `const Vec<Param>&` as argument, memoization would not know when the parameters have been changed externally!
        copy.m_calcfn = memoizeLast(copy.m_calcfn); // Here, if `m_calcfn` did not consider `const Vec<Param>&` as argument, memoization would not know when the parameters have been changed externally!
        return copy;
    }
 
    auto apply(ResultRef res, const Args&... args) const -> void
    {
        assert(m_evalfn);
        m_evalfn(res, args..., m_params);
    }
 
    auto operator()(const Args&... args) const -> Result
    {
        assert(m_calcfn);
        return m_calcfn(args..., m_params);
    }
 
    auto operator()(ResultRef res, const Args&... args) const -> void
    {
        apply(res, args...);
    }
 
    auto initialized() const -> bool
    {
        return m_evalfn != nullptr;
    }
 
    operator bool() const
    {
        return initialized();
    }
 
    auto evaluatorFn() const -> const ModelEvaluator<ResultRef, Args..., const Vec<Param>&>&
    {
        return m_evalfn;
    }
 
    auto calculatorFn() const -> const ModelCalculator<Result, Args..., const Vec<Param>&>&
    {
        return m_calcfn;
    }
 
    auto serializerFn() const -> const ModelSerializer
    {
        return m_serializerfn;
    }
 
    auto params() const -> const Vec<Param>&
    {
        return m_params;
    }
 
    auto serialize() const -> Data
    {
        return m_serializerfn ? m_serializerfn() : Data{}; // evaluate m_serializerfn because Param objects may have changed
    }
 
    static auto Constant(const Param& param) -> Model
    {
        auto calcfn = [param](const Args&... args) { return param; }; // no need to have `const Vec<Param>&` in the lambda function here. This is added in the constructor call below!
        Vec<Param> params = { param };
        return Model(calcfn, params);
    }
 
private:
    Vec<Param> m_params;
 
    ModelEvaluator<ResultRef, Args..., const Vec<Param>&> m_evalfn;
 
    ModelCalculator<Result, Args..., const Vec<Param>&> m_calcfn;
 
    ModelSerializer m_serializerfn;
};
 
template<typename Result, typename... Args>
auto chain(const Vec<Model<Result(Args...)>>& models) -> Model<Result(Args...)>
{
    using ResultRef = Ref<Result>;
 
    const auto evalfns = vectorize(models, RKT_LAMBDA(model, model.evaluatorFn()));
    const auto paramsvec = vectorize(models, RKT_LAMBDA(model, model.params()));
    const auto serializerfns = vectorize(models, RKT_LAMBDA(model, model.serializerFn()));
 
    auto evalfn = [=](ResultRef res, const Args&... args)
    {
        for(auto i = 0; i < evalfns.size(); ++i)
            evalfns[i](res, args..., paramsvec[i]);
    };
 
    auto serializerfn = [serializerfns]() -> Data
    {
        Data result;
        for(auto i = 0; i < serializerfns.size(); ++i)
            result.add(serializerfns[i]());
        return result;
    };
 
    Vec<Param> params;
    for(const auto& model : models)
        for(const auto& param : model.params())
            params.push_back(param);
 
    return Model<Result(Args...)>(evalfn, params);
}
 
template<typename Signature>
auto chain(const Model<Signature>& model) -> Model<Signature>
{
    return model;
}
 
template<typename Result, typename... Args, typename... Models>
auto chain(const Model<Result(Args...)>& model, const Models&... models) -> Model<Result(Args...)>
{
    Vec<Model<Result(Args...)>> vec = {model, models...};
    return chain(vec);
}
 
} // namespace Reaktoro