MCSamples.hpp

/*
 *  This file is part of the AiBO+ project
 *
 *  Copyright (C) 2005-2016 Csaba Kertész (csaba.kertesz@gmail.com)
 *
 *  AiBO+ 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.
 *
 *  AiBO+ is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.
 *
 */

#pragma once

#include "MCDefs.hpp"

#include <string>
#include <vector>

template <typename T>
class MCSampleStatistic;

namespace MC
{
template <typename T>
struct Statistic
{
typedef std::vector<MCSampleStatistic<T>* > List;
};
}

template <typename T>
struct MCSamples
{
public:
  explicit MCSamples(int size, MCSampleStatistic<T>& statistic) : Samples(nullptr), Weights(nullptr),
    Size(size < 2 ? 2 : size), Valid(false), LastElementIndex(-1)
  {
    AddStatistic(statistic);
  }

  MCSamples(const MCSamples& other) : Samples(nullptr), Weights(nullptr), Size(-1)
  {
    operator=(other);
  }

  virtual ~MCSamples()
  {
    ClearStatistics();
    delete[] Samples;
    Samples = nullptr;
    delete[] Weights;
    Weights = nullptr;
  }

  int GetSize() const
  {
    return Size;
  }

  inline bool IsEmpty() const
  {
    return LastElementIndex == -1;
  }

  bool IsValid() const
  {
    return Valid;
  }

  int GetSampleCount() const
  {
    if (unlikely(IsEmpty()))
    {
      return 0;
    }
    if (likely(Valid))
    {
      return Size;
    }
    return LastElementIndex+1;
  }

  void AddStatistic(MCSampleStatistic<T>& statistic)
  {
    Statistics.push_back(&statistic);
    statistic.SetSize(Size);
    statistic.SetStorage(Samples);
    statistic.Reset();
  }

  MCSampleStatistic<T>& GetDefaultStatistic()
  {
    return *Statistics[0];
  }

  MCSampleStatistic<T>* GetStatistic(const std::string& statistic_name)
  {
    for (auto& statistic : Statistics)
    {
      if (statistic->GetName() == statistic_name)
        return statistic;
    }
    return nullptr;
  }

  void RemoveStatistic(MCSampleStatistic<T>& statistic)
  {
    for (auto& statistic_iter : Statistics)
    {
      if (*statistic_iter == &statistic)
      {
        statistic_iter = Statistics.erase(statistic_iter);
        return;
      }
    }
  }

  void Reset()
  {
    Valid = false;
    LastElementIndex = -1;
    // Reset the statistics
    for (auto& statistic : Statistics)
    {
      statistic->Reset();
    }
  }

  void ClearStatistics()
  {
    for (auto& statistic : Statistics)
    {
      delete statistic;
    }
    Statistics.clear();
  }

  template <typename U>
  void AddValues(const U& container)
  {
    for (auto& value : container)
    {
      *this << (T)value;
    }
  }

  MCSamples<T>& operator=(const MCSamples<T>& other)
  {
    if (unlikely(Size != other.Size))
    {
      Size = other.Size;
      Valid = other.Valid;
      LastElementIndex = other.LastElementIndex;
      delete[] Samples;
      delete[] Weights;
    }
    // Clear the statistics
    ClearStatistics();
    // Clone the statistics
    for (auto& statistic : other.Statistics)
    {
      Statistics.push_back(statistic->Clone());
    }
    // Copy the sample cache
    if (other.Samples)
    {
      Samples = new T[Size];
      for (int i = 0; i < Size; ++i)
        Samples[i] = other.Samples[i];
      // Set the new storage references
      for (auto& statistic : Statistics)
        statistic->SetStorage(Samples);
    }
    // Copy the weight cache
    if (other.Weights)
    {
      Weights = new float[Size];
      for (int i = 0; i < Size; ++i)
        Weights[i] = other.Weights[i];
    }
    return *this;
  }

  bool operator==(const MCSamples<T>& other) const
  {
    if (Size != other.Size || !Samples || !Weights || !other.Samples || !other.Weights)
    {
      return false;
    }
    for (int i = 0; i < Size; ++i)
    {
      if (Samples[i] != other.Samples[i])
        return false;
    }
    for (int i = 0; i < Size; ++i)
    {
      if (Weights[i] != other.Weights[i])
        return false;
    }
    return true;
  }

