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 <vector>
 
namespace hmap
{
 
template <typename T> struct Vec2
{
  T x, y; 
  Vec2() : x(0), y(0)
  {
  }
 
  Vec2(T x, T y) : x(x), y(y)
  {
  }
 
  Vec2(const std::vector<T> &vec) : x(0), y(0)
  {
    if (vec.size() != 2)
    {
      throw std::invalid_argument("Vector must contain exactly two elements.");
    }
    x = vec[0];
    y = vec[1];
  }
 
  bool operator==(const Vec2 &other_vec) const
  {
    return ((this->x == other_vec.x) && (this->y == other_vec.y));
  }
 
  bool operator!=(const Vec2 &other_vec) const
  {
    return ((this->x != other_vec.x) || (this->y != other_vec.y));
  }
 
  Vec2 &operator/=(const T value)
  {
    this->x /= value;
    this->y /= value;
    return *this;
  }
 
  Vec2 operator/(const Vec2 &other_vec) const
  {
    Vec2 out;
    out.x = this->x / other_vec.x;
    out.y = this->y / other_vec.y;
    return out;
  }
 
  Vec2 operator*(const Vec2 &other_vec) const
  {
    Vec2 out;
    out.x = this->x * other_vec.x;
    out.y = this->y * other_vec.y;
    return out;
  }
 
  Vec2 operator+(const Vec2 &other_vec) const
  {
    Vec2 out;
    out.x = this->x + other_vec.x;
    out.y = this->y + other_vec.y;
    return out;
  }
 
  Vec2 operator-(const Vec2 &other_vec) const
  {
    Vec2 out;
    out.x = this->x - other_vec.x;
    out.y = this->y - other_vec.y;
    return out;
  }
 
  Vec2 operator*(T scalar) const
  {
    return Vec2(x * scalar, y * scalar);
  }
 
  friend Vec2 operator*(T scalar, const Vec2 &vec)
  {
    return Vec2(scalar * vec.x, scalar * vec.y);
  }
 
  friend float dot(const Vec2 v1, const Vec2 v2)
  {
    return v1.x * v2.x + v1.y * v2.y;
  }
 
  T magnitude() const
  {
    return std::sqrt(x * x + y * y);
  }
 
  void normalize()
  {
    T mag = magnitude();
    if (mag > 0) // Avoid division by zero
    {
      x /= mag;
      y /= mag;
    }
  }
};
 
template <typename T> struct Vec3
{
  T x, y, z; 
  Vec3() : x(0), y(0), z(0)
  {
  }
 
  Vec3(T x, T y, T z) : x(x), y(y), z(z)
  {
  }
 
  Vec3(const std::vector<T> &vec) : x(0), y(0), z(0)
  {
    if (vec.size() != 3)
    {
      throw std::invalid_argument(
          "Vector must contain exactly three elements.");
    }
    x = vec[0];
    y = vec[1];
    z = vec[2];
  }
 
  bool operator==(const Vec3 &other_vec) const
  {
    return ((this->x == other_vec.x) && (this->y == other_vec.y) &&
            (this->z == other_vec.z));
  }
 
  bool operator!=(const Vec3 &other_vec) const
  {
    return ((this->x != other_vec.x) || (this->y != other_vec.y) ||
            (this->z != other_vec.z));
  }
 
  Vec3 &operator/=(const T value)
  {
    this->x /= value;
    this->y /= value;
    this->z /= value;
    return *this;
  }
 
  Vec3 operator/(const Vec3 &other_vec) const
  {
    Vec3 out;
    out.x = this->x / other_vec.x;
    out.y = this->y / other_vec.y;
    out.z = this->z / other_vec.z;
    return out;
  }
 
  Vec3 operator*(const Vec3 &other_vec) const
  {
    Vec3 out;
    out.x = this->x * other_vec.x;
    out.y = this->y * other_vec.y;
    out.z = this->z * other_vec.z;
    return out;
  }
 
  Vec3 operator+(const Vec3 &other_vec) const
  {
    Vec3 out;
    out.x = this->x + other_vec.x;
    out.y = this->y + other_vec.y;
    out.z = this->z + other_vec.z;
    return out;
  }
 
  Vec3 operator-(const Vec3 &other_vec) const
  {
    Vec3 out;
    out.x = this->x - other_vec.x;
    out.y = this->y - other_vec.y;
    out.z = this->z - other_vec.z;
    return out;
  }
 
  Vec3 operator*(T scalar) const
  {
    return Vec3(x * scalar, y * scalar, z * scalar);
  }
 
  friend Vec3 operator*(T scalar, const Vec3 &vec)
  {
    return Vec3(scalar * vec.x, scalar * vec.y, scalar * vec.z);
  }
 
  friend Vec3 cross(const Vec3 v1, const Vec3 v2)
  {
    Vec3 out;
    out.x = v1.y * v2.z - v1.z * v2.y;
    out.y = v1.z * v2.x - v1.x * v2.z;
    out.z = v1.x * v2.y - v1.y * v2.x;
    return out;
  }
 
  friend float dot(const Vec3 v1, const Vec3 v2)
  {
    return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
  }
 
  T magnitude() const
  {
    return std::sqrt(x * x + y * y + z * z);
  }
 
  void normalize()
  {
    T mag = magnitude();
    if (mag > 0) // Avoid division by zero
    {
      x /= mag;
      y /= mag;
      z /= mag;
    }
  }
 
  T sum() const
  {
    return x + y + z;
  }
};
 
template <typename T> struct Vec4
{
  T a, b, c, d; 
  Vec4() : a(0), b(0), c(0), d(0)
  {
  }
 
  Vec4(T a, T b, T c, T d) : a(a), b(b), c(c), d(d)
  {
  }
 
  Vec4(const std::vector<T> &vec) : a(0), b(0), c(0), d(0)
  {
    if (vec.size() != 4)
    {
      throw std::invalid_argument("Vector must contain exactly four elements.");
    }
    a = vec[0];
    b = vec[1];
    c = vec[2];
    d = vec[3];
  }
 
  bool operator==(const Vec4 &other_vec) const
  {
    return ((this->a == other_vec.a) && (this->b == other_vec.b) &&
            (this->c == other_vec.c) && (this->d == other_vec.d));
  }
 
  bool operator!=(const Vec4 &other_vec) const
  {
    return ((this->a != other_vec.a) || (this->b != other_vec.b) ||
            (this->c != other_vec.c) || (this->d != other_vec.d));
  }
 
  Vec4 &operator/=(const T value)
  {
    this->a /= value;
    this->b /= value;
    this->c /= value;
    this->d /= value;
    return *this;
  }
 
  Vec4 operator/(const Vec4 &other_vec) const
  {
    Vec4 out;
    out.a = this->a / other_vec.a;
    out.b = this->b / other_vec.b;
    out.c = this->c / other_vec.c;
    out.d = this->d / other_vec.d;
    return out;
  }
 
  Vec4 operator*(const Vec4 &other_vec) const
  {
    Vec4 out;
    out.a = this->a * other_vec.a;
    out.b = this->b * other_vec.b;
    out.c = this->c * other_vec.c;
    out.d = this->d * other_vec.d;
    return out;
  }
 
  Vec4 operator+(const Vec4 &other_vec) const
  {
    Vec4 out;
    out.a = this->a + other_vec.a;
    out.b = this->b + other_vec.b;
    out.c = this->c + other_vec.c;
    out.d = this->d + other_vec.d;
    return out;
  }
 
  Vec4 operator-(const Vec4 &other_vec) const
  {
    Vec4 out;
    out.a = this->a - other_vec.a;
    out.b = this->b - other_vec.b;
    out.c = this->c - other_vec.c;
    out.d = this->d - other_vec.d;
    return out;
  }
 
  Vec4 operator*(T scalar) const
  {
    return Vec4(a * scalar, b * scalar, c * scalar, d * scalar);
  }
 
  friend Vec4 operator*(T scalar, const Vec4 &vec)
  {
    return Vec4(scalar * vec.a, scalar * vec.b, scalar * vec.c, scalar * vec.d);
  }
 
  Vec4<T> adjust(float da, float db, float dc, float dd)
  {
    return Vec4<T>(this->a + da, this->b + db, this->c + dc, this->d + dd);
  }
 
  friend float dot(const Vec4 v1, const Vec4 v2)
  {
    return v1.a * v2.a + v1.b * v2.b + v1.c * v2.c + v1.d * v2.d;
  }
};
 
template <typename T> struct Mat
{
  std::vector<T> vector; 
  Vec2<int> shape;       
  Mat(Vec2<int> shape) : shape(shape)
  {
    this->vector.resize(shape.x * shape.y);
  }
 
  T &operator()(int i, int j)
  {
    return this->vector[i * this->shape.y + j];
  }
 
  const T &operator()(int i, int j) const
  {
    return this->vector[i * this->shape.y + j];
  }
};
 
template <typename T> Vec3<T> normalized_vec3(T x, T y, T z)
{
  Vec3<T> v = Vec3<T>(x, y, z);
  v.normalize();
  return v;
}
 
} // namespace hmap