Файл: Курсовая работа по дисциплине Программирование.docx

//---------------------------------------------------------------------------

#include

#pragma hdrstop

#include "mFunit.h"

#include "Gauss.h"

#include "extrapolation.h"

#include

#include

#include

#include

#include

#include

//---------------------------------------------------------------------------

#pragma package(smart_init)

#pragma link "cspin"

#pragma resource "*.dfm"

using namespace std;

TForm1 *Form1;

// Димнамический массив-------------------------------------------------------

typedef float elem_type;

typedef DynamicArray D_Arr;

typedef DynamicArray> D_Matr;

D_Matr MatrG;

D_Arr ArrX, ArrY, ArrLin, ArrPar;

elem_type a_l, b_l, a_par, b_par, c_par;

//---------------------------------------------------------------------------

class TAdditionalSGrid : TStringGrid {

public:

using TStringGrid::DeleteRow;

using TStringGrid::DeleteColumn;

using TStringGrid::MoveColumn;

using TStringGrid::MoveRow;

};

// Метод наименьших квадратов------------------------------------

void MNK(D_Arr &ArrX, D_Arr &ArrY, elem_type &a, elem_type &b){

elem_type xy, am_x, am_y, pow_am_x, pow_x;

int n = ArrX.Length;

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

am_x += ArrX[i];

xy += ArrX[i] * ArrY[i];

pow_am_x += pow(ArrX[i], 2);

am_y += ArrY[i];

}

pow_x = pow(am_x, 2);

a = (n * xy - (am_x * am_y))/(n* pow_am_x - pow_x);

b = (am_y - a * am_x) / n;

}

//Вывод линейной функции на график и в таблицу

void Filling_ArrLin(TStringGrid* StringGrid, D_Arr ArrX,D_Arr &ArrLin, elem_type &a, elem_type &b){

if (StringGrid->RowCount == 2)

StringGrid->RowCount++;

StringGrid->Cells[0][2] = L"Лин.";

ArrLin.Length = ArrX.Length;

for( int i = 0; i <= ArrLin.High; i++){

ArrLin[i] = a*ArrX[i] + b;

StringGrid->Cells[i+1][2] = FloatToStrF(ArrLin[i],ffGeneral,3, 2) ;

}

}

// Вывод квадратичной функции

void Filling_ArrPar(TStringGrid* StringGrid, D_Arr ArrX,D_Arr &ArrPar, elem_type &a, elem_type &b,elem_type &c){

if (StringGrid->RowCount == 3){

StringGrid->RowCount++;

StringGrid->Cells[0][StringGrid->RowCount - 1] = L"Пар.";

}

ArrPar.Length = ArrX.Length;

for( int i = 0; i <= ArrPar.High; i++){

ArrPar[i] = a*pow(ArrX[i],2) + b*ArrX[i] + c;

StringGrid->Cells[i+1][StringGrid->RowCount-1] = FloatToStrF(ArrPar[i],ffGeneral,3, 2) ;

}

}

// Подготовка системы уравнений для метода Гаусса--------------------------------------------------------------------

D_Matr Par(D_Arr &ArrX, D_Arr & ArrY, D_Matr &Matr, elem_type &a_par, elem_type &b_par, elem_type &c_par){

elem_type x_p4, x_p3, x_p2, x, x_p2y, xy, y;

Matr.Length = 3;

//int n =

for(int i = 0; i < Matr.Length; i++)

Matr[i].Length = 4;

for(int i = 0; i < ArrX.Length; i++){

x_p4 += pow(ArrX[i], 4);

x_p3 += pow(ArrX[i], 3);

x_p2 += pow(ArrX[i], 2);

x += ArrX[i];

x_p2y+= pow(ArrX[i],2)* ArrY[i];

xy += ArrX[i] * ArrY[i];

y += ArrY[i];

}

Matr[0][0] = x_p4;

Matr[0][1] = x_p3;

Matr[0][2] = x_p2;

Matr[0][3] = x_p2y;

Matr[1][0] = x_p3;

Matr[1][1] = x_p2;

Matr[1][2] = x;

Matr[1][3] = xy;

Matr[2][0] = x_p2;

Matr[2][1] = x;

Matr[2][2] = ArrX.Length;

Matr[2][3] = y;

}

