Matrix.h

#pragma once
 
#include "DefinitionsMathematics.h"
#include "FLPointArray.h"
 
namespace FLImaging
{
    namespace Foundation
    {
        enum EMatrixTemplateType
        {
            EMatrixTemplateType_Float,
 
            EMatrixTemplateType_Double,
        };
 
        enum EMatrixReduceType
        {
            EMatrixReduceType_Both,
            EMatrixReduceType_Row,
            EMatrixReduceType_Column,
        };
 
        template <typename Ty>
        class FL_EXPORT CMatrixFor3D;
 
        template <typename Ty>
        class FL_EXPORT CMatrix : public Base::CFLBase
        {
        public:
            CMatrix();
 
            virtual ~CMatrix();
 
            CMatrix(const CMatrix<Ty>& matrix);
 
            CMatrix(const CMatrix<Ty>* pMatrix);
 
            CMatrix(int64_t i64Row, int64_t i64Column);
 
            CMatrix(int64_t i64Row, int64_t i64Column, Ty tFillValue);
 
            CMatrix<Ty>(const Base::CFLArray<Base::CFLArray<Ty>>& fla2Mat);
 
            virtual const CMatrix<Ty>& operator+=(const int32_t& i32Param);
 
            virtual const CMatrix<Ty>& operator+=(const int64_t& i64Param);
 
            virtual const CMatrix<Ty>& operator+=(const float& f32Param);
 
            virtual const CMatrix<Ty>& operator+=(const double& f64Param);
 
            virtual const CMatrix<Ty>& operator+=(const CMatrix<Ty>& cMat);
 
            virtual const CMatrix<Ty>& operator-=(const int32_t& i32Param);
 
            virtual const CMatrix<Ty>& operator-=(const int64_t& i64Param);
 
            virtual const CMatrix<Ty>& operator-=(const float& f32Param);
 
            virtual const CMatrix<Ty>& operator-=(const double& f64Param);
 
            virtual const CMatrix<Ty>& operator-=(const CMatrix<Ty>& cMat);
 
            virtual const CMatrix<Ty>& operator*=(const int32_t& i32Param);
 
            virtual const CMatrix<Ty>& operator*=(const int64_t& i64Param);
 
            virtual const CMatrix<Ty>& operator*=(const float& f32Param);
 
            virtual const CMatrix<Ty>& operator*=(const double& f64Param);
 
            virtual const CMatrix<Ty>& operator*=(const CMatrix<Ty>& cMat);
 
            virtual const CMatrix<Ty>& operator/=(const int32_t& i32Param);
 
            virtual const CMatrix<Ty>& operator/=(const int64_t& i64Param);
 
            virtual const CMatrix<Ty>& operator/=(const float& f32Param);
 
            virtual const CMatrix<Ty>& operator/=(const double& f64Param);
 
            virtual const CMatrix<Ty>& operator/=(const CMatrix<Ty>& cMat);
 
            CMatrix<Ty> operator+(const int32_t& i32Param) const;
 
            CMatrix<Ty> operator+(const int64_t& i64Param) const;
 
            CMatrix<Ty> operator+(const float& f32Param) const;
 
            CMatrix<Ty> operator+(const double& f64Param) const;
 
            CMatrix<Ty> operator+(const CMatrix<Ty>& cMat) const;
 
            CMatrix<Ty> operator-(const int32_t& i32Param) const;
 
            CMatrix<Ty> operator-(const int64_t& i64Param) const;
 
            CMatrix<Ty> operator-(const float& f32Param) const;
 
            CMatrix<Ty> operator-(const double& f64Param) const;
 
            CMatrix<Ty> operator-(const CMatrix<Ty>& cMat) const;
 
            CMatrix<Ty> operator*(const int32_t& i32Param) const;
 
            CMatrix<Ty> operator*(const int64_t& i64Param) const;
 
            CMatrix<Ty> operator*(const float& f32Param) const;
 
            CMatrix<Ty> operator*(const double& f64Param) const;
 
