Ćwiczenia z Zastosowania informatyki w chemii-5

CZEŚĆ A. Przykłady, cd.
1.Obliczanie wartości pierwiastka kwadratowego - algorytm Newtona-Raphsona
http://pl.wikipedia.org/wiki/Metoda_Newtona
(pierwszy przykład na stronach Wiki)
Dane: Liczba a (a>0) - liczba podpierwiastkowa; p - początkowe przybliżenie pierwiastka; maxiter - liczba
iteracji
Wynik: Przybliżona wartość pierwiastka kwadratowego z a
Kroki:
1. iter:=0;
2. x:=(p+a/p)/2; iter:=iter+1
3.Jeśli iter=maxiter to zakończ algorytm; przybliżona wartość pierwiastka kwadratowego z a jest równa x
4. Przyjmij, że p:=x i wróć do kroku 2
program NewtonRaphson;
var iter, Maxiter: integer;
a, p, x: real;
begin
write('podaj pierwiastkowana liczbe: ');
readln(a);
write('Podaj poczatkowe przyblizenie: ');
readln(p);write('Podaj liczbe iteracji: ');
readln(Maxiter);
iter:=0;
repeat
x:=(p+a/p)/2;
iter:=iter+1;
p:=x;
until iter=Maxiter;
writeln('Pierwiastek z ',a:0:2 ,' wynosi: ', x:0:10);
readln;
end.
2.Sprawdzanie czy podana liczba naturalna jest pierwsza
Liczba pierwsza to liczba podzielna tylko przez 1 i przez siebie.
Programy:
1) Lp1.pas - generuje liczby pierwsze dla zakresu 1..1000, wykorzystuje instrukcję goto na wyjście z pętli.
Wyniki tego programu są zapisywane do pliku Lp1.txt. Analogiczne nazwy mają pliki wyników pozostałych
programów - jak program, tylko z rozszerzeniem .txt.
2) Lp2a.pas - podaje się liczbę max do której obliczane są liczby pierwsze, 0 - kończy obliczenia. Max zakres
100000 (p=p+1).
3) Lp2b.pas - przy generowaniu liczb korzysta się z tablicy liczb wygenerowanych (p=p+2).
4. Liczp1.pas - podaje się ilość liczb a nie zakres
5. Liczp2.pas j.w.
6. Liczp3.pas j.w., obliczenia w pętli do podania 0.
7. Liczbyp.pas - program najprostszy pod wzgl. algorytm, nie korzysta z tablic ale efektywny, wyniki zapisuje
tylko do pliku.
Max ilość generowanych liczb ograniczona teoretycznie wielkością typu longint, w praktyce oczywiście
mniejsza.
2. Tablice
Tablica jest zbiorem elementów tego samego typu. Każdy element tablicy ma numer (indeks).
Tablicę stosujemy w przypadku, gdy chcemy przechowywać w jednej zmiennej (pod jedną nazwą)
większą ilość danych.
Deklaracja tablicy jednowymiarowej:
nazwa: array[rozmiar] of typ;
Przykład:
var T: array[0..3] of real; {deklaracja tablicy przechowującej 4 wartości typu rzeczywistego}
Przykład: 0, 1, 2, 3
var Dni: array[1..7] of string; {deklaracja tablicy typu łańcuch}
Tablic używa się w programie podając nazwę zmiennej tablicowej oraz numer elementu, którego
operacja ma dotyczyć ujęty w nawiasy kwadratowe.
Przykłady:
T[0] := 1.25; {przypisanie wartości 1.25 pierwszemu elementowi tablicy „T” }
writeln(Dni[7]); {wyświetlenie elementu tablicy Dni o indeksie 7}
Możliwe jest zadeklarowanie tablicy dwuwymiarowej (bądź wielowymiarowej):
nazwa: array[rozmiar1, rozmar2] of typ;
var tab: array[0..2,0..3] of integer; {deklaracja tablicy dwuwymiarowej 3x4 o wartościach całkowitych}
tab[0,0] := 32; {przypisanie wartości 32 do pierwszego elementu tablicy}
Wynik := tab[0,0]; {pobranie wartości z pierwszego elementu tablicy}
Przyklad
program tablica_liczb_calkowitych;
uses crt;
{Program wczytuje do tablicy 5 liczb całkowitych
a następnie wczytane liczby wyświetla}
var
Tab: array[1..5] of integer;
i: integer;
begin
for i:=1 to 5 do
begin
write('Podaj ', i, ' liczbe: ');
readln(Tab[i])
end;
write('Podales nastepujace liczby: ');
for i:=1 to 5 do write(Tab[i], ', ');
readln;
end.
CZĘŚĆ B – WE/WY DO PLIKU, FUNKCJE I PROCEDURY
Pliki
a) deklaracja zmiennej plikowej. Dla plików sformatowanych, sekwencyjnych:
var
plik:text;
b) nadanie zmiennej plikowej wartości (nazwnie pliku)
assign(zmienna_plikowa;AAAA); gdzie AAAA – zmienna typu łańcuchowego lub łańcuch
np.
assign(plik,'dane.dat'); {plik – zmienna zadeklarowana jako var plik:text}
LUB
aaa:='dane dat'; {aaa zmienna typu string}
assign(plik, aaa);
c) otwarcie pliku
reset(plik); - do odczytu
rewrite(plik); - odczyt/zapis
append(plik); - dopisywanie
d)
operacje na pliku
e) zamknięcie pliku
close(plik);
Przykład : odczytywanie pliku znak po znaku, aż do konca. FUNKCJA
EOF(plik) – end of file:
Program Odczyt;
var plik: text;
znak: array[1..1111] of char;
i: integer;
begin
assign(plik, 'dane.txt');
i:=0;
reset(plik);
while not eof(plik) do
begin
i:=i+1
read(plik, znak[i]);
write(znak[i]);
end;
close(plik);
end.
Funkcje i procedury
function nazwa_funkcji(lista_zmiennych): typ_funkcji;
np.
lista zmiennych „wyjsciowych” : x,y:real, i,j,k: integer, itp.
lista zmiennych „wejściowych” : var x,y :real; var i,j,k : integer; itp
function ff(x,y:real):real
procedure nazwa_procedury(lista zmiennych);
np. procedure calka(var a,b,delta:real; wynik:real);
PRZYKŁADY
P1. Obliczanie potęgi liczby rzeczywistej
program pote;
uses crt;
var liczba,wykladnik:real;
Function Potega(podst, wykl: real): real;
begin
if (podst>0) then Potega:= Exp(wykl * Ln(podst))
else Potega:= 0;
end;
begin
writeln('Porogram oblicza potegi liczb o rzeczywistym wykladniku');
write('Podaj podstawe potegi :');readln(liczba);
write('Podaj wykladnik potege :');readln(wykladnik);
writeln('Potega liczby ',liczba:0:4,' wynosi = ',Potega(liczba,wykladnik):0:4);
readln;
end.
P2. Obliczanie silni, funkcja + rekurencja
PROGRAM Obliczanie_silni;
USES Crt;
VAR
liczba, i, n : INTEGER;
FUNCTION Silnia(liczba : INTEGER) : LONGINT;
BEGIN
IF liczba > 1 THEN
Silnia:=liczba*Silnia(liczba-1)
ELSE
Silnia:=1;
END; {Silnia}
BEGIN {main}
ClrScr;
Writeln('Obliczanie silni z danej liczby calkowitej');
Writeln('Podaj liczbe');
Readln(n);
FOR i:=0 TO n DO
Writeln(' ', i , ' != ', Silnia(i));
REPEAT UNTIL KeyPressed;
END.
P3. Program z ozdobnikami. Przykład na to, jak skomplikować proste zadania.
Program oblicza objętość kuli. Dane: promień kuli. Wszystkie operacje
przeprowadzane są w procedurach.
PROGRAM KULA1; { naglowek programu}
{ poczatek BLOKu DEKLARACJI}
USES DOS,CRT;
CONST ESC=#27; {stala}
{Zmienne globalne}
VAR r : real; {promien - typu rzeczywistego}
v : real; {objetosc - typu rzeczywistego}
i: integer; { zmienna typu calkowitego}
z: char; {zmienna typu znak}
PROCEDURE dane (VAR x: real);
begin
textcolor(red);
writeln('Obliczenie NR ',i);
writeln;
textcolor(yellow);
write('Promien=');
readln(x);
end; {dane}
PROCEDURE obliczenia ( x: real; VAR y: real);
{ x,y - zmienne lokalne
x-promien - przekazywany przea wartosc
z programu glownego
y-objetosc - przekazywany przez zmiennana zewnatrz procedury do programu glown }
var x3: real; { r*r*r - promien do potegi 3 - zmienna lokalna}
Begin {pocz bloku operacji procedury obliczenia}
x3:=x*x*x;
y:=4.0/3.0*pi*x3;
End;
PROCEDURE wyniki(promien,objetosc: real);
Begin
writeln;
textcolor(green);
writeln('PI=',pi);
writeln;
textcolor(blue);
write('OBJETOSC KULI o promieniu ');
textcolor(magenta);
writeln(promien:7:3);
textcolor(green);
write(' wynosi ');
textcolor(lightcyan);
writeln(objetosc:10:3);
textcolor(white);
writeln;
writeln;
write('BY zakonczyc obliczenia nacisnij');
highvideo;
textcolor(yellow+blink);
writeln(' ESC...');
textcolor(white);
z:=Readkey;
normvideo;
writeln;
End; {wyniki}
{ Koniec bloku deklaracji}
{ Blok operacji - zacznie sie}
BEGIN { Kula }
clrscr;
textmode(c40);
i:=0;
repeat
i:=i+1;
dane(r);
obliczenia(r,v); { r wchodzi do procedury, a wychodzi z niej v}
wyniki(r,v);
until (z=ESC);
END. { Kula}
{Koniec bloku operacji}