C - Split matrix in equipartitions
I am writing an algorithm for dividing a matrix into 4 sub-matrices (equipartitions). The size of the entire matrix is always multiplied by 4 as shown in the added image. If you are looking, I am trying to access items like 1D instead of 2D. I cannot understand the error in the calculation part.
#include <stdio.h>
/* Soner Akar - Algoritmayı alırsanız lütfen benden aldığınızı belirtin. */
enum { /*BLKSZ = 4*/ NBLOCKS = 4, SIZE = 16, BLKSZ = SIZE / NBLOCKS } ;
void get_slice( int arr[400], int slice[100], int sliceSize, int i, int j );
void get_slice( int arr[400], int slice[100], int sliceSize, int i, int j )
{
int k = 0;
int l = 0;
for( k = 0 ; k < sliceSize / 2 ; ++k ) { // calculation part
for (l = 0; l < sliceSize / 2; ++l) {
slice[l + k * sliceSize / 2] = arr[(l + j) + (k + i) * (sliceSize / 2)];
printf("slice[%d][%d] -> %d ", k, l, slice[l + k * (sliceSize / 2)]);
}
printf("\n");
}
printf("\n");
}
int main() {
int matrix[SIZE] ;
int block[BLKSZ];
int j = 0;
int i = 0;
for (j = 0; j < SIZE; ++j) {
matrix[j] = 1 + j;
}
for (i = 0; i < BLKSZ; ++i) {
for (j = 0; j < BLKSZ; ++j) {
printf("matrix[%d][%d] -> %d ", i, j, matrix[j + i * BLKSZ]);
}
printf("\n");
}
printf("\n");
printf("\n");
for( int i = 0 ; i < NBLOCKS ; ++i ) // get all blocks (invariant: NBLOCKS == 4)
get_slice( matrix, block, SIZE / NBLOCKS ,BLKSZ*i/2, BLKSZ*i%2 ) ;
return 0;
}
Output:
matrix[0][0] -> 1 matrix[0][1] -> 2 matrix[0][2] -> 3 matrix[0][3] -> 4
matrix[1][0] -> 5 matrix[1][1] -> 6 matrix[1][2] -> 7 matrix[1][3] -> 8
matrix[2][0] -> 9 matrix[2][1] -> 10 matrix[2][2] -> 11 matrix[2][3] -> 12
matrix[3][0] -> 13 matrix[3][1] -> 14 matrix[3][2] -> 15 matrix[3][3] -> 16
slice[0][0] -> 1 slice[0][1] -> 2
slice[1][0] -> 3 slice[1][1] -> 4
slice[0][0] -> 5 slice[0][1] -> 6
slice[1][0] -> 7 slice[1][1] -> 8
slice[0][0] -> 9 slice[0][1] -> 10
slice[1][0] -> 11 slice[1][1] -> 12
slice[0][0] -> 13 slice[0][1] -> 14
slice[1][0] -> 15 slice[1][1] -> 16
Process finished with exit code 0
Expected Result:
slice[0][0] -> 1 slice[0][1] -> 2
slice[1][0] -> 5 slice[1][1] -> 6
slice[0][0] -> 3 slice[0][1] -> 4
slice[1][0] -> 7 slice[1][1] -> 8
slice[0][0] -> 9 slice[0][1] -> 10
slice[1][0] -> 13 slice[1][1] -> 14
slice[0][0] -> 11 slice[0][1] -> 12
slice[1][0] -> 15 slice[1][1] -> 16
+3
source to share
1 answer
You have to define two variables for the get_slice function because of the arr column size and the slice column size. And you can define a print function for the slice to customize the readability.
#include <stdio.h>
#include <math.h>
/* Soner Akar - Algoritmayı alırsanız lütfen benden aldığınızı belirtin. */
enum { /*BLKSZ = 4*/ NBLOCKS = 4, SIZE = 64 } ;
void get_slice( int arr[400], int slice[100], int arrSize, int sliceSize, int i, int j )
{
int k = 0;
int l = 0;
int spliceColumnSize = sqrt(sliceSize);
int arrayColumnSize = sqrt(arrSize);
for( k = 0 ; k < spliceColumnSize ; ++k ) { // calculation part
for (l = 0; l < spliceColumnSize; ++l) {
slice[l + (k * (spliceColumnSize))] = arr[(i+k)*arrayColumnSize+j+l];
}
}
}
void printSlice(int arr[], int sliceSize)
{
int size = sqrt(sliceSize);
for(int i=0;i<size;++i){
for(int j=0;j<size;++j)
{
printf("arr[%d][%d]:%2d, ",i,j,arr[i*(size)+j]);
}
printf("\n");
}
}
int main() {
int matrix[SIZE] ;
int block[SIZE];
int j = 0;
int i = 0;
for (j = 0; j < SIZE; ++j) {
matrix[j] = 1 + j;
}
int matrixColumnSize = sqrt(SIZE);
for (i = 0; i < matrixColumnSize; ++i) {
for (j = 0; j < matrixColumnSize; ++j) {
printf("matrix[%d][%d] -> %2d ", i, j, matrix[j + i * matrixColumnSize]);
}
printf("\n");
}
printf("\n");
printf("*************\n");
for( int i = 0 ; i < NBLOCKS/2 ; ++i )
for( int j = 0 ; j < NBLOCKS/2 ; ++j ){
int sliceColumnSize = sqrt(SIZE / NBLOCKS);
get_slice( matrix, block, SIZE, SIZE / NBLOCKS ,i*(sliceColumnSize), j*(sliceColumnSize) );
printf("part:%d\n",1+j+i*(NBLOCKS/2));
printSlice(block,SIZE / NBLOCKS);
printf("*************\n");
}
/*for( int i = 0 ; i < NBLOCKS ; ++i ) // get all blocks (invariant: NBLOCKS == 4)
get_slice( matrix, block, SIZE / NBLOCKS ,BLKSZ*i/2, BLKSZ*i%2 ) ;*/
return 0;
}
Output:
matrix[0][0] -> 1 matrix[0][1] -> 2 matrix[0][2] -> 3 matrix[0][3] -> 4 matrix[0][4] -> 5 matrix[0][5] -> 6 matrix[0][6] -> 7 matrix[0][7] -> 8
matrix[1][0] -> 9 matrix[1][1] -> 10 matrix[1][2] -> 11 matrix[1][3] -> 12 matrix[1][4] -> 13 matrix[1][5] -> 14 matrix[1][6] -> 15 matrix[1][7] -> 16
matrix[2][0] -> 17 matrix[2][1] -> 18 matrix[2][2] -> 19 matrix[2][3] -> 20 matrix[2][4] -> 21 matrix[2][5] -> 22 matrix[2][6] -> 23 matrix[2][7] -> 24
matrix[3][0] -> 25 matrix[3][1] -> 26 matrix[3][2] -> 27 matrix[3][3] -> 28 matrix[3][4] -> 29 matrix[3][5] -> 30 matrix[3][6] -> 31 matrix[3][7] -> 32
matrix[4][0] -> 33 matrix[4][1] -> 34 matrix[4][2] -> 35 matrix[4][3] -> 36 matrix[4][4] -> 37 matrix[4][5] -> 38 matrix[4][6] -> 39 matrix[4][7] -> 40
matrix[5][0] -> 41 matrix[5][1] -> 42 matrix[5][2] -> 43 matrix[5][3] -> 44 matrix[5][4] -> 45 matrix[5][5] -> 46 matrix[5][6] -> 47 matrix[5][7] -> 48
matrix[6][0] -> 49 matrix[6][1] -> 50 matrix[6][2] -> 51 matrix[6][3] -> 52 matrix[6][4] -> 53 matrix[6][5] -> 54 matrix[6][6] -> 55 matrix[6][7] -> 56
matrix[7][0] -> 57 matrix[7][1] -> 58 matrix[7][2] -> 59 matrix[7][3] -> 60 matrix[7][4] -> 61 matrix[7][5] -> 62 matrix[7][6] -> 63 matrix[7][7] -> 64
*************
part:1
arr[0][0]: 1, arr[0][1]: 2, arr[0][2]: 3, arr[0][3]: 4,
arr[1][0]: 9, arr[1][1]:10, arr[1][2]:11, arr[1][3]:12,
arr[2][0]:17, arr[2][1]:18, arr[2][2]:19, arr[2][3]:20,
arr[3][0]:25, arr[3][1]:26, arr[3][2]:27, arr[3][3]:28,
*************
part:2
arr[0][0]: 5, arr[0][1]: 6, arr[0][2]: 7, arr[0][3]: 8,
arr[1][0]:13, arr[1][1]:14, arr[1][2]:15, arr[1][3]:16,
arr[2][0]:21, arr[2][1]:22, arr[2][2]:23, arr[2][3]:24,
arr[3][0]:29, arr[3][1]:30, arr[3][2]:31, arr[3][3]:32,
*************
part:3
arr[0][0]:33, arr[0][1]:34, arr[0][2]:35, arr[0][3]:36,
arr[1][0]:41, arr[1][1]:42, arr[1][2]:43, arr[1][3]:44,
arr[2][0]:49, arr[2][1]:50, arr[2][2]:51, arr[2][3]:52,
arr[3][0]:57, arr[3][1]:58, arr[3][2]:59, arr[3][3]:60,
*************
part:4
arr[0][0]:37, arr[0][1]:38, arr[0][2]:39, arr[0][3]:40,
arr[1][0]:45, arr[1][1]:46, arr[1][2]:47, arr[1][3]:48,
arr[2][0]:53, arr[2][1]:54, arr[2][2]:55, arr[2][3]:56,
arr[3][0]:61, arr[3][1]:62, arr[3][2]:63, arr[3][3]:64,
*************
+1
source to share