void task2(int size, int tid, int ctid) {
{
std::stringstream ss;
ss << "task 2 with tid " << tid << " and ctid " << ctid << " started" << std::endl;
std::cout << ss.str();
}
matrix mk, mn;
mk = generateMatrix(size);
mn = generateMatrix(size);
int result = func2(mk, mn);
if (size < 8) {
std::stringstream ss;
ss << "task 2 result: " << result;
ss << std::endl;
std::cout << ss.str();
}
{
std::stringstream ss;
ss << "task 2 with tid " << tid << " and ctid " << ctid << " finished" << std::endl;
std::cout << ss.str();
}
}
void task3(int size, int tid, int ctid) {
{
std::stringstream ss;
ss << "task 3 with tid " << tid << " and ctid " << ctid << " started" << std::endl;
std::cout << ss.str();
}
vector w, x;
matrix ms, mz;
w = generateVector(size);
x = generateVector(size);
ms = generateMatrix(size);
mz = generateMatrix(size);
vector result = func3(ms, mz, w, x);
if (size < 8) {
std::stringstream ss;
ss << "task 3 result: ";
ss << '[';
for (int i = 0; i < result.size(); ++i) {
ss << result[i] << " ";
}
ss << ']';
ss << std::endl;
std::cout << ss.str();
}
{
std::stringstream ss;
ss << "task 3 with tid " << tid << " and ctid " << ctid << " finished" << std::endl;
std::cout << ss.str();
}
}
void testMatrixMulti(void)
{
int **matrixA, **matrixB;
int **matrixResult;
int rowNumOfA, colNumOfA;
int rowNumOfB, colNumOfB;
int rowNumOfR, colNumOfR;
rowNumOfA = 2;
colNumOfA = 3;
rowNumOfB = 3;
colNumOfB = 2;
matrixA = generateMatrix(rowNumOfA, colNumOfA);
matrixB = generateMatrix(rowNumOfB, colNumOfB);
matrixResult = make2DArray(rowNumOfA, colNumOfA);
printf("----------- test: matrix multiplication ------------------\n");
if(!matrixMulti(matrixResult, matrixA, rowNumOfA, colNumOfA, matrixB, rowNumOfB, colNumOfB)) {
printf("matrixA\n");
printMatrix(matrixA, rowNumOfA, colNumOfA);
printf("matrixB\n");
printMatrix(matrixB, rowNumOfB, colNumOfB);
printf("matrixResult = matrixA x matrixB\n");
rowNumOfR = rowNumOfA;
colNumOfR = colNumOfB;
printMatrix(matrixResult, rowNumOfR, colNumOfR);
}
else
printf("Fail to matrix multiplication\n");
}
void task1(int size, int tid, int ctid) {
{
std::stringstream ss;
ss << "task 1 with tid " << tid << " and ctid " << ctid << " started" << std::endl;
std::cout << ss.str();
}
vector a, b;
matrix ma, md;
a = generateVector(size);
b = generateVector(size);
ma = generateMatrix(size);
md = generateMatrix(size);
vector result = func1(a, b, ma, md);
if (size < 8) {
std::stringstream ss;
ss << "task 1 result: ";
ss << '[';
for (int i = 0; i < result.size(); ++i) {
ss << result[i] << " ";
}
ss << ']';
ss << std::endl;
std::cout << ss.str();
}
{
std::stringstream ss;
ss << "task 1 with tid " << tid << " and ctid " << ctid << " finished" << std::endl;
std::cout << ss.str();
}
}
int main() {
int i, args[THREADS_COUNT];
int size = MATRIX_SIZE / THREADS_COUNT;
pthread_t thID[THREADS_COUNT];
allocateMemory(&matrix1);
allocateMemory(&matrix2);
allocateMemory(&result);
generateMatrix(matrix1);
sleep(1);
generateMatrix(matrix2);
for (i = 0; i < THREADS_COUNT; i++) {
args[i] = i;
pthread_create(&(thID[i]), NULL, multMatrix, (void*)(&(args[i])));
}
for (i = 0; i < THREADS_COUNT; i++) {
pthread_join(thID[i], NULL);
}
/* printMatrix(matrix1);
printf("\n");
printMatrix(matrix2);
printf("\n");
printMatrix(result); */
freeMemory(matrix1);
freeMemory(matrix2);
freeMemory(result);
return 0;
}
void testMatrixSum(void)
{
int **matrixA, **matrixB;
int **matrixResult;
int rowNum, colNum;
rowNum = colNum = 3;
matrixA = generateMatrix(rowNum, colNum);
matrixB = generateMatrix(rowNum, colNum);
matrixResult = make2DArray(rowNum, colNum);
matrixSum(matrixResult, matrixA, matrixB, rowNum, colNum);
printf("----------- test: matrix addition ------------------\n");
printf("matrixA\n");
printMatrix(matrixA, rowNum, colNum);
printf("matrixB\n");
printMatrix(matrixB, rowNum, colNum);
printf("matrixResult = matrixA + matrixB\n");
printMatrix(matrixResult, rowNum, colNum);
}
int main(int argc, char *argv[])
{
int n;
float **m = NULL;
float **k = NULL;
float **kt = NULL;
struct timeval fin, ini;
float **res = NULL;
int n_threads = 1;
if ( argc != 3 )
{
printf("Error: ./%s <matrix size> <threads>\n", argv[0]);
return -1;
}
n_threads = atoi(argv[2]);
n = atoi(argv[1]);
m = generateMatrix(n);
k = generateMatrix(n);
kt = generateEmptyMatrix(n);
res = generateEmptyMatrix(n);
if ( !m || !k || !res || !kt)
{
return -1;
}
omp_set_num_threads(n_threads);
gettimeofday(&ini, NULL);
/* Main computation */
compute(m, k, kt, res, n);
/* End of computation */
gettimeofday(&fin, NULL);
#ifdef OUTPUT_RESULT
int i, j;
for(i = 0; i < n; i++)
{
for(j = 0; j < n; j++)
printf("%.1f ", res[i][j]);
printf("\n");
}
#else
printf("%f", ((fin.tv_sec * 1000000 + fin.tv_usec) - (ini.tv_sec * 1000000 + ini.tv_usec)) * 1.0 / 1000000.0);
#endif
free(m);
return 0;
}
int main(int argc, char* argv[]){
int tam=0;
struct timeval t_ini, t_fin;
num **A=NULL, **B=NULL, **e_matrix=NULL, **t_matrix=NULL, **B_t=NULL;
int i=0, j=0;
tam=atoi(argv[1]);
/*Generar las matrices*/
A=generateMatrix(tam);
B=generateMatrix(tam);
e_matrix=generateEmptyMatrix(tam);
t_matrix=generateEmptyMatrix(tam);
B_t=generateEmptyMatrix(tam);
/*Multiplicar matrices*/
/* Multiplicacion normal*/
gettimeofday(&t_ini,NULL);
mult(A, B, e_matrix,tam);
gettimeofday(&t_fin,NULL);
printf("%f\n", ((t_fin.tv_sec*1000000+t_fin.tv_usec)-(t_ini.tv_sec*1000000+t_ini.tv_usec))*1.0/1000000.0);
/*Multiplicacion traspuesta*/
traspuesta(B, B_t, tam);
gettimeofday(&t_ini, NULL);
mult_t(A, B_t, t_matrix,tam);
gettimeofday(&t_fin, NULL);
printf("%f\n", ((t_fin.tv_sec*1000000+t_fin.tv_usec)-(t_ini.tv_sec*1000000+t_ini.tv_usec))*1.0/1000000.0);
/*printf("Normal\n");
for(i=0; i<tam; i++){
for(j=0; j<tam; j++){
printf("| %f |", B[i][j]);
}
printf("\n");
}
printf("\nTraspueta\n");
for(i=0; i<tam; i++){
for(j=0; j<tam; j++){
printf("| %f |", B_t[i][j]);
}
printf("\n");
}*/
freeMatrix(A);
freeMatrix(B);
freeMatrix(B_t);
freeMatrix(e_matrix);
freeMatrix(t_matrix);
return 0;
}
int main(int argc, char** argv)
{
float **A=NULL, **B=NULL, **C=NULL;
int i=0,j=0,k=0;
struct timeval fin,ini;
unsigned long long num;
unsigned long thr;
int sum=0;
thr=atoi(argv[1]);
num=atoi(argv[2]);
A = generateMatrix(num);
B = generateMatrix(num);
C = generateEmptyMatrix(num);
if ( !A || !B || !C)
{
printf("Error when allocationg matrix\n");
freeMatrix(A);
freeMatrix(B);
freeMatrix(C);
return -1;
}
gettimeofday(&ini,NULL);
omp_set_num_threads(thr);
/* Bloque de computo */
#pragma omp parallel for private(k,i,j) firstprivate(A,B) shared(C) schedule(static)
for (i=0; i<num; i++){
for (j=0; j<num; j++){
for (k=0; k<num; k++){
C[i][j]+= A[i][k] * B[k][j];
}
}
}
/* Fin del computo */
gettimeofday(&fin,NULL);
//printf("Resultado: %f\t%f\t%f\n",C[0][0],C[1][1],C[2][2]);
printf("Tiempo: %f\n", ((fin.tv_sec*1000000+fin.tv_usec)-(ini.tv_sec*1000000+ini.tv_usec))*1.0/1000000.0);
freeMatrix(A);
freeMatrix(B);
freeMatrix(C);
return 0;
}
int main(int argc, char * argv[]){
int n = 5, i;
int **edge = generateMatrix(n);
printMatrix(edge, n);
int **result = floyd(n, edge);
}
int main() {
generateMatrix();
std::vector<int> colSum(MatrixSize);
for(int i = 0; (i < 100); i++) {
columnSum2(colSum);
}
std::cout << "colSum[10] = " << colSum[10] << std::endl;
return 0;
}
int main(){
vector<vector<int> > res = generateMatrix(5);
for(int i=0; i<res.size(); i++){
for(int j=0; j<res[i].size(); j++)
printf("%d ", res[i][j]);
printf("\n");
}
return 0;
}
int main(int argc, char* argv[]) {
/* Set parameters */
int N = atoi(argv[1]);
int nIterations = atoi(argv[2]);
/* Start parallel calculations */
int rank, p;
MPI_Init(&argc, & argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &p);
/* p has to be a divisor of N !! */
if(rank==0) assert(!(N%p));
/* Test the used algorithms */
//matrix_testAll();
/* Generate the matrix */
double matrix[N*N/p];
generateMatrix(matrix,N);
/* Run the powerMethod algorithm */
double start = MPI_Wtime();
double lambda = powerMethod(matrix,nIterations,N);
double stop = MPI_Wtime();
/* Calculating times */
double timediff = stop - start;
double times[p];
double average = 0;
MPI_Gather(&timediff,1,MPI_DOUBLE,times,1,MPI_DOUBLE,0,MPI_COMM_WORLD);
if(rank==0){
for(int i=0; i<p; i++)
average += times[i];
average /= p;
}
/* Print the results */
if(rank==0)
printf("dimension\t%d\tlambda\t%f\ttime\t%f\n",N,lambda,average);
/* End MPI */
MPI_Finalize();
return 0;
}
int main(){
int i,n;
while(scanf("%d", &n) && n != 0) {
generateMatrix(n);
printf("\n");
}
return 0;
}
int main()
{
int n;
while (~scanf("%d", &n)) {
int **m = generateMatrix(n);
printf("The spiral matrix of size %d is:\n", n);
print_matrix(m, n);
free_matrix(m, n);
}
}
int main (int argc, char ** argv)
{
if (argc != 3)
{
printf("Use: %s <N> <T>, onde 'N' é a dimensão da matriz unitária e 'T' é o número de threads.\n", argv[0]);
return 1;
}
//Retira valores dos argumentos passados pela linha de comando
matrix_size = atoi(argv[1]);
number_of_threads = atoi(argv[2]);
//Aloca espaço para variáveis e ponteiros para colunas
A = allocateMatrix(matrix_size);
//Gera matrizes A e B
generateMatrix(A, matrix_size);
//Imprime A e B (teste)
if (matrix_size < 20)
printMatrix(A, matrix_size, "A");
//Ponteiro com threads
pthread_t * p_threads;
//Alocação de espaço para threads de acordo com o número de threads
p_threads = (pthread_t *) malloc(number_of_threads * sizeof(pthread_t));
//Inicializa o mutex
pthread_mutex_init(&mut, NULL);
//Captura tempo inicial
clock_gettime(CLOCK_MONOTONIC, &initial_time);
//Criação de threads
createThreads(p_threads, number_of_threads, matrix_size, A);
//Join das threads
joinThreads(p_threads);
//Captura tempo final
clock_gettime(CLOCK_MONOTONIC, &end_time);
//imprime resultado
printf("A soma de todos os termos é: %d\n", sum);
//Calcula tempo final
double elapsed = end_time.tv_sec - initial_time.tv_sec;
elapsed += (end_time.tv_nsec - initial_time.tv_nsec) / 1000000000.0;
printf ("O tempo de processamento foi de: %f segundos\n", elapsed);
//Inicializa o mutex
pthread_mutex_destroy(&mut);
return 0;
}
int main(int argc, char *argv[]){
// Instantiate tallied variables.
int i, j, width, correct, hintCount, guesses, hints, trys;
//Instantiate stats array
int stats[5] = {0};
// Determine width of Matrix
width = getWidth(argc, argv);
// Generate matrix based on width
complex** M = generateMatrix(width);
// Create randmom number generator.
srand((unsigned)time(NULL));
// Create string array for user input.
char choice[20];
// Create array of type complex to store generated row column pairs
complex uniques[width * width];
// Continue game until user quits.
while(strncmp(choice, "Q", 1) != 0){
// Generate random row column pairs for ser to guess.
i = rand() % width;
j = rand() % width;
// Reset counting variable for each generated row column pair.
correct = hints = guesses = 0;
while(correct == 0 && strncmp(choice, "Q", 1) != 0){
// Count number of hints used for this specific pair.
hintCount = 0;
// Display message to user displaying options.
printf("M[0][0]=%p. M[i][j]=%p What's i and j?\n(Q to Quit or H or
HH or HHH for hints.): ", &M[0][0], &M[i][j]);
// Recieve and store user input.
fgets(choice, 20, stdin);
// Check if user requested hints
hintCount += checkHints(choice, M, width);
// If user did not want hints check is valid answer submitted
if (hintCount == 0){
// Check answer
correct = checkAnswer(choice, i, j);
}
// Accumulate hints used.
hints += hintCount;
// Accumulate guesses used.
guesses++;
}
// If user has not quit calculate stats for pair.
if (strncmp(choice, "Q", 1) != 0){
setUnique(uniques, i, j, stats);
setStats(stats,hints, guesses);
}
}
// Print stats of the game after user has quit.
printStats(stats);
// terminate matrix.
killMatrix(M, width);
}
int main(int argc, char *argv[])
{
int rank, size;
double start_time,end_time;
MPI_Init(&argc,&argv);
MPI_Comm_size(MPI_COMM_WORLD, &size); // p
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Barrier(MPI_COMM_WORLD);
int retval = generateMatrix(size, rank);
if (retval != 0) {
MPI_Finalize();
return retval;
}
MPI_Barrier(MPI_COMM_WORLD);
// start timing
if (MASTER(rank)) {
start_time = MPI_Wtime();
}
double spectralRadius = powerMethod(rank);
if (MASTER(rank)) {
end_time = MPI_Wtime();
}
// end timing
if (MASTER(rank)) {
printf("The spectral radius is %f\n", spectralRadius);
printf("It took %f seconds\n", end_time-start_time);
/*
int index = 0;
for (index = 0; index < n; index++) {
printf("%f ", x[index]);
}
printf("\nsize of n is %d\n", n);
*/
// checking
if(cs240_verify(x,n,end_time-start_time)>0){
printf("yay, we win!\n");
}else{
printf("Boo, we lose... again\n");
}
}
//printf("calling MPI_Finalize()\n");
MPI_Finalize();
return(0);
}
matrix operator*(matrix left, matrix right) {
assert(left.size() > 0);
assert(right.size() > 0);
assert(left[0].size() == right.size());
matrix result = generateMatrix(left.size(), right[0].size(), 0);
for (int i = 0; i < left.size(); ++i) {
for (int j = 0; j < right[0].size(); ++j) {
for (int k = 0; k < left[0].size(); ++k) {
result[i][j] += left[i][k] * right[k][j];
}
}
}
return result;
}
int main(int arg, char *argv[]) {
// insert code here...
printf("LeetCode 059 Spiral Matrix II, C ...\n\n");
int n = 3;
int **m = generateMatrix(n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
printf("%d ", m[i][j]);
}
printf("\n");
}
return 0;
}
int main() {
int n = 3;
int i, j;
int**matrix = NULL;
matrix = generateMatrix(n);
for(i = 0; i<=n-1; i++) {
for(j = 0; j<=n-1; j++){
printf("%d ", matrix[i][j]);
}
printf("\n");
}
return 0;
}
int _tmain(int argc, _TCHAR* argv[])
{
int** matrix = generateMatrix(rows, cols);
printOutMatrix(matrix, rows, cols);
std::vector<int> tmpPath;
dfsMinSumPath(matrix, 0, tmpPath, 0);
std::cout << "The min path sum is: " << minPathSum << std::endl;
std::cout << "The min sum path is: ";
for (int i = 0; i < minSumPath.size(); ++i)
std:: cout << minSumPath[i] << ", ";
std::cout << std::endl << "Total func calls: " << totalFuncCalls << std::endl;
std::cout << std::endl;
return 0;
}
void testMatrixTranspose(void)
{
int **matrixA;
int **matrixAT;
int rowNumOfA, colNumOfA;
int rowNumOfAT, colNumOfAT;
rowNumOfA = 2;
colNumOfA = 3;
matrixA = generateMatrix(rowNumOfA, colNumOfA);
rowNumOfAT = colNumOfA;
colNumOfAT = rowNumOfA;
matrixAT = make2DArray(rowNumOfAT, colNumOfAT);
printf("----------- test: matrix transpose ------------------\n");
matrixTranspose(matrixAT, matrixA, rowNumOfA, colNumOfA);
printf("matrixA\n");
printMatrix(matrixA, rowNumOfA, colNumOfA);
printf("matrixAT\n");
printMatrix(matrixAT, rowNumOfAT, colNumOfAT);
}
int main() {
print(generateMatrix(4),4);
}
int main( int argc, char **argv ) {
MPI_Init( &argc, &argv );
int rank, P;
MPI_Comm_rank( MPI_COMM_WORLD, &rank );
MPI_Comm_size( MPI_COMM_WORLD, &P );
int s = read_int( argc, argv, "-s", 5 );
int d = read_int( argc, argv, "-d", 1 );
int ds = read_int( argc, argv, "-ds", 0 );
int_d n = ((int_d) 1) << s;
int_d colsPerProc = n/P;
n = colsPerProc * P;
double density = 1.*d/n/(1 << ds);
if( rank == 0 )
printf("Using n=%ld, d=%d on P=%d processors\n", n, d, P );
int sqrtP = (int) sqrt(1.*P);
if( sqrtP*sqrtP != P ) {
if( rank == 0 )
printf("Requires a square processor grid\n");
MPI_Finalize();
exit(-1);
}
// construct row and column communicators
MPI_Group initialGroup;
MPI_Comm_group( MPI_COMM_WORLD, &initialGroup );
MPI_Comm rowComm;
MPI_Comm colComm;
MPI_Group gp;
MPI_Comm cm;
for( int i = 0; i < sqrtP; i++ ) {
int rranks[sqrtP];
int cranks[sqrtP];
bool rc = false, cc = false;
for( int j = 0; j < sqrtP; j++ ) {
rranks[j] = sqrtP*i+j;
cranks[j] = sqrtP*j+i;
if( rranks[j] == rank )
rc = true;
if( cranks[j] == rank )
cc = true;
}
MPI_Group_incl( initialGroup, sqrtP, rranks, &gp );
MPI_Comm_create( MPI_COMM_WORLD, gp, &cm );
if( rc )
rowComm = cm;
MPI_Group_free( &gp );
MPI_Group_incl( initialGroup, sqrtP, cranks, &gp );
MPI_Comm_create( MPI_COMM_WORLD, gp, &cm );
if( cc )
colComm = cm;
MPI_Group_free( &gp );
}
MPI_Group_free( &initialGroup );
int rrank, crank;
MPI_Comm_rank( rowComm, &rrank );
MPI_Comm_rank( colComm, &crank );
int_d bs = n/sqrtP;
BlockIndexColMajor ai = BlockIndexColMajor(crank*bs, rrank*bs, bs, bs );
BlockIndexRowMajor bi = BlockIndexRowMajor(crank*bs, rrank*bs, bs, bs );
//printf("%d Generating matrices\n", rank);
Matrix *A = generateMatrix( &ai, density, time(0)+100*rank );
Matrix *B = generateMatrix( &bi, density, time(0)+100*rank+1 );
//Matrix *A = generateMatrix( &ai, density, 2*rank+39 );
//Matrix *B = generateMatrix( &bi, density, 2*rank+1+39 );
/*
printf("A %d: ", rank);
for( auto it = A->begin(); it != A->end(); it++ )
printf("(%d %d) ", it->first.first, it->first.second);
printf("\n");
printf("B %d: ", rank);
for( auto it = B->begin(); it != B->end(); it++ )
printf("(%d %d) ", it->first.first, it->first.second);
printf("\n");
*/
//printf("%d collecting input\n", rank );
Matrix *fullA = gather(A, rank, P );
Matrix *fullB = gather(B, rank, P );
//printf("%d dist multiply\n", rank );
Matrix *C = spSUMMA( A, B, n, sqrtP, rowComm, rrank, colComm, crank );
/*
printf("C %d: ", rank);
for( auto it = C->begin(); it != C->end(); it++ )
printf("(%d %d) ", it->first.first, it->first.second);
printf("\n");
*/
//printf("%d collecting output\n", rank );
Matrix *fullC = gather(C, rank, P );
/*
printf("fC %d: ", rank);
for( auto it = fullC->begin(); it != fullC->end(); it++ )
printf("(%d %d) ", it->first.first, it->first.second);
printf("\n");
*/
//printf("%d checking answer\n", rank );
if( rank == 0 ) {
double maxError = 0.;
std::sort( fullA->begin(), fullA->end(), CompColMajorEntry );
std::sort( fullB->begin(), fullB->end(), CompRowMajorEntry );
Matrix *testC = sortDedup( local_multiply( fullA, fullB ), CompColMajorEntry );
printf("sizes %lu vs %lu\n", testC->size(), fullC->size());
std::sort( fullC->begin(), fullC->end(), CompColMajorEntry );
for( auto it1 = testC->begin(), it2 = fullC->begin();
it1 != testC->end() && it2 != fullC->end();
it1++, it2++ ) {
if( it1->first.first != it2->first.first ||
it1->first.second != it2->first.second )
printf("Error: %ld %ld vs %ld %ld\n", it1->first.first, it1->first.second, it2->first.first, it2->first.second );
else {
if( it2->second-it1->second > maxError )
maxError = it2->second-it1->second;
if( it1->second-it2->second > maxError )
maxError = it1->second-it2->second;
}
}
printf("max error %e\n", maxError );
}
MPI_Finalize();
}
int main(int argc, char* argv[])
{
int x;
printf("\n\nWähle einen Modus:\n1 = neue Matrix soll generiert werden\n2 = zwei Matrixen sollen addiert werden\n3 = zwei Matrixen sollen multipliziert werden\n");
scanf("%d",&x);
if(x == 1)
{
int n, m;
char fileName[100];
printf("\n\n Wie groß soll die generierte Matrix sein?\n Gebe eine Zeilenanzal (n) ein:\n");
scanf("%d",&n);
printf("\nGebe eine Spaltenanzal (m) ein:\n");
scanf("%d",&m);
printf("\nGebe ein Dateiname ein, in die die Matrix gespeichert werden soll:\n");
scanf("%s",fileName);
struct matrix *newMatrix = allocMatrix(n, m);
generateMatrix(newMatrix, 100);
printf("\n\n Generierte Matrix:\n");
printMatrix(newMatrix);
writeFile(newMatrix, fileName);
freeMatrix(newMatrix);
}
else if(x == 2 || x == 3)
{
char fileName1[100];
char fileName2[100];
char fileName3[100];
printf("\n\nGebe ein Dateiname ein, für die erste Matrix der Berechnung:\n");
scanf("%s",fileName1);
printf("\n\nGebe ein Dateiname ein, für die zweite Matrix der Berechnung:\n");
scanf("%s",fileName2);
printf("\n\nGebe ein Dateiname ein, in der die Ergebnismatrix gespeichert werden soll:\n");
scanf("%s",fileName3);
struct matrix *matrixA = einlesen(fileName1);
struct matrix *matrixB = einlesen(fileName2);
struct matrix *matrixResult;
if(x == 2)
{
matrixResult = add(matrixA, matrixB);
}
else
{
matrixResult = mult(matrixA, matrixB);
}
writeFile(matrixResult, fileName3);
freeMatrix(matrixA);
freeMatrix(matrixB);
freeMatrix(matrixResult);
}
else
{
printf("falscher Modus\n");
}
return 0;
}
matrix generateMatrix(int size, int filler) {
return generateMatrix(size, size, filler);
}
int main() {
int n = 4;
int **ans = generateMatrix(n);
printMatrix(ans, n, n);
return 0;
}
DWORD WINAPI computationThread_PC( LPVOID lpParam ){
// Buffer declarations
long i ;
{
init_ProdMatVect_0_prodScalVect_init_accIn(vectorOut_accIn);
}
for(;;){
vectorOut_accIn_2 = &vectorOut_accIn[0];
generateMatrix(outMat_in, 9/*size*/);
generateVect(outVect_in, 3/*size*/);
{//ProdMatVect_0_explode_vectorIn
out_ScalIn = &outVect_in[0];
out_ScalIn_1 = &outVect_in[3];
out_ScalIn_0 = &outVect_in[2];
}
{//ProdMatVect_0_explode_matrixIn
out_vector1In = &outMat_in[0];
out_vector1In_0 = &outMat_in[9];
out_vector1In_1 = &outMat_in[6];
}
{//ProdMatVect_0_prodScalVect
init_inLoopPort_0(outLoopPort_0_inLo_0, 1/*init_size*/);
for(i = 0; i<3 ; i ++)
{//cluster_0
char *inSub_i_cluster_0__0 = &cluster_0_in_in [((i*(1))%3)];
int *outSub_i_out_vecto_0 = &out_vector1In [((i*(1))%0)];
char *outSub_i_vectorOut_0 = &vectorOut_accIn [((i*(1))%3)];
int *outSub_i_out_ScalIn = &out_ScalIn [((i*(1))%0)];
mux();
{//productScal
{//brScal
memcpy(outLoopPort_0_inLo_0, out_scal2, 1*sizeof(char)/*size*/);
}
mult(outSub_i_out_vecto_0, res_op1);
add(res_op1, outSub_i_vectorOut_0, inSub_i_cluster_0__0);
}
}
for(i = 0; i<3 ; i ++)
{//brScal
char *inSub_i_vectorOut__0 = &vectorOut_accIn_0 [((i*(1))%3)];
char *inSub_i_vectorFina_0 = &vectorFinal_in [((i*(1))%3)];
char *outSub_i_cluster_0_0 = &cluster_0_in_in [((i*(1))%3)];
brScal();
}
}
{//ProdMatVect_0_prodScalVect_1
init_inLoopPort_0(outLoopPort_0_inLo_0, 1/*init_size*/);
for(i = 0; i<3 ; i ++)
{//cluster_0
char *inSub_i_cluster_0__0 = &cluster_0_in_in [((i*(1))%3)];
int *outSub_i_out_vecto_0 = &out_vector1In_0 [((i*(1))%0)];
char *outSub_i_vectorOut_0 = &vectorOut_accIn_0 [((i*(1))%3)];
int *outSub_i_out_ScalI_0 = &out_ScalIn_1 [((i*(1))%0)];
mux();
{//productScal
{//brScal
memcpy(outLoopPort_0_inLo_0, out_scal2, 1*sizeof(char)/*size*/);
}
mult(outSub_i_out_vecto_0, res_op1);
add(res_op1, outSub_i_vectorOut_0, inSub_i_cluster_0__0);
}
}
for(i = 0; i<3 ; i ++)
{//brScal
char *inSub_i_vectorOut__0 = &vectorOut_accIn_1 [((i*(1))%3)];
char *inSub_i_vectorFina_0 = &vectorFinal_in_0 [((i*(1))%9)];
char *outSub_i_cluster_0_0 = &cluster_0_in_in [((i*(1))%3)];
brScal();
}
}
{//ProdMatVect_0_prodScalVect_2
init_inLoopPort_0(outLoopPort_0_inLo_0, 1/*init_size*/);
for(i = 0; i<3 ; i ++)
{//cluster_0
char *inSub_i_cluster_0__0 = &cluster_0_in_in [((i*(1))%3)];
int *outSub_i_out_vecto_0 = &out_vector1In_1 [((i*(1))%0)];
char *outSub_i_vectorOut_0 = &vectorOut_accIn_1 [((i*(1))%3)];
int *outSub_i_out_ScalI_0 = &out_ScalIn_0 [((i*(1))%0)];
mux();
{//productScal
{//brScal
memcpy(outLoopPort_0_inLo_0, out_scal2, 1*sizeof(char)/*size*/);
}
mult(outSub_i_out_vecto_0, res_op1);
add(res_op1, outSub_i_vectorOut_0, inSub_i_cluster_0__0);
}
}
for(i = 0; i<3 ; i ++)
{//brScal
char *inSub_i_vectorOut__0 = &vectorOut_accIn_2 [((i*(1))%0)];
char *inSub_i_vectorFina_0 = &vectorFinal_in_1 [((i*(1))%3)];
char *outSub_i_cluster_0_0 = &cluster_0_in_in [((i*(1))%3)];
brScal();
}
}
{//ProdMatVect_0_roundBuffer_vectorOut
memcpy(out_inResult, vectorFinal_in_1, 3*sizeof(char)/*size*/);
}
display(out_inResult, 3/*size*/);
}
return 0;
}//computationThread
/**
* Sample arguments
*
* To transpose a randomly generated 64x32 matrix using basic algorithm
* (both input and output displayed on screen)
* ./transposeOP -basic -m 64 -n 32
*
*
*/
int main(int argc, char *argv[])
{
int *a, *b;
const char *usage = "Usage: basictransposeOP [[-i <infile>] -m <row> -n <column>] [-o <outfile>] [-noIO] [-noinit]\n";
char *infile=NULL, *outfile=NULL;
int row=0, column=0, tile1size=0, tile2size=0;
int i, noio=0, noinit=0;;
if (argc <=1 ) {
printf("%s", usage);
exit(0);
}
// printf("%d\n", argc);
for (i=1; i<argc; i++) {
// printf("%s", argv[i]);
if (!strcmp("-i", argv[i])) {
infile = argv[++i];
} else if (!strcmp("-o", argv[i])) {
outfile = argv[++i];
} else if (!strcmp("-m", argv[i])) {
sscanf(argv[++i], "%d", &row);
} else if (!strcmp("-n", argv[i])) {
sscanf(argv[++i], "%d", &column);
} else if (!strcmp("-noIO", argv[i]) || !strcmp("-noio", argv[i])) {
noio=1;
} else if (!strcmp("-noinit", argv[i])) {
noinit=1;
}
}
if (infile == NULL) {
// no input file provided
if (row==0) {
row=ROW;
}
if (column==0) {
column=COLUMN;
}
a = generateMatrix(row, column, noinit);
} else {
if (row<=0 || column<=0) {
printf("Please provide a valid dimension of the input matrix.\n");
printf("%s", usage);
exit(0);
}
a = loadMatrix(infile, row, column);
}
b = allocateMatrix(column, row);
if (!noio) {
printf("\nBefore Transpose: \n");
printm(a, row, column);
}
printf("Starting transpose...\n");
transpose(a, b, row, column, row, column);
printf("Transpose complete.\n");
if (!noio) {
printf("\nAfter Transpose: \n");
if (outfile==NULL) {
printm(b, column, row);
} else {
printmf(b, column, row, outfile);
}
}
free(a);
free(b);
return 1;
}
