step_size_limits.h

Go to the documentation of this file.

/*
 * Copyright 2022 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 <limits>
 
#include "num_collect/base/concepts/real_scalar.h"
#include "num_collect/base/exception.h"
#include "num_collect/base/precondition.h"
#include "num_collect/constants/sqrt.h"
#include "num_collect/logging/logging_macros.h"
 
namespace num_collect::ode {
 
namespace impl {
 
template <base::concepts::real_scalar Scalar>
constexpr auto default_step_size_upper_limit = static_cast<Scalar>(1);
 
template <base::concepts::real_scalar Scalar>
constexpr Scalar default_step_size_lower_limit =
    constants::sqrt(std::numeric_limits<Scalar>::epsilon());
 
}  // namespace impl
 
template <base::concepts::real_scalar Scalar>
class step_size_limits {
public:
    using scalar_type = Scalar;
 
    constexpr step_size_limits() = default;
 
    [[nodiscard]] auto apply(scalar_type val) const -> scalar_type {
        if (val < lower_limit_) {
            return lower_limit_;
        }
        if (val > upper_limit_) {
            return upper_limit_;
        }
        return val;
    }
 
    [[nodiscard]] auto upper_limit() const -> const scalar_type& {
        return upper_limit_;
    }
 
    [[nodiscard]] auto lower_limit() const -> const scalar_type& {
        return lower_limit_;
    }
 
    auto upper_limit(const scalar_type& val) -> step_size_limits& {
        NUM_COLLECT_PRECONDITION(val > lower_limit_,
            "0 < lower_limit < upper_limit must be satisfied.");
        upper_limit_ = val;
        return *this;
    }
 
    auto lower_limit(const scalar_type& val) -> step_size_limits& {
        NUM_COLLECT_PRECONDITION(
            static_cast<scalar_type>(0) < val && val < upper_limit_,
            "0 < lower_limit < upper_limit must be satisfied.");
        lower_limit_ = val;
        return *this;
    }
 
private:
    scalar_type upper_limit_{impl::default_step_size_upper_limit<scalar_type>};
 
    scalar_type lower_limit_{impl::default_step_size_lower_limit<scalar_type>};
};
 
}  // namespace num_collect::ode