            CMatrix<Ty> operator*(const CMatrix<Ty>& cMat) const;
 
            CMatrix<Ty> operator/(const int32_t& i32Param) const;
 
            CMatrix<Ty> operator/(const int64_t& i64Param) const;
 
            CMatrix<Ty> operator/(const float& f32Param) const;
 
            CMatrix<Ty> operator/(const double& f64Param) const;
 
            CMatrix<Ty> operator/(const CMatrix<Ty>& cMat) const;
 
            virtual const CMatrix<Ty>& operator=(const CMatrix<double>& matrix);
 
            virtual const CMatrix<Ty>& operator=(const CMatrix<float>& matrix);
 
            virtual const CMatrix<Ty>& operator=(const CMatrix<double>* pMatrix);
 
            virtual const CMatrix<Ty>& operator=(const CMatrix<float>* pMatrix);
 
            virtual const CMatrix<Ty>& operator=(const Base::CFLArray<Base::CFLArray<Ty>>& fla2Matrix);
 
            virtual bool operator==(const CMatrix<Ty>& cMat) const;
 
            virtual bool operator!=(const CMatrix<Ty>& cMat) const;
 
            CMatrix<Ty> operator==(const double& f64Param) const;
 
            CMatrix<Ty> operator!=(const double& f64Param) const;
 
            CMatrix<Ty> operator<(const double& f64Param) const;
 
            CMatrix<Ty> operator>(const double& f64Param) const;
 
            CMatrix<Ty> operator<(const CMatrix<Ty>& matOperand) const;
 
            CMatrix<Ty> operator>(const CMatrix<Ty>& matOperand) const;
 
            CMatrix<Ty> operator%(const double& f64Param) const;
 
            CMatrix<Ty> operator%(const CMatrix<Ty>& matOperand) const;
 
            CMatrix<Ty> operator&&(const CMatrix<Ty>& matOperand) const;
 
            virtual const CMatrix<Ty>& operator%=(const double& f64Param);
 
            friend CMatrix<Ty> operator+(const double& value, const CMatrix<Ty>& mat)
            {
                CMatrix<Ty> matReturn(mat);
                matReturn += value;
                return matReturn;
            }
 
            friend CMatrix<Ty> operator+(const float& value, const CMatrix<Ty>& mat)
            {
                CMatrix<Ty> matReturn(mat);
                matReturn += value;
                return matReturn;
            }
 
            friend CMatrix<Ty> operator+(const int64_t& value, const CMatrix<Ty>& mat)
            {
                CMatrix<Ty> matReturn(mat);
                matReturn += value;
                return matReturn;
            }
 
            friend CMatrix<Ty> operator+(const int32_t& value, const CMatrix<Ty>& mat)
            {
                CMatrix<Ty> matReturn(mat);
                matReturn += value;
                return matReturn;
            }
 
            friend CMatrix<Ty> operator-(const double& value, const CMatrix<Ty>& mat)
            {
                CMatrix<Ty> matReturn(mat);
                matReturn -= value;
                return matReturn;
            }
 
            friend CMatrix<Ty> operator-(const float& value, const CMatrix<Ty>& mat)
            {
                CMatrix<Ty> matReturn(mat);
                matReturn -= value;
                return matReturn;
            }
 
            friend CMatrix<Ty> operator-(const int64_t& value, const CMatrix<Ty>& mat)
            {
                CMatrix<Ty> matReturn(mat);
                matReturn -= value;
                return matReturn;
            }
 
            friend CMatrix<Ty> operator-(const int32_t& value, const CMatrix<Ty>& mat)
            {
                CMatrix<Ty> matReturn(mat);
                matReturn -= value;
                return matReturn;
            }
 
            friend CMatrix<Ty> operator*(const double& value, const CMatrix<Ty>& mat)
            {
                CMatrix<Ty> matReturn(mat);
                matReturn *= value;
                return matReturn;
            }
 
