Classes | Namespaces | Typedefs | Functions
Matrix.hpp File Reference
#include <Core/Matrix/MatrixDenseBase.hpp>
#include <Core/Matrix/MatrixExpression.hpp>
#include <Core/Utils/Macros.hpp>
#include <Core/Utils/NestedInitializerList.hpp>
#include <Core/Utils/TypeHelpers.hpp>
#include <array>
#include <cstdint>
#include <vector>
#include <Core/Matrix/Matrix-Impl.hpp>

Go to the source code of this file.

Classes

class  CubbyFlow::Matrix< T, Rows, Cols >
 
class  CubbyFlow::Matrix< T, 1, 1 >
 
class  CubbyFlow::Matrix< T, 2, 1 >
 
class  CubbyFlow::Matrix< T, 3, 1 >
 
class  CubbyFlow::Matrix< T, 4, 1 >
 
class  CubbyFlow::Matrix< T, MATRIX_SIZE_DYNAMIC, MATRIX_SIZE_DYNAMIC >
 
class  CubbyFlow::Matrix< T, MATRIX_SIZE_DYNAMIC, 1 >
 
struct  CubbyFlow::GetScalarType< Matrix< T, Rows, Cols > >
 

Namespaces

 CubbyFlow
 

Typedefs

template<typename T >
using CubbyFlow::Matrix2x2 = Matrix< T, 2, 2 >
 
template<typename T >
using CubbyFlow::Matrix3x3 = Matrix< T, 3, 3 >
 
template<typename T >
using CubbyFlow::Matrix4x4 = Matrix< T, 4, 4 >
 
using CubbyFlow::Matrix2x2B = Matrix2x2< int8_t >
 
using CubbyFlow::Matrix2x2UB = Matrix2x2< uint8_t >
 
using CubbyFlow::Matrix2x2S = Matrix2x2< int16_t >
 
using CubbyFlow::Matrix2x2US = Matrix2x2< uint16_t >
 
using CubbyFlow::Matrix2x2I = Matrix2x2< int32_t >
 
using CubbyFlow::Matrix2x2UI = Matrix2x2< uint32_t >
 
using CubbyFlow::Matrix2x2L = Matrix2x2< int64_t >
 
using CubbyFlow::Matrix2x2UL = Matrix2x2< uint64_t >
 
using CubbyFlow::Matrix2x2F = Matrix2x2< float >
 
using CubbyFlow::Matrix2x2D = Matrix2x2< double >
 
using CubbyFlow::Matrix2x2Z = Matrix2x2< ssize_t >
 
using CubbyFlow::Matrix2x2UZ = Matrix2x2< size_t >
 
using CubbyFlow::Matrix3x3B = Matrix3x3< int8_t >
 
using CubbyFlow::Matrix3x3UB = Matrix3x3< uint8_t >
 
using CubbyFlow::Matrix3x3S = Matrix3x3< int16_t >
 
using CubbyFlow::Matrix3x3US = Matrix3x3< uint16_t >
 
using CubbyFlow::Matrix3x3I = Matrix3x3< int32_t >
 
using CubbyFlow::Matrix3x3UI = Matrix3x3< uint32_t >
 
using CubbyFlow::Matrix3x3L = Matrix3x3< int64_t >
 
using CubbyFlow::Matrix3x3UL = Matrix3x3< uint64_t >
 
using CubbyFlow::Matrix3x3F = Matrix3x3< float >
 
using CubbyFlow::Matrix3x3D = Matrix3x3< double >
 
using CubbyFlow::Matrix3x3Z = Matrix3x3< ssize_t >
 
using CubbyFlow::Matrix3x3UZ = Matrix3x3< size_t >
 
using CubbyFlow::Matrix4x4B = Matrix4x4< int8_t >
 
using CubbyFlow::Matrix4x4UB = Matrix4x4< uint8_t >
 
using CubbyFlow::Matrix4x4S = Matrix4x4< int16_t >
 
using CubbyFlow::Matrix4x4US = Matrix4x4< uint16_t >
 
