long long int * fastPowerMatrix(long long int *a,long long int size,long long int power) {
int i;
long long int * temp;
long long int *tempTable = malloc(size*size*sizeof(long long int ));
long long int * res = calloc(size*size,sizeof(long long int )); //αρχικοποίηση σε μοναδιαίο πίνακα
for (i=0;i<size;i++)
*(res+i*size+i)=1;
while(power>0) {
if(power&1) {
matrixMul(a,res,tempTable,size);
temp = res;
res = tempTable;
tempTable = temp;
}
power = power>>1;
matrixMul(a,a,tempTable,size);
temp = a;
a = tempTable;
tempTable = temp;
}
return res;
}
int main(int argc, char const *argv[])
{
Matrix a = matrixNew(555555, 2);
Matrix b = matrixNew(2, 555555);
//Matrix b = matrixNew(100, 100);
for (int i = 0; i < matrixGetRows(a); i++) {
for (int j = 0; j < matrixGetCols(a); j++) {
//printf("%d ", (i + 5));
matrixSet(a, i, j, (float) (i + 5));
}
// printf("\n");
}
for (int i = 0; i < matrixGetRows(b); i++) {
for (int j = 0; j < matrixGetCols(b); j++) {
matrixSet(b, i, j, (float) 1.);
}
}
//printMatrix(a);
//printMatrix(b);
Matrix c = matrixMul(a, b);
//Matrix c = matrixNew(9, 13);
printf("\n%d\n-----", (int) c);
printMatrix(c);
return 0;
}
Mat matrixAllocMul(Mat a, Mat b) {
Mat dest;
dest = matrixAlloc(a.row, b.clm);
matrixMul(dest, a, b);
return dest;
}
int GzPushMatrix(GzRender *render, GzMatrix matrix)
{
/*
- push a matrix onto the Ximage stack
- check for stack overflow
*/
if(render->matlevel>=MATLEVELS)
return GZ_FAILURE;
if(render->matlevel==-1)
{
render->matlevel++;
int i=render->matlevel + 1;
memcpy(render->Ximage[render->matlevel],matrix,sizeof(GzMatrix));
//return GZ_SUCCESS;
}
else
{
int i=render->matlevel;
matrixMul(render->Ximage[i],matrix,render->Ximage[render->matlevel+1]);
render->matlevel++;
// return GZ_SUCCESS;
}
if(render->matlevel==0 || render->matlevel==1)
memcpy(render->Xnorm[render->matlevel],defaultMatrix,sizeof(GzMatrix));
else
{
float scaleFactor=0.0;
GzMatrix temp;
memcpy(temp,matrix,sizeof(GzMatrix));
temp[0][3]=0;
temp[1][3]=0;
temp[2][3]=0;
temp[3][3]=1;
float f=sqrt(temp[0][0]*temp[0][0] + temp[1][0]*temp[1][0] + temp[2][0]*temp[2][0]);
scaleFactor=1/f;
for (int i=0;i<3;i++)
{
for(int j=0;j<3;j++)
temp[i][j] = temp[i][j]*scaleFactor;
}
f=0.0;
matrixMul(render->Xnorm[render->matlevel-1],temp, render->Xnorm[render->matlevel]);
}
return GZ_SUCCESS;
}
int main()
{
printf("Testing work:\n");
int n = 9;
int m = 1;
Matrix a = matrixNew(n, m);
for (int i = 0; i < matrixGetRows(a); i++)
for (int j = 0; j < matrixGetCols(a); j++)
matrixSet(a, i, j, (float)(i + 1) / (j + 1));
for (int i = 0; i < matrixGetRows(a); i++)
{
for (int j = 0; j < matrixGetCols(a); j++)
printf("%.5f ", matrixGet(a, i, j));
printf("\n");
}
printf("\n");
Matrix b = matrixScale(a, 10);
for (int i = 0; i < matrixGetRows(b); i++)
{
for (int j = 0; j < matrixGetCols(b); j++)
printf("%.5f ", matrixGet(b, i, j));
printf("\n");
}
printf("\n");
Matrix c = matrixAdd(a, b);
for (int i = 0; i < matrixGetRows(c); i++)
{
for (int j = 0; j < matrixGetCols(c); j++)
printf("%.5f ", matrixGet(c, i, j));
printf("\n");
}
printf("\n");
Matrix d = matrixTranspose(c);
for (int i = 0; i < matrixGetRows(d); i++)
{
for (int j = 0; j < matrixGetCols(d); j++)
printf("%.5f ", matrixGet(d, i, j));
printf("\n");
}
/*c = matrixAdd(a, matrixNew(1, 1));
if (c == NULL)
printf("Yeah\n"), c = matrixNew(3, 3);*/
Matrix e = matrixMul(c, d);
printf("%i %i\n", matrixGetRows(e), matrixGetCols(e));
for (int i = 0; i < matrixGetRows(e); i++)
{
for (int j = 0; j < matrixGetCols(e); j++)
printf("%.5f ", matrixGet(e, i, j));
printf("\n");
}
matrixDelete(a);
matrixDelete(b);
matrixDelete(c);
matrixDelete(d);
matrixDelete(e);
return 0;
}
void display(){
glClear(GL_COLOR_BUFFER_BIT);
vector<Triangle> &tri_vec=triModel[model_idx].triangleList;
double ver[3][3];
double tmp[3], tmp2[3];
for(vector<Triangle>::iterator iter=tri_vec.begin(); iter!=tri_vec.end(); iter++){
double normal[3];
int n=0;
for(int i=0; i<3; i++){
matrixMul(matrix, iter->vertex[i], ver[n]);
matrixMul3(nowView->matrix, iter->normal[i], tmp);
matrixMul(nowView->matrix, iter->vertex[i], tmp2);
normal[n] = 0.0;
for(int j=0; j<3; j++)
normal[n] -= tmp2[j]*tmp[j];
normal[n] /= sqrt(tmp2[0]*tmp2[0]+tmp2[1]*tmp2[1]+tmp2[2]*tmp2[2]);
n++;
}
for(int i=0; i<n; i++){
if(normal[i]+normal[(i+1)%n] > -0.3)
glColor3f((double)iter->foreColor[0]/255, (double)iter->foreColor[1]/255, (double)iter->foreColor[2]/255);
else{
continue;
glColor3f((double)iter->backColor[0]/255, (double)iter->backColor[1]/255, (double)iter->backColor[2]/255);
}
double v1[3], v2[3];
if(insertNode(ver[i], ver[(i+1)%n], v1, v2)){
glBegin(GL_LINES);
glVertex2f(v1[0]*WINDOW_SIZE_X/2+WINDOW_SIZE_X/2, v1[1]*WINDOW_SIZE_Y/2+WINDOW_SIZE_Y/2);
glVertex2f(v2[0]*WINDOW_SIZE_X/2+WINDOW_SIZE_X/2, v2[1]*WINDOW_SIZE_Y/2+WINDOW_SIZE_Y/2);
glEnd();
}
}
}
glutSwapBuffers();
}
void initialize(){
aov = 120;
zNear = 100;
zFar = 1000;
genPM(pm);
for(int i=0; i<MODEL_NUM; i++){
if(!triModel[i].loadFromFile(modelName[i])){
fprintf(stderr, "Can't load file %s\n", modelName[i]);
exit(-1);
}
view[i].init(triModel[i].center, (zFar-zNear)/2);
}
nowView = &view[0];
matrixMul(pm, nowView->matrix, matrix);
}
int main(void) {
int mat[6] = {2,6,5,3,7,8};
int mat2[6] = {2,4,8,3,1,5};
matrix x, y;
x.row = 2;
x.col = 3;
x.content = mat;
y.row = 3;
y.col = 2;
y.content = mat2;
matrix z;
z = matrixMul(x, y);
for(int i = 0; i<z.row; i++){
for(int j = 0; j<z.col; j++)
printf("%d\t",*(z.content+i*z.col+j));
printf("\n");
}
return 0;
}
int GzPushMatrix(GzRender *render, GzMatrix matrix)
{
/*
- push a matrix onto the Ximage stack
- check for stack overflow
*/
//init if render->matlevel = -1
if(render->matlevel == -1){
initMatrix(&(render->Ximage[0]),4);
(render->Ximage[0])[0][0] = 1;
(render->Ximage[0])[1][1] = 1;
(render->Ximage[0])[2][2] = 1;
(render->Ximage[0])[3][3] = 1;
render->matlevel += 1;
}
if(render->matlevel > -1)
{
if (render->matlevel < MATLEVELS - 1)
{
//GzMatrix tempMatrix;
//matrixCopy(matrix, &tempMatrix,4,4);
render->matlevel += 1;
initMatrix(&(render->Ximage[render->matlevel]),4);
matrixMul(render->Ximage[render->matlevel-1], matrix, &(render->Ximage[render->matlevel]),4,4,4);
}else
{
errorCall("GzPushMatrix","matlevel >= MATLEVELS");
AfxMessageBox( "Matrix has full\n" );
return GZ_FAILURE;
}
}else
{
errorCall("GzPushMatrix", "render->matlevel < -1");
//return GZ_FAILURE;
}
return GZ_SUCCESS;
}
int GzPushMatrix(GzRender *render, GzMatrix matrix)
{
/*
- push a matrix onto the Ximage stack
- check for stack overflow
*/
if(render->matlevel>=MATLEVELS)
return GZ_FAILURE;
if(render->matlevel==-1)
{
render->matlevel++;
int i=render->matlevel++;
memcpy(render->Ximage[render->matlevel],matrix,sizeof(GzMatrix));
return GZ_SUCCESS;
}
else
{
int i=render->matlevel;
matrixMul(render->Ximage[i],matrix,render->Ximage[render->matlevel+1]);
render->matlevel++;
return GZ_SUCCESS;
}
}
int main() {
using matrix_t = std::vector<std::vector<float>>;
using matrix_aligned_t = std::vector<std::vector<float, aligned_allocator<float, 32>>>;
assert(testMatrixMul<matrix_t>(*matrixMul<matrix_t>));
assert(testMatrixMul<matrix_aligned_t>(*matrixMulFMA<matrix_aligned_t>));
assert(testMatrixMul<matrix_t>(*matrixMulRotated<matrix_t>));
assert(testMatrixMul<matrix_t>(*matrixMulTiled<matrix_t>));
assert(testMatrixMul<matrix_t>(*matrixMulUnrolled<matrix_t>));
assert(testGaussSeidel());
std::cout << "benching gaussSeidelIteration with different Sizes" << std::endl;
{
auto iterationsGaussSeidel = [](size_t size) -> int {return 50000000/static_cast<int>(std::pow(size, 2)) + 1;};//reduce iterations by complexity
auto opsPerIterationGaussSeidel = [](size_t size) -> double {return std::pow(size, 2)*4;};
auto functionGaussSeidel = [](matrix_t & matrix) -> std::remove_reference<decltype(matrix)>::type {return gaussSeidelIteration(matrix);};
measure<matrix_t>(16384, iterationsGaussSeidel, opsPerIterationGaussSeidel, functionGaussSeidel);
}
std::cout << std::endl;
std::cout << "benching MatrixMul with different Sizes" << std::endl;
auto iterationsMatrixMul = [](size_t size) -> int {return 100000000/static_cast<int>(std::pow(size, 2.7)) + 1;};//reduce iterations by complexity
auto opsPerIterationMatrixMul = [](size_t size) -> double {return std::pow(size, 3)*2;};
{
auto functionMatrixMul = [](matrix_t & matrix) -> std::remove_reference<matrix_t>::type {return matrixMul(matrix, matrix);};
measure<matrix_t>(2048, iterationsMatrixMul, opsPerIterationMatrixMul, functionMatrixMul);
}
std::cout << std::endl;
std::cout << "benching MatrixMulFMA with different Sizes" << std::endl;
{
auto functionMatrixMulFMA = [](matrix_aligned_t & matrix) -> std::remove_reference<matrix_aligned_t>::type {return matrixMulFMA(matrix, matrix);};
measure<matrix_aligned_t>(2048, iterationsMatrixMul, opsPerIterationMatrixMul, functionMatrixMulFMA);
}
std::cout << std::endl;
std::cout << "benching matrixMulRotated with different Sizes" << std::endl;
{
auto functionMatrixMul = [](matrix_t & matrix) -> std::remove_reference<matrix_t>::type {return matrixMulRotated(matrix, matrix);};
measure<matrix_t>(2048, iterationsMatrixMul, opsPerIterationMatrixMul, functionMatrixMul);
}
std::cout << std::endl;
std::cout << "benching matrixMulTiled with different Sizes" << std::endl;
{
auto functionMatrixMul = [](matrix_t & matrix) -> std::remove_reference<matrix_t>::type {return matrixMulTiled(matrix, matrix);};
measure<matrix_t>(2048, iterationsMatrixMul, opsPerIterationMatrixMul, functionMatrixMul);
}
std::cout << std::endl;
std::cout << "benching matrixMulUnrolled with different Sizes" << std::endl;
{
auto functionMatrixMul = [](matrix_t & matrix) -> std::remove_reference<matrix_t>::type {return matrixMulUnrolled(matrix, matrix);};
measure<matrix_t>(2048, iterationsMatrixMul, opsPerIterationMatrixMul, functionMatrixMul);
}
}
void keyboard(unsigned char key, int x, int y){
switch(key){
case 'z':
exit(0);
break;
case 'v':
model_idx = (model_idx+1)%MODEL_NUM;
nowView = &view[model_idx];
matrixMul(pm, nowView->matrix, matrix);
glutPostRedisplay();
break;
case 'c':
model_idx = (model_idx+MODEL_NUM-1)%MODEL_NUM;
nowView = &view[model_idx];
matrixMul(pm, nowView->matrix, matrix);
glutPostRedisplay();
break;
case 'd': // scale + all
for(int i=0; i<3; i++)
nowView->scale[i] *= SCALE_RATE;
nowView->genMM();
matrixMul(pm, nowView->matrix, matrix);
glutPostRedisplay();
break;
case 'f': // scale + x
nowView->scale[0] *= SCALE_RATE;
nowView->genMM();
matrixMul(pm, nowView->matrix, matrix);
glutPostRedisplay();
break;
case 'e': // scale + y
nowView->scale[1] *= SCALE_RATE;
nowView->genMM();
matrixMul(pm, nowView->matrix, matrix);
glutPostRedisplay();
break;
case 'r': // scale + z
nowView->scale[2] *= SCALE_RATE;
nowView->genMM();
matrixMul(pm, nowView->matrix, matrix);
glutPostRedisplay();
break;
case 's': // scale - all
for(int i=0; i<3; i++)
nowView->scale[i] /= SCALE_RATE;
nowView->genMM();
matrixMul(pm, nowView->matrix, matrix);
glutPostRedisplay();
break;
case 'a': // scale + x
nowView->scale[0] /= SCALE_RATE;
nowView->genMM();
matrixMul(pm, nowView->matrix, matrix);
glutPostRedisplay();
break;
case 'w': // scale - y
nowView->scale[1] /= SCALE_RATE;
nowView->genMM();
matrixMul(pm, nowView->matrix, matrix);
glutPostRedisplay();
break;
case 'q': // scale + z
nowView->scale[2] /= SCALE_RATE;
nowView->genMM();
matrixMul(pm, nowView->matrix, matrix);
glutPostRedisplay();
break;
case 'l': // translate + all
for(int i=0; i<3; i++)
nowView->translate[i] += TRANSLATE_STEP;
nowView->genMM();
matrixMul(pm, nowView->matrix, matrix);
glutPostRedisplay();
break;
case ';': // translate + x
nowView->translate[0] += TRANSLATE_STEP;
nowView->genMM();
matrixMul(pm, nowView->matrix, matrix);
glutPostRedisplay();
break;
case 'o': // translate + y
nowView->translate[1] += TRANSLATE_STEP;
nowView->genMM();
matrixMul(pm, nowView->matrix, matrix);
glutPostRedisplay();
break;
case 'p': // translate + z
nowView->translate[2] += TRANSLATE_STEP;
nowView->genMM();
matrixMul(pm, nowView->matrix, matrix);
glutPostRedisplay();
break;
case 'k': // translate - all
for(int i=0; i<3; i++)
nowView->translate[i] -= TRANSLATE_STEP;
nowView->genMM();
matrixMul(pm, nowView->matrix, matrix);
glutPostRedisplay();
break;
case 'j': // translate - x
nowView->translate[0] -= TRANSLATE_STEP;
nowView->genMM();
matrixMul(pm, nowView->matrix, matrix);
glutPostRedisplay();
break;
case 'i': // translate - y
nowView->translate[1] -= TRANSLATE_STEP;
nowView->genMM();
matrixMul(pm, nowView->matrix, matrix);
glutPostRedisplay();
break;
case 'u': // translate - z
nowView->translate[2] -= TRANSLATE_STEP;
nowView->genMM();
matrixMul(pm, nowView->matrix, matrix);
glutPostRedisplay();
break;
case '8': // rotate + x
nowView->rotate[0] += ROTATE_DEGREE;
nowView->genMM();
matrixMul(pm, nowView->matrix, matrix);
glutPostRedisplay();
break;
case '5': // rotate - x
nowView->rotate[0] -= ROTATE_DEGREE;
nowView->genMM();
matrixMul(pm, nowView->matrix, matrix);
glutPostRedisplay();
break;
case '6': // rotate + y
nowView->rotate[1] += ROTATE_DEGREE;
nowView->genMM();
matrixMul(pm, nowView->matrix, matrix);
glutPostRedisplay();
break;
case '4': // rotate - y
nowView->rotate[1] -= ROTATE_DEGREE;
nowView->genMM();
matrixMul(pm, nowView->matrix, matrix);
glutPostRedisplay();
break;
case '9': // rotate + z
nowView->rotate[2] += ROTATE_DEGREE;
nowView->genMM();
matrixMul(pm, nowView->matrix, matrix);
glutPostRedisplay();
break;
case '7': // rotate - z
nowView->rotate[2] -= ROTATE_DEGREE;
nowView->genMM();
matrixMul(pm, nowView->matrix, matrix);
glutPostRedisplay();
break;
case '.': // shear + x
nowView->shear[0] += SHEAR_STEP;
nowView->genMM();
matrixMul(pm, nowView->matrix, matrix);
glutPostRedisplay();
break;
case ',': // shear - x
nowView->shear[0] -= SHEAR_STEP;
nowView->genMM();
matrixMul(pm, nowView->matrix, matrix);
glutPostRedisplay();
break;
case '/': // shear + y
nowView->shear[1] += SHEAR_STEP;
nowView->genMM();
matrixMul(pm, nowView->matrix, matrix);
glutPostRedisplay();
break;
case 'm': // shear - y
nowView->shear[1] -= SHEAR_STEP;
nowView->genMM();
matrixMul(pm, nowView->matrix, matrix);
glutPostRedisplay();
break;
case '[': // lookat rotate + y
nowView->lRotate[1] += LROTATE_DEGREE;
nowView->genLookAt();
matrixMul(pm, nowView->matrix, matrix);
glutPostRedisplay();
break;
case ']': // lookat rotate - y
nowView->lRotate[1] -= LROTATE_DEGREE;
nowView->genLookAt();
matrixMul(pm, nowView->matrix, matrix);
glutPostRedisplay();
break;
case '=': // lookat translate + y
nowView->lTranslate[1] += LTRANSLATE_STEP;
nowView->genLookAt();
matrixMul(pm, nowView->matrix, matrix);
glutPostRedisplay();
break;
case '-': // lookat translate- y
nowView->lTranslate[1] -= LTRANSLATE_STEP;
nowView->genLookAt();
matrixMul(pm, nowView->matrix, matrix);
glutPostRedisplay();
break;
case 'x': // reset
nowView->reset();
matrixMul(pm, nowView->matrix, matrix);
glutPostRedisplay();
break;
}
}