            friend CMatrix<Ty> operator*(const float& value, const CMatrix<Ty>& mat)
            {
                CMatrix<Ty> matReturn(mat);
                matReturn *= value;
                return matReturn;
            }
 
            friend CMatrix<Ty> operator*(const int64_t& value, const CMatrix<Ty>& mat)
            {
                CMatrix<Ty> matReturn(mat);
                matReturn *= value;
                return matReturn;
            }
 
            friend CMatrix<Ty> operator*(const int32_t& value, const CMatrix<Ty>& mat)
            {
                CMatrix<Ty> matReturn(mat);
                matReturn *= value;
                return matReturn;
            }
 
            friend CMatrix<Ty> operator<(const double& value, const CMatrix<Ty>& mat)
            {
                CMatrix<Ty> matReturn(mat > value);
                return matReturn;
            }
 
            friend CMatrix<Ty> operator>(const double& value, const CMatrix<Ty>& mat)
            {
                CMatrix<Ty> matReturn(mat < value);
                return matReturn;
            }
 
            virtual operator Ty* ();
 
            virtual Ty* operator() (const int32_t i32Row, const int32_t i32Column) const;
 
            virtual Ty* operator[](int32_t i32Index);
 
            virtual Ty* operator[](int64_t i64Index);
 
            virtual const Ty* operator[](int32_t i32Index) const;
 
            virtual const Ty* operator[](int64_t i64Index) const;
 
            virtual EMatrixTemplateType GetTemplateType() const;
 
            virtual const CResult Create(int64_t i64Row, int64_t i64Column, bool bFillZero = true);
 
            virtual const CResult Create(const CMatrix<float>& matShape, Ty tFillValue = 0);
 
            virtual const CResult Create(const CMatrix<double>& matShape, Ty tFillValue = 0);
 
            virtual const CResult Create(const CMatrix<float>* pMatShape, Ty tFillValue = 0);
 
            virtual const CResult Create(const CMatrix<double>* pMatShape, Ty tFillValue = 0);
 
            virtual const CResult Ones(int64_t i64Row, int64_t i64Column);
 
            virtual const CResult Zeros(int64_t i64Row, int64_t i64Column);
 
            virtual const CResult Full(int64_t i64Row, int64_t i64Column, Ty tFillValue);
 
            virtual const CResult OnesLike(const CMatrix<float>& matShape);
 
            virtual const CResult OnesLike(const CMatrix<double>& matShape);
 
            virtual const CResult OnesLike(const CMatrix<float>* pMatShape);
 
            virtual const CResult OnesLike(const CMatrix<double>* pMatShape);
 
            virtual const CResult ZerosLike(const CMatrix<float>& matShape);
 
            virtual const CResult ZerosLike(const CMatrix<double>& matShape);
 
            virtual const CResult ZerosLike(const CMatrix<float>* pMatShape);
 
            virtual const CResult ZerosLike(const CMatrix<double>* pMatShape);
 
            virtual const CResult FullLike(const CMatrix<float>& matShape, Ty tFillValue);
 
            virtual const CResult FullLike(const CMatrix<double>& matShape, Ty tFillValue);
 
            virtual const CResult FullLike(const CMatrix<float>* pMatShape, Ty tFillValue);
 
            virtual const CResult FullLike(const CMatrix<double>* pMatShape, Ty tFillValue);
 
            virtual bool IsValid() const override;
 
            virtual const CResult Assign(const CMatrix<double>& matrix);
 
            virtual const CResult Assign(const CMatrix<float>& matrix);
 
            virtual const CResult Assign(const CMatrix<double>* pMatrix);
 
            virtual const CResult Assign(const CMatrix<float>* pMatrix);
 
            virtual const CResult Assign(Ty* pArr2Mat, int64_t i64Row, int64_t i64Column);
 
            virtual const CResult Assign(const Base::CFLArray<Base::CFLArray<Ty>>& fla2Matrix);
 
            virtual const CResult Assign(const Base::CFLArray<Base::CFLArray<Ty>>* pFla2Matrix);
 
