How to pass a 2D array to a function in C when the array is formatted like this?

Question

I'd like to make an array (called Csend) and then create a function which modifies it slightly, such as by adding 0.05 to every element. The problem I'm having is with the formatting of the array, I'm not sure how to pass it into a function properly. I've allocated the memory in this way following this guide so that I can later put it in MPI_Send and MPI_Recv.

Here is my attempt:

#include "stdio.h"
#include "stdlib.h"
#include "mpi.h"
#include "math.h"


int main(int argc, char **argv) {

  int N = 32;
  int dim = 3;
  float a = 10.0; // size of 3D box
  int size, rank, i, j, k, q;
  float **C, **Csend, **Crecv;
  float stepsize = 0.05;

  MPI_Init(&argc, &argv);
  MPI_Comm_size(MPI_COMM_WORLD, &size);
  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
  float **alloc_2d_float(int rows, int cols) {
    float *data = (float *)malloc(N*dim*sizeof(float));
    float **array= (float **)malloc(N*sizeof(float*));
    for(i=0; i<N; i++) {
        array[i] = &(data[dim*i]);
     }
    return array;
}

  C = alloc_2d_float(N,dim);
  Csend = alloc_2d_float(N,dim);
  Crecv = alloc_2d_float(N,dim);

if(rank == 0) {
for (i = 0; i < N; i++) {
    for (j = 0; j < dim; j++) {
        Csend[i][j] = (float)rand()/(float)(RAND_MAX/a);
  }}
}

  // FUNCTION TO MODIFY MATRIX //
  float randomsteps(float *matrix, int N, int dim) {
  int i, j;
for(i = 0; i < N; i = i+2) {
        for (j = 0; j < dim; j++) {
*((matrix+i*N) + j) = *((matrix+i*N) + j) + stepsize;
}
}
return matrix;
  } 

C = randomsteps(Csend, 32, 3);
  for (i=0; i<N; i++){
    for (j=0; j<dim; j++){
      printf("%f, %f\n", Csend[i][j], C[i][j]);
    }
  }

 MPI_Finalize();

  return 0;
}

The problem I'm having is that formatted like it is here, I get error messages, and formatted in ways that didn't give error messages, C was just empty.

Here is the error message:

test.c: In function ‘randomsteps’:
test.c:46: error: incompatible types when returning type ‘float *’ but ‘float’ was expected
test.c: In function ‘main’:
test.c:49: warning: passing argument 1 of ‘randomsteps’ from incompatible pointer type
test.c:39: note: expected ‘float *’ but argument is of type ‘float **’
test.c:49: error: incompatible types when assigning to type ‘float **’ from type ‘float’

Thanks for the help!

Answer 1

You are confusing between 1 dimensional representation of a matrix and a two dimensional pointer to pointer approach of it.

*((matrix+i*N) + j) = *((matrix+i*N) + j) + stepsize; -> This line implies that matrix is just linear collection and it is accessed like a matrix using index manipulation.

float **C; -> This implies you want a matrix which can be accessed as C[i][j].

Stick to any one of the representations. Also, since your function returns a matrix, the return type should be either float* (if the 2d matrix is considered linear with array manipulation) of float** if you want a 2d matrix without index manipulation access.

float* matrix = malloc(row * cols * sizeof(float)); // This is a linear version.
// matrix[i*cols + j] gives you the (i, j)th element.

float** matrix = malloc(rows * sizeof(float*)); 
for(int i = 0; i < rows; ++i)
    matrix[i] = malloc(cols * sizeof(float));
// Now you can access matrix[i][j] as the (i, j)th element.

Here is a way to interconvert between the two formats.

float* linearize(float** matrix, unsigned int rows, unsigned int cols)
{
    float* linear = malloc(rows * cols * sizeof(float));
    if(linear)
    {
        for(unsigned int i = 0; i < rows; ++i)
            for(unsigned int j = 0; j < cols; ++j)
                linear[i*cols + j] = matrix[i][j] ;
    }
    return linear ;
}


float** unlinearize(float* linear, unsigned int rows, unsigned int cols)
{
    float** matrix = malloc(rows * sizeof(float*));
    if(matrix)
    {
        for(unsigned int i = 0; i < rows; ++i)
        {
            matrix[i] = malloc(cols * sizeof(float));
            if(matrix[i])
            {
                for(unsigned int j = 0; j < cols; ++j)
                    matrix[i][j] = linear[i*cols + j] ;
            }
        }
    }
    return matrix ;
}