int main(int argc, char* argv[]) {
if (argc != 2)
fprintf(stderr, "Usage: Requires number of threads.");
thread_count = atoi(argv[1]);
Lab3LoadInput(&A, &size);
x = CreateVec(size);
double start, end;
int i = 0;
GET_TIME(start);
# pragma omp parallel num_threads(thread_count) \
shared(A)
{
gaussian_elimination();
jordan_elimination();
# pragma omp for
for (i = 0; i < size; ++i) {
x[i] = A[i][size] / A[i][i];
}
}
GET_TIME(end);
Lab3SaveOutput(x, size, end-start);
printf("time is: %e\n", end-start);
DestroyVec(x);
DestroyMat(A, size);
return EXIT_SUCCESS;
}
int main(int argc, char * argv[]){
int threads = parse_number_threads(argc, argv);
double **A; int size;
Lab3LoadInput(&A, &size);
double storage[size];
// Initialize Times
double start_time;
double end_time;
GET_TIME(start_time);
int k;
for (k = 0; k < size; k++){
int max_indice = find_max_indice(k, A, size);
swap_rows(A, k, max_indice);
int i;
int j;
//printf("Current k value: %d \n",k);
//printf("----------------------------\n");
for (i = k+1; i < size; i++){
//printf("Current Row: %d \n",i);
double subtrahend_coefficient = (A[i][k]/A[k][k]);
//printf("Subtrahend Coefficient: %f \n",subtrahend_coefficient);
for (j = k; j < size + 1; j++){
//printf("Current Col: %d \n",j);
A[i][j] = A[i][j] - (subtrahend_coefficient* A[k][j]);
}
}
}
//Lab2_saveoutput(A, size, 10, "Gauss.txt");
for (k = size-1; k > 0; k--){
int i;
for (i = 0; i < k; i++){
//double result = A[i][size] - ( (A[i][k] / A[k][k]) * A[k][size]);;
//printf("A[%d][%d] = %f \n", i, size, result);
A[i][size] = A[i][size] - ( (A[i][k] / A[k][k]) * A[k][size]);
A[i][k] = A[i][k] - ( (A[i][k] / A[k][k]) * A[k][k]);
}
}
//Lab2_saveoutput(A, size, 10, "Jordan.txt");
// Retrieve elapsed time
GET_TIME(end_time);
get_result(storage, A, size);
printf("Total Time: %f \n",end_time-start_time);
Lab3SaveOutput(storage, size, end_time - start_time);
return 0;
}
matrix_t read_matrix_input() {
matrix_t input;
Lab3LoadInput(&input.matrix, &input.size);
return input;
}
int main(int argc, char* argv[])
{
int i, j, k, size;
double** Au;
double* X;
double temp, error, Xnorm;
int* index;
FILE* fp;
/*Load the datasize and verify it*/
Lab3LoadInput(&Au, &size);
if ((fp = fopen("data_output","r")) == NULL){
printf("Fail to open the result data file!\n");
return 2;
}
fscanf(fp, "%d\n\n", &i);
if (i != size){
printf("The problem size of the input file and result file does not match!\n");
return -1;
}
/*Calculate the solution by serial code*/
X = CreateVec(size);
index = malloc(size * sizeof(int));
for (i = 0; i < size; ++i)
index[i] = i;
if (size == 1)
X[0] = Au[0][1] / Au[0][0];
else{
/*Gaussian elimination*/
for (k = 0; k < size - 1; ++k){
/*Pivoting*/
temp = 0;
for (i = k, j = 0; i < size; ++i)
if (temp < Au[index[i]][k] * Au[index[i]][k]){
temp = Au[index[i]][k] * Au[index[i]][k];
j = i;
}
if (j != k)/*swap*/{
i = index[j];
index[j] = index[k];
index[k] = i;
}
/*calculating*/
for (i = k + 1; i < size; ++i){
temp = Au[index[i]][k] / Au[index[k]][k];
for (j = k; j < size + 1; ++j)
Au[index[i]][j] -= Au[index[k]][j] * temp;
}
}
/*Jordan elimination*/
for (k = size - 1; k > 0; --k){
for (i = k - 1; i >= 0; --i ){
temp = Au[index[i]][k] / Au[index[k]][k];
Au[index[i]][k] -= temp * Au[index[k]][k];
Au[index[i]][size] -= temp * Au[index[k]][size];
}
}
/*solution*/
for (k=0; k< size; ++k)
X[k] = Au[index[k]][size] / Au[index[k]][k];
}
/*compare the solution*/
error = 0;
Xnorm = 0;
for (i = 0; i < size; ++i){
fscanf(fp, "%lf\t", &temp);
error += (temp-X[i]) * (temp-X[i]);
Xnorm += X[i]*X[i];
}
error = sqrt(error);
Xnorm = sqrt(Xnorm);
printf("The relative error to the reference solution is %e\n", error / Xnorm);
if (error / Xnorm <= TOL)
printf("Congratulation!!! Your result is accepted!\n");
else
printf("Sorry, your result is wrong.\n");
fclose(fp);
DestroyVec(X);
DestroyMat(Au, size);
free(index);
return 0;
}
