Аппроксимация и интерполяция

  printf("\n");

  solvegauss(&g, &s, &res);//вызов функции решения системы

  outsolve(res, &g, &s); //вывод решения на экран

  freemem(&g, &s, res); //освобождение выделенной памяти

  

  if(heapcheck() != _HEAPOK) //проверка на целостность

  {      //кучи

    printf("ERROR!!!");

    while(!getch());

  }

}

 

func.h

#define IN "INPUT.TXT"

#define EPS 0.0000001

/*-------------------------------------------------------*/

struct slau //структура, хранящая параметры системы

{

  float **A, *b;

  int n;

};

struct slv //структура, хранящая решение системы

{

  float *x, **B;

  int num, *per;

};

/*-------------------------------------------------------*/

void menu(int *ch);         //функция меню

void myexit();              //функция заморозки экрана

void freemem(slau *g, slv *s, int res);              //функция освобождение памяти

void fileinput(slau *g, slv *s);                          //функция считывания системы из файла

void manualinput(slau *g, slv *s);                        //функция ввода системы вручную

void autoinput(slau *g, slv *s);                          //функция генерации системы случайным образом

void changerowcol(slau *g, int k, int p, int q, slv *s);  //функция перестановки строк и столбцов в матрице системы

float maxelement(slau *g, int k, slv *s);                 //функция поиска максимального по модулю элемента в подматрице

int ressolving(slau *g, slv *s);                          //функция определения вида решения

void changerowcolB(slau *g, slv *s);                      //функция перестановки строк в матрице базисов

void changerowx(slau *g, slv *s);                         //функция перестановки элементов в векторе решений x

void solvegauss(slau *g, slv *s, int *res);               //функция решения системы методом Гаусса

void printB(slau *g, slv *s);                             //функция вывода на экран матрицы базисов

void outsolve(int res, slau *g, slv *s);                  //функция вывода решения системы на экран

void printm(slau *g);                                     //функция вывода расширенной матрицы системы на экран

/*-------------------------------------------------------*/

 

func.cpp

#include <conio.h>

#include <stdio.h>

#include <math.h>

#include <stdlib.h>

#include <alloc.h>

#include "func.h" //подключение заголовочного файла

/*-------------------------------------------------------*/

void menu(int *ch)

{

  clrscr();

  textcolor(13);

  printf("METHOD GAUSS\r\n"); //вывод меню выбора

  textcolor(10);

  printf("\r\nIf you want to exit, press ");

    textcolor(LIGHTCYAN); printf("0");

    textcolor(10);

  printf("\r\nTo input system manually, press ");

    textcolor(LIGHTCYAN); printf("1");

    textcolor(10);

  printf("\r\nTo download system from file, press ");

    textcolor(LIGHTCYAN); printf("2");

    textcolor(10);

  printf("\r\nTo generate system in a random way, press ");

    textcolor(LIGHTCYAN); printf("3\n");

  textcolor(WHITE);

  printf("\r\nyour choice? -> ");

  scanf("%d", ch); //выбор пользователя

}

/*-------------------------------------------------------*/

void myexit()

{ textcolor(LIGHTGREEN); //конец программы

  printf("\n\nPress any key to exit...");

  while(!getch()); //задержка программы

}

/*-------------------------------------------------------*/

void fileinput(slau *g, slv *s) //функция ввода системы

{       //из файла

  FILE *fin;

  int i, j, n;

  float a;

  fin = fopen(IN, "r"); //открытие файла

  if(fin == NULL)

  {

    perror("Error");

    exit(1);

  }

  fscanf(fin, "%d", &n); //порядок матрицы

  g->n = n;

  g->A = (float**)malloc((g->n) * sizeof(float*));

  if(g->A==NULL) //выделение памяти под матрицу системы

  {

    printf("no memory");

    exit(1);

  }

  for(i = 0; i < g->n; i++)

  {

    g->A[i] = (float*)malloc(g->n * sizeof(float));

    if(g->A[i] == NULL)

    {

      printf("no memory");

      exit(1);

    }

    for(j = 0; j < g->n; j++)

    {

      if(fscanf(fin, "%f", &a) == NULL)  //считывание

      {      //очередного элемента

        printf("\nerror reading the file");

        fclose(fin);

        exit(1);

      }

      else

      {

        g->A[i][j] = a;

      } 

    }

  }  //выделение памяти под вектор свободных членов

  g->b = (float*)malloc(g->n * sizeof(float));

  for(i = 0; i < g->n; i++)

  {

    fscanf(fin, "%f", &(g->b[i]));

  }

//выделение памяти и заполнение вектора перестановок

  s->per = (int*)(malloc)(g->n * sizeof(int));

  for(i = 0; i < g->n; i++)

  {

    s->per[i] = i;

  }

  fclose(fin); //закрытие файла

}

/*-------------------------------------------------------*/

//ручной ввод системы

void manualinput(slau *g, slv *s)

