FLImagingFoundation/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 *= -1;
                matReturn += value;
                return matReturn;
            }
 
            friend CMatrix<Ty> operator-(const float& value, const CMatrix<Ty>& mat)
            {
                CMatrix<Ty> matReturn(mat);
                matReturn *= -1;
                matReturn += value;
                return matReturn;
            }
 
            friend CMatrix<Ty> operator-(const int64_t& value, const CMatrix<Ty>& mat)
            {
                CMatrix<Ty> matReturn(mat);
                matReturn *= -1;
                matReturn += value;
                return matReturn;
            }
 
            friend CMatrix<Ty> operator-(const int32_t& value, const CMatrix<Ty>& mat)
            {
                CMatrix<Ty> matReturn(mat);
                matReturn *= -1;
                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 bool IsEqual(const CMatrix<double>& matRhs) const;
            virtual bool IsEqual(const CMatrix<double>* pMatRhs) const;
            virtual bool IsEqual(const CMatrix<float>& matRhs) const;
            virtual bool IsEqual(const CMatrix<float>* pMatRhs) const;


            virtual bool IsEqual(const CMatrix<double>& matRhs, double f64Tolerance) const;
            virtual bool IsEqual(const CMatrix<double>* pMatRhs, double f64Tolerance) const;
            virtual bool IsEqual(const CMatrix<float>& matRhs, double f64Tolerance) const;
            virtual bool IsEqual(const CMatrix<float>* pMatRhs, double f64Tolerance) const;


            virtual bool IsShapeEqual(const CMatrix<double>& matRhs) const;
            virtual bool IsShapeEqual(const CMatrix<double>* pMatRhs) const;
            virtual bool IsShapeEqual(const CMatrix<float>& matRhs) const;
            virtual bool IsShapeEqual(const CMatrix<float>* pMatRhs) const;

            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 Schur(CMatrix<Ty>* pMatrixU, CMatrix<Ty>* pMatrixT) 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;
    }
}