IOLink/cpp/_vector_8h_source.html

#pragma once


#include <iolink/IOLinkAPI.h>

#include <iolink/VectorX.h>


#include <array>

#include <cstdint>

#include <initializer_list>

#include <iostream>


namespace iolink

{


template <typename T, size_t N>

class Vector final

{

public:

  using ValueType = T;


  using Iterator = typename std::array<T, N>::iterator;

  using ConstIterator = typename std::array<T, N>::const_iterator;


  static Vector createUniform(ValueType value);


  Vector();


  Vector(std::initializer_list<ValueType> init);


  Vector(const VectorX<ValueType>& other);


  Vector(const VectorX<ValueType>& other, ValueType padding);


  template <typename U>

  explicit Vector(const Vector<U, N>& other)

  {

    for (size_t i = 0; i < N; ++i)

    {

      m_data[i] = static_cast<ValueType>(other[i]);

    }

  }


  Vector(const Vector& other) = default;

  Vector& operator=(const Vector& other) = default;


  Vector(Vector&& other) noexcept = default;

  Vector& operator=(Vector&& other) noexcept = default;


  size_t size() const { return N; }


  inline ValueType at(size_t index) const { return m_data[index]; }


  inline void setAt(size_t index, ValueType value) { m_data[index] = value; }


  inline ValueType operator[](size_t index) const { return m_data[index]; }

  inline ValueType& operator[](size_t index) { return m_data[index]; }


  double squaredLength() const;


  double length() const;


  void normalize();


  Iterator begin() noexcept { return m_data.begin(); }

  ConstIterator begin() const noexcept { return m_data.begin(); }

  Iterator end() noexcept { return m_data.end(); }

  ConstIterator end() const noexcept { return m_data.end(); }


  bool operator==(const Vector& other) const;

  bool operator!=(const Vector& other) const;


  std::string toString() const;


  // ==================== //

  // Arithmetic operators //

  // ==================== //


  Vector operator-() const;


  Vector& operator+=(const Vector& v);

  Vector& operator-=(const Vector& v);


  inline Vector operator+(const Vector& v) const { return Vector(*this) += v; }

  inline Vector operator-(const Vector& v) const { return Vector(*this) -= v; }


  Vector& operator*=(ValueType value);

  Vector& operator/=(ValueType value);


  inline Vector operator*(ValueType v) const { return Vector(*this) *= v; }

  inline Vector operator/(ValueType v) const { return Vector(*this) /= v; }


  friend inline Vector operator*(ValueType value, Vector v) { return v *= value; }


  ValueType dot(const Vector& v) const;


  Vector cross(const Vector& v) const;


  // ==================== //

  // GLSL style operators //

  // ==================== //


  Vector& operator*=(const Vector& v);

  Vector& operator/=(const Vector& v);


  inline Vector operator*(const Vector& v) const { return Vector(*this) *= v; }

  inline Vector operator/(const Vector& v) const { return Vector(*this) /= v; }


  bool operator<(const Vector& other) const;

  bool operator<=(const Vector& other) const;

  bool operator>(const Vector& other) const;

  bool operator>=(const Vector& other) const;


  operator VectorX<ValueType>() const;


private:

