Extremum.h

Go to the documentation of this file.

#pragma once
 
#include <limits>
#include <optional>
#include <type_traits>
 
#include "storm/solver/OptimizationDirection.h"
#include "storm/utility/ExtendedNumber.h"
#include "storm/utility/NumberTraits.h"
 
namespace storm::utility {

template<storm::OptimizationDirection Dir, typename ValueType>
class Extremum {
   public:
    Extremum() = default;
    Extremum(ValueType const& value);
    Extremum(ValueType&& value);
    Extremum(Extremum const&) = default;
    Extremum(Extremum&&) = default;
    Extremum& operator=(Extremum const&) = default;
    Extremum& operator=(Extremum&&) = default;
    ~Extremum() = default;

    Extremum& operator=(ValueType const& value);

    Extremum& operator=(ValueType&& value);

    bool better(ValueType const& value) const;

    template<typename ExtendedType>
        requires(std::is_same_v<ExtendedType, storm::utility::ExtendedValueType<ValueType>> &&
                 !std::is_same_v<storm::utility::ExtendedValueType<ValueType>, ValueType>)
    bool better(ExtendedType const& value) const {
        if constexpr (storm::solver::minimize(Dir)) {
            return value < extremalValue;
        } else {
            static_assert(storm::solver::maximize(Dir));
            return value > extremalValue;
        }
    }

    bool operator&=(Extremum const& other);

    bool operator&=(Extremum&& other);

    bool operator&=(ValueType const& value);

    bool operator&=(ValueType&& value);

    bool empty() const;

    ValueType const& operator*() const;

    ValueType& operator*();

    std::optional<ValueType> getOptionalValue() const;

    storm::utility::ExtendedValueType<ValueType> const& getExtendedValue() const;

    template<typename ExtendedType>
        requires(std::is_same_v<ExtendedType, storm::utility::ExtendedValueType<ValueType>> &&
                 !std::is_same_v<storm::utility::ExtendedValueType<ValueType>, ValueType>)
    bool operator&=(ExtendedType const& value) {
        if (better(value)) {
            extremalValue = value;
            return true;
        }
        return false;
    }

    void reset();
 
   private:
    static bool const StoresPlainValues = std::is_same_v<storm::utility::ExtendedValueType<ValueType>, ValueType>;
    static_assert(!StoresPlainValues || std::numeric_limits<ValueType>::has_infinity, "NumberTraits claims an infinity that numeric_limits cannot provide.");

    static storm::utility::ExtendedValueType<ValueType> baseValue() {
        if constexpr (StoresPlainValues) {
            // Taken from numeric_limits rather than from storm::utility so that it stays a compile time constant.
            if constexpr (storm::solver::minimize(Dir)) {
                return std::numeric_limits<ValueType>::infinity();
            } else {
                static_assert(storm::solver::maximize(Dir));
                return -std::numeric_limits<ValueType>::infinity();
            }
        } else {
            if constexpr (storm::solver::minimize(Dir)) {
                return storm::utility::ExtendedValueType<ValueType>::infinity();
            } else {
                static_assert(storm::solver::maximize(Dir));
                return storm::utility::ExtendedValueType<ValueType>::negativeInfinity();
            }
        }
    }
 
    storm::utility::ExtendedValueType<ValueType> extremalValue{baseValue()};
};
 
template<typename ValueType>
using Maximum = Extremum<storm::OptimizationDirection::Maximize, ValueType>;
template<typename ValueType>
using Minimum = Extremum<storm::OptimizationDirection::Minimize, ValueType>;
 
}  // namespace storm::utility