C: Using a 2D array created in a function during main

VLA (variable length arrays) are not advised in C. Add an "allocate_matrix" function, which would return a double ** matrix allocated with malloc, and return it to main ! Dont forget to free everything after use ;)

"However I am completely stumped on how to then use this function in main, as outside of the function the variable is no longer in scope"

You have correctly identified the problem as scope. It can be addressed in several ways. I like the following:

    double ** read_matrix(char *filename, int *rows, int *cols);//requires memory allocation

In this, the function will return array, and filename is passed as a parameter, and because you do not know the size parameters until the file is read, pass pointers to rows and cols. It would be called as:

int main(void)
{
     const char filename[] = {"c:\\somefile.txt"};
     double **array = NULL;
     int rows, cols;
     ... other variables
     array = read_matrix(filename, &rows, &cols);
     if(array)
     {
          // use array
          ...
          free(array);
     }

The internals of read_matrix() include:

• reading and parsing the file to get values for rows, cols and data for array.
• using rows, cols, allocate memory to double **array. (malloc() used)
• populate new dynamically allocated array with data values.
• set *cols == to internally determined value for columns.
• set *rows == to internally determined value for rows.
• return array.

And, back in main(),

• use the array object.
• free(array);

Inside the read_matrix() function, the memory allocation that is called could (and probably should) be implemented as another function, such as:

double ** Create2D(int c, int r)
{   
    double **arr;
    int    y;
    
    arr   = calloc(c, sizeof(double *));
    for(y=0;y<c;y++)
    {
        arr[y] = calloc(r, sizeof(double)); 
    }
    return arr;
}

Called as:

double ** read_matrix(char *filename, int *rows, int *cols)
{
     int cols=0, rows=0, i, j;
     
     //variables, initializations
     //read and parse files
     //convert values read from file from text into `cols` and `rows`
     //allocate memory for double **array
     //place data values from file into array
     double **array = Create2D(rows, cols
     if(array)
     {
         for(i=0;i<rows;i++)
         {
             for(j=0;j<cols;j++)
             {
                  array[i][j] = data[i][j];
             }
         }
     }
     return array;  //must test that array is not null in caller
 }

Where could Create2D() be implemented as:

double ** Create2D(int r, int c)
{   
    double **arr;
    int    y;
    
    arr   = calloc(c, sizeof(double *));
    for(y=0;y<c;y++)
    {
        arr[y] = calloc(r, sizeof(double)); 
    }
    return arr;
}                 

you will need to dynamically allocate your matrix with malloc and return it from your function, that way you will be able return it from the function and access the information you saved outside of the scope, there is no way to do this in C without dynamically allocating it. here's an answer from another user to show how to dynamically allocate a matrix: https://stackoverflow.com/a/2128754/6365408 the intuitive way is to allocate a pointer pointer to a double the size of columns, and in each index allocate a row in a for loop:

int **mat = (int **)malloc(rows * sizeof(int*));
for(int i = 0; i < rows; i++) mat[i] = (int *)malloc(cols * sizeof(int));

but you lose on locality of reference which will affect performance. the 2nd option is:

int *mat = (int *)malloc(rows * cols * sizeof(int));

Then, you simulate the matrix using

int offset = i * cols + j;
// now mat[offset] corresponds to m(i, j)

for row-major ordering and

int offset = i + rows * j;
// not mat[offset] corresponds to m(i, j)

in the end you will have to free all the allocations you've made with malloc.