void LoadOd(AnsiString name){

}

// Проверка корректности данных

bool ChechGrid(TStringGrid *StringGrid,TMainMenu* MainMenu, TButton *Button_Obr,TButton *Save, TMenuItem* Save_as,TMenuItem* C1, TButton *Prognoz, TStatusBar *SB, bool avObr){

int a, b,count = 0;

float c;

a = StringGrid->ColCount -1;

b = 2;

SB->SimpleText = "Некорректные значения в ячейках:";

for( int i = 0; i
for(int j = 0; j< b; j++){

try{

StrToFloat(StringGrid->Cells[i+1][j]);

}

catch(EConvertError &e){

StringGrid->Canvas->Font->Color = clBlack;

SB->SimpleText += L", [" + IntToStr(i+2)+L"]"+ L"[" + IntToStr(j+1)+ L"]";

count++;

//StringGrid->Cells[i+1][j]->SetFocus();

}

}

}

if(count == 0){

SB->SimpleText = "Данные верны";

Button_Obr->Enabled = true;

Save->Enabled = true;

Save_as->Enabled = true;

//Prognoz->Enabled = true;

C1->Enabled = true;

return true;

}

else {

Button_Obr->Enabled = false;

Save->Enabled = false;

Save_as->Enabled = false;

Prognoz->Enabled = false;

C1->Enabled = false;

return false;

}

}

bool Save_to_file(TStringGrid* StringGrid, String name){ //Загрузка данных

fstream file;

file.open(AnsiString(name).c_str(), ios::out | ios::binary);

if(!file.is_open()){

return false;

}

int n = (StringGrid->ColCount - 1)*2;

file.write((char*)&n, sizeof(n));

elem_type f;

for(int i = 0; i < n/2; i++){

f = StrToFloat(StringGrid->Cells[i+1][0]);

file.write((char*)&f, sizeof(elem_type));

}

for(int i = 0; i < n/2; i++){

f = StrToFloat(StringGrid->Cells[i+1][1]);

file.write((char*)&f, sizeof(elem_type));

}

file.close();

return true;

}

//---------------------------------------------------------------------------

bool ChechGridCell(TStringGrid *StringGrid, TButton *Button_Obr, TStatusBar * SB){

try{

StrToFloat(StringGrid->Cells[StringGrid->Col][StringGrid->Row]);

}

catch(EConvertError &e){

StringGrid->Canvas->Font->Color = clBlack;

SB->SimpleText = L" Некорректное значение! ";

StringGrid->EditorMode = true;

//StringGrid->Cells[i+1][j]->SetFocus();

}

}

//Первоначальная настройка таблицы---------------------------------------------------------------------------

__fastcall TForm1::TForm1(TComponent* Owner)

: TForm(Owner)

{

DynamicArray ArrX,ArrY;

Button_Obr->Enabled = false;

Button_Save->Enabled = false;

N4->Enabled = false;

C1->Enabled = false;

StringGrid->ColWidths[0]= 60;

StringGrid->Cells[0][0] = L"X";

StringGrid->Cells[0][1] = L"Y измер.";

SB->SimpleText = L"Заполните таблицу!";

for(int i = 1; i<=10; i++){

StringGrid->Cells[i][0] = IntToStr(i);

}

SB->Panels->Add();

}

//Загрузка файла---------------------------------------------------------------------------

void __fastcall TForm1::Button_OpenClick(TObject *Sender)

{

if(!OD->Execute()){

return;

}

fstream file;

file.open(AnsiString(OD->FileName).c_str(), ios::in | ios:: binary);

if (!file.is_open()){

ShowMessage(L"Ошибка открытия файла!");

return;}

file.seekg(0, ios::end);

int l = file.tellg();

if (l == 0) {

file.close();

ShowMessage(L"Файл пуст!");

return;

}

int n;

file.seekg(0, ios_base::beg);

file.read((char*)&n, sizeof(n));

if(n%2 != 0) {

file.close();

ShowMessage(L"Файл содержит некорректные данные!");

return;

}

if (n * sizeof(elem_type) + sizeof(n) != l) {

file.close();

ShowMessage(L"Файл содержит некорректные данные!");

return;

}

StringGrid->ColCount = n/2 +1;

StringGrid->RowCount = 2;

file.seekg(sizeof(n), ios_base::beg);

elem_type f;

for(int i = 0; i < n/2; i++){

file.read((char*)&f, sizeof(f));

StringGrid->Cells[i+1][0] = FloatToStrF(f,ffGeneral,3, 2);

}

for(int i = 0; i < n/2; i++){

file.read((char*)&f, sizeof(f));

StringGrid->Cells[i+1][1] = FloatToStrF(f,ffGeneral,3, 2);

}

file.close();

//N4->Enabled = true;

//LoadOd(StringGrid, SFile, OD->FilterIndex);

ChechGrid(StringGrid,MainMenu, Button_Obr, Button_Save, N4,C1, Button_Predict, SB, avObr);

}

