Model.hpp

// Reaktoro is a unified framework for modeling chemically reactive systems.
//
// Copyright © 2014-2024 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>
 
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)>;
 
template<typename Result, typename... Args>
class Model<Result(Args...)>
{
public:
    using ResultRef = Ref<Result>;
 
    Model()
    {}
 
    Model(const ModelEvaluator<ResultRef, Args...>& evalfn, const Data& params = {})
    : m_params(params)
    {
        assert(evalfn);
 
        m_evalfn = [evalfn](ResultRef res, const Args&... args)
        {
            evalfn(res, args...);
        };
 
        m_calcfn = [evalfn](const Args&... args) -> Result
        {
            Result res;
            evalfn(res, args...);
            return res;
        };
    }
 
    Model(const ModelCalculator<Result, Args...>& calcfn, const Data& params = {})
    : m_params(params)
    {
        assert(calcfn);
 
        m_evalfn = [calcfn](ResultRef res, const Args&... args)
        {
            res = calcfn(args...);
        };
 
        m_calcfn = [calcfn](const Args&... args) -> Result
        {
            return calcfn(args...);
        };
    }
 
    template<typename Fun, Requires<!isFunction<Fun>> = true>
    Model(const Fun& f)
    : Model(std::function(f))
    {}
 
    auto withMemoization() const -> Model
    {
        Model copy = *this;
        copy.m_evalfn = memoizeLastUsingRef<Result>(copy.m_evalfn); // Here, `m_evalfn` is memoized in case it is called multiple times with the same arguments and parameters.
        copy.m_calcfn = memoizeLast(copy.m_calcfn); // Here, `m_calcfn` is memoized in case it is called multiple times with the same arguments and parameters.
        return copy;
    }
 
    auto apply(ResultRef res, const Args&... args) const -> void
    {
        errorifnot(m_evalfn, "Model evaluator function object has not been initialized.");
        m_evalfn(res, args...);
    }
 
    auto operator()(const Args&... args) const -> Result
    {
        errorifnot(m_calcfn, "Model calculator function object has not been initialized.");
        return m_calcfn(args...);
    }
 
    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...>&
    {
        return m_evalfn;
    }
 
    auto calculatorFn() const -> const ModelCalculator<Result, Args...>&
    {
        return m_calcfn;
    }
 
    auto params() const -> const Data&
    {
        return m_params;
    }
 
    static auto Constant(String const& name, real const& value) -> Model
    {
        auto calcfn = [value](const Args&... args) -> real { return value; }; // the constant model is a simple function that always return the given constant value
        Data params;
        params[name]["Value"] = value; //
        return Model(calcfn, params);
    }
 
private:
    ModelEvaluator<ResultRef, Args...> m_evalfn;
 
    ModelCalculator<Result, Args...> m_calcfn;
 
    Data m_params;
};
 
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()));
 
    auto evalfn = [=](ResultRef res, const Args&... args)
    {
        for(auto i = 0; i < evalfns.size(); ++i)
            evalfns[i](res, args...);
    };
 
    Data params;
    for(auto const& model : models)
        params.add(model.params());
 
    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