1 / 22

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

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

kim
Download Presentation

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

An Image/Link below is provided (as is) to download presentation 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. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. 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;

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

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

  4. 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;

  5. 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 add: matrix matrix  matrix sub: matrix matrix  matrix

  6. eqns: a1,a2,a3,a4, b1,b2,b3,b4ring 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;

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

  8. 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!)

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

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

  11. p.req p.ent[] p.ex : a szinkronizáció követelményeinek megfelelő belépési feltétel. p  pre obj

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

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

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

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

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

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

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

  19. 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].exreader[j].ent  reader[j].exwriter[i].ent)  (writer[i].reqread[j].ent  writer[i].exreader[j].ent)

  20. 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: ddb; eelem; 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].exreader[j].ent  reader[j].exwriter[i].ent)  (writer[i].reqread[j].ent  writer[i].exreader[j].ent) end db;

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

  22. 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;

More Related