//Раскраска ячеек таблицы---------------------------------------------------------------------------

void __fastcall TForm1::StringGridDrawCell(TObject *Sender, int ACol, int ARow, TRect &Rect, ////////Цвета

TGridDrawState State)

{

/*if(!color)return;

StringGrid->Canvas->Brush->Color=clYellow;

if (ACol==2 && ARow==2) {

StringGrid->Canvas->FillRect(Rect);

StringGrid->Canvas->TextOut

(Rect.Left, Rect.Top, StringGrid->Cells[ACol][ARow]);

}

*/

TCanvas *a = this->StringGrid->Canvas;

float d;

a->Brush->Color = clWhite;

if (State.Contains(gdFixed)) a->Brush->Color = clMoneyGreen;

try

{

if ((!State.Contains(gdFixed))&&(!TryStrToFloat(StringGrid->Cells[ACol][ARow], d))) a->Brush->Color = clRed;

if ((!State.Contains(gdFixed))&&(StringGrid->Cells[ACol][ARow] == L"")) a->Brush->Color = TColor(RGB(251,251,230));//(TColor)0xFCCFFF;

}catch(...)

{

}

a->FillRect(Rect);

TRect r = Rect;

r.left +=2;

r.top+=2;

DrawText(a->Handle,this->StringGrid->Cells[ACol][ARow].t_str(),-1,(TRect*)&r,DT_CENTER);

}

//Обработчик двойного клика--------------------------------------------------------------------------

void __fastcall TForm1::StringGridDblClick(TObject *Sender)

{

if(StringGrid->Row > 1){

StringGrid->Options >> goEditing;

Clipboard()->AsText = L""; // Блокировка редактирования и копирование результирующей ячейки

Clipboard()->AsText = StringGrid->Cells[StringGrid->Col][StringGrid->Row];

SB->SimpleText = L"Ячейка скопирована!";

return;

}

StringGrid->Options << goEditing;

StringGrid->EditorMode = true;

FCurCellText = StringGrid->Cells[StringGrid->Col][StringGrid->Row];

}

//Обработчик нажатий клавиш---------------------------------------------------------------------------

void __fastcall TForm1::StringGridKeyPress(TObject *Sender, System::WideChar &Key)

{

if(StringGrid->EditorMode == false) return;

if(Key == VK_ESCAPE||Key == VK_RETURN){

if(StringGrid->EditorMode){

if (Key == VK_ESCAPE){

StringGrid->Cells [StringGrid->Col][StringGrid->Row] = FCurCellText;

//if(FCurCellText == L""){

// SB->SimpleText = L"Пустая ячейка";

// Button_Obr->Enabled = false;

//}

StringGrid->EditorMode = false;

return;

}

ChechGrid(StringGrid,MainMenu, Button_Obr, Button_Save, N4,C1, Button_Predict, SB, avObr);

Button_Obr->Click();

return;

}

}

if(!(Key >= L'0'& Key<= L'9' || Key== FormatSettings.DecimalSeparator ||

Key == L'+' || Key == L'-' || Key == L'e' || Key == L'E')&&

Key != VK_BACK && Key != 3/*C_c*/ && Key != 22/*C_v*/&&

Key != 26/*C_z*/){

SB->SimpleText = L"Недопустимый символ '" + UnicodeString(Key)+ L'\'';

Key = 0;

}

else SB->SimpleText = L"";

}

//Дублирует кнопку "Загрузить"---------------------------------

void __fastcall TForm1::N3Click(TObject *Sender)

{

Button_Open->Click();

}

//Проверка формата данных---------------------------