{

  int i, j;

  float a;

  printf("vvedite poryadok matricy  n = ");

  scanf("%d", &g->n); //ввод порядка системы

  printf("\n");

//выделение памяти  и считывание матрицы системы

  g->A = (float**)malloc((g->n) * sizeof(float*));

  if(g->A==NULL)

  {

    printf("no memory");

    exit(1);

  }

  for(i = 0; i < g->n; i++)

  {

    g->A[i] = (float*)malloc(g->n * sizeof(float));

    if(g->A[i] == NULL)

    {

      printf("no memory");

      exit(1);

    }

    for(j = 0; j < g->n; j++)

    {

      printf("A[%d][%d] = ", i, j);

      scanf("%f", &a);

      g->A[i][j] = a;

    }

  }

  printf("\n"); //выделение памяти и считывание вектора

  g->b = (float*)malloc(g->n * sizeof(float));//свободных

  for(i = 0; i < g->n; i++)    //членов

  { 

    printf("b[%d] = ", i);

    scanf("%f", &a);

    g->b[i] = a;

  } 

//выделение памяти  и заполнение вектора перестановок

  s->per = (int*)(malloc)(g->n * sizeof(int));

  for(i = 0; i < g->n; i++)

  {

    s->per[i] = i;

  }

}

/*-------------------------------------------------------*/

void autoinput(slau *g, slv *s)

{ //автоматическое заполнение системы

  printf("\nvvedite poryadok matricy n = ");

  scanf("%d", &g->n);

  int i, j;

  g->A = (float**)malloc((g->n) * sizeof(float*));

  if(g->A==NULL)

  {

    printf("no memory");

    exit(1);

  }

  for(i = 0; i < g->n; i++)

  {

    g->A[i] = (float*)malloc(g->n * sizeof(float));

    if(g->A[i] == NULL)

    {

      printf("no memory");

      exit(1);

    }

    for(j = 0; j < g->n; j++)

    {

      g->A[i][j] = random(10) + 1;

    }

  }

  g->b = (float*)malloc(g->n * sizeof(float));

  for(i = 0; i < g->n; i++)

  {

    g->b[i] = random(10) + 1;

  }

  s->per = (int*)(malloc)(g->n * sizeof(int));

  for(i = 0; i < g->n; i++)

  {

    s->per[i] = i;

  }

}

/*-------------------------------------------------------*/

//перестановка строк  и столбцов в матрице системы

void changerowcol(slau *g, int k, int p, int q, slv *s)

{

  int i, d;

  float buf;

  if(k != p) //если максимальный по модулю элемент

  { //находится в другой строке, то переставляем их

    for(i = 0; i < g->n; i++)

    {

      buf = g->A[k][i];

      g->A[k][i] = g->A[p][i];

      g->A[p][i] = buf;

    }

    buf = g->b[k];

    g->b[k] = g->b[p];

    g->b[p] = buf;

  }

  if(k != q) //если максимальный по модулю элемент

  { //находится в другом столбце, то переставляем их

    for(i = 0; i < g->n; i++) //и переставляем строки в

    {   //векторе перестановок

      buf = g->A[i][k];

      g->A[i][k] = g->A[i][q];

      g->A[i][q] = buf;

    }

    d = s->per[k];

    s->per[k] = s->per[q];

    s->per[q] = d;

  }

}

/*-------------------------------------------------------*/

//поиск максимального  по модулю элемента

float maxelement(slau *g, int k, slv *s)

{

  int i, j, p, q;

  float buf = 0.0, d = g->A[k][k];

  for(i = k; i < g->n; i++)

  {

    for(j = k; j < g->n; j++)

    {

      if(fabs(g->A[i][j]) >= buf)

      {

        buf = fabs(g->A[i][j]);

        p = i;

        q = j;

        d = g->A[i][j];

      }

    }

  } //если нашелся такой элемент, который по модулю

  //больше, чем искомый,  переставляем строки и столбцы

  if(buf > EPS) changerowcol(g, k, p, q, s);

  return d; //возвращаем этот элемент

}

/*-------------------------------------------------------*/

//определение вида решения

int ressolving(slau *g, slv *s)

{

  int i = 0, k;

  int n = g->n;

  while(g->A[i][i] != 0.0 && i < n)

    ++i;

  s->num = g->n - i;

  if(i == n) return 0;

  for(k = i; k < n; k++)

  {

    if(g->b[k] != 0.0) return 1;

  }

  return 2;

}

/*-------------------------------------------------------*/

void changerowcolB(slau *g, slv *s)

{     //перестановка строк в матрице

  int i, j, nn, k, bf; //базисов в соответствии

  float buf;   //с вектором перестановок

  nn = 1 + 2 * s->num;

  for(i = 0; i < g->n; i++)

  {

    while(s->per[i] != i)

    {

      k = s->per[i];

      for(j = 0; j < nn; j++)

      {

        buf = s->B[i][j];

        s->B[i][j] = s->B[k][j];

        s->B[k][j] = buf;

      }

      bf = s->per[i];

      s->per[i] = s->per[k];

      s->per[k] = bf;

    }

  }

}

/*-------------------------------------------------------*/

void changerowx(slau *g, slv *s)

