работа с матрицами в файлах

#include <stdio.h>
 
int main()
{
    double **mas;
    char buff;
    int res;
    int i, j;
    
    FILE *in;
    FILE *out;
    
    if ((in = fopen("in.txt", "r")) == NULL)
        return -1;
    
    res = 1;
    
    while ((buff = fgetc(in)) != EOF)
        if (buff == '\n')
            res++;
    
    mas = (double **)malloc(res * sizeof(double *));
    
    for (i = 0; i < res; i++)
        mas[i] = (double *)malloc(res * sizeof(double));
    
    fseek(in, 0, SEEK_SET);
    
    fscanf(in, "%lf", &mas[0][0]);
    fscanf(in, "%lf", &mas[0][1]);
    
    for (i = 2; i < res; i++)
        mas[0][i] = 0;
    
    for (i = 1; i < res - 1; i++)
    {
        for (j = 0; j < ((i - 1 <= 0) ? 0 : (i - 1)); j++)
            mas[i][j] = 0;
        
        fscanf(in, "%lf", &mas[i][j++]);
        fscanf(in, "%lf", &mas[i][j++]);
        fscanf(in, "%lf", &mas[i][j++]);
        
        for ( ; j < res; j++)
            mas[i][j] = 0;
    }
    
    
    for (i = 0; i < res - 3; i++)
        mas[res - 1][i] = 0;
    
    fscanf(in, "%lf", &mas[res - 1][res - 2]);
    fscanf(in, "%lf", &mas[res - 1][res - 1]);
    
    if ((out = fopen("out.txt", "w")) == NULL)
        return -1;
    
    for (i = 0; i < res; i++)
    {
        for (j = 0; j < res; j++)
            fprintf(out, "%lf ", mas[i][j]);
        
        fprintf(out, "\n");
    }
    
    fclose(in);
    fclose(out);
    
    for (i = 0; i < res; i++)
        free(mas[i]);
    
    free(mas);
    
    return 0;
}

#include <stdio.h>
#include <stdlib.h>
 
// -----------------------------------------------------------------------------
 
// Функция, производящая перемножение двух матриц
int matrix_multiplication(double **matrix1,
                          double **matrix2,
                          int rows1,
                          int cols1,
                          int rows2,
                          int cols2,
                          double **result_matrix)
{
    int i, j, r;
 
// -----------------------------------------------------------------------------
 
    // Проверяем, совпадает ли число столбцов первой матрицы с числом строк второй.
    // Если нет - матрицы невозможно перемножить - поэтому выходим
    
    if (cols1 != rows2)
        return 1;
 
// -----------------------------------------------------------------------------
    
    // Производим заполнение результирующей матрицы нулями
    
    for (i = 0; i < rows1; i++)
        for (j = 0; j < cols2; j++)
            result_matrix[i][j] = 0.0;
            
// -----------------------------------------------------------------------------
    
    // Собственно само перемножение
    
    for (i = 0; i < rows1; i++)
        for (j = 0; j < cols2; j++)
            for (r = 0; r < cols1; r++)
                result_matrix[i][j] += matrix1[i][r] * matrix2[r][j];
                
// -----------------------------------------------------------------------------
    
    return 0;
}
 
// -----------------------------------------------------------------------------
 
// Функция, подсчитывающая число строк в файле. В качестве аргумента принимает
// имя входного файла. В данном случае нужна, чтобы посчитать размерность матрицы
 
int line_count(char *filename)
{
    FILE *in; // Указатель на входной поток
    
    int count = 1; // Уоличество строк в файле
    char buff;     // Временная переменная для проверки считанного символа
 
// -----------------------------------------------------------------------------
 
    // Открываем файл. Если файл не удалось открыть - выходим
    
    if ((in = fopen(filename, "r")) == NULL)
        return -1;
 
// -----------------------------------------------------------------------------
    
    // Посимвольно читаем информацию из файла и проверяем считанный символ. Если
    // он является символом перевода строки - увеличиваем количество строк на 1
    
     while ((buff = fgetc(in)) != EOF)
        if (buff == '\n')
            count++;
            
// -----------------------------------------------------------------------------
    
    fclose(in); // Закрываем входной поток
    
    return count; // Возвращаем количество строк в файле
}
 
// -----------------------------------------------------------------------------
 
