Нахождение обратной матрицы

void one_matrix(double y0, double y1, double y2, double y3, double t0, double max_t, double h) {
    const int n = 4; // размерность матрицы
 
    //единичная матрица
    double a[n][n];
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (i == j) a[i][j] = 1;
            else a[i][j] = 0;
        }
    }
 
    // якобиан системы
    double jac[n][n];
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            jac[0][0] = (2 * (y2 * (y0 - 0.1) - 50000000.0 * (y1 - 1.0))) / (1.0 - y1);
            jac[0][1] = ((y0 - 0.2)*y0 * y2) / pow((1.0 - y1), 2);
            jac[0][2] = ((y0 - 0.2)*y0) / (1.0 - y1);
            jac[0][3] = 0.0;
            jac[1][0] = y2;
            jac[1][1] = 0.0;
            jac[1][2] = y0;
            jac[1][3] = 0.0;
            jac[2][0] = y3;
            jac[2][1] = 0.0;
            jac[2][2] = 0.0;
            jac[2][3] = y0;
            jac[3][0] = (5 * pow(10, 29)*(exp(-0.75 / y0))*(1.5 + y0)) / pow(y0, 3 / 2);
            jac[3][1] = 0.0;
            jac[3][2] = 0.0;
            jac[3][3] = 0.0;
        }
    }
 
    //умножение матрицы на число
    //cout << "\numn:\n";
    double umn[n][n];
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            jac[i][j] *= (h / 2);
            umn[i][j] = jac[i][j];
            //cout << umn[i][j] << " ";
        }
        //cout << endl;
    }
    
    // моя матрица, к которой нужно найти обратную
    double temp[n][n];
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            temp[i][j] = a[i][j] - umn[i][j];
            //temp[i][j] = a[i][j] - (h/2)*jac[i][j];
            cout << temp[i][j] << "\t\t";
        }
        cout << endl;
    }
}

int SLAU(double **matrica_a, int n, double *massiv_b, double *x){
 
    int i, j, k, r;
    double c, M, max, s, **a, *b; 
    
    a = new double *[n];
    for (i = 0; i < n; i++) 
        a[i] = new double[n];
    
    b = new double[n]; 
    for (i = 0; i < n; i++)
        for (j = 0; j < n; j++) 
            a[i][j] = matrica_a[i][j];
 
    for (i = 0; i < n; i++) 
        b[i] = massiv_b[i];
 
    for (k = 0; k < n; k++) {
        max = fabs(a[k][k]);
        r = k;
        for (i = k + 1; i < n; i++)
            if (fabs(a[i][k]) > max) {
                max = fabs(a[i][k]);
                r = i;
            }
        for (j = 0; j < n; j++)
        {
            c = a[k][j];
            a[k][j] = a[r][j];
            a[r][j] = c;
        }
 
        c = b[k]; 
        b[k] = b[r]; 
        b[r] = c; 
        for (i = k + 1; i < n; i++)
        {
            for (M = a[i][k] / a[k][k], j = k; j < n; j++)
                a[i][j] -= M * a[k][j]; 
            b[i] -= M * b[k];
        }
    }
 
    if (a[n - 1][n - 1] == 0)
        if (b[n - 1] == 0) 
            return-1; 
        else return-2;
    else {
        for (i = n - 1; i >= 0; i--)
        {
            for (s = 0, j = i + 1; j < n; j++)
                s += a[i][j] * x[j]; x[i] = (b[i] - s) / a[i][i];
 
        }
        return 0;
    } 
    for (i = 0; i < n; i++) 
        delete[] a[i]; 
    delete[] a;
 
    delete[] b;
 
}
 
int INVERSE(double **a, int n, double **y) {
    int i, j, res; 
    double *b, *x; 
    b = new double[n]; 
    x = new double[n]; 
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++)
            if (j == i)
                b[j] = 1; 
            else
                b[j] = 0;
        res = SLAU(a, n, b, x);    
        if (res != 0) break;
        else
            for(j = 0; j < n; j++)
                y[j][i] = x[j];
    }
          
    delete[] x;
    delete[] b;
 
    if (res != 0)   return -1;
    else return 0;
}