OccupancySpectrum.hpp

// Copyright 2021 Arnaud Becheler    <abechele@umich.edu>
 
/*********************************************************************** * This program is free software; you can
 *redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free
 *Software Foundation; either version 2 of the License, or    * (at your option) any later version. *
 *                                                                      *
 ***************************************************************************/
 
#ifndef __OCCUPANCY_SPECTRUM_CLASS_H_INCLUDED__
#define __OCCUPANCY_SPECTRUM_CLASS_H_INCLUDED__
 
#include <random>
#include <utility> // std::forward, std::move
#include <vector>
 
namespace quetzal
{
namespace coalescence
{
namespace occupancy_spectrum
{
class OccupancySpectrum
{
  private:
    using occupancy_spectrum_type = std::vector<int>;
    occupancy_spectrum_type M_j;
    int k;
    int N;
    bool test_number_of_balls_conservation()
    {
        int sum = 0;
        for (int i = 0; i < this->M_j.size(); ++i)
        {
            assert(this->M_j.at(i) >= 0);
            sum += i * (this->M_j.at(i));
        }
        return (sum == this->k);
    }
    bool test_number_of_urns_conservation()
    {
        int sum = 0;
        for (int i = 0; i < this->M_j.size(); ++i)
        {
            assert(this->M_j.at(i) >= 0);
            sum += this->M_j.at(i);
        }
        return (sum == this->N);
    }
 
  public:
    using value_type = typename occupancy_spectrum_type::value_type;
    using iterator = typename occupancy_spectrum_type::iterator;
    using const_iterator = typename occupancy_spectrum_type::const_iterator;
    OccupancySpectrum(std::vector<int> const &v, int k, int N) : M_j(v), k(k), N(N)
    {
        assert(this->N >= 0);
        assert(this->k >= 0);
        assert(test_number_of_balls_conservation());
        assert(test_number_of_urns_conservation());
    }
    OccupancySpectrum(std::vector<int> &&v, int k, int N) : M_j(std::move(v)), k(k), N(N)
    {
        assert(this->N >= 0);
        assert(this->k >= 0);
        assert(test_number_of_balls_conservation());
        assert(test_number_of_urns_conservation());
    }
    OccupancySpectrum() = delete;
    OccupancySpectrum(const OccupancySpectrum &other) = default;
    OccupancySpectrum(OccupancySpectrum &&other) noexcept : M_j(std::move(other.M_j)), N(other.N), k(other.k)
    {
        assert(this->N >= 0);
        assert(this->k >= 0);
        assert(test_number_of_balls_conservation());
        assert(test_number_of_urns_conservation());
    }
    OccupancySpectrum &operator=(const OccupancySpectrum &other)
    {
        OccupancySpectrum otherCopy(other);
        this->M_j = std::move(otherCopy.M_j);
        this->N = otherCopy.N;
        this->k = otherCopy.k;
        return *this;
    }
    OccupancySpectrum &operator=(OccupancySpectrum &&other)
    {
        this->M_j = std::move(other.M_j);
        this->N = other.N;
        this->k = other.k;
        return *this;
    }
    iterator begin()
    {
        return M_j.begin();
    }
    iterator end()
    {
        return M_j.end();
    }
    const_iterator begin() const
    {
        return M_j.begin();
    }
    const_iterator end() const
    {
        return M_j.end();
    }
    const_iterator cbegin() const
    {
        return M_j.cbegin();
    }
    const_iterator cend() const
    {
        return M_j.cend();
    }
    void erase(iterator first, iterator last)
    {
        M_j.erase(first, last);
    }
    bool empty() const
    {
        return M_j.empty();
    }
}; // end class OccupancySpectrum
} // end namespace occupancy_spectrum
} // end namespace coalescence
} // end namespace quetzal
 
#endif