            virtual const CResult Set(Ty* pArr2Mat, int64_t i64Row, int64_t i64Column);
 
            virtual void Clear();
 
            virtual int64_t GetColumn() const;
 
            virtual int64_t GetRow() const;
 
            virtual int64_t GetElementCount() const;
 
            virtual int64_t GetTotalSizeByte() const;
 
            virtual int64_t GetColumnSizeByte() const;
 
            virtual int64_t GetRowSizeByte() const;
 
            virtual Ty* GetBuffer() const;
 
            virtual Ty** GetYCache() const;
 
            virtual Ty* GetValue(int64_t i64Row, int64_t i64Column) const;
 
            virtual const CResult GetRange(CMatrix<Ty>* pMatResult, int64_t i64StartRow = -1, int64_t i64StartColumn = -1, int64_t i64EndRow = -1, int64_t i64EndColumn = -1) const;
 
            virtual const CResult GetRange(Base::CFLArray<Ty>* pMatResult, int64_t i64StartRow = -1, int64_t i64StartColumn = -1, int64_t i64EndRow = -1, int64_t i64EndColumn = -1) const;
 
            virtual const CResult GetRange(Base::CFLArray<Base::CFLArray<Ty>>* pMatResult, int64_t i64StartRow = -1, int64_t i64StartColumn = -1, int64_t i64EndRow = -1, int64_t i64EndColumn = -1) const;
 
            virtual const CResult GetRangeRef(CMatrix<Ty>* pMatResult, int64_t i64StartRow = -1, int64_t i64StartColumn = -1, int64_t i64EndRow = -1, int64_t i64EndColumn = -1) const;
 
            virtual const CResult Fill(Ty value);
 
            virtual const CResult FillZero();
 
            virtual const CResult FillRandom(Ty tRangeMin, Ty tRangeMax);
 
            virtual const CResult FillLinear(Ty tRangeStart, Ty tRangeEnd);
 
            virtual const CResult LinSpace(Ty tRangeStart, Ty tRangeEnd);
 
            virtual const CResult SetValue(int64_t i64Row, int64_t i64Column, Ty value);
 
            virtual const CResult Add(const CMatrix<Ty>& matrix);
 
            virtual const CResult Add(const CMatrix<Ty>* pMatrix);
 
            virtual const CResult Add(const CMatrix<Ty>& matrix, CMatrix<Ty>* pTargetMatrix) const;
 
            virtual const CResult Add(const CMatrix<Ty>* pMatrix, CMatrix<Ty>* pTargetMatrix) const;
 
            virtual const CResult Subtract(const CMatrix<Ty>& matrix);
 
            virtual const CResult Subtract(const CMatrix<Ty>* pMatrix);
 
            virtual const CResult Subtract(const CMatrix<Ty>& matrix, CMatrix<Ty>* pTargetMatrix) const;
 
            virtual const CResult Subtract(const CMatrix<Ty>* pMatrix, CMatrix<Ty>* pTargetMatrix) const;
 
            virtual const CResult Multiply(const int32_t& i32Scalar);
 
            virtual const CResult Multiply(const int64_t& i64Scalar);
 
            virtual const CResult Multiply(const float& f32Scalar);
 
            virtual const CResult Multiply(const double& f64Scalar);
 
            virtual const CResult Multiply(const CMatrix<Ty>& matrix);
 
            virtual const CResult Multiply(const CMatrix<Ty>* pMatrix);
 
            virtual const CResult Multiply(const CMatrix<Ty>& matrix, CMatrix<Ty>* pTargetMatrix) const;
 
            virtual const CResult Multiply(const CMatrix<Ty>* pMatrix, CMatrix<Ty>* pTargetMatrix) const;
 
            virtual const CResult MultiplyElementwise(const CMatrix<Ty>& matrix);
 
            virtual const CResult MultiplyElementwise(const CMatrix<Ty>* pMatrix);
 
            virtual const CResult MultiplyElementwise(const CMatrix<Ty>& matrix, CMatrix<Ty>* pTargetMatrix) const;
 