void __fastcall TForm1::StringGridSetEditText(TObject *Sender, int ACol, int ARow,

const UnicodeString Value)

{ if(!StringGrid->EditorMode)return;

String sb = SB->SimpleText;

float d;

if(!TryStrToFloat(StringGrid->Cells[ACol][ARow], d)){

SB->SimpleText = L"\"" + StringGrid->Cells[ACol][ARow] + L"\" Не является корректным";

//Button_Obr->Enabled = false;

}

if(StringGrid->Cells [StringGrid->Col][StringGrid->Row] != FCurCellText)changes_text = true;

else {

changes_text = false;

SB->SimpleText = sb;

}

}

//Проверка данных при смене фокуса ячейки---------------------------------------------------------------------------

void __fastcall TForm1::StringGridSelectCell(TObject *Sender, int ACol, int ARow,

bool &CanSelect)

{

if(!changes_text) return;

ChechGrid(StringGrid,MainMenu, Button_Obr, Button_Save, N4,C1, Button_Predict, SB, avObr);

changes_text = false;

}

//Вставка столбца---------------------------------------------------------------------------

void __fastcall TForm1::Button_InsertClick(TObject *Sender)

{

StringGrid->ColCount++;

((TAdditionalSGrid*)StringGrid)->MoveColumn(StringGrid->ColCount - 1,

StringGrid->Col);

StringGrid->Cols[StringGrid->Col - 1]->Clear();

StringGrid->Col--;

Button_Obr->Click();

}

//Удаление столбца---------------------------------------------------------------------------

void __fastcall TForm1::Button_DeleteClick(TObject *Sender)

{

if (StringGrid->Selection.Left == StringGrid->Selection.Right)

{

if (StringGrid->Col == 1 & StringGrid->Col == StringGrid->ColCount -1 || StringGrid->Col == 0){

Application->MessageBox(String(L"Невозможно удалить данный столбец")

.w_str(), Application->Title.w_str(), MB_OK | MB_ICONERROR);

return;

}

}

((TAdditionalSGrid*)StringGrid)->DeleteColumn(StringGrid->Col);

Button_Obr->Click();

}

// Добавление столбца-------------------------------------------------------------------

void __fastcall TForm1::Button_AddClick(TObject *Sender)

{

if (StringGrid->ColWidths[1] == -1) { // если нет столбцов с данными

StringGrid->ColWidths[1] = StringGrid->DefaultColWidth;

if (StringGrid->RowHeights[1] == -1)

StringGrid->RowHeights[1] = StringGrid->DefaultRowHeight;

StringGrid->ColCount++;

}

else {

StringGrid->Cols[StringGrid->ColCount]->Clear();

StringGrid->Col = StringGrid->ColCount - 1;

StringGrid->ColCount++;

StringGrid->SetFocus();

}

}

//Обработка данных---------------------------------------------------------------------------

void __fastcall TForm1::Button_ObrClick(TObject *Sender)

{ if(!ChechGrid(StringGrid,MainMenu, Button_Obr, Button_Save, N4,C1, Button_Predict, SB, avObr)) {

//Button_Save->Enabled = false;

N4->Enabled = false;

if(OD->FileName ==L"")

C1->Enabled = false;

return;

}

else{

if(OD->FileName !=L""){

//Button_Save->Enabled = true;

C1->Enabled = true;

}

N4->Enabled = true;

}

Chart1->Series[0]->Clear();

Chart1->Series[1]->Clear();

Chart1->Series[2]->Clear();

ArrX.Length =(StringGrid->ColCount-1);

int n = ArrX.Length;

ArrY.set_length(n);

for( int i = 1; i < StringGrid->ColCount; i++){

ArrX[i-1] = StrToFloat(StringGrid->Cells[i][0]);

ArrY[i-1] = StrToFloat(StringGrid->Cells[i][1]);

}

MNK(ArrX, ArrY, a_l, b_l); // Метод наименьших квадратов

Filling_ArrLin(StringGrid, ArrX, ArrLin, a_l, b_l ); // Заполнение массива Lin

Par(ArrX, ArrY, MatrG, a_par, b_par, c_par); // МНК для квадратичной функции

// Флаги на отрисовку графиков

if(CheckBox_M->Checked){

for(int i = 0; i < ArrX.Length; i++)

Chart1->Series[0]->AddXY(ArrX[i], ArrY[i], "", clBlue);

}

if(CheckBox_L->Checked){

for(int i = 0; i < ArrLin.Length; i++)

Chart1->Series[1]->AddXY(ArrX[i], ArrLin[i], "", clRed);

}

if(!Gauss(MatrG, a_par, b_par,c_par)){ // Метод Гаусса

ShowMessage(L"Решение получить невозможно!");

StringGrid->Rows[3]->Clear();

return;

}

Filling_ArrPar(StringGrid, ArrX, ArrPar, a_par, b_par, c_par); //Заполнение массива Par

if(CheckBox_P->Checked){

for(int i = 0; i < ArrPar.Length; i++)

Chart1->Series[2]->AddXY(ArrX[i], ArrPar[i], "", clGreen);

}

Button_Predict->Enabled = true;

}