using CubbyFlow::Matrix4x4I = Matrix4x4< int32_t >
 
using CubbyFlow::Matrix4x4UI = Matrix4x4< uint32_t >
 
using CubbyFlow::Matrix4x4L = Matrix4x4< int64_t >
 
using CubbyFlow::Matrix4x4UL = Matrix4x4< uint64_t >
 
using CubbyFlow::Matrix4x4F = Matrix4x4< float >
 
using CubbyFlow::Matrix4x4D = Matrix4x4< double >
 
using CubbyFlow::Matrix4x4Z = Matrix4x4< ssize_t >
 
using CubbyFlow::Matrix4x4UZ = Matrix4x4< size_t >
 
template<typename T , size_t Rows>
using CubbyFlow::Vector = Matrix< T, Rows, 1 >
 
template<typename T >
using CubbyFlow::Vector1 = Vector< T, 1 >
 
template<typename T >
using CubbyFlow::Vector2 = Vector< T, 2 >
 
template<typename T >
using CubbyFlow::Vector3 = Vector< T, 3 >
 
template<typename T >
using CubbyFlow::Vector4 = Vector< T, 4 >
 
using CubbyFlow::Vector1B = Vector1< int8_t >
 
using CubbyFlow::Vector1UB = Vector1< uint8_t >
 
using CubbyFlow::Vector1S = Vector1< int16_t >
 
using CubbyFlow::Vector1US = Vector1< uint16_t >
 
using CubbyFlow::Vector1I = Vector1< int32_t >
 
using CubbyFlow::Vector1UI = Vector1< uint32_t >
 
using CubbyFlow::Vector1L = Vector1< int64_t >
 
using CubbyFlow::Vector1UL = Vector1< uint64_t >
 
using CubbyFlow::Vector1F = Vector1< float >
 
using CubbyFlow::Vector1D = Vector1< double >
 
using CubbyFlow::Vector1Z = Vector1< ssize_t >
 
using CubbyFlow::Vector1UZ = Vector1< size_t >
 
using CubbyFlow::Vector2B = Vector2< int8_t >
 
using CubbyFlow::Vector2UB = Vector2< uint8_t >
 
using CubbyFlow::Vector2S = Vector2< int16_t >
 
using CubbyFlow::Vector2US = Vector2< uint16_t >
 
using CubbyFlow::Vector2I = Vector2< int32_t >
 
using CubbyFlow::Vector2UI = Vector2< uint32_t >
 
using CubbyFlow::Vector2L = Vector2< int64_t >
 
using CubbyFlow::Vector2UL = Vector2< uint64_t >
 
using CubbyFlow::Vector2F = Vector2< float >
 
using CubbyFlow::Vector2D = Vector2< double >
 
using CubbyFlow::Vector2Z = Vector2< ssize_t >
 
using CubbyFlow::Vector2UZ = Vector2< size_t >
 
using CubbyFlow::Vector3B = Vector3< int8_t >
 
using CubbyFlow::Vector3UB = Vector3< uint8_t >
 
using CubbyFlow::Vector3S = Vector3< int16_t >
 
using CubbyFlow::Vector3US = Vector3< uint16_t >
 
using CubbyFlow::Vector3I = Vector3< int32_t >
 
using CubbyFlow::Vector3UI = Vector3< uint32_t >
 
using CubbyFlow::Vector3L = Vector3< int64_t >
 
using CubbyFlow::Vector3UL = Vector3< uint64_t >
 
using CubbyFlow::Vector3F = Vector3< float >
 
using CubbyFlow::Vector3D = Vector3< double >
 
using CubbyFlow::Vector3Z = Vector3< ssize_t >
 
using CubbyFlow::Vector3UZ = Vector3< size_t >
 
using CubbyFlow::Vector4B = Vector4< int8_t >
 
using CubbyFlow::Vector4UB = Vector4< uint8_t >
 
using CubbyFlow::Vector4S = Vector4< int16_t >
 
using CubbyFlow::Vector4US = Vector4< uint16_t >
 
using CubbyFlow::Vector4I = Vector4< int32_t >
 