            virtual const CResult MultiplyElementwise(const CMatrix<Ty>* pMatrix, CMatrix<Ty>* pTargetMatrix) const;
 
            virtual const CResult Transpose();
 
            virtual const CResult Transpose(CMatrix<Ty>* pTargetMatrix) const;
 
            virtual const CResult Invert();
 
            virtual const CResult Invert(CMatrix<Ty>* pTargetMatrix) const;
 
            virtual const CResult Unit();
 
            virtual const CResult Unit(CMatrix<Ty>* pTargetMatrix) const;
 
            virtual const CResult SetDiagonal(Ty tVal);
 
            virtual const CResult SetDiagonal(Ty tVal, CMatrix<Ty>* pTargetMatrix) const;
 
            virtual const CResult PseudoInverse();
 
            virtual const CResult PseudoInverse(CMatrix<Ty>* pTargetMatrix) const;
 
            virtual Ty GetNorm(const Ty tP = 2) const;
 
            virtual const CResult ReduceSum(const EMatrixReduceType eReduceType, CMatrix<Ty>* pMatResult) const;
 
            virtual const CResult ReduceMean(const EMatrixReduceType eReduceType, CMatrix<Ty>* pMatResult) const;
 
            virtual const CResult ReduceMax(const EMatrixReduceType eReduceType, CMatrix<Ty>* pMatResult) const;
 
            virtual const CResult ReduceMin(const EMatrixReduceType eReduceType, CMatrix<Ty>* pMatResult) const;
 
            virtual CMatrix<Ty> T() const;
 
            virtual CMatrix<Ty> I() const;
 
            virtual CMatrix<Ty> P() const;
 
            virtual CMatrix<Ty> U() const;
 
            virtual double Determinant() const;
 
            virtual const CResult Hessenberg(CMatrix<Ty>* pMatrixH, CMatrix<Ty>* pMatrixP = nullptr) const;
 
            virtual const CResult SVD(CMatrix<Ty>* pMatrixU, CMatrix<Ty>* pMatrixSig, CMatrix<Ty>* pMatrixVT) const;
 
            virtual const CResult QR(CMatrix<Ty>* pMatrixQ, CMatrix<Ty>* pMatrixR) const;
 
            virtual const CResult LU(CMatrix<Ty>* pMatrixL, CMatrix<Ty>* pMatrixU) const;
 
            virtual const CResult LUP(CMatrix<Ty>* pMatrixP, CMatrix<Ty>* pMatrixL, CMatrix<Ty>* pMatrixU) const;
 
            virtual bool CheckRange(Ty tMin, Ty tMax) const;
 
            virtual const CResult MulTransposed(const CMatrix<Ty>* pMatrixSource, CMatrix<Ty>* pMatrixDestination, int32_t i32Order, CMatrix<Ty>* pMatDelta = nullptr, double f64Scale = 1.) const;
 
            virtual const CResult CrossProduct(const CMatrix<Ty>& matrixSource2, CMatrix<Ty>* pMatrixDestination) const;
 
            virtual const CResult CrossProduct(const CMatrix<Ty>* pMatrixSource2, CMatrix<Ty>* pMatrixDestination) const;
 
            virtual const CResult Reshape(int64_t i64Row, int64_t i64Column = -1);
 
            virtual const CResult Abs();
 
            virtual const CResult Sqrt();
 
            virtual const CResult Ceil();
 
            virtual const CResult Floor();
 
            virtual const CResult Round();
 
            virtual const CResult Sin();
 
            virtual const CResult Cos();
 
            virtual const CResult Tan();
 
            virtual const CResult Arcsin();
 
            virtual const CResult Arccos();
 
            virtual const CResult Arctan2(const CMatrix<Ty>& matrixX);
 
            virtual const CResult Arctan2(const CMatrix<Ty>* pMatrixX);
 
            virtual const CResult Degrees();
 
            virtual const CResult Radians();
 
            virtual const CResult Log();
 
