fixed.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: BSD-2-Clause
 
#ifndef pRC_ALGORITHMS_OPTIMIZER_LINE_SEARCH_FIXED_H
#define pRC_ALGORITHMS_OPTIMIZER_LINE_SEARCH_FIXED_H
 
#include <prc/core/tensor/declarations.hpp>
#include <prc/core/value/float.hpp>
 
namespace pRC::Optimizer::LineSearch
{
    struct Fixed
    {
    private:
        static constexpr Float<> defaultStepSize()
        {
            return 1;
        }
 
    public:
        constexpr Fixed(Float<> const stepSize = defaultStepSize())
            : mStepSize(stepSize)
        {
        }
 
        template<class T = Float<>>
        constexpr decltype(auto) stepSize() const
        {
            return cast<T>(mStepSize);
        }
 
        template<IsTensor X, IsFloat T = Value<X>, class F, class FC>
            requires IsInvocable<F, X const &, X &> &&
            IsFloat<ResultOf<F, X const &, X &>> &&
            IsInvocable<FC, X const &> &&
            IsConvertible<ResultOf<FC, X const &>, X>
        constexpr auto operator()(X &x, ResultOf<F, X const &, X &> &f, X &g,
            typename ResultOf<ScalarProduct, X, X>::Type &d, F &&function,
            FC &&constraint, X const &p, T alpha = identity<T>(),
            T const alphaMin = zero<T>(),
            T const alphaMax = identity<T>(NumericLimits<T>::max())) const
        {
            x = x - stepSize<T>() * g;
            f = function(x, g);
 
            return stepSize<T>();
        }
 
        template<IsTensor X, IsFloat T = Value<X>, class F>
            requires IsInvocable<F, X const &, X &> &&
            IsFloat<ResultOf<F, X const &, X &>>
        constexpr auto operator()(X &x, ResultOf<F, X const &, X &> &f, X &g,
            typename ResultOf<ScalarProduct, X, X>::Type &d, F &&function,
            X const &p, T alpha = identity<T>(), T const alphaMin = zero<T>(),
            T const alphaMax = identity<T>(NumericLimits<T>::max())) const
        {
            return operator()(
                x, f, g, d, forward<F>(function),
                [](auto &&x) -> decltype(auto)
                {
                    return forward<decltype(x)>(x);
                },
                p, alpha, alphaMin, alphaMax);
        }
 
    private:
        Float<> const mStepSize;
    };
}
#endif // pRC_ALGORITHMS_OPTIMIZER_LINE_SEARCH_FIXED_H