Extremum.h

Go to the documentation of this file.

#pragma once
 
#include <limits>
#include <optional>
#include <type_traits>
 
#include "storm/solver/OptimizationDirection.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;
 
    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;
 
    void reset();
 
   private:
    static bool const SupportsInfinity = std::numeric_limits<ValueType>::is_iec559;
 
    struct DefaultData {
        ValueType value;
        bool empty{true};
    };
 
    struct DataInfinity {
        ValueType constexpr baseValue() const {
            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();
            }
        }
        ValueType value{baseValue()};
    };
 
    std::conditional_t<SupportsInfinity, DataInfinity, DefaultData> data;
};
 
template<typename ValueType>
using Maximum = Extremum<storm::OptimizationDirection::Maximize, ValueType>;
template<typename ValueType>
using Minimum = Extremum<storm::OptimizationDirection::Minimize, ValueType>;
 
}  // namespace storm::utility