secuencias_ordenada

//--------------------------------------------//
// Especificacion Algebraica TAD Secuencia //
// Ordenada //
// Autor: Pablo Sanchez (p.sanchez@unican.es) //
// http://personales.unican.es/sanchezbp //
//--------------------------------------------//

espec SortedSequence(SortedList)

usa Boolean, Natural, Integer

generos SortedSequence(Element) como SortedSeq

parametro
generos Element como E
operaciones
equal : Element Element -> Boolean
lessThan : Element Element -> Boolean
variables
x, y, z : Element;
ecuaciones
equal(x,x) = TRUE
equal(x,y) = equal(y,x)
[equal(x,y) and equal(y,z)] equal(x,z) = TRUE;

lessThan(x,x) = FALSE
[lessThan(x,y) and lessThan(y,z)] lessThan(x,z) = TRUE
[NOT(equal(x,y)) and NOT(lessThan(y,x))]
lessThan(x,y) = TRUE
[NOT(equal(x,y)) and lessThan(x,y))]
lessThan(y,x) = FALSE
fparametro

operaciones
emptySortedSeq : -> SortedSeq
add : SortedSeq E -> SortedSeq
getTail : SortedSeq -> E
getHead : SortedSeq -> E
get : SortedSeq Natural -> E
removeAll : SortedSeq E -> SortedSeq
removeOne : SortedSeq E -> SortedSeq
remove : SortedSeq Natural -> SortedSeq
contains : SortedSeq E -> Boolean
findFirstIndex : SortedSeq E -> Integer
findLastIndex : SortedSeq E -> Integer
size : SortedSeq -> Natural
number : SortedSeq E -> Natural
isEmpty : SortedSeq -> Boolean
mix : SortedSeq SortedSeq -> SortedSeq
equal : SortedSeq SortedSeq -> Boolean
subseq : SortedSeq SortedSeq -> Boolean
max : SortedSeq -> Element
min : SortedSeq -> Element
vars
s, s2 : SortedSeq; n : Natural; x, y : Element;

precondiciones
[isEmpty(s) == FALSE] getTail(s), getHead(s), min(s), max(s)
[0 <= n < size(s)] get(s,n), remove(s,n)

ecuaciones
// Las generadoras son emptySortedSeq y add y son libres
// Los patrones del tipo son:
// - emptySortedSeq
// - add(s,x)
// NOTA: El patr�n no tiene porque estar ordenado, pero
// las operaciones han de comportarse como si lo
// estuviese.

size(emptySortedSeq) = 0
size(add(s,x)) = 1 + size(s)

min(add(emptySortedSeq,x)) = x
[lessThan(x,min(s)) == TRUE] min(add(s,x)) = x
[lessThan(x,min(s)) != TRUE] min(add(s,x)) = min(s)

max(add(emptySortedSeq,x)) = x
[lessThan(x,max(s)) == TRUE] max(add(s,x)) = max(s)
[lessThan(x,max(s)) != TRUE] max(add(s,x)) = x

getTail(s) = max(s)
getHead(s) = min(s)

[n == (size(s) - 1)] get(s,n) = getTail(s)
[n < (size(s) - 1)] get(s,n) = get(removeOne(s,max(s)),n)

removeAll(emptySortedSeq,x) = emptySortedSeq
[equal(x,y) == TRUE]
removeAll(add(s,x),y) = removeAll(s,y)
[equal(x,y) != TRUE]
removeAll(add(s,x),y) = add(removeAll(s,y),x)

remove(s,n) = removeOne(s,get(s,n))

contains(emptySortedSeq,x) = FALSE
[equal(x,y) == TRUE]
contains(addTail(s,x),y) = TRUE
[equal(x,y) != TRUE]
contains(addTail(s,x),y) = contains(s,y)

findLastIndex(emptySortedSeq,x) = -1
// NOTA: en la funci�n de arriba, en lugar de -1
// podr�a devolverse cualquier valor no v�lido
[max(add(s,x)) == y]
findLastIndex(add(s,x),y) = size(s)
[max(add(s,x)) != y]
findLastIndex(add(s,x),y) =
findLastIndex(removeOne(add(s,x),max(add(s,x))),y)

findFirstIndex(emptySortedSeq,x) = -1
[equal(min(add(s,x)),y) == TRUE]
findFirstIndex(add(s,x),y) = 0
[equal(min(add(s,x)),y) != FALSE]
findFirstIndex(add(s,x),y) =
1 + findFirstIndex(removeOne(add(s,x),min(add(s,x))),y)

removeOne(emptySortedSeq,x) = emptySortedSeq
[equal(x,y) == TRUE]
removeOne(add(s,x),y) = s
[equal(x,y) != TRUE]
removeOne(add(s,x),y) = add(removeOne(s,y),x)

number(emptySortedSeq,x) = 0
[equal(x,y) == TRUE]
number(add(s,x),y) = 1 + number(s,x)
[equal(x,y) != TRUE]
number(add(s,x),y) = number(s,y)

isEmpty(emptySortedSeq) = TRUE
isEmpty(add(s,x)) = FALSE

mix(s,emptySortedSeq) = s
mix(s,add(s2,x)) = add(mix(s,s2),x)

equal(emptySortedSeq,emptySortedSeq) = TRUE
equal(add(s,x),emptySortedSeq) = FALSE
equal(emptySortedSeq,add(s,x)) = FALSE
equal(add(s,x),add(s2,y)) =
and(equal(getTail(add(s,x)),getTail(add(s2,y))),
equal(remove(add(s,x),getTail(add(s,x))),
remove(add(s2,y),getTail(add(s2,y))))

subSeq(emptySortedSeq,emptySortedSeq) = TRUE
subSeq(add(s,x),emptySortedSeq) = FALSE
subseq(emptySortedSeq,add(s,x)) = TRUE
[size(s) == size(s2)]
subseq(add(s,x),add(s2,y)) = equal(add(s,x),add(s2,y))
[size(s) > size(s2)]
subseq(add(s,x),add(s2,y)) = FALSE
[size(s) < size(s2)]
subseq(add(s,x),add(s2,y)) =
subseq(add(s,x),remove(add(s2,y),getTail(add(s2,y))))

fespec