// Функция считывания матрицы из файла с учётом формата файал (файл содержит
// только ненулевую часть верхнетреугольной матрицы). В качестве аргумента принимает
// имя файла, содержащего матрицу, указатель на двумерный массив, куда бедт помещена
// матрица, а так же размерность матрицы
 
int read_matrix(char *filename, double **matrix, int res)
{
    FILE *in; // Указатель на входной поток
    
    int i, j;
    
// -----------------------------------------------------------------------------
    
    // Открываем файл. Если файл не удалось открыть - выходим
    
    if ((in = fopen(filename, "r")) == NULL)
        return -1;
 
// -----------------------------------------------------------------------------
    
    // Заполняем матрицу
    
    for (i = 0; i < res; i++)
    {
        // В n-той строке треугольной матрицы сначала идёт n нулей
        
        for (j = 0; j < i; j++)
            matrix[i][j] = 0.0;
        
        // А затем данные, считываемые из файла
        
        for ( ; j < res; j++)
            fscanf(in, "%lf", &matrix[i][j]);
    }
    
// -----------------------------------------------------------------------------
    
    fclose(in); // Закрываем входной поток
    
    return 0;
}
 
int main()
{
    FILE *out; // Указатель на выходной поток
 
    int res1; // Размерность первой матрицы
    int res2; // Размерность второй матрицы
    int i, j;
 
    double **matrix1;       // Первая матрицы
    double **matrix2;       // Вторая матрица
    double **result_matrix; // Результирующая матрицы
 
// -----------------------------------------------------------------------------
 
    // Узнаём размерность первой матрицы
    
    if ((res1 = line_count("m1.txt")) == -1)
    {
        printf("Oshibka chteniya faila m1.txt");
        getch();
        
        return -1;
    }
 
// -----------------------------------------------------------------------------
    
    // Узнаём размерность второй матрицы
    
    if ((res2 = line_count("m2.txt")) == -1)
    {
        printf("Oshibka chteniya faila m2.txt");
        getch();
        
        return -1;
    }
 
// -----------------------------------------------------------------------------
    
    // Проверяем, можно ли перемножить матрицы
    
    if (res1 != res2)
    {
        printf("Matrici imeyut raznuyu razmernost' i ne mogut bit' peremnojeni");
        getch();
        
        return 0;
    }
    
// -----------------------------------------------------------------------------
    
    // Выделяем память под первую матрицу
    
    matrix1 = (double **)malloc(res1 * sizeof(double *));
    
    for (i = 0; i < res1; i++)
        matrix1[i] = (double *)malloc(res1 * sizeof(double));
        
// -----------------------------------------------------------------------------
    
    // Выделяем память под вторую матрицу
    
    matrix2 = (double **)malloc(res2 * sizeof(double *));
    
    for (i = 0; i < res2; i++)
        matrix2[i] = (double *)malloc(res2 * sizeof(double));
        
// -----------------------------------------------------------------------------
    
    // Считываем первую матрицу
    
    if (read_matrix("m1.txt", matrix1, res1) == -1)
    {
        printf("Oshibka chteniya faila m1.txt");
        getch();
        
        return -1;
    }
    
// -----------------------------------------------------------------------------
    
    // Считываем вторую матрицу
    
    if (read_matrix("m2.txt", matrix2, res1) == -1)
    {
        printf("Oshibka chteniya faila m2.txt");
        getch();
        
        return -1;
    }
    
// -----------------------------------------------------------------------------
    
    // Выделяем память под результирующую матрицу
    
    result_matrix = (double **)malloc(res1 * sizeof(double *));
    
    for (i = 0; i < res1; i++)
        result_matrix[i] = (double *)malloc(res2 * sizeof(double));
 
// -----------------------------------------------------------------------------
 
    // Перемножаем матрицы
    
    matrix_multiplication(matrix1, matrix2, res1, res1, res2, res2, result_matrix);
    
// -----------------------------------------------------------------------------
    
    // Открываем выходной поток
    
    if ((out = fopen("mr.txt", "w")) == NULL)
        return -1;
        
// -----------------------------------------------------------------------------
    
    // Записываем ненулевую часть результирующей матрицы в выходной файл
    
    for (i = 0; i < res1; i++)
    {
        for (j = 0; j < res2; j++)
            if (result_matrix[i][j] != 0.0)
                fprintf(out, "%lf ", result_matrix[i][j]);
        
        fprintf(out, "\n");
    }
    
// -----------------------------------------------------------------------------
    
    // Закрываем выходной поток
    
    fclose(out);
    
// -----------------------------------------------------------------------------
    
    // Очищаем память
    
    for (i = 0; i < res1; i++)
        free(matrix1[i]);
    
    free(matrix1);
 
    for (i = 0; i < res2; i++)
        free(matrix2[i]);
    
    free(matrix2);
 
    for (i = 0; i < res1; i++)
        free(result_matrix[i]);
    
    free(result_matrix);
    
// -----------------------------------------------------------------------------
    
    return 0;
}

