-абсолютная величина целого хж
квадрат значения х;
целая часть вещественной величины х;
целое число, полученное из вещественного ч по правилу округления;
случайное целое число из интервала от 0 до х
Множество всех символов образуют
символьные величины (тип char), которые являются упорядоченными.
Выражения - это конструкции,
задающие правила вычисления значений переменных. В общем случае выражения
строятся из переменных, констант, функций с помощью операций и скобок.
Эта роль выражения отражена в
основном операторе языка - операторе присваивания. Он имеет следующий вид:
<имя переменной>: =<выражение>
Тип переменной и тип выражения
должны быть согласованы (величины принадлежат к одному и тому же типу).
В Паскале можно вводить с
клавиатуры числовые и символьные данные. Имеются две встроенные процедуры (подпрограммы)
ввода:
1) read (< список
переменных>);
2) readln
(<список переменных>).
Процедура readln отличается от
read только тем, что при завершении ввода курсор перемещается в начало строки.
Программа на Паскале может
выводить на экран или на принтер значения числовых или символьных выражений. Имеются
две процедуры вывода на экран:
1) write (<список
выражений>);
2) writeln (<список
выражений>).
Процедура write (x1,x2,x3,…xn) печатает на экран значения выражения из списка х1, х2,…хn.
Для вывода на принтер используются те же процедуры с добавлением служебного
слова lst перед списком выражений:
Пример: write
(lst,’ нет решений‘);
Паскаль - это язык структурного
программирования. Это значит, что программа должна выражать свои мысли очень
дисциплинированно, с использованием малого числа четко оговоренных конструкций,
используя как чередование их, так и вложения друг в друга. Не рекомендуется (хотя
и возможно) использовать оператор перехода goto.
Реализация последовательности
действий (т.е. структуры следования) выполняется с помощью составного оператора:
Begin
<последовательность операторов> end
Раздел операторов в программе
всегда является составным оператором. Служебные слова begin и end часто
называют операторными скобками.
Для реализации развилки в
Паскале предусмотрены два оператора: условный оператор и оператор варианта (выбора).
Они предназначены для выделения из составляющих их операторов одного, который и
выполняется.
Структура и действие условного
оператора таковы:
IF < логическое
выражение>
Then
<оператор 1 >
Else
< оператор 2>
Условный оператор может быть
неполным, т.е. не содержать часть “else <оператор
2>". В этом случае, если значение логического выражения равно false,
условный оператор не вызывает никаких действий.
Оператор варианта имеет
следующую форму:
Case
<выражение> of
<список констант 1>: <оператор
1>;
<список констант 2>: <оператор
2>;
………………………………………
<список констант n>: <оператор n>;
end;
Выражение, стоящее между
служебными словами case и of, должно иметь значение ординального типа. Любой
список констант может состоять из одной константы.
Оператор варианта вычисляет
значение выражения, записанного после case. Если его значение совпадает с одной
из констант в некотором списке, то выполняется оператор, стоящий после этого
списка. Если значение выражения не совпало ни с одной константой во всех
вариантах, то оператор варианта ничего не делает.
Для реализации циклов в Паскале
имеются три оператора. Если число повторений известно заранее, то удобно
воспользоваться оператором цикла с параметром. В других случаях следует использовать
операторы цикла с предусловием (цикл "пока") или с постусловием (цикл
"до").
Цикл с предусловием является
наиболее мощным в Паскале. Другие операторы цикла можно выразить через него. Его
форма такова:
While
< логическое выражение> do <оператор >
Действие: вычисляется значение
логического выражения. Если оно равно true, то выполняется оператор, после чего
снова вычисляется значение логического выражения, в противном случае действие
заканчивается.
Оператор цикла с постусловием
имеет форму:
Repeat
<последовательность операторов >
Until
< логическое выражение>
Действие: выполняется
последовательность операторов. Далее вычисляется значение логического выражения.
Если оно равно true, то действие заканчивается, в противном случае снова
выполняется последовательность операторов цикла и т.д.
Оператор цикла с параметром
предусматривает повторное выполнение некоторого оператора с одновременным
изменением по правилу арифметической прогрессии значения управляющей переменной
(параметра) этого цикла. Оператор цикла с параметром имеет две формы.
Форма 1:
For <
параметр>: = < выражение 1 > to < выражение
2 > do < оператор>
Параметр, выражение 1, выражение
2 должны быть одного ординального типа. Параметр в этом цикле возрастает. Действие
эквивалентно действию следующего составного оператора:
Begin
< параметр >: =
<выражение 1 >;
while
< параметр> <= < выражение 2> do
begin
< оператор>;
<параметр >: = succ (<параметр >)
end
end.
Если в этом описании отношение
<= заменить на >=, а функцию succ на pred, то параметр в цикле будет
убывать, в этом случае цикл с параметром принимает форму 2.
Форма 2:
For <
параметр>: = < выражение 1 > downto <
выражение 2 > do < оператор>
В Паскале кроме простых типов
данных: real, integer, boolean, byte, char, программист по своему желанию может
определить новый тип путем перечисления его элементов - перечисляемый тип,
который относится к простым ординальным типам.
Описание перечисляемого типа
выполняется по схеме:
Type
< имя типа> = <список имен >
Например, type
operator = (plus, minus, multi, divide);
Интервальный тип - это
подмножество другого уже определенного ординального типа, называемого базовым. Интервал
можно задать в разделе типов указанием наименьшего и наибольшего значений,
входящих в него и разделяющихся двумя последовательными точками, например:
Type days = (mon,
tue, wed, thu, fri, sat, sun);
Workdays=
mon. fri;
Index=1.
.30;
Операции и функции - те же, что
и для базового типа. Использование интервальных типов в программе позволяет
экономить память и проводить во время выполнения программы контроль
присваивания.
Естественно и часто очень удобно
группировать однотипные данные в последовательности - массивы, строки символов,
объединять разнотипные данные в одном и том же объекте в виде записей. Значительное
удобство представляются пользователю в Паскале при организации однотипных
величин в виде множества с соответствующим набором операций: объединения,
пересечения и т.д. Последовательность однотипных величин переменной длины можно
представить в Паскале в виде файла данных и хранить на внешних носителях,
используя его в разных программах.
Массив -это последовательность,
состоящая из фиксированного числа однотипных элементов. Все элементы массива
имеют общее имя и различаются индексами. Индексы можно вычислять, их тип должен
быть ординальным. В описании массива используются служебные слова array и of. В
описании массива указывается тип его элементов и типы их индексов.
Все имена, описанные в программе
до процедуры, действуют во всей программе и в любой ее подпрограмме. Они
называются глобальными, в отличии от локальных имен, описанных в процедуре и
действующих лишь в ней.
Данные для обработки могут
передаваться процедуре через глобальные имена или через аргументы процедуры. В
процедуре каждый аргумент имеет свое имя - формальный параметр, описываемый в
заголовке процедуры по схеме
Procedure
< имя > (<список формальных параметров >)
Описание формальных параметров
может иметь вид
<список имен >: <
тип> или var < список имен>: < тип>
Оператор вызова процедуры имеет
вид
< имя процедуры> (<
список выражений>);
Указанные выражения называются
фактическими параметрами. Их список должен точно соответствовать списку
описаний формальных параметров процедуры. Во время вызова процедуры каждому
параметру-значению присваивается значение соответствующего фактического
параметра и поэтому их используют для передачи входных данных. Параметры -
переменные используются для представления результатов процедуры.
Функция - это подпрограмма,
определяющая единственное скалярное, вещественное или строковое значение. Отличия
подпрограммы - функции от процедуры:
заголовок функции начинается со
служебного слова function и заканчивается указанием типа значения функции:
function
< имя> (список описаний формальных параметров): < тип>;
раздел операторов функции должен
содержать хотя бы один оператор присваивания имени функции;
обращение к функции - не
оператор, а выражение вида:
< имя функции> (<
список фактических параметров>)
Для решения систем линейных
уравнений методом Гаусса и матричным методом создана программа на языке Паскаль.
Программа запрашивает исходные данные (рис.1):
матрицу коэффициентов при
неизвестных х;
столбец свободных членов
способ решения системы линейных
уравнений - вариант 1 или 2.
Рисунок 3.1 Ввод исходных данных
В зависимости от выбранного
вариант в программе происходит решение системы уравнений методом Гаусса (рис.2)
или матричным методом (рис.3) с выдачей на экран результатов:
Рисунок 3.2 Результаты расчетов
системы линейных уравнений методом Гаусса.
Рисунок 3.3 Результаты расчетов
системы линейных уравнений матричным методом.
Программа состоит из 7
подпрограмм - 6 процедур и одной функции:
процедура Gauss обеспечивает
решение системы линейных уравнений по методу Гаусса;
процедура matrica обеспечивает
решение системы линейных уравнений матричным методом;
процедура PrintMatr2
предназначена для выдачи на экран исходной и обратной матрицы;
процедура MultString
предназначена для умножения строк матрицы на число r;
процедура AddStrings прибавляет
к i1-ой строке матрицы i2-ю,
умноженную на число r;
процедура MultMatr предназначена
для умножения матриц.
Функция Sign используется для
изменения знака на противоположный при вычислении обратной матрицы.
Программа настроена на решение
системы 3-х линейных уравнений с тремя неизвестными. Чтобы решить систему из
2-х уравнений с 2-мя неизвестными необходимо в программе изменить значение
константы N с N=3 на N =2 (рис.4).
Рисунок 3.4. Фрагмент программы
с описанием констант и переменных.
Заключение
В данной курсовой работе
рассмотрены математические методы решения систем линейных уравнений: матричный
метод и метод Гаусса, приводятся основные конструкции языка Паскаль. Рассмотренные
теоретические вопросы дают возможность создания программы на Паскале для
решения систем линейных уравнений. В курсовой работе приводится текст данной
программы, рассматривается структура программы, анализируются все подпрограммы.
Данная программа может быть использована в различных областях, где требуется
решение систем линейных уравнений.
1.
А.В. Могилев, Н.И. Пак, Е.К. Хеннер "Информатика", Москва,
ACADEMA, 2000 г.
2.
"Турбо Паскаль 7.0", Киев, Торгово-издательское бюро BHV, 1997г.
3.
С.А. Немнюгин, "Турбо ПАСКАЛЬ", Практикум, Питер, 2002г.
Текст программы
"Решение систем линейных
уравнений матричным способом и методом Гаусса"
Program Lin_yravneniya;
uses crt;
const N=3;
eps=0.00001; {
all numbers less than eps are equal 0 }
type matr=array
[1. n,1. n] of real;
mas=array [1. n]
of real;
var
i,j: integer;
b,x: mas;
variant: byte;
a,c: matr;
dt: real;
imx,np: integer;
{*** печать исходной и обратной
матрицы*** }
procedure
PrintMatr2 (m,m1: matr; n,nz,nd: integer);
var i,j: integer;
begin
for i: =1 to n
do
begin
if (i=1) then
write (np: 2,': ')
else write (' ');
for j: =1 to n
do
write (m [i,j]:
nz: nd); write (' ');
write (m1 [i,j]:
nz: nd);
writeln;
end;
inc (np);
end;
procedure
MultString (var a,b: matr; i1: integer; r: real);
var j: integer;
begin
for j: =1 to n
do
begin
a [i1,j]: =a [i1,j]
*r;
b [i1,j]: =b [i1,j]
*r;
end;
end;
procedure
AddStrings (var а,b: matr; i1, i2: integer; r: real);
{ процедура прибавляет к i1
строке матрицы а i2-ю умноженную на r}
var j: integer;
begin
for j: =1 to n
do
begin
a [i1,j]: =a [i1,j]
+r*a [i2,j] ;
b [i1,j]: =b [i1,j]
+r*b [i2,j] ;
end;
end;
procedure
MultMatr (a,b: matr; var c: matr);
var i,j,k: byte;
s: real;
begin
for i: =1 to n
do
for j: =1 to n
do
begin
s: =0;
for k: =1 to n
do
s: =s+a [i,k] *b
[k,j] ;
c [i,j]: =s;
end;
end;
function sign (r:
real): shortint;
begin
if (r>=0) then
sign: =1 else sign: =-1;
end;
{***************************************************}
{** вычеркивание из матрицы
строки и столбца **}
procedure
GetMatr (a: matr; var b: matr; m, i,j: integer);
var ki,kj,di,dj:
integer;
begin
di: =0;
for ki: =1 to
m-1 do
begin
if (ki=i) then
di: =1;
dj: =0;
for kj: =1 to
m-1 do
begin
if (kj=j) then
dj: =1;
b [ki,kj]: =a [ki+di,kj+dj]
;
end;
end;
end;
{*** метод
Гаусса *******}
procedure gauss
(a: matr; b: mas; var x: mas; n: integer);
Var k: byte;
m, s: real;
begin
{ приведение к треугольному
виду}
For k: =1 to
N-1 do
For i: =k+1 to
n do
begin
m: =a [i,k] /a
[k,k] ;
a [i,k]: =0;
For j: =k+1 to
N do
b [i]: =b [i] -m*b
[k] ;
end;
{расчет неизвестных х в обратном
порядке}
x [n]: =b [n] /a
[n,n] ;
writeln;
writeln ('Вывод результатов
решения системы уравнений методом Гаусса');
writeln ('x [',n,']
=',x [n]: 6: 2);
for i: = (n-1) downto
1 do
begin s: =0;
For j: =i+1 to
n do
s: =s-a [i,j] *x
[j] ;
x [i]: = (b [i]
+s) /a [i, i] ;
writeln ('x [',
i,'] =',x [i]: 6: 2);
end;
end;
{*** матричный
способ ***}
procedure
matrica (a: matr; y: mas; n: integer);
var z,a0: matr;
imx,np: integer;
s: mas;
begin
for i: =1 to n
do
begin
for j: =1 to n
do z [i,j]: =0;
z [i, i]: =1;
end;
for i: =1 to n
do
for j: =1 to n
do
a0 [i,j]: =a [i,j]
;
for i: =1 to n
do
begin
{ к i-ой строке прибавляем (или
вычитаем) j-ую строку
взятую со знаком i-того элемента
j-ой строки. Таким образом,
на месте элементова a [i, i] возникает
сумма модулей элементов i-того
столбца (ниже i-ой строки) взятая
со знаком бывшего элемента a [i, i],
равенство нулю которой говорит о
несуществовании обратной матрицы }
for j: =i+1 to
n do
AddStrings (a,z,
i,j,sign (a [i, i]) *sign (a [j, i]));
{ PrintMatr (a,b,n,6,1);
}
{ прямой
ход }
if (abs (a [i,
i]) >eps) then
begin
MultString (a,z,
i,1/a [i, i]);
for j: =i+1 to
n do
AddStrings (a,z,j,
i,-a [j, i]);
{ PrintMatr (a,b,n,6,1);
}
end
else
begin
writeln ('Обратной матрицы не
существует. ');
halt;
end
end;
{обратный
ход: '); }
if (a [n,n] >eps)
then
begin
for i: =n
downto 1 do
for j: =1 to
i-1 do
begin
AddStrings (a,z,j,
i,-a [j, i]);
end;
{ PrintMatr (a,b,n,8,4);
}
end
else writeln ('Обратной матрицы
не существует. ');
MultMatr (a0,z,a);
writeln ('Начальная матрица, обратная
к ней матрица: ');
PrintMatr2 (a0,z,n,7,3);
{** умножение обратной матрицы
на столбец свободных членов **}
for i: =1 to n
do s [i]: =0;
for i: =1 to n
do
s [i]: =s [i] +z [i,j] *y [j] ;
writeln ('Вывод результатов
решения системы уравненй матричным способом');
for i: =1 to n
do write (' ', s [i]: 5: 2);
end;
begin {***** тело программы
******}
clrscr;
writeln ('ввод матрицы
коэффициентов при неизвестных х');
for i: =1 to N
do
for j: =1 to N
do
begin
write (' введите a [', i,',',j,'] => ');
read (a [i,j]);
end;
writeln ('ввод столбца свободных
членов');
for i: =1 to N
do
begin
write (' введите b [', i,'] => ');
read (b [i]);
end;
writeln ('введите
вариант ');
writeln (' 1 - решение системы
линейных уравнений методом Гаусса ');
write (' 2 - решение системы
линейных уравнений матричным методом => ');
readln (variant);
case variant of
1: gauss (a,b,x,n);
2: matrica (a,b,n);
else writeln ('неверно указан
вариант');
end;
end.
Похожие работы на - Разработка программы решения системы линейных уравнений
|