CRS representation of 4 dimensional array

We take input of four dimensional array then apply CRS(Compressed  row sparse ), then use some search, save print operation

Full code with explanation

#include
#include
#include
#include
#include
#include

using namespace std;
using std::cout;
using std::cin;

class CRS{

private:

// Counter Variable
int Totnon0, Rownon0;
// Array 4 Dimensions
int DN;
int d1, d2, d3, d4;
// Declare ArrayMD
int ****arrayMD;
// Declare Array RO KO JO CO VL
int *arrayRO;
int *arrayKO;
int *arrayJO;
int *arrayCO;
int *arrayVL;

public:
// Array Iterators
int i, j, k, l;
CRS(){
Totnon0 = 0;
}
void allocateArray();
void assignArrayMD();
void showArrayMD();
void applyCRS();
void showCRSarrays();
void searchLoc();
void searchItem();
void saveArray();
float getFileSize(const char *filename);
int printMenu();
void deallocateArray();
};

//********************************************//
//******* Allocate 4D and other Arrays *******//
//********************************************//

void CRS::allocateArray()
{
DN = 4;
cout<<"No. of Dimension [--- 2 <= Dimension <=4 ---]:" << DN <>DN;

// Input for length of each dimension
for(i = 1; i <= DN; i++)
{
cout<<"Length of Dimension"<< i <<" (d"<< i <>d1;
if(i == 2)
cin>>d2;
if(i == 3)
cin>>d3;
if(i == 4)
cin>>d4;
}

// Allocate Array CO & JO & KO & VL
arrayRO = new int[d1+1];
arrayKO = new int[d1*d2*d3*d4];
arrayJO = new int[d1*d2*d3*d4];
arrayCO = new int[d1*d2*d3*d4];
arrayVL = new int[d1*d2*d3*d4];

//******* Allocate 4D Array *******//

arrayMD = new int***[d1];

for(i = 0; i < d1; i++)
{
arrayMD[i] = new int**[d2];

for(j = 0; j < d2; j++)
{
arrayMD[i][j] = new int*[d3];

for(k = 0; k < d3; k++)
{
arrayMD[i][j][k] = new int[d4];
}
}
}
}

//************************************************//
//************ Assign Array Elements ************//
//************************************************//

void CRS::assignArrayMD()
{
srand((unsigned)time(0));
int lowest = 0, highest = 10;
int range=(highest-lowest);

for(i = 0; i < d1; i++)
{
for(j = 0; j < d2; j++)
{
for(k = 0; k < d3; k++)
{
for(l = 0; l < d4; l++)
{
//arrayMD[i][j][k][l] = rand() % 2;
arrayMD[i][j][k][l] = lowest+int(range*rand()/(RAND_MAX + 1.0));
}
}
}

//cout << endl << endl;
}

}

//************************************************//
//************ Display Array Elements ************//
//************************************************//

void CRS::showArrayMD()
{
for(i = 0; i < d1; i++)
{
//cout << "[" << i << "]" <<endl;

for(j = 0; j < d2; j++)
{
cout << endl << "[" << i << "]" << "[" << j << "]" << endl;

for(k = 0; k < d3; k++)
{
cout << endl;
for(l = 0; l < d4; l++)
{
cout << '\t' << arrayMD[i][j][k][l];
}
}
}

cout << endl << endl;
}

}

//************************************************//
//************** Apply CRS Method ***************//
//***********************************************//

void CRS::applyCRS()
{
Totnon0 = 0;
arrayRO[0] = 1;
for(i = 0; i 0)
{
arrayRO[i] = arrayRO[i - 1] + Rownon0;
}
Rownon0 = 0;
for(j = 0; j < d2; j++)
{
for(k = 0; k < d3; k++)
{
for(l = 0; l < d4; l++)
{
if(arrayMD[i][j][k][l] != 0)
{
arrayVL[Totnon0] = arrayMD[i][j][k][l];
arrayKO[Totnon0] = j;
arrayJO[Totnon0] = k;
arrayCO[Totnon0] = l;
Totnon0++;
Rownon0++;
}
}
}
}

}
arrayRO[d1] = arrayRO[d1 - 1] + Rownon0;

}

