Vector.h

Go to the documentation of this file.

#ifndef INCLUDE_MOLASSEMBLER_TEMPLE_CONSTEXPR_VECTOR_H
#define INCLUDE_MOLASSEMBLER_TEMPLE_CONSTEXPR_VECTOR_H

#include "Molassembler/Temple/constexpr/Math.h"
#include "Molassembler/Temple/Stl17.h"

#include <array>

namespace Scine {
namespace Molassembler {
namespace Temple {

struct Vector {
  std::array<double, 3> data;

  constexpr Vector() : data({{0, 0, 0}}) {}
  constexpr Vector(std::array<double, 3> positions) : data(positions) {}
  constexpr Vector(double x, double y, double z) : data({{x, y, z}}) {}


  PURITY_WEAK constexpr double dot(const Vector& other) const noexcept {
    return (
      this->data[0] * other.data[0]
      + this->data[1] * other.data[1]
      + this->data[2] * other.data[2]
    );
  }

  PURITY_WEAK constexpr Vector cross(const Vector& other) const noexcept {
    return Vector {
      {{
        this -> data[1] * other.data[2] - this -> data[2] * other.data[1],
        this -> data[2] * other.data[0] - this -> data[0] * other.data[2],
        this -> data[0] * other.data[1] - this -> data[1] * other.data[0]
       }}
    };
  }

  PURITY_WEAK constexpr double norm() const {
    return Math::sqrt(
      this -> data[0] * this -> data[0]
      + this -> data[1] * this -> data[1]
      + this -> data[2] * this -> data[2]
    );
  }

  PURITY_WEAK constexpr Vector operator + (const Vector& other) const noexcept {
    return Vector {
      {{
        this->data[0] + other.data[0],
        this->data[1] + other.data[1],
        this->data[2] + other.data[2]
      }}
    };
  }

  PURITY_WEAK constexpr Vector operator - (const Vector& other) const noexcept {
    return Vector {
      {{
        this->data[0] - other.data[0],
        this->data[1] - other.data[1],
        this->data[2] - other.data[2]
      }}
    };
  }

  PURITY_WEAK constexpr Vector operator * (const double constant) const noexcept {
    return Vector {
      {{
        constant * this->data[0],
        constant * this->data[1],
        constant * this->data[2]
      }}
    };
  }

  PURITY_WEAK constexpr Vector operator / (const double constant) const {
    if(constant == 0) {
      throw "Constexpr::Vector divided by zero!";
    }

    return Vector {
      {{
        this->data[0] / constant,
        this->data[1] / constant,
        this->data[2] / constant
      }}
    };
  }

  PURITY_WEAK constexpr Vector operator - () const noexcept {
    return Vector {
      {{
        - this -> data[0],
        - this -> data[1],
        - this -> data[2]
      }}
    };
  }
};

PURITY_WEAK constexpr double angle(const Vector& a, const Vector& b) {
  return Math::acos(
    Stl17::clamp(
      a.dot(b) / (
        a.norm() * b.norm()
      ),
      -1.0,
      1.0
    )
  );
}

} // namespace Temple
} // namespace Molassembler
} // namespace Scine

#endif