Report

ABSTRACT DATA TYPES Reference Tremblay and Cheston: 6.1 - 6.3, 7.2, 9.2, 11.1.1 One of the keys to design and development of large software packages is data abstraction i.e., abstract specification of methods during the design of a class; specifies the type/class behaviour without giving the implementation. Why develop the ADT? Specify behaviour of a type before its implementation as a class. Other types are designed based on this behaviour. Facilitates independent development of different types by different individuals. Postpones development of details that initially are unnecessary. Programming language independent. Precise. Why hide the implementation (even if it exists)? The current type is the supplier in a client-supplier relationship. Note that a client is another module that uses the type being defined. Minimizes coupling: clients only know the ADT, not the implementation, of the current type/class Implementation may change, but don’t want it to affect client classes A client cannot make changes to the implementation that cause errors What needs to be specified for an Abstract Data Type? name of the type data types needed the one being specified others used to define the present type Each of them must be already defined by its own ADT mathematically defined e.g., sets, integers, reals, pairs, triples, etc. built into the language signature for each operation of the new type precondition for each operation semantics meaning of each operation what does it do? Techniques to specify an ADT Axiomatic Constructive Postcondition Each technique uses a different approach to specify the semantics. Only the axiomatic technique will be discussed. Student Abstract Data Type I. Name Student II. Sets ?? III. Signatures ?? What features are the students going to have? name student number ability to change name Student Abstract Data Type I. Name Student II. Sets S : set of all students N : set of all names K : set of all student numbers III. Signatures (using object oriented notation) newStudent: N x K S S.getName: N S.getNumber: K S.setName: N S Note that all operations are defined to be functions with no side effects. Operations that would normally change an object, like setName, are defined to be functions that return a new object. IV. Preconditions IV. Preconditions For all s S, n N, n2 N, k K pre-newStudent(n, k) ::= true pre-s.getName() ::= true pre-s.getNumber() ::= true pre-s.setName(n2) ::= true V. Semantics Axiomatic approach (a) specify a minimum set of operations that can be used to construct an arbitrary instance, call them the build operations newStudent (b) for each other operation (the non-build operations) when this operation is invoked on an arbitrary instance (built by the build operations) define the result for this operation (usually using the parameters of the build operation, and sometimes using build operations) V. Semantics (a) Build operations newStudent (b) Axioms newStudent(n, k).getName = n newStudent(n, k).getNumber = k newStudent(n, k).setName(n2) = newStudent(n2, k) Simple List ADT I. Name List<G> II. Sets L = set of all lists containing items of type G G = set of all items that can be placed in the list B = {true, false} III. Signatures newList<G>: L L.isEmpty: B L.insertFirst: G L L.firstItem: ↛ G L.deleteFirst: ↛ L IV. Preconditions For all l L, g G pre-newList<G>() ::= true pre-l.isEmpty() ::= true pre-l.insertFirst(g) ::= true IV. Preconditions For all l L, g G pre-newList<G>() ::= true pre-l.isEmpty() ::= true pre-l.insertFirst(g) ::= true pre-l.firstItem() ::= not l.isEmpty() pre-l.deleteFirst() ::= not l.isEmpty() V. Semantics (a) Build operations (b) Axioms V. Semantics (a) Build operations newList insertFirst Note that an arbitrary list has one of two forms: newList() or l.insertFirst(g), for some existing list l and some item g V. Semantics (a) Build operations newList insertFirst (b) Axioms newList().isEmpty() = true l.insertFirst(g).isEmpty() = false V. Semantics (a) Build operations newList insertFirst (b) Axioms newList().isEmpty() = true l.insertFirst(g).isEmpty() = false l.insertFirst(g).firstItem() =g l.insertFirst(g).deleteFirst() = l alternate notation when there is more than one case (if expression): l.isEmpty() = if l = newList() then true else false ADT for a Queue with a bounded size I. Name Queue<G> II. Sets Q = set of all queues with items from G G = set of all items to be placed in the queue B = {true, false} N = set of non-negative integers III. Signatures newQueue<G>: N Q Q.isEmpty: B Q.isFull: B Q.insert: G ↛ Q Q.item: ↛ G // the item that has been in the queue the longest Q.deleteItem: ↛ Q // the current item III. Preconditions For all q Q, g G pre-q.insert(g) ::= not q.isFull() pre-q.item() ::= not q.isEmpty pre-q.deleteItem() ::= not q.isEmpty() IV. Semantics (a) Build operations newQueue, insert (b) Semantics q.isEmpty() = if q = newQueue<G>(n) then true else false What is the definition/semantics of the item() operation? IV. Semantics (a) Build operations newQueue, insert (b) Semantics q.isEmpty() = if q = newQueue<G>(n) then true else false Note that insertion is at the end of the queue, while the current item is at the front q.insert(g).item() = if q.isEmpty() then g else q.item() What is the definition/semantics of the deleteItem() operation? rule 1 rule 2 Note that insertion is at the end of the queue, while the first item is the one to be deleted q.insert(g).deleteItem() = if q.isEmpty() then q else q.deleteItem().insert(g) Trace: Notation: draw a queue as an array with the front item of the queue at the front of the array. Suppose that the queue has capacity 6. [2, 7, 4, , , ].deleteItem() = newQueue<int>(6).insert(2).insert(7).insert(4).deleteItem() using the ADT notation = (newQueue<int>(6).insert(2).insert(7)) .insert(4).deleteItem() parenthesis = (newQueue<int>(6).insert(2).insert(7)) .deleteItem().insert(4) used rule 2 = (newQueue<int>(6).insert(2)) .insert(7).deleteItem().insert(4) parenthesis = (newQueue<int>(6).insert(2)) .deleteItem().insert(7). insert(4) used rule 2 = (newQueue<int>(6)) .insert(2).deleteItem().insert(7). insert(4) parenthesis = newQueue<int>(6).insert(7). insert(4) used rule 1 = [7, 4, , , , ] Sometimes to define an operation, it is necessary/helpful to define other operations. For example, to know whether the queue is full or not, it is necessary to determine its capacity and compare that to the number currently in the queue. Hence, we need to have operations to determine the capacity and current number in the queue. Signatures: Q.capacity: N Q.count: N Preconditions: none Semantics: newQueue<G>(n).capacity() = n q.insert(g).capacity() = q.capacity() newQueue<G>(n).count() = 0 q.insert(g).count() = 1 + q.count() or q.count() = if q.isEmpty() then 0 else 1 + q.deleteItem().count() q.isFull() = if q.capacity() = q.count() then true else false