web-dev-qa-db-fra.com

Comment créer un objet itérable de type plage de flotteurs?

Je veux créer une construction semblable à range dans c ++ , qui sera utilisée comme ceci:

for (auto i: range(5,9))
    cout << i << ' ';    // prints 5 6 7 8 

for (auto i: range(5.1,9.2))
    cout << i << ' ';    // prints 5.1 6.1 7.1 8.1 9.1

La gestion du cas entier est relativement simple:

template<typename T>
struct range 
{
    T from, to;
    range(T from, T to) : from(from), to(to) {}

    struct iterator
    {
        T current;
        T operator*() {  return current; }

        iterator& operator++()
        {
            ++current;
            return *this;
        }

        bool operator==(const iterator& other) { return current == other.current; }
        bool operator!=(const iterator& other) { return current != other.current; }
    };

    iterator begin() const { return iterator{ from }; }
    iterator end()   const { return iterator{ to }; }
};

Cependant, cela ne fonctionne pas dans le cas float, car la boucle standard basée sur une plage dans C++ vérifie si iter==end et non si iter <= end comme vous le feriez dans une boucle.

Existe-t-il un moyen simple de créer un objet itérable qui se comportera comme une plage correcte basée sur la boucle for sur floats?

c++templatesfloating-pointiteratorc++17
24
Erel Segal-Halevi

Voici ma tentative qui ne porte pas atteinte à la sémantique des itérateurs. Maintenant, chaque itérateur connaît sa valeur d'arrêt. L'itérateur se mettra à cette valeur en la dépassant. Tous les itérateurs de fin d'une plage avec _ to égaux comparent donc égaux.

template <typename T> 
struct range {
    T from, to;
    range(T from, T to): from(from), to(to) {}

    struct iterator {
        const T to; // iterator knows its bounds
        T current;

        T operator*() { return current; }

        iterator& operator++() { 
            ++current;
            if(current > to)
                // make it an end iterator
                // (current being exactly equal to 'current' of other end iterators)
                current = to;
            return *this;
        }

        bool operator==(const iterator& other) const // OT: note the const
        { return current == other.current; }
        // OT: this is how we do !=
        bool operator!=(const iterator& other) const { return !(*this == other); }
    };

    iterator begin() const { return iterator{to, from}; }
    iterator end()   const { return iterator{to, to}; }
};

Pourquoi est-ce mieux?

La solution de @JeJo repose sur l'ordre dans lequel vous comparez ces itérateurs, c'est-à-dire it != end Ou end != it. Mais, dans le cas d'une plage basée sur, elle est définie . Si vous utilisez cet engin dans un autre contexte, je conseille l'approche ci-dessus.

Alternativement, si sizeof(T) > sizeof(void*), il est judicieux de stocker un pointeur vers l'instance d'origine range (qui, dans le cas de l'intervalle-pour, persiste jusqu'à la fin) et de l'utiliser pour faire référence à un valeur unique T:

template <typename T> 
struct range {
    T from, to;
    range(T from, T to): from(from), to(to) {}

    struct iterator {
        range const* range;
        T current;

        iterator& operator++() { 
            ++current;
            if(current > range->to)
                current = range->to;
            return *this;
        }

        ...
    };

    iterator begin() const { return iterator{this, from}; }
    iterator end()   const { return iterator{this, to}; }
};

Ou cela pourrait être T const* const Pointant directement vers cette valeur, c'est à vous de décider.

OT: N'oubliez pas de faire les internes private pour les deux classes.

17
LogicStuff

Au lieu d'un objet de plage, vous pouvez utiliser un générateur (une coroutine utilisant co_yield). Bien qu'il ne soit pas dans la norme (mais prévu pour C++ 20), certains compilateurs l'implémentent déjà.

Voir: https://en.cppreference.com/w/cpp/language/coroutines

Avec MSVC, ce serait:

#include <iostream>
#include <experimental/generator>

std::experimental::generator<double> rangeGenerator(double from, double to) {
    for (double x=from;x <= to;x++)
    {
        co_yield x;
    }
}

int main()
{
    for (auto i : rangeGenerator(5.1, 9.2))
        std::cout << i << ' ';    // prints 5.1 6.1 7.1 8.1 9.1
}
14
P. PICARD

