Получить новую матрицу путем деления всех элементов данной матрицы на ее наибольший по модулю элемент

#ifndef EXTERN_C_H
#define EXTERN_C_H
 
#ifdef __cplusplus
#define extern_c_start extern "C" {
#define extern_c_stop }
#else
#define extern_c_start
#define extern_c_stop
#endif // C++
 
#endif

#ifndef MATRIX_T_H
#define MATRIX_T_H
 
#include <stdlib.h>
#include <stdio.h>
#include "extern_c.h"
 
extern_c_start
 
typedef double number_t;
typedef struct{
    number_t** data;
    size_t row_count, col_count;
} matrix_t;
 
matrix_t* matrix_sq_create(size_t size);
matrix_t* matrix_create(size_t row_count, size_t col_count);
matrix_t* matrix_read(FILE* in);
void matrix_free(matrix_t* m);
void matrix_print(const matrix_t* m, FILE* out);
matrix_t* matrix_multi(const matrix_t* a, const matrix_t* b);
 
extern_c_stop
 
#endif

#include "matrix_t.h"
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable : 4996)
 
matrix_t* matrix_sq_create(size_t size) {
    return matrix_create(size, size);
}
matrix_t* matrix_create(size_t row_count, size_t col_count) {
    matrix_t* m = NULL;
    void* mem_block = NULL;
    size_t    row = 0;
 
    m = (matrix_t*)malloc(sizeof(matrix_t));
    if (m) {
        m->row_count = row_count;
        m->col_count = col_count;
        // выделяем один блок под ссылки на строки и собственно данные, т.е. матрица у нас выходит одномерная
        //    память: под ссылки                   под данные
        m->data = (number_t**)mem_block = malloc(row_count*sizeof(number_t*) + row_count*col_count*sizeof(number_t));
        if (m->data) {
            mem_block = m->data + m->row_count;
            for (row = 0; row < row_count; ++row) {
                m->data[row] = ((number_t*)mem_block) + row*col_count; // запоминаем ссылки на начало строк, приводим матрицу к 2-мерному массиву
            }
        }
        else {
            free(m);
            m = NULL;
        }
    }
    return m;
}
 
void matrix_free(matrix_t* m) {
    if (m) {
        if (m->data) {
            free(m->data);
        }
        free(m);
    }
}
 
void matrix_print(const matrix_t* m, FILE* out) {
    size_t j, i;
    // для квадратной матрицы выводим только колво строк
    fprintf(out, "%z", m->row_count);
    if (m->row_count != m->col_count)
        fprintf(out, " %z", m->col_count);
    fprintf(out, "\n");
 
    for (i = 0; i < m->row_count; i++) {
        for (j = 0; j < (m->col_count - 1); j++) {
            fprintf(out, "%lf ", m->data[i][j]);
        }
        fprintf(out, "%lf\n", m->data[i][j]);
    }
}
 
static int is_endl(FILE* in) {
    int c;
    if ((c = fgetc(in)) == '\n')
        return 1;// ignore it
    else // push it back
        ungetc(c, in);
    return 0;
}
 
matrix_t* matrix_read(FILE* in) {
    matrix_t* m;
    size_t i, j, row, col;
 
    fscanf(in, "%z", &row);
    if (is_endl(in))
        col = row;
    else {
        fscanf(in, "%z", &col);
        is_endl(in);
    }
    if (m = matrix_create(row, col)){
        for (i = 0; i < m->row_count; ++i) {
            for (j = 0; j < m->col_count; ++j) {
                fscanf(in, "%ld", m->data[i]+j);
            }
            is_endl(in);
        }
    }
    return m;
}
matrix_t* matrix_multi(const matrix_t* a, const matrix_t* b) {
    matrix_t* result = NULL;
    size_t i, j, k;
 
    if (a->col_count != b->row_count)
        return NULL;
    if (result = matrix_create(a->row_count, b->col_count)) {
        for (i = 0; i < result->row_count; ++i) {
            for (j = 0; j <result->col_count; ++j) {
                result->data[i][j] = 0;
                for (k = 0; k < a->col_count; ++k) {
                    result->data[i][j] += a->data[i][k] * b->data[k][j];
                }
            }
        }
    }
    return result;
}