algebra.hpp

Go to the documentation of this file.

/* Copyright (c) 2023 Otto Link. Distributed under the terms of the GNU General
   Public License. The full license is in the file LICENSE, distributed with
   this software. */
 
#pragma once
#include <cmath>
#include <stdexcept>
#include <string>
#include <vector>
 
#include <glm/glm.hpp>
 
namespace hmap
{
 
void to_csv(const std::vector<glm::vec3> &xyz, const std::string &fname);
 
// --- For unordered_map
 
// for glm::ivec2 map
struct IVec2Hash
{
  size_t operator()(const glm::ivec2 &v) const noexcept
  {
    return std::hash<int>()(v.x) ^ (std::hash<int>()(v.y) << 1);
  }
};
 
struct IVec2Eq
{
  bool operator()(const glm::ivec2 &a, const glm::ivec2 &b) const noexcept
  {
    return a == b;
  }
};
 
// for glm::ivec4 map
struct IVec4Hash
{
  std::size_t operator()(const glm::ivec4 &v) const noexcept
  {
    std::size_t h = 0;
    h ^= std::hash<int>{}(v.x) + 0x9e3779b9 + (h << 6) + (h >> 2);
    h ^= std::hash<int>{}(v.y) + 0x9e3779b9 + (h << 6) + (h >> 2);
    h ^= std::hash<int>{}(v.z) + 0x9e3779b9 + (h << 6) + (h >> 2);
    h ^= std::hash<int>{}(v.w) + 0x9e3779b9 + (h << 6) + (h >> 2);
    return h;
  }
};
 
struct IVec4Eq
{
  bool operator()(const glm::ivec4 &a, const glm::ivec4 &b) const noexcept
  {
    return a == b;
  }
};
 
inline glm::vec4 adjust(const glm::vec4 &v,
                        float            dx,
                        float            dy,
                        float            dz,
                        float            dw)
{
  return glm::vec4{v.x + dx, v.y + dy, v.z + dz, v.w + dw};
}
 
inline glm::vec4 adjust(const glm::vec4 &v, float dr)
{
  return glm::vec4{v.x - dr, v.y + dr, v.z - dr, v.w + dr};
}
 
template <typename T> struct Mat
{
  std::vector<T> vector; 
  glm::ivec2 shape;      
  Mat() = default;
 
  Mat(glm::ivec2 shape) : shape(shape)
  {
    this->vector.resize(shape.x * shape.y);
  }
 
  Mat(glm::ivec2 shape, T value) : shape(shape)
  {
    this->vector.resize(shape.x * shape.y);
    std::fill(this->vector.begin(), this->vector.end(), value);
  }
 
  T &operator()(int i, int j)
  {
    return this->vector[j * this->shape.x + i];
  }
 
  const T &operator()(int i, int j) const
  {
    return this->vector[j * this->shape.x + i];
  }
 
  T &operator()(glm::ivec2 ij)
  {
    return this->vector[ij.y * this->shape.x + ij.x];
  }
 
  const T &operator()(glm::ivec2 ij) const
  {
    return this->vector[ij.y * this->shape.x + ij.x];
  }
};
 
} // namespace hmap