int main()
{
double*** dp3_Seed = new double**;
int *ip1_SeedRowCount = new int;
int *ip1_SeedColumnCount = new int;
int i_RowCount, i_ColumnCount, i_MaxNonZerosInRows;
//populate the Jacobian. Uncomment one of the 2 matrices below
/* 1x1 matrix
i_RowCount = 1;
i_ColumnCount = 1;
i_MaxNonZerosInRows = 1;
unsigned int **uip2_JacobianSparsityPattern = new unsigned int *[i_RowCount];//[1][1]
for(int i=0;i<i_RowCount;i++) uip2_JacobianSparsityPattern[i] = new unsigned int[i_MaxNonZerosInRows + 1];
uip2_JacobianSparsityPattern[0][0] = 1; uip2_JacobianSparsityPattern[0][1] = 0;
//*/
//* 32x9 matrix
i_RowCount = 32;
i_ColumnCount = 9;
i_MaxNonZerosInRows = 3;
unsigned int **uip2_JacobianSparsityPattern = new unsigned int *[i_RowCount];//[32][9]
for(int i=0;i<i_RowCount;i++) uip2_JacobianSparsityPattern[i] = new unsigned int[i_MaxNonZerosInRows + 1];
uip2_JacobianSparsityPattern[0][0] = 0;
uip2_JacobianSparsityPattern[1][0] = 1; uip2_JacobianSparsityPattern[1][1] = 0;
uip2_JacobianSparsityPattern[2][0] = 1; uip2_JacobianSparsityPattern[2][1] = 1;
uip2_JacobianSparsityPattern[3][0] = 1; uip2_JacobianSparsityPattern[3][1] = 2;
uip2_JacobianSparsityPattern[4][0] = 1; uip2_JacobianSparsityPattern[4][1] = 0;
uip2_JacobianSparsityPattern[5][0] = 3; uip2_JacobianSparsityPattern[5][1] = 0; uip2_JacobianSparsityPattern[5][2] = 1; uip2_JacobianSparsityPattern[5][3] = 3;
uip2_JacobianSparsityPattern[6][0] = 3; uip2_JacobianSparsityPattern[6][1] = 1; uip2_JacobianSparsityPattern[6][2] = 2; uip2_JacobianSparsityPattern[6][3] = 4;
uip2_JacobianSparsityPattern[7][0] = 2; uip2_JacobianSparsityPattern[7][1] = 2; uip2_JacobianSparsityPattern[7][2] = 5;
uip2_JacobianSparsityPattern[8][0] = 1; uip2_JacobianSparsityPattern[8][1] = 3;
uip2_JacobianSparsityPattern[9][0] = 3; uip2_JacobianSparsityPattern[9][1] = 3; uip2_JacobianSparsityPattern[9][2] = 4; uip2_JacobianSparsityPattern[9][3] = 6;
uip2_JacobianSparsityPattern[10][0] = 3; uip2_JacobianSparsityPattern[10][1] = 4; uip2_JacobianSparsityPattern[10][2] = 5; uip2_JacobianSparsityPattern[10][3] = 7;
uip2_JacobianSparsityPattern[11][0] = 2; uip2_JacobianSparsityPattern[11][1] = 5; uip2_JacobianSparsityPattern[11][2] = 8;
uip2_JacobianSparsityPattern[12][0] = 1; uip2_JacobianSparsityPattern[12][1] = 6;
uip2_JacobianSparsityPattern[13][0] = 2; uip2_JacobianSparsityPattern[13][1] = 6; uip2_JacobianSparsityPattern[13][2] = 7;
uip2_JacobianSparsityPattern[14][0] = 2; uip2_JacobianSparsityPattern[14][1] = 7; uip2_JacobianSparsityPattern[14][2] = 8;
uip2_JacobianSparsityPattern[15][0] = 1; uip2_JacobianSparsityPattern[15][1] = 8;
uip2_JacobianSparsityPattern[16][0] = 1; uip2_JacobianSparsityPattern[16][1] = 0;
uip2_JacobianSparsityPattern[17][0] = 2; uip2_JacobianSparsityPattern[17][1] = 0; uip2_JacobianSparsityPattern[17][2] = 1;
uip2_JacobianSparsityPattern[18][0] = 2; uip2_JacobianSparsityPattern[18][1] = 1; uip2_JacobianSparsityPattern[18][2] = 2;
uip2_JacobianSparsityPattern[19][0] = 1; uip2_JacobianSparsityPattern[19][1] = 2;
uip2_JacobianSparsityPattern[20][0] = 2; uip2_JacobianSparsityPattern[20][1] = 0; uip2_JacobianSparsityPattern[20][2] = 3;
uip2_JacobianSparsityPattern[21][0] = 3; uip2_JacobianSparsityPattern[21][1] = 1; uip2_JacobianSparsityPattern[21][2] = 3; uip2_JacobianSparsityPattern[21][3] = 4;
uip2_JacobianSparsityPattern[22][0] = 3; uip2_JacobianSparsityPattern[22][1] = 2; uip2_JacobianSparsityPattern[22][2] = 4; uip2_JacobianSparsityPattern[22][3] = 5;
uip2_JacobianSparsityPattern[23][0] = 1; uip2_JacobianSparsityPattern[23][1] = 5;
uip2_JacobianSparsityPattern[24][0] = 2; uip2_JacobianSparsityPattern[24][1] = 3; uip2_JacobianSparsityPattern[24][2] = 6;
uip2_JacobianSparsityPattern[25][0] = 3; uip2_JacobianSparsityPattern[25][1] = 4; uip2_JacobianSparsityPattern[25][2] = 6; uip2_JacobianSparsityPattern[25][3] = 7;
uip2_JacobianSparsityPattern[26][0] = 3; uip2_JacobianSparsityPattern[26][1] = 5; uip2_JacobianSparsityPattern[26][2] = 7; uip2_JacobianSparsityPattern[26][3] = 8;
uip2_JacobianSparsityPattern[27][0] = 1; uip2_JacobianSparsityPattern[27][1] = 8;
uip2_JacobianSparsityPattern[28][0] = 1; uip2_JacobianSparsityPattern[28][1] = 6;
uip2_JacobianSparsityPattern[29][0] = 1; uip2_JacobianSparsityPattern[29][1] = 7;
uip2_JacobianSparsityPattern[30][0] = 1; uip2_JacobianSparsityPattern[30][1] = 8;
uip2_JacobianSparsityPattern[31][0] = 0;
//*/
//Step 1: Read the sparsity pattern of the given Jacobian matrix (compressed sparse rows format)
//and create the corresponding bipartite graph
BipartiteGraphPartialColoringInterface * g = new BipartiteGraphPartialColoringInterface(SRC_MEM_ADOLC, uip2_JacobianSparsityPattern, i_RowCount, i_ColumnCount);
//Step 2: Do Partial-Distance-Two-Coloring the bipartite graph with the specified ordering
g->PartialDistanceTwoColoring( "SMALLEST_LAST", "COLUMN_PARTIAL_DISTANCE_TWO");
//Step 3: From the coloring information, create and return the seed matrix
(*dp3_Seed) = g->GetSeedMatrix(ip1_SeedRowCount, ip1_SeedColumnCount);
/* Notes:
In stead of doing step 1-3, you can just call the bellow function:
g->GenerateSeedJacobian(uip2_JacobianSparsityPattern, i_RowCount,i_ColumnCount, dp3_Seed, ip1_SeedRowCount, ip1_SeedColumnCount, "COLUMN_PARTIAL_DISTANCE_TWO", "SMALLEST_LAST"); // compress columns. This function is inside BipartiteGraphPartialColoringInterface class
*/
cout<<"Finish GenerateSeed()"<<endl;
//this SECTION is just for displaying the result
g->PrintBipartiteGraph();
g->PrintColumnPartialColors();
g->PrintColumnPartialColoringMetrics();
double **RSeed = *dp3_Seed;
int rows = g->GetColumnVertexCount();
int cols = g->GetRightVertexColorCount();
cout<<"Right Seed matrix: ("<<rows<<","<<cols<<")"<<endl;
for(int i=0; i<rows; i++) {
for(int j=0; j<cols; j++) {
cout<<setw(6)<<RSeed[i][j];
}
cout<<endl;
}
//END SECTION
Pause();
//GraphColoringInterface * g = new GraphColoringInterface();
delete g;
g = NULL;
//double*** dp3_Seed = new double**;
delete dp3_Seed;
dp3_Seed = NULL;
RSeed = NULL;
//int *ip1_SeedRowCount = new int;
delete ip1_SeedRowCount;
ip1_SeedRowCount = NULL;
//int *ip1_SeedColumnCount = new int;
delete ip1_SeedColumnCount;
ip1_SeedColumnCount = NULL;
//unsigned int **uip2_HessianSparsityPattern = new unsigned int *[i_RowCount];//[5][5]
free_2DMatrix(uip2_JacobianSparsityPattern, i_RowCount);
uip2_JacobianSparsityPattern = NULL;
return 0;
}
int main()
{
// s_InputFile = baseDir + <name of the input file>
string s_InputFile; //path of the input file
s_InputFile = baseDir;
s_InputFile += DIR_SEPARATOR; s_InputFile += "Graphs"; s_InputFile += DIR_SEPARATOR; s_InputFile += "column-compress.mtx";
//s_InputFile += DIR_SEPARATOR; s_InputFile += "Graphs"; s_InputFile += DIR_SEPARATOR; s_InputFile += "hess_pat.mtx";
// Step 1: Determine sparsity structure of the Jacobian.
// This step is done by an AD tool. For the purpose of illustration here, we read the structure from a file,
// and store the structure in a Compressed Row Format and then ADIC format.
unsigned int *** uip3_SparsityPattern = new unsigned int **; //uip3_ means triple pointers of type unsigned int
double*** dp3_Value = new double**; //dp3_ means triple pointers of type double. Other prefixes follow the same notation
int rowCount, columnCount;
ConvertMatrixMarketFormat2RowCompressedFormat(s_InputFile, uip3_SparsityPattern, dp3_Value,rowCount, columnCount);
cout<<"just for debugging purpose, display the 2 matrices: the matrix with SparsityPattern only and the matrix with Value"<<endl;
cout<<"Matrix rowCount = "<<rowCount<<"; columnCount = "<<columnCount<<endl;
cout<<fixed<<showpoint<<setprecision(2); //formatting output
cout<<"(*uip3_SparsityPattern)"<<endl;
displayCompressedRowMatrix((*uip3_SparsityPattern),rowCount, true);
cout<<"(*dp3_Value)"<<endl;
displayCompressedRowMatrix((*dp3_Value),rowCount);
cout<<"Finish ConvertMatrixMarketFormat2RowCompressedFormat()"<<endl;
Pause();
std::list<std::set<int> > lsi_SparsityPattern;
std::list<std::vector<double> > lvd_Value;
ConvertRowCompressedFormat2ADIC( (*uip3_SparsityPattern) , rowCount, (*dp3_Value), lsi_SparsityPattern, lvd_Value);
cout<<"just for debugging purpose, display the matrix in ADIC format rowCount = "<<rowCount<<endl;
cout<<"Display lsi_SparsityPattern"<<endl;
DisplayADICFormat_Sparsity(lsi_SparsityPattern);
cout<<"Display lvd_Value"<<endl;
DisplayADICFormat_Value(lvd_Value);
cout<<"Finish ConvertRowCompressedFormat2CSR()"<<endl;
Pause();
//Step 2: Coloring.
int *ip1_ColorCount = new int; //The number of distinct colors used to color the graph
//Step 2.1: Read the sparsity pattern of the given Jacobian matrix (ADIC format)
//and create the corresponding bipartite graph
BipartiteGraphPartialColoringInterface *g = new BipartiteGraphPartialColoringInterface(SRC_MEM_ADIC, &lsi_SparsityPattern, columnCount);
//Step 2.2: Do Partial-Distance-Two-Coloring the bipartite graph with the specified ordering
g->PartialDistanceTwoColoring("SMALLEST_LAST", "COLUMN_PARTIAL_DISTANCE_TWO");
//Step 2.3: From the coloring information, you can get the vector of colorIDs of left or right vertices (depend on the s_ColoringVariant that you choose)
vector<int> vi_VertexPartialColors;
g->GetVertexPartialColors(vi_VertexPartialColors);
*ip1_ColorCount = g->GetRightVertexColorCount();
cout<<"Finish GetVertexPartialColors()"<<endl;
//Display results of step 2
printf(" Display vi_VertexPartialColors *ip1_ColorCount=%d \n",*ip1_ColorCount);
displayVector(vi_VertexPartialColors);
Pause();
// Step 3: Obtain the Jacobian-seed matrix product.
// This step will also be done by an AD tool. For the purpose of illustration here, the orginial matrix V
// (for Values) is multiplied with the seed matrix S (represented as a vector of colors vi_VertexPartialColors).
// The resulting matrix is stored in dp3_CompressedMatrix.
double*** dp3_CompressedMatrix = new double**;
cout<<"Start MatrixMultiplication()"<<endl;
MatrixMultiplication_VxS__usingVertexPartialColors(lsi_SparsityPattern, lvd_Value, columnCount, vi_VertexPartialColors, *ip1_ColorCount, dp3_CompressedMatrix);
cout<<"Finish MatrixMultiplication()"<<endl;
displayMatrix(*dp3_CompressedMatrix,rowCount,*ip1_ColorCount);
Pause();
//Step 4: Recover the numerical values of the original matrix from the compressed representation.
// The new values are store in "lvd_NewValue"
std::list<std::vector<double> > lvd_NewValue;
JacobianRecovery1D* jr1d = new JacobianRecovery1D;
jr1d->RecoverD2Cln_ADICFormat(g, *dp3_CompressedMatrix, lsi_SparsityPattern, lvd_NewValue);
cout<<"Finish Recover()"<<endl;
DisplayADICFormat_Value(lvd_NewValue);
Pause();
//Check for consistency, make sure the values in the 2 matrices are the same.
if (ADICMatricesAreEqual(lvd_Value, lvd_NewValue,0)) cout<< "lvd_Value == lvd_NewValue"<<endl;
else cout<< "lvd_Value != lvd_NewValue"<<endl;
Pause();
//Deallocate memory using functions in Utilities/MatrixDeallocation.h
free_2DMatrix(uip3_SparsityPattern, rowCount);
uip3_SparsityPattern=NULL;
free_2DMatrix(dp3_Value, rowCount);
dp3_Value=NULL;
free_2DMatrix(dp3_CompressedMatrix, rowCount);
dp3_CompressedMatrix = NULL;
delete ip1_ColorCount;
ip1_ColorCount = NULL;
delete jr1d;
jr1d = NULL;
delete g;
g=NULL;
return 0;
}