//Режим редактирования---------------------------------------------------------------------------

void __fastcall TForm1::N8Click(TObject *Sender)

{

if(N8->Checked){

StringGrid->Options << goAlwaysShowEditor;

StringGrid->SetFocus();

StringGrid->Options << goEditing;

StringGrid->EditorMode = true;

}

else {

StringGrid->Options >> goAlwaysShowEditor;

StringGrid->EditorMode = false;

}

}

//Кнопа очистить строку---------------------------------------------------------------------------

void __fastcall TForm1::N5Click(TObject *Sender)

{

for(int i = 0; i < StringGrid->ColCount; i++){

StringGrid->Cols[i+1]->Clear();

}

Button_Obr->Enabled = false;

SB->SimpleText = L"Заполните таблицу!";

ArrX.Length = 0;

ArrY.Length = 0;

ArrLin.Length = 0;

ArrPar.Length = 0;

Chart1->Series[0]->Clear();

Chart1->Series[1]->Clear();

Chart1->Series[2]->Clear();

while(StringGrid->RowCount != 2)

StringGrid->RowCount --;

}

//Кнопка очистить столбец---------------------------------------------------------------------------

void __fastcall TForm1::N6Click(TObject *Sender)

{

StringGrid->Cols[StringGrid->Col]->Clear();

SB->SimpleText = L"Заполните " + IntToStr(StringGrid->Col +1) + L" столбец";

}

//Кнопка очистить таблицу---------------------------------------------------------------------------

void __fastcall TForm1::N7Click(TObject *Sender)

{

for(int i = 0; i < StringGrid->ColCount; i++)

StringGrid->Cells[i+StringGrid->FixedCols][StringGrid->Row] = L"";

SB->SimpleText = L"Заполните " + IntToStr(StringGrid->Row+1 ) + L" строку";

ArrX.Length = 0;

ArrY.Length = 0;

ArrLin.Length = 0;

ArrPar.Length = 0;

Chart1->Series[0]->Clear();

Chart1->Series[1]->Clear();

Chart1->Series[2]->Clear();

while(StringGrid->RowCount != 2)

StringGrid->RowCount --;

}

//Обработчик входа в редактирование ячейки---------------------------------------------------------------------------

void __fastcall TForm1::StringGridGetEditText(TObject *Sender, int ACol, int ARow,

UnicodeString &Value)

{

if(StringGrid->Row > 1){

StringGrid->Options >> goEditing;

return;

}

}

//Отрисовка графиков---------------------------------------------------------------------------

//График1

void __fastcall TForm1::CheckBox_MClick(TObject *Sender)

{

if(CheckBox_M->Checked){

if(ArrY.RefCount > 0){

for(int i = 0; i < ArrX.Length; i++)

Chart1->Series[0]->AddXY(ArrX[i], ArrY[i], "", clBlue);

}

}

if(!CheckBox_M->Checked)

Chart1->Series[0]->Clear();

}

//График2

void __fastcall TForm1::CheckBox_LClick(TObject *Sender)

{

if(CheckBox_L->Checked){

if(ArrLin.RefCount > 0){

for(int i = 0; i < ArrX.Length; i++)

Chart1->Series[1]->AddXY(ArrX[i], ArrLin[i], "", clRed);

}

}

if(!CheckBox_L->Checked)

Chart1->Series[1]->Clear();

}

//График3

void __fastcall TForm1::CheckBox_PClick(TObject *Sender)

