index_range.h

Go to the documentation of this file.

/* 
* Copyright (C) 2020-2026 MEmilio
*
* Authors: René Schmieding
*
* Contact: Martin J. Kuehn <Martin.Kuehn@DLR.de>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef MIO_UTILS_INDEX_RANGE_H_
#define MIO_UTILS_INDEX_RANGE_H_
 
#include "memilio/utils/index.h"
#include "memilio/utils/stl_util.h"
 
namespace mio
{
 
template <class MultiIndex>
class MultiIndexIterator
{
public:
    using iterator_category = std::forward_iterator_tag;
    using value_type        = MultiIndex;
    using reference         = value_type;
    using pointer           = void;
    using difference_type   = std::ptrdiff_t;
 
    MultiIndexIterator()
        : m_index(MultiIndex::Zero())
        , m_dims(MultiIndex::Zero())
    {
    }
 
    MultiIndexIterator(value_type index, reference dimensions)
        : m_index(std::move(index))
        , m_dims(std::move(dimensions))
    {
    }
 
    reference operator*() const
    {
        return m_index;
    }
 
    MultiIndexIterator& operator++()
    {
        if constexpr (MultiIndex::size > 0) {
            increment_index();
        }
        return *this;
    }
 
    MultiIndexIterator operator++(int)
    {
        auto retval = *this;
        ++(*this);
        return retval;
    }
 
    bool operator==(const MultiIndexIterator& other) const
    {
        return m_index == other.m_index;
    }
 
    bool operator!=(const MultiIndexIterator& other) const
    {
        return !(*this == other);
    }
 
private:
    template <size_t I = MultiIndex::size - 1>
    inline void increment_index()
    {
        assert(mio::get<I>(m_dims).get() > 0 && "All dimensions must be positive.");
        assert(mio::get<I>(m_index) < mio::get<I>(m_dims) && "Index out of bounds.");
 
        if constexpr (I > 0) {
            // increment first, then do a carry-over if necessary
            ++mio::get<I>(m_index);
            if (mio::get<I>(m_index) == mio::get<I>(m_dims)) {
                mio::get<I>(m_index) = mio::get<I>(m_index).Zero();
                increment_index<I - 1>();
            }
        }
        else {
            ++mio::get<0>(m_index);
            // no carry check for the most significant index
        }
    }
    value_type m_index; 
    value_type m_dims; 
};
 
template <class... Categories>
MultiIndexIterator<Index<Categories...>> begin(Index<Categories...> dimensions)
{
    return {Index<Categories...>::Zero(), std::move(dimensions)};
}
 
template <class... Categories>
MultiIndexIterator<Index<Categories...>> end(Index<Categories...> dimensions)
{
    // set end to the first invalid index that is reached by increments of 1,
    // i.e. 0 everywhere except for the most significant index (position 0),
    // which is set to its dimension
    auto end = Index<Categories...>::Zero();
    if constexpr (Index<Categories...>::size > 0) {
        mio::get<0>(end) = mio::get<0>(dimensions);
    }
    return {end, dimensions};
}
 
template <class... Categories>
Range<MultiIndexIterator<Index<Categories...>>> make_index_range(Index<Categories...> dimensions)
{
    return {begin(dimensions), end(dimensions)};
}
 
} // namespace mio
 
#endif // MIO_UTILS_INDEX_RANGE_H_