Question: #include #include #include #define MIN _ DIM _ POWER 3 #define MAX _ DIM _ POWER 1 0 #define FALSE 0 #define TRUE 1 void

#include
#include
#include
#define MIN_DIM_POWER 3
#define MAX_DIM_POWER 10
#define FALSE 0
#define TRUE 1
void init(const int dim, int * const m){
for (int i =0; i < dim * dim; ++i){
m[i]= rand()%20;
}
}
void print(const int dim, const int * const m){
for (int i =0; i < dim; ++i){
for (int j =0; j < dim; ++j){
printf("%d\t", m[i * dim + j]);
}
printf("
");
}
printf("
");
}
void multiply(const int dim, const int * const a, int * const b, int * const c){
for (int i =0; i < dim; ++i){
for (int j =0; j < dim; ++j){
int sum =0;
for (int k =0; k < dim; ++k){
sum += a[i * dim + k]* b[k * dim + j];
}
c[i * dim + j]= sum;
}
}
}
void transpose(const int dim, int * const m){
for (int i =0; i < dim; ++i){
for (int j =0; j < i; ++j){
int tmp = m[i * dim + j];
m[i * dim + j]= m[j * dim + i];
m[j * dim + i]= tmp;
}
}
}
void multiply_transpose(const int dim, const int * const a, const int * const b_t, int * const c){
for (int i =0; i < dim; ++i){
for (int j =0; j < dim; ++j){
int sum =0;
for (int k =0; k < dim; ++k){
sum += a[i * dim + k]* b_t[j * dim + k];
}
c[i * dim + j]= sum;
}
}
}
void transpose_and_multiply(const int dim, const int * const a, int * const b, int * const c){
transpose(dim, b);
multiply_transpose(dim, a, b, c);
}
int verify(const int dim, const int * const c1, const int * const c2){
for (int i =0; i < dim * dim; ++i){
if (c1[i]!= c2[i]){
return FALSE;
}
}
return TRUE;
}
struct timeval run_and_time(
void (*mult_func)(const int, const int * const, int * const, int * const),
const int dim,
const int * const a,
int * const b,
int * const c
){
struct timeval start, end;
gettimeofday(&start, NULL);
mult_func(dim, a, b, c);
gettimeofday(&end, NULL);
if (end.tv_usec < start.tv_usec){
end.tv_sec--;
end.tv_usec +=1000000;
}
end.tv_sec -= start.tv_sec;
end.tv_usec -= start.tv_usec;
return end;
}
void run_test(const int dim){
int *a = calloc(dim * dim, sizeof(int));
int *b = calloc(dim * dim, sizeof(int));
int *c1= calloc(dim * dim, sizeof(int));
int *c2= calloc(dim * dim, sizeof(int));
init(dim, a);
init(dim, b);
printf("Matrix A:
");
print(dim, a);
printf("Matrix B:
");
print(dim, b);
printf("Running standard multiplication...
");
struct timeval standard_time = run_and_time(&multiply, dim, a, b, c1);
printf("Standard multiplication: %ld seconds, %d microseconds
", standard_time.tv_sec, standard_time.tv_usec);
printf("Running multiplication with transpose...
");
struct timeval transpose_time = run_and_time(&transpose_and_multiply, dim, a, b, c2);
printf("Multiplication with transpose: %ld seconds, %d microseconds
", transpose_time.tv_sec, transpose_time.tv_usec);
printf("Results agree. %s
", verify(dim, c1, c2)? "Standard multiplication" : "Multiplication with transpose");
free(a);
free(b);
free(c1);
free(c2);
}
int main(){
for (int power = MIN_DIM_POWER; power <= MAX_DIM_POWER; ++power){
int dim =1<< power;
printf("Running test for dimension: %d
", dim);
run_test(dim);
}
return EXIT_SUCCESS;
} edit this c code that represents matrix multiplication to have this sample run ./pa5.c
Results agree.
Standard multiplication: 0 seconds, 4 microseconds
Multiplication with transpose: 0 seconds, 4 microseconds
Results agree.
Standard multiplication: 0 seconds, 39 microseconds
Multiplication with transpose: 0 seconds, 24 microseconds

Step by Step Solution

There are 3 Steps involved in it

1 Expert Approved Answer
Step: 1 Unlock blur-text-image
Question Has Been Solved by an Expert!

Get step-by-step solutions from verified subject matter experts

Step: 2 Unlock
Step: 3 Unlock

Students Have Also Explored These Related Accounting Questions!