iteration.hpp

// SPDX-FileCopyrightText: 2017 - 2026 The Ginkgo authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef GKO_PUBLIC_CORE_STOP_ITERATION_HPP_
#define GKO_PUBLIC_CORE_STOP_ITERATION_HPP_
 
 
#include <ginkgo/core/base/abstract_factory.hpp>
#include <ginkgo/core/stop/combined.hpp>
#include <ginkgo/core/stop/criterion.hpp>
 
 
namespace gko {
namespace stop {
 
class Iteration : public Criterion {
public:
    GKO_CREATE_FACTORY_PARAMETERS(parameters, Factory)
    {
        size_type max_iters{0};
 
        parameters_type& with_max_iters(size_type value)
        {
            this->max_iters = value;
            return *this;
        }
    };
    GKO_ENABLE_CRITERION_FACTORY(Iteration, parameters, Factory);
    GKO_ENABLE_BUILD_METHOD(Factory);
 
protected:
    bool check_impl(uint8 stoppingId, bool setFinalized,
                    array<stopping_status>* stop_status, bool* one_changed,
                    const Updater& updater) override;
 
    explicit Iteration(std::shared_ptr<const gko::Executor> exec)
        : Criterion(std::move(exec))
    {}
 
    explicit Iteration(const Factory* factory, const CriterionArgs& args)
        : Criterion(factory->get_executor()),
          parameters_{factory->get_parameters()}
    {}
};
 
 
deferred_factory_parameter<const Iteration::Factory> max_iters(size_type count);
 
 
deferred_factory_parameter<const CriterionFactory> min_iters(
    size_type count,
    deferred_factory_parameter<const CriterionFactory> criterion);
 
 
template <typename... Args>
std::enable_if_t<sizeof...(Args) >= 2,
                 deferred_factory_parameter<const CriterionFactory>>
min_iters(size_type count, Args&&... criteria)
{
    std::vector<deferred_factory_parameter<const CriterionFactory>>
        criterion_vec{std::forward<Args>(criteria)...};
    return min_iters(count, Combined::build().with_criteria(criterion_vec));
}
 
 
}  // namespace stop
}  // namespace gko
 
 
#endif  // GKO_PUBLIC_CORE_STOP_ITERATION_HPP_