tensor_index_tp.hpp

Go to the documentation of this file.

// --------------------------------------------------------------------------
//
// Copyright (C) 2025-present by Pablo Antolin
//
// This file is part of the QUGaR library.
//
// SPDX-License-Identifier:    MIT
//
// --------------------------------------------------------------------------
 
#ifndef QUGAR_LIBRARY_TENSOR_INDEX_TP_HPP
#define QUGAR_LIBRARY_TENSOR_INDEX_TP_HPP
 
 
#include <qugar/vector.hpp>
 
 
#include <array>
#include <cassert>
#include <cstddef>
#include <functional>
#include <type_traits>
 
namespace qugar {
 
template<int dim> class TensorIndexTP;
 
template<int dim> class TensorSizeTP : public Vector<int, dim>
{
public:
 
 
  TensorSizeTP();
 
  explicit TensorSizeTP(const int size);
 
  explicit TensorSizeTP(const Vector<int, dim> &sizes);
 
  explicit TensorSizeTP(const TensorIndexTP<dim> &sizes);
 
 
  const Vector<int, dim> &as_Vector() const;
 
  Vector<int, dim> &as_Vector();
 
  [[nodiscard]] int size() const;
 
  [[nodiscard]] bool operator==(const TensorSizeTP<dim> &rhs) const;
 
  [[nodiscard]] TensorSizeTP<dim> operator+(const TensorSizeTP<dim> &rhs) const;
};
 
template<int dim> class TensorIndexTP : public Vector<int, dim>
{
public:
 
 
  template<int aux_dim = dim>
    requires(aux_dim == dim && dim > 0)
  TensorIndexTP() : TensorIndexTP(0)
  {}
 
  template<int aux_dim = dim>
    requires(aux_dim == dim && dim == 0)
  TensorIndexTP()
  {}
 
  template<int aux_dim = dim>
    requires(aux_dim == dim && dim > 0)
  explicit TensorIndexTP(int ind) : Vector<int, dim>(ind)
  {}
 
  explicit TensorIndexTP(const Vector<int, dim> &indices);
 
  explicit TensorIndexTP(const TensorSizeTP<dim> &indices);
 
  template<int aux_dim = dim>
    requires(aux_dim == dim && dim > 0)
  TensorIndexTP(int flat_index, const TensorIndexTP<dim> &size)
  {
    int total_size = prod(size.as_Vector());
 
    // NOLINTNEXTLINE (readability-simplify-boolean-expr)
    assert(0 <= flat_index && flat_index < total_size);
 
    for (int dir = dim - 1; dir >= 0; --dir) {
      total_size /= size(dir);
      const auto ind = flat_index / total_size;
      this->operator()(dir) = ind;
      flat_index -= ind * total_size;
    }
  }
 
  template<int aux_dim = dim>
    requires(aux_dim == dim && dim > 0)
  TensorIndexTP(int flat_index, const TensorSizeTP<dim> &size) : TensorIndexTP(flat_index, TensorIndexTP(size))
  {}
 
  template<typename... T>
    requires(dim > 1 && sizeof...(T) == dim && std::conjunction_v<std::is_same<int, T>...>)
  explicit TensorIndexTP(T... indices) : TensorIndexTP(Vector<int, dim>{ indices... })
  {}
 
 
  const Vector<int, dim> &as_Vector() const
  {
    // For an unknown reason, the linker (llvm 17) doesn't find the symbol if the implementation is moved to the .cpp
    // file
    return dynamic_cast<const Vector<int, dim> &>(*this);
  }
 
  Vector<int, dim> &as_Vector();
 
  template<typename S> [[nodiscard]] int flat(const S &size) const;
 
  [[nodiscard]] bool operator==(const TensorIndexTP<dim> &rhs) const;
 
  [[nodiscard]] bool operator!=(const TensorIndexTP<dim> &rhs) const;
 
  [[nodiscard]] bool operator<(const TensorIndexTP<dim> &rhs) const;
 
  template<int aux_dim = dim>
    requires(aux_dim == dim && dim > 1)
  TensorIndexTP<dim - 1> remove_component(int comp) const;
 
  [[nodiscard]] std::size_t hash() const;
};
 
}// namespace qugar
 
namespace std {
template<int dim> struct hash<qugar::TensorIndexTP<dim>>
{
  size_t operator()(const qugar::TensorIndexTP<dim> &tid) const noexcept { return tid.hash(); }
};
}// namespace std
 
namespace qugar {
 
template<int dim> class TensorIndexRangeTP
{
public:
  TensorIndexRangeTP(const TensorIndexTP<dim> &lower_bound, const TensorIndexTP<dim> &upper_bound);
 
  explicit TensorIndexRangeTP(const TensorIndexTP<dim> &upper_bound);
 
  explicit TensorIndexRangeTP(const TensorSizeTP<dim> &upper_bound);
 
  explicit TensorIndexRangeTP(int upper_bound);
 
  [[nodiscard]] TensorSizeTP<dim> get_sizes() const;
 
  [[nodiscard]] int size() const;
 
  [[nodiscard]] std::array<TensorIndexRangeTP<dim>, 2> split() const;
 
 
  class Iterator
  {
  public:
    Iterator(const TensorIndexTP<dim> &index,
      const TensorIndexTP<dim> &lower_bound,
      const TensorIndexTP<dim> &upper_bound);
 
    [[nodiscard]] const TensorIndexTP<dim> &operator*() const;
 
    [[nodiscard]] const TensorIndexTP<dim> *operator->() const;
 
    [[nodiscard]] int flat() const;
 
    Iterator &operator++();
 
    // NOLINTNEXTLINE (cert-dcl21-cpp) // Check deprecated.
    Iterator operator++(int);
 
    [[nodiscard]] bool operator==(const Iterator &rhs) const;
 
    [[nodiscard]] bool operator!=(const Iterator &rhs) const;
 
  private:
    TensorIndexTP<dim> index_;
    TensorIndexTP<dim> lower_bound_;
    TensorIndexTP<dim> upper_bound_;
  };
 
  Iterator cbegin() const;
 
  Iterator begin() const;
 
  Iterator cend() const;
 
  Iterator end() const;
 
  [[nodiscard]] const TensorIndexTP<dim> &get_lower_bound() const;
 
  [[nodiscard]] const TensorIndexTP<dim> &get_upper_bound() const;
 
  [[nodiscard]] bool is_in_range(const TensorIndexTP<dim> &index) const;
 
  [[nodiscard]] bool is_in_range(int index) const;
 
private:
  TensorIndexTP<dim> lower_bound_;
  TensorIndexTP<dim> upper_bound_;
};
 
 
}// namespace qugar
 
#endif// QUGAR_LIBRARY_TENSOR_INDEX_TP_HPP