Простейшая нейронная сеть для аппроксимации параболы

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "sys.h"
#include "matrix.h"
 
 
 
mat* mat_new(int rows, int colls)
{
    double **data = malloc(rows * sizeof(double*));
    for (int i = 0; i < rows; ++i) data[i] = calloc(colls, sizeof(double));
    mat tmp = { data,rows,colls };
    return localcpy(&tmp, sizeof(mat));
}
 
void mat_del(mat* m)
{
    for (int i = 0; i < m->rows; ++i) free(m->data[i]);
    free(m->data);
    free(m);
}
 
mat* mat_transp(mat* m)
{
    mat *res = mat_new(m->colls, m->rows);
    for (int i = 0; i < m->rows; ++i)
        for (int j = 0; j < m->colls; ++j)
            res->data[j][i] = m->data[i][j];
 
    return res;
}
 
mat* mat_pw(mat* m1, mat* m2, double f(double, double))
{
    mat *res = mat_new(m1->colls, m1->rows);
    for (int i = 0; i < m1->rows; ++i)
        for (int j = 0; j < m1->colls; ++j)
            res->data[i][j] = f(m1->data[i][j], m2->data[i][j]);
 
    return res;
}
 
mat* mat_fromvec(double* vec, int len)
{
    mat* m = mat_new(len, 1);
    for (int i = 0; i < len; ++i) m->data[i][0] = vec[i];
    return m;
}
 
mat* mat_mult(mat* m1, mat* m2)
{
    mat *res = mat_new(m1->colls, m1->rows);
    for (int i = 0; i < m1->rows; ++i)
    {
        for (int j = 0; j < m1->colls; ++j)
        {
            double p = 0;
            for (int k = 0; k < m1->colls; ++k)
                p += m1->data[i][k] * m2->data[k][j];
 
            res->data[i][j] = p;
        }
    }
    return res;
}
 
void mat_multvec(double* v, mat* m, double* res)
{
    int l = _msize(v) / sizeof(double);
    for (int i = 0; i < m->rows; ++i)
    {
        res[i] = 0;
        for (int j = 0; j < m->colls; ++j)
        {
            double c = j < l ? v[j] : 1;
            res[i] += c * m->data[i][j];
        }
    }
}
 
mat* mat_copy(mat* m)
{
    mat* res = mat_new(m->rows, m->colls);
    for (int i = 0; i < m->rows; ++i)
        for (int j = 0; j < m->colls; ++j)
            res->data[i][j] = m->data[i][j];
 
    return res;
}
 
mat* mat_one(mat* m)
{
    mat* res = mat_new(m->rows, m->colls);
    for (int i = 0; i < m->rows; ++i)
    {
        for (int j = 0; j < m->colls; ++j)
        {
            if (i == j) res->data[i][j] = 1;
            else  res->data[i][j] = 0;
        }
    }
    return res;
}
 
void mat_print(mat *m)
{
    for (int i = 0; i < m->rows; ++i)
    {
        for (int j = 0; j < m->colls; ++j)
            printf("%f\t", m->data[i][j]);
 
        printf("\n");
    }
}
 
double mat_det(mat* m)
{
    mat* tmp = mat_copy(m);
 
    for (int x = 1; x < m->rows; ++x)
    {
        int x1 = x - 1;
        for (int i = x; i < m->rows; ++i)
        {
            double k = tmp->data[i][x1] / tmp->data[x1][x1];
            for (int j = 0; j < m->colls; ++j)
                tmp->data[i][j] -= tmp->data[x1][j] * k;
        }
    }
 
    double det = 1;
    for (int i = 0; i < m->rows; ++i)
        for (int j = 0; j < m->colls; ++j)
            if (i == j) det *= tmp->data[i][j];
 
    mat_del(tmp);
 
    return  det;
}
 
double mat_minor(mat* m, int mi, int mj)
{
    mat *minor = mat_new(m->rows - 1, m->colls - 1);
 
    for (int i = 0; i < m->rows; ++i)
    {
        for (int j = 0; j < m->colls; ++j)
        {
            if (i != mi && j != mj)
            {
                int ii = i < mi ? i : i - 1;
                int jj = j < mj ? j : j - 1;
                minor->data[ii][jj] = m->data[i][j];
            }
        }
    }
 
    double det = mat_det(minor);
    mat_del(minor);
    return det;
}
 
mat* mat_inverse(mat* m)
{
    mat* adds = mat_new(m->rows, m->colls);
    for (int i = 0; i < m->rows; ++i)
    {
        for (int j = 0; j < m->colls; ++j)
        {
            int k = ((i % 2) ^ (j % 2)) ? -1 : 1;
            adds->data[i][j] = k * mat_minor(m, i, j);
        }
    }
 
    mat* tadds = mat_transp(adds);
    mat_del(adds);
    double det = mat_det(m);
    mat* res = mat_new(m->rows, m->colls);
 
    for (int i = 0; i < m->rows; ++i)
        for (int j = 0; j < m->colls; ++j)
            res->data[i][j] = tadds->data[i][j] / det;
 
    mat_del(tadds);
 
    return res;
}
 
void mat_test()
{
    int N = 3;
    mat *m = mat_new(N, N);
    double v1[] = { 2,5,7 };
    double v2[] = { 6,3,4 };
    double v3[] = { 5,-2,-3 };
    m->data[0] = v1;
    m->data[1] = v2;
    m->data[2] = v3;
 
 
    mat* inv1 = mat_inverse(m);
    mat_print(inv1);
}