stat.hpp

Go to the documentation of this file.

#ifndef _stat_H_
#define _stat_H_
 
#include "Type.hpp"
#include "cytnx_error.hpp"
 
#include "Tensor.hpp"
#include <algorithm>
#include <iostream>
 
#ifdef BACKEND_TORCH
#else
 
  #include "backend/Storage.hpp"
namespace cytnx {
  namespace stat {
 
    class Histogram {
     public:
      double min;
      double max;
      uint64_t bins;
      cytnx::Storage vars;
      cytnx::Storage x;
 
      // std::vector<double> vars;
      // std::vector<double> x;
 
      double total_count;
 
      Histogram(const unsigned long long &Nbins, const double &min_val, const double &max_val);
 
      Histogram(const Histogram &rhs) {
        this->min = rhs.min;
        this->max = rhs.max;
        this->bins = rhs.bins;
        this->vars = rhs.vars.clone();
        this->x = rhs.x.clone();
        this->total_count = rhs.total_count;
      }
 
      Histogram &operator=(const Histogram &rhs) {
        this->min = rhs.min;
        this->max = rhs.max;
        this->bins = rhs.bins;
        this->vars = rhs.vars.clone();
        this->x = rhs.x.clone();
        this->total_count = rhs.total_count;
        return *this;
      }
 
      void clear_vars() {
        total_count = 0;
        memset(this->vars.data(), 0, sizeof(double) * this->vars.size());
      }
 
      template <class T>
      void accumulate(const std::vector<T> &data) {
        std::vector<T> tmp = data;
        std::sort(tmp.begin(), tmp.end());
 
        uint64_t cntr = 0;
        double curr_x = 0;
        double dx = double(max - min) / bins;
 
        // for each elem in data, compare
        for (unsigned long long i = 0; i < tmp.size(); i++) {
          while (cntr <= this->bins) {
            if (tmp[i] < curr_x) {
              if (cntr) {
                vars.at<double>(cntr - 1) += 1;
                total_count += 1;
              }
              break;
            }
            cntr++;
            curr_x = cntr * dx;
          }
        }
      }
 
      void normalize();
      void print() const;
 
      const Storage &get_x() const {
        // get x
        return this->x;
      }
      Storage &get_x() {
        // get x
        return this->x;
      }
 
      cytnx_uint64 size() { return this->x.size(); }
 
    };  // class histogram
 
    class Histogram2d {
     public:
      double minx, miny;
      double maxx, maxy;
      uint64_t binx, biny;
      cytnx::Storage vars;
      cytnx::Storage x;
      cytnx::Storage y;
 
      // std::vector<double> vars;
      // std::vector<double> x;
 
      double total_count;
 
      Histogram2d(const unsigned long long &Nbinx, const unsigned long long &Nbiny,
                  const double &min_x, const double &max_x, const double &min_y,
                  const double &max_y);
 
      Histogram2d(const Histogram2d &rhs) {
        this->minx = rhs.minx;
        this->maxx = rhs.maxx;
        this->miny = rhs.miny;
        this->maxy = rhs.maxy;
        this->binx = rhs.binx;
        this->biny = rhs.biny;
        this->vars = rhs.vars.clone();
        this->x = rhs.x.clone();
        this->y = rhs.y.clone();
        this->total_count = rhs.total_count;
      }
 
      Histogram2d &operator=(const Histogram2d &rhs) {
        this->minx = rhs.minx;
        this->maxx = rhs.maxx;
        this->miny = rhs.miny;
        this->maxy = rhs.maxy;
        this->binx = rhs.binx;
        this->biny = rhs.biny;
        this->vars = rhs.vars.clone();
        this->x = rhs.x.clone();
        this->y = rhs.y.clone();
        this->total_count = rhs.total_count;
        return *this;
      }
 
      void clear_vars() {
        total_count = 0;
        memset(this->vars.data(), 0, sizeof(double) * this->vars.size());
      }
 
      template <class T>
      void accumulate(const std::vector<T> &data_x, const std::vector<T> &data_y) {
        //[not fin!]
        cytnx_error_msg(
          data_x.size() != data_y.size(),
          "[ERROR][Histogram2d::accumulate] data_x and data_y should have same size!%s", "\n");
 
        double dx = double(maxx - minx) / binx;
        double dy = double(maxy - miny) / biny;
 
        unsigned int nx, ny;
 
        // for each elem in data, compare
        for (unsigned long long i = 0; i < data_x.size(); i++) {
          nx = floor(data_x[i] / dx);
          ny = floor(data_y[i] / dy);
          vars.at<double>(ny * binx + nx) += 1;
          total_count += 1;
        }
      }
 
      void normalize();
      void print() const;
 
      const Storage &get_x() const {
        // get x
        return this->x;
      }
      Storage &get_x() {
        // get x
        return this->x;
      }
 
      const Storage &get_y() const {
        // get y
        return this->y;
      }
      Storage &get_y() {
        // get y
        return this->y;
      }
 
      std::vector<cytnx_uint64> size() {
        return std::vector<cytnx_uint64>({this->x.size(), this->y.size()});
      }
 
    };  // class histogram
 
    // function, statistical:
    // class Boostrap{
 
    //};//class bootstrap
 
  }  // namespace stat
}  // namespace cytnx
 
#endif  // BACKEND_TORCH
 
#endif