{

if(CheckBox_P->Checked){

if(ArrPar.RefCount > 0){

for(int i = 0; i < ArrX.Length; i++)

Chart1->Series[2]->AddXY(ArrX[i], ArrPar[i], "", clGreen);

}

}

if(!CheckBox_P->Checked)

Chart1->Series[2]->Clear();

}

//Сохранить как---------------------------------------------------------------------------

void __fastcall TForm1::N4Click(TObject *Sender)

{

if(!ChechGrid(StringGrid,MainMenu, Button_Obr, Button_Save, N4,C1, Button_Predict, SB, avObr)) return;

if(!(SD->Execute()))return;

String name;

name = AnsiString(SD->FileName).c_str();

if(!Save_to_file(StringGrid, name))

ShowMessage(L"Не удалось создать файл!");

else

ShowMessage(L"Данные успешно сохранены!");;

}

//Перезаписать файл---------------------------------------------------------------------------

void __fastcall TForm1::Button_SaveClick(TObject *Sender)

{

if(OD->FileName == L""){

//Button_Save->Enabled = false;

N4->Click();

return;

}

if(!ChechGrid(StringGrid,MainMenu, Button_Obr, Button_Save, N4,C1, Button_Predict, SB, avObr)) return;

String name;

name = AnsiString(OD->FileName).c_str();

if(!Save_to_file(StringGrid, name))

ShowMessage(L"Ошибка открытия файла!");

else

ShowMessage(L"Файл перезаписан!");

}

//---------------------------------------------------------------------------

void __fastcall TForm1::C1Click(TObject *Sender)

{

Button_Save->Click();

}

//---------------------------------------------------------------------------

void __fastcall TForm1::N9Click(TObject *Sender)

{

Button_Obr->Click();

}

//---------------------------------------------------------------------------

void __fastcall TForm1::Button_PredictClick(TObject *Sender)

{

Form2->Show();

}

//---------------------------------------------------------------------------

void __fastcall TForm1::FormCloseQuery(TObject *Sender, bool &CanClose)

{

if (!Button_Save->Enabled) return;

switch ( Application->MessageBox((String(L"Сохранить исходные данные перед выходом?").w_str()),

Application->Title.w_str(),

MB_YESNOCANCEL|MB_ICONQUESTION))

{

case ID_YES:

Button_Save->Click();

break;

case ID_CANCEL:

CanClose=false;

break;

}

}

//---------------------------------------------------------------------------

//Выход из проги

void __fastcall TForm1::N13Click(TObject *Sender)

{

Form1->Close();

}

//---------------------------------------------------------------------------

1 2 3 4 5 6 7 8 9

8.3 Заголовочный файл “Gauss.h”

//---------------------------------------------------------------------------

#pragma once

#ifndef GaussH

#define GaussH

//---------------------------------------------------------------------------

#endif

typedef float elem_type;

typedef DynamicArray> D_Matr;

bool Gauss(D_Matr &mas, elem_type &a_par, elem_type &b_par, elem_type &c_par);

8.4 Файл реализации “Gauss.cpp”

//---------------------------------------------------------------------------

#pragma hdrstop

#include "Gauss.h"

//---------------------------------------------------------------------------

#pragma package(smart_init)

#include

#include

#include

#include

#include

#include

#include

using namespace std;

typedef float elem_type;

typedef DynamicArray> D_Matr;

bool Gauss(D_Matr &mas, elem_type a_par, elem_type b_par, elem_type c_par);

bool Gauss(D_Matr &mas, elem_type &a_par, elem_type &b_par, elem_type &c_par){

int n = mas.Length;

int m = mas[0].Length;

int k;

float eps = 0.0001;

elem_type* str = new elem_type[m];

for (k = 0; k < n; k++) {

// Ищем максимальный элемент в столбце

int index = 0;

elem_type max = abs(mas[k][k]);

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

if (abs(mas[i][k]) > max) {

max = mas[i][k];

index = i;

}

}

if (max < eps)

{

// нет ненулевых диагональных элементов

return false;

}

//Переставляем строки

if (!(k == n - 1)) {

for (int i = k; i < m; i++) {

str[i] = mas[k][i];

mas[k][i] = mas[index][i];

mas[index][i] = str[i];

}

}

//Делим строку на первый элемент

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

float ak = mas[i][k];

for (int j = k; j < m; j++) {

mas[i][j] /= ak;

}

}