  bool operator!=(const MCSamples<T>& other) const
  {
    return !operator==(other);
  }

  MCSamples<T>& operator<<(const T value)
  {
    return operator+=(value);
  }

  MCSamples<T>& operator<<(const std::vector<T>& container)
  {
    return operator+=(container);
  }


  MCSamples<T>& operator<<(const std::pair<const T, float>& value)
  {
    return operator+=(value);
  }

  const MCSamples<T> operator+(const T value) const
  {
    return MCSamples<T>(*this) += value;
  }

  const MCSamples<T> operator+(const std::pair<const T, float>& value) const
  {
    return MCSamples<T>(*this) += value;
  }

  MCSamples<T>& operator+=(const T value)
  {
    return operator+=(std::pair<T, float>(value, 0.0));
  }

  MCSamples<T>& operator+=(const std::vector<T>& container)
  {
    for (auto& value : container)
    {
      *this << (T)value;
    }
    return *this;
  }


  MCSamples<T>& operator+=(const std::pair<const T, float>& value)
  {
    // Delayed memory allocation
    if (!Samples)
    {
      Samples = new T[Size];
      Weights = new float[Size];
      // Set the new storage references
      for (auto& statistic : Statistics)
        statistic->SetStorage(Samples);
    }
    int OldIndex = LastElementIndex;
    int NewIndex;
    int NewerIndex;

    LastElementIndex++;
    NewIndex = LastElementIndex % Size;
    NewerIndex = (NewIndex+1) % Size;
    // Making the cache valid if possible
    if (unlikely(!Valid && LastElementIndex == Size-1))
      Valid = true;

    // Remove the old value from the statistics
    for (auto& statistic : Statistics)
    {
      if (likely(statistic->IsValid()))
        statistic->RemoveValue(Samples[NewIndex], Weights[NewIndex], Samples[NewerIndex], Weights[NewerIndex]);
    }

    // Replace the old sample with the new
    Samples[NewIndex] = value.first;
    Weights[NewIndex] = value.second;
    LastElementIndex = NewIndex;

    // Add the new value to the statistics
    for (auto& statistic : Statistics)
    {
      if (unlikely(OldIndex == -1))
      {
        statistic->AddValue(value.first, value.second, (T)0, MCFloatInfinity());
      } else {
        statistic->AddValue(value.first, value.second, Samples[OldIndex], Weights[OldIndex]);
      }
    }
    return *this;
  }

private:
  T* Samples;
  float* Weights;
  int Size;
  bool Valid;
  int LastElementIndex;
  typename MC::Statistic<T>::List Statistics;
};

template <typename T>
class MCSampleStatistic
{
  friend class MCSamples<T>;

public:

  MCSampleStatistic(const std::string& name) : Name(name), Size(0), Storage(nullptr), Samples(0), Valid(false)
  { }
  virtual ~MCSampleStatistic() { }

  inline const std::string& GetName() const
  {
    return Name;
  }

  inline bool IsValid()
  {
    return Valid;
  }

  virtual float GetResult() = 0;

  virtual MCSampleStatistic<T>* Clone() = 0;

protected:

  void AddValue(const T value, const float weight, const T prev_value, const float prev_weight)
  {
    // The value was not valid for the statistic -> Return
    if (!Add(value, weight, prev_value, prev_weight))
      return;

    if (unlikely(!Valid))
    {
      Samples++;
      if (Samples % Size == 0)
        Valid = true;
    }
  }

  void RemoveValue(const T value, const float weight, const T prev_value, const float prev_weight)
  {
    Remove(value, weight, prev_value, prev_weight);
  }

private:

  virtual bool Add(const T value, const float weight, const T prev_value, const float prev_weight) = 0;

  virtual void Remove(const T value, const float weight, const T next_value, const float next_weight) = 0;

public:

  virtual void SetSize(int size)
  {
    Size = size;
  }

  inline void SetStorage(const T* storage)
  {
    Storage = storage;
  }

  virtual void Reset()
  {
    Samples = 0;
    Valid = false;
  }

protected:
  std::string Name;
  int Size;
  const T* Storage;
  int Samples;
  bool Valid;
};