class ARRAY{T} < $ARR{T} is
-- This class implements one-dimensional arrays of elements of type T.
-- The operations provided include sorting, searching, etc. Array indices
-- start at 0 and go up to `asize-1'.
--
-- Most features here work when self is void. The intent is that
-- a void array behaves just like a zero-sized array. Thus self may be void
-- on operations which don't try to directly access specific elements since
-- any such access would be out of range.
-- Version 1.2 Oct 98. Copyright K Hopper, U of Waikato
-- Development History
-- -------------------
-- Date Who By Detail
-- ---- ------ ------
-- 11 Jul 96 bg Original for Sather 1.1
-- 13 Jan 97 kh Changed to CARD from INT
-- 4 Nov 98 kh Now as 1.2 dist, added pre/post conditions.
include CONTAINER{T} ;
private include AREF{T}
aget -> aget,
aset -> aset,
asize -> asize,
array_ptr -> array_ptr ;
-- Note that self may not be void for these public included routines.
create : SAME is
-- This routine creates an empty array.
return SAME::create(0)
end ;
create(
sz : CARD
) : SAME is
-- This routine xreates a new array of size sz, all of whose elements
-- are void.
return new(sz)
end ;
create(
arr : ARRAY{T}
) : SAME is
-- This routine creates a new array which has exactly the same contents
-- as arr.
me : SAME := create(arr.size) ;
loop
me.set!(arr.elt!)
end ;
return me
end ;
create_from(
elems : $ELT{T}
) : SAME is
-- This routine creates an array out of the elements of "elems". It is
-- expensive - first converts the argument into an FLIST to determine the
-- number of elements and then converts the FLIST into an array.
flist : FLIST{T} := FLIST{T}::create ;
loop
flist := flist.push(elems.elt!)
end ;
me : SAME := SAME::create(flist.size) ;
loop
me.set!(flist.elt!)
end ;
return me
end ;
size : CARD is
-- This routine returns the number of elements in the array. Self may
-- be void. Built-in to this implementation.
builtin ARRAY_SIZE
end ;
clear is
-- This routine sets each array element to void. Built-in to this
-- implementation. Self may be void.
builtin ARRAY_CLEAR
end ;
equals(
arr : $CONTAINER{T}
) : BOOL is
-- This predicate returns true if and only if all elements of self are
-- the same as the corresponding elements of arr.
typecase arr
when SAME then
loop
if ~elt_eq(elt!,arr.elt!) then
return false
end
end ;
return true
else
return false
end
end ;
has_ind(
val : CARD
) : BOOL is
-- This predicate returns true if and only if val is a valid index for
-- the array.
return val < size
end ;
inds : ARRAY{CARD}
pre ~void(self)
post (result.size = size)
is
-- This routine returns an index array which is the same size as self
-- and is set to the values of the indices.
sz : CARD := size ;
res : ARRAY{CARD} := ARRAY{CARD}::create(sz) ;
index : CARD := 0 ;
loop
until!(index >= sz) ;
res[index] := ind! ;
index := index + 1
end ;
return res
end ;
resize(
new_size : CARD
) : SAME
pre ~void(self)
post (result.size = new_size)
is
-- This routine allocates a new array and copies whatever will fit of
-- self. It then returns the new array.
res : SAME := SAME::create(new_size) ;
loop
res.set!(elt!)
end ;
return res
end ;
copy : SAME
pre true
post (result.size = self.size) -- (result = self)
is
-- This routine returns a copy of self.
if void(self) then
return void
end ;
res : SAME := create(size) ;
res.copy(self) ;
return res
end ;
copy(
src : SAME
)
pre ~void(self)
and ~void(src)
post true
-- (self.size >= src.size)
-- and {forall ind member dom.src
-- | self(ind) = src(ind)}
-- and {forall ind member dom.self
-- and ~member dom.src
-- | self(ind) =
-- initial(self(ind))
-- or (self.size < src.size)
-- and {forall ind member dom.self
-- | self(ind) = src(ind)}
is
-- This routine copies as many elements from src to self as will fit.
-- Built-in to this implementation.
builtin ARRAY_COPY
end ;
copy(
beg : CARD,
src : SAME
)
pre ~void(self)
and ((beg <= (size - 1))
or (src.size = 0))
post true -- + vdm stuff!?!
is
-- This routine copies as many elements from src to self as will fit
-- when starting at index beg of self. Self may not be void but src may
-- be void. Built-in to this implementation.
builtin ARRAY_COPY_BEG
end ;
copy(
beg,
num : CARD,
src : SAME
)
pre ~void(self)
and ~void(src)
and (beg <= (size - 1))
and (num <= (size - beg))
and (num <= src.size)
post (self.size = initial(self.size))
is
-- This routine copies num elements from src to self starting at index
-- beg of self. Neither self nor src may be void. Built-in to this
-- implementation.
builtin ARRAY_COPY_BEG_NUM
end ;
copy(
beg,
num,
srcbeg : CARD,
src : SAME
)
pre ~void(self)
and ~void(src)
and (beg <= (size - 1))
and (num <= (size - beg))
and (num <= (src.size - srcbeg))
post (self.size = initial(self.size))
is
-- This routine copies num elements from src to self starting at index
-- beg of self and index srcbeg of src. Neither self nor src may be void.
-- Built-in to this implementation.
builtin ARRAY_COPY_BEG_NUM_SRCBEG
end ;
subarr(
beg,
num : CARD
) : SAME
pre ~void(self)
and (beg <= (size - 1))
and (num = (size - beg))
post (result.size = num)
is
-- This routine returns a new array which is a sub-sequence of self,
-- with num entries copied from self starting at beg. Self may not be void.
res : SAME := new(num) ;
res.copy(0,num,beg,self) ;
return res
end ;
to_reverse
pre ~void(self)
post true -- and is reversed, of course!
is
-- This routine reverses the order of the elements in self. Self may
-- not be void.
loop
index : CARD := (size/2).times! ;
up_index : CARD := size - index - 1 ;
temp : T := [index ] ;
[index] := [up_index] ;
[up_index] := temp
end
end ;
reverse : SAME
pre true
post void(result)
or true -- (result.to_reverse = self)
is
-- This routine returns a copy of self with all elements in reverse
-- order. Self may be void.
if void(self) then
return void
else
res: SAME := new(size) ;
loop
res.set!(asize - 1,asize, -1,elt!)
end ;
return res
end
end ;
to(
src : SAME
)
pre (src.size = size)
post true -- (src = self)
is
-- This routine sets self to be a copy of src. Both may be void!
loop
set!(src.elt!)
end
end ;
to_val(
val : T
)
pre true
post void(self)
or (count(val) = size)
is
-- This routine sets each element of self to val. Self may be void.
loop
set!(val)
end
end ;
append(
arr : SAME
) : SAME
pre true
post true -- + vdm stuff !?!
is
-- This routine returns a new array consisting of self followed by
-- arr. Both may be void.
if void(self) then
return arr.copy
elsif void(arr) then
return copy
else
res : SAME := new(size + arr.size) ;
res.copy(self) ;
res.copy(size,arr) ;
return res
end
end ;
append(
arr1,
arr2 : SAME
) : SAME
pre true
post true -- + vdm stuff !?!
is
-- This routine returns a new array consisting of self followed by
-- arr1 and then arr2. This is more efficient than two appends. Any of
-- the arrays may be void.
if void(self) then
return arr1.append(arr2)
elsif void(arr1) then
return append(arr2)
elsif void(arr2) then
return append(arr1)
else
res : SAME := new(size + arr1.size + arr2.size) ;
res.copy(self) ;
res.copy(size,arr1) ;
res.copy(size + arr1.size,arr2) ;
return res
end
end ;
append(
arr1,
arr2,
arr3 : SAME
) : SAME
pre true
post true -- + vdm stuff !?!
is
-- This routine returns a new array consisting of self followed by
-- arr1 then arr2 and finally arr3. This is more efficient than three
-- appends. Any of the arrays may be void.
if void(self) then
return arr1.append(arr2,arr3)
elsif void(arr1) then
return append(arr2,arr3)
elsif void(arr2) then
return append(arr1,arr3)
elsif void(arr3) then
return append(arr1,arr2)
else
res : SAME := new(size + arr1.size + arr2.size + arr3.size) ;
res.copy(self) ;
res.copy(size,arr1) ;
res.copy(size + arr1.size,arr2) ;
res.copy(size + arr1.size + arr2.size,arr3) ;
return res
end
end ;
contains(
elem : T
) : BOOL is
-- This predicate returns true if and only if self contains an element
-- for which elt_eq returns true, otherwise false.
if void(self) then
return false
end ;
loop
if elt_eq(elt!,elem) then
return true
end
end ;
return false
end ;
has(
elem : T
) : BOOL is
-- This predicate is a renaming of contains.
return contains(elem)
end ;
count(
val : T
) : CARD
pre true
post true -- irrespective of result!
is
-- This routine returns the number of array elements which are elt_eq
-- to val. Self may be void.
res : CARD := 0 ;
loop
if elt_eq(elt!,val) then
res := res + 1
end
end ;
return res
end ;
index_of(
elem : T
) : CARD
pre true
post (result = CARD::maxval)
or (~void(self)
and(count(elem) > 0))
is
-- This routine returns the lowest index of an element which is elt_eq
-- to elem. If there is no such element then CARD::maxval is returned.
-- Self may be void.
loop
res : CARD := ind! ;
if elt_eq(elem,[res]) then
return res
end
end ;
return CARD::maxval
end ;
remove(
elem : T
) : SAME
pre true
post ~result.contains(elem)
is
-- This routine returns a new array in which no elements are elt_eq to
-- elem. Self may be void.
if void(self) then
return void
else
res : SAME := create(size - count(elem)) ;
loop
loc_elem : T := elt! ;
if ~elt_eq(loc_elem,elem) then
res.set!(loc_elem)
end
end ;
return res
end
end ;
remove_if(
test : ROUT{T} : BOOL
) : SAME
pre void(self)
or ~void(test)
post true
is
-- This routine returns a new array without those elements which satisfy
-- the given test. Self may be void.
if void(self) then
return void
else
res : SAME := create(size - count_if(test)) ;
loop
elem : T := elt! ;
if ~test.call(elem) then
res.set!(elem)
end
end ;
return res
end
end ;
private is_sorted(
lower : CARD,
upper : CARD
) : BOOL is
-- This predicate returns true if and only if the elements of self are
-- sorted according to the relation elt_lt. Self may be void.
loop
index : CARD := (lower + 1).upto!(upper) ;
if elt_lt([index],[index - 1]) then
return false
end
end ;
return true
end ;
is_sorted : BOOL is
-- This predicate returns true if and only if the elements of self are
-- sorted according to the relation elt_lt. Self may be void.
if self.size = 0 then
return true
else
return is_sorted(0,(asize - 1))
end
end ;
remove_duplicates : SAME
pre is_sorted
post (result.size <= size)
is
-- This routine returns a new arry with only the first copy of
-- duplicated elements. Self may be void. If not it must be sorted
-- prior to calling this routine.
if void(self)
or self.size = 1 then
return self
end ;
res : SAME := new(size) ; -- Same size as self for now...
num_elems : CARD := 0 ; -- No of elems in res!
prev : T := [0] ;
loop
curr : T := elt!(1) ;
if ~elt_eq(prev,curr) then
res[num_elems] := prev ;
num_elems := num_elems + 1
end ;
prev := curr
end ;
res[num_elems] := [size - 1] ;
num_elems := num_elems + 1 ;
return res.resize(num_elems)
end ;
to_replace(
old,
new_val : T
)
pre true
post (initial(count(old)) <= count(new_val))
is
-- This routine replaces those elements that are elt_eq to old by
-- new_val wherever the match is found. Self may be void.
loop
elem : T := elt! ;
if elt_eq(elem,old) then
elem := new_val
end ;
set!(elem)
end
end ;
to_replace_if(
test : ROUT{T} : BOOL,
new_val : T
)
pre void(self)
or ~void(test)
post true
is
-- This routine replaces all of the elements of self which satisfy
-- the given test by new_val. Self may be void.
loop
elem : T := elt! ;
if test.call(elem) then
elem := new_val
end ;
set!(elem)
end
end ;
find_if(
test : ROUT{T} : BOOL
) : T
pre void(self)
or ~void(test)
post true
is
-- Searching from the lowest index, this routine returns the first
-- element which satisfies the given test. If there is no such element
-- then void is returned. Self may be void.
loop
res : T := elt! ;
if test.call(res) then
return res
end
end ;
return void
end ;
index_if(
test : ROUT{T} : BOOL
) : CARD
pre void(self)
or ~void(test)
post (result = CARD::maxval)
or test.call([result])
is
-- This routine returns the index of the first element, searching from
-- zero, which satisfies the given test. If there is no such element then
-- CARD::maxval is returned. Self may be void.
loop
res : CARD := ind! ;
if test.call([res]) then
return res
end
end ;
return CARD::maxval
end ;
mismatch(
arr : SAME
) : CARD
pre true
post (result = CARD::maxval)
or (result < asize)
is
-- This routine returns the index of the first element of self which
-- differs from the corresponding element of arr. If there is no such
-- element or self is void or self is a prefix of arr then CARD::maxval is
-- returned.
if void(self) then
return CARD::maxval
end ;
loop
res : CARD := ind! ;
if ~elt_eq([res],arr.elt!) then
return res
end
end ;
return CARD::maxval
end ;
search(
arr : SAME
) : CARD
pre true
post (result = CARD::maxval)
or (result < asize)
is
-- This routine returns the index of the first sub-array of self,
-- starting at zero, which matches arr. If self is void or there is no
-- match then CARD::maxval is returned.
if void(self) then
return CARD::maxval
end ;
loop
res : CARD := 0.upto!(size - arr.size) ;
match : BOOL := true ;
loop
if ~elt_eq(elt!(res),arr.elt!) then
match := false ;
break!
end
end ;
if match then
return res
end
end ;
return CARD::maxval
end ;
search(
beg : CARD,
arr : SAME
) : CARD
pre ~void(self)
and ~void(arr)
and (beg <= (asize - 1))
post (result = CARD::maxval)
or (result < asize)
is
-- This routine returns the index of the beginning of the first
-- sub-array of self which matches arr, starting at zero. If there is no
-- such sub-array then CARD::maxval is returned.
loop
res : CARD := beg.upto!(size - arr.size) ;
match : BOOL := true ;
loop
if ~elt_eq(elt!(res),arr.elt!) then
match := false ;
break!
end
end ;
if match then
return res
end
end ;
return CARD::maxval
end ;
map(
operation : ROUT{T} : T
)
pre ~void(operation)
post true
is
-- This routine sets each element of self to be the result of applying
-- the given operation to it. Self may be void.
loop
set!(operation.call(elt!))
end
end ;
reduce(
operation : ROUT{T,T} : T
) : T
pre ~void(operation)
post true
is
-- This routine returns the result of applying the given operation
-- to self from the lowest index to the highest. Void is returned if self
-- is void.
if size = 0 then
return void
end ;
val : T := [0] ;
loop
val := operation.call(val,elt!(1,size - 1))
end ;
return val
end ;
scan(
operation : ROUT{T,T} : T
)
pre ~void(operation)
post true
is
-- This routine sets each element of self to be the result of applying
-- the given operation to adjacent elements of self from lowest to highest
-- index. The element with index zero is not altered. Self may be void.
if ~void(self) then
loop
index : CARD := 1.upto!(size - 1) ;
[index] := operation.call([index - 1],[index])
end
end
end ;
-- The following group of operations relate to sorted arrays
insertion_sort_range(
lower,
upper : CARD
)
pre (self.size > 1)
and (lower < upper)
and (upper <= (asize - 1))
post is_sorted(lower,upper)
is
-- This routine performs an insertion sort of the elements of self
-- in the index range lower to upper. Ordering is defined by elt_lt.
loop
out_index : CARD := (lower + 1).upto!(upper) ;
elem : T := [out_index] ;
loop
in_index : CARD := out_index.downto!(lower) ;
if (in_index = lower) then
[lower] := elem ;
break!
elsif (elt_lt([in_index - 1], elem)) then
[in_index] := elem ;
break!
else
[in_index] := [in_index - 1]
end
end
end
end ;
private const quicksort_limit : CARD := 10 ;
-- The value of this is used to stop quicksort recursion and switch to an
-- insertion sort.
quicksort_range(
lower,
upper : CARD
)
pre (self.size > 1)
and (lower < upper)
and (upper <= (asize - 1))
post is_sorted(lower,upper)
is
-- This routine implements part of the quicksort algorithm to search
-- the range of self between lower and upper according to the relation elt_lt
if (upper - lower) > quicksort_limit then
res : CARD := RANDOM::card(lower,upper) ;
temp : T := [res] ; -- Swap the random element & lower
[res] := [lower] ;
[lower] := temp ;
middle : CARD := lower ;
loop
index : CARD := (lower + 1).upto!(upper) ;
if elt_lt([index],temp) then
middle := middle + 1 ;
stemp : T := [middle] ;
[middle] := [index] ;
[index ] := stemp
end
end ;
temp := [lower] ;
[lower] := [middle] ;
[middle] := temp ;
if (middle > 0)
and (lower < (middle - 1)) then
quicksort_range(lower,middle - 1)
end ;
if (middle + 1) < upper then
quicksort_range(middle + 1,upper)
end
else
insertion_sort_range(lower,upper)
end
end ;
sort
pre true
post is_sorted
is
-- This routine sorts the entire array using quick-sort with respect
-- to elt_lt. Self may be void.
if self.size > 1 then -- less than 2 is sorted!
quicksort_range(0,asize - 1)
end
end ;
stable_sort
pre true
post is_sorted
is
-- This routine uses an insertion sort to permute the elements of self
-- so that it is sorted with respect to elt_lt and equal elements are in
-- the original order. Self may be void.
if self.size > 0 then
insertion_sort_range(0,asize - 1)
end
end ;
binary_search(
elem : T
) : CARD
pre is_sorted
post (result = CARD::maxval)
or (result < asize)
is
-- This search routine assumes that self is sorted. It returns
-- the index of the element preceding the first element greater than elem
-- according to elt_lt or CARD::maxval if self is void or if all elements
-- are greater than elem.
if void(self) then
return CARD::maxval
end ;
lower : CARD := 0 ;
upper : CARD := asize - 1 ;
if ~elt_lt(elem,[upper]) then
return upper
end ;
if elt_lt(elem,[lower]) then
return CARD::maxval
end ;
-- At this point [u] is always greater than elem, and [l] is not
-- greater than elem.
loop
while!(upper > (lower + 1)) ;
index : CARD := (upper + lower)/2 ;
if elt_lt(elem,[index]) then
upper := index
else
lower :=index
end
end ;
return lower
end ;
is_sorted_by(
order : ROUT{T,T} : BOOL
) : BOOL
pre void(self)
or ~void(order)
post true
is
-- This predicate returns true if and only if the elements of self are
-- sorted in an order specified by the order routine which is expected to
-- return true if and only if its first argument is less than its second
-- argument. Self may be void.
if ~void(self) then
loop
index : CARD := 1.upto!(asize - 1) ;
if order.call([index],[index - 1]) then
return false
end
end
end ;
return true
end ;
insertion_sort_by(
order : ROUT{T,T} : BOOL
)
pre ~void(order)
post is_sorted_by(order)
is
-- This routine sorts the elements of self using insertion sorting
-- in an order specified by the order routine which is expected to return
-- true if and only if its first argument is less than its second argument.
-- Self may be void.
if void(self) then
return
end ;
loop
out_index : CARD := 1.upto!(asize - 1) ;
elem : T := [out_index] ;
loop
in_index : CARD := (out_index).downto!(0) ;
if (in_index = 0) then
[in_index] := elem ;
break!
elsif (order.call([in_index - 1], elem)) then
[in_index] := elem ;
break!
else
[in_index] := [in_index - 1]
end
end
end
end ;
binary_search_by(
elem : T,
order : ROUT{T,T} : BOOL
) : CARD
pre ~void(order)
and is_sorted_by(order)
post (result = CARD::maxval)
or (result < asize)
is
-- This routine returns the index of the element of self preceding
-- the first element greater than elem unless self is void or all elements
-- are greater then elem, when CARD::maxval is returned.
if void(self) then
return CARD::maxval
end ;
lower : CARD := 0 ;
upper : CARD := asize - 1 ;
if ~order.call(elem,[upper]) then
return upper
end ;
if order.call(elem,[lower]) then
return CARD::maxval
end ;
-- At this point [upper] is known to be greater than elem, and
-- [lower] is not greater than elem.
loop
while!(upper > (lower + 1)) ;
index : CARD := (upper + lower)/2 ;
if order.call(elem,[index]) then
upper := index
else
lower := index
end
end ;
return lower
end ;
merge_with_by(
arr : SAME,
order : ROUT{T,T} : BOOL
) : SAME
pre is_sorted_by(order)
and arr.is_sorted_by(order)
post result.is_sorted_by(order)
is
-- This routine returns a new array with the elements of self merged
-- together according to order which should return true if and only if its
-- first argument is less than its second.
if void(self) then
return arr.copy
end ;
if void(arr) then
return copy
end ;
res : SAME := create(size + arr.size) ;
self_index,
arr_index : CARD ;
temp : T ;
loop
if self_index = size then
temp := arr[arr_index] ;
arr_index := arr_index + 1
elsif arr_index = arr.size then
temp := [self_index] ;
self_index := self_index + 1
elsif order.call([self_index],arr[arr_index]) then
temp := [self_index] ;
self_index := self_index + 1
else
temp := arr[arr_index] ;
arr_index := arr_index + 1
end ;
res.set!(temp)
end ;
return res
end ;
select(
index : CARD
)
pre ~void(self)
and (index < size)
post true
is
-- This routine moves the elements of self so that the element with
-- the given index is not elt_lt any element with lower indices and
-- no element with a larger index is elt_lt it.
lower : CARD := 0 ;
upper : CARD := size - 1 ;
loop
until!(lower >= upper) ;
out_index : CARD := RANDOM::card(lower,upper) ;
temp : T := [out_index] ;
[out_index] := [lower] ;
[lower] := temp ;
middle : CARD := lower ;
loop
in_index : CARD := (lower + 1).upto!(upper) ;
if elt_lt([out_index],temp) then
middle := middle + 1 ;
temp := [middle] ;
[middle] := [in_index] ;
[in_index] := temp
end
end ;
temp := [lower] ;
[lower] := [middle] ;
[middle] := temp ;
if middle <= out_index then
lower := middle + 1
end ;
if middle >= out_index then
upper := middle - 1
end
end
end ;
median : T
pre true
post void(result)
or self.contains(result)
is
-- This routine returns the median of the elements contained in self
-- according to the ordering relation elt_lt. This permutes the elements
-- of self. Void is returned if self is void.
if size = 0 then
return void
end ;
middle : CARD := (size - 1)/2 ;
select(middle) ;
return [middle]
end ;
select_by(
order : ROUT{T,T} : BOOL,
index : CARD
)
pre ~void(self)
and ~void(order)
and (index < size)
post true
is
-- This routine moves the elements of self so that the element with
-- the given index is not less than (as determined by the order routine,
-- which is expected to return true if and only if its first argument is
-- less than its second) any element with lower indices and no element with
-- a larger index is less than it.
lower : CARD := 0 ;
upper : CARD := size - 1 ;
loop
until!(lower >= upper) ;
out_index : CARD := RANDOM::card(lower,upper) ;
temp : T := [out_index] ;
[out_index] := [lower] ;
[lower] := temp ;
middle : CARD := lower ;
loop
in_index : CARD := (lower + 1).upto!(upper) ;
if order.call([in_index],temp) then
middle := middle + 1 ;
temp := [middle] ;
[middle] := [in_index] ;
[in_index] := temp
end
end ;
temp := [lower] ;
[lower] := [middle] ;
[middle] := temp ;
if middle <= out_index then
lower := middle + 1
end ;
if middle >=out_index then
upper := middle - 1
end
end
end ;
-- The iters over array elements.
elt! : T
pre ~void(self)
post (self.contains(result))
is
-- This iter yields each element of self in order. Self may be void.
-- Built-in to this implementation.
builtin ARRAY_ELTB
end ;
elt!(
once beg : CARD
) : T
pre ~void(self)
and (beg <= (asize - 1))
post contains(result) -- (result = [ind!])
is
-- This iter yields each element of self starting at `beg'. Self may
-- not be void. Built-in to this implementation.
builtin ARRAY_ELT_BEGB
end ;
elt!(
once beg,
once num : CARD
) : T
pre ~void(self)
and (beg <= (size - 1))
and (num <= (size - beg))
post contains(result) -- (result = [beg + ind!])
is
-- This iter yields num successive elements of self starting at
-- index beg. Self may not be void. Built-in to this implementation.
builtin ARRAY_ELT_BEG_NUMB
end ;
elt!(
once beg,
once num : CARD,
once step : INT
) : T
pre ~void(self)
and is_legal_aelts_arg(beg,num,step)
post contains(result) -- (result = [beg + ind!])
is
-- This iter yields num elements of self starting at beg and stepping
-- by step which must not be zero. Self may not be void. Built-in to this
-- implementation.
builtin ARRAY_ELT_BEG_NUM_STEPB
end ;
set!(
val : T
)
pre true
post contains(val) -- ([ind!] = val)
is
-- This iter sets successive elements of self to the values of val.
-- Self may be void. Built_in to this implementation.
builtin ARRAY_SETB
end ;
set!(
once beg : CARD,
val : T
)
pre ~void(self)
and (beg <= (size - 1))
post contains(val) -- ([beg + ind!] = val)
is
-- This iter sets successive elements starting at beg to the values of
-- val. Self may not be void. Built-in to this implementation.
builtin ARRAY_SET_BEGB
end ;
set!(
once beg,
once num : CARD,
val : T
)
pre ~void(self)
and (beg <= (size - 1))
and (num <= (size - beg))
post contains(val) -- ([beg + ind!] = val)
is
-- This iter sets num successive elements of self starting at beg
-- to the values of val. Self may not be void. Built-in to this
-- implementation.
builtin ARRAY_SET_BEG_NUMB
end ;
set!(
once beg,
once num : CARD,
once step : INT,
val : T
)
pre ~void(self)
and is_legal_aelts_arg(beg,num,step)
post contains(val) -- + vdm stuff !?!
is
-- This iter sets num elements of self starting at beg stepping by
-- step to the values of val. Step must not be zero. Self may not be void.
-- Built-in to this implementation.
builtin ARRAY_SET_BEG_NUM_STEPB
end ;
ind! : CARD
pre true
post (result < size)
is
-- This iter yields the indices of self in order. Self may be void.
-- Built-in to this implementation.
builtin ARRAY_INDB
end ;
ind1! : CARD
pre true
post (result < size)
is
-- This iter yields the indices of self in order. Self may be void.
-- Built-in to this implementation.
--
-- NOTE This is provided for consistency with ARRAY2 and ARRAY3 classes.
builtin ARRAY_INDB
end ;
end ; -- class ARRAY{T}