{    //перестановка элементов в

  int k, bb, i; //векторе решений

  float bf;  //в соответствии с вектором

  for(i = 0; i < g->n; i++) //перестановок

  {

    while(s->per[i] != i)

    {

      k = s->per[i];

      bf = s->x[i];

      s->x[i] = s->x[k];

      s->x[k] = bf;

      bb = s->per[i];

      s->per[i] = s->per[k];

      s->per[k] = bb;

    }

  }

}

/*-------------------------------------------------------*/

//решение системы методом  Гаусса

void solvegauss(slau *g, slv *s, int *res)

{

  int n = g->n;

  int i, j, w;

  float maxel = 0.0, bf, q;

  for(i = 0; i < n; i++)

  {

    maxel = maxelement(g, i, s); //поиск макс по модулю

//элемента

   if(fabs(maxel) < EPS) break; //если макс по модулю

//элемент слишком мал,  то выходим из цикла

    for(j = i + 1; j < n; j++)

    {

      q = g->A[j][i] / maxel; //преобразование строк

      for(w = i; w < n; w++) //расширенной матрицы

      {

        bf = g->A[j][w];

        g->A[j][w] = bf - g->A[i][w] * q;

      }

      bf = g->b[j];

      g->b[j] = bf - g->b[i] * q;

    }

    for(j = 0; j < i; j++) //приведение матрицы к

    {     //единичной

      q = g->A[j][i] / g->A[i][i];

      for(w = i; w < n; w++)

      {

        g->A[j][w] = g->A[j][w] - g->A[i][w] * q;

      }

      g->b[j] = g->b[j] - g->b[i] * q;

    }

    g->b[i] = g->b[i] / (g->A[i][i]);

    q = g->A[i][i];

    for(w = i; w < n; w++)

    {

      g->A[i][w] = g->A[i][w] / q;

    }

  }

  *res = ressolving(g, s); //определяем вид решения

  if(*res == 2) //если бесконечное множество решений,

  {  //то заполняем матрицу базисов

    s->B = (float**)malloc(g->n * sizeof(float*));

    if(s->B==NULL)

    {

      printf("no memory");

      exit(1);

    }

    for(i = 0; i < g->n; i++)

    {

      s->B[i] = (float*)malloc((1 + s->num * 2) * sizeof(float));

      if(s->B[i] == NULL)

      {

        printf("no memory");

        exit(1);

      }

    }

    for(i = 0; i < g->n; i++)

    {

      s->B[i][0] = g->b[i];

    }

    for(i = 1; i <= s->num; i++)

    {

      for(j = 0; j < n ; j++)

      {

        s->B[j][i] = - g->A[j][g->n - s->num + i - 1];

        s->B[j][i + s->num] = 0;

      }

    }

    for(i = 0; i < s->num; i++)

    {

      s->B[g->n - i - 1][2 * s->num - i] = 1;

    }

    changerowcolB(g, s);

  }

  if(*res == 0) //если единственное решение, то

  {   //заполняем вектор x

    s->x = (float*)malloc(g->n * sizeof(float));

    for(i = 0; i < g->n; i++)

    {

      s->x[i] = g->b[i];

    }

    changerowx(g, s);

  }

}

/*-------------------------------------------------------*/

void printB(slau *g, slv *s)

{  //вывод матрицы базисов на экран

  textcolor(WHITE);

  printf("\r\n");

  int i, j;

  for(i = 0; i < g->n; i++)

  {

    for(j = 0; j < 1 + 2 * s->num; j++)

    {

      if(j == 1) printf("|");

      if(j == 1 + s->num) printf("|");

      printf("%6.3f ", s->B[i][j]);

      if(j == 2 * s->num) printf("|");

    }

    printf("\r\n");

  }

}

/*-------------------------------------------------------*/

void outsolve(int res, slau *g, slv *s)

{   //вывод решения на экран

  switch(res)

  {

    case 0:

    {

      textcolor(LIGHTMAGENTA);

      printf("\r\nreshenie sistemy: ");

      printf("\r\n");

      for(int i = 0; i < g->n; i++)

      {

        printf("\r\nx[%d] = %6.3f", i, s->x[i]);

      }

      break;

    }

    case 1:

    {

      textcolor(CYAN);

      printf("\r\nSystem has no solutions");

      break;

    }

    case 2:

    {

      textcolor(CYAN);

   printf("\r\nSystem has an infinite set of solutions. ");

      printf("\r\nSystem has %d basic unknown quantities\r\n", s->num);

      printB(g, s);

      break;

    }

  }

  printf("\r\n");

}

/*------------------------------------------------*/

void printm(slau *g)

{  //вывод расширенной матрицы системы на экран

  textcolor(WHITE);

  printf("\n");

  int i, j;

  for(i = 0; i < g->n; i++)

  {

    printf("|");

    for(j = 0; j < g->n; j++)

    {

      printf("%4.1f ", g->A[i][j]);

    }

    printf(" | ");

    printf("   %4.1f", g->b[i]);

    printf("\r\n");

  }

}