int is_magic_square(Matrix *A) {
assert((A->rows > 1) && (A->cols > 1));
assert(A->cols == A->rows);
int res = 1;
double *row_vals = row_sum(A);
double *col_vals = col_sum(A);
double comp_val = row_vals[0];
int i;
for (i = 0; i < A->rows; i++) {
if (comp_val != row_vals[i]) res = 0;
}
for (i = 0; i < A->cols; i++) {
if (comp_val != col_vals[i]) res = 0;
}
double sum1 = 0;
double sum2 = 0;
int j;
for (i = 0; i < A->rows; i++) {
j = (A->rows-1) - i;
sum1 += A->data[i][i];
sum2 += A->data[j][i];
}
if ((sum1 != comp_val) || (sum2 != comp_val)) res = 0;
return res;
}
int is_magic_square(Matrix *A){
//Case that rows and columns not the same
//Not a Square grid, so cannot be square
if (A->rows != A->cols){
printf("Not a square matrix\n");
return 0;
}
//Getting sum of rows
double *allRowSum = row_sum(A);
//Get sum of columns
double *allColSum = col_sum(A);
//Get sum of diagnols
double *allDiag = diag_sum(A);
//Get total of first row - all others should be the same either way
double magic = allRowSum[0];
if (test_rows(allRowSum, A->rows, magic)){
if (test_cols(allColSum, A->cols, magic)){
if (test_diag(allDiag, magic)){
//If rows, cols, and diags are the same
//We have a magic square!
return 1;
}
}
}
return 0;
}
// Returns 1 if is_magic_square is a magic square, otherwise returns 0
int is_magic_square(Matrix *A) {
assert(A->rows == A->cols);
int i;
int n = A->rows;
double check;
double diag_a = 0.0;
double diag_b = 0.0;
double *res = row_sum(A);
// col_res contains the sums of the columns
double *col_res = col_sum(A);
check = res[0];
// loop and if statements to return 0 if all rows, columns, and
// diagonals do not add to the same value
for (i=0; i<n; i++) {
diag_a += A->data[i][i];
diag_b += A->data[i][(n-1)-i];
if ((res[i] != check) || (col_res[i] != check))
return 0;
}
if ((diag_a != check) || (diag_b != check))
return 0;
return 1;
}
//-----------------------------------------------------------------------------
// TestMatrixRowSum
//-----------------------------------------------------------------------------
bool TestMatrixRowSum()
{
Matrix A("1,2,3;4,5,6;7,8,9");
Matrix x;
RowSum( A, x );
Matrix row_sum("6;15;24");
return ApproxEqual(x,row_sum,TOLERANCE);
}
int main() {
int i;
Matrix *A = make_matrix(3, 4);
consecutive_matrix(A);
printf("A\n");
print_matrix(A);
Matrix *C = add_matrix_func(A, A);
printf("A + A\n");
print_matrix(C);
Matrix *B = make_matrix(4, 3);
increment_matrix(B, 1);
printf("B\n");
print_matrix(B);
Matrix *D = mult_matrix_func(A, B);
printf("D\n");
print_matrix(D);
double sum = matrix_sum1(A);
printf("sum = %lf\n", sum);
sum = matrix_sum2(A);
printf("sum = %lf\n", sum);
printf("A\n");
print_matrix(A);
double *sums = row_sum(A);
for (i=0; i<A->rows; i++) {
printf("row %d\t%lf\n", i, sums[i]);
}
// should print 6, 22, 38
double *sums2 = col_sum(A);
for (i=0; i<A->cols; i++) {
printf("col %d\t%lf\n", i, sums2[i]);
}
Matrix *E = make_matrix(3, 3);
E->data[0][0] = 2; E->data[0][1] = 7; E->data[0][2] = 6;
E->data[1][0] = 9; E->data[1][1] = 5; E->data[1][2] = 1;
E->data[2][0] = 4; E->data[2][1] = 3; E->data[2][2] = 8;
printf("E\n");
print_matrix(E);
printf("Magic matrix?: %d \n", is_magic_square(E));
return 0;
}
int main() {
int i;
Matrix *A = make_matrix(3, 4);
consecutive_matrix(A);
printf("A\n");
print_matrix(A);
Matrix *C = add_matrix_func(A, A);
printf("A + A\n");
print_matrix(C);
Matrix *B = make_matrix(4, 3);
increment_matrix(B, 1);
printf("B\n");
print_matrix(B);
Matrix *D = mult_matrix_func(A, B);
printf("D\n");
print_matrix(D);
double sum = matrix_sum1(A);
printf("sum(A) = %lf\n", sum);
sum = matrix_sum2(A);
printf("sum2(A) = %lf\n", sum);
double *sums = row_sum(A);
for (i=0; i<A->rows; i++) {
printf("row %d\t%lf\n", i, sums[i]);
}
// should print 6, 22, 38
Matrix *E = make_matrix(3,3);
increment_matrix(E, 1);
printf("\nE ");
if (is_magic_square(E)) {
printf("is magic! Whizzam!\n");
} else {
printf("isn't magic...\n");
}
print_matrix(E);
return 0;
}
int main() {
int i;
Matrix *A = make_matrix(3, 4);
consecutive_matrix(A);
printf("A\n");
print_matrix(A);
Matrix *C = add_matrix_func(A, A);
printf("A + A\n");
print_matrix(C);
Matrix *B = make_matrix(4, 3);
increment_matrix(B, 1);
printf("B\n");
print_matrix(B);
Matrix *D = mult_matrix_func(A, B);
printf("D\n");
print_matrix(D);
double sum = matrix_sum1(A);
printf("sum = %lf\n", sum);
sum = matrix_sum2(A);
printf("sum = %lf\n", sum);
double *sums = row_sum(A);
for (i=0; i<A->rows; i++) {
printf("row %d\t%lf\n", i, sums[i]);
}
// should print 6, 22, 38
//Test matrix
Matrix *E = make_matrix(3, 3);
increment_matrix(E, 1);
int magic1 = is_magic_square(A); //Not Magic
int magic2 = is_magic_square(B); //Not Magic
int magic3 = is_magic_square(E); //Magic
printf("Magic Matrix result: %d , %d , %d \n", magic1, magic2, magic3);
return 0;
}
/*
http://en.wikipedia.org/wiki/Magic_square
A magic square is an arrangement of numbers (usually integers) in a
square grid, where the numbers in each row, and in each column, and
the numbers in the forward and backward main diagonals, all add up
to the same number.
Write a function called is_magic_square() that takes a matrix and
returns an int, 1 if the matrix is a magic square, and 0 otherwise.
Feel free to use row_sum().
*/
int is_magic_square(Matrix *M) {
// adding rows should be fastest due to caching, check that first
double *row_sums = row_sum(M);
double magnum = row_sums[0];
if (!is_uniform_vector(row_sums,M->rows,magnum)) {
return 0;
}
free(row_sums); // tidy tidy
// adding columns is slower, since it's more likely for the data to be
// spatially distant
double *col_sums = col_sum(M);
if (!is_uniform_vector(col_sums,M->cols,magnum)) {
return 0;
}
free(col_sums);
double *diag_sums = diag_sum(M);
return (diag_sums[0] == magnum) && (diag_sums[1] == magnum);
}