//Вычитаем строку из ниже стоящих

for (int i = k + 1; i < n; i++) {

for (int j = 0; j < m; j++) {

mas[i][j] -= mas[k][j];

}

}

}

// Обратный ход

elem_type* x = new elem_type[n];

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

x[i] = mas[i][n];

for (int i = n - 2; i >= 0; i--)

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

x[i] -= x[j] * mas[i][j];

a_par = x[0];

b_par = x[1];

c_par = x[2];

return true;

}

8.5 Заголовочный файл “extrapolation.h”

//---------------------------------------------------------------------------

#ifndef extrapolationH

#define extrapolationH

//---------------------------------------------------------------------------

#include

#include

#include

#include

#include "cspin.h"

//---------------------------------------------------------------------------

class TForm2 : public TForm

{

__published: // IDE-managed Components

TLabel *Label_X;

TLabel *Label_Lin;

TLabel *Label_Par;

TCSpinEdit *CSpinEdit_X;

TEdit *Edit_Lin;

TEdit *Edit_Par;

void __fastcall CSpinEdit_XKeyPress(TObject *Sender, System::WideChar &Key);

void __fastcall CSpinEdit_XChange(TObject *Sender);

void __fastcall Edit_LinKeyPress(TObject *Sender, System::WideChar &Key);

void __fastcall Edit_ParKeyPress(TObject *Sender, System::WideChar &Key);

private:

float x, lin, par; // User declarations

public: // User declarations

__fastcall TForm2(TComponent* Owner);

};

//---------------------------------------------------------------------------

extern PACKAGE TForm2 *Form2;

//---------------------------------------------------------------------------

#endif

8.6 Файл реализации “extrapolation.сpp”

//---------------------------------------------------------------------------

#include

#pragma hdrstop

#include "extrapolation.h"

#include "mFunit.cpp"

//---------------------------------------------------------------------------

#pragma package(smart_init)

#pragma link "cspin"

#pragma resource "*.dfm"

TForm2 *Form2;

//---------------------------------------------------------------------------

__fastcall TForm2::TForm2(TComponent* Owner)

: TForm(Owner)

{

extern elem_type a_l, b_l, a_par, b_par, c_par;

}

//---------------------------------------------------------------------------

void __fastcall TForm2::CSpinEdit_XKeyPress(TObject *Sender, System::WideChar &Key)

{

if(Key == VK_ESCAPE||Key == VK_RETURN){

if (Key == VK_ESCAPE){

Close();

}

x = StrToFloat(CSpinEdit_X->Text);

lin = a_l*x + b_l;

par = a_par * pow(x,2) + b_par * x + c_par;

Edit_Lin->Text = FloatToStrF(lin, ffGeneral, 3 , 3);

Edit_Par->Text = FloatToStrF(par, ffGeneral, 3 , 3);

return;

}

if(!(Key >= L'0'& Key<= L'9' || Key== FormatSettings.DecimalSeparator ||

Key == L'+' || Key == L'-' || Key == L'e' || Key == L'E')&&

Key != VK_BACK && Key != 3/*C_c*/ && Key != 22/*C_v*/&&

Key != 26/*C_z*/){

Key = 0;

}

}

//---------------------------------------------------------------------------

void __fastcall TForm2::CSpinEdit_XChange(TObject *Sender)

{

x = StrToFloat(CSpinEdit_X->Text);

lin = a_l*x + b_l;

par = a_par * pow(x,2) + b_par * x + c_par;

Edit_Lin->Text = FloatToStrF(lin, ffGeneral, 3 , 3);

Edit_Par->Text = FloatToStrF(par, ffGeneral, 3 , 3);

}

//---------------------------------------------------------------------------

void __fastcall TForm2::Edit_LinKeyPress(TObject *Sender, System::WideChar &Key)

{

if( Key != 3/*C_c*/ ){

Key = 0;

}

}

//---------------------------------------------------------------------------

void __fastcall TForm2::Edit_ParKeyPress(TObject *Sender, System::WideChar &Key)

{

if( Key != 3/*C_c*/ ){

Key = 0;

}

}

//---------------------------------------------------------------------------

1 2 3 4 5 6 7 8 9