            virtual const CResult Log2();
 
            virtual const CResult Log10();
 
            virtual const CResult Log1p();
 
            virtual const CResult Clip(Ty tMin, Ty tMax);
 
            virtual const CResult ArgMin(int64_t& i64ResultRow, int64_t& i64ResultColumn) const;
 
            virtual const CResult ArgMin(Base::CFLArray<int64_t>& flaResultIndex, EMatrixAxis eAxis) const;
 
            virtual const CResult ArgMin(Base::CFLArray<int64_t>* pFlaResultIndex, EMatrixAxis eAxis) const;
 
            virtual const CResult ArgMax(int64_t& i64ResultRow, int64_t& i64ResultColumn) const;
 
            virtual const CResult ArgMax(Base::CFLArray<int64_t>& flaResultIndex, EMatrixAxis eAxis) const;
 
            virtual const CResult ArgMax(Base::CFLArray<int64_t>* pFlaResultIndex, EMatrixAxis eAxis) const;
 
            virtual const CResult ArgSort(CMatrix<Ty>* pMatResultIndex = nullptr, EMatrixSortOrder eOrder = EMatrixSortOrder_Ascending, EMatrixAxis eAxis = EMatrixAxis_Column);
 
            virtual Ty Min() const;
 
            virtual const CResult Min(CMatrix<Ty>& matResult, EMatrixAxis eAxis) const;
 
            virtual const CResult Min(CMatrix<Ty>* pMatResult, EMatrixAxis eAxis) const;
 
            virtual Ty Max() const;
 
            virtual const CResult Max(CMatrix<Ty>& matResult, EMatrixAxis eAxis) const;
 
            virtual const CResult Max(CMatrix<Ty>* pMatResult, EMatrixAxis eAxis) const;
 
            virtual Ty Sum() const;
 
            virtual const CResult Sum(CMatrix<Ty>& matResult, EMatrixAxis eAxis) const;
 
            virtual const CResult Sum(CMatrix<Ty>* pMatResult, EMatrixAxis eAxis) const;
 
            virtual Ty Mean() const;
 
            virtual const CResult Mean(CMatrix<Ty>& matResult, EMatrixAxis eAxis) const;
 
            virtual const CResult Mean(CMatrix<Ty>* pMatResult, EMatrixAxis eAxis) const;
 
            virtual Ty Std() const;
 
            virtual const CResult Std(CMatrix<Ty>& matResult, EMatrixAxis eAxis) const;
 
            virtual const CResult Std(CMatrix<Ty>* pMatResult, EMatrixAxis eAxis) const;
 
            virtual const CResult HStack(const CMatrix<Ty>& matInput, CMatrix<Ty>* pMatResult = nullptr);
 
            virtual const CResult HStack(const CMatrix<Ty>* pMatInput, CMatrix<Ty>* pMatResult = nullptr);
 
            virtual const CResult VStack(const CMatrix<Ty>& matInput, CMatrix<Ty>* pMatResult = nullptr);
 
            virtual const CResult VStack(const CMatrix<Ty>* pMatInput, CMatrix<Ty>* pMatResult = nullptr);
 
            virtual const CResult Swap(CMatrix<Ty>& matRight);
 
            virtual const CResult Swap(CMatrix<Ty>* pMatRight);
 
            virtual const CResult Diff(CMatrix<Ty>& matResult, EMatrixAxis eAxis = EMatrixAxis_Column, int64_t i64Depth = 1) const;
 
            virtual const CResult Diff(CMatrix<Ty>* pMatResult, EMatrixAxis eAxis = EMatrixAxis_Column, int64_t i64Depth = 1) const;
 
            virtual const CResult Dot(const CMatrix<Ty>* pMatInput);
 
            virtual const CResult Dot(const CMatrix<Ty>* pMatInput, CMatrix<Ty>* pMatResult) const;
 
            virtual double Prod() const;
 
            virtual const CResult Prod(Base::CFLArray<double>& flaResult, EMatrixAxis eAxis) const;
 