Existe-t-il un moyen simple de créer un objet itérable qui se comportera comme une boucle for correcte sur floats?

Le hack le plus simple † utiliserait les traits std::is_floating_point pour fournir un retour différent (c'est-à-dire iter <= end) dans le operator!= surcharge.

( Voir Live ) 

#include <type_traits>

bool operator!=(const iterator& other)
{
    if constexpr (std::is_floating_point_v<T>) return current <= other.current;
    return !(*this == other);
}

† Avertissement: même si cela fait l'affaire, cela rompt le sens de operator!= surcharge.

Solution alternative

La classe range entière peut être remplacée par une simple fonction dans laquelle les valeurs de la plage seront renseignées à l'aide de std::iota dans le conteneur standard std::vector.

Utilisez SFINE , pour restreindre l'utilisation de la fonction uniquement aux types valides. De cette façon, vous pouvez compter sur des implémentations standard et oublier les réinventions.

( Voir Live ) 

#include <iostream>
#include <type_traits>
#include <vector>      // std::vector
#include <numeric>     // std::iota
#include <cstddef>     // std::size_t
#include <cmath>       // std::modf

// traits for valid template types(integers and floating points)
template<typename Type>
using is_integers_and_floats = std::conjunction<
    std::is_arithmetic<Type>,
    std::negation<std::is_same<Type, bool>>,
    std::negation<std::is_same<Type, char>>,
    std::negation<std::is_same<Type, char16_t>>,
    std::negation<std::is_same<Type, char32_t>>,
    std::negation<std::is_same<Type, wchar_t>>
    /*, std::negation<std::is_same<char8_t, Type>> */ // since C++20
>;    

template <typename T>
auto ragesof(const T begin, const T end)
               -> std::enable_if_t<is_integers_and_floats<T>::value, std::vector<T>>
{
    if (begin >= end) return std::vector<T>{}; // Edge case to be considered
    // find the number of elements between the range
    const std::size_t size = [begin, end]() -> std::size_t 
    {
        const std::size_t diffWhole
                 = static_cast<std::size_t>(end) - static_cast<std::size_t>(begin);
        if constexpr (std::is_floating_point_v<T>) {
            double whole; // get the decimal parts of begin and end
            const double decimalBegin = std::modf(static_cast<double>(begin), &whole);
            const double decimalEnd   = std::modf(static_cast<double>(end), &whole);
            return decimalBegin <= decimalEnd ? diffWhole + 1 : diffWhole;
        }
        return diffWhole;
    }();
    // construct and initialize the `std::vector` with size
    std::vector<T> vec(size);
    // populates the range from [first, end)
    std::iota(std::begin(vec), std::end(vec), begin);
    return vec;
}

int main()
{
    for (auto i : ragesof( 5, 9 ))
        std::cout << i << ' ';    // prints 5 6 7 8
    std::cout << '\n';

    for (auto i : ragesof(5.1, 9.2))
            std::cout << i << ' '; // prints 5.1 6.1 7.1 8.1 9.1
}
9
JeJo

Une boucle ou un itérateur à virgule flottante doit généralement utiliser des types entiers pour contenir le nombre total d'itérations et le numéro de l'itération en cours, puis calculer la valeur d '"indice de boucle" utilisée dans la boucle en fonction de celles-ci et de la virgule flottante invariante de la boucle valeurs.

Par exemple:

for (int i=-10; i<=10; i++)
{
  double x = i/10.0;  // Substituting i*0.1 would be faster but less accurate
}

ou

for (int i=0; i<=16; i++)
{
  double x = ((startValue*(16-i))+(endValue*i))*(1/16);
}

Notez qu'il n'y a aucune possibilité d'erreurs d'arrondi affectant le nombre d'itérations. Ce dernier calcul est garanti pour donner un résultat correctement arrondi aux points limites; le calcul de startValue+i*(endValue-startValue) serait probablement plus rapide (puisque l'invariant de boucle (endValue-startValue) peut être hissé) mais peut être moins précis.

L'utilisation d'un itérateur entier avec une fonction pour convertir un entier en valeur à virgule flottante est probablement le moyen le plus robuste pour itérer sur une plage de valeurs à virgule flottante. Essayer d'itérer directement sur des valeurs à virgule flottante est beaucoup plus susceptible de générer des erreurs "off-by-one".

5
supercat