type complex = record
re, im: real
end;
E' ora possibile scrivere procedure e funzioni che realizzano operazioni su dati di tipo complex:
{AI: r,i sono inizializzati}
procedure setCar (var c:complex;
r,i:real);
{AF: c conitiene il numero con parte reale r parte immaginaria i}
begin
c.re:=r; c.im:=i;
end;
{AI: c e' inizializzato}
function getRe (c:complex):real;
{AF: restituisce la parte reale di c}
begin
getRe:=c.re;
end;
{AI: c e' inizializzato}
function getIm (c:complex):real;
{AF: restituisce la parte immaginaria di c}
begin
getIm:=c.im;
end;
{AI: c e' inizializzato}
procedure writeComplex (c:complex);
{AF: nessuna}
{COMMENTO:scrive su OUTPUT il contenuto di c}
begin
writeln(getRe(c),`+`,getIm(c),`i`);
end;
{AI: c1,c2 sono inizializzati}
procedure sumComplex ( c1,c2:complex;
var c3:complex);
{AF: c3 contiene la somma di c1 e c2}
begin
setCar(c3, getRe(c1)+getRe(c2), getIm(c1)+getIm(c2));
end;
unit NOME
{EVENTUALI COMMENTI}
interface
uses NOMEu1,...,NOMEuN; {Una UNIT puo' usare altre UNIT!!!}
const
NOMEc1 = ... {EVENTUALI COMMENTI}
.
.
.
NOMEcN = ... {EVENTUALI COMMENTI}
type
{Attenzione:
chi usa la UNIT (un PROGRAM o altre UNIT) puo' usare i nomi di questi tipi,
ma NON DEVE fare riferimento alla rappresentazione}
NOMEt1 = ... {EVENTUALI COMMENTI}
.
.
.
NOMEtN = ... {EVENTUALI COMMENTI}
{AI:...}
procedure NOMEp1 (...);
{AF:...}
{EVENTUALI COMMENTI}
.
.
.
{AI:...}
procedure NOMEpN (...);
{AF:...}
{EVENTUALI COMMENTI}
implements
{---Funzioni nell'interfaccia che dipendono da NOMEt1, ..., NOMEtN}
.
.
.
{---Funzioni nell'interfaccia che non dipendono da NOMEt1, ..., NOMEtN}
.
.
.
{---Funzioni private che dipendono da NOMEt1, ..., NOMEtN}
.
.
.
{---Funzioni private che non dipendono da NOMEt1, ..., NOMEtN}
.
.
.
end.
{--CODICE COMMENTATO (nel senso che e' racchiuso tra graffe)
che contiene un main che permette di testare le funzioni
presenti nella UNIT:
...
begin
...
end.
}
Un file che utilizza UNIT e' strutturato nel seguente modo:
program NOMEp
uses NOMEu1,...,NOMEuN; {Una PROGRAM puo' usare piu' UNIT!!!}
...
begin
...
end.
unit NumCom
interface
{Attenzione:
chi usa la UNIT non deve fare riferimento alla
rappresentazione del tipo complex}
type complex = record
re, im: real
end;
procedure setCar (var c:complex;
r,i:real);
{AI: r,i sono inizializzati}
{AF: c contiene il numero con parte reale r parte immaginaria i}
function getRe (c:complex):real;
{AI: c e' inizializzato}
{AF: restituisce la parte reale di c}
function getIm (c:complex):real;
{AI: c e' inizializzato}
{AF: restituisce la parte immaginaria di c}
procedure writeCarComplex (c:complex);
{AI: c e' inizializzato}
{AF: nessuna}
{COMMENTO:scrive su OUTPUT il contenuto di c
in rappresentazione cartesiana}
procedure sumComplex ( c1,c2:complex;
var c3:complex);
{AI: c1,c2 sono inizializzati}
{AF: c3 contiene la somma di c1 e c2}
implements
{---Funzioni nell'interfaccia che dipendono da: complex}
procedure setCar (var c:complex;
r,i:real);
begin
c.re:=r; c.im:=i;
end;
function getRe (c:complex):real;
begin
getRe:=c.re;
end;
function getIm (c:complex):real;
begin
getIm:=c.im;
end;
{---Funzioni nell'interfaccia che dipendono da: complex}
procedure writeComplex (c:complex);
begin
writeln(getRe(c),`+`,getIm(c),`i`);
end;
procedure sumComplex ( c1,c2:complex;
var c3:complex);
begin
setCar(c3, getRe(c1)+getRe(c2), getIm(c1)+getIm(c2));
end;
{---Funzioni private che non dipendono da: complex}
{---Funzioni private che dipendono da: complex}
end.
{--CODICE COMMENTATO (nel senso che e' racchiuso tra graffe)
che contiene un main che permette di testare le funzioni
presenti nella UNIT: SCRIVETELO VOI
...
begin
...
end.
}
Esercizi proposti
Esercizi
- Realizzare di una UNIT per le matrici (vedi lez. in LABORATORIO
dell'11-12-15 Gennaio 2001 (Matrici)),
e un programma che la usa.
- Estendere la UNIT per numeri complessi (vedi sopra),
con le seguenti operazioni:
function getM (c:complex):real;
{AI: c e' inizializzato}
{AF: restituisce il modulo di c}
function getA (c:complex):real;
{AI: c e' inizializzato}
{AF: restituisce l'anomalia di c}
procedure writePolComplex (c:complex);
{AI: c e' inizializzato}
{AF: nessuna}
{COMMENTO:scrive su OUTPUT il contenuto di c
in rappresentazione polare}
e scrivere un programma che le usa per risovere un'equazione di
secondo grado a coefficienti reali.
- Modificare la UNIT per i numeri complessi (sviluppata al punto precedente)
cambiando la rappresentazione del tipo complex: utilizzare la
rappresentazione in coordinate polari:
type complex = record
m: real; {modulo}
a: real {anomalia}
end;
ATTENZIONE: il resto dell'interfaccia NON DEVE ESSERE CAMBIATO,
e il programma che usa i complessi per risolvere
le equazioni di secondo grado DEVE CONTINUARE A
FUNZIONARE SENZA ESSERE CAMBIATO.
- Estendere la UNIT per numeri complessi (vedi sopra),
con le seguenti operazioni:
procedure setPol (var c:complex;
m,a:real);
{AI: m,a sono inizializzati}
{AF: c contiene il numero con modulo m e anomalia r}
procedure prodComplex ( c1,c2:complex;
var c3:complex);
{AI: c1,c2 sono inizializzati}
{AF: c3 contiene il prodotto di c1 e c2}
procedure invComplex ( c1:complex;
var c2:complex);
{AI: c1 e' inizializzato}
{AF: c2 contiene l'inverso moltipltivo di c1}
procedure radComplex ( c1:complex;
var c2:complex);
{AI: c1 e' inizializzato}
{AF: c2 contiene la radice quadrata di c1}
e scrivere un programma che le usa per risovere un'equazione di
secondo grado a coefficienti complessi.
- Modificare la UNIT per i numeri complessi (sviluppata al punto precedente)
cambiando la rappresentazione del tipo complex:
da coordinate polari a cartesiane (o viceversa, a seconda di quella
che avete usato).
ATTENZIONE: il resto dell'interfaccia NON DEVE ESSERE CAMBIATO,
e il programma che usa i complessi per risolvere
le equazioni di secondo grado a coefficienti complessi
DEVE CONTINUARE A FUNZIONARE SENZA ESSERE CAMBIATO.
Soluzioni
(NON ANCORA PRESENTI)