VectorExpression.h

Go to the documentation of this file.

/*************************************************************************
> File Name: VectorExpression.h
> Project Name: CubbyFlow
> Author: Chan-Ho Chris Ohk
> Purpose: Base class for vector expression.
> Created Time: 2017/09/27
> Copyright (c) 2018, Chan-Ho Chris Ohk
*************************************************************************/
#ifndef CUBBYFLOW_VECTOR_EXPRESSION_H
#define CUBBYFLOW_VECTOR_EXPRESSION_H

#include <Core/Utils/Functors.h>

#include <functional>

namespace CubbyFlow
{
    // MARK: VectorExpression
    template <typename T, typename E>
    class VectorExpression
    {
    public:
        size_t size() const;

        const E& operator()() const;
    };

    // MARK: VectorUnaryOp
    template <typename T, typename E, typename Op>
    class VectorUnaryOp : public VectorExpression<T, VectorUnaryOp<T, E, Op>>
    {
    public:
        VectorUnaryOp(const E& u);

        size_t size() const;

        T operator[](size_t i) const;

    private:
        const E& m_u;
        Op m_op;
    };

    // MARK: VectorUnaryOp Aliases
    template <typename T, typename E, typename U>
    using VectorTypeCast = VectorUnaryOp<T, E, TypeCast<U, T>>;

    // MARK: VectorBinaryOp
    template <typename T, typename E1, typename E2, typename Op>
    class VectorBinaryOp : public VectorExpression<T, VectorBinaryOp<T, E1, E2, Op>>
    {
    public:
        VectorBinaryOp(const E1& u, const E2& v);

        size_t size() const;

        T operator[](size_t i) const;

    private:
        const E1& m_u;
        const E2& m_v;
        Op m_op;
    };

    template <typename T, typename E, typename Op>
    class VectorScalarBinaryOp : public VectorExpression<T, VectorScalarBinaryOp<T, E, Op>>
    {
    public:
        VectorScalarBinaryOp(const E& u, const T& v);

        size_t size() const;

        T operator[](size_t i) const;

    private:
        const E& m_u;
        T m_v;
        Op m_op;
    };

    // MARK: VectorBinaryOp Aliases
    template <typename T, typename E1, typename E2>
    using VectorAdd = VectorBinaryOp<T, E1, E2, std::plus<T>>;

    template <typename T, typename E>
    using VectorScalarAdd = VectorScalarBinaryOp<T, E, std::plus<T>>;

    template <typename T, typename E1, typename E2>
    using VectorSub = VectorBinaryOp<T, E1, E2, std::minus<T>>;

    template <typename T, typename E>
    using VectorScalarSub = VectorScalarBinaryOp<T, E, std::minus<T>>;

    template <typename T, typename E>
    using VectorScalarRSub = VectorScalarBinaryOp<T, E, RMinus<T>>;

    template <typename T, typename E1, typename E2>
    using VectorMul = VectorBinaryOp<T, E1, E2, std::multiplies<T>>;

    template <typename T, typename E>
    using VectorScalarMul = VectorScalarBinaryOp<T, E, std::multiplies<T>>;

    template <typename T, typename E1, typename E2>
    using VectorDiv = VectorBinaryOp<T, E1, E2, std::divides<T>>;

    template <typename T, typename E>
    using VectorScalarDiv = VectorScalarBinaryOp<T, E, std::divides<T>>;

    template <typename T, typename E>
    using VectorScalarRDiv = VectorScalarBinaryOp<T, E, RDivides<T>>;

    // MARK: Global Functions
    template <typename T, typename E>
    VectorScalarAdd<T, E> operator+(const T& a, const VectorExpression<T, E>& b);

    template <typename T, typename E>
    VectorScalarAdd<T, E> operator+(const VectorExpression<T, E>& a, const T& b);

    template <typename T, typename E1, typename E2>
    VectorAdd<T, E1, E2> operator+(const VectorExpression<T, E1>& a, const VectorExpression<T, E2>& b);

    template <typename T, typename E>
    VectorScalarRSub<T, E> operator-(const T& a, const VectorExpression<T, E>& b);

    template <typename T, typename E>
    VectorScalarSub<T, E> operator-(const VectorExpression<T, E>& a, const T& b);

    template <typename T, typename E1, typename E2>
    VectorSub<T, E1, E2> operator-(const VectorExpression<T, E1>& a, const VectorExpression<T, E2>& b);

    template <typename T, typename E>
    VectorScalarMul<T, E> operator*(const T& a, const VectorExpression<T, E>& b);

    template <typename T, typename E>
    VectorScalarMul<T, E> operator*(const VectorExpression<T, E>& a, const T& b);

    template <typename T, typename E1, typename E2>
    VectorMul<T, E1, E2> operator*(const VectorExpression<T, E1>& a, const VectorExpression<T, E2>& b);

    template <typename T, typename E>
    VectorScalarRDiv<T, E> operator/(const T& a, const VectorExpression<T, E>& b);

    template <typename T, typename E>
    VectorScalarDiv<T, E> operator/(const VectorExpression<T, E>& a, const T& b);

    template <typename T, typename E1, typename E2>
    VectorDiv<T, E1, E2> operator/(const VectorExpression<T, E1>& a, const VectorExpression<T, E2>& b);
}

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

#endif