spectral.h

#ifndef DETAIL_SPECTRAL_H
#define DETAIL_SPECTRAL_H

#include <tuple>
#include "detail/basic.h"

namespace bf {
namespace detail {
namespace spectral {

template <typename Store>
unsigned 
minimum(const typename Store::pos_vector& pos, const Store& store)
{
    auto min = store.max();
    for (auto i : pos)
    {
        auto cnt = store.count(i);
        if (cnt < min)
            min = cnt;

        if (min == 0)
            break;
    }

    return min;
}

template <typename Store>
std::tuple<typename Store::size_type, bool, typename Store::pos_vector>
minima(const typename Store::pos_vector& pos, const Store& store)
{
    typedef std::tuple<
        typename Store::size_type
      , bool
      , typename Store::pos_vector
    > result_type;

    auto min = store.max();
    typename Store::pos_vector pos_min;
    for (auto i : pos)
    {
        auto cnt = store.count(i);

        if (cnt == min)
            pos_min.push_back(i);
        else if (cnt < min)
        {
            min = cnt;
            pos_min.clear();
            pos_min.push_back(i);
        }
    }

//    pos_min.shrink_to_fit();
    bool recurring = pos_min.size() > 1 || pos.size() == 1;

    return result_type{ min, recurring, pos_min };
}

template <typename T, typename Core>
void minimum_increase(const T& x, Core& core)
{
    auto pos = core.positions(x);
    for (auto i : std::get<2>(minima(pos, core.store)))
        core.store.increment(i);
}

template <typename T, typename Core1, typename Core2>
unsigned
recurring_minimum_count(const T& x, const Core1& core1, const Core2& core2)
{
    auto min = minima(core1.positions(x), core1.store);
    if (std::get<1>(min))
        return std::get<0>(min);

    auto min2 = minimum(core2.positions(x), core2.store);
    if (min2)
        return min2;

    return std::get<0>(min);
}

template <typename T, typename Core1, typename Core2>
void recurring_minimum_add(const T& x, Core1& core1, Core2& core2)
{
    auto pos = core1.positions(x);
    for (auto i : pos)
        core1.store.increment(i);

    auto min = minima(pos, core1.store);
    if (std::get<1>(min))
        return;

    pos = core2.positions(x);
    if (minimum(pos, core2.store))
        for (auto i : pos)
            core2.store.increment(i);
    else
        for (auto i : pos)
            core2.store.increment(i, std::get<0>(min));
}

template <typename T, typename Core1, typename Core2>
void recurring_minimum_remove(const T& x, Core1& core1, Core2& core2)
{
    auto pos = core1.positions(x);
    for (auto i : pos)
        core1.store.decrement(i);

    auto min = minima(pos, core1.store);
    if (std::get<1>(min))
        return;

    pos = core2.positions(x);
    typename Core2::store_type::size_type i = 0;
    while (i < pos.size())
    {
        if (core2.store.count(i) == 0)
            break;

        ++i;
    }

    if (i == pos.size())
        for (auto i : pos)
            core2.store.decrement(i);
}

} // namespace spectral
} // namespace detail
} // namespace bf

#endif