VectorN.h

Go to the documentation of this file.

/*************************************************************************
> File Name: VectorN.h
> Project Name: CubbyFlow
> Author: Chan-Ho Chris Ohk
> Purpose: General purpose dynamically-sized N-D vector class.
> Created Time: 2017/09/28
> Copyright (c) 2018, Chan-Ho Chris Ohk
*************************************************************************/
#ifndef CUBBYFLOW_VECTORN_H
#define CUBBYFLOW_VECTORN_H

#include <Core/Array/ArrayAccessor1.h>
#include <Core/Vector/VectorExpression.h>

namespace CubbyFlow
{
    // 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");

        using ContainerType = std::vector<T>;

        // MARK: Constructors
        VectorN();

        VectorN(size_t n, const T& val = 0);

        template <typename U>
        VectorN(const std::initializer_list<U>& list);

        template <typename E>
        VectorN(const VectorExpression<T, E>& other);

        VectorN(const VectorN& other);

        VectorN(VectorN&& other) noexcept;

        // 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>& list);

        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* 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 SubdominantAxis() 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>& list);

        template <typename E>
        VectorN& operator=(const VectorExpression<T, E>& other);

        VectorN& operator=(const VectorN& other);

        VectorN& operator=(VectorN&& other) noexcept;

        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 m_elements;
    };

    using VectorNF = VectorN<float>;

    using VectorND = VectorN<double>;
}

#include <Core/Vector/VectorN-Impl.h>

#endif