            virtual const CResult Prod(Base::CFLArray<double>* pFlaResult, EMatrixAxis eAxis) const;
 
            virtual const CResult Unique(CMatrix<Ty>& matResult) const;
 
            virtual const CResult Unique(CMatrix<Ty>* pMatResult) const;
 
            virtual const CResult Unique(CMatrix<Ty>& matResult, EMatrixAxis eAxis) const;
 
            virtual const CResult Unique(CMatrix<Ty>* pMatResult, EMatrixAxis eAxis) const;
 
            virtual bool Any() const;
 
            virtual const CResult Any(EMatrixAxis eAxis, CMatrix<Ty>& matResult) const;
 
            virtual const CResult Any(EMatrixAxis eAxis, CMatrix<Ty>* pMatResult) const;
 
            static const CResult Where(const CMatrix<Ty>& matCondition, const CMatrix<Ty>& matTrue, const CMatrix<Ty>& matFalse, CMatrix<Ty>& matResult);
 
            static const CResult Where(const CMatrix<Ty>& matCondition, const CMatrix<Ty>& matTrue, const CMatrix<Ty>& matFalse, CMatrix<Ty>* pMatResult);
 
            static const CResult Where(const CMatrix<Ty>* pMatCondition, const CMatrix<Ty>* pMatTrue, const CMatrix<Ty>* pMatFalse, CMatrix<Ty>& matResult);
 
            static const CResult Where(const CMatrix<Ty>* pMatCondition, const CMatrix<Ty>* pMatTrue, const CMatrix<Ty>* pMatFalse, CMatrix<Ty>* pMatResult);
 
            static const CResult Where(const CMatrix<Ty>& matCondition, const CMatrix<Ty>& matTrue, Ty tFalse, CMatrix<Ty>& matResult);
 
            static const CResult Where(const CMatrix<Ty>& matCondition, const CMatrix<Ty>& matTrue, Ty tFalse, CMatrix<Ty>* pMatResult);
 
            static const CResult Where(const CMatrix<Ty>* pMatCondition, const CMatrix<Ty>* pMatTrue, Ty tFalse, CMatrix<Ty>& matResult);
 
            static const CResult Where(const CMatrix<Ty>* pMatCondition, const CMatrix<Ty>* pMatTrue, Ty tFalse, CMatrix<Ty>* pMatResult);
 
            static const CResult Where(const CMatrix<Ty>& matCondition, Ty tTrue, const CMatrix<Ty>& matFalse, CMatrix<Ty>& matResult);
 
            static const CResult Where(const CMatrix<Ty>& matCondition, Ty tTrue, const CMatrix<Ty>& matFalse, CMatrix<Ty>* pMatResult);
 
            static const CResult Where(const CMatrix<Ty>* pMatCondition, Ty tTrue, const CMatrix<Ty>* pMatFalse, CMatrix<Ty>& matResult);
 
            static const CResult Where(const CMatrix<Ty>* pMatCondition, Ty tTrue, const CMatrix<Ty>* pMatFalse, CMatrix<Ty>* pMatResult);
 
            static const CResult Where(const CMatrix<Ty>& matCondition, Ty tTrue, Ty tFalse, CMatrix<Ty>& matResult);
 
            static const CResult Where(const CMatrix<Ty>& matCondition, Ty tTrue, Ty tFalse, CMatrix<Ty>* pMatResult);
 
            static const CResult Where(const CMatrix<Ty>* pMatCondition, Ty tTrue, Ty tFalse, CMatrix<Ty>& matResult);
 
            static const CResult Where(const CMatrix<Ty>* pMatCondition, Ty tTrue, Ty tFalse, CMatrix<Ty>* pMatResult);
 
            static const CResult SolveLU(CMatrix<Ty>* pMatL, CMatrix<Ty>* pMatU, CMatrix<Ty>* pMatB, CMatrix<Ty>* pMatRes);
 
