félcsoport (semigroup) = ({s},{ * : s s s [infix]}. semigroup is a type specification =
DESCRIPTION
félcsoport (semigroup) = ({s},{ * : s s s [infix]}. semigroup is a type specification = sorts : s oprs : * : s s s [infix] eqns : m 1 , m 2 , m 3 s (m 1 * m 2 ) * m 3 = m 1 * (m 2 * m 3 ) ; end semigroup;. monoid = ({s},{ * : s s s[infix], e:s }. - PowerPoint PPT PresentationTRANSCRIPT
félcsoport (semigroup) = ({s},{ *: s s s [infix]}.
semigroup is a type specification =
sorts: s
oprs: *: s s s [infix]
eqns: m1, m2, m3 s
(m1* m2) * m3 = m1* (m2* m3) ;
end semigroup;
monoid = ({s},{ *: s s s[infix], e:s}.
monoid is a type specification = semigroup +
oprs: e:s
eqns: m s
e*m = m
m*e = m
group = ({s},{ *: s s s[infix], e:s, ( _ ) -1: s s}.
group is a type specification = monoid +
oprs: ( _ ) -1: s s
eqns: m s
m*(m -1) = e
(m -1)*m = e
ring = ({s},{ z: s, * : s s s[infix], + : s s s[infix], - : s s}.
ring is a type specification = semigroup +
oprs: z : s,
+ : s s s[infix],
- : s s
eqns: m, m1, m2, m3 s
(m1+ m2)+ m3 = m1+ (m2+ m3)
m1+ m2= m2+ m1
m + z = m
m + (-m) = z
(m1+ m2)*m3 = (m1*m3) + (m2*m3))
m1*(m2+ m3) = (m1*m2) + (m1*m3))
end ring;
Mátrix.
Egyszerűség kedvéért 22-es mátrixot definiálunk.
matrix(ring) is a type specification =
parameters = ring +
exports =
type sort : matrix
oprs : zero : matrix
unit : matrix
MATRIX: ring ring ring ring matrix
add: matrix matrix matrix
sub: matrix matrix matrix
eqns: a1,a2,a3,a4, b1,b2,b3,b4ring
zero = MATRIX(z,z,z,z)
unit = MATRIX(e,z,z,e)
add(MATRIX(a1,a2,a3,a4), MATRIX(b1,b2,b3,b4)) =
MATRIX(a1+b1,a2+b2,a3+b3,a4+b4)
sub(MATRIX(a1,a2,a3,a4), MATRIX(b1,b2,b3,b4)) =
MATRIX(a1+(-b1),a2+(-b2),a3+(-b3),a4+(-b4))
end matrix;
Ismételt paraméter átadás.
Példa:
Van: int, matrix(ring); string(data); bintree(data);
Kellene. bintree(string(matrix(int)));
1. Megoldás:
int matrix(ring) = matrix(int);
matrix(int) string(data) = string(matrix(int));
string(matrix(int)) bintree(data) = bintree(string(matrix(int)));
2. Megoldás:
string(data) bintree(data) = bintree(string(data));
matrix(ring) bintree(string(data)) = bintree(string(matrix(ring)));
int bintree(string(matrix(ring))) = bintree(string(matrix(int)));
Paraméter átadás kompozíciója asszociatív:
(f °g) ° h = f ° (g ° h);
data bintree(data)
h1
param string(param) (3)
h2 h2'
(1)
ring matrix(ring) string(matrix(ring))
h3 h3
(2)
int string(matrix(int)) bintree(string(matrix(int)));
(Az eredmény független a választott stratégiától!)
Cél: megbízható szoftver előállítása.
Módszer : absztrakció + modularizáció.
Objektum elvű szoftverfejlesztési módszer:
Objektum modul, az objektumhoz való szabványos
hozzáférhetőséggel.
Szinkronizált objektum modul
párhuzamos környezetben.
nem szinkronizált
objektum
szinkronizációs
mechanizmus
requestenterexit
Az objektumon végzendő operációk fázisai:
requestenterexit
Állapot az objektum létezésének egy feltételnek eleget tevő szakasza. (aktivitást fejt ki, vagy vár egy esemény bekövetkezésére).
állapotentry/event/exit/
Az objektum állapotához három fázis kötődik:
Indulás fázis. (Az entry akció kezdeményezi).Belső tevékenységek fázisa. (Az event akció). Kilépési fázis. (Az exit akció).
Adattípus specifikációja:eqns: <típus név> is a type specification = parameters = ... ; exports = class sort:
oprs: eqns: . . . fs(fc(a)) = h(a) pre(fs(b)) : b = fc(a);
attr(fc(a)) n fc(a) = "undefined" pre(fc(a)) : attr(a) n.
sync: ... .Egy specifikációs nyelv a szinkronizációra:
elsőrendű predikátum kalkulus nyelve
+
klózok (operáció, akció, időbeli rendezettség).
Individuum változók: közös erőforráson végzendő operációkhoz tartozó akciók.
Az akciók szintaktikai formája: operáció neve[végrehajtásának sorszáma](paraméter), ;
{req, ent, ex};Például: p[i](x).req;
Individuumok halmazán értelmezett reláció: akciók közötti időbeli rendezettségi reláció:
Szintaxis: akció akció bool [infix].Például : p[i].req q[j].exit;
A reláció tulajdonságai:nem reflexív: ~ (A B); asszimmetrikus: (A B) ~ (B A);
tranzitív: (A B) ~ (B C) (A C);Szemantika: A B = ha A műveleti akció megelőzi B műveleti akciót
akkor "true" különben "false".
Paraméterekre vonatkozó relációk az elsőbbségi relációban.
Szintaxis:
R(x,y)(f[i](x).ex g[j](y).ent), ahol R(x,y) reláció.
Szemantika:R(x,y)(f[i](x).ex g[j](y).ent) =ha az f(x) művelet exit akciója az i. végrehajtás esetén
megelőzi a g(y) művelet enter akcióját a j. végrehajtás eseténés a paramétereikre ugyanakkor fennáll az R(x,y)="true" állítás
akkor "true" különben "false".
Megjegyzés:Az univerzális és az egzisztenciális kvantor: : for all; : for some.
implementor absztrakt szinkronizációs specifikáció program
követelményeknek való megfelelés ellenőrzése szinkronizációs tulajdonságok bizonyítása
függetlenül az operáció algoritmusától
Axiómák:
(i)( p(i).req p(i).ent);
(i)( p(i).ent p(i).ex);
(i,k; k 0)(p(i).req p(i+k).req);
Erőforráshoz való hozzáférési korlátozások:
1.) Addig az adaton nem végezhető p művelet, amíg nem jött létre:
(i)(create.ex p[i].ent);
2.) Ugyanabból a műveletből egyszerre csak egy dolgozhat az
objektumon (kizárólagos használat):
(i)(p[i].ex p[i+1].ent);
3.) Ugyanabból a műveletből egyszerre csak n 1 dolgozhat az
objektumon:
(i)( h[i].ex h[i+1].ent);
4.) Különböző műveletekből egyszerre csak egy dolgozhat az
objektumon (kölcsönös kizárás):
(i,j)( p[i].ex q[j].ent q[j].ex p[i].ent );
5.) Két különböző művelet esetén q művelet az objektumhoz való
hozzáférések számában legfeljebb n-nel haladhatja meg
a p hozzáféréseinek számát:
(i)( p[i].ex q[i+n].ent );
Prioritásos korlátozások.
1.) A p operációnak elsőbbsége van a q operációval szemben az
erőforráshoz való hozzáférésben (prioritásos belépés):
(i,j)( p[i].req q[j].ent) p[i].ent q[j].ent );
2.) A p operációnak elsőbbsége van a q operációval szemben az
erőforráshoz való hozzáférésben (prioritásos belépés):
(i,j)( p[i].req q[j].ent) p[i].ent q[j].ent );
3.) A p operációnak elsőbbsége van a q operációval szemben az
erőforrás kizárólagos használatában (prioritásos kölcsönös kizárás):
(i,j)( p[i].req q[j].ent) p[i].ex q[j].ent );
4.) Paraméterektől függő prioritásos kölcsönös kizárás :
(i,j)( p[i](x).req q[j](y).ent) R(x,y) p[i](x).ex q[j](y).ent);
Beütemezések.
1.) Beütemezés prioritás alapján kölcsönös kizárással:
(i,j,k)( q[j].req p[i].ex q[j].ent r[k].req p[i].ex r[k].ent q[j].ex r[k].ent);
2.) Beütemezés kölcsönös kizárással paramétertől függő prioritás
alapján:
(i,j,k)((q[j](x).req p[i].ex q[j](x).ent r[k](y).req p[i].ex r[k](y).ent) R(x,y)
q[j](x).ex r[k](y).ent);
Sorrendiségi korlátozás.
p[i] operáció után közvetlenül q[j] operáció használja az erőforrást:
(~k)( p[i].ex r[k].ent q[j].ent);
Korlátos buffer szinkronizációs axiómája.
syn = for all j;
create.ex deposit[j].ent deposit [j].ex remove[j].ent
remove [j].ex deposit[j+n].ent (szinkronizáció);
deposit[j].ex deposit [j+1].ent remove[j].ex remove[j+1].ent; (kizárólagos használat)
Adatbázis szinkronizációs axiómája.
syn: for all i,j:
create.ex writer[i].ent (write[i].ex write[i+1].ent)
(writer[i].exreader[j].ent reader[j].exwriter[i].ent) (writer[i].reqread[j].ent writer[i].exreader[j].ent)
Példa. Az adatbázis típusának a specifikációja párhuzamos esetre.db(elem) is a class specification = parameters =
sorts: elem oprs: : elem
exports = class sorts: db
oprs: create: db write: db elem db read: db elem
eqns: ddb; eelem; read(create) = read(write(d,e)) = e
syn: for all i,j: create writer[i].ent (write[i].ex write[i+1].ent
(writer[i].exreader[j].ent reader[j].exwriter[i].ent) (writer[i].reqread[j].ent writer[i].exreader[j].ent)
end db;
Adva a lista típus specifikációja:
listx(elem) is a type specification =
sorts : listx, elem
oprs :
empty : listx
add : elem listx listx
_ . _ : listx listx listx
eqns : /, m list; e elem;
empty . / = /
add(e , /) . m = add(e, / . m )
end listx;
Egészítsük ki a specifikációt a szinkronizációs specifikációval.
Megoldás.
listx(elem) is a type specification = sorts : listx, elem oprs : /, m listx; e elem; empty : listx
add : elem listx listx _ . _ : listx listx listx eqns : /, m list; e elem;
empty . / = / add(e , /) . m = add(e, / . m )
syn : (i,j)(empty.ex _ . _ [j].ent
_ . _ [j].ex _ . _ [j+1].ent add[j].ex add[j+1].ent
(add[i].ex _ . _ [j].ent _ . _ [j].ex add[i].ent))end listx;