/// CONFIGURABLE INTERFACE void AbstractIAFController::notifyOnChange(const paramkey& key){ if(key=="thresholdi") { tI.toZero().toSum((*conf.thresholdI)*sqrt(*conf.numberIAFNeuronsPerInput)); } else if (key=="thresholdo") { tO.toZero().toSum((*conf.thresholdO)*sqrt(*conf.numberIAFNeuronsPerOutput)); } else if(key=="wiinitscale") { wI.toId().toMult(*conf.wIInitScale); // scale } else if(key=="woinitscale") { wI.toId().toMult(*conf.wOInitScale); // scale } else if(key=="niafperinput") { initMatrices(); } else if(key=="niafperoutput") { initMatrices(); } }
bool OpenGL::initContext() { if (contextInitialized) return true; if (!gladLoadGLLoader(LOVEGetProcAddress)) return false; initOpenGLFunctions(); initVendor(); initMatrices(); bugs = {}; #if defined(LOVE_WINDOWS) || defined(LOVE_LINUX) // See the comments in OpenGL.h. if (getVendor() == VENDOR_AMD) { bugs.clearRequiresDriverTextureStateUpdate = true; bugs.generateMipmapsRequiresTexture2DEnable = true; } #endif contextInitialized = true; return true; }
void StressMinimization::call(GraphAttributes& GA) { const Graph& G = GA.constGraph(); // if the graph has at most one node nothing to do if (G.numberOfNodes() <= 1) { // make it exception save for(node v : G.nodes) { GA.x(v) = 0; GA.y(v) = 0; } return; } if (m_componentLayout && !isConnected(G)) { OGDF_THROW(PreconditionViolatedException); return; } NodeArray<NodeArray<double> > shortestPathMatrix(G); NodeArray<NodeArray<double> > weightMatrix(G); initMatrices(G, shortestPathMatrix, weightMatrix); // if the edge costs are defined by the attribute copy it to an array and // construct the proper shortest path matrix if (m_hasEdgeCostsAttribute) { if (!GA.has(GraphAttributes::edgeDoubleWeight)) { OGDF_THROW(PreconditionViolatedException); return; } m_avgEdgeCosts = dijkstra_SPAP(GA, shortestPathMatrix); // compute shortest path all pairs } else { m_avgEdgeCosts = m_edgeCosts; bfs_SPAP(G, shortestPathMatrix, m_edgeCosts); } call(GA, shortestPathMatrix, weightMatrix); }
/* ************************************************************************ */ int main (int argc, char** argv) { struct options options; struct calculation_arguments arguments; struct calculation_results results; /* get parameters */ AskParams(&options, argc, argv); /* ************************* */ initVariables(&arguments, &results, &options); /* ******************************************* */ allocateMatrices(&arguments); /* get and initialize variables and matrices */ initMatrices(&arguments, &options); /* ******************************************* */ pthread_barrier_init(&loop_barrier, NULL, options.number+1); /* init der Loop-Barriere */ gettimeofday(&start_time, NULL); /* start timer */ calculate(&arguments, &results, &options); /* solve the equation */ gettimeofday(&comp_time, NULL); /* stop timer */ displayStatistics(&arguments, &results, &options); DisplayMatrix(&arguments, &results, &options); freeMatrices(&arguments); /* free memory */ return 0; }
/* ************************************************************************ */ int main (int argc, char** argv) { struct options options; struct mpi_options mpi_options; struct calculation_arguments arguments; struct calculation_results results; initMpi(&mpi_options, &argc, &argv); /* get parameters */ AskParams(&options, argc, argv, mpi_options.mpi_rank == 0); /* ************************* */ initVariables(&arguments, &results, &options, &mpi_options); /* ******************************************* */ allocateMatrices(&arguments); /* get and initialize variables and matrices */ initMatrices(&arguments, &options); /* ******************************************* */ gettimeofday(&start_time, NULL); /* start timer */ calculate(&arguments, &results, &options, &mpi_options); /* solve the equation */ gettimeofday(&comp_time, NULL); /* stop timer */ if(mpi_options.mpi_rank == 0) displayStatistics(&arguments, &results, &options); DisplayMatrix(&arguments, &results, &options, mpi_options.mpi_rank, mpi_options.mpi_size, arguments.row_start, arguments.row_end); freeMatrices(&arguments); /* free memory */ MPI_Finalize(); return 0; }
/* ************************************************************************ */ int main (int argc, char** argv) { struct options options; struct calculation_arguments arguments; struct calculation_results results; /* get parameters */ AskParams(&options, argc, argv); /* ************************* */ initVariables(&arguments, &results, &options); /* ******************************************* */ allocateMatrices(&arguments); /* get and initialize variables and matrices */ initMatrices(&arguments, &options); /* ******************************************* */ gettimeofday(&start_time, NULL); /* start timer */ calculate(&arguments, &results, &options); /* solve the equation */ gettimeofday(&comp_time, NULL); /* stop timer */ displayStatistics(&arguments, &results, &options); /* **************** */ DisplayMatrix("Matrix:", /* display some */ arguments.Matrix[results.m][0], options.interlines); /* statistics and */ freeMatrices(&arguments); /* free memory */ return 0; }
int main (int argc, char** argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGBA|GLUT_DOUBLE|GLUT_DEPTH); glutInitWindowSize(800, 600); glutCreateWindow("Index Buffers"); glutReshapeFunc(changeViewport); glutDisplayFunc(render); glewInit(); /*set up the matricies*/ initMatrices(); // Make a shader shaderProgramID = createShaders(); glGenVertexArrays(1, &vao); glBindVertexArray(vao); glGenBuffers(1, &vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo); // Create the buffer, but don't load anything yet glBufferData(GL_ARRAY_BUFFER, sizeof(colors)*sizeof(vertices), NULL, GL_STATIC_DRAW); // Load the vertex points glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertices), vertices); // Load the colors right after that glBufferSubData(GL_ARRAY_BUFFER, sizeof(vertices),sizeof(colors), colors); glGenBuffers(1, &indexBufferID); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBufferID); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW); positionID = glGetAttribLocation(shaderProgramID, "s_vPosition"); colorID = glGetAttribLocation(shaderProgramID, "s_vColor"); perspectiveMatrixID = glGetUniformLocation(shaderProgramID, "mP"); viewMatrixID = glGetUniformLocation(shaderProgramID, "mV"); modelMatrixID = glGetUniformLocation(shaderProgramID, "mM"); glVertexAttribPointer(positionID, 3, GL_FLOAT, GL_FALSE, 0, 0); glVertexAttribPointer(colorID, 3, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(sizeof(vertices))); glutKeyboardFunc(keyboard); glUseProgram(shaderProgramID); glEnableVertexAttribArray(positionID); glEnableVertexAttribArray(colorID); glutSpecialFunc(SpecialInput); printWelcome(); glutMainLoop(); return 0; }
void AbstractIAFController::init(int sensornumber, int motornumber, RandGen* randGen) { if(!randGen) randGen = new RandGen(); // this gives a small memory leak this->randG=randGen; // set dimensions sensorNumber=sensornumber; motorNumber=motornumber; initMatrices(); initialised=true; }
void MyWindow::initialize() { CreateVertexBuffer(); initShaders(); initMatrices(); //mRotationMatrixLocation = mProgram->uniformLocation("RotationMatrix"); glFrontFace(GL_CCW); glEnable(GL_DEPTH_TEST); }
/* ************************************************************************ */ int main (int argc, char** argv) { struct options options; struct calculation_arguments arguments; struct calculation_results results; struct comm_options comm; MPI_Init(&argc, &argv); MPI_Comm_rank(MPI_COMM_WORLD, &comm.rank); MPI_Comm_size(MPI_COMM_WORLD, &comm.num_procs); /* get parameters */ AskParams(&options, argc, argv, comm.rank); /* ************************* */ initVariables(&arguments, &results, &options); /* ******************************************* */ if (options.method == METH_JACOBI && comm.num_procs > 1) { allocateMatrices_mpi(&arguments, &comm); initMatrices_mpi(&arguments, &options, &comm); gettimeofday(&start_time, NULL); /* start timer */ calculate_mpi(&arguments, &results, &options, &comm); /* solve the equation */ gettimeofday(&comp_time, NULL); /* stop timer */ if (comm.rank == ROOT) { displayStatistics(&arguments, &results, &options); } DisplayMatrix_mpi(&arguments, &results, &options, comm.rank, comm.num_procs, comm.absoluteStartRow, comm.absoluteStartRow + comm.matrixRows -3); freeMatrices(&arguments); /* free memory */ } else { allocateMatrices(&arguments); /* get and initialize variables and matrices */ initMatrices(&arguments, &options); /* ******************************************* */ gettimeofday(&start_time, NULL); /* start timer */ calculate(&arguments, &results, &options); /* solve the equation */ gettimeofday(&comp_time, NULL); /* stop timer */ displayStatistics(&arguments, &results, &options); DisplayMatrix(&arguments, &results, &options); freeMatrices(&arguments); /* free memory */ } MPI_Finalize(); return 0; }
/* ************************************************************************ */ int main (int argc, char** argv) { MPI_Init(&argc, &argv); struct options options; struct calculation_arguments arguments; struct calculation_results results; /* get parameters */ AskParams(&options, argc, argv); initVariables(&arguments, &results, &options); allocateMatrices(&arguments); /* get and initialize variables and matrices */ initMatrices(&arguments, &options); gettimeofday(&start_time, NULL); /* start timer */ if (options.method == METH_JACOBI) calculate_jacobi(&arguments, &results, &options); /* solve the equation using Jaocbi */ else calculate_gaussseidel(&arguments, &results, &options); /* solve the equation using Gauss-Seidel */ MPI_Barrier(MPI_COMM_WORLD); gettimeofday(&comp_time, NULL); /* stop timer */ // only attempt communication if we have more than 1 procss if(arguments.nproc > 1) { // communicate final maxresiduum from last rank to rank 0 if(arguments.rank == 0) MPI_Recv(&results.stat_precision, 1, MPI_DOUBLE, arguments.nproc - 1, 1, MPI_COMM_WORLD, NULL); if(arguments.rank == arguments.nproc - 1) MPI_Send(&results.stat_precision, 1, MPI_DOUBLE, 0, 1, MPI_COMM_WORLD); } //printDebug(&arguments, &results); // pretty-print matrix if we are debugging if(arguments.rank == 0) displayStatistics(&arguments, &results, &options); DisplayMatrix("Matrix:", arguments.Matrix[results.m][0], options.interlines, arguments.rank, arguments.nproc, arguments.offset + ((arguments.rank > 0) ? 1 : 0), (arguments.offset + arguments.N - ((arguments.rank != arguments.nproc - 1) ? 1 : 0))); freeMatrices(&arguments); /* free memory */ MPI_Finalize(); return 0; }
void MyWindow::initialize() { CreateVertexBuffer(); initShaders(); pass1Index = mFuncs->glGetSubroutineIndex( mProgram->programId(), GL_FRAGMENT_SHADER, "pass1"); pass2Index = mFuncs->glGetSubroutineIndex( mProgram->programId(), GL_FRAGMENT_SHADER, "pass2"); pass3Index = mFuncs->glGetSubroutineIndex( mProgram->programId(), GL_FRAGMENT_SHADER, "pass3"); initMatrices(); setupFBO(); glFrontFace(GL_CCW); glEnable(GL_DEPTH_TEST); }
void MyWindow::initialize() { mFuncs->glGenVertexArrays(1, &mVAO); mFuncs->glBindVertexArray(mVAO); CreateVertexBuffer(); initShaders(); initMatrices(); mRotationMatrixLocation = mProgramSimpleADS->uniformLocation("RotationMatrix"); glFrontFace(GL_CCW); glEnable(GL_DEPTH_TEST); }
void MyWindow::initialize() { CreateVertexBuffer(); initShaders(); initMatrices(); //PrepareTexture(GL_TEXTURE0, GL_TEXTURE_2D, "../Media/cement.jpg", false); //PrepareTexture(GL_TEXTURE1, GL_TEXTURE_2D, "../Media/moss.png", true); PrepareCubeMap(GL_TEXTURE0, "../media/cubemapnight/night", true); //mRotationMatrixLocation = mProgram->uniformLocation("RotationMatrix"); glFrontFace(GL_CCW); glEnable(GL_DEPTH_TEST); }
/* ************************************************************************ */ int main (int argc, char** argv) { struct options options; struct calculation_arguments arguments; struct calculation_results results; // mpi setup --------------------------------------------------------------- MPI_Init(NULL, NULL); int rank, nprocs; MPI_Comm_rank(MPI_COMM_WORLD, &rank); MPI_Comm_size(MPI_COMM_WORLD, &nprocs); /* get parameters */ AskParams(&options, argc, argv, rank); initVariables(&arguments, &results, &options, rank, nprocs); // printf("[%d] %" PRIu64 " %" PRIu64 "\n", rank, arguments.offset_start, arguments.offset_end); // get and initialize variables and matrices allocateMatrices(&arguments); initMatrices(&arguments, &options); gettimeofday(&start_time, NULL); /* start timer */ // solve the equation if (options.method == METH_JACOBI) { calculate_mpi(&arguments, &results, &options); } else { calculate(&arguments, &results, &options); } // MPI_Barrier(MPI_COMM_WORLD); // gettimeofday(&comp_time, NULL); /* stop timer */ DisplayMatrix(&arguments, &results, &options); freeMatrices(&arguments); MPI_Finalize(); return 0; }
int main(int argc, char **argv) { ros::init(argc, argv, "imu_vision_bias_fusion"); ros::NodeHandle nh; state_pub = nh.advertise<geometry_msgs::TwistWithCovarianceStamped>("state",1); acc_pub = nh.advertise<geometry_msgs::Twist>("compensatedACC",1); bias_pub = nh.advertise<geometry_msgs::Twist>("estimatedBias",1); error_pub = nh.advertise<geometry_msgs::Twist>("error_vision_state",1); ros::Subscriber imu_sub = nh.subscribe("imu/data", 1, imuCb); ros::Subscriber vision_sub = nh.subscribe("vision_transformed", 1, visionCb); PrevCbTime = ros::Time::now(); // INPUT // posSTD, velSTD, bias_STD, visionSTD, biasNoise, biasInitValue; if( argc >= 6) { posSTD = atof(argv[1]); velSTD = atof(argv[2]); biasSTD = atof(argv[3]); visionSTD = atof(argv[4]); biasNoise = atof(argv[5]); posNoise = atof(argv[6]); velNoise = atof(argv[7]); biasInitValue = atof(argv[8]); } // 0.2 0.05 0.03 0.01 0.1 0.05 0.001 0.05 ROS_INFO_STREAM(" Input Parameters "); ROS_INFO_STREAM("posSTD: " << posSTD << " velSTD: " << velSTD << " biasSTD: " << biasSTD << " visionSTD: " << visionSTD); ROS_INFO_STREAM("posNoise: " << posNoise << " velNoise: " << velNoise << " biasNoise: " << biasNoise << " biasInitValue: " << biasInitValue); initMatrices(); ros::spin(); }
int main (int argc, char** argv) { AskParams(&options, argc, argv); if (argc > 7) { altermode = argv[7]; if (rank == root) { printf("altermode enabled!\n"); } } MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &size); MPI_Comm_rank(MPI_COMM_WORLD, &rank); last = size-1; printf("process %d starting ...\n", rank); initVariables(); initMatrices(); gettimeofday(&start_time, NULL); if (options.method == METH_JACOBI) { calculateJacobi(); } MPI_Barrier(MPI_COMM_WORLD); gettimeofday(&comp_time, NULL); if (rank == root) { double time = (comp_time.tv_sec - start_time.tv_sec) + (comp_time.tv_usec - start_time.tv_usec) * 1e-6; printf("Berechnungszeit: %f s \n", time); printf("Anzahl Iterationen: %d\n", iteration); } DisplayMatrix(); freeMemory(); MPI_Finalize(); }
/* ************************************************************************ */ int main (int argc, char** argv) { struct options options; struct calculation_arguments arguments; struct calculation_results results; // MPI Init MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &size); MPI_Comm_rank(MPI_COMM_WORLD, &rank); /* get parameters */ AskParams(&options, argc, argv); /* ************************* */ initVariables(&arguments, &results, &options); /* ******************************************* */ allocateMatrices(&arguments); /* get and initialize variables and matrices */ initMatrices(&arguments, &options); /* ******************************************* */ gettimeofday(&start_time, NULL); /* start timer */ calculate(&arguments, &results, &options); /* solve the equation */ //wait MPI_Barrier(MPI_COMM_WORLD); gettimeofday(&comp_time, NULL); /* stop timer */ if (rank == root){ displayStatistics(&arguments, &results, &options); } DisplayMatrix(&arguments, &results, &options); freeMatrices(&arguments); /* free memory */ //MPI End MPI_Finalize(); return 0; }
int main (int argc, char** argv) { glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGBA|GLUT_DOUBLE|GLUT_DEPTH); glutInitWindowSize(800, 600); glutCreateWindow("Project 2: hot shot!"); glutReshapeFunc(changeViewport); glClearColor(1.0f, 1.0f, 1.0f, 1.0f); glutDisplayFunc(render); glewInit(); /*set up the matricies*/ initMatrices(); initShaders();// glutKeyboardFunc(keyboard); glEnableVertexAttribArray(positionID); glEnableVertexAttribArray(colorID); glutMainLoop(); return 0; }
/* ************************************************************************ */ int main (int argc, char** argv) { struct options options; struct calculation_arguments arguments; struct calculation_results results; /* get parameters */ AskParams(&options, argc, argv); /* ************************* */ initVariables(&arguments, &results, &options); /* ******************************************* */ allocateMatrices(&arguments, &options); /* get and initialize variables and matrices */ initMatrices(&arguments, &options); /* ******************************************* */ if (options.inf_func == FUNC_FPISIN) /* Init Cache für Sinus berechnung */ initMysin(&arguments); gettimeofday(&start_time, NULL); /* start timer */ calculate(&arguments, &results, &options); /* solve the equation */ gettimeofday(&comp_time, NULL); /* stop timer */ // int i, j; // for(i = 0; i <=arguments.N ; i++) // for(j = 0; j <=arguments.N; j++) // arguments.Matrix[results.m][i][j] = Matrix_getValue(arguments.Mat[results.m], i, j); displayStatistics(&arguments, &results, &options); /* **************** */ DisplayMatrix("Matrix:", /* display some */ arguments.Mat[results.m], options.interlines); /* statistics and */ freeMysin(&arguments); /* Cache für Sinus freigeben */ freeMatrices(&arguments); /* free memory */ return 0; }
/* ************************************************************************ */ int main (int argc, char** argv) { struct options options; struct calculation_arguments arguments; struct calculation_results results; int rc; rc = MPI_Init(&argc,&argv); if (rc != MPI_SUCCESS) { printf("Error initializing MPI. Terminating.\n"); MPI_Abort(MPI_COMM_WORLD, rc); } AskParams(&options, argc, argv); /* get parameters */ initVariables(&arguments, &results, &options); /* ******************************************* */ initMPI(&mpis, &arguments); /* initalize MPI */ allocateMatrices(&arguments); /* get and initialize variables and matrices */ initMatrices(&arguments, &options); /* ******************************************* */ gettimeofday(&start_time, NULL); /* start timer */ calculate(&arguments, &results, &options); /* solve the equation */ gettimeofday(&comp_time, NULL); /* stop timer */ if (0 == mpis.rank) { displayStatistics(&arguments, &results, &options); /* **************** */ DisplayMatrix("Matrix:", /* display some */ arguments.Matrix[results.m][0], options.interlines); /* statistics and */ } freeMatrices(&arguments); freeMPI(&mpis); /* free memory */ /* **************** */ //MPI_Barrier(MPI_COMM_WORLD); MPI_Finalize(); return 0; }
/* ************************************************************************ */ int main (int argc, char** argv) { int rank; int size; int rest; int from, to; MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &size); MPI_Comm_rank(MPI_COMM_WORLD, &rank); struct options options; struct calculation_arguments arguments; struct calculation_results results; /* Parameter nur einmal abfragen */ if(rank == 0) { AskParams(&options, argc, argv); } MPI_Bcast(&options, (sizeof(options)), MPI_BYTE, MASTER, MPI_COMM_WORLD); initVariables(&arguments, &results, &options); /* Damit allocation + initialization richtig läuft, wird für GS size = 1 gesetzt */ if(options.method == METH_GAUSS_SEIDEL) { size = 1; } /* Aufteilen bis auf rest */ int N_part = arguments.N; int lines = N_part - 1; rest = lines % size; N_part = (lines - rest) / size; /* globale zeilennummer berechnen, hier wird der rest beachtet */ /* offset ist (rank + 1) für rank < rest, steigt also linear mit steigendem rang */ if(rank < rest) { from = N_part * rank + rank + 1; to = N_part * (rank + 1) + (rank + 1); } /* offset hier ist rest also die der maximale offset von oben */ else { from = N_part * rank + rest + 1; to = N_part * (rank + 1) + rest ; } arguments.to = to; arguments.from = from; /* at least we only need N - 1 processes for calculation */ if((unsigned int)size > (arguments.N -1)) { size = (arguments.N - 1); if(rank == MASTER ) { printf("\nWarning, you are using more processes than rows.\n This can slow down the calculation process! \n\n"); } } //calculate Number of Rows arguments.numberOfRows = ((to - from + 1) > 0 ) ? (to - from + 1) : 0; allocateMatrices(&arguments); initMatrices(&arguments, &options, rank, size); gettimeofday(&start_time, NULL); /* start timer */ if (options.method == METH_JACOBI ) { calculateJacobi(&arguments, &results, &options, rank, size); } else { /* GS berechnet nur MASTER */ if(rank == MASTER) { printf("\nGS wird nur sequentiell berechnet! \n"); calculate(&arguments, &results, &options); } } gettimeofday(&comp_time, NULL); /* stop timer */ /* only once */ if(rank == MASTER) { displayStatistics(&arguments, &results, &options, size); } /* GS macht alte ausgabe */ if((options.method == METH_GAUSS_SEIDEL) && (rank == MASTER)) { DisplayMatrix(&arguments, &results, &options); } else { DisplayMatrixMPI(&arguments, &results, &options, rank, size, from, to); } freeMatrices(&arguments); /* free memory */ MPI_Finalize(); return 0; }
int main (int argc, char** argv) { // Standard stuff... glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGBA|GLUT_DOUBLE|GLUT_DEPTH); glutInitWindowSize(800, 600); glutCreateWindow("Diffuse Lighting"); glutReshapeFunc(changeViewport); glutDisplayFunc(render); glewInit(); initMatrices(); GLfloat vertices[]= { -0.5f,0.5f,0.5f, -0.5f,-0.5f,0.5f, 0.5f,-0.5f,0.5f, -0.5f,0.5f,0.5f, 0.5f,-0.5f,0.5f, 0.5f,0.5f, 0.5f, 0.5f,0.5f,0.5f, 0.5f,-0.5f,0.5f, 0.5f,-0.5f,-0.5f, 0.5f,0.5f,0.5f, 0.5f,-0.5f,-0.5f, 0.5f,0.5f,-0.5f, 0.5f,-0.5f,0.5f, -0.5f,-0.5f,0.5f, -0.5f,-0.5f,-0.5f, 0.5f,-0.5f,0.5f, -0.5f,-0.5f,-0.5f, 0.5f,-0.5f,-0.5f, 0.5f,0.5f,-0.5f, -0.5f, 0.5f,-0.5f, -0.5f,0.5f,0.5f, 0.5f,0.5f,-0.5f, -0.5f,0.5f,0.5f, 0.5f,0.5f,0.5f, -0.5f,-0.5f,-0.5f, -0.5f,0.5f,-0.5f, 0.5f,0.5f,-0.5f, -0.5f,-0.5f,-0.5f, 0.5f,0.5f,-0.5f, 0.5f,-0.5f,-0.5f, -0.5f,0.5f,-0.5f, -0.5f,-0.5f,-0.5f, -0.5f,-0.5f,0.5f, -0.5f,0.5f,-0.5f, -0.5f,-0.5f,0.5f, -0.5f,0.5f,0.5f, }; //GLuint indices[] = {1,0,3,2,2,3,7,6,3,0,4,7,6,5,1,2,4,5,6,7,5,4,0,1}; GLfloat normals[]={ 0.0f,0.0f,1.0f, 0.0f,0.0f,1.0f, 0.0f,0.0f,1.0f, 0.0f,0.0f,1.0f, 0.0f,0.0f,1.0f, 0.0f,0.0f,1.0f, 1.0f,0.0f,0.0f, 1.0f,0.0f,0.0f, 1.0f,0.0f,0.0f, 1.0f,0.0f,0.0f, 1.0f,0.0f,0.0f, 1.0f,0.0f,0.0f, 0.0f,-1.0f,0.0f, 0.0f,-1.0f,0.0f, 0.0f,-1.0f,0.0f, 0.0f,-1.0f,0.0f, 0.0f,-1.0f,0.0f, 0.0f,-1.0f,0.0f, 0.0f,1.0f,0.0f, 0.0f,1.0f,0.0f, 0.0f,1.0f,0.0f, 0.0f,1.0f,0.0f, 0.0f,1.0f,0.0f, 0.0f,1.0f,0.0f, 0.0f,0.0f,-1.0f, 0.0f,0.0f,-1.0f, 0.0f,0.0f,-1.0f, 0.0f,0.0f,-1.0f, 0.0f,0.0f,-1.0f, 0.0f,0.0f,-1.0f, -1.0f,0.0f,0.0f, -1.0f,0.0f,0.0f, -1.0f,0.0f,0.0f, -1.0f,0.0f,0.0f, -1.0f,0.0f,0.0f, -1.0f,0.0f,0.0f, }; /*GLfloat vertices[] = {0.0f, 0.5f, 0.0f, // 0 -0.25f, 0.0f, 0.0f, // 1 0.25f, 0.0f, 0.0f, // 2 -0.5f, -0.5f, 0.0f, // 3 0.0f, -0.5f, 0.0f, // 4 0.5f, -0.5f, 0.0f // 5 }; GLuint indices[] = {0, 1, 2, 1, 3, 4, 2, 4, 5}; GLfloat normals[]={ 0.0f,0.0f,1.0f, 0.0f,0.0f,1.0f, 0.0f,0.0f,1.0f, 0.0f,0.0f,1.0f, 0.0f,0.0f,1.0f, 0.0f,0.0f,1.0f };*/ // Make a shader char* vertexShaderSourceCode = readFile("vertexShader.vsh"); char* fragmentShaderSourceCode = readFile("fragmentShader.fsh"); GLuint vertShaderID = makeVertexShader(vertexShaderSourceCode); GLuint fragShaderID = makeFragmentShader(fragmentShaderSourceCode); shaderProgramID = makeShaderProgram(vertShaderID, fragShaderID); // Create the "remember all" glGenVertexArrays(1, &vao); glBindVertexArray(vao); glGenBuffers(1, &vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo); // Create the buffer, but don't load anything yet //glBufferData(GL_ARRAY_BUFFER, 7*NUM_VERTICES*sizeof(GLfloat), NULL, GL_STATIC_DRAW); glBufferData(GL_ARRAY_BUFFER, 6*NUM_VERTICES*sizeof(GLfloat), NULL, GL_STATIC_DRAW); // NEW!! - We're only loading vertices and normals (6 elements, not 7) // Load the vertex points glBufferSubData(GL_ARRAY_BUFFER, 0, 3*NUM_VERTICES*sizeof(GLfloat), vertices); // Load the colors right after that //glBufferSubData(GL_ARRAY_BUFFER, 3*NUM_VERTICES*sizeof(GLfloat),4*NUM_VERTICES*sizeof(GLfloat), colors); glBufferSubData(GL_ARRAY_BUFFER, 3*NUM_VERTICES*sizeof(GLfloat),3*NUM_VERTICES*sizeof(GLfloat), normals); #ifdef USING_INDEX_BUFFER glGenBuffers(1, &indexBufferID); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBufferID); glBufferData(GL_ELEMENT_ARRAY_BUFFER, NUM_INDICES*sizeof(GLuint), indices, GL_STATIC_DRAW); #endif // Find the position of the variables in the shader positionID = glGetAttribLocation(shaderProgramID, "s_vPosition"); normalID = glGetAttribLocation(shaderProgramID, "s_vNormal"); lightID = glGetUniformLocation(shaderProgramID, "vLight"); // NEW // ============ glUniformLocation is how you pull IDs for uniform variables=============== perspectiveMatrixID = glGetUniformLocation(shaderProgramID, "mP"); viewMatrixID = glGetUniformLocation(shaderProgramID, "mV"); modelMatrixID = glGetUniformLocation(shaderProgramID, "mM"); allRotsMatrixID = glGetUniformLocation(shaderProgramID, "mRotations"); // NEW //============================================================================================= glVertexAttribPointer(positionID, 3, GL_FLOAT, GL_FALSE, 0, 0); //glVertexAttribPointer(colorID, 4, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(sizeof(vertices))); glVertexAttribPointer(normalID, 3, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(sizeof(vertices))); glUseProgram(shaderProgramID); glEnableVertexAttribArray(positionID); glEnableVertexAttribArray(normalID); glEnable(GL_CULL_FACE); // NEW! - we're doing real 3D now... Cull (don't render) the backsides of triangles glCullFace(GL_BACK); // Other options? GL_FRONT and GL_FRONT_AND_BACK glEnable(GL_DEPTH_TEST);// Make sure the depth buffer is on. As you draw a pixel, update the screen only if it's closer than previous ones glClearColor( 1.0, 1.0, 1.0, 1.0 ); glutKeyboardFunc( keyboard ); glutMainLoop(); return 0; }
int main( void ) { initGLFW(); initWindow(); initGLEW(); initKeyboard(); // Dark blue background glClearColor(0.0f, 0.0f, 0.4f, 0.0f); int size = 5; float* map = generateHeightMap(size); printf("generated map\n" ); std::vector<glm::vec3> terrain; mapHeightsToPoints(terrain, map, size); printf("mapped to points\n"); // GLuint* indices = generateIndices(terrain, size); uint terrainVertexAmount = size* size * 3; uint indiceAmount = 3 * (1 << size); for(int i = 0; i < terrain.size(); ++i){ printf("[%f, %f, %f]\n", terrain[i].x, terrain[i].y, terrain[i].z); } printf("vertices %d\n", terrainVertexAmount); GLuint VertexArrayID = newVertexArray(); // Create and compile our GLSL program from the shaders GLuint programID = LoadShaders( "SimpleVertexShader.vertexshader", "SimpleFragmentShader.fragmentshader" ); printf("loaded\n"); initMatrices(programID); GLuint vertexbuffer = newVertexBuffer(terrainVertexAmount, &terrain); double lastTime = glfwGetTime(); int nbFrames = 0; printf("loop\n"); initDepth(); do{ // Clear the screen glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Use our shader glUseProgram(programID); // TODO // recalculateMatrices(); // Send our transformation to the currently bound shader, // in the "MVP" uniform glUniformMatrix4fv(MatrixID, 1, GL_FALSE, &MVP[0][0]); // 1rst attribute buffer : vertices bindVertexBuffer(vertexbuffer); // Draw the triangle ! glDrawArrays(GL_TRIANGLE_FAN, 0, terrainVertexAmount); // 3 indices starting at 0 -> 1 triangle glDisableVertexAttribArray(0); // Swap buffers glfwSwapBuffers(window); glfwPollEvents(); // measureTime(lastTime, &nbFrames); } // Check if the ESC key was pressed or the window was closed while( glfwGetKey(window, GLFW_KEY_ESCAPE ) != GLFW_PRESS && glfwWindowShouldClose(window) == 0 ); // Cleanup VBO glDeleteBuffers(1, &vertexbuffer); glDeleteVertexArrays(1, &VertexArrayID); glDeleteProgram(programID); // Close OpenGL window and terminate GLFW glfwTerminate(); // normal** ns = generateNormals(map, size); return 0; }
int main (int argc, char** argv) { // Standard stuff... glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGBA|GLUT_DOUBLE|GLUT_DEPTH); glutInitWindowSize(800, 600); glutCreateWindow("Index Buffers"); glutReshapeFunc(changeViewport); glewInit(); initMatrices(); // New <======================================== vao=gen_particles(); /*#ifdef USING_INDEX_BUFFER #endif*/ // Make a shader char* vertexShaderSourceCode = readFile("vertexShader1.vsh"); char* fragmentShaderSourceCode = readFile("fragmentShader1.fsh"); GLuint vertShaderID = makeVertexShader(vertexShaderSourceCode); GLuint fragShaderID = makeFragmentShader(fragmentShaderSourceCode); shaderProgramID = makeShaderProgram(vertShaderID, fragShaderID); /*/ / Create the "remember all" glGenVertexArrays(1, &vao); glBindVertexArray(vao); glGenBuffers(1, &vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo); // Create the buffer, but don't load anything yet //glBufferData(GL_ARRAY_BUFFER, 7*NUM_VERTICES*sizeof(GLfloat), NULL, GL_STATIC_DRAW); glBufferData(GL_ARRAY_BUFFER, 6*NUM_VERTICES*sizeof(GLfloat), NULL, GL_STATIC_DRAW); // Load the vertex points glBufferSubData(GL_ARRAY_BUFFER, 0, 3*NUM_VERTICES*sizeof(GLfloat), vertices); // Load the colors right after that //glBufferSubData(GL_ARRAY_BUFFER, 3*NUM_VERTICES*sizeof(GLfloat),4*NUM_VERTICES*sizeof(GLfloat), colors); glBufferSubData(GL_ARRAY_BUFFER, 3*NUM_VERTICES*sizeof(GLfloat),3*NUM_VERTICES*sizeof(GLfloat), normals);*/ /*#ifdef USING_INDEX_BUFFER glGenBuffers(1, &indexBufferID); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBufferID); glBufferData(GL_ELEMENT_ARRAY_BUFFER, NUM_INDICES*sizeof(GLuint), indices, GL_STATIC_DRAW); #endif*/ // Find the position of the variables in the shader //ositionID = glGetAttribLocation(shaderProgramID, "v_i"); //colorID = glGetAttribLocation(shaderProgramID, "elapsed_system_time"); // ============ New! glUniformLocation is how you pull IDs for uniform variables=============== perspectiveMatrixID = glGetUniformLocation(shaderProgramID, "P"); viewMatrixID = glGetUniformLocation(shaderProgramID, "V"); emitterID=glGetUniformLocation(shaderProgramID, "emitter_pos_wor"); timeID=glGetUniformLocation(shaderProgramID, "elapsed_system_time"); //============================================================================================= /*glVertexAttribPointer(positionID, 3, GL_FLOAT, GL_FALSE, 0, 0); //glVertexAttribPointer(colorID, 4, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(sizeof(vertices))); glVertexAttribPointer(colorID, 3, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(sizeof(vertices))); printf ("BUFFER_OFFSET is: %d\n", sizeof(vertices));*/ glUseProgram(shaderProgramID); //glEnableVertexAttribArray(positionID); //glEnableVertexAttribArray(colorID); //glEnable(GL_DEPTH_TEST); //glClearColor( 0.0, 0.0, 0.0, 0.2 ); //current_seconds=Timer(); glutDisplayFunc(render); glutKeyboardFunc( keyboard ); glutMainLoop(); return 0; }
int compute(){ //Assuming that the processes form a square int n_procs_row = sqrt(number_of_processes); int n_procs_col = n_procs_row; if (n_procs_col * n_procs_row != number_of_processes) { std::cerr << "number of proccessors must be a perfect square!" << std::endl; MPI_Abort(MPI_COMM_WORLD, 1); } int n_dims = 2; int dims[n_dims] = {n_procs_row, n_procs_col}; int periods[n_dims] = {0, 0}; int repeat = 0; //create comm_groups MPI_Comm comm_cart; MPI_Cart_create(MPI_COMM_WORLD, n_dims, dims, periods, repeat, &comm_cart); int m_block = m / n_procs_row; int n_block = n / n_procs_col; int k_block = k / n_procs_col; if (m_block * n_procs_row != m) { std::cerr << "m must be dividable by n_procs_row" << std::endl; MPI_Abort(MPI_COMM_WORLD, 1); } if (n_block * n_procs_col != n) { std::cerr << "n must be dividable by n_procs_col" << std::endl; MPI_Abort(MPI_COMM_WORLD, 1); } if (k_block * n_procs_col != k) { std::cerr << "k must be dividable by n_procs_col" << std::endl; MPI_Abort(MPI_COMM_WORLD, 1); } double * A_local = (double *) calloc(m_block * n_block, sizeof(double)); double * B_local = (double *) calloc(n_block * k_block, sizeof(double)); double * C_local = (double *) calloc(m_block * k_block, sizeof(double)); double * A = (double *) calloc(m * n, sizeof(double)); double * B = (double *) calloc(n * k, sizeof(double)); initMatrices(A_local, B_local, C_local, m_block, n_block, comm_cart); /** testing the scatter function */ if(rank == 0){ double * A_1 = (double *) calloc(n * k, sizeof(double)); double * B_1 = (double *) calloc(n * k, sizeof(double)); double * C_1 = (double *) calloc(n * k, sizeof(double)); initMatrices(A_1, B_1, C_1, n, n, comm_cart); distributeSquareMatrix(A_1, n, C_1); } gatherMatrix(m_block, n_block, A_local, m, n, A); gatherMatrix(n_block, k_block, B_local, n, k, B); /*if (rank == 3) { std::cout << "A" << std::endl; printMatrix(m_block,m_block, A_local); std::cout << "B" << std::endl; printMatrix(m_block,m_block, B_local); std::cout << "C" << std::endl; printMatrix(m_block,m_block, C_local); }*/ double start_time, end_time; start_time = MPI_Wtime(); summa(comm_cart, m_block, n_block, k_block, A_local, B_local, C_local); end_time = MPI_Wtime(); getTimes(start_time, end_time); double * C = (double *) calloc(m * n, sizeof(double)); double * C_naive = (double *) calloc(m * n, sizeof(double)); gatherMatrix(m_block, k_block, C_local, m, k, C); if (rank == 0) { multMatricesLineByLine(m, n, k, A, B, C_naive); double eps = validate(n, k, C, C_naive); if (eps > 1e-4) { std::cerr << "ERROR: Invalid matrix -> eps = " << eps << std::endl; MPI_Abort(MPI_COMM_WORLD, 1); } else { std::cout << "Valid matrix" << std::endl; } } }
int main (int argc, char** argv) { // GLUT initialisation and matrices glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGBA|GLUT_DOUBLE|GLUT_DEPTH); glutInitWindowSize(800, 600); glutCreateWindow("GCP Assignment"); glutReshapeFunc(changeViewport); glutKeyboardFunc(keyboardFunc); glutDisplayFunc(render); glewInit(); initMatrices(); // Make shaders char* vertexShaderSourceCode = readFile("vertexShader.vsh"); char* fragmentShaderSourceCode = readFile("fragmentShader.fsh"); GLuint vertShaderID = makeVertexShader(vertexShaderSourceCode); GLuint fragShaderID = makeFragmentShader(fragmentShaderSourceCode); shaderProgramID = makeShaderProgram(vertShaderID, fragShaderID); // create and bind the VBO toi the VAO" glGenVertexArrays(1, &vao); glBindVertexArray(vao); glGenBuffers(1, &vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo); // Create the buffer of the size necessary to store the model 3 flaots for RGB 3 for the vertices XYZ glBufferData(GL_ARRAY_BUFFER, 6*NUM_VERTICES*sizeof(GLfloat), NULL, GL_STATIC_DRAW); // Load the vertex points glBufferSubData(GL_ARRAY_BUFFER, 0, 3*NUM_VERTICES*sizeof(GLfloat), vertices); // Load the colors right after that glBufferSubData(GL_ARRAY_BUFFER, 3*NUM_VERTICES*sizeof(GLfloat),3*NUM_VERTICES*sizeof(GLfloat), normals); #ifdef USING_INDEX_BUFFER glGenBuffers(1, &indexBufferID); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBufferID); glBufferData(GL_ELEMENT_ARRAY_BUFFER, NUM_INDICES*sizeof(GLuint), indices, GL_STATIC_DRAW); #endif // the console output std::cout << "Giannandrea Grone Assignment \n"; std::cout << "Simple demonstration of rotating a model around itself with Quaternions or Matrices\n "; std::cout << "The results seem similar but the maths behind it is significantly different\n "; std::cout << "How to use: \n "; std::cout << "Press P to toggle between Matrices and Quaternions \n "; std::cout << "Press O to toggle between Automatic and Manual \n "; std::cout << "WASD to move the camera (left, right, forward, backward \n "; std::cout << "QE to move the camera upward downward \n "; std::cout << "RT FG CV to rotate the camera on XYZ \n "; std::cout << "(Manual only) YU HJ NM to rotate the model on XYZ \n"; // bind the data with the shaders positionID = glGetAttribLocation(shaderProgramID, "s_vPosition"); normalID = glGetAttribLocation(shaderProgramID, "s_vNormal"); lightID = glGetUniformLocation(shaderProgramID, "vLight"); // NEW // gives the data to the shaders perspectiveMatrixID = glGetUniformLocation(shaderProgramID, "mP"); viewMatrixID = glGetUniformLocation(shaderProgramID, "mV"); modelMatrixID = glGetUniformLocation(shaderProgramID, "mM"); allRotsMatrixID = glGetUniformLocation(shaderProgramID, "mRotations"); glVertexAttribPointer(positionID, 3, GL_FLOAT, GL_FALSE, 0, 0); glVertexAttribPointer(normalID, 3, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(sizeof(vertices))); glUseProgram(shaderProgramID); glEnableVertexAttribArray(positionID); glEnableVertexAttribArray(normalID); // Turn on depth cullint glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glEnable(GL_DEPTH_TEST); glutMainLoop(); return 0; }
/* ************************************************************************ */ static void calculate (struct calculation_arguments const* arguments, struct calculation_results *results, struct options const* options) { int i, j; /* local variables for loops */ int m1, m2; /* used as indices for old and new matrices */ double star; /* four times center value minus 4 neigh.b values */ double residuum; /* residuum of current iteration */ double maxresiduum; /* maximum residuum value of a slave in iteration */ int const N = arguments->N; double const h = arguments->h; double pih = 0.0; double fpisin = 0.0; int term_iteration = options->term_iteration; /* initialize m1 and m2 depending on algorithm */ if (options->method == METH_JACOBI) { m1 = 0; m2 = 1; } else { m1 = 0; m2 = 0; } if (options->inf_func == FUNC_FPISIN) { pih = PI * h; fpisin = 0.25 * TWO_PI_SQUARE * h * h; } #if defined(ROWS) || defined(COLS) || defined(ELEMENTS) omp_set_num_threads(options->number); #endif while (term_iteration > 0) { double** Matrix_Out = arguments->Matrix[m1]; double** Matrix_In = arguments->Matrix[m2]; maxresiduum = 0; #if !defined(ROWS) && !defined(COLS) && !defined(ELEMENTS) for (i = 1; i < N; i++) { double fpisin_i = 0.0; if (options->inf_func == FUNC_FPISIN) { fpisin_i = fpisin * sin(pih * (double)i); } /* over all columns */ for (j = 1; j < N; j++) { #endif #ifdef ROWS #pragma omp parallel for private(j, star, residuum) reduction(max : maxresiduum) /* over all rows */ for (i = 1; i < N; i++) { double fpisin_i = 0.0; if (options->inf_func == FUNC_FPISIN) { fpisin_i = fpisin * sin(pih * (double)i); } /* over all columns */ for (j = 1; j < N; j++) { #endif #ifdef COLS #pragma omp parallel for private(i, star, residuum) reduction(max : maxresiduum) /* over all colums */ for (j = 1; j < N; j++) { /* over all rows */ for (i = 1; i < N; i++) { double fpisin_i = 0.0; if (options->inf_func == FUNC_FPISIN) { fpisin_i = fpisin * sin(pih * (double)i); } #endif #ifdef ELEMENTS int k; #pragma omp parallel for private(i, j, star, residuum) reduction(max : maxresiduum) for (k = 0; k < ((N-1) * (N-1) - 1); k++) { j = k % (N - 1) + 1; // +1 weil k bei 0 anfängt i = k / N +1; // i ist int, die Nachkommastellen fallen weg; +1 weil k bei 0 anfängt double fpisin_i = 0.0; if (options->inf_func == FUNC_FPISIN) { fpisin_i = fpisin * sin(pih * (double)i); } #endif star = 0.25 * (Matrix_In[i-1][j] + Matrix_In[i][j-1] + Matrix_In[i][j+1] + Matrix_In[i+1][j]); if (options->inf_func == FUNC_FPISIN) { star += fpisin_i * sin(pih * (double)j); } if (options->termination == TERM_PREC || term_iteration == 1) { residuum = Matrix_In[i][j] - star; residuum = (residuum < 0) ? -residuum : residuum; maxresiduum = (residuum < maxresiduum) ? maxresiduum : residuum; } Matrix_Out[i][j] = star; } #ifndef ELEMENTS } #endif results->stat_iteration++; results->stat_precision = maxresiduum; /* exchange m1 and m2 */ i = m1; m1 = m2; m2 = i; /* check for stopping calculation, depending on termination method */ if (options->termination == TERM_PREC) { if (maxresiduum < options->term_precision) { term_iteration = 0; } } else if (options->termination == TERM_ITER) { term_iteration--; } } results->m = m2; } /* ************************************************************************ */ /* displayStatistics: displays some statistics about the calculation */ /* ************************************************************************ */ static void displayStatistics (struct calculation_arguments const* arguments, struct calculation_results const* results, struct options const* options) { int N = arguments->N; double time = (comp_time.tv_sec - start_time.tv_sec) + (comp_time.tv_usec - start_time.tv_usec) * 1e-6; printf("Berechnungszeit: %f s \n", time); printf("Speicherbedarf: %f MiB\n", (N + 1) * (N + 1) * sizeof(double) * arguments->num_matrices / 1024.0 / 1024.0); printf("Berechnungsmethode: "); if (options->method == METH_GAUSS_SEIDEL) { printf("Gauss-Seidel"); } else if (options->method == METH_JACOBI) { printf("Jacobi"); } printf("\n"); printf("Interlines: %" PRIu64 "\n",options->interlines); printf("Stoerfunktion: "); if (options->inf_func == FUNC_F0) { printf("f(x,y) = 0"); } else if (options->inf_func == FUNC_FPISIN) { printf("f(x,y) = 2pi^2*sin(pi*x)sin(pi*y)"); } printf("\n"); printf("Terminierung: "); if (options->termination == TERM_PREC) { printf("Hinreichende Genaugkeit"); } else if (options->termination == TERM_ITER) { printf("Anzahl der Iterationen"); } printf("\n"); printf("Anzahl Iterationen: %" PRIu64 "\n", results->stat_iteration); printf("Norm des Fehlers: %e\n", results->stat_precision); printf("\n"); } /****************************************************************************/ /** Beschreibung der Funktion DisplayMatrix: **/ /** **/ /** Die Funktion DisplayMatrix gibt eine Matrix **/ /** in einer "ubersichtlichen Art und Weise auf die Standardausgabe aus. **/ /** **/ /** Die "Ubersichtlichkeit wird erreicht, indem nur ein Teil der Matrix **/ /** ausgegeben wird. Aus der Matrix werden die Randzeilen/-spalten sowie **/ /** sieben Zwischenzeilen ausgegeben. **/ /****************************************************************************/ static void DisplayMatrix (struct calculation_arguments* arguments, struct calculation_results* results, struct options* options) { int x, y; double** Matrix = arguments->Matrix[results->m]; int const interlines = options->interlines; printf("Matrix:\n"); for (y = 0; y < 9; y++) { for (x = 0; x < 9; x++) { printf ("%7.4f", Matrix[y * (interlines + 1)][x * (interlines + 1)]); } printf ("\n"); } fflush (stdout); } /* ************************************************************************ */ /* main */ /* ************************************************************************ */ int main (int argc, char** argv) { struct options options; struct calculation_arguments arguments; struct calculation_results results; /* get parameters */ AskParams(&options, argc, argv); /* ************************* */ initVariables(&arguments, &results, &options); /* ******************************************* */ allocateMatrices(&arguments); /* get and initialize variables and matrices */ initMatrices(&arguments, &options); /* ******************************************* */ gettimeofday(&start_time, NULL); /* start timer */ calculate(&arguments, &results, &options); /* solve the equation */ gettimeofday(&comp_time, NULL); /* stop timer */ displayStatistics(&arguments, &results, &options); DisplayMatrix(&arguments, &results, &options); freeMatrices(&arguments); /* free memory */ return 0; }
int main(int argc, const char *argv[]) { int N, M, T, maxIters, seed, i, j, iter, str_len; char **alphabet; double logProb, newLogProb; double *pi, *piBar, **A, **Abar, **B, **Bbar; struct stepStruct *step; FILE *in, *out; char s[80]; int wantTraining = 1; if(argc != 10) { fprintf(stderr, "\nUsage: %s N M T maxIters filename alphabet modelfile seed\n\n", argv[0]); fprintf(stderr, "where N == number of states of the HMM\n"); fprintf(stderr, " M == number of observation symbols\n"); fprintf(stderr, " T == number of observations in the training set\n"); fprintf(stderr, " maxIters == max iterations of re-estimation algorithm\n"); fprintf(stderr, " filename == name of input file\n"); fprintf(stderr, " alphabet == name of file defining the alphabet\n"); fprintf(stderr, " modelfile == name of model output file\n"); fprintf(stderr, " seed == seed value for pseudo-random number generator (PRNG)\n\n"); fprintf(stderr, " wantTraining == to train enter 1, otherwise 0 \n\n"); fprintf(stderr, "For example:\n\n %s 2 10 10000 500 datafile alphabet modelfile 1241\n\n", argv[0]); fprintf(stderr, "will create a HMM with 2 states and 10 observation symbols,\n"); fprintf(stderr, "will read in the first 10000 observations from `datafile',\n"); fprintf(stderr, "will use the observation symbols defined in file `alphabet', and\n"); fprintf(stderr, "will write the model (pi, A, B) to `modelfile', and\n"); fprintf(stderr, "will seed the PRNG with 1241 and train the HMM with a maximum of 500 iterations.\n\n"); exit(0); } N = atoi(argv[1]); M = atoi(argv[2]); T = atoi(argv[3]); maxIters = atoi(argv[4]); seed = atoi(argv[8]); wantTraining = atoi(argv[9]); pi = (double *)malloc(N * sizeof(double)); piBar = (double *)malloc(N * sizeof(double)); A = (double **)malloc(N * sizeof(double*)); Abar =static_cast<double **>(malloc(N * sizeof(double*))); for (i=0; i<N; ++i) { A[i] = static_cast<double *>(malloc(N * sizeof(double))); Abar[i] = static_cast<double *>(malloc(N * sizeof(double))); } B = static_cast<double **>(malloc(N * sizeof(double*))); Bbar = static_cast<double **>(malloc(N * sizeof(double*))); for (i=0; i<N; ++i) { B[i] = static_cast<double *>(malloc(M * sizeof(double))); Bbar[i] = static_cast<double *>(malloc(M * sizeof(double))); } //////////////////////// // read the data file // //////////////////////// // allocate memory printf("allocating %d bytes of memory... ", (T + 1) * sizeof(struct stepStruct)); fflush(stdout); if((step = static_cast<stepStruct *>(calloc(T + 1, sizeof(struct stepStruct)))) == NULL) { fprintf(stderr, "\nUnable to allocate alpha\n\n"); exit(0); } for (i=0; i<T+1; ++i) { step[i].alpha = static_cast<double *>(malloc(N * sizeof(double))); step[i].beta = static_cast<double *>(malloc(N * sizeof(double))); step[i].gamma = static_cast<double *>(malloc(N * sizeof(double))); step[i].diGamma = static_cast<double **>(malloc(N * sizeof(double*))); for (j=0; j<N; ++j) { step[i].diGamma[j] = static_cast<double *>(malloc(N * sizeof(double))); } } printf("done\n"); // read in the observations from file printf("GetObservations... "); fflush(stdout); in = fopen(argv[5], "r"); // argv[5] = filename if(in == NULL) { fprintf(stderr, "\nError opening file %s\n\n", argv[5]); exit(0); } i = 0; fgets(s,80,in); // get rid of the first line while (i < T) { fgets(s,80,in); step[i].obs = atoi(s); ++i; } fclose(in); printf("done\n"); // read in the alphabet from file printf("GetAlphabet... "); fflush(stdout); alphabet = static_cast<char **>(malloc(M * sizeof (char*))); in = fopen(argv[6], "r"); // argv[6] = alphabet if(in == NULL) { fprintf(stderr, "\nError opening file %s\n\n", argv[6]); exit(0); } i = 0; fgets(s,80,in); // get rid of the first line while (i < M) { fgets(s,80,in); str_len = strlen(s); alphabet[i] = static_cast<char *>(malloc(str_len * sizeof(char))); strncpy(alphabet[i], s, str_len-1); alphabet[i][str_len-1] = '\0'; ++i; } fclose(in); printf("done\n"); ///////////////////////// // hidden markov model // ///////////////////////// srand(seed); // initialize pi[], A[][] and B[][] initMatrices(pi, A, B, N, M, seed); // print pi[], A[][] and B[][] transpose printf("\nN = %d, M = %d, T = %d\n", N, M, T); printf("initial pi =\n"); printPi(pi, N); printf("initial A =\n"); printA(A, N); printf("initial B^T =\n"); printBT(B, N, M, alphabet); // initialization iter = 0; logProb = -1.0; newLogProb = 0.0; if (wantTraining) { // main loop while((iter < maxIters) && (newLogProb > logProb)) { printf("\nbegin iteration = %d\n", iter); logProb = newLogProb; // alpha (or forward) pass printf("alpha pass... "); fflush(stdout); alphaPass(step, pi, A, B, N, T); printf("done\n"); // beta (or backwards) pass printf("beta pass... "); fflush(stdout); betaPass(step, pi, A, B, N, T); printf("done\n"); // compute gamma's and diGamma's printf("compute gamma's and diGamma's... "); fflush(stdout); computeGammas(step, pi, A, B, N, T); printf("done\n"); // find piBar, reestimate of pi printf("reestimate pi... "); fflush(stdout); reestimatePi(step, piBar, N); printf("done\n"); // find Abar, reestimate of A printf("reestimate A... "); fflush(stdout); reestimateA(step, Abar, N, T); printf("done\n"); // find Bbar, reestimate of B printf("reestimate B... "); fflush(stdout); reestimateB(step, Bbar, N, M, T); printf("done\n"); #ifdef PRINT_REESTIMATES printf("piBar =\n"); printPi(piBar, N); printf("Abar =\n"); printA(Abar, N); printf("Bbar^T = \n"); printBT(Bbar, N, M, alphabet); #endif // PRINT_REESTIMATES // assign pi, A and B corresponding "bar" values for(i = 0; i < N; ++i) { pi[i] = piBar[i]; for(j = 0; j < N; ++j) { A[i][j] = Abar[i][j]; } for(j = 0; j < M; ++j) { B[i][j] = Bbar[i][j]; } }// next i // compute log [P(observations | lambda)], where lambda = (A,B,pi) newLogProb = 0.0; for(i = 0; i < T; ++i) { newLogProb += log(step[i].c); } newLogProb = -newLogProb; // a little trick so that no initial logProb is required if(iter == 0) { logProb = newLogProb - 1.0; } printf("completed iteration = %d, log [P(observation | lambda)] = %f\n", iter, newLogProb); ++iter; }// end while out = fopen(argv[7], "w"); // argv[7] = modelfile writeModel(pi, A, B, N, M, T, alphabet, out); fclose(out); printf("\nT = %d, N = %d, M = %d, iterations = %d\n\n", T, N, M, iter); printf("final pi =\n"); printPi(pi, N); printf("\nfinal A =\n"); printA(A, N); printf("\nfinal B^T =\n"); printBT(B, N, M, alphabet); printf("\nlog [P(observations | lambda)] = %f\n\n", newLogProb); } // end of training else { //want to do testing out = fopen(argv[7], "r"); // argv[7] = modelfile readModelFile(pi, A, B, N, M, T, alphabet, out); // alpha (or forward) pass printf("alpha pass... "); fflush(stdout); alphaPass(step, pi, A, B, N, T); printf("done\n"); printf("logProb %f\n", computeLogProb(step, T)/T); // FILE * newFile = fopen("testing.txt", "a"); //writeModel(pi, A, B, N, M, T, alphabet, newFile); //fclose(newFile); fclose(out); } // end of testing }// end hmm
int main (int argc, char** argv) { AskParams(&options, argc, argv); if (argc > 7) { altermode = argv[7]; if (rank == root) { printf("altermode enabled!\n"); } } MPI_Init(&argc, &argv); MPI_Comm_size(MPI_COMM_WORLD, &size); MPI_Comm_rank(MPI_COMM_WORLD, &rank); last = size-1; printf("process %d starting ...\n", rank); initVariables(); initMatrices(); gettimeofday(&start_time, NULL); calculate(); MPI_Barrier(MPI_COMM_WORLD); gettimeofday(&comp_time, NULL); if (rank == root) { double time = (comp_time.tv_sec - start_time.tv_sec) + (comp_time.tv_usec - start_time.tv_usec) * 1e-6; printf("Berechnungszeit: %f s \n", time); printf("Anzahl Iterationen: %d\n", iteration); } DisplayMatrix(); //testPrint(); /*MPI_Barrier(MPI_COMM_WORLD); if (rank == 0) { for (int i = 0; i < actuallines; i++) { for (int j = 0; j <= N; j++) { printf("%7.4f ", newmatrix[i][j]); } printf("\n"); } printf("\n"); } MPI_Barrier(MPI_COMM_WORLD); if (rank == 1) { for (int i = 0; i < actuallines; i++) { for (int j = 0; j <= N; j++) { printf("%7.4f ", newmatrix[i][j]); } printf("\n"); } printf("\n"); } MPI_Barrier(MPI_COMM_WORLD); if (rank == 2) { for (int i = 0; i < actuallines; i++) { for (int j = 0; j <= N; j++) { printf("%7.4f ", newmatrix[i][j]); } printf("\n"); } printf("\n"); } MPI_Barrier(MPI_COMM_WORLD); if (rank == 3) { for (int i = 0; i < actuallines; i++) { for (int j = 0; j <= N; j++) { printf("%7.4f ", newmatrix[i][j]); } printf("\n"); } printf("\n"); }*/ freeMemory(); MPI_Finalize(); }