            static const CResult SolveLUP(CMatrix<Ty>* pMatP, CMatrix<Ty>* pMatL, CMatrix<Ty>* pMatU, CMatrix<Ty>* pMatB, CMatrix<Ty>* pMatRes);
 
            static const CResult Solve(CMatrix<Ty>* pMatA, CMatrix<Ty>* pMatB, CMatrix<Ty>* pMatRes);
 
            static const CResult ConjugateGradient(const CMatrix<Ty>* pMatA, const CMatrix<Ty>* pMatB, CMatrix<Ty>* pMatRes, bool bSparseMatrix = false, double f64Tolerance = 1e-5, int64_t i64MaxIteratorCount = 10000);
 
            static const CResult GetSimilarity(const CFLPointArray& flpaSrcPoints, const CFLPointArray& flpaDstPoints, CMatrix<Ty>* pMatResult);
 
            static const CResult GetSimilarity(const CFLPointArray* pFlpaSrcPoints, const CFLPointArray* pFlpaDstPoints, CMatrix<Ty>* pMatResult);
 
            static const CResult GetSimilarity(const Base::CFLArray<Base::TPoint<Ty>>& flaSrcPoints, const Base::CFLArray<Base::TPoint<Ty>>& flaDstPoints, CMatrix<Ty>* pMatResult);
 
            static const CResult GetSimilarity(const Base::CFLArray<Base::TPoint<Ty>>* pFlaSrcPoints, const Base::CFLArray<Base::TPoint<Ty>>* pFlaDstPoints, CMatrix<Ty>* pMatResult);
 
            static const CResult GetSimilarity(const Base::CFLArray<Ty>& flaSrcX, const Base::CFLArray<Ty>& flaSrcY, const Base::CFLArray<Ty>& flaDstX, const Base::CFLArray<Ty>& flaDstY, CMatrix<Ty>* pMatResult);
 
            static const CResult GetSimilarity(const Base::CFLArray<Ty>* pFlaSrcX, const Base::CFLArray<Ty>* pFlaSrcY, const Base::CFLArray<Ty>* pFlaDstX, const Base::CFLArray<Ty>* pFlaDstY, CMatrix<Ty>* pMatResult);
 
            virtual const CResult Save(const Base::CFLString<wchar_t>& strFilePath) const;
 
            virtual const CResult Save(const Base::CFLString<wchar_t>* pStrFilePath) const;
 
            virtual const CResult Load(const Base::CFLString<wchar_t>& strFilePath);
 
            virtual const CResult Load(const Base::CFLString<wchar_t>* pStrFilePath);
 
            virtual const CResult SaveCSV(const Base::CFLString<wchar_t>& strFilePath) const;
 
            virtual const CResult SaveCSV(const Base::CFLString<wchar_t>* pStrFilePath) const;
 
            virtual const CResult LoadCSV(const Base::CFLString<wchar_t>& strFilePath);
 
            virtual const CResult LoadCSV(const Base::CFLString<wchar_t>* pStrFilePath);
 
 
            virtual EAccuracy GetOperationAccuracy();
 
            virtual const CResult SetOperationAccuracy(EAccuracy eOperationAccuracy);
 
            virtual bool IsReferenceEnabled() const;
 
 
 
            SupportToDuplicateObject(CMatrix, *this);
            DeclareGetClassType();
 
        private:
            const CResult InternalGetProcessingMode(Base::CProcessingUnitCPU::EInstruction* pEMode, int32_t* pCoreCount = nullptr) const;
 
        protected:
            Ty* m_pTVectors;
            Ty** m_pTVectorsYCache;
            int64_t m_i64Column;
            int64_t m_i64Row;
            int64_t m_i64ElementCount;
            int64_t m_i64TotalSizeByte;
            bool m_bBufferCreated;
            bool m_bReference;
            EAccuracy m_eOperationAccuracy;
 
            template <typename Ty>
            friend class FL_EXPORT CMatrixFor3D;
        };
 
        typedef CMatrix<float> CMatrixF;
        typedef CMatrix<double> CMatrixD;
    }
}