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

Add max and min to function2D

Browse Source
This commit is contained in:
kradchen
2023-12-04 14:53:46 +08:00
parent 3438121b0c
commit 09d9e52eb0
7 changed files with 1134 additions and 67 deletions
Download Patch File Download Diff File Expand all files Collapse all files

461
test/Function2D_Cuda_Test.cpp Normal file
View File

@@ -0,0 +1,461 @@
#include <gtest/gtest.h>
#include <chrono>
#include "CudaMatrix.h"
#include "Function.h"
#include "Matrix.h"
#include "TestUtility.h"
#include "Function2D.h"
#include "Function2D.cuh"
class Function2D_Cuda_Test:public ::testing::Test
{
protected:
static void SetUpFunction2DCudaTester(){
}
static void TearDownTestCase(){
}
public:
Aurora::Matrix B;
Aurora::CudaMatrix dB;
void SetUp(){
}
void TearDown(){
}
};
TEST_F(Function2D_Cuda_Test, min)
{
{
float *dataB = Aurora::random(4096*41472);
B = Aurora::Matrix::fromRawData(dataB, 4096, 41472);
dB = B.toDeviceMatrix();
long r,c;
auto start_time_ = std::chrono::high_resolution_clock::now();
auto ret1 = Aurora::min(B, Aurora::FunctionDirection::Column,r,c);
auto end_time = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
start_time_ = std::chrono::high_resolution_clock::now();
auto ret2 = Aurora::min(dB, Aurora::FunctionDirection::Column,r,c);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
for (size_t i = 0; i < ret1.getDataSize(); i++)
{
ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
start_time_ = std::chrono::high_resolution_clock::now();
ret1 = Aurora::min(B, Aurora::FunctionDirection::Row,r,c);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
start_time_ = std::chrono::high_resolution_clock::now();
ret2 = Aurora::min(dB, Aurora::FunctionDirection::Row,r,c);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
for (size_t i = 0; i < ret1.getDataSize(); i++)
{
ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
}
{
float *dataB = Aurora::random(3157*111);
B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
dB = B.toDeviceMatrix();
long r,c;
auto start_time_ = std::chrono::high_resolution_clock::now();
auto ret1 = Aurora::min(B, Aurora::FunctionDirection::Column,r,c);
auto end_time = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
start_time_ = std::chrono::high_resolution_clock::now();
auto ret2 = Aurora::min(dB, Aurora::FunctionDirection::Column,r,c);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
for (size_t i = 0; i < ret1.getDataSize(); i++)
{
ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
B.forceReshape( 111,3157, 1);
dB = B.toDeviceMatrix();
start_time_ = std::chrono::high_resolution_clock::now();
ret1 = Aurora::min(B, Aurora::FunctionDirection::Column,r,c);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
start_time_ = std::chrono::high_resolution_clock::now();
ret2 = Aurora::min(dB, Aurora::FunctionDirection::Column,r,c);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
for (size_t i = 0; i < ret1.getDataSize(); i++)
{
ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
}
{
float *dataB = Aurora::random(3157*111);
B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
dB = B.toDeviceMatrix();
long r,c;
auto start_time_ = std::chrono::high_resolution_clock::now();
auto ret1 = Aurora::min(B, 500.5f);
auto end_time = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
start_time_ = std::chrono::high_resolution_clock::now();
auto ret2 = Aurora::min(dB, 500.5f);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
for (size_t i = 0; i < ret1.getDataSize(); i++)
{
ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
}
{
float *dataB = Aurora::random(3157*111);
float *dataA = Aurora::random(3157*111);
auto A = Aurora::Matrix::fromRawData(dataA, 3157, 111);
B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
auto dA = A.toDeviceMatrix();
dB = B.toDeviceMatrix();
long r,c;
auto start_time_ = std::chrono::high_resolution_clock::now();
auto ret1 = Aurora::min(B, A);
auto end_time = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
start_time_ = std::chrono::high_resolution_clock::now();
auto ret2 = Aurora::min(dB, dA);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
for (size_t i = 0; i < ret1.getDataSize(); i++)
{
ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
}
{
float *dataB = Aurora::random(3157*111);
float *dataA = Aurora::random(3157);
auto A = Aurora::Matrix::fromRawData(dataA, 3157, 1);
B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
auto dA = A.toDeviceMatrix();
dB = B.toDeviceMatrix();
long r,c;
auto start_time_ = std::chrono::high_resolution_clock::now();
auto ret1 = Aurora::min(B, A);
auto end_time = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
start_time_ = std::chrono::high_resolution_clock::now();
auto ret2 = Aurora::min(dB, dA);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
for (size_t i = 0; i < ret1.getDataSize(); i++)
{
ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
start_time_ = std::chrono::high_resolution_clock::now();
ret2 = Aurora::min(dA, dB);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
for (size_t i = 0; i < ret1.getDataSize(); i++)
{
ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
}
{
float *dataB = Aurora::random(3157*111);
float *dataA = Aurora::random(111);
auto A = Aurora::Matrix::fromRawData(dataA, 1, 111);
B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
auto dA = A.toDeviceMatrix();
dB = B.toDeviceMatrix();
long r,c;
auto start_time_ = std::chrono::high_resolution_clock::now();
auto ret1 = Aurora::min(B, A);
auto end_time = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
start_time_ = std::chrono::high_resolution_clock::now();
auto ret2 = Aurora::min(dB, dA);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
for (size_t i = 0; i < ret1.getDataSize(); i++)
{
ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
}
}
TEST_F(Function2D_Cuda_Test, max)
{
{
float *dataB = Aurora::random(4096*41472);
B = Aurora::Matrix::fromRawData(dataB, 4096, 41472);
dB = B.toDeviceMatrix();
long r,c;
auto start_time_ = std::chrono::high_resolution_clock::now();
auto ret1 = Aurora::max(B, Aurora::FunctionDirection::Column,r,c);
auto end_time = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
start_time_ = std::chrono::high_resolution_clock::now();
auto ret2 = Aurora::max(dB, Aurora::FunctionDirection::Column,r,c);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
for (size_t i = 0; i < ret1.getDataSize(); i++)
{
ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
start_time_ = std::chrono::high_resolution_clock::now();
ret1 = Aurora::max(B, Aurora::FunctionDirection::Row,r,c);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
start_time_ = std::chrono::high_resolution_clock::now();
ret2 = Aurora::max(dB, Aurora::FunctionDirection::Row,r,c);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
for (size_t i = 0; i < ret1.getDataSize(); i++)
{
ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
}
{
float *dataB = Aurora::random(3157*111);
B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
dB = B.toDeviceMatrix();
long r,c;
auto start_time_ = std::chrono::high_resolution_clock::now();
auto ret1 = Aurora::max(B, Aurora::FunctionDirection::Column,r,c);
auto end_time = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
start_time_ = std::chrono::high_resolution_clock::now();
auto ret2 = Aurora::max(dB, Aurora::FunctionDirection::Column,r,c);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
for (size_t i = 0; i < ret1.getDataSize(); i++)
{
ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
B.forceReshape( 111,3157, 1);
dB = B.toDeviceMatrix();
start_time_ = std::chrono::high_resolution_clock::now();
ret1 = Aurora::max(B, Aurora::FunctionDirection::Column,r,c);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
start_time_ = std::chrono::high_resolution_clock::now();
ret2 = Aurora::max(dB, Aurora::FunctionDirection::Column,r,c);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
for (size_t i = 0; i < ret1.getDataSize(); i++)
{
ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
}
{
float *dataB = Aurora::random(3157*111);
B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
dB = B.toDeviceMatrix();
long r,c;
auto start_time_ = std::chrono::high_resolution_clock::now();
auto ret1 = Aurora::max(B, 500.5f);
auto end_time = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
start_time_ = std::chrono::high_resolution_clock::now();
auto ret2 = Aurora::max(dB, 500.5f);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
for (size_t i = 0; i < ret1.getDataSize(); i++)
{
ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
}
{
float *dataB = Aurora::random(3157*111);
float *dataA = Aurora::random(3157*111);
auto A = Aurora::Matrix::fromRawData(dataA, 3157, 111);
B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
auto dA = A.toDeviceMatrix();
dB = B.toDeviceMatrix();
long r,c;
auto start_time_ = std::chrono::high_resolution_clock::now();
auto ret1 = Aurora::max(B, A);
auto end_time = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
start_time_ = std::chrono::high_resolution_clock::now();
auto ret2 = Aurora::max(dB, dA);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
for (size_t i = 0; i < ret1.getDataSize(); i++)
{
ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
}
{
float *dataB = Aurora::random(3157*111);
float *dataA = Aurora::random(3157);
auto A = Aurora::Matrix::fromRawData(dataA, 3157, 1);
B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
auto dA = A.toDeviceMatrix();
dB = B.toDeviceMatrix();
long r,c;
auto start_time_ = std::chrono::high_resolution_clock::now();
auto ret1 = Aurora::max(B, A);
auto end_time = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
start_time_ = std::chrono::high_resolution_clock::now();
auto ret2 = Aurora::max(dB, dA);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
for (size_t i = 0; i < ret1.getDataSize(); i++)
{
ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
start_time_ = std::chrono::high_resolution_clock::now();
ret2 = Aurora::max(dA, dB);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
for (size_t i = 0; i < ret1.getDataSize(); i++)
{
ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
}
{
float *dataB = Aurora::random(3157*111);
float *dataA = Aurora::random(111);
auto A = Aurora::Matrix::fromRawData(dataA, 1, 111);
B = Aurora::Matrix::fromRawData(dataB, 3157, 111);
auto dA = A.toDeviceMatrix();
dB = B.toDeviceMatrix();
long r,c;
auto start_time_ = std::chrono::high_resolution_clock::now();
auto ret1 = Aurora::max(B, A);
auto end_time = std::chrono::high_resolution_clock::now();
auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test1 duration: " << duration.count() << " ms" << std::endl;
start_time_ = std::chrono::high_resolution_clock::now();
auto ret2 = Aurora::max(dB, dA);
end_time = std::chrono::high_resolution_clock::now();
duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time_);
std::cout << "Test2 duration: " << duration.count() << " ms" << std::endl;
ASSERT_EQ(ret1.getDimSize(0),ret2.getDimSize(0));
ASSERT_EQ(ret1.getDimSize(1),ret2.getDimSize(1));
ASSERT_EQ(ret1.getDimSize(2),ret2.getDimSize(2));
for (size_t i = 0; i < ret1.getDataSize(); i++)
{
ASSERT_FLOAT_EQ(ret1[i], ret2.getValue(i))<<", index at :"<<i;
}
}
}

103
test/Function2D_Test.cpp
View File

@@ -73,13 +73,16 @@ TEST_F(Function2D_Test, std){
}
TEST_F(Function2D_Test, min) {
float *dataA = new float[3]{1, 2, 3};
float *dataA = new float[3]{1, 2,-9};
float *dataB = new float[9]{2, 3, 3, 2, 2, -1, 3, 3, 3};
float *dataC = new float[1]{1.5};
float *dataE = new float[12]{2, 3, 3, 2, 2, -1, 3, 3, 3,1,-5,7};
auto A = Aurora::Matrix::fromRawData(dataA, 3, 1);
auto B = Aurora::Matrix::fromRawData(dataB, 3, 3);
auto C = Aurora::Matrix::fromRawData(dataC, 1);
auto D = Aurora::Matrix::copyFromRawData(dataA, 1, 3);
auto E = Aurora::Matrix::copyFromRawData(dataE, 4, 3);
Aurora::Matrix ret = Aurora::min(B);
EXPECT_EQ(1, ret.getDimSize(0));
EXPECT_EQ(3, ret.getDimSize(1));
@@ -99,32 +102,64 @@ TEST_F(Function2D_Test, min) {
long r,c;
ret = Aurora::min(A, Aurora::Column,r,c);
EXPECT_FLOAT_EQ(1, ret.getDataSize());
EXPECT_FLOAT_EQ(1, ret.getData()[0]);
EXPECT_EQ(0, r);
EXPECT_FLOAT_EQ(-9, ret.getData()[0]);
EXPECT_EQ(2, r);
EXPECT_EQ(0, c);
ret = Aurora::min(D);
EXPECT_EQ(1, ret.getDimSize(0));
EXPECT_EQ(1, ret.getDimSize(1));
EXPECT_FLOAT_EQ(1, ret.getData()[0]);
EXPECT_FLOAT_EQ(-9, ret.getData()[0]);
ret = Aurora::min(A, C);
EXPECT_FLOAT_EQ(3, ret.getDataSize());
EXPECT_FLOAT_EQ(1, ret.getData()[0]);
EXPECT_FLOAT_EQ(1.5, ret.getData()[1]);
EXPECT_FLOAT_EQ(1.5, ret.getData()[2]);
EXPECT_FLOAT_EQ(-9, ret.getData()[2]);
// mat x row-vec
ret = Aurora::min(B,D);
EXPECT_FLOAT_EQ(9, ret.getDataSize());
EXPECT_FLOAT_EQ(1, ret.getData()[0]);
EXPECT_FLOAT_EQ(1, ret.getData()[1]);
EXPECT_FLOAT_EQ(1, ret.getData()[2]);
EXPECT_FLOAT_EQ(-1, ret.getData()[5]);
EXPECT_FLOAT_EQ(-9, ret.getData()[8]);
// row-vec x mat
ret = Aurora::min(D,E);
EXPECT_FLOAT_EQ(12, ret.getDataSize());
EXPECT_FLOAT_EQ(1, ret.getData()[0]);
EXPECT_FLOAT_EQ(1, ret.getData()[1]);
EXPECT_FLOAT_EQ(-1, ret.getData()[5]);
EXPECT_FLOAT_EQ(-9, ret.getData()[8]);
D.forceReshape(3,1,1);
ret = Aurora::min(D,B);
EXPECT_FLOAT_EQ(9, ret.getDataSize());
EXPECT_FLOAT_EQ(1, ret.getData()[0]);
EXPECT_FLOAT_EQ(2, ret.getData()[1]);
EXPECT_FLOAT_EQ(-9, ret.getData()[5]);
EXPECT_FLOAT_EQ(-9, ret.getData()[8]);
D.forceReshape(3,1,1);
//col-vec x mat
ret = Aurora::min(D,B);
EXPECT_FLOAT_EQ(9, ret.getDataSize());
EXPECT_FLOAT_EQ(1, ret.getData()[0]);
EXPECT_FLOAT_EQ(2, ret.getData()[1]);
EXPECT_FLOAT_EQ(-9, ret.getData()[5]);
//mat x col-vec
ret = Aurora::min(E,D);
EXPECT_FLOAT_EQ(0, ret.getDataSize());
}
TEST_F(Function2D_Test, max) {
float *dataA = new float[3]{1, 2, 3};
float *dataC = new float[3]{1, 2, 4};
float *dataB = new float[9]{2, 3, 3, 2, 2, 1, 3, 3, 3};
TEST_F(Function2D_Test, max)
{
float *dataA = new float[3]{1, 2,-9};
float *dataB = new float[9]{2, 3, 3, 2, 2, -1, 3, 3, 3};
float *dataC = new float[1]{1.5};
float *dataE = new float[12]{2, 3, 3, 2, 2, -1, 3, 3, 3,1,-5,7};
auto A = Aurora::Matrix::fromRawData(dataA, 3, 1);
auto B = Aurora::Matrix::fromRawData(dataB, 3, 3);
auto C = Aurora::Matrix::fromRawData(dataC, 3, 1);
auto C = Aurora::Matrix::fromRawData(dataC, 1);
auto D = Aurora::Matrix::copyFromRawData(dataA, 1, 3);
auto E = Aurora::Matrix::copyFromRawData(dataE, 4, 3);
Aurora::Matrix ret = Aurora::max(B);
EXPECT_EQ(1, ret.getDimSize(0));
@@ -145,17 +180,51 @@ TEST_F(Function2D_Test, max) {
long r,c;
ret = Aurora::max(A, Aurora::Column,r,c);
EXPECT_FLOAT_EQ(1, ret.getDataSize());
EXPECT_FLOAT_EQ(3, ret.getData()[0]);
EXPECT_EQ(2, r);
EXPECT_FLOAT_EQ(2, ret.getData()[0]);
EXPECT_EQ(1, r);
EXPECT_EQ(0, c);
auto D = Aurora::Matrix::copyFromRawData(dataA, 1, 3);
ret = Aurora::max(D);
EXPECT_EQ(1, ret.getDimSize(0));
EXPECT_EQ(1, ret.getDimSize(1));
EXPECT_FLOAT_EQ(3, ret.getData()[0]);
EXPECT_FLOAT_EQ(2, ret.getData()[0]);
ret = Aurora::max(A, C);
EXPECT_FLOAT_EQ(3, ret.getDataSize());
EXPECT_FLOAT_EQ(1.5, ret.getData()[0]);
EXPECT_FLOAT_EQ(2, ret.getData()[1]);
EXPECT_FLOAT_EQ(1.5, ret.getData()[2]);
// mat x row-vec
ret = Aurora::max(B,D);
EXPECT_FLOAT_EQ(9, ret.getDataSize());
EXPECT_FLOAT_EQ(2, ret.getData()[0]);
EXPECT_FLOAT_EQ(3, ret.getData()[1]);
EXPECT_FLOAT_EQ(2, ret.getData()[5]);
EXPECT_FLOAT_EQ(3, ret.getData()[8]);
// row-vec x mat
ret = Aurora::max(D,E);
EXPECT_FLOAT_EQ(12, ret.getDataSize());
EXPECT_FLOAT_EQ(2, ret.getData()[0]);
EXPECT_FLOAT_EQ(3, ret.getData()[1]);
EXPECT_FLOAT_EQ(2, ret.getData()[5]);
EXPECT_FLOAT_EQ(3, ret.getData()[8]);
D.forceReshape(3,1,1);
ret = Aurora::max(D,B);
EXPECT_FLOAT_EQ(9, ret.getDataSize());
EXPECT_FLOAT_EQ(2, ret.getData()[0]);
EXPECT_FLOAT_EQ(3, ret.getData()[1]);
EXPECT_FLOAT_EQ(-1, ret.getData()[5]);
EXPECT_FLOAT_EQ(3, ret.getData()[8]);
D.forceReshape(3,1,1);
//col-vec x mat
ret = Aurora::max(D,B);
EXPECT_FLOAT_EQ(9, ret.getDataSize());
EXPECT_FLOAT_EQ(2, ret.getData()[0]);
EXPECT_FLOAT_EQ(3, ret.getData()[1]);
EXPECT_FLOAT_EQ(-1, ret.getData()[5]);
//mat x col-vec
ret = Aurora::max(E,D);
EXPECT_FLOAT_EQ(0, ret.getDataSize());
ret = Aurora::max(A,C);
EXPECT_FLOAT_EQ(4, ret.getData()[2]);
}
TEST_F(Function2D_Test, sum) {