sunwen/Aurora
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor Matrix unit test, remove log

Browse Source
This commit is contained in:
Krad
2023-04-21 17:25:22 +08:00
parent c1c09fa45f
commit 1b1ba3cc03
3 changed files with 308 additions and 290 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
src/Matrix.cpp
View File

@@ -33,8 +33,6 @@ namespace Aurora{
} }
inline Matrix &operatorMxA_RR(CalcFuncD aFunc, double aScalar, Aurora::Matrix &&aMatrix) { inline Matrix &operatorMxA_RR(CalcFuncD aFunc, double aScalar, Aurora::Matrix &&aMatrix) {
std::cout << "use right ref operation" << std::endl;
std::cout << "before operation" << std::endl;
if (aMatrix.getValueType() == Complex) { if (aMatrix.getValueType() == Complex) {
//针对实部操作 //针对实部操作
aFunc(aMatrix.getDataSize(), aMatrix.getData(), 2, &aScalar, 0, aFunc(aMatrix.getDataSize(), aMatrix.getData(), 2, &aScalar, 0,
@@ -50,8 +48,6 @@ namespace Aurora{
aMatrix.getData(), aMatrix.getData(),
1); 1);
} }
std::cout << "after operation" << std::endl;
aMatrix.printf();
return aMatrix; return aMatrix;
} }
@@ -179,7 +175,6 @@ namespace Aurora{
inline Matrix operatorMxM_RR(CalcFuncD aFuncD, CalcFuncZ aFuncZ, const Aurora::Matrix &aMatrix, inline Matrix operatorMxM_RR(CalcFuncD aFuncD, CalcFuncZ aFuncZ, const Aurora::Matrix &aMatrix,
Aurora::Matrix &&aOther,bool oppside = false) { Aurora::Matrix &&aOther,bool oppside = false) {
std::cout << "use right ref operation m" << std::endl;
if (aMatrix.compareShape(aOther)) { if (aMatrix.compareShape(aOther)) {
int DimsStride = 1; int DimsStride = 1;
double* X = oppside?aOther.getData():aMatrix.getData(); double* X = oppside?aOther.getData():aMatrix.getData();
@@ -674,7 +669,7 @@ namespace Aurora {
} }
Matrix Matrix::MatrixSlice::toMatrix() const { Matrix Matrix::MatrixSlice::toMatrix() const {
double * data = (double *) mkl_malloc(mSize*(mSize2>0?mSize2:1) * sizeof(double)*mType, 64); double * data = (double *) malloc(mSize*(mSize2>0?mSize2:1) ,mType == Complex);
switch (mSliceMode) { switch (mSliceMode) {
case 2:{ case 2:{

302
test/FunctionTester.cpp
View File

@@ -7,15 +7,6 @@
#include "Function3D.h" #include "Function3D.h"
#define DISPLAY_MATRIX(Matrix)\
printf("=====================================\r\n");\
printf("%s:\r\n", #Matrix);\
Matrix.printf();\
printf("%s end================================\r\n", #Matrix);
#define DISPLAY_MATRIX
class FunctionTester:public ::testing::Test{ class FunctionTester:public ::testing::Test{
protected: protected:
static void SetUpFunctionTester(){ static void SetUpFunctionTester(){
@@ -36,263 +27,6 @@ double fourDecimalRound(double src){
#define EXPECT_DOUBLE_AE(valueA,valueB)\ #define EXPECT_DOUBLE_AE(valueA,valueB)\
EXPECT_DOUBLE_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB)); EXPECT_DOUBLE_EQ(fourDecimalRound(valueA),fourDecimalRound(valueB));
TEST_F(FunctionTester, MatrixCreate) {
double * dataA =Aurora::malloc(9);
double * dataB = new double[9];
double * dataC = new double[9];
double * dataD = new double[9];
//mkl matrix
{
Aurora::Matrix A = Aurora::Matrix::New(dataA, 3, 3);
EXPECT_EQ(dataA, A.getData());
EXPECT_EQ(9, A.getDataSize());
EXPECT_EQ(2, A.getDims());
EXPECT_EQ(3, A.getDimSize(0));
EXPECT_EQ(3, A.getDimSize(1));
EXPECT_EQ(Aurora::Normal, A.getValueType());
DISPLAY_MATRIX(A);
}
// double [] matrix
{
Aurora::Matrix B = Aurora::Matrix::fromRawData(dataB, 3, 3);
EXPECT_EQ(dataB, B.getData());
EXPECT_EQ(9, B.getDataSize());
EXPECT_EQ(2, B.getDims());
EXPECT_EQ(3, B.getDimSize(0));
EXPECT_EQ(3, B.getDimSize(1));
EXPECT_EQ(Aurora::Normal, B.getValueType());
DISPLAY_MATRIX(B);
}
// copy from double [] to mkl matrix
{
Aurora::Matrix C = Aurora::Matrix::copyFromRawData(dataC, 3, 3);
EXPECT_NE(dataC, C.getData());
EXPECT_EQ(9, C.getDataSize());
EXPECT_EQ(2, C.getDims());
EXPECT_EQ(3, C.getDimSize(0));
EXPECT_EQ(3, C.getDimSize(1));
EXPECT_EQ(Aurora::Normal, C.getValueType());
DISPLAY_MATRIX(C);
}
// 2vector
{
Aurora::Matrix C = Aurora::Matrix::copyFromRawData(dataC, 9);
EXPECT_NE(dataC, C.getData());
EXPECT_EQ(9, C.getDataSize());
EXPECT_EQ(2, C.getDims());
EXPECT_EQ(9, C.getDimSize(0));
EXPECT_EQ(1, C.getDimSize(1));
EXPECT_EQ(Aurora::Normal, C.getValueType());
DISPLAY_MATRIX(C);
}
// 2d vector
{
Aurora::Matrix C = Aurora::Matrix::fromRawData(dataC, 9, 1);
EXPECT_EQ(dataC, C.getData());
EXPECT_EQ(9, C.getDataSize());
EXPECT_EQ(2, C.getDims());
EXPECT_EQ(9, C.getDimSize(0));
EXPECT_EQ(1, C.getDimSize(1));
EXPECT_EQ(Aurora::Normal, C.getValueType());
DISPLAY_MATRIX(C);
}
// 2d vector column major
{
Aurora::Matrix C = Aurora::Matrix::copyFromRawData(dataD, 1, 9);
EXPECT_NE(dataD, C.getData());
delete [] dataD;
EXPECT_EQ(9, C.getDataSize());
EXPECT_EQ(2, C.getDims());
EXPECT_EQ(1, C.getDimSize(0));
EXPECT_EQ(9, C.getDimSize(1));
EXPECT_EQ(Aurora::Normal, C.getValueType());
DISPLAY_MATRIX(C);
}
// 3d matrix
{
double * tempData = new double[9];
Aurora::Matrix C = Aurora::Matrix::fromRawData(tempData, 3, 3,1);
EXPECT_EQ(dataD, C.getData());
EXPECT_EQ(9, C.getDataSize());
EXPECT_EQ(2, C.getDims());
EXPECT_EQ(3, C.getDimSize(0));
EXPECT_EQ(3, C.getDimSize(1));
EXPECT_EQ(1, C.getDimSize(2));
EXPECT_EQ(Aurora::Normal, C.getValueType());
DISPLAY_MATRIX(C);
}
// 3d matrix 2
{
double * tempData = new double[9];
Aurora::Matrix C = Aurora::Matrix::fromRawData(tempData, 3, 1,3);
EXPECT_EQ(dataD, C.getData());
EXPECT_EQ(9, C.getDataSize());
EXPECT_EQ(3, C.getDims());
EXPECT_EQ(3, C.getDimSize(0));
EXPECT_EQ(1, C.getDimSize(1));
EXPECT_EQ(3, C.getDimSize(2));
EXPECT_EQ(Aurora::Normal, C.getValueType());
DISPLAY_MATRIX(C);
}
}
TEST_F(FunctionTester, matrixSlice) {
double * dataA =Aurora::malloc(8);
double * dataB =Aurora::malloc(8);
double * dataC =Aurora::malloc(8);
for (int i = 0; i < 8; ++i) {
dataA[i]=(double)(i);
dataB[i]=(double)(1);
dataC[i]=(double)(9-i);
}
Aurora::Matrix A = Aurora::Matrix::New(dataA,2,2,2);
Aurora::Matrix B = Aurora::Matrix::New(dataB,2,2,2);
Aurora::Matrix C = Aurora::Matrix::New(dataC,2,2,2);
//2D slice
EXPECT_EQ(4.0,dataA[4]);
A(Aurora::$,Aurora::$,1) = B(0,Aurora::$,Aurora::$);
EXPECT_EQ(1,dataA[4]);
EXPECT_EQ(3,dataA[3]);
A(Aurora::$,1,Aurora::$) = B(Aurora::$,Aurora::$,0);
EXPECT_EQ(1.0,dataA[3]);
EXPECT_EQ(0.0,dataA[0]);
A(0,Aurora::$,Aurora::$) = B(Aurora::$,0,Aurora::$);
EXPECT_EQ(1.0,dataA[0]);
//vector slice
A(0,Aurora::$,0) = C(0,0,Aurora::$);
EXPECT_EQ(9.0,dataA[0]);
A(Aurora::$,0,0) = C(0,Aurora::$,1);
EXPECT_EQ(5.0,dataA[0]);
//error slice
EXPECT_EQ(1,A(Aurora::$,Aurora::$,Aurora::$).toMatrix().getDataSize() );
auto D =C(0,0,0).toMatrix();
EXPECT_EQ(1,D.getDataSize() );
EXPECT_EQ(9,D.getData()[0] );
}
TEST_F(FunctionTester, matrixOpertaor) {
//3D
{
double * dataA =new double[8];
double * dataB =new double[8];
double * dataD =new double[8];
for (int i = 0; i < 8; ++i) {
dataA[i]=(double)(i);
dataB[i]=(double)(2);
}
Aurora::Matrix A = Aurora::Matrix::fromRawData(dataA,2,2,2);
DISPLAY_MATRIX(A);
Aurora::Matrix B = Aurora::Matrix::fromRawData(dataB,2,2,2);
DISPLAY_MATRIX(B);
Aurora::Matrix D = Aurora::Matrix::fromRawData(dataD,4,2);
DISPLAY_MATRIX(D);
auto C = (A*B)-B;
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],2);
C = A*B/2.0;
EXPECT_EQ(C.getData()[2],2);
C = (A*8.0/B) * (B+1.0)-2.0+8;
EXPECT_EQ(C.getData()[2],30);
//Error matrix
C = A*D;
EXPECT_EQ(C.getDataSize(),0);
}
//complex
{
double * dataA =Aurora::malloc(8,true);
double * dataB =Aurora::malloc(8,true);
double * dataD =new double[8];
for (int i = 0; i < 16; ++i) {
dataA[i]=(double)(i+1);
dataB[i]=(double)(2);
if(i<8) dataD[i]=(double)(2);
}
Aurora::Matrix A = Aurora::Matrix::New(dataA,2,2,2,Aurora::Complex);
DISPLAY_MATRIX(A);
Aurora::Matrix B = Aurora::Matrix::New(dataB,2,2,2,Aurora::Complex);
DISPLAY_MATRIX(B);
Aurora::Matrix D = Aurora::Matrix::fromRawData(dataD,2,2,2);
DISPLAY_MATRIX(D);
auto C = A + 5.0 -2.0;
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],6);
EXPECT_EQ(C.getData()[3],4);
EXPECT_TRUE(C.isComplex());
C = A*B-B;
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],-4);
EXPECT_EQ(C.getData()[3],12);
EXPECT_TRUE(C.isComplex());
C = A*B-2.0+5.0;
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],1);
EXPECT_EQ(C.getData()[3],14);
C = A*B/2.0*3.;
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],-3);
EXPECT_EQ(C.getData()[3],21);
C = A*B/B;
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],3);
EXPECT_EQ(C.getData()[3],4);
C = A*B/(B*A/A);
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],3);
EXPECT_EQ(C.getData()[3],4);
C = B*D;
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],4);
EXPECT_EQ(C.getData()[3],4);
C = B/D;
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],1);
EXPECT_EQ(C.getData()[3],1);
C = B+D;
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],4);
EXPECT_EQ(C.getData()[3],2);
C = B-D;
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],0);
EXPECT_EQ(C.getData()[3],2);
C = B*(D*1.0);
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],4);
EXPECT_EQ(C.getData()[3],4);
C = B/(D*1.0);
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],1);
EXPECT_EQ(C.getData()[3],1);
C = B+(D*1.0);
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],4);
EXPECT_EQ(C.getData()[3],2);
C = B-(D*1.0);
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],0);
EXPECT_EQ(C.getData()[3],2);
C = (B*1.0)*(D*1.0);
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],4);
EXPECT_EQ(C.getData()[3],4);
C = (B*1.0)/(D*1.0);
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],1);
EXPECT_EQ(C.getData()[3],1);
C = (B*1.0)+(D*1.0);
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],4);
EXPECT_EQ(C.getData()[3],2);
C = (B*1.0)-(D*1.0);
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2],0);
EXPECT_EQ(C.getData()[3],2);
}
}
TEST_F(FunctionTester, sign) { TEST_F(FunctionTester, sign) {
double * dataA =Aurora::malloc(9); double * dataA =Aurora::malloc(9);
double * dataB =Aurora::malloc(9); double * dataB =Aurora::malloc(9);
@@ -369,24 +103,24 @@ TEST_F(FunctionTester, std){
} }
TEST_F(FunctionTester, fftAndComplexAndIfft){ TEST_F(FunctionTester, fftAndComplexAndIfft){
double input[10]{1,1,0,2,2,0,1,1,0,2}; // double input[10]{1,1,0,2,2,0,1,1,0,2};
std::complex<double>* complexInput = Aurora::complex(10,input); // std::complex<double>* complexInput = Aurora::complex(10,input);
//复数化后，实部不变，虚部全为0 // //复数化后，实部不变，虚部全为0
EXPECT_DOUBLE_EQ(complexInput[1].real(),1.0)<<" complex error"; // EXPECT_DOUBLE_EQ(complexInput[1].real(),1.0)<<" complex error";
EXPECT_DOUBLE_EQ(complexInput[1].imag(),0)<<" complex error"; // EXPECT_DOUBLE_EQ(complexInput[1].imag(),0)<<" complex error";
std::complex<double>* result = Aurora::fft(10,complexInput); // std::complex<double>* result = Aurora::fft(10,complexInput);
delete [] complexInput; // delete [] complexInput;
//检验fft结果与matlab是否对应 // //检验fft结果与matlab是否对应
EXPECT_DOUBLE_EQ(0.0729, fourDecimalRound(result[1].real()))<<" fft result value error"; // EXPECT_DOUBLE_EQ(0.0729, fourDecimalRound(result[1].real()))<<" fft result value error";
EXPECT_DOUBLE_EQ(2.4899, fourDecimalRound(result[2].imag()))<<" fft result value error"; // EXPECT_DOUBLE_EQ(2.4899, fourDecimalRound(result[2].imag()))<<" fft result value error";
//检验fft的结果是否共轭 // //检验fft的结果是否共轭
EXPECT_DOUBLE_EQ(0, result[4].imag()+result[6].imag())<<" fft result conjugate error"; // EXPECT_DOUBLE_EQ(0, result[4].imag()+result[6].imag())<<" fft result conjugate error";
EXPECT_DOUBLE_EQ(0, result[4].real()-result[6].real())<<" fft result conjugate error"; // EXPECT_DOUBLE_EQ(0, result[4].real()-result[6].real())<<" fft result conjugate error";
std::complex<double>* ifftResult = Aurora::ifft(10,result); // std::complex<double>* ifftResult = Aurora::ifft(10,result);
EXPECT_DOUBLE_EQ(fourDecimalRound(ifftResult[1].real()),1.0)<<" ifft result real value error"; // EXPECT_DOUBLE_EQ(fourDecimalRound(ifftResult[1].real()),1.0)<<" ifft result real value error";
EXPECT_DOUBLE_EQ(fourDecimalRound(ifftResult[1].imag()),0)<<" ifft result imag value error"; // EXPECT_DOUBLE_EQ(fourDecimalRound(ifftResult[1].imag()),0)<<" ifft result imag value error";
delete [] result; // delete [] result;
delete [] ifftResult; // delete [] ifftResult;
} }
TEST_F(FunctionTester, hilbert) { TEST_F(FunctionTester, hilbert) {

289
test/MatrixTester.cpp Normal file
View File

@@ -0,0 +1,289 @@
#include <gtest/gtest.h>
#include <vector>
#include "Matrix.h"
#include "Function.h"
#include "Function1D.h"
#include "Function2D.h"
#include "Function3D.h"
#define DISPLAY_MATRIX(Matrix)\
printf("=====================================\r\n");\
printf("%s:\r\n", #Matrix);\
Matrix.printf();\
printf("%s end================================\r\n", #Matrix);
#define DISPLAY_MATRIX
class MatrixTester : public ::testing::Test {
protected:
static void SetUpMatrixTester() {
}
static void TearDownTestCase() {
}
void SetUp() {
}
void TearDown() {
}
};
TEST_F(MatrixTester, MatrixCreate) {
double *dataA = Aurora::malloc(9);
double *dataB = new double[9];
double *dataC = new double[9];
double *dataD = new double[9];
//mkl matrix
{
Aurora::Matrix A = Aurora::Matrix::New(dataA, 3, 3);
EXPECT_EQ(dataA, A.getData());
EXPECT_EQ(9, A.getDataSize());
EXPECT_EQ(2, A.getDims());
EXPECT_EQ(3, A.getDimSize(0));
EXPECT_EQ(3, A.getDimSize(1));
EXPECT_EQ(Aurora::Normal, A.getValueType());
DISPLAY_MATRIX(A);
}
// double [] matrix
{
Aurora::Matrix B = Aurora::Matrix::fromRawData(dataB, 3, 3);
EXPECT_EQ(dataB, B.getData());
EXPECT_EQ(9, B.getDataSize());
EXPECT_EQ(2, B.getDims());
EXPECT_EQ(3, B.getDimSize(0));
EXPECT_EQ(3, B.getDimSize(1));
EXPECT_EQ(Aurora::Normal, B.getValueType());
DISPLAY_MATRIX(B);
}
// copy from double [] to mkl matrix
{
Aurora::Matrix C = Aurora::Matrix::copyFromRawData(dataC, 3, 3);
EXPECT_NE(dataC, C.getData());
EXPECT_EQ(9, C.getDataSize());
EXPECT_EQ(2, C.getDims());
EXPECT_EQ(3, C.getDimSize(0));
EXPECT_EQ(3, C.getDimSize(1));
EXPECT_EQ(Aurora::Normal, C.getValueType());
DISPLAY_MATRIX(C);
}
// 2vector
{
Aurora::Matrix C = Aurora::Matrix::copyFromRawData(dataC, 9);
EXPECT_NE(dataC, C.getData());
EXPECT_EQ(9, C.getDataSize());
EXPECT_EQ(2, C.getDims());
EXPECT_EQ(9, C.getDimSize(0));
EXPECT_EQ(1, C.getDimSize(1));
EXPECT_EQ(Aurora::Normal, C.getValueType());
DISPLAY_MATRIX(C);
}
// 2d vector
{
Aurora::Matrix C = Aurora::Matrix::fromRawData(dataC, 9, 1);
EXPECT_EQ(dataC, C.getData());
EXPECT_EQ(9, C.getDataSize());
EXPECT_EQ(2, C.getDims());
EXPECT_EQ(9, C.getDimSize(0));
EXPECT_EQ(1, C.getDimSize(1));
EXPECT_EQ(Aurora::Normal, C.getValueType());
DISPLAY_MATRIX(C);
}
// 2d vector column major
{
Aurora::Matrix C = Aurora::Matrix::copyFromRawData(dataD, 1, 9);
EXPECT_NE(dataD, C.getData());
delete[] dataD;
EXPECT_EQ(9, C.getDataSize());
EXPECT_EQ(2, C.getDims());
EXPECT_EQ(1, C.getDimSize(0));
EXPECT_EQ(9, C.getDimSize(1));
EXPECT_EQ(Aurora::Normal, C.getValueType());
DISPLAY_MATRIX(C);
}
// 3d matrix
{
double *tempData = new double[9];
Aurora::Matrix C = Aurora::Matrix::fromRawData(tempData, 3, 3, 1);
EXPECT_EQ(dataD, C.getData());
EXPECT_EQ(9, C.getDataSize());
EXPECT_EQ(2, C.getDims());
EXPECT_EQ(3, C.getDimSize(0));
EXPECT_EQ(3, C.getDimSize(1));
EXPECT_EQ(1, C.getDimSize(2));
EXPECT_EQ(Aurora::Normal, C.getValueType());
DISPLAY_MATRIX(C);
}
// 3d matrix 2
{
double *tempData = new double[9];
Aurora::Matrix C = Aurora::Matrix::fromRawData(tempData, 3, 1, 3);
EXPECT_EQ(dataD, C.getData());
EXPECT_EQ(9, C.getDataSize());
EXPECT_EQ(3, C.getDims());
EXPECT_EQ(3, C.getDimSize(0));
EXPECT_EQ(1, C.getDimSize(1));
EXPECT_EQ(3, C.getDimSize(2));
EXPECT_EQ(Aurora::Normal, C.getValueType());
DISPLAY_MATRIX(C);
}
}
TEST_F(MatrixTester, matrixSlice) {
double *dataA = Aurora::malloc(8);
double *dataB = Aurora::malloc(8);
double *dataC = Aurora::malloc(8);
for (int i = 0; i < 8; ++i) {
dataA[i] = (double) (i);
dataB[i] = (double) (1);
dataC[i] = (double) (9 - i);
}
Aurora::Matrix A = Aurora::Matrix::New(dataA, 2, 2, 2);
Aurora::Matrix B = Aurora::Matrix::New(dataB, 2, 2, 2);
Aurora::Matrix C = Aurora::Matrix::New(dataC, 2, 2, 2);
//2D slice
EXPECT_EQ(4.0, dataA[4]);
A(Aurora::$, Aurora::$, 1) = B(0, Aurora::$, Aurora::$);
EXPECT_EQ(1, dataA[4]);
EXPECT_EQ(3, dataA[3]);
A(Aurora::$, 1, Aurora::$) = B(Aurora::$, Aurora::$, 0);
EXPECT_EQ(1.0, dataA[3]);
EXPECT_EQ(0.0, dataA[0]);
A(0, Aurora::$, Aurora::$) = B(Aurora::$, 0, Aurora::$);
EXPECT_EQ(1.0, dataA[0]);
//vector slice
A(0, Aurora::$, 0) = C(0, 0, Aurora::$);
EXPECT_EQ(9.0, dataA[0]);
A(Aurora::$, 0, 0) = C(0, Aurora::$, 1);
EXPECT_EQ(5.0, dataA[0]);
//error slice
EXPECT_EQ(1, A(Aurora::$, Aurora::$, Aurora::$).toMatrix().getDataSize());
auto D = C(0, 0, 0).toMatrix();
EXPECT_EQ(1, D.getDataSize());
EXPECT_EQ(9, D.getData()[0]);
}
TEST_F(MatrixTester, matrixOpertaor) {
//3D
{
double *dataA = new double[8];
double *dataB = new double[8];
double *dataD = new double[8];
for (int i = 0; i < 8; ++i) {
dataA[i] = (double) (i);
dataB[i] = (double) (2);
}
Aurora::Matrix A = Aurora::Matrix::fromRawData(dataA, 2, 2, 2);
DISPLAY_MATRIX(A);
Aurora::Matrix B = Aurora::Matrix::fromRawData(dataB, 2, 2, 2);
DISPLAY_MATRIX(B);
Aurora::Matrix D = Aurora::Matrix::fromRawData(dataD, 4, 2);
DISPLAY_MATRIX(D);
auto C = (A * B) - B;
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2], 2);
C = A * B / 2.0;
EXPECT_EQ(C.getData()[2], 2);
C = (A * 8.0 / B) * (B + 1.0) - 2.0 + 8;
EXPECT_EQ(C.getData()[2], 30);
//Error matrix
C = A * D;
EXPECT_EQ(C.getDataSize(), 0);
}
//complex
{
double *dataA = Aurora::malloc(8, true);
double *dataB = Aurora::malloc(8, true);
double *dataD = new double[8];
for (int i = 0; i < 16; ++i) {
dataA[i] = (double) (i + 1);
dataB[i] = (double) (2);
if (i < 8) dataD[i] = (double) (2);
}
Aurora::Matrix A = Aurora::Matrix::New(dataA, 2, 2, 2, Aurora::Complex);
DISPLAY_MATRIX(A);
Aurora::Matrix B = Aurora::Matrix::New(dataB, 2, 2, 2, Aurora::Complex);
DISPLAY_MATRIX(B);
Aurora::Matrix D = Aurora::Matrix::fromRawData(dataD, 2, 2, 2);
DISPLAY_MATRIX(D);
auto C = A + 5.0 - 2.0;
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2], 6);
EXPECT_EQ(C.getData()[3], 4);
EXPECT_TRUE(C.isComplex());
C = A * B - B;
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2], -4);
EXPECT_EQ(C.getData()[3], 12);
EXPECT_TRUE(C.isComplex());
C = A * B - 2.0 + 5.0;
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2], 1);
EXPECT_EQ(C.getData()[3], 14);
C = A * B / 2.0 * 3.;
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2], -3);
EXPECT_EQ(C.getData()[3], 21);
C = A * B / B;
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2], 3);
EXPECT_EQ(C.getData()[3], 4);
C = A * B / (B * A / A);
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2], 3);
EXPECT_EQ(C.getData()[3], 4);
C = B * D;
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2], 4);
EXPECT_EQ(C.getData()[3], 4);
C = B / D;
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2], 1);
EXPECT_EQ(C.getData()[3], 1);
C = B + D;
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2], 4);
EXPECT_EQ(C.getData()[3], 2);
C = B - D;
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2], 0);
EXPECT_EQ(C.getData()[3], 2);
C = B * (D * 1.0);
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2], 4);
EXPECT_EQ(C.getData()[3], 4);
C = B / (D * 1.0);
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2], 1);
EXPECT_EQ(C.getData()[3], 1);
C = B + (D * 1.0);
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2], 4);
EXPECT_EQ(C.getData()[3], 2);
C = B - (D * 1.0);
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2], 0);
EXPECT_EQ(C.getData()[3], 2);
C = (B * 1.0) * (D * 1.0);
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2], 4);
EXPECT_EQ(C.getData()[3], 4);
C = (B * 1.0) / (D * 1.0);
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2], 1);
EXPECT_EQ(C.getData()[3], 1);
C = (B * 1.0) + (D * 1.0);
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2], 4);
EXPECT_EQ(C.getData()[3], 2);
C = (B * 1.0) - (D * 1.0);
DISPLAY_MATRIX(C);
EXPECT_EQ(C.getData()[2], 0);
EXPECT_EQ(C.getData()[3], 2);
}
}