vector_n.h

Go to the documentation of this file.

// Copyright (c) 2018 Doyub Kim
//
// I am making my contributions/submissions to this project solely in my
// personal capacity and am not conveying any rights to any intellectual
// property of any third parties.
 
#ifndef INCLUDE_JET_VECTOR_N_H_
#define INCLUDE_JET_VECTOR_N_H_
 
#include <jet/array_accessor1.h>
#include <jet/vector_expression.h>
 
#include <initializer_list>
#include <limits>
#include <vector>
 
namespace jet {
 
// MARK: VectorN
 
template <typename T>
class VectorN final : public VectorExpression<T, VectorN<T>> {
 public:
    static_assert(std::is_floating_point<T>::value,
                  "VectorN only can be instantiated with floating point types");
 
    typedef std::vector<T> ContainerType;
 
    // MARK: Constructors
 
    VectorN();
 
    VectorN(size_t n, const T& val = 0);
 
    template <typename U>
    VectorN(const std::initializer_list<U>& lst);
 
    template <typename E>
    VectorN(const VectorExpression<T, E>& other);
 
    VectorN(const VectorN& other);
 
    VectorN(VectorN&& other);
 
    // MARK: Basic setters
 
    void resize(size_t n, const T& val = 0);
 
    void clear();
 
    void set(const T& s);
 
    template <typename U>
    void set(const std::initializer_list<U>& lst);
 
    template <typename E>
    void set(const VectorExpression<T, E>& other);
 
    void append(const T& val);
 
    void swap(VectorN& other);
 
    void setZero();
 
    void normalize();
 
    // MARK: Basic getters
 
    size_t size() const;
 
    T* data();
 
    const T* const data() const;
 
    typename ContainerType::iterator begin();
 
    typename ContainerType::const_iterator begin() const;
 
    typename ContainerType::iterator end();
 
    typename ContainerType::const_iterator end() const;
 
    ArrayAccessor1<T> accessor();
 
    ConstArrayAccessor1<T> constAccessor() const;
 
    T at(size_t i) const;
 
    T& at(size_t i);
 
    T sum() const;
 
    T avg() const;
 
    T min() const;
 
    T max() const;
 
    T absmin() const;
 
    T absmax() const;
 
    size_t dominantAxis() const;
 
    size_t subminantAxis() const;
 
    VectorScalarDiv<T, VectorN> normalized() const;
 
    T length() const;
 
    T lengthSquared() const;
 
    template <typename E>
    T distanceTo(const E& other) const;
 
    template <typename E>
    T distanceSquaredTo(const E& other) const;
 
    template <typename U>
    VectorTypeCast<U, VectorN<T>, T> castTo() const;
 
    template <typename E>
    bool isEqual(const E& other) const;
 
    template <typename E>
    bool isSimilar(const E& other,
                   T epsilon = std::numeric_limits<T>::epsilon()) const;
 
    // MARK: Binary operations: new instance = this (+) v
 
    template <typename E>
    VectorAdd<T, VectorN, E> add(const E& v) const;
 
    VectorScalarAdd<T, VectorN> add(const T& s) const;
 
    template <typename E>
    VectorSub<T, VectorN, E> sub(const E& v) const;
 
    VectorScalarSub<T, VectorN> sub(const T& s) const;
 
    template <typename E>
    VectorMul<T, VectorN, E> mul(const E& v) const;
 
    VectorScalarMul<T, VectorN> mul(const T& s) const;
 
    template <typename E>
    VectorDiv<T, VectorN, E> div(const E& v) const;
 
    VectorScalarDiv<T, VectorN> div(const T& s) const;
 
    template <typename E>
    T dot(const E& v) const;
 
    // MARK: Binary operations: new instance = v (+) this
 
    VectorScalarRSub<T, VectorN> rsub(const T& s) const;
 
    template <typename E>
    VectorSub<T, VectorN, E> rsub(const E& v) const;
 
    VectorScalarRDiv<T, VectorN> rdiv(const T& s) const;
 
    template <typename E>
    VectorDiv<T, VectorN, E> rdiv(const E& v) const;
 
    // MARK: Augmented operations: this (+)= v
 
    void iadd(const T& s);
 
    template <typename E>
    void iadd(const E& v);
 
    void isub(const T& s);
 
    template <typename E>
    void isub(const E& v);
 
    void imul(const T& s);
 
    template <typename E>
    void imul(const E& v);
 
    void idiv(const T& s);
 
    template <typename E>
    void idiv(const E& v);
 
    // MARK: Operators
 
    template <typename Callback>
    void forEach(Callback func) const;
 
    template <typename Callback>
    void forEachIndex(Callback func) const;
 
    template <typename Callback>
    void parallelForEach(Callback func);
 
    template <typename Callback>
    void parallelForEachIndex(Callback func) const;
 
    T operator[](size_t i) const;
 
    T& operator[](size_t i);
 
    template <typename U>
    VectorN& operator=(const std::initializer_list<U>& lst);
 
    template <typename E>
    VectorN& operator=(const VectorExpression<T, E>& other);
 
    VectorN& operator=(const VectorN& other);
 
    VectorN& operator=(VectorN&& other);
 
    VectorN& operator+=(const T& s);
 
    template <typename E>
    VectorN& operator+=(const E& v);
 
    VectorN& operator-=(const T& s);
 
    template <typename E>
    VectorN& operator-=(const E& v);
 
    VectorN& operator*=(const T& s);
 
    template <typename E>
    VectorN& operator*=(const E& v);
 
    VectorN& operator/=(const T& s);
 
    template <typename E>
    VectorN& operator/=(const E& v);
 
    template <typename E>
    bool operator==(const E& v) const;
 
    template <typename E>
    bool operator!=(const E& v) const;
 
 private:
    ContainerType _elements;
};
 
typedef VectorN<float> VectorNF;
 
typedef VectorN<double> VectorND;
 
}  // namespace jet
 
#include "detail/vector_n-inl.h"
 
#endif  // INCLUDE_JET_VECTOR_N_H_