using CubbyFlow::Vector4UI = Vector4< uint32_t >
 
using CubbyFlow::Vector4L = Vector4< int64_t >
 
using CubbyFlow::Vector4UL = Vector4< uint64_t >
 
using CubbyFlow::Vector4F = Vector4< float >
 
using CubbyFlow::Vector4D = Vector4< double >
 
using CubbyFlow::Vector4Z = Vector4< ssize_t >
 
using CubbyFlow::Vector4UZ = Vector4< size_t >
 
template<typename T >
using CubbyFlow::MatrixMxN = Matrix< T, MATRIX_SIZE_DYNAMIC, MATRIX_SIZE_DYNAMIC >
 
using CubbyFlow::MatrixMxNB = MatrixMxN< int8_t >
 
using CubbyFlow::MatrixMxNUB = MatrixMxN< uint8_t >
 
using CubbyFlow::MatrixMxNS = MatrixMxN< int16_t >
 
using CubbyFlow::MatrixMxNUS = MatrixMxN< uint16_t >
 
using CubbyFlow::MatrixMxNI = MatrixMxN< int32_t >
 
using CubbyFlow::MatrixMxNUI = MatrixMxN< uint32_t >
 
using CubbyFlow::MatrixMxNL = MatrixMxN< int64_t >
 
using CubbyFlow::MatrixMxNUL = MatrixMxN< uint64_t >
 
using CubbyFlow::MatrixMxNF = MatrixMxN< float >
 
using CubbyFlow::MatrixMxND = MatrixMxN< double >
 
using CubbyFlow::MatrixMxNZ = MatrixMxN< ssize_t >
 
using CubbyFlow::MatrixMxNUZ = MatrixMxN< size_t >
 
template<typename T >
using CubbyFlow::VectorN = Matrix< T, MATRIX_SIZE_DYNAMIC, 1 >
 
using CubbyFlow::VectorNB = VectorN< int8_t >
 
using CubbyFlow::VectorNUB = VectorN< uint8_t >
 
using CubbyFlow::VectorNS = VectorN< int16_t >
 
using CubbyFlow::VectorNUS = VectorN< uint16_t >
 
using CubbyFlow::VectorNI = VectorN< int32_t >
 
using CubbyFlow::VectorNUI = VectorN< uint32_t >
 
using CubbyFlow::VectorNL = VectorN< int64_t >
 
using CubbyFlow::VectorNUL = VectorN< uint64_t >
 
using CubbyFlow::VectorNF = VectorN< float >
 
using CubbyFlow::VectorND = VectorN< double >
 
using CubbyFlow::VectorNZ = VectorN< ssize_t >
 
using CubbyFlow::VectorNUZ = VectorN< size_t >
 

Functions

template<typename T , size_t R1, size_t C1, size_t R2, size_t C2, typename M2 >
void CubbyFlow::operator+= (Matrix< T, R1, C1 > &a, const MatrixExpression< T, R2, C2, M2 > &b)
 
template<typename T , size_t Rows, size_t Cols>
void CubbyFlow::operator+= (Matrix< T, Rows, Cols > &a, const T &b)
 
template<typename T , size_t R1, size_t C1, size_t R2, size_t C2, typename M2 >
void CubbyFlow::operator-= (Matrix< T, R1, C1 > &a, const MatrixExpression< T, R2, C2, M2 > &b)
 
template<typename T , size_t Rows, size_t Cols>
void CubbyFlow::operator-= (Matrix< T, Rows, Cols > &a, const T &b)
 
template<typename T , size_t R1, size_t C1, size_t R2, size_t C2, typename M2 >
void CubbyFlow::operator*= (Matrix< T, R1, C1 > &a, const MatrixExpression< T, R2, C2, M2 > &b)
 
template<typename T , size_t R1, size_t C1, size_t R2, size_t C2, typename M2 >
void CubbyFlow::ElemIMul (Matrix< T, R1, C1 > &a, const MatrixExpression< T, R2, C2, M2 > &b)
 
template<typename T , size_t Rows, size_t Cols>
void CubbyFlow::operator*= (Matrix< T, Rows, Cols > &a, const T &b)
 
