Splitting a 2D array into an array of smaller 2D arrays in C

Question

Given:

1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 1 2 3 4 5 6 7 8 

I want to split a 2d array (struct MATRIX) into an array of MATRIX structure taking CS into account: suppose cs is 2, the answer will be

 Seg[0]: 1 2 1 2 1 2 Seg[1]: 3 4 3 4 3 4 .... Seg[3]: 7 8 7 8 7 8 

Here is my matrix structure:

 typedef struct MATRIX { int nrow; int ncol; int **element; } MATRIX; 

and here is the function separating them:

 void SegmentMatrix(MATRIX input,MATRIX* segs,int Chunksize, int p) { int i,j,r; //Allocate segs for (i = 0; i<p;i++) { CreateMatrix(&(segs[i]),input.nrow ,Chunksize,0); } //Now Copy the elements from input to the segs //where seg0 takes from 0 to cs cols of a, and all their rows, and seg1 takes from cs to 2cs ... printf("Stats:\n\t P: %d\t CS: %d\n",p,Chunksize); for (r = 0; r<p; r++) { for (i = 0; i<input.nrow;i++) { for (j = r*Chunksize; j<r*Chunksize+Chunksize-1; j++) { //I tried (&(segs[r]))->element... Doesn't work, produces wrong data segs[r].element[i][j] = input.element[i][j]; } } PRINTM(segs[r]); } } 

Note that PRINTM basically prints the matrix, it knows the limitations, checking segs [r] .nrow and ncol and CreateMatrix accepts the following inputs (& matrix, number of rows, number of columns, filltype) and mallocs from the inside.

 filltype: 0- generates zeroth matrix 1- generates identity else A[i][j] = j; for simplicity 

The problem is that if I print the Segs [i] matrices, they are all reset with the default value specified by CreateMatrix, and not just the added values.

CLARIFICATION: Okay, so if you guys check out this last PRINTM in the SegmentMatrix function, it outputs the matrices as if the for loops were not running, aka, I can remove the for loops and get the same result. I did something wrong on this line (taken from SegmentMatrix)

 Segs[r].element[i][j] = input.element[i][j]; 

Answer 1

I don’t understand why and what you are manipulating with multiplication by ChunkSize and r (which is by no means initialized), I would suggest simplifying the code (the rule of thumb: if it seems dirty, it's also complicated). All you need is a 3-dimensional array for storing an array of pieces and modulo arithmetic plus integer division to insert into the corresponding column of the corresponding fragment:

 /* the variable-sized dimension of the `chunks' argument is w / chsz elements big * (it the number of chunks) */ void split(int h, int w, int mat[h][w], int chsz, int chunks[][h][chsz]) { /* go through each row */ for (int i = 0; i < h; i++) { /* and in each row, go through each column */ for (int j = 0; j < w; j++) { /* and for each column, find which chunk it goes in * (that j / chsz), and put it into the proper row * (which is j % chsz) */ chunks[j / chsz][i][j % chsz] = mat[i][j]; } } } 

Demonstration, a. to. and. what to call him:

 int main(int agrc, char *argv[]) { const size_t w = 8; const size_t h = 3; const size_t c = 2; int mat[h][w] = { { 1, 2, 3, 4, 5, 6, 7, 8 }, { 1, 2, 3, 4, 5, 6, 7, 8 }, { 1, 2, 3, 4, 5, 6, 7, 8 } }; int chunks[w / c][h][c]; split(h, w, mat, c, chunks); for (int i = 0; i < w / c; i++) { for (int j = 0; j < h; j++) { for (int k = 0; k < c; k++) { printf("%3d ", chunks[i][j][k]); } printf("\n"); } printf("\n\n"); } return 0; } 

Answer 2

The question was unclear. so I thought he just wanted to know how to achieve this. So I wrote this simple pseudo code. Otherwise, accept my apologies:

 matrix[i] matrix //matrixes total column size should be bigger big 2d array column size first condition check: sum(matrix[i].colsize)>=big2d.colsize //in this simple code raw sizes must be equal second condition: for all i matrix[i].rawsize=big2d.rawsize //if columns sizes will be equal the algorithm could be simplified , does not mean optimized //splitting big2d into matrixes for (int br=0;br<big2d.rawsize;br++){ i=0;//store matrix index int previndex=0;//store offset for next matrix for(int bc=0;bc<big2d.colsize;bc++){ matrix[i].val[bc-previndex][br]=big2d.val[bc][br]; //assign (bc,br) if(bc-previndex==matrix[i].colsize-1){ i++; //move to next matrix;//if we not have next matrix then break; previndex=bc+1; } /*if it be for equal chunks matrixes offset can be calculated this way too matrix[bc/chunk].val[bc%chunk][br]=big2d.val[bc][br]; */ }//loop columns }//loop raws