simple_solver.h

Go to the documentation of this file.

/*
 * Copyright 2021 MusicScience37 (Kenta Kabashima)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#pragma once
 
#include "num_collect/base/exception.h"
#include "num_collect/base/index_type.h"
#include "num_collect/base/precondition.h"
#include "num_collect/constants/zero.h"  // IWYU pragma: keep
#include "num_collect/logging/iterations/iteration_logger.h"
#include "num_collect/logging/logging_macros.h"
#include "num_collect/ode/concepts/formula.h"
#include "num_collect/ode/solver_base.h"
 
namespace num_collect::ode {

template <concepts::formula Formula>
class simple_solver : public solver_base<simple_solver<Formula>, Formula> {
public:
    using this_type = simple_solver<Formula>;

    using base_type = solver_base<simple_solver<Formula>, Formula>;
 
    using typename base_type::formula_type;
    using typename base_type::problem_type;
    using typename base_type::scalar_type;
    using typename base_type::variable_type;
 
    using base_type::base_type;
    using base_type::formula;
    using base_type::problem;

    void init(scalar_type time, const variable_type& variable) {
        time_ = time;
        variable_ = variable;
        steps_ = 0;
    }

    void step() {
        prev_variable_ = variable_;
        formula().step(time_, step_size_, prev_variable_, variable_);
        time_ += step_size_;
        ++steps_;
    }

    void configure_iteration_logger(
        logging::iterations::iteration_logger<this_type>& iteration_logger)
        const {
        iteration_logger.template append<index_type>(
            "Steps", &this_type::steps);
        iteration_logger.template append<scalar_type>("Time", &this_type::time);
        iteration_logger.template append<scalar_type>("StepSize",
            static_cast<scalar_type (this_type::*)() const>(
                &this_type::step_size));
    }

    [[nodiscard]] auto time() const -> scalar_type { return time_; }

    [[nodiscard]] auto variable() const -> const variable_type& {
        return variable_;
    }

    [[nodiscard]] auto step_size() const -> scalar_type { return step_size_; }

    [[nodiscard]] auto steps() const -> index_type { return steps_; }

    auto step_size(scalar_type val) -> this_type& {
        NUM_COLLECT_PRECONDITION(val > static_cast<scalar_type>(0),
            "Step size must be a positive value.");
        step_size_ = val;
        return *this;
    }
 
private:
    variable_type variable_{};

    variable_type prev_variable_{};

    static constexpr auto default_step_size = static_cast<scalar_type>(1e-4);

    scalar_type step_size_{default_step_size};

    scalar_type time_{};

    index_type steps_{};
};
 
}  // namespace num_collect::ode