int main(int argc, const char * argv[])
{
double matrixSize = 5;
double eValue = 4;
std::vector<double> dValues(matrixSize);
std::default_random_engine gen;
std::uniform_int_distribution<double> dist(1, 50);
gen.seed((unsigned int)time(NULL));
for (int i = 0; i < matrixSize; i ++) {
dValues[i] = dist(gen);
}
std::vector<double> randomL;
for (int i = 1; i < matrixSize; i++) {
randomL.push_back(dist(gen));
}
std::cout << std::endl;
Matrix matrixT(matrixSize);
matrixT.GenerateTridiagonal(eValue, dValues);
matrixT.PrintMatrix();
std::cout << std::endl;
std::vector<double> result = matrixT.Multiply(randomL);
for (int i = 0; i < matrixSize; i++) {
std::cout << randomL[i] << "," << std::endl;
}
std::cout << std::endl;
for (int i = 0; i < matrixSize; i++) {
std::cout << result[i] << "," << std::endl;
}
Matrix::SolveTridiagonal(eValue, dValues, result, randomL);
std::cout << "L is: " << std::endl;
for(int i = 0; i < matrixSize; i++)
std::cout << randomL[i] << " ";
return 0;
}
int test_Matrix::serialtest1()
{
fei::SharedPtr<testData> testdata(new testData(localProc_, numProcs_));
std::vector<int>& fieldIDs = testdata->fieldIDs;
std::vector<int>& fieldSizes = testdata->fieldSizes;
std::vector<int>& idTypes = testdata->idTypes;
std::vector<int>& ids = testdata->ids;
fei::SharedPtr<fei::VectorSpace> vspc(new fei::VectorSpace(comm_, "sU_Mat"));
vspc->defineFields(fieldIDs.size(),
&fieldIDs[0],
&fieldSizes[0]);
vspc->defineIDTypes(idTypes.size(), &idTypes[0]);
fei::SharedPtr<fei::MatrixGraph>
matgraph(new fei::MatrixGraph_Impl2(vspc, vspc, "sU_Mat"));
int numIDs = ids.size();
int fieldID = fieldIDs[0];
int idType = idTypes[0];
int patternID = matgraph->definePattern(numIDs, idType, fieldID);
CHK_ERR( matgraph->initConnectivityBlock(0, 1, patternID) );
CHK_ERR( matgraph->initConnectivity(0, 0, &ids[0]) );
CHK_ERR( matgraph->initComplete() );
fei::SharedPtr<fei::FillableMat> ssmat(new fei::FillableMat), ssmatT(new fei::FillableMat);
int localsize = matgraph->getRowSpace()->getNumIndices_Owned();
fei::SharedPtr<fei::Matrix> matrix(new fei::Matrix_Impl<fei::FillableMat>(ssmat, matgraph, localsize));
fei::SharedPtr<fei::Matrix> matrixT(new fei::Matrix_Impl<fei::FillableMat>(ssmatT, matgraph, localsize));
std::vector<int> indices(numIDs);
CHK_ERR( matgraph->getConnectivityIndices(0, 0, numIDs, &indices[0], numIDs) );
std::vector<double> data1(numIDs*numIDs);
std::vector<double*> data2d(numIDs);
int i;
for(i=0; i<numIDs; ++i) {
data2d[i] = &(data1[i*numIDs]);
}
for(i=0; i<numIDs*numIDs; ++i) {
data1[i] = 1.0*i;
}
CHK_ERR( matrix->sumIn(numIDs, &indices[0], numIDs, &indices[0],
&data2d[0], 0) );
CHK_ERR( matrix->sumIn(0, 0, &data2d[0], 0) );
CHK_ERR( matrixT->sumIn(numIDs, &indices[0],
numIDs, &indices[0], &data2d[0], 3) );
CHK_ERR( matrixT->sumIn(0, 0, &data2d[0], 3) );
if (*ssmat != *ssmatT) {
ERReturn(-1);
}
return(0);
}
TEST_F(CublasWrapperTest, matrixTransMatrixMultiply) {
const int numberOfRows = 5;
const int numberOfColumns = 3;
const int numberOfRows2 = 5;
const int numberOfColumns2 = 4;
PinnedHostMatrix matrixT(numberOfRows, numberOfColumns);
PinnedHostMatrix matrix2(numberOfRows2, numberOfColumns2);
matrixT(0, 0) = 1;
matrixT(1, 0) = 2;
matrixT(2, 0) = 3;
matrixT(3, 0) = 4;
matrixT(4, 0) = 5;
matrixT(0, 1) = 10;
matrixT(1, 1) = 20;
matrixT(2, 1) = 30;
matrixT(3, 1) = 40;
matrixT(4, 1) = 50;
matrixT(0, 2) = 1.1;
matrixT(1, 2) = 2.2;
matrixT(2, 2) = 3.3;
matrixT(3, 2) = 4.4;
matrixT(4, 2) = 5.5;
for(int i = 0; i < numberOfRows2; ++i){
matrix2(i, 0) = 6;
}
for(int i = 0; i < numberOfRows2; ++i){
matrix2(i, 1) = 7;
}
for(int i = 0; i < numberOfRows2; ++i){
matrix2(i, 2) = 8;
}
for(int i = 0; i < numberOfRows2; ++i){
matrix2(i, 3) = 9;
}
DeviceMatrix* matrixTDevice = hostToDeviceStream1.transferMatrix(matrixT);
DeviceMatrix* matrix2Device = hostToDeviceStream1.transferMatrix(matrix2);
DeviceMatrix* resultDevice = new DeviceMatrix(numberOfColumns, numberOfColumns2);
cublasWrapper.matrixTransMatrixMultiply(*matrixTDevice, *matrix2Device, *resultDevice);
cublasWrapper.syncStream();
handleCudaStatus(cudaGetLastError(), "Error with matrixTransMatrixMultiply in matrixTransMatrixMultiply: ");
HostMatrix* resultHost = deviceToHostStream1.transferMatrix(*resultDevice);
cublasWrapper.syncStream();
handleCudaStatus(cudaGetLastError(), "Error with transfer in matrixTransMatrixMultiply: ");
EXPECT_EQ(90, (*resultHost)(0, 0));
EXPECT_EQ(105, (*resultHost)(0, 1));
EXPECT_EQ(120, (*resultHost)(0, 2));
EXPECT_EQ(135, (*resultHost)(0, 3));
EXPECT_EQ(900, (*resultHost)(1, 0));
EXPECT_EQ(1050, (*resultHost)(1, 1));
EXPECT_EQ(1200, (*resultHost)(1, 2));
EXPECT_EQ(1350, (*resultHost)(1, 3));
EXPECT_EQ(99, (*resultHost)(2, 0));
EXPECT_EQ(115.5, (*resultHost)(2, 1));
EXPECT_EQ(132, (*resultHost)(2, 2));
EXPECT_EQ(148.5, (*resultHost)(2, 3));
delete matrixTDevice;
delete matrix2Device;
delete resultDevice;
delete resultHost;
}