//************************************************//
//************** Show Arrays of CRS *************//
//************************************************//

void CRS::showCRSarrays()
{
for(i = 0; i < d1+1; i++)
{
cout<< "arrayRO[" << i <<"]:" << arrayRO[i] << endl ;
}
cout<< endl << endl;
for(i = 0; i < Totnon0; i++)
{
cout<< "arrayVL[" << i <<"]:" << arrayVL[i] << " " ;
cout<< "arrayKO[" << i <<"]:" << arrayKO[i] << " " ;
cout<< "arrayJO[" << i <<"]:" << arrayJO[i] << " " ;
cout<< "arrayCO[" << i <<"]:" << arrayCO[i] << endl ;
cout<< endl << endl;
}

}

//************************************************//
//************* Search by given Item ************//
//************************************************//

void CRS::searchLoc()
{
int Searchval, RO = 0, Row, count = 0;
cout<< "---------- Search by given Item ------------"<< endl <<endl;
cout<>Searchval;

for(i = 0; i < Totnon0; i++)
{
if(arrayVL[i] == Searchval)
{
count++;
RO = 0;
for(j = 0; j i)
{
Row = j;
break;
}
}
cout<<count<<". value = "<< arrayVL[i]<<'\t'<<"ArrayMD["<< Row <<"]["<< arrayCO[i] <<"]"<< endl << endl;

}

}
if(count == 0)
{
cout << Searchval << " - is not found" << endl;
}

}

//************************************************//
//********** Search by given Location ***********//
//************************************************//

void CRS::searchItem()
{
int dim1, dim2, dim3, dim4, found = 0; // RO, CO
cout<< "------------ Search by given Location ------------"<< endl << endl;
for(i = 1; i <= DN; i++)
{
cout<<"Dimension"<< i <<" (dim"<< i <>dim1;
if(i == 2)
cin>>dim2;
if(i == 3)
cin>>dim3;
if(i == 4)
cin>>dim4;
}
int nonZero = arrayRO[dim1 + 1] - arrayRO[dim1];
cout << "No. of Non Zero Elements in Row "<< dim1 <<": "<<nonZero << endl;
for(i = (arrayRO[dim1] - 1); i < (arrayRO[dim1] - 1 + nonZero); i++)
{
if(arrayKO[i] == dim2)
{ //cout<< arrayKO[i]<<endl;
for(j = i; j < (arrayRO[dim1] - 1 + nonZero); j++)
{
if(arrayKO[j] == dim2 && arrayJO[j] == dim3)
{ //cout<< arrayJO[j]<<endl;
for(k = j; k < (arrayRO[dim1] - 1 + nonZero); k++)
{
if(arrayKO[k] == dim2 && arrayJO[k] == dim3 && arrayCO[k] == dim4)
{ //cout<< arrayKO[k]<<endl;
//found = 1;
cout<< "Value is: " << arrayVL[k] << endl << endl;
//break;
goto END;
}

}

}

}

}

}
cout<< "Value is: 0" << endl;
END : ;//exit Loop
}

//************************************************//
//********* Calculating File Size **************//
//************************************************//

float CRS::getFileSize(const char *filename)
{
float result;
FILE *fh = fopen(filename, "r");
fseek(fh, 0, SEEK_END);
result = ftell(fh);
fclose(fh);
return result;
}

//************************************************//
//***************** saveArray ******************//
//************************************************//

void CRS::saveArray()
{
ofstream outputMD("MDArray.txt");
ofstream outputCRS("CRSArray.txt");

for(i = 0; i < d1; i++)
{
for(j = 0; j < d2; j++)
{
for(k = 0; k < d3; k++)
{
for(l = 0; l < d4; l++)
{
outputMD << arrayMD[i][j][k][l];
}
}
}

}

for(i = 0; i < Totnon0; i++)
{
outputCRS<<arrayVL[i];
}

}