  std::array<ValueType, N> m_data;

};


template <typename T, size_t N>

inline std::ostream&

operator<<(std::ostream& os, const Vector<T, N>& v)

{

  os << v.toString();

  return os;

}


// ===================== //

// Template declarations //

// ===================== //


//------------

// 2D


extern template class IOLINK_API_IMPORT Vector<int8_t, 2>;

extern template class IOLINK_API_IMPORT Vector<int16_t, 2>;

extern template class IOLINK_API_IMPORT Vector<int32_t, 2>;

extern template class IOLINK_API_IMPORT Vector<int64_t, 2>;


extern template class IOLINK_API_IMPORT Vector<uint8_t, 2>;

extern template class IOLINK_API_IMPORT Vector<uint16_t, 2>;

extern template class IOLINK_API_IMPORT Vector<uint32_t, 2>;

extern template class IOLINK_API_IMPORT Vector<uint64_t, 2>;


extern template class IOLINK_API_IMPORT Vector<float, 2>;

extern template class IOLINK_API_IMPORT Vector<double, 2>;


//------------

// 3D


extern template class IOLINK_API_IMPORT Vector<int8_t, 3>;

extern template class IOLINK_API_IMPORT Vector<int16_t, 3>;

extern template class IOLINK_API_IMPORT Vector<int32_t, 3>;

extern template class IOLINK_API_IMPORT Vector<int64_t, 3>;


extern template class IOLINK_API_IMPORT Vector<uint8_t, 3>;

extern template class IOLINK_API_IMPORT Vector<uint16_t, 3>;

extern template class IOLINK_API_IMPORT Vector<uint32_t, 3>;

extern template class IOLINK_API_IMPORT Vector<uint64_t, 3>;


extern template class IOLINK_API_IMPORT Vector<float, 3>;

extern template class IOLINK_API_IMPORT Vector<double, 3>;


//------------

// 3D


extern template class IOLINK_API_IMPORT Vector<int8_t, 4>;

extern template class IOLINK_API_IMPORT Vector<int16_t, 4>;

extern template class IOLINK_API_IMPORT Vector<int32_t, 4>;

extern template class IOLINK_API_IMPORT Vector<int64_t, 4>;


extern template class IOLINK_API_IMPORT Vector<uint8_t, 4>;

extern template class IOLINK_API_IMPORT Vector<uint16_t, 4>;

extern template class IOLINK_API_IMPORT Vector<uint32_t, 4>;

extern template class IOLINK_API_IMPORT Vector<uint64_t, 4>;


extern template class IOLINK_API_IMPORT Vector<float, 4>;

extern template class IOLINK_API_IMPORT Vector<double, 4>;


//==================== //

// Aliases declaration //

//==================== //


//------------

// 2D


using Vector2u8 = Vector<uint8_t, 2>;

using Vector2u16 = Vector<uint16_t, 2>;

using Vector2u32 = Vector<uint32_t, 2>;

using Vector2u64 = Vector<uint64_t, 2>;

using Vector2i8 = Vector<int8_t, 2>;

using Vector2i16 = Vector<int16_t, 2>;

using Vector2i32 = Vector<int32_t, 2>;

using Vector2i64 = Vector<int64_t, 2>;

using Vector2f = Vector<float, 2>;

using Vector2d = Vector<double, 2>;


//------------

// 3D


using Vector3u8 = Vector<uint8_t, 3>;

using Vector3u16 = Vector<uint16_t, 3>;

using Vector3u32 = Vector<uint32_t, 3>;

using Vector3u64 = Vector<uint64_t, 3>;

using Vector3i8 = Vector<int8_t, 3>;

using Vector3i16 = Vector<int16_t, 3>;

using Vector3i32 = Vector<int32_t, 3>;

using Vector3i64 = Vector<int64_t, 3>;

using Vector3f = Vector<float, 3>;

using Vector3d = Vector<double, 3>;


//------------

// 4D


using Vector4u8 = Vector<uint8_t, 4>;

using Vector4u16 = Vector<uint16_t, 4>;

using Vector4u32 = Vector<uint32_t, 4>;

using Vector4u64 = Vector<uint64_t, 4>;

using Vector4i8 = Vector<int8_t, 4>;

using Vector4i16 = Vector<int16_t, 4>;

using Vector4i32 = Vector<int32_t, 4>;

using Vector4i64 = Vector<int64_t, 4>;

using Vector4f = Vector<float, 4>;

using Vector4d = Vector<double, 4>;


} // end namespace iolink

iolink::Vector
An arithmetic vector.
Definition: Vector.h:37

iolink::Vector::Vector
Vector(std::initializer_list< ValueType > init)
Create a vector with the values contained in a bracket list.

iolink::Vector::size
size_t size() const
Returns the size of the vector, which also correspond to vector number of dimension.
Definition: Vector.h:104

iolink::Vector::length
double length() const
Returns the vector's norm.

iolink::Vector::dot
ValueType dot(const Vector &v) const
Dot product of two vectors.

iolink::Vector::Vector
Vector()
Create a vector with unitialized values.

iolink::Vector::Vector
Vector(const VectorX< ValueType > &other, ValueType padding)
Build a vector from a VectorX of same type.

iolink::Vector::Vector
Vector(const VectorX< ValueType > &other)
Build a Vector from a VectorX of same type.

iolink::Vector::Vector
Vector(const Vector< U, N > &other)
Build a vector from a vector storing another type.
Definition: Vector.h:87

iolink::Vector::createUniform
static Vector createUniform(ValueType value)
Create a vector with the given value for all components.

iolink::Vector::squaredLength
double squaredLength() const
Returns the vector's norm, squared.

iolink::Vector::setAt
void setAt(size_t index, ValueType value)
Set value as given index.
Definition: Vector.h:114

iolink::Vector::at
ValueType at(size_t index) const
Access vector's value at given index.
Definition: Vector.h:109

iolink::Vector::normalize
void normalize()
Normalize the vector.

iolink::Vector::cross
Vector cross(const Vector &v) const
Cross product of two vectors.

iolink::VectorX
A dynamically sized arithmetic vector.
Definition: VectorX.h:18

iolink
All IOLink symbols are enclosed in this namespace.
Definition: ArrayX.h:8