int main(int argc, char** argv) {
pthread_t threads[NUM_THRD];
int thread_args[NUM_THRD];
int rc, i;
//Init Matrix
initMatrix();
while(errorCount()) {
for (int x = 0; x < SIZE; x++)
x1[x] = x2[x];
//Count N * x + b
for (i = 0; i < NUM_THRD; i++) {
thread_args[i] = i;
rc = pthread_create(&threads[i], NULL, count, (void *) &thread_args[i]);
assert(0 == rc);
}
for (i = 0; i < NUM_THRD; i++) {
rc = pthread_join(threads[i], NULL);
assert(0 == rc);
}
}
printX2();
return 0;
}
// units of k0, kp, only matter relative to d (only m*d products ever used)
SMatrix::SMatrix(const cdouble *eps, const double *d, int NIn, double k0In, double kpIn)
: kz(new cdouble[N+1]), k(new cdouble[N+1]), kp(kpIn), k0(k0In), N(NIn),
sTE(new cdouble[4*(2*N+1)]), sTM(new cdouble[4*(2*N+1)]) // member init. list
{
mlgeo g = mlgeo(eps, d, N);
initMatrix(g);
}
int main(int argc, char* argv[]){
int i;
char c;
int selectedFunc=-1;
while( (c=getopt(argc,argv,"M:N:F:")) != -1){
switch(c){
case 'M':
M = atoi(optarg);
break;
case 'N':
N = atoi(optarg);
break;
case 'F':
selectedFunc = atoi(optarg);
break;
case '?':
default:
printf("./tracegen failed to parse its options.\n");
exit(1);
}
}
/* Register transpose functions */
registerFunctions();
/* Fill A with data */
initMatrix(M,N, A, B);
/* Record marker addresses */
FILE* marker_fp = fopen(".marker","w");
assert(marker_fp);
//fprintf(marker_fp, "%llx %llx",
fprintf(marker_fp, "%lx %lx",
//(unsigned long long int) &MARKER_START,
//(unsigned long long int) &MARKER_END );
(unsigned long int) &MARKER_START,
(unsigned long int) &MARKER_END );
fclose(marker_fp);
if (-1==selectedFunc) {
/* Invoke registered transpose functions */
for (i=0; i < func_counter; i++) {
MARKER_START = 33;
(*func_list[i].func_ptr)(M, N, A, B);
MARKER_END = 34;
if (!validate(i,M,N,A,B))
return i+1;
}
} else {
MARKER_START = 33;
(*func_list[selectedFunc].func_ptr)(M, N, A, B);
MARKER_END = 34;
if (!validate(selectedFunc,M,N,A,B))
return selectedFunc+1;
}
return 0;
}
Matrix *copyMatrixConfig(Matrix *from) {
Matrix *to = initMatrix();
to->pages = from->pages;
allocMatrixByConfig(to);
return to;
}
int main(int argc, char *argv[]) {
if(argc != 5) {
printf("Usage:\n<program_name> <rows> <columns> <aug_rows> <aug_columns>\n");
return -1;
}
int r1=atoi(argv[1]);
int c1=atoi(argv[2]);
int r2=atoi(argv[3]);
int c2=atoi(argv[4]);
if(r1 != r2) {
printf("\n Number of rows of both matrix should be same %d != %d", r1, r2);
return -2;
}
int **matrix1 = createMatrix(r1,c1);
int **matrix2 = createMatrix(r2,c2);
printf("Matrix 1 :\n");
initMatrix(matrix1, r1,c1);
displayMatrix(matrix1, r1,c1);
printf("Matrix 2 :\n");
initMatrix(matrix2, r2,c2);
displayMatrix(matrix2, r2,c2);
int **aug_matrix3 = augMatrix(matrix1, r1, c1, matrix2, r2, c2);
deleteMatrix(matrix1,r1,c1);
deleteMatrix(matrix2,r2,c2);
int r3 = r1;
int c3 = c1 + c2;
printf("\nSum Matrix 3 :\n");
displayMatrix(aug_matrix3, r3, c3);
deleteMatrix(aug_matrix3,r3,c3);
return 0;
}
void AliasingManager::computeClosure() {
// Initialization of matrices
initMatrix(MK_SymetricalMatrix);
initMatrix(MK_ClosedMatrix);
// Efficient closure algorithm
// http://www.enseignement.polytechnique.fr/informatique/profs/
// Jean-Jacques.Levy/poly/main5/node5.html
for (int x = 0, n = m_dimension; x < n; x++)
for (int u = 0; u < n; u++)
if (m_matricesMap[MK_ClosedMatrix][u][x])
for (int v = 0; v < n; v++)
if (m_matricesMap[MK_ClosedMatrix][x][v])
m_matricesMap[MK_ClosedMatrix][u][v] = true;
m_matrixChanged = false;
}
void VisualMatrix::init()
{
initSprite();
initEffect();
initMatrix();
initStats();
initState();
}
void CMap::increaseMap()
{
width++;
height++;
center();
initMatrix();
}
mesh_core::PlaneProjection::PlaneProjection(
const Eigen::Vector3d& normal,
const Eigen::Vector3d& origin,
const Eigen::Vector3d& x_axis)
: Plane(normal, origin)
, origin_(origin)
{
initMatrix(x_axis);
}
int main(){
int **M;
int i=0;
initMatrix(M);
setDataToMatrix(M);
printMatrix(M);
findMaAn(M);
return 1;
}
int main (int argc, char *argv[])
{
int c, i, j;
int begin, end;
int iTotalSize;
pthread_attr_t attr;
pthread_t *tid;
int *id;
double error;
if (argc == 1)
{
printf("This program should take at least one parameter for input matrix\n");
return 0;
}
if (argc == 3)
task_num = atoi(argv[2]);
if (argc > 3)
{
printf("This program should not take more than 2 parameters \n");
return 0;
}
nsize = initMatrix(argv[1]);
id = (int *) malloc (sizeof (int) * task_num);
tid = (pthread_t *) malloc (sizeof (pthread_t) * task_num);
if (!id || !tid)
{
fprintf(stderr, "The matrix file open error\n");
exit(-1);
}
pthread_attr_init (&attr);
pthread_attr_setscope (&attr, PTHREAD_SCOPE_SYSTEM);
for (i = 1; i < task_num; i++) {
id[i] = i;
pthread_create (&tid[i], &attr, work_thread, &id[i]);
}
id[0]=0;
work_thread(&id[0]);
// wait for all threads to finish
for (i = 1; i < task_num; i++)
pthread_join (tid[i], NULL);
FILE *result;
result = fopen ("result.txt", "w");
for (i=0; i<nsize; i++){
fprintf (result, "X[%d] = %f \n", i, X[i]);
}
error = 0.0;
for (i = 0; i < nsize; i++) {
double error__ = (X__[i]==0.0) ? 1.0 : fabs((X[i]-X__[i])/X__[i]);
if (error < error__) {
error = error__;
}
}
fprintf(stdout, "Error: %6.3f\n", error);
return 0;
}
// Position and Rotation
const LLMatrix4& LLMatrix4::initRotTrans(const F32 angle, const F32 rx, const F32 ry, const F32 rz,
const F32 tx, const F32 ty, const F32 tz)
{
LLMatrix3 mat(angle, rx, ry, rz);
LLVector3 translation(tx, ty, tz);
initMatrix(mat);
setTranslation(translation);
return (*this);
}
mesh_core::PlaneProjection::PlaneProjection(
const Plane& plane,
const Eigen::Vector3d& point_near_origin,
const Eigen::Vector3d& x_axis)
: Plane(plane)
{
double dist = point_near_origin.dot(normal_) + d_;
origin_ = point_near_origin - dist * normal_;
initMatrix(x_axis);
}
Matrix4 orthoM(float left, float right, float bottom, float top, float near, float far) {
float tx = -(right+left)/(right-left);
float ty = -(top+bottom)/(top-bottom);
float tz = -(far+near)/(far-near);
return initMatrix(
2/(right-left), 0, 0, 0,
0, 2/(top-bottom), 0, 0,
0, 0, -2/(far-near), 0,
tx, ty, tz, 1);
}
/* returns an nxn identity matrix */
Matrix idMat(int n)
{
Matrix mat = initMatrix(n);
int i;
for(i = 0; i < n; i++)
{
mat->m[i][i] = 1;
}
return mat;
}
int MatchingApplication::match() {
try{
addOptions();
processArguments();
initConfiguration();
// Cleaning
if(w_)
delete w_;
if(g1_)
delete g1_;
if(g2_)
delete g2_;
if(gl1_)
delete gl1_;
if(gl2_)
delete gl2_;
w_ = 0;
g1_ = g2_ = 0;
gl1_ = gl2_ = 0;
// Check number of arguments
QStringList args = positionalArguments();
if(args.size() != 2)
Exception(QString("You must provide exactly two %1 (%2 given)").arg(isMultiMatching_?"directories":"graphs").arg(args.size()));
// Loading weights and graphs
w_ = new Weights(cfg_->substitution, cfg_->creation);
if(isMultiMatching_) {
gl1_ = new GraphList(QDir(args.at(0)), cfg_->ext);
gl2_ = (args.at(0).compare(args.at(1)) == 0)? gl1_ : new GraphList(QDir(args.at(1)), cfg_->ext);
} else {
g1_ = new Graph(args.at(0));
g2_ = new Graph(args.at(1));
}
initMatrix();
QThreadPool::globalInstance()->setMaxThreadCount(cfg_->parallelInstances);
// Running the matching(s)
if(isMultiMatching_) {
for(auto i : *gl1_)
for(auto j : *gl2_)
if((gl1_ != gl2_) || (j->getIndex() > i->getIndex()))
queue_.enqueue(qMakePair(i,j));
} else {
queue_.enqueue(qMakePair(g1_, g2_));
}
populate();
return exec();
} catch(std::exception &e) {
error(e);
}
return EXIT_FAILURE;
}
int main(int argc, char* argv[])
{
//loadCalculatedValues();
parseFile("input.txt");
initMatrix();
calculateCurrentMoves();
runTestMoves();
outputFile("output.txt");
//std::cout << "p1 score is " << player1Score << " p2 score is " << player2Score << std::endl;
return 0;
}
/* create a 2D matrix from a 1D array */
Matrix createMatrix(double *mtx, int n)
{
Matrix mat = initMatrix(n);
int i,j;
for(i = 0; i < n; i++)
{
for(j = 0; j < n; j++, mtx++)
mat->m[i][j] = *mtx;
}
return mat;
}
void NewLDAModel(LDAMODEL** m)
{
(*m) = xmalloc(sizeof(LDAMODEL));
initUIVector(&((*m)->classid));
initMatrix(&((*m)->evect));
initArray(&((*m)->mnpdf));
initArray(&((*m)->features));
initMatrix(&((*m)->inv_cov));
initMatrix(&((*m)->mu));
initMatrix(&((*m)->fsdev));
initMatrix(&((*m)->fmean));
initDVector(&((*m)->eval));
initDVector(&((*m)->pprob));
initDVector(&((*m)->sens));
initDVector(&((*m)->spec));
initDVector(&((*m)->ppv)); /* o precision */
initDVector(&((*m)->npv));
initDVector(&((*m)->acc));
(*m)->nclass = (*m)->class_start = 0;
}
void onDraw()
{
/*setViewer O(1)*/
setMatrixMode(PROJECTION);
initMatrix();
setViewer(vertex(eyex, eyey, eyez), vertex(lookx, looky, lookz), vertex(upx, upy, upz));
setFrustum(10, 10*MAX_H/MAX_W, 4, 25);
/*createPolygons O(1)*/
initScene();
setMatrixMode(MODELVIEW);
initMatrix();
if(!Aisclippingwindow)
drawA(Ax, Ay, Az);
drawB(Bx, By, Bz);
/*drawPixels*/
renderScene();
glDrawPixels(MAX_W, MAX_H, GL_RGBA, GL_BYTE, data);
glFlush();
}
int main(int argc, char *argv[])
{
int i;
struct timeval start, finish;
double error;
pthread_attr_t attr;
pthread_t *tid;
int *id;
if (argc < 2) {
fprintf(stderr, "usage: %s <matrixfile>\n", argv[0]);
exit(-1);
}
// for getting the threads
if(argc == 3) {
task_num = strtol(argv[2], NULL, 10);
}
nsize = initMatrix(argv[1]);
initRHS(nsize);
initResult(nsize);
// create threads
id = (int *) malloc (sizeof (int) * task_num);
tid = (pthread_t *) malloc (sizeof (pthread_t) * task_num);
if (!id || !tid)
errexit ("out of shared memory");
pthread_attr_init (&attr);
pthread_attr_setscope (&attr, PTHREAD_SCOPE_SYSTEM);
for (i = 1; i < task_num; i++) {
id[i] = i;
pthread_create (&tid[i], &attr, work_thread, &id[i]);
}
id[0]=0;
work_thread(&id[0]);
// wait for all threads to finish
for (i = 1; i < task_num; i++)
pthread_join (tid[i], NULL);
solveGauss(nsize);
error = 0.0;
for (i = 0; i < nsize; i++) {
double error__ = (X__[i]==0.0) ? 1.0 : fabs((X[i]-X__[i])/X__[i]);
if (error < error__) {
error = error__;
}
}
fprintf(stdout, "Error: %e\n", error);
}
static int readFile(FILE *file, pmatrix_t *matrix, index_t rows, index_t columns) {
index_t x, y;
initMatrix(matrix, rows, columns);
if (matrix == NULL)
return ERRORCODE_CANT_MALLOC;
for(y = 0; y < rows; y++) {
for(x = 0; x < columns; x++)
if (fscanf(file, UNIT_SPECIFIER, getMatrixElement(*matrix, y, x)) != 1)
return ERRORCODE_PARSER_ERROR;
}
return ERRORCODE_NOERRORS;
}
int main(){
std::vector<std::vector<int>> matrix;
initMatrix(matrix);
int toy = matrix[6][8] * matrix[7][9] * matrix[8][10] * matrix[9][11];
std::cout << " toy example: " << toy << std::endl;
std::cout << " the greatest product of 4 is " << products(matrix) << std::endl;
return 0;
}
float TExamplesDistance_DTW::operator ()(const TExample &e1, const TExample &e2) const
{
vector<float> seq1, seq2, der1, der2;
getNormalized(e1, seq1);
getNormalized(e2, seq2);
TdtwMatrix mtrx;
switch (dtwDistance) {
case DTW_EUCLIDEAN: {
initMatrix(seq1, seq2, mtrx);
break;
}
case DTW_DERIVATIVE: {
getDerivatives(seq1, der1);
getDerivatives(seq2, der2);
initMatrix(der1, der2, mtrx);
break;
}
}
float dist = calcDistance(mtrx);
return dist;
}
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;
}
ForwardBackward::ForwardBackward(const HiddenMarkovModel &hmm, const std::vector<int> &outputSequence)
: hmm(hmm), outputSequence(outputSequence)
{
assert(outputSequence.size() > 0);
int timeEnd = outputSequence.size()-1;
lnForward = initMatrix(timeEnd + 1, hmm.getAmountHiddenStates(), 1.0);
int start = 0;
int outputIndex = outputSequence.at(start);
for (size_t i = 0; i < hmm.getAmountHiddenStates(); i++) {
lnForward.at(start).at(i) = hmm.lnInitial.at(i)
+ hmm.lnEmission.at(i).at(outputIndex);
}
lnBackward = initMatrix(timeEnd + 1, hmm.getAmountHiddenStates(), 1.0);
for (size_t i = 0; i < hmm.getAmountHiddenStates(); i++) {
lnBackward.at(timeEnd).at(i) = 0;
}
}
short newCorner( short alpha, short beta, short gamma,
short c1, short c2, short c3)
{ // generates a cube corner (3 x face)
// alpha beta gamma indicate the rotation
// c1, c2, c3 are the colors for the three faces in order
// return index to face table (containing 3 new faces)
short fo, po;
short x, y, z;
short a, b ,c, d, e, f, g;
// determin vertex coordinates
x = (U + U/2 +3);
y = (U + U/2 +3);
z = (U + U/2 +3);
// rotation
initMatrix( mo, alpha, beta, gamma, 0, 0, 0);
// verify there is room in the tables
if ((facec>=3) && (pyc>=3) && (pc>=7))
{
// generate all points necessary for the cube corner
// in base position
a = newPoint( x, y, z); // A
b = newPoint( x, y-U, z); // B
c = newPoint( x-U, y-U, z); // C
d = newPoint( x-U, y, z); // D
e = newPoint( x, y-U, z-U); // E
f = newPoint( x, y, z-U); // F
g = newPoint( x-U, y, z-U); // G
// generate all the polygons and faces
// with proper orientation (normal outbound)
newFace ( newPoly( a, b, c, d), c1);
newFace ( newPoly( d, g, f, a), c2);
fo = newFace( newPoly( a, f, e, b), c3);
// add an object with 3 faces
po = newObj( fo, 3);
// rotate as required
rotateObject( mo, po);
// returns the object index
return po;
} // if
else
while( 1);
} // new cube corner
void Skok(fxpnt_matrix_t **Y, fxpnt_matrix_t **U, int N, int d, int delay){
int i,j;
m_free(Y);
m_free(U);
*U = initMatrix(N, 1);
*Y = initMatrix(N, 1);
for(i = 0; i < delay; i++)
(*U)->matrix[i][0] = 0;
for(i = delay; i < N; i++)
(*U)->matrix[i][0] = 1;
for(i = 0; i < N-d; i++){
for(j = 0; j < St; j++){
if(i > j){
(*Y)->matrix[i+d][0] = (*Y)->matrix[i+d][0] - teta->matrix[j][0]*(*Y)->matrix[i-j+d-1][0];
}
}
for(j = 0; j <= teta->rows - St; j++){
if(i > j){
(*Y)->matrix[i+d][0] = (*Y)->matrix[i+d][0] + teta->matrix[j+St][0]*(*U)->matrix[i-j][0];
}
}
}
}
/* create a clone of matrix provided */
Matrix copyMatrix(Matrix mat)
{
Matrix copy = initMatrix(mat->dim);
copy->dim = mat->dim;
int i, j;
for(i = 0; i < mat->dim; i++)
{
for(j = 0; j < mat->dim; j++)
{
copy->m[i][j] = mat->m[i][j];
}
}
return copy;
}
void init_output_dist(const Eigen::MatrixBase<Derived> &outputDist_const,const Eigen::MatrixBase<Derived2> &normalization_const) {
UNCONST(Derived,outputDist_const,outputDist);
UNCONST(Derived2,normalization_const,normalization);
initMatrix(outputDist);
//std::cout << outputDist << "\n\n";
normalization.setZero();
for(int i=0; i<outputDist.rows(); i++) {
normalization += outputDist.row(i);
}
for(int i=0; i<outputDist.rows(); i++) {
outputDist.row(i) = (outputDist.row(i).array()/normalization.array()).matrix();
}
}