//************************************************//
//***************** printMenu ******************//
//************************************************//

int CRS::printMenu()
{
//system ("cls");
cout << "-------------------------------------------------" << endl;
cout << " Compress Row Storage(CRS) Implementation" << endl;
cout << "-------------------------------------------------" << endl;
cout << "\t\t 1. Create a Multi Dimensional Array" << endl;
cout << "\t\t 2. Show All Records of the MD Array" << endl;
cout << "\t\t 3. Apply CRS on the MD Array" << endl;
cout << "\t\t 4. Show All Records of the CRS Arrays" << endl;
cout << "\t\t 5. Search a Location of a given Record" << endl;
cout << "\t\t 6. Search a Record for a given Location" << endl;
cout << "\t\t 7. Save Arrays" << endl;
cout << "\t\t 8. Exit" << endl;

int choice;
cout <> choice;
cout.flush();
return choice;
}

//************************************************//
//************* Deallocate 4D array ************//
//************************************************//

void CRS::deallocateArray()
{
for(i = 0; i < d1; i++)
{
for(j = 0; j < d2; j++)
{
for(k = 0; k < d3; k++)
{
delete[] arrayMD[i][j][k];
}
}

delete[] arrayMD[i];
}
delete[] arrayMD;

// Deallocate CO JO KO and VL array

delete[] arrayVL;
delete[] arrayCO;
delete[] arrayJO;
delete[] arrayKO;
delete[] arrayRO;
}

void credits()
{
std::cout < 0)
{

crs.deallocateArray();
crsapp = 0;
cout << "deallocated" << endl;
}
crs.allocateArray();
crs.assignArrayMD();
allocate = 1;
flag = 1;
break;
}

case 2: // Show the MD the array
{
if(flag == 0)
{
cout << "Array is not Available" << endl;
}
else
crs.showArrayMD();
getch();
//ch = std::getchar();
break;
}

case 3: // Apply CRS
{
if(flag == 0)
{
cout << "Array is not Available and CRS can't be Applied" << endl;
}
else if(flag != 0 && crsapp == 0)
{
crs.applyCRS();
crsapp =1;

}
else
{
cout << "CRS is already Applied" << endl;

}

break;
}

case 4: // Show CRS data
{
if(crsapp == 1)
{

crs.showCRSarrays();
getch();
}
else
cout << "CRS is not even applied" << endl;
break;
}

case 5: //Search by a Item in the CRS Arrays
{
if(crsapp == 1)
{
crs.searchLoc();
getch();
}
else
cout << "CRS is not even applied" << endl;
break;
}

case 6: //Search by a Loc in the CRS arrays
{
if(crsapp == 1)
{
crs.searchItem();
getch();
}
else
cout << "CRS is not even applied" << endl;

break;
}

case 7: // Save Array
{
crs.saveArray();
MDsize = crs.getFileSize("MDArray.txt");
cout << "MDsize: " << MDsize << " bytes" << endl;

CRSsize = crs.getFileSize("CRSArray.txt");
cout << "CRSsize: " << CRSsize << " bytes" << endl;

lambda = CRSsize / MDsize;
cout << "Compression ratio= " << lambda < 0)
{
crs.deallocateArray();
}
credits();
getch();
return 0;
}

hope this helps

Advertisements

About kishor datta gupta

Graduate Research Assistant at University of Memphis Software Engineer at Silicon Orchard LTD. Former Research Assistant at Lamar University Former Software Engineer at Samsung R&D Institute Bangladesh Studies Ph.D. Computer Science at University of Memphis Studied Masters of Science in Computer Sciences at Lamar University Studied BSC in CSE at Khulna University of Engineering and Technology Studied HSC (completed) at Chittagang college 04-06 Studied High school at ST. Placid's High School'04 Studied Junior Secondary School at Saint Mary's School Lives in Memphis, Tennessee
This entry was posted in CPP, DATABASE and tagged , , , , , , , . Bookmark the permalink.

Leave a Reply

Please log in using one of these methods to post your comment:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s