From 405963ad62d60c4e196dae51e5efd8a528cb7cde Mon Sep 17 00:00:00 2001 From: Krad Date: Thu, 27 Apr 2023 14:39:51 +0800 Subject: [PATCH] Compare and negative for matrix --- src/Matrix.cpp | 167 +++++++++++++++++++++++++++++++++++++++++++++++++ src/Matrix.h | 17 +++++ 2 files changed, 184 insertions(+) diff --git a/src/Matrix.cpp b/src/Matrix.cpp index 1377513..980fdb5 100644 --- a/src/Matrix.cpp +++ b/src/Matrix.cpp @@ -515,6 +515,173 @@ namespace Aurora { } } + Matrix Matrix::operator>(double aScalar) const { + if (isComplex()) { + std::cerr << "Complex cann't compare!" << std::endl; + return Matrix(); + } + Eigen::Map v(getData(), getDataSize()); + double *ret = malloc(getDataSize()); + Eigen::Map result(ret, getDataSize()); + result.setConstant(0.0); + result = (v.array() > aScalar).select(1.0, result); + return New(ret, getDimSize(0), getDimSize(1), getDimSize(2)); + } + + Matrix operator>(double aScalar, const Matrix &matrix) { + if (matrix.isComplex()) { + std::cerr << "Complex cann't compare!" << std::endl; + return Matrix(); + } + Eigen::Map v(matrix.getData(), matrix.getDataSize()); + double *ret = malloc(matrix.getDataSize()); + Eigen::Map result(ret, matrix.getDataSize()); + result.setConstant(0.0); + result = (aScalar>v.array()).select(1.0, result); + return Matrix::New(ret, matrix.getDimSize(0), matrix.getDimSize(1), matrix.getDimSize(2)); + } + + Matrix Matrix::operator>(const Matrix &matrix) const { + if (isComplex() || matrix.isComplex()) { + std::cerr << "Complex cann't compare!" << std::endl; + return Matrix(); + } + if (!compareShape(matrix) && !isScalar() && !matrix.isScalar()) { + std::cerr << "Matrix not equal, matrix 1(" << matrix.getDimSize(0) << "," << matrix.getDimSize(1) << "," + << matrix.getDimSize(2) << "), matrix 2(" << getDimSize(0) << "," << getDimSize(1) << "," + << getDimSize(2) << ")" << std::endl; + return Matrix(); + } + if(isScalar()){ + return getData()[0]>matrix; + } + if(matrix.isScalar()){ + return (*this)>matrix.getData()[0]; + } + Eigen::Map v(getData(), getDataSize()); + Eigen::Map v2(matrix.getData(), matrix.getDataSize()); + double *ret = malloc(matrix.getDataSize()); + Eigen::Map result(ret, matrix.getDataSize()); + result.setConstant(0.0); + result = (v.array() > v2.array()).select(1.0, result); + return Matrix::New(ret, matrix.getDimSize(0), matrix.getDimSize(1), matrix.getDimSize(2)); + } + + Matrix Matrix::operator<(double aScalar) const { + if (isComplex()) { + std::cerr << "Complex cann't compare!" << std::endl; + return Matrix(); + } + Eigen::Map v(getData(), getDataSize()); + double *ret = malloc(getDataSize()); + Eigen::Map result(ret, getDataSize()); + result.setConstant(0.0); + result = (v.array() < aScalar).select(1.0, result); + return New(ret, getDimSize(0), getDimSize(1), getDimSize(2)); + } + + Matrix operator<(double aScalar, const Matrix &matrix) { + if (matrix.isComplex()) { + std::cerr << "Complex cann't compare!" << std::endl; + return Matrix(); + } + Eigen::Map v(matrix.getData(), matrix.getDataSize()); + double *ret = malloc(matrix.getDataSize()); + Eigen::Map result(ret, matrix.getDataSize()); + result.setConstant(0.0); + result = (aScalar < v.array() ).select(1.0, result); + return Matrix::New(ret, matrix.getDimSize(0), matrix.getDimSize(1), matrix.getDimSize(2)); + } + + Matrix Matrix::operator<(const Matrix &matrix) const { + if (isComplex() || matrix.isComplex()) { + std::cerr << "Complex cann't compare!" << std::endl; + return Matrix(); + } + if (!compareShape(matrix) && !isScalar() && !matrix.isScalar()) { + std::cerr << "Matrix not equal, matrix 1(" << matrix.getDimSize(0) << "," << matrix.getDimSize(1) << "," + << matrix.getDimSize(2) << "), matrix 2(" << getDimSize(0) << "," << getDimSize(1) << "," + << getDimSize(2) << ")" << std::endl; + return Matrix(); + } + if(isScalar()){ + return getData()[0] v(getData(), getDataSize()); + Eigen::Map v2(matrix.getData(), matrix.getDataSize()); + double *ret = malloc(matrix.getDataSize()); + Eigen::Map result(ret, matrix.getDataSize()); + result.setConstant(0.0); + result = (v.array() < v2.array()).select(1.0, result); + return Matrix::New(ret, matrix.getDimSize(0), matrix.getDimSize(1), matrix.getDimSize(2)); + } + + Matrix Matrix::operator==(double aScalar) const { + if (isComplex()) { + std::cerr << "Complex cann't compare!" << std::endl; + return Matrix(); + } + Eigen::Map v(getData(), getDataSize()); + double *ret = malloc(getDataSize()); + Eigen::Map result(ret, getDataSize()); + result.setConstant(0.0); + result = (v.array() == aScalar).select(1.0, result); + return New(ret, getDimSize(0), getDimSize(1), getDimSize(2)); + } + + Matrix operator==(double aScalar, const Matrix &matrix) { + if (matrix.isComplex()) { + std::cerr << "Complex cann't compare!" << std::endl; + return Matrix(); + } + Eigen::Map v(matrix.getData(), matrix.getDataSize()); + double *ret = malloc(matrix.getDataSize()); + Eigen::Map result(ret, matrix.getDataSize()); + result.setConstant(0.0); + result = (aScalar == v.array() ).select(1.0, result); + return Matrix::New(ret, matrix.getDimSize(0), matrix.getDimSize(1), matrix.getDimSize(2)); + } + + Matrix Matrix::operator==(const Matrix &matrix) const { + if (isComplex() || matrix.isComplex()) { + std::cerr << "Complex cann't compare!" << std::endl; + return Matrix(); + } + if (!compareShape(matrix) && !isScalar() && !matrix.isScalar()) { + std::cerr << "Matrix not equal, matrix 1(" << matrix.getDimSize(0) << "," << matrix.getDimSize(1) << "," + << matrix.getDimSize(2) << "), matrix 2(" << getDimSize(0) << "," << getDimSize(1) << "," + << getDimSize(2) << ")" << std::endl; + return Matrix(); + } + if(isScalar()){ + return getData()[0]==matrix; + } + if(matrix.isScalar()){ + return (*this)==matrix.getData()[0]; + } + Eigen::Map v(getData(), getDataSize()); + Eigen::Map v2(matrix.getData(), matrix.getDataSize()); + double *ret = malloc(matrix.getDataSize()); + Eigen::Map result(ret, matrix.getDataSize()); + result.setConstant(0.0); + result = (v.array() == v2.array()).select(1.0, result); + return Matrix::New(ret, matrix.getDimSize(0), matrix.getDimSize(1), matrix.getDimSize(2)); + } + + Matrix operator-(Matrix &&aMatrix) { + int size = aMatrix.getDataSize()*aMatrix.getValueType(); + double zero = 0.0; + vdSubI(size,&zero,0,aMatrix.getData(),1,aMatrix.getData(),1); + return aMatrix; + } + + Matrix operator-(const Matrix &aMatrix) { + return -(std::forward(aMatrix.deepCopy())); + } + Matrix::MatrixSlice::MatrixSlice(int aSize,int aStride, double* aData, ValueType aType, int aSliceMode,int aSize2, int aStride2): mSliceMode(aSliceMode),mData(aData), mSize(aSize),mSize2(aSize2), diff --git a/src/Matrix.h b/src/Matrix.h index 4a79529..9d4d1e1 100644 --- a/src/Matrix.h +++ b/src/Matrix.h @@ -122,6 +122,10 @@ namespace Aurora { Matrix operator-(Matrix &&matrix) const; friend Matrix operator-(Matrix &&aMatrix,Matrix &aOther); + //negetive + friend Matrix operator-(Matrix &&aMatrix); + friend Matrix operator-(const Matrix &aMatrix); + // mul Matrix operator*(double aScalar) const; friend Matrix operator*(double aScalar, const Matrix &matrix); @@ -144,6 +148,19 @@ namespace Aurora { Matrix operator^(int times) const; friend Matrix operator^(Matrix &&matrix,int times); + //compare + Matrix operator>(double aScalar) const; + friend Matrix operator>(double aScalar, const Matrix &matrix); + Matrix operator>(const Matrix &matrix) const; + + Matrix operator<(double aScalar) const; + friend Matrix operator<(double aScalar, const Matrix &matrix); + Matrix operator<(const Matrix &matrix) const; + + Matrix operator==(double aScalar) const; + friend Matrix operator==(double aScalar, const Matrix &matrix); + Matrix operator==(const Matrix &matrix) const; + /** * print matrix , only support 2d matrix now */