Додаток 2 розв’язання системи рівнянь методом гаусса
Подамо початкову систему лінійних рівнянь алгебри (СЛАР) у вигляді
(Д.2.1)
Ділимо
перше рівняння системи (Д.2.1) на
.
У результаті одержимо рівняння
, (Д.2.2)
де
.
З
другого рівняння системи (Д.2.1) віднімемо
рівняння (Д.2.2), помножене на
,
а з третього рівняння системи (Д.2.1) –
рівняння (Д.2.2), помножене на
.
Одержуємо систему
(Д.2.3)
де
.
Ділимо
перше рівняння системи (Д.2.3) на
.
У результаті одержимо рівняння
, (Д.2.4)
де
.
Помножуючи
рівняння (Д.2.4) на
і віднімаючи його з другого рівняння
системи (Д.2.3), одержуємо
,
(Д.2.5)
де
.
Нарешті,
розділивши рівняння (Д.2.5) на
,
одержимо
.
(Д.2.6)
Використовуючи
рівняння (Д.2.4) і (Д.2.2), знаходимо послідовно
значення
і
.
Додаток 3 текст класу рисування графіка
//*************************************************************************/
// Graph.h: interface for CGraph class.
//////////////////////////////////////////////////////////////////////
#pragma once
// Тип даних для зберігання координат точок графіка
typedef CArray<double,double&> TValues;
// Цей тип використовується для уніфікації даних
// функцій, що експортуються
struct TData { double d1, d2, d3; };
//*************************************************************************/
class CGraph
{
double dMinX, dMaxX; // Min-Max значення по горизонталі
double dMinY, dMaxY; // Min-Max значення по вертикалі
double dSpanX; // Розмах графіка по горизонталі
double dSpanY; // Розмах графіка по вертикалі
double dStepX, dStartX; // Крок і початкове значення
double dStepY, dStartY;
UINT nPoints; // Кількість крапок
int N; // Кількість точок експерименту
// Цілочисельні аналоги
UINT nStepsX, nStepX, MinX, MaxX;
UINT nStepsY, nStepY, MinY, MaxY;
UINT *X *Y; // Координати крапок на екрані
int iPowerX, iPowerY; // Експоненти
CRect rect; // Прямокутник висновку
// Три типи шрифтів: для осей,
// заголовка і експонент
CFont TextFont, TitleFont, PowerFont;
public:
CGraph (CRect, UINT, int n);
// Функції нормування вихідних масивів
void ScaleX(TValues&);
void ScaleY(TValues&);
// Масштабування масиву
void Scale (double, int&, double&);
// Зображення координатної сітки
void DrawGrid (CDC*, CString&, CString&, CString&, TValues&, TValues&);
// Зображення графіка залежності
void DrawFunc (CDC*,CPen* RedPen);
virtual ~CGraph();
};
//*************************************************************************/
// Graph.cpp: implementation CGraph class.
//////////////////////////////////////////////////////////////////////
#include "stdafx.h"
//#include "Casc.h"
#include "Graph.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
// Частки екрану, зайняті прямокутником рисунка
const double dXLeft=0.2; // Лівий верхній кут
const double dYTop =0.2;
const double dFracX=0.6; // Ширина і висота
const double dFracY=0.6;
//*************************************************************************/
CGraph::CGraph (CRect r, UINT Pts,int n)
{
rect = r; // Прямокутник висновку в пікселах
// Обмеження числа крапок
nPoints = Pts<=1000 ? Pts : 1000;
N=n;
// Створення шрифтів
TextFont.CreatePointFont(80,"MS Sans Serif");
TitleFont.CreatePointFont(120,"Times New Roman Cyr");
PowerFont.CreatePointFont(80,"Arial");
}
//*************************************************************************/
void CGraph::ScaleX (TValues& x)
{ // Обробка масиву абсцис
UINT i;
for (i=0, dMaxX=x[0], dMinX=x[0]; i<nPoints; i++)
{ // Пошук (min, max)
dMinX = x[i]<dMinX ? x[i]: dMinX;
dMaxX = x[i]>dMaxX ? x[i]: dMaxX;
}
dSpanX = dMaxX - dMinX; // Розмах
// Вибір кроку з (0,1) і експоненти за основою 10
Scale (dSpanX, iPowerX, dStepX);
// Реальний крок
double step = dStepX*pow(10,iPowerX);
// Кількість кроків плюс 1 або 2 кроки (human factor)
nStepsX=(UINT)(dSpanX/step)+ (dMinX ? 2 : 1);
// Цілий крок в пікселах
nStepX =(UINT) (dFracX * rect.Width() / nStepsX +.5);
// Початковий x (dStartX) повинен бути кратний кроку
double d = dMinX/step;
dStartX = d ? step * сеil (d-1.) : 0.; // Human factor
MinX = (UINT) (dXLeft * rect.Width()); // Початковий x (піксел)
MaxX = MinX + nStepsX * nStepX; // Кінцевий x (піксел)
X = new UINT [nPoints]; // Масив абсцис (піксел)
// Заповнюємо масив абсцис (піксел)
for (i=0; i<nPoints; i++)
X[i]= MinX+(UINT)((x[i]-dStartX)*nStepX/step);
// Коректуємо початкове значення (мантису)
dStartX /= pow (10,iPowerX);
}
//*************************************************************************/
void CGraph::ScaleY (TValues& y)
{
// Те ж, але для осі ординат
// Тут є відмінності від випадку осі абсцис
UINT i;
for (i=0, dMaxY=y[0], dMinY=y[0]; i<nPoints; i++)
{
dMinY = y[i]<dMinY ? y[i]: dMinY;
dMaxY = y[i]>dMaxY ? y[i]: dMaxY;
}
dSpanY = dMaxY-dMinY;
Scale (dSpanY, iPowerY, dStepY);
double step = dStepY*pow(10,iPowerY);
nStepsY= (UINT)(dSpanY/step) + (dMinY ? 2 : 1);
nStepY = (UINT) (dFracY * rect.Height() / nStepsY +.5);
// не враховуємо особливості сприйняття (human factor)
dStartY = step * (сеil (dMaxY/step));
MinY = (UINT) (dYTop * rect.Height());
MaxY = MinY + nStepsY * nStepY;
Y = new UINT [nPoints];
for (i=0; i<nPoints; i++)
Y[i]= MinY+(UINT)((dStartY-у[i])*nStepY/step);
dStartY /= pow (10,iPowerY);
}
//*************************************************************************/
void CGraph::Scale (double span, int& pow, double& step)
{
// Пошук мантиси (кроку) і експоненти
pow=0;
// Заганяємо мантису в діапазон (1,10)
if (0.<span && span<1.)
for ( ; span<1.; span*=10., pow--)
; // Множенням на 10 або
else if (span>10.) // діленням на 10
for ( ; span>10.; span/=10., pow++)
;
if (span<1.1) // Вибір одного із стандартних
step=.1; // значень для кроку
else if (span<2.1)
step=.2;
else if (span<2.6)
step=.25;
else if (span<5.1)
step=.5;
else
step=1.;
}
//*************************************************************************/
CGraph::~CGraph ()
{
delete [] X; // У деструкторі звільняємо пам'ять, зайняту
delete [] Y; // цілочисловими аналогами вихідних масивів
}
//*************************************************************************/
void CGraph::DrawGrid (CDC* dc, CString& Title
CString& Xlab, CString& Ylab,TValues& xGr, TValues& yGr)
{
// Рисуємо координатну сітку й написи
dc->SelectObject(&TextFont); // Основний шрифт
TEXTMETRIC tm; // Метрики шрифту
dc->GetTextMetrics (&tm);
ScaleX (xGr); // Масштабуємо абсциси
ScaleY(yGr); // Масштабуємо ординати
UINT x, y, i // Робочі змінні
LW=tm.tmMaxCharWidth // Середня ширина букви
LH=tm.tmHeight // Середня висота букви
h2=LH/2, h4=LH/4 // Частки ширини (для підстроювання)
w2=LW/2, w4=LW/4 // Частки висоти
ww=LW+LW, hh=LH+LH // Подвоєні ширина і висота
xy=MinX-ww // X-координата шкали осі Y
yx=MaxY+h2 // Y-координата шкали осі X
xh=MaxX+ww // X-координата заголовка осі X
yh=MinY-hh; // Y-координата заголовка осі Y
double d; // Робочі змінні
CString s;
dc->SetBkMode(TRANSPARENT); // Фон тексту – прозорий
dc->SetTextAlign(TA_CENTER); // Вирівнювання – по центру
for (i=0, x=MinX, d=dStartX; // Розмітка осі X
i<=nStepsX;
x+=nStepX, d+=dStepX, i++)
{
dc->MoveTo(x,MinY);
dc->LineTo (x,MaxY); // Зображення осі X
s.Format("%3.1f",d);
dc->TextOut (x, юшок, s); // Оцифровка шкали осі X
}
// Розмітка осі Y
for (i=0, y=MinY, d=dStartY;
i<=nStepsY;
y+=nStepY, d-=dStepY, i++)
{
dc->MoveTo(MinX, y);
dc->LineTo(MaxX, y);
s.Format("%5.1f",d);
dc->TextOut(xy,y-h2,s);
}
// Виведення діапазону зміни ординат
s.Format("Range = (%.3g, %.3g)",dMinY,dMaxY);
dc->TextOut((MinX+MaxX)/2,yh+h2,s);
// Виведення найменувань осей
dc->TextOut (MinX+w2,yh-h2,Ylab);
dc->TextOut (xh+w2,yx,Xlab);
// Вибираємо більш дрібний шрифт
dc->SetTextColor (RGB(0,0,255));
dc->SelectObject(&PowerFont);
// Рамка навкруги експоненти осі Y
dc->RoundRect(xy-w2-w2,yh-LH,xy+LW+w2,yh+LH,h2,h2);
dc->TextOut(xy,yh-h4,"10");
// Рамка навкруги експоненти осі X
dc->RoundRect(xh-w2-w2,yx-hh-h2,xh+LH+w4,yx-h2,h2,h2);
dc->TextOut(xh,yx-hh+h4,"10");
// Виведення експонент осей Y і X
s.Format("%d",iPowerY);
dc->TextOut(xy+w2+w4,yh-LH,s);
s.Format("%d",iPowerX);
dc->TextOut(xh+w2+w4,MaxY-hh,s);
// Вибираємо крупний шрифт і
// виводимо заголовок усього графіка
dc->SelectObject(&TitleFont);
dc->TextOut((MinX+MaxX)/2,yh-ww,Title);
}
// ******************* Зображення кривої Y (X) ************************/
void CGraph::DrawFunc (CDC* dc,CPen* RedPen)
{
dc->MoveTo(X[0], Y[0]); // Ставимо перо в першу крапку
// і з’єднуємо послідовно всі крапки
for (UINT i=0; i < nPoints-N-1; i++)
{
dc->LineTo (X[i], Y[i]);
}
int ind=i-1;
CPen* oldPen;
CGdiObject* oldBrush;
oldPen=dc->SelectObject(RedPen);
COLORREF color=RGB(255,0,0);
oldBrush=dc->SelectStockObject(BLACK_BRUSH);
for (i=0; i<=N; i++)
{
ind++;
dc->MoveTo (X[ind], Y[ind]);
dc->Ellipse(X[ind]-6, Y[ind]-6,X[ind]+6, Y[ind]+6);
}
dc->SelectObject(oldPen);
dc->SelectObject(oldBrush);
}
//*************************************************************************/