secuencia_sin_repeticiones_ordenada

//-----------------------------------------------//
// Especificacion Algebraica Conjunto Posicional //
// con Orden Natural //
// Autor: Pablo Sanchez (p.sanchez@unican.es) //
// http://personales.unican.es/sanchezbp //
//-----------------------------------------------//

espec SortedOrderSet

usa Boolean, Natural, Integer

generos SortedOrderSet(Element) como SortedOrSet

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
emptySortedOrSet : -> SortedOrSet
add : SortedOrSet E -> SortedOrSet
getTail : SortedOrSet -> E
getHead : SortedOrSet -> E
get : SortedOrSet Natural -> E
remove : SortedOrSet E -> SortedOrSet
removeAt : SortedOrSet Natural -> SortedOrSet
contains : SortedOrSet E -> Boolean
findIndex : SortedOrSet E -> Integer
size : SortedOrSet -> Natural
isEmpty : SortedOrSet -> Booleano
mix : SortedOrSet SortedOrSet -> SortedOrSet
equal : SortedOrSet SortedOrSet -> Boolean
subseq : SortedOrSet SortedOrSet -> Boolean
max : SortedSeq -> Element
min : SortedSeq -> Element
vars
s, s2 : SortedOrSet; n : Natural; x, y : Element;

precondiciones
[isEmpty(s) != TRUE] getTail(s), getHead(s)
[0 <= n < size(s)] get(s,n), remove(s,n)

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

[contains(s,x) == TRUE] add(s,x) = s

size(emptySortedOrSet) = 0
size(add(s,x)) = 1 + size(remove(s,x))

min(add(emptySortedOrSeq,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(emptySortedOrSeq,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(remove(s,getTail(s)),n)

remove(emptySortedOrSet,x) = emptySortedOrSet
[equal(x,y) == TRUE]
remove(add(s,x),y) = remove(s,y)
[equal(x,y) != TRUE]
remove(add(s,x),y) = add(remove(s,y),x)

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

contains(emptySortedOrSet,x) = FALSE
[equal(x,y) == TRUE]
contains(add(s,x),y) = TRUE
[equal(x,y) != TRUE]
contains(add(s,x),y) = contains(s,y)

findIndex(emptySortedSeq,x) = -1
// NOTA: en la función de arriba, en lugar de -1
// podría devolverse cualquier valor no válido
[equal(max(add(s,x)),y) == TRUE]
findIndex(add(s,x),y) = size(s)
[equal(max(add(s,x)),y) != TRUE]
findIndex(add(s,x),y) =
findIndex(removeOne(add(s,x),getTail(add(s,x))),y)

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

mix(s,emptySortedOrSet) = s
[contains(s,x) == TRUE]
mix(s,add(s2,x)) = mix(s,s2)
[contains(s,x) != TRUE]
mix(s,add(s2,x)) = add(mix(s,s2),x)

subseq(emptySortedOrSet,emptySortedOrSet) = TRUE
subseq(add(s,x),emptySortedOrSet) = FALSE
subseq(emptySortedOrSet,add(s,x)) = TRUE
[size(add(s,x)) == size(add(s2,y))]
subseq(add(s,x),add(s2,y)) =
and(equal(getTail(add(s,x)),getTail(add(s2,y))),
subseq(remove(add(s,x),getTail(add(s,x))),
remove(add(s2,y),getTail(add(s2,y))))
)

[size(add(s,x)) > size(add(s2,y))]
subseq(add(s,x),add(s2,y)) = FALSE

[size(add(s,x)) < size(add(s2,y))]
subseq(add(s,x),add(s2,y)) =
subseq(add(s,x),remove(add(s2,y)getTail(add(s2,y))))

equal(s,s2) = and(igual(size(s),size(s2)),subseq(s,s2))

fespec

Last modified: Friday, 26 May 2017, 11:22 AM