template<typename T , size_t R1, size_t C1, size_t R2, size_t C2, typename M2 >
void CubbyFlow::ElemIDiv (Matrix< T, R1, C1 > &a, const MatrixExpression< T, R2, C2, M2 > &b)
 
template<typename T , size_t Rows, size_t Cols>
void CubbyFlow::operator/= (Matrix< T, Rows, Cols > &a, const T &b)
 
template<typename T , size_t Rows, size_t Cols, typename M1 , typename M2 >
constexpr std::enable_if_t< IsMatrixSizeStatic< Rows, Cols >), bool > CubbyFlow::operator== (const MatrixExpression< T, Rows, Cols, M1 > &a, const MatrixExpression< T, Rows, Cols, M2 > &b)
 
template<typename T , size_t R1, size_t C1, size_t R2, size_t C2, typename M1 , typename M2 >
bool CubbyFlow::operator== (const MatrixExpression< T, R1, C1, M1 > &a, const MatrixExpression< T, R2, C2, M2 > &b)
 
template<typename T , size_t R1, size_t C1, size_t R2, size_t C2, typename M1 , typename M2 >
bool CubbyFlow::operator!= (const MatrixExpression< T, R1, C1, M1 > &a, const MatrixExpression< T, R2, C2, M2 > &b)
 
template<typename T , size_t Rows, size_t Cols, typename M1 , typename BinaryOperation >
constexpr std::enable_if_t< TraitIsMatrixSizeStatic< Rows, Cols >::value, T > CubbyFlow::Accumulate (const MatrixExpression< T, Rows, Cols, M1 > &a, const T &init, BinaryOperation op)
 
template<typename T , size_t Rows, size_t Cols, typename M1 >
constexpr std::enable_if_t< TraitIsMatrixSizeStatic< Rows, Cols >::value, T > CubbyFlow::Accumulate (const MatrixExpression< T, Rows, Cols, M1 > &a, const T &init)
 
template<typename T , size_t Rows, size_t Cols, typename M1 >
constexpr std::enable_if_t< TraitIsMatrixSizeStatic< Rows, Cols >::value, T > CubbyFlow::Accumulate (const MatrixExpression< T, Rows, Cols, M1 > &a)
 
template<typename T , size_t Rows, size_t Cols, typename M1 , typename BinaryOperation >
constexpr std::enable_if_t< TraitIsMatrixSizeDynamic< Rows, Cols >::value, T > CubbyFlow::Accumulate (const MatrixExpression< T, Rows, Cols, M1 > &a, const T &init, BinaryOperation op)
 
template<typename T , size_t Rows, size_t Cols, typename M1 >
constexpr std::enable_if_t< TraitIsMatrixSizeDynamic< Rows, Cols >::value, T > CubbyFlow::Accumulate (const MatrixExpression< T, Rows, Cols, M1 > &a, const T &init)
 
template<typename T , size_t Rows, size_t Cols, typename M1 >
constexpr std::enable_if_t< TraitIsMatrixSizeDynamic< Rows, Cols >::value, T > CubbyFlow::Accumulate (const MatrixExpression< T, Rows, Cols, M1 > &a)
 
template<typename T , size_t Rows, size_t Cols, typename M1 >
constexpr T CubbyFlow::Product (const MatrixExpression< T, Rows, Cols, M1 > &a, const T &init)
 
template<typename T , size_t Rows, size_t Cols, typename M1 , typename M2 , typename M3 , typename M4 >
std::enable_if_t< IsMatrixSizeStatic< Rows, Cols >), Matrix< T, Rows, Cols > > CubbyFlow::MonotonicCatmullRom (const MatrixExpression< T, Rows, Cols, M1 > &f0, const MatrixExpression< T, Rows, Cols, M2 > &f1, const MatrixExpression< T, Rows, Cols, M3 > &f2, const MatrixExpression< T, Rows, Cols, M4 > &f3, T f)
 
Generated on Wed Jul 27 2022 14:50:11 for CubbyFlow by   doxygen 1.8.13