CZĘŚĆ A: Etykiety, instrukcja skoku (zawsze do zastapienia

CZĘŚĆ A: Etykiety, instrukcja skoku (zawsze do zastapienia intrukcjami
warunkowymi lub petlami repeat/while, ale czasami wygodna). Opis:
deklaracja etykiety, w części z deklaracjami:
label nazwa_etykiety;
instrukcja skoku: goto nazwa_etykiety;
umieszczenie etykiety w programie:
nazwa_etykiety: intrukcja;
Przykład: wybieramy funkcje do tablicowania z funkcji sin(x), cos(x), exp(x), gdy niepoprawny
wybór program pyta raz jeszcze; wybieramy przedział tablicowania, gdy niepoprawnie podany –
raz jeszcze. Zapis funkcji do pliku oraz na ekran.
program tablicuje;
uses crt;
var x,dol,gor,krok:real;
c:char;
plik:text;
nazwa:string;
label zpowrotem,zpowrotem1;
function f(xx:real;cc:char):real;
var
y:real;
begin
case cc of
's' : y:=sin(x);
'c' : y:=cos(x);
'e' : y:=exp(x);
end;
f:=y;
end;
begin
zpowrotem: writeln(' jaka funkcje chcesz liczyc? ');
writeln(' s -sinus, c-cosinus, e-exp');
readln(c);
if ((c<>'s') and (c<>'c') and (c<>'e')) then begin
writeln(' zly wybor');
goto zpowrotem;
end;
zpowrotem1: writeln(' w jakim przedziale: dol,gor,krok');
readln(dol,gor,krok);
if(dol>gor) then begin
writeln(' gor < dol , podaj poprawnie');
goto zpowrotem1;
end;
writeln('podaj nazwe pliku');
readln(nazwa);
clrscr;
assign(plik,nazwa);
rewrite(plik);
x:=dol;
while(x<=gor) do begin
writeln(x,' ',f(x,c));
writeln(plik,x,' ',f(x,c));
x:=x+krok;
end;
close(plik);
end.
CZĘŚĆ B. Przykłady programów z procedurami i funkcjami
P1) Mnożenie 2 macierzy, elementy macierzy są liczbami całkowitymi. Teoria jest tu:
http://pl.wikipedia.org/wiki/Mno%C5%BCenie_macierzy
Program:
program monzenie_macierzy;
uses crt;
{ macierz A ma wymiar M na P, macierz B - P na N,
sprawdz kiedy mnozenie macierzy jest mozliwe na podanych wyzej
stronach wiki}
{stale sa zmiennymi globalnymi}
const
N=2;
M=3;
P=2;
{zauwaz, ze mozna zadeklarowac wymiary podajac stale}
type TA=array[1..M,1..P] of integer;
TB=array[1..P,1..N] of integer;
TC=array[1..M,1..N] of integer;
var i,j,k:integer;
A:TA;
B:TB;
C:TC;
procedure iloczyn(AA: TA; BB:TB; var CC:TC);
var
s,i,k: integer;
begin
for i:=1 to M do
begin
for k:=1 to N do
begin
s:=0;
for j:=1 to P do
s:=s+AA[i,j] * BB[j,k];
CC[i,k]:=s;
end;
end;
end;
{program glowny}
begin
writeln(' wczytuje macierz A, o wymiarach ',M,' x ',P);
writeln('Podaj elementy macierzy A : ' );
for i:=1 to M do
for j:=1 to P do
begin
write('Element [',i,' , ',j,' ] = ');
readln(A[i,j]);
end;
writeln(' wczytuje macierz B, o wymiarach ',P,' x ',N);
writeln('Podaj elementy macierz B : ');
for j:=1 to P do
for k:=1 to N do
begin
write('Element [',j,' , ',k,' ] = ');
readln(B[j,k]);
end;
iloczyn(A,B,C);
writeln('Macierz wynikowa C=A*B o wymiarach ', M,' x ',N);
writeln(' po kazdym elemencie wcisnij ENTER');
for i:=1 to M do
begin
for k:=1 to N do
begin
writeln('Element [',i,' , ',k,' ] = ' ,C[i,k]);
readln;
end;
end;
end.
P2. Rozwiązywanie układu równań liniowych metodą eliminacji Gaussa
http://pl.wikipedia.org/wiki/Metoda_eliminacji_Gaussa
program ze strony:
http://edu.i-lo.tarnow.pl/inf/alg/001_search/0076.php
jest tam teoria.
Program jest dobrze napisany. Zawiera dynamiczną deklarację rozmiarów
tablic. Dołaczyłem komentarze w programie
// Eliminacja Gaussa
// Data: 15.02.2010
// (C)2012 mgr Jerzy Wałaszek
//----------------------------program gauss;
type
NReal = array of extended; // typ tablic wierszy
{zauwaz, nie ma rozmiarow, to deklaracja dynamiczna,
uzyjemy takich rozmiarow, jakie beda potrzebne
deklaracja typu Mreal to „tablica tablic”, jeśli dalej będzie
var AB:Mreal; to elementy są AB[i][j], A NIE A[i,j]!!}
MReal = array of NReal;
const
eps = 1e-12;
// stała przybliżenia zera, wszystko < eps, to zero
// Funkcja realizuje algorytm eliminacji Gaussa
//--------------------------------------------function gauss(n : integer; var AB : MReal; var X : NReal) : boolean;
var
i,j,k : integer;
m,s : double;
begin
// eliminacja współczynników
for i := 0 to n - 2 do
begin
for j := i + 1 to n - 1 do
begin
if abs(AB[i][i]) < eps then exit(false);
{exit – procedura standardowa, wyjscie z funkcji, funkcja ma wartosc FALSE
metoda eliminacji gaussa nie może być stosowana}
m := -AB[j][i] / AB[i][i];
for k := i + 1 to n do
AB[j][k] := AB[j][k] + m * AB[i][k];
end;
end;
// wyliczanie niewiadomych
for i := n - 1 downto 0 do
begin
s := AB[i][n];
for j := n - 1 downto i + 1 do
s := s - AB[i][j] * X[j];
if abs(AB[i][i]) < eps then exit(false);
X[i] := s / AB[i][i];
end;
gauss := true;
{wszystkie obliczenia są prawidlowe, funkcja ma wartosc TRUE}
end;
// Program główny
//--------------var
AB : MReal;
X : NReal;
n,i,j : integer;
begin
// odczytujemy liczbę niewiadomych
read(n);
// tworzymy macierze AB i X
{TUTAJ USTALAMY POTRZEBNY ROZMIAR TABLIC,
procedura SetLength (tablica, rozmiar) to procedura standardowa}
SetLength(AB,n);
SetLength(X,n);
for i := 0 to n - 1 do SetLength(AB[i],n + 1);
// odczytujemy dane dla macierzy AB
for i := 0 to n - 1 do
for j := 0 to n do read(AB[i][j]);
{instrukcja if dziala, jeśli wartosc gauss=prawda (TRUE),
czyli jeśli metoda daje rozwiazanie}
if gauss(n,AB,X) then
begin
for i := 0 to n - 1 do
writeln('x',i + 1,' = ',X[i]:9:4);
end
else
writeln('DZIELNIK ZERO');
// usuwamy macierze z pamięci
{a to już ozdobnik, uwalnianie pamieci, można pominac}
for i := 0 to n - 1 do SetLength(AB[i],0);
SetLength(AB,0);
SetLength(X,0);
end.
P3 Metoda Newtona (zwana również metodą Newtona-Raphsona lub metodą stycznych) –
iteracyjny algorytm wyznaczania przybliżonej wartości pierwiastka funkcji.
http://pl.wikipedia.org/wiki/Metoda_Newtona
Program ze strony:
http://edu.i-lo.tarnow.pl/inf/alg/005_root/0013.php
UWAGA: zmien funkcje f oraz jej pochodną
DLA funkcji podanej w przykładzie punkt startowy to 1
Typu double to extended!
// Program znajduje miejsce zerowe funkcji f(x)
// za pomocą algorytmu Newtona
//--------------------------------------------// (C)2006 mgr J.Wałaszek
I LO w Tarnowie
program mzf1;
//uses crt,math;
uses crt;
const
EPS0 = 0.0000000001; // dokładność porównania z zerem
EPSX = 0.0000000001; // dokładność wyznaczenia pierwiastka
// Funkcja, której miejsce zerowe obliczamy
// f(x) = x^3*(x+sin(x^2-1)-1)-1
// <-1,0> i <1,2>
//----------------------------------------function f(x : real) : double;
begin
f := x * x * x * (x + sin(x * x - 1) - 1) - 1;
end;
// Oblicza pochodną funkcji f(x)
// f'(x) =2x^4*COS(x^2 - 1) + 3x^2*SIN(x^2 - 1) + 4x^3 - 3x^2
//----------------------------------------------------------function fp(x : real) : double;
begin
fp := x * x * (2 * x * x * cos(x * x - 1) + 3 * sin(x * x - 1) + 4 * x - 3)
end;
//----------------------------------------------------// Program główny
//----------------------------------------------------var
x0,x1,f0,f1 : double;
i
: integer;
begin
writeln('Obliczanie pierwiastka funkcji - metoda Newtona');
writeln('f(x) = x^3*(x+sin(x^2-1)-1)-1');
writeln('-----------------------------------------------');
writeln('(C)2006 mgr Jerzy Walaszek
I LO w Tarnowie');
writeln;
write('Podaj punkt startowy x0 = '); readln(x0);
writeln;
writeln('-----------------------------------------------');
writeln('WYNIK:');
writeln;
x1 := x0 - 1; f0 := f(x0); i := 64;
while (i > 0) and (abs(x1 - x0) > EPSX) and (abs(f0) > EPS0) do
begin
f1 := fp(x0);
if abs(f1) < EPS0 then
begin
writeln('Zly punkt startowy');
i := 0;
break;
end;
x1 := x0;
x0 := x0 - f0 / f1;
f0 := f(x0);
dec(i);
if i = 0 then writeln('Przekroczony limit obiegow');
end;
if i > 0 then writeln('x0 = ',x0:15:8);
writeln;
writeln('-----------------------------------------------');
writeln('Koniec. Nacisnij klawisz Enter...');
readln;
end.
P4. Metoda trapezów wyznaczania całki pojedynczej
http://pl.wikipedia.org/wiki/Metoda_trapez%C3%B3w
Program wzięty ze strony:
http://edu.i-lo.tarnow.pl/inf/alg/004_int/0003.php
//*************************************************
//** Obliczanie całki oznaczonej metodą trapezów **
//** ------------------------------------------- **
//** (C)2004 mgr Jerzy Wałaszek I LO w Tarnowie **
//*************************************************
program int_trapez;
uses crt;
//*******************************
//** Tutaj definiujemy funkcję **
// JAK INNA FUNKCJA - TO TO TRZEBA ZMIENIC
//*******************************
function f(x : double) : double;
begin
f := x * x + 2 * x;
end;
//********************
//** Program główny **
//********************
const N = 1000; //liczba punktów/trapezów podziałowych
var
xp,xk,s,dx : double;
i : integer;
begin
writeln('Obliczanie calki oznaczonej');
writeln(' za pomoca metody trapezow');
writeln('----------------------------');
writeln('(C)2004 mgr J.Walaszek I LO');
writeln;
writeln('f(x) = x * x + 2 * x');
writeln;
writeln('Podaj poczatek przedzialu calkowania');
writeln;
write('xp = '); readln(xp);
writeln;
writeln('Podaj koniec przedzialu calkowania');
writeln;
write('xk = '); readln(xk);
writeln;
s := 0;
dx := (xk - xp) / N;
for i := 1 to N - 1 do s := s + f(xp + i * dx);
s := (s + (f(xp) + f(xk)) / 2)* dx;
writeln('Wartosc calki wynosi : ',s:8:3);
writeln;
writeln('Nacisnij klawisz Enter...');
readln;
end.
ZMIEŃ PROGRAM, ABY WYZNACZAŁ CAŁKE Z DANĄ DOKŁADNOŚCIĄ
P5. Metoda Monte Carlo wyznaczania całek
http://pl.wikipedia.org/wiki/Metoda_Monte_Carlo
Program wzięty ze strony
http://edu.i-lo.tarnow.pl/inf/alg/004_int/0005.php
//****************************************************
//** Obliczanie całki oznaczonej metodą Monte Carlo **
//** ---------------------------------------------- **
//** (C)2004 mgr Jerzy Wałaszek I LO w Tarnowie **
//****************************************************
program int_montecarlo;
uses crt;
//*******************************
//** Tutaj definiujemy funkcję **
//*******************************
function f(x : double) : double;
begin
f := x * x + 2 * x;
end;
//********************
//** Program główny **
//********************
const N = 10000; //liczba punktów losowych
var
xp,xk,s,dx : double;
i : integer;
begin
writeln('Obliczanie calki oznaczonej');
writeln(' Metoda Monte Carlo');
writeln('---------------------------');
writeln('(C)2004 mgr J.Walaszek I LO');
writeln;
writeln('f(x) = x * x + 2 * x');
writeln;
writeln('Podaj poczatek przedzialu calkowania');
writeln;
write('xp = '); readln(xp);
writeln;
writeln('Podaj koniec przedzialu calkowania');
writeln;
write('xk = '); readln(xk);
writeln;
randomize; //inicjujemy generator liczb pseudolosowych
s := 0;
dx := xk - xp;
for i := 1 to N do s := s + f(xp + random * dx);
s := dx * s / N;
writeln('Wartosc calki wynosi : ',s:8:3);
writeln;
writeln('Nacisnij klawisz Enter...');
readln;
end.
POLECAM STRONY I LO W TARNOWIE!!!!!!
http://edu.i-lo.tarnow.pl/index.php