Sequences At the end of this lecture you should be able to: provide a definition of a VDM sequence; utilize and interpret sequence notation; make appropriate use of the VDM sequence operators; define a sequence by comprehension; identify situations in which a sequence is an appropriate data type; write VDM specifications using the sequence type.

Introduction A sequence is an ordered collection of objects; In a sequence, repetitions are significant. Examples The queue of patients waiting for a doctor. Planes circling an airport.

Notation A sequence is specified by enclosing its members in square brackets; queue = [ michael, varinder, elizabeth, winston, judith ] s = [ a, d, f, a, d, d, c ] [ a, d, f ]  [ a, f, d ] [ ]

Retrieving items from the sequence s = [ a, d, f, a, d, d, c ] queue = [ michael, varinder, elizabeth, winston, judith ] s(3) = queue(4) = s(10) = f winston undefined

Sequence operators len operator:Returns the length of a sequence s = [ a, d, f, a, d, d, c ] queue = [ michael, varinder, elizabeth, winston, judith ] len s = len queue = 7 5

Sequence operators s = [ a, d, f, a, d, d, c ] queue = [ michael, varinder, elizabeth, winston, judith ] elems operator:Returns a set that contains all the members of the sequence elems s = elems queue = { a, d, f, c } {michael, varinder, elizabeth, winston, judith}

Sequence operators inds operator :Returns a set of all the indices of the sequence s = [ a, d, f, a, d, d, c ] queue = [ michael, varinder, elizabeth, winston, judith ] inds s = inds queue = {1, 2, 3, 4, 5, 6, 7 } {1, 2, 3, 4, 5} inds [] ={ }

Sequence operators head (hd) operator :Returns the first element in the sequence s = [ a, d, f, a, d, d, c ] queue = [ michael, varinder, elizabeth, winston, judith ] hd s = hd queue = a michael hd [] =undefined

Sequence operators tail (tl) operator :Returns a sequence containing all but the first element s = [ a, d, f, a, d, d, c ] queue = [ michael, varinder, elizabeth, winston, judith ] tl s = tl queue = [d, f, a, d, d, c ] [varinder, elizabeth, winston, judith ] tl [] =undefinedtl [a] =[ ]

Sequence operators concatenation operator ( ^ ) operator: operates on two sequences, and returns a sequence that consists of the two sequences joined together first = [ w, e, r, w ]second = [ t, w, q ] first ^ second =[ w, e, r, w, t, w, q ] second ^ first =[t, w, q, w, e, r, w ] first ^ [ ] =[ w, e, r, w ]

Sequence operators the override operator (†) Takes a sequence and gives us a new sequence with a particular element of the old sequence overridden by a new element [a, c, d, e] † {1  z} =[z, c, d, e] [a, c, d, e] † {2  x, 4  y} =[a, x, d, y] [a, c, d, e] † {7  g} =undefined

Sequence operators subsequence operator allow us to extract a part of a sequence between two indices s = [ a, d, f, a, d, d, c ] s(2,..., 5) =[d, f, a, d] s(1,...,0) = [ ]s(8,..., 7) = [ ] s(2,..., 2) =[d] s(2,..., 13) =undefined

Sequence by comprehension [ expression(a) | a  SomeSet  test (a) ] [ a | a  {1,…,10}  is-odd(a)] [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] s1 = [2, 3, 4, 7, 9, 11, 6, 7, 8, 14, 39, 45, 3] s2 = [ s1(i) | i  inds s1  s1(i) > 10] [11, 14, 39, 45]

Using the sequence type in VDM-SL To declare a variable to be of type sequence we place an asterisk after the name of the type contained within the sequence. seq :  * convoy : SpaceCraft *

Specifying a stack Stack stack : Element[*] push(Element) pop() : Element isEmpty(): Boolean

Specifying the state of the stack types Element = TOKEN state Stack of stack : init mk-Stack(s)  end Element* s = [ ]

The push operation push( ) ext pre post itemIn : Element stack : Element* wr stack = [itemIn] ^ stack TRUE

The pop operation pop( ) ext pre post itemRemoved : Element stack : Element* wr stack = tl stack stack  [ ] itemRemoved = hd stack 

The isEmpty operation isEmpty( ) ext pre post query :  stack : Element* rd TRUE  querystack = [ ]

Re-thinking the Airport system In the new system, when an aircraft approaches the airport it is placed in a queue, and must circle the airport until a runway becomes available; Only aircraft that have permission to land are allowed to circle; The circling aircraft are landed on a first-come-first served basis.

Re-specifying the state types state Airport2 of init mk-Airport2 ( )  end Aircraft = TOKEN permission: Aircraft-set landed: Aircraft-set circling: Aircraft* p, l, cp = { }  l = { }  c = [ ] inv mk-Airport2(p,l,c)  ?

The new invariant inv mk-Airport2(p,l,c)  1.Landed planes must have permission 2.Circling planes must have permission 3.Circling planes can not be landed 4.All circling planes are unique l  p  elems c  p  elems c  l = { }  isUnique(c) isUnique(seqIn : Aircraft*) query :  pre true post query   i1,i2  inds seqIn  i1  i2  seqIn(i1)  seqIn(i2)

Re-specifying the operations The following operations access only the permission and landed components, and do not therefore need to be changed: givePermission recordTakeOff numberWaiting atAirport getPermission getLanded The meaning of recordLanding will change in the new specification; Two new operations are required getCircling allowToCircle

allowToCircle ( ) ext pre post allowToCircle operation craftIn : Aircraft circling : Aircraft*wr permission : Aircraft-set rd landed : Aircraft-set rd circling = circling ^ [craftIn] craftIn  permission  craftIn  elems circling  craftIn  landed

The modified recordLanding operation recordLanding( ) ext pre post circling : Aircraft* landed : Aircraft-set wr  circling = tl circling landed = landed  {hd circling } circling  [ ]

Some useful functions to use with sequences A function that returns the last element in a sequence: last( ) pre post sequenceIn : Element* elementOut : Element elementOut = sequenceIn(len sequenceIn) sequenceIn  [ ]

Some useful functions to use with sequences A function that returns the sequence with the last element removed. allButLast( ) pre post sequenceIn : Element*sequenceOut : Element* sequenceOut = sequenceIn(1,..., (len sequenceIn - 1)) sequenceIn  [ ]

Some useful functions to use with sequences A find function Returns the index of a particular element; Assuming elements are unique: find( ) pre post sequenceIn : Element*, element : Element position :  sequenceIn(position) = element element  elems sequencIn

Some useful functions to use with sequences A find function Returns the index of a particular element; Assuming elements are not unique: find( ) pre post sequenceIn : Element*, element : Element position :  sequenceIn(position) = element element  elems sequencIn   i  inds sequenceIn  sequenceIn(i) = element  position  i