// -----------------------------------------------------------------------------
 
// Функция считывания матрицы из файла с учётом формата файал (файл содержит
// только ненулевую часть верхнетреугольной матрицы). В качестве аргумента принимает
// имя файла, содержащего матрицу, указатель на двумерный массив, куда бедт помещена
// матрица, а так же размерность матрицы
 
int read_matrix(char *filename, double **matrix, int res)
{
    FILE *in; // Указатель на входной поток
    
    int i, j;
    
// -----------------------------------------------------------------------------
    
    // Открываем файл. Если файл не удалось открыть - выходим
    
    if ((in = fopen(filename, "r")) == NULL)
        return -1;
 
// -----------------------------------------------------------------------------
    
    // Заполняем матрицу
    
    for (i = 0; i < res; i++)
    {
        // В n-той строке треугольной матрицы сначала идёт n нулей
        
        for (j = 0; j < i; j++)
            matrix[i][j] = 0.0;
        
        // А затем данные, считываемые из файла
        
        for ( ; j < res; j++)
            fscanf(in, "%lf", &matrix[i][j]);
    }
    
// -----------------------------------------------------------------------------
    
    fclose(in); // Закрываем входной поток
    
    return 0;
}

for (j = 0; j < i; j++)
            matrix[i][j] = 0.0;

#include <stdio.h>
 
int main()
{
    double **mas;
    char buff;
    int res;
    int i, j;
    
    FILE *in;
    FILE *out;
    
    if ((in = fopen("in.txt", "r")) == NULL)
        return -1;
    
    res = 1;
    
    while ((buff = fgetc(in)) != EOF)
        if (buff == '\n')
            res++;
    
    mas = (double **)malloc(res * sizeof(double *));
    
    for (i = 0; i < res; i++)
        mas[i] = (double *)malloc(res * sizeof(double));
    
    fseek(in, 0, SEEK_SET);
    
    fscanf(in, "%lf", &mas[0][0]);
    fscanf(in, "%lf", &mas[0][1]);
    
    for (i = 2; i < res; i++)
        mas[0][i] = 0.0;
    
    for (i = 1; i < res - 1; i++)
    {
        for (j = 0; j < ((i - 1 <= 0) ? 0 : (i - 1)); j++)
            mas[i][j] = 0.0;
        
        fscanf(in, "%lf", &mas[i][j++]);
        fscanf(in, "%lf", &mas[i][j++]);
        fscanf(in, "%lf", &mas[i][j++]);
        
        for ( ; j < res; j++)
            mas[i][j] = 0.0;
    }
    
    
    for (i = 0; i < res - 3; i++)
        mas[res - 1][i] = 0.0;
    
    fscanf(in, "%lf", &mas[res - 1][res - 2]);
    fscanf(in, "%lf", &mas[res - 1][res - 1]);
    
    if ((out = fopen("out.txt", "w")) == NULL)
        return -1;
    
    for (i = 0; i < res; i++)
    {
        for (j = 0; j < res; j++)
            fprintf(out, "%lf ", mas[i][j]);
        
        fprintf(out, "\n");
    }
    
    fclose(in);
    fclose(out);
    
    for (i = 0; i < res; i++)
        free(mas[i]);
    
    free(mas);
    
    return 0;
}

for (i = 0; i < res; i++)
    {
        for (j = 0; j < res; j++)
            fprintf(out, "%lf ", mas[i][j]);
        
        fprintf(out, "\n");
    }

for (i = 0; i < res; i++)
    {
        for (j = 0; j < res; j++)
            printf("%lf ", mas[i][j]);
        
        printf("\n");
    }