Различные результаты при отображении матрицы результатов

Question

В настоящее время я работаю над кодом, который вычисляет следующее уравнение: W = (XT * X)^-1 * XT * Y, где XT - транспонирование X, а ^ -1 - инверсия произведения XT*X.

Чтобы сделать это, я передаю текстовый файл с матрицей программе, а затем выполняю операции над ней, чтобы получить надлежащие форматы матрицы для использования в уравнении. Хотя код работает несколько раз, бывают случаи, когда я запускаю код и получаю правильный ответ, но есть и другие, когда будет получено случайное число.

Например, при использовании матрицы [первое целое число = столбцы-1, второе целое число = строки]:

4 
4
4.000000,3.000000,2.000000,3.000000,200.000000
5.000000,2.000000,1.000000,7.000000,300.000000
1.000000,4.000000,2.000000,1.000000,500.000000
8.000000,8.000000,9.000000,3.000000,200.000000

для XT * (XT * X)^-1 будет получен ответ:

0.497617        -0.166646       0.061712        -0.137570
-61.086998      -0.258283       -0.340935       -0.064228
0.186411        -0.083895       0.285920        -0.082587
-0.722773       0.207515        -0.009408       0.238550
-0.579552       0.345476        0.154362        0.055048

и цифры не будут оставаться неизменными при каждом тесте. Это происходит с помощью этой матрицы результатов, умноженной на Y [последний столбец в исходной матрице]. Ниже приведен пример кода, который я написал до сих пор:

#include <stdlib.h>
#include <stdio.h>

int main(int argc, char* argv[]){
if(argc < 2){
                printf("error.");
                return 0;
        }
        FILE *fptrain = fopen(argv[1], "r");
        int row, col, i, j;
        fscanf(fptrain, "%d", &col);
        col = col+1;
        fscanf(fptrain, "%d", &row);
        char ch;

        //creates the original X and Y matrix
        float trainX[row][col];
        float trainY[row][1];
        for(i=0; i<row; i++)
        {
                trainX[i][0] = 1.000000;
                for(j=1; j<col; j++)
                {
                        fscanf(fptrain, "%f%c", &trainX[i][j], &ch);
                }

                        fscanf(fptrain, "%f%c", &trainY[i][0], &ch);
        }
 //creates the X transposed matrix
        float trainXtrans[col][row];
        for(i=0; i<row; i++)
        {
                for(j=0; j<col; j++)
                {
                        trainXtrans[j][i] = trainX[i][j];
                }
        }

        //multiplies X and X transposed
        float trainXtemp[row][row];
        int s;
        int num=0;
        for(i=0; i<row; i++)
        {
                for(j=0; j<row; j++)
                {
                        for(s=0; s<col; s++)
                        {
                                num = num + trainX[i][s]*trainXtrans[s][j];
                        }
                                trainXtemp[i][j] = num;
                                num =0;
                }
        }
 //finds the identity matrix of X times X transposed
        float trainXinden[row][row*2];
        for(i=0; i<row; i++)
        {
                for(j=0; j<row; j++)
                {
                        trainXinden[i][j] = trainXtemp[i][j];
                }
                for(j=row; j<row*2; j++)
                {
                        if(j==i+row)
                        {
                                trainXinden[i][j] = 1;
                        }
                        else{
                                trainXinden[i][j] = 0;
                        }
                }
        }
 //finds the inverse of X times X transposed through Gauss Jordan Elimination
        int k;
        float divscalar;
        for(i=0; i<row; i++)
        {
                divscalar = trainXinden[i][i];
                for(j=0; j<row*2; j++)
                {
                        trainXinden[i][j] = trainXinden[i][j]/divscalar;
                }
                for(k=0; k<row; k++)
                {
                        if(i!=k)
                        {
                                float subscalar = trainXinden[k][i];
                                for(j=0; j<row*2; j++)
                                {
                                        trainXinden[k][j] = trainXinden[k][j] - subscalar*trainXinden[i][j];
                                }
                        }
                }
        }
 //copies over the result of gauss jordan elimination
        float trainXinverse[row][row];
        for(i=0; i<row; i++)
        {
                for(j=0; j<row; j++)
                {
                        trainXinverse[i][j] = trainXinden[i][j+row];
                }
        }
 //multiplies (X times X transpose) inverse by (X transposed)
        float trainXinvXt[col][row];
        for(i=0; i<col; i++)
        {
                for(j=0; j<row; j++)
                {
                        for(s=0; s<row; s++)
                        {
                                trainXinvXt[i][j] += trainXtrans[i][s]*trainXinverse[s][j];
                        }
                }
        }
        //multiples (trainXinvXt) by Y
        float weight[row][1];
        for(i=0; i<col; i++)
        {
                for(s=0; s<col-1; s++)
                {
                        weight[i][0] += trainXinvXt[i][s]*trainY[s][0];
                }

        }
return 0;
}

возможно, это проблема с памятью или мой метод исключения Гаусса-Джордана выбрасывает что-то?