monolish_view_tensor_dense.hpp

Go to the documentation of this file.

#pragma once
#include "./monolish_logger.hpp"
#include <cassert>
#include <exception>
#include <fstream>
#include <iostream>
#include <iterator>
#include <memory>
#include <omp.h>
#include <stdexcept>
#include <string>
#include <vector>
 
#if USE_SXAT
#undef _HAS_CPP17
#endif
#include <random>
#if USE_SXAT
#define _HAS_CPP17 1
#endif
 
#if defined USE_MPI
#include <mpi.h>
#endif
 
namespace monolish {
template <typename Float> class vector;
 
namespace matrix {
template <typename Float> class Dense;
template <typename Float> class CRS;
template <typename Float> class LinearOperator;
} // namespace matrix
 
namespace tensor {
template <typename Float> class tensor_Dense;
} // namespace tensor
 
template <typename TYPE, typename Float> class view_tensor_Dense {
private:
  TYPE &target;
  Float *target_data;
  size_t first;
  size_t last;
  size_t range;
 
  std::vector<size_t> shape;
 
public:
  view_tensor_Dense(vector<Float> &x, const size_t start,
                    const std::vector<size_t> &shape_)
      : target(x) {
    first = start;
    shape = shape_;
    range = calc_range();
    last = start + range;
    target_data = x.data();
  }
 
  view_tensor_Dense(matrix::Dense<Float> &A, const size_t start,
                    const std::vector<size_t> &shape_)
      : target(A) {
    first = start;
    shape = shape_;
    range = calc_range();
    last = start + range;
    target_data = A.data();
  }
 
  view_tensor_Dense(tensor::tensor_Dense<Float> &A, const size_t start,
                    const std::vector<size_t> &shape_)
      : target(A) {
    first = start;
    shape = shape_;
    range = calc_range();
    last = start + range;
    target_data = A.data();
  }
 
  view_tensor_Dense(view_tensor_Dense<vector<Float>, Float> &x,
                    const size_t start, const std::vector<size_t> &shape_)
      : target(x) {
    first = x.get_first() + start;
    shape = shape_;
    range = calc_range();
    last = first + range;
    target_data = x.data();
  }
 
  view_tensor_Dense(view_tensor_Dense<matrix::Dense<Float>, Float> &x,
                    const size_t start, const std::vector<size_t> &shape_)
      : target(x) {
    first = x.get_first() + start;
    shape = shape_;
    range = calc_range();
    last = first + range;
    target_data = x.data();
  }
 
  view_tensor_Dense(view_tensor_Dense<tensor::tensor_Dense<Float>, Float> &x,
                    const size_t start, const std::vector<size_t> &shape_)
      : target(x) {
    first = x.get_first() + start;
    shape = shape_;
    range = calc_range();
    last = first + range;
    target_data = x.data();
  }
 
  [[nodiscard]] std::string type() const {
    return "view_tensor_Dense(" + target.type() + ")";
  }
 
  // communication
  // ///////////////////////////////////////////////////////////////////////////
  void send() const { target.send(); };
 
  void recv() { target.recv(); };
 
  [[nodiscard]] size_t calc_range() const {
    size_t N = 1;
    for (auto n : shape) {
      N *= n;
    }
    return N;
  };
 
  [[nodiscard]] std::vector<size_t> get_shape() const { return shape; }
 
  [[nodiscard]] size_t size() const { return range; }
 
  [[nodiscard]] size_t get_nnz() const { return range; }
 
  [[nodiscard]] size_t get_first() const { return first; }
 
  [[nodiscard]] size_t get_last() const { return last; }
 
  [[nodiscard]] size_t get_offset() const { return first; }
 
  [[nodiscard]] std::shared_ptr<Float> get_val() const { return target.val; }
 
  [[nodiscard]] size_t get_alloc_nnz() const { return target.get_alloc_nnz(); }
 
  void set_first(size_t i) { first = i; }
 
  void set_last(size_t i) {
    assert(first + i <= target.get_nnz());
    last = i;
  }
 
  [[nodiscard]] Float at(const size_t pos) const {
    return target.at(first + pos);
  }
 
  [[nodiscard]] Float at(const std::vector<size_t> &pos) const {
    return target.at(first + get_index(pos));
  }
 
  template <typename... Args>
  [[nodiscard]] Float at(const std::vector<size_t> &pos, const size_t dim,
                         const Args... args) const {
    std::vector<size_t> pos_copy = pos;
    pos_copy.push_back(dim);
    return this->at(pos_copy, args...);
  };
 
  template <typename... Args>
  [[nodiscard]] Float at(const size_t dim, const Args... args) const {
    std::vector<size_t> pos(1);
    pos[0] = dim;
    return this->at(pos, args...);
  };
 
  [[nodiscard]] Float at(const size_t pos) {
    return static_cast<const view_tensor_Dense<TYPE, Float> *>(this)->at(pos);
  };
 
  [[nodiscard]] Float at(const std::vector<size_t> &pos) {
    return static_cast<const view_tensor_Dense<TYPE, Float> *>(this)->at(pos);
  };
 
  template <typename... Args>
  [[nodiscard]] Float at(const std::vector<size_t> &pos, const Args... args) {
    return static_cast<const view_tensor_Dense *>(this)->at(pos, args...);
  };
 
  template <typename... Args>
  [[nodiscard]] Float at(const size_t dim, const Args... args) {
    return static_cast<const view_tensor_Dense *>(this)->at(dim, args...);
  };
 
  void insert(const size_t i, const Float Val) {
    target.insert(first + i, Val);
    return;
  };
 
  void insert(const std::vector<size_t> &pos, const Float Val) {
    target.insert(first + get_index(pos), Val);
    return;
  };
 
  [[nodiscard]] size_t get_device_mem_stat() const {
    return target.get_device_mem_stat();
  }
 
  [[nodiscard]] std::shared_ptr<bool> get_gpu_status() const {
    return target.get_gpu_status();
  }
 
  [[nodiscard]] Float *data() const { return target_data; }
 
  [[nodiscard]] Float *data() { return target_data; }
 
  [[nodiscard]] TYPE &get_target() const { return target; }
 
  [[nodiscard]] TYPE &get_target() { return target; }
 
  [[nodiscard]] Float *begin() const { return target_data + get_offset(); }
 
  [[nodiscard]] Float *begin() { return target_data + get_offset(); }
 
  [[nodiscard]] Float *end() const { return target_data + range; }
 
  [[nodiscard]] Float *end() { return target_data + range; }
 
  void print_all(bool force_cpu = false) const;
 
  void resize(std::vector<size_t> &shape_) {
    shape = shape_;
    range = calc_range();
    assert(first + range <= target.get_nnz());
    last = first + range;
  }
 
  void fill(Float value);
 
  void operator=(const tensor::tensor_Dense<Float> &tens);
 
  void operator=(const view_tensor_Dense<vector<Float>, Float> &tens);
 
  void operator=(const view_tensor_Dense<matrix::Dense<Float>, Float> &tens);
 
  void
  operator=(const view_tensor_Dense<tensor::tensor_Dense<Float>, Float> &tens);
 
  [[nodiscard]] Float &operator[](const size_t i) {
    if (target.get_device_mem_stat()) {
      throw std::runtime_error("Error, GPU vector cant use operator[]");
    }
    return target_data[i + first];
  }
 
  size_t get_index(const std::vector<size_t> &pos) const {
    if (pos.size() != this->shape.size()) {
      throw std::runtime_error("pos size should be same with the shape");
    }
    size_t ind = 0;
    for (auto i = 0; i < pos.size(); ++i) {
      ind *= this->shape[i];
      ind += pos[i];
    }
    return ind;
  }
 
  std::vector<size_t> get_index(const size_t pos) const {
    std::vector<size_t> ind(this->shape.size(), 0);
    auto pos_copy = pos;
    for (int i = (int)this->shape.size() - 1; i >= 0; --i) {
      ind[i] = pos_copy % this->shape[i];
      pos_copy /= this->shape[i];
    }
    return ind;
  }
 
  void diag_add(const Float alpha);
 
  void diag_sub(const Float alpha);
 
  void diag_mul(const Float alpha);
 
  void diag_div(const Float alpha);
 
  void diag_add(const vector<Float> &vec);
  void diag_add(const view1D<vector<Float>, Float> &vec);
  void diag_add(const view1D<matrix::Dense<Float>, Float> &vec);
  void diag_add(const view1D<tensor::tensor_Dense<Float>, Float> &vec);
 
  void diag_sub(const vector<Float> &vec);
  void diag_sub(const view1D<vector<Float>, Float> &vec);
  void diag_sub(const view1D<matrix::Dense<Float>, Float> &vec);
  void diag_sub(const view1D<tensor::tensor_Dense<Float>, Float> &vec);
 
  void diag_mul(const vector<Float> &vec);
  void diag_mul(const view1D<vector<Float>, Float> &vec);
  void diag_mul(const view1D<matrix::Dense<Float>, Float> &vec);
  void diag_mul(const view1D<tensor::tensor_Dense<Float>, Float> &vec);
 
  void diag_div(const vector<Float> &vec);
  void diag_div(const view1D<vector<Float>, Float> &vec);
  void diag_div(const view1D<matrix::Dense<Float>, Float> &vec);
  void diag_div(const view1D<tensor::tensor_Dense<Float>, Float> &vec);
};
} // namespace monolish