1. Relational Database Application
1.1. Dissimilarity from SQL2. Object Database Application
1.2. Declaring database
$base "..." =; $base "..." ~; = $base "..."; ~ $base "..."; $base "...", $"..."*
1.3. Creating table relations
R (A1, ); R: r(A1:a1, ); {E1, }; S*
1.4. Selecting table relations
= E; =A:a; = R(E1, ...); = {E1 =/~/, ...}; = A: a^b
1.5. Printing database contents
$printX($file "F", Q1, ); $printX(Q1, ); = *; = *:; = :*
1.6. Updating relation
=E = (A1:a1, ); E ~ (A1:a1, ); R: #n
1.7. Coping and deleting relation
R0 =/~ R1; R: {r0 =/~ r1}; R:r ~ ( ); R:r ~
1.8. Exporting and importing table data
$printTable($file "F0", Q, A0, A1, ); $readTable($file "F1", R, N0, N1, )
1.9. Quoting and numbering
R("A"); R(#n); A:'...'; A:"..."; A:#n
2.1. Dissimilarity from relational database3. Administrating
2.2. Multilevel classification
C1: C2: ; C1(E11, ): C2(E21, ):
2.3. Class passing
E / ; E / E1; / E; / E / ; E / / E1
2.4. Class analysis
C():c; E:c | ; E:c \ ; | {C, C:c}; \ C:c
2.5. Class manipulation
C : [C1/]; C: = C1:; C: ~ C1:
2.6. Multitude variable
$mul S; $S =/~ E; $S ~; = [$S]; [$S] ~; [$S] =; $S*
3.1. User account4. Language Reference
$User:"..." ($Password:"...", $Service:"...", $Info:"..."); $login("...", "...", "...")
3.2. Database navigation
$Content:E ($Attribute:E1, ...); E ($WebPage:"...")
$base "..." ~ ; Opens "..." database as new modifiable.
= $base "..." ; Opens "..." database as non-modifiable (only readable).
~ $base "..." ; Closes "..." database.
$base "..." ; Sets "..." database as current. If database is not opened yet, opens it as modifiable.
$"..."* ; Contraction of specification. If S1 specific name was declared by $base "S1" before, the $"S"* suggests S1 database.
Database type is specified by base key word immediately after
$.
The name of the current database may be missing. Need be careful with
$"..."
. If a specification is used without type, system tries remember type
or otherwise suggests multitude ($mul "...").
< Tests multibase working > $base "Notes/Test" =; B; $base "Notes/RelDB"; =A; = $"Notes/T"*; < Apparently Notes/Test > =B; $base ~; < Clears current database >;The < ... > construction is a Z comments.
R (A1,
) - an R relation of an A1,
.
R:r (A1:a1,
) - an R class namely r relation
of an A1 class namely a1,
.
R:(A:a, ...) (A1:a1,
) - an R class namely relation
of an A: a,
which is relation of A1: a1, .... The attributes
of first relation, A:a,..., are key.
The R and A are denotes of relational model: Relation, Attribute. Really for Z, if R(A1, A2) is exists, it is suggested existence of A1(R) and A2(R).
Considered auxiliary structure:
{E1,
} - a set of E1 expression,
.
For example A: {a1, a2}, or equal {A:a1, A:a2}.S* . S denotes begin of sequences of non key symbols and blanks.
For example a*, in place of {a1, a2, ... an}.
note workfellow telephone address #1 Ringer Michael 415 506-0111 4 Broadway Av 503 743-5226 #2 Smith Anne 400 297-0752 10 Seventh Av Smith RobertLet us create new empty Notes/RelDB database.
$base "Notes/RelDB" ~;Now input the table information. Description of schema, first statement, is optional!!!. Z DBMS deduces schema automatically.
note (workfellow, telephone, address); note:#1 ( workfellow:Ringer Michael, telephone:{415 506-0111,503 743-5226}, address:4 Broadway Av ); note:#2 ( w*:Smith Anne, t*:400 297-0752, a*:10 Seventh Av );We can use some attributes as key without preliminary declaration. Assume the telephone is key. The following statement will not add new note, because the note: (telephone:400 297-0752) exists.
note:( t*:400 297-0752 ) ( a*:10 Seventh Av, w*:Smith Robert );There are more flexible possibilities to enter new data.
workfellow:Smith Robert (note:#2);Moreover we can describe attributes via request, for example note: #2, in last statement, may be expressed over = (:Smith*), see 1.4 section. Even the workfellow attribute name, itself, we can express via = {(note) ~ {telephone, address}} (1.4 section) or via = :Smith Anne\ (2.4 section). Can you understand easy following?:
For example:Important note: if database includes only {A}, then =A: equals indefinitude, =A(): equals A, =:A equals A, =A:A equals A.
= A: - the A class;
= :a - the a of an arbitrary class;
= R:(E1, ...).
For example:= {E1=/~/, ...} - the set of the E1 expression and/no/or the ... .
= R:r (A:a) - the R class namely r relation of the A: a ;
= (A:a, B:b) - the relation of the A: a and B: b ;
= ({A:a,B:b}) - the relation of the A: a or B: b ;
= {A,B}: (R:#1) - the A, B classes namely relation of the R: #1
For example:= A:a^b - the A class namely range from a to b.
= {R: ~ (B:)} - anything of the R class no the relation of the B class;
= {:a=A:, B:} - the union of the :a = A: intersection and B:. Evidently = {:a = A:} equals = A: a.
All the complete expressions separated by the ';' are statements. Expression may be description or request. If Z expression begins with '=' or with '~' symbol, its operand (and itself expression) is a request. For '= Q;' and '~ Q;' the Q is a request, whereas for 'D;' the D is description. Operands are descriptions for D=, D=D1. For '~' operator of negation the operands are request, Q~Q1, Q~. Look at these combinations: D = =Q; = {Q, D=};.
See 3.Reference... about all the Z operators, ordered
from highest to lowest precedence. Consecution of operators is executed
from left to the right. For example, A = B = C is equal to {
A = B } = C.
note workfellow telephone address #1 Ringer Michael 415 506-0111 4 Broadway Av 503 743-5226 #2 Smith Anne 400 297-0752 10 Seventh Av Smith RobertFollowing request reports some objects that belong to the telephone class with values in the range from 415* .
= telephone:415*^;Result in the Report area (in Report window for Sav Z DBMS Interpreter, or in Report buffer for Sav Z API):
telephone:{ 415 506-0111, 503 743-5226 };We can image relations with 4* address and with one of the 4* telephones.
= (address:4*, telephone:4*);Result:
note:#1;Finally let's output all the notes that have relation with 4* telephone, but no relation with 503* value.
= {note:(telephone:4*)~(:503*)}; ----- note:#2;
$printX(Q1, ) print X of the Q1, . Missing of the $file parameter denotes output in the Report area (window or buffer).
We can use: print, printLine, printRelation, printClass, or a abbreviation thereof p, pl, pr, pc. The F is an output file. The Q1, are requests or " " string, or #n number.
Considered * request:
= * - names
= *: - class names
= :* - instance names
To understand expressions, review example for database that consists of {A:a, B}:
Statement Result
$pc(); A:a, B;
$pc(*) A, B;
$pc(*:) A;
$pc(:*) a;
$pc({*}:) A:a;
$p("SCHEMA OF ", *);
$p("------------------------------------------------------");
$pr(*);
SCHEMA OF address, note, telephone, workfellow ------------------------------------------------------ address ( note ), note ( address, telephone, workfellow ), telephone ( note ), workfellow ( note );If you want to print contents of the workfellow class related with the notes of the 415* telephone in the Notes/wf415.txt, type
$pc($file "Notes/wf415.txt", workfellow: (note: (telephone: 415*) ) );If you need print all the objects of two level class in the Notes/test.txt, type
$pl($file "Notes/test.txt", *:*);
E ~ (A1:a1, ) - E is not relation of the A1 class a1 and . The a(~b2) is not correct! The a~(b) is the same as =a~(b).
R: #n - R class namely n number. Here n
is positive number, 1073741823 maximum by default.
Look at the R: # expression. The indefinite number is last number
if the R: # request, and is new number if the R: # description.
=note:(:Smith*) ~ (:Smith Anne); note:# (:Smith Anne); =note:# = (t*:503 743-5226);Take a look at the result using
$pr( (:Smith*) );
note:{ #2 ( address:10 Seventh Av, telephone:400 297-0752, workfellow:Smith Robert ), #3 ( telephone:503 743-5226, workfellow:Smith Anne ) };
R: {r0 =/~ r1} R namely r0 is equal/unequal to R namely r1. Expression might transform to R: r0 =/~ R: r1. It copies relations from R: r1 to R: r0 or deletes relations of R: r1 from R: r0.
R:r ~ ( ) - R class namely r is not relation. Deletes relations.
R:r ~ - R class namely r is not. Deletes objects.
$pr(note:#3); ----- note:{ #1 ( address:4 Broadway Av, telephone:{ 415 506-0111, 503 743-5226 }, workfellow:Ringer Michael ), #2 ( address:10 Seventh Av, telephone:400 297-0752, workfellow:Smith Robert ), #3 ( telephone:503 743-5226, workfellow:Smith Anne ) };Set data of Michael Ringer (#1 record) to #3 record.
note: {=#3 = =(:Ringer Michael)}; $pr(note:#3); ----- note:#3 ( address:4 Broadway Av, telephone:{ 415 506-0111, 503 743-5226 }, workfellow:{ Ringer Michael, Smith Anne } );Following fragment demonstrates integrity control. To delete Ringer Michael we need not to point records (#1, #3) with this field and we may not use triggers or like SQL CONSTRAINT statements.
:Ringer Michael ~; $pr(note:{#1,#3}); ----- note:{ #1( address:4 Broadway Av, telephone:{ 415 506-0111, 503 743-5226 } ), #3( address:4 Broadway Av, telephone:{ 415 506-0111, 503 743-5226 }, workfellow:Smith Anne ) };The #1 record dose not have workfellow value, so we can delete and it.
note:#1 ~ (); $pr(note:); ----- note:{ #1, #2 ( address:10 Seventh Av, telephone:400 297-0752, workfellow:Smith Robert ), #3 ( address:4 Broadway Av, telephone:{ 415 506-0111, 503 743-5226 }, workfellow:Smith Anne ) };
For example, we can import R(A, B) table directly from script:$printTable($file "F", Q, A0, A1, ) - print table in F file from Q with column names A0 key, A1, . There are procedure name contraction, $pt(...). The Q is a request. The A0, A1, may be requests. If F file parameter is missing, Report area is suggested. The $printTableRow($file "F", Q, A0, A1, ...) procedure, $ptr(...) contraction, prints only table rows, without first line determining column names. If the A0, A1, are absent, attributes entered by $readTable(...) will be output in alphabet order.
$rt() <
R ; A ; B
#1; a1; b1
#2; a2; b2
>
Notice large profit of thess procedures for database archiving. The F file may be directory, without extension ( .tab). For example: If database consists of R1, R2 tables, $pt($file "Tables") exports all the tables in Tables/R1.tab and Tables/R2.tab accordingly; Then we can import all the files from Tables by $rt($file "Tables").
A first input line of tabular data must define the names of columns.
Only
";" semicolon may be delimiter of the table fields. Values of the
field are separated by the ','. The words with the $ * # " ' { [ ( } ]
) ^ : / | \ ~ = , ; < > key symbols need be enclosed in the quotes.
The price may be without quotes, $10.2. Distinction of the "..."
and
'...' see in the 1.9 section.
$pt($file "Notes/Note.tab", note:, note, address, telephone, workfellow); $base "Notes/ObjDB" ~; $rt($file "Notes/Note.tab", #4, #2, #3); $pt($file "Notes/Workfellow.tab", workfellow: ); $pt(workfellow:);
workfellow; telephone; address Smith Anne; 415 506-0111, 503 743-5226; 4 Broadway Av Smith Robert; 400 297-0752; 10 Seventh Av
Single quotes may be helpful only to use special symbols as non-special,
for instance
A: '2*3'. Using A: "...", as A: #n, reduces
the required database size and accelerates running, but a price must be
paid in loss of the contractions: =:"...", =:#n . The
R("A")
and R(#n) only reduce memory. The =("A") and
=(#n)
contractions are not attainable. Quoting and numbering may be fit for a
big database. Particularly it may be useful to express repeating classes:
"A": "A" or #1: #1. Remember that usual words do not express
class repeat, A: A is A.
$base "Notes/Test" ~; "office":'#10' (employer:#10, "company":"Unknown"); $pr(); = "ATTAINABLE EXPRESSIONS"; = "office":''*; = employer:#*; = "company":"U"*; = "----------"; = :'#10'; = "company":"Unknown"; = "office":("company":"Unknown"); = ["UNATTAINABLE EXPRESSIONS"]; = :#10; = :"Unknown"; =("company":"Unknown")Derivable result:
"company":"Unknown", "office"( "company", employer ):'#10'( "company":"Unknown", employer:#10 ), employer( "office" ):#10( "office":'#10' ); "ATTAINABLE EXPRESSIONS"; "office":'#10'; employer:#10; "company":"Unknown"; "----------"; "office":'#10'; "company":"Unknown"; "office":'#10';Following fragment produces Failure messages.
= ("Unattainable"); = :#1; = :"Unknown";
C1(E11, ): C2(E21, ):
Mark that R1(A1): R2(A2) expression equals to {R1(A1): R2}(A2)
and equals to R1(A1): {R2(A2)}. The R1: {:R2} is allowable,
but it is the same as R1: R2. Duplicate names are not tolerable.
It may be useful to know: the R1: expression assumes all the levels
of R1 class, R1: R2:
, but R1:* only one level -
R1:
R2.
category: acquainted (property: telephone, property: address ): { relative (property: propinquity ), workfellow (property: position, property: function ) };Execute the queries.
$pc(category:relative); $p("-----"); $pc(:acquainted:(property:telephone, property:propinquity)); $p("-----"); $pc(category:~:workfellow);Report window will have three equal Z statements separated by the "-----"; string.
category:acquainted:relative;Additional test:
$p("category:*"); $pr(category:*);Result:
category: * category ( property ):acquainted ( property:{ address, telephone } );
E / E1 - E1 instance of E class.
/ E - class of E instance.
/ E / - instance of class of E instance.
E / / E1 - instance of E and class of E1.
We are going to complicate test namely add unacquainted relative.
category:{unacquainted:relative = =:relative}; $pr(category:);
category:{ acquainted( property:{ address, telephone } ):{ relative( property:propinquity ), workfellow( property:{ function, position } ) }, unacquainted():relative( property:propinquity ) };It is left to enter many of '/' request combinations and look at result.
= "= category:unacquainted/"; = category:unacquainted/; = "= category:*/"; = category:*/; = "= category/relative"; = category/relative; = "= category/(property:propinquity, property:address)"; = category/(property:propinquity, property:address); = "= /relative"; = /relative; = "= category:acquainted:{/relative}"; = category:acquainted:{/relative}; = "= {/relative = /workfellow}"; = {/relative = /workfellow}; = "= /relative/"; = /relative/; = "= category//relative"; = category//relative;Result:
"= category:unacquainted/"; relative; "= category:*/"; { relative, workfellow }; "= category/relative"; { acquainted:relative, unacquainted:relative }; "= category/(property:propinquity, property:address)"; acquainted:relative; "= /relative"; category:{ acquainted, unacquainted }; "= category:acquainted:{/relative}"; category:acquainted; "= {/relative = /workfellow}"; category:acquainted; "= /relative/"; { relative, workfellow }; "= category//relative"; { acquainted, unacquainted };
E:c | - instances of E:c expression. Result is lower level, c.
E:c \ - class of E:c expression. Result is E.
| {C, C:c} - normal (proper) objects of {C, C:c} expression. Result is C:c.
\ C:c - all objects of C:c expression. Result is a {C,
C:c} or equal C():c.
category:unacquainted():~; = category:;
category:acquainted():{ relative, workfellow };Now test '|' and '\' combinations.
$pl("", "CURRENT (CONSIDERED) OBJECTS", category:); $pl("", "CURRENT IDENTIFIERS", category:|); $pl("", "CURRENT CATEGORIES", category:\); $pl("", "NORMAL OBJECTS", |category:); $pl("", "ALL OBJECTS", \category:); $pl("", "NORMAL IDENTIFIERS", |category:|); $pl("", "NORMAL CATEGORIES", |category:\); $pl("", "NORMAL GENERAL CATEGORIES", |category:\*); $pl("", "ALL IDENTIFIERS", \category:|); $pl("", "ALL CATEGORIES", \category:\);Result:
CURRENT (CONSIDERED) OBJECTS category:acquainted category:acquainted:relative category:acquainted:workfellow CURRENT IDENTIFIERS acquainted relative workfellow CURRENT CATEGORIES category category:acquainted NORMAL OBJECTS category:acquainted:relative category:acquainted:workfellow ALL OBJECTS category category:acquainted category:acquainted:relative category:acquainted:workfellow NORMAL IDENTIFIERS relative workfellow NORMAL CATEGORIES category:acquainted NORMAL GENERAL CATEGORIES category ALL IDENTIFIERS acquainted category relative workfellow ALL CATEGORIES category category:acquainted
C: = C1: - C class is equal to C1 class. Relations of C1: objects are copied to C: with identical instances.
C: ~ C1: - C class is unequal to C1 class. Relations of C1: are removed from C: with identical instances.
Assume that C: {c, c1}, C1(A): {c1(A:a1), c2(A:a2)} are available. Consequently, the C: = C1: entails C(A): { c, c1(A:a1)}.
$pt(workfellow:);
workfellow ; address ; telephone Smith Anne ; 4 Broadway Av; 415 506-0111, 503 743-5226 Smith Robert; 10 Seventh Av; 400 297-0752
Assume we face the need of transmitting workfellow class relation to object:workfellow class relation. Look at the workfellow instances.
= workfellow/;
{ Smith Anne, Smith Robert };Make instance of the object:workfellow class initially.
object:workfellow: [=workfellow/]; $pr(object:);
object:workfellow():{ Smith Anne, Smith Robert };Now we can copy class relations from workfellow:.
object:workfellow: = workfellow:; $pr(object:);
object:workfellow():{ Smith Anne ( address:4 Broadway Av, telephone:{ 415 506-0111, 503 743-5226 } ), Smith Robert ( address:10 Seventh Av, telephone:400 297-0752 ) };Let's print all the objects with Smith* instances (identifiers).
$pl(:Smith*);
object:workfellow:Smith Anne object:workfellow:Smith Robert workfellow:Smith Anne workfellow:Smith RobertLet's print now all the classes of Smith* instances.
$pl(/Smith*);
object:workfellow workfellowThe old workfellow (not object:workfellow) class relation should be deleted.
workfellow(): ~;Lastly we can print information about objects over property . attributes.
$pt(object:, :workfellow, property.);
object:workfellow; address ; telephone Smith Anne ; 4 Broadway Av; 415 506-0111, 503 743-5226 Smith Robert ; 10 Seventh Av; 400 297-0752
$S =/~ E - S is equal/unequal to E. It includes/excludes objects to set denoted by S.
$S ~ . It excludes all objects from S set.
= [$S] . Expression extracts the objects, equal to S set, from a database.
[$S] ~ . It deletes objects of S from database.
[$S] = . It creates objects of S in a current database.
$S* . Using ellipsis for multitude name.
The mul key word is optional and need only if a variable of other type with the same name was declared earlier. For example, if $base "s1", $mul s1 were declared, the $s1 implies "Ambiguous" error. Type or name of variable must follow immediately after $.
System supposes that objects of multitude variable are in a current
database and therefore tests the multitude existing only if variable is
in [] brackets, or defines connection. For example contents of $x
will be tested in ($x), [$x], $x: , but not in =$x, {$x}, $print($x).
Constructions
$x (
) and
$x:
may be used for creating new
connections in database.
$mul telephone ~; $tel* = =tel*:(:Smith Anne); = $tel*;Result:
telephone:{ 415 506-0111, 503 743-5226 };
=====
$x ~; $x = $tel*; $x ~ tel*:415*; = $x;Result:
telephone:503 743-5226;
=====
$x = ={telephone:~(:Smith Anne)}; = $x;Result:
telephone:{ 400 297-0752, 503 743-5226 };The following fragment illustrates using the variable data in another database.
$p("Test New Database"); $base "Notes/Test" ~; = {"current DB", [$x]}; [$x] =; = {"DB after [$x]=", [$x]}; [$x] ~; = {"DB after [$x]~", [$x]};Result:
Test New Database "current DB"; { "DB after [$x]=", telephone:{ 400 297-0752, 503 743-5226 } }; "DB after [$x]~";
Considered expression
$User:"..." ($Password:"...", $Service:"...", $Info:"...").
Only administrator has to enter this expression. The $User:"" and
$Service:""
denote arbitrary user and service. If there are some
$User:"...",
then database has limit access.
$login("...", "...", "..."). The $l is a contraction of procedure name. First parameter - a service name, second - a password, third - user name. Parameters may be missed, then its are assumed from previous $login or "".
Current version of Sav Z has 4 system services:
Service | Class |
navigate | Sav.DBMS.Navigator, Sav.Server.Navigator |
import | Sav.DBMS.Importer, Sav.Server.Importer |
export | Sav.DBMS.Exporter, Sav.Server.Exporter |
record | Sav.Server.Recorder |
$base "Notes/Resource"; $User:"Administrator" ($Password:"123456", $Service:""); $User:"Serg" ($Password:"123123", $Service:"navigate"); $User:"" ($Service:"record"); $pr($User:);
-----
$User:{ ""( $Service:"record" ), "Administrator"( $Password:"123456", $Service:"" ), "Serg"( $Password:"123123", $Service:"navigate" ) };After login with others properties statements will be rejected.
$l("navigate", "123456", "Mole"); $pr();
Considered expression
$Content:E ($Attribute:E1, ...). Z DBMS's or Z Server's navigator
will have a chance of observing only E: and E1,.... Note
that
$Content:R ($Attribute:A1, ...) is made automatically by $rt()
<R; A1; ...> procedure.
E ($WebPage:"..."). Z Servers navigator uses $WebPage:"...".
The "..." is a URL reference.
$pr($*:);
-----
$Password:{ "123123"( $User:"Serg" ), "123456"( $User:"Administrator" ) }, $Service:{ ""( $User:"Administrator" ), "navigate"( $User:"Serg" ), "record"( $User:"" ) }, $User:{ ""( $Service:"record" ), "Administrator"( $Password:"123456", $Service:"" ), "Serg"( $Password:"123123", $Service:"navigate" ) };We need read table to make automaticly $Content class.
$rt() < A ; B ; C ; D ; $WebPage a1; b1; c1; d1; "http://www.org.com" a2; b2; c2; d2; >; $pr($Content:);
----- $Content:A( $WebPage, B, C, D );Let's change $Content:.
$Content:A ~ ($Attribute:D); $Content:D ($Attribute:A); $pr($Content:); $pt();
-----
$Content:{ A( $WebPage, B, C ), D( A ) }; A; $WebPage; B; C a1; "http://www.org.com"; b1; c1 a2; ; b2; c2 D; A d1; a1 d2; a2It remains only to see as navigator is working.
E Expression S Sequence of non-key symbols and blanks N Number with # (#1, #2, ...). A,B,C,... Class names of A:E, B:E, C:E, ... a,b,c,... Class values of E:a, E:b, E:c, ... R:r Relation name of R:r(E) A:a, B:b,... Relation attributes of E(A:a, B:b, ...) Q Request for = Q | Q ~ | Q1 ~ Q2 | $print(Q1, ...) D Description for D; | D =Syntax designations:
Z Key symbol $ | * | # | " | ' | | { | [ | ( | } | ] | ) | ^ | : | / | | | \ | ~ | = | , | ; | < | > C Non-key character L Letter D Digital W Word C... | '...' N Number D... S String "..." WN Word Name W | W* | W WN SN String Name "..." | "..."* | W SN NN Number Name #N | # | #* | W NN Nm Name * | WN | SN | NN Exp Z Expression Nm | Exp Z | Z Exp Stm Statement Exp, ... Scr Script Stm; ...Expressions ordered by priority:
1 $SN | $SN(Exp, ...) $base SN 1.2 $file SN 1.5, 1.8 $mul SN 2.6 $SN 1.2, 2.6 $W(Exp,...) 1.5, 1.8, 3.1 $W 3.1, 3.2 1 Nm WN 1.3 S | S* 1.9 N | N* 1.6, 1.9 * 1.5, 2.2 1 <...> 1.2, 1.8 1 [Exp, ...] 2.5, 2.6 1 {Exp, ...} 1.3, 1.4 1 (Exp, ...) 1.4 2 ^Exp | Exp^Exp | Exp^ 1.4 3 Exp(Exp, ...) 1.3, 1.4 4 Exp:Exp 1.3, 1.9, 2.2 4 :Exp | Exp: 1.4 5 /Exp | Exp/ 2.3 5 Exp/Exp | Exp//Exp 2.3 6 |Exp | \Exp 2.4 6 Exp| | Exp\ 2.4 7 =Exp 1.4, 1.6 7 ~Exp 1.2 8 Exp~Exp 1.4, 1.6, 1.7, 2.5, 2.6 9 Exp=Exp 1.4, 1.6, 1.7, 2.5, 2.6 10 Exp~ | Exp= 1.2, 1.7 11 Exp,Exp 1.3, 1.4 12 Stm;Stm 1.3