félcsoport (semigroup) = ({s},{ * : s s  s [infix]}. semigroup is a type specification =

1 / 22

# félcsoport (semigroup) = ({s},{ * : s s  s [infix]}. semigroup is a type specification = - PowerPoint PPT Presentation

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 }.

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.

## PowerPoint Slideshow about 'félcsoport (semigroup) = ({s},{ * : s s  s [infix]}. semigroup is a type specification =' - kim

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

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 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 22-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

sub: matrix matrix  matrix

eqns: a1,a2,a3,a4, b1,b2,b3,b4ring

zero = MATRIX(z,z,z,z)

unit = MATRIX(e,z,z,e)

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;

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)));

(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

request

enter

exit

Az objektumon végzendő operációk fázisai:

request

enter

exit

Á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).

állapot

entry/

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ó).

p.req

p.ent[]

p.ex

: a szinkronizáció követelményeinek megfelelő belépési feltétel.

p

pre

obj

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".

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 );

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)

syn: for all i,j:

create.ex writer[i].ent 

(write[i].ex  write[i+1].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

eqns: ddb; eelem;

syn: for all i,j:

create writer[i].ent 

(write[i].ex  write[i+1].ent 

end db;

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 . / = /

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 . / = /