"

 COPYRIGHT (c) 1993 by Claus Gittinger

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

"{ Package: 'stx:libbasic' }"

OrderedCollection subclass:#SortedCollection

	instanceVariableNames:'sortBlock'

	classVariableNames:'DefaultSortBlock'

	poolDictionaries:''

	category:'Collections-Sequenceable'

!

!SortedCollection class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1993 by Claus Gittinger

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

!

documentation

"

    I keep my elements sorted. The sort order is defined by a sortblock,

    a two-argument block which, when given two elements of the collection,

    should return true if the element given as first arg has to come before the

    element given as second arg.

    Equal elements may occur multiple times.

    SortedCollection uses quickSort to resort and a binary search when adding/removing elements.

    Because insertion/removal may require that remaining elements have to

    be shifted within the container, adding many individual elements may be done faster

    by creating a completely new collection from the unsorted elements.

    (see examples)

    A sortBlock of [:a :b | a < b] defines ascending sort-order,

    while [:a :b | a > b] defines descening order.

    The default sortBlock for SortedCollections is the first one.

    Compatibility Warning:

        VW seems to use a default sortBlock which compares a<=b, wheras ST/X uses a<b.

        That means, that elements which are compared MUST understand #< in ST/X

        while the minumum protocol is #<= in VW.

        This may be changed in a future release of ST/X

        (it is not yet, to not confuse existing applications ...

         ... be aware, that the sortBlock has an effect on a few algorithms

         found here; especially #indexForInserting is critical.)

    [caveat:]

        a balanced tree may be a better choice, as inserting may be slow when

        elements have to be shifted.

    [author:]

        Claus Gittinger

"

!

examples

"

    when many elements are to be added, it may be better to add them

    all en-bloeque instead of individually.

    The reason is that for each individual #add:, the contents has to be

    shifted, to create an empty slot for the new element.

    timing example:

        |o rnd|

        o := SortedCollection new.

        rnd := Random new.

        10000 timesRepeat:[

            o add:rnd next.

        ]

    takes 1365 ms on a P5 (admitted: this is a fast machine ;-)

    Times are a'changing: 

        Just came around 2005: on my 1.5Ghz laptop, this now takes 260ms...

        an another comment 2008: on a 1.8Ghz laptop, it takes now 105ms...

    In contrast:

        |o rnd|

        o := OrderedCollection new.

        rnd := Random new.

        10000 timesRepeat:[

            o add:rnd next.

        ].

        o := o asSortedCollection

    takes 383 ms on the same machine.

        2005: on my 1.5Ghz laptop, this now takes 100ms

        2008: on a 1.8Ghz laptop, this now takes 47ms

    If you already have a big sortedCollection at hand, adding multiple

    items may be better done with #addAll:, which resorts all elements, if

    the number of added items is more than some threshold number.

    However, the break-even point where bulk-adding is faster depends

    on the machine ... (and ST/X version ;-).

  adding elements in order:

    |c|

    Time millisecondsToRun:[

        10 timesRepeat:[

            |c|

            c := SortedCollection new.

            (1 to:100000) do:[:e | c add:e].

        ]

    ].    

    (5.4.1: 2031 2187)

    (5.4.3: 484 516)

    |c|

    c := SortedCollection new.

    (1 to:100000) do:[:e | c add:e].

    self assert:(c asBag = (1 to:100000) asBag).

  adding elements in reverse order:

    Time millisecondsToRun:[

        10 timesRepeat:[

            |c|

            c := SortedCollection new.

            (1 to:100000) reverseDo:[:e | c add:e].

        ]

    ].        

    (5.4.1: 201969)

    (5.4.3: 1609 1766)

    |c|

    c := SortedCollection new.

    (1 to:100000) reverseDo:[:e | c add:e].

    self assert:(c asBag = (1 to:100000) asBag).

  adding elements in random order:

    |toAdd|

    toAdd := (1 to:100000) asOrderedCollection randomShuffle.

    Time millisecondsToRun:[

        10 timesRepeat:[

            |c|

            c := SortedCollection new.

            toAdd do:[:e | c add:e].

        ]

    ].

    (5.4.1: 108484)

    (5.4.3: 75734)

    |c|

    c := SortedCollection new.

    (1 to:100000) asOrderedCollection randomShuffle do:[:e | c add:e].

    self assert:(c asBag = (1 to:100000) asBag).

"

! !

!SortedCollection class methodsFor:'initialization'!

initialize

    "setup the default sortBlock.

     Use #<, since this is the base method in Magnitude."

    "/ only do this once at early startup

    DefaultSortBlock isNil ifTrue:[

        DefaultSortBlock := [:a :b | a < b]

    ]

    "

     SortedCollection initialize

    "

    "Modified: 12.4.1996 / 12:29:27 / cg"

! !

!SortedCollection class methodsFor:'instance creation'!

forStrings

    "this is supposed to return a sortedCollection, which sorts using

     the current locales collating sequence. For now, simply use a

     normal string compare.

     This will change"

    ^ self new

    "Modified: 13.9.1997 / 10:18:58 / cg"

    "Created: 13.9.1997 / 10:41:54 / cg"

!

forStrings:size

    "this is supposed to return a sortedCollection, which sorts using

     the current locales collating sequence. For now, simply use a

     normal string compare.

     This will change"

    ^ self new:size

    "Modified: 13.9.1997 / 10:18:58 / cg"

!

new

    "return a new sortedCollection, the sorting is done using

     a compare for a < b, in ascending order"

    ^ super new setSortBlock:DefaultSortBlock

    "Modified: 12.4.1996 / 12:28:18 / cg"

!

new:size

    "return a new sortedCollection with preallocated size.

     The sorting is done using a compare for a < b, in ascending order"

    ^ (super new:size) setSortBlock:DefaultSortBlock

    "Modified: 12.4.1996 / 12:28:22 / cg"

!

sortBlock:aBlock

    "return a new sortedCollection, whe the sort order is defined

     by aBlock.

     This must be a two-argument block which returns true if its arg1 has to come before

     its arg2 in the collection."

    ^ super new setSortBlock:aBlock

    "default:

     |s|

     s := SortedCollection new.

     s add:15; add:99; add:3; add:-29; add:17; add:-6.

     Transcript showCR:s

    "

    "sorting by absolute values:

     |s|

     s := SortedCollection sortBlock:[:a :b | a abs < b abs].

     s add:15; add:99; add:3; add:29; add:17; add:-6.

     Transcript showCR:s

    "

    "default again:

     |s|

     s := SortedCollection new.

     s add:'foo'; add:'Bar'; add:'baz'; add:'hello'; add:'world'; add:'Wow'.

     Transcript showCR:s

    "

    "sorting strings caseless:

     |s|

     s := SortedCollection sortBlock:[:a :b | a asLowercase < b asLowercase].

     s add:'foo'; add:'Bar'; add:'baz'; add:'hello'; add:'world'; add:'Wow'.

     Transcript showCR:s

    "

    "Modified: 12.4.1996 / 12:26:28 / cg"

!

withAll:aCollection sortBlock:aBlock

    "initialize from aCollection and set the sort-block"

    ^ (self sortBlock:aBlock) addAll:aCollection; yourself

    "

     SortedCollection withAll:#(1 2 3 4 5 6 7 8 9 0)

		      sortBlock:[:a :b | a > b]

    "

    "default:

     |s|

     s := SortedCollection withAll:#(15 99 3 29 17 -6).

     Transcript showCR:s

    "

    "sorting by absolute values:

     |s|

     s := SortedCollection withAll:#(15 99 3 29 17 -6) sortBlock:[:a :b | a abs < b abs].

     Transcript showCR:s

    "

    "default again:

     |s|

     s := SortedCollection withAll:#('foo' 'Bar' 'baz' 'hello' 'world' 'Wow').

     Transcript showCR:s

    "

    "sorting strings caseless:

     |s|

     s := SortedCollection withAll:#('foo' 'Bar' 'baz' 'hello' 'world' 'Wow') sortBlock:[:a :b | a asLowercase < b asLowercase].

     Transcript showCR:s

    "

    "Modified: 12.4.1996 / 12:28:09 / cg"

! !

!SortedCollection class methodsFor:'Compatibility-Dolphin'!

sortBlock:aBlock withAll:aCollection

    ^ self withAll:aCollection sortBlock:aBlock

! !

!SortedCollection methodsFor:'adding & removing'!

add:anObject

    "add the argument, anObject at the proper place in the receiver. 

     Returns the argument, anObject (sigh)."

    |index lastElement|

    "/

    "/ cg: the original code was simply:

    "/

    "/  index := self indexForInserting:anObject.

    "/  index := self makeRoomAtIndex:index.

    "/  contentsArray basicAt:index put:anObject.

    "/

    "/  which was nice and simple to understand.

    "/ However, the code below is 5 times faster, if elements are added in an already ordered fashion,

    "/ which often happens.

    "/ so we allow the code to be a bit more complicated...

    (lastIndex < firstIndex "i.e. self size == 0"

    or:[ 

        lastElement := contentsArray at:lastIndex.

        (sortBlock value:lastElement value:anObject)    

    ]) ifTrue:[

        "/ empty or lastElement is smaller then newElement; add at the end

        index := lastIndex.

        (index == contentsArray size) ifTrue:[

            self makeRoomAtLast.

            index := lastIndex.

        ].

        lastIndex := index := index + 1.

    ] ifFalse:[

        index := self indexForInserting:anObject.

        (index == firstIndex) ifTrue:[

            (firstIndex == 1) ifTrue:[

                self makeRoomAtFront.

            ].

            index := firstIndex := firstIndex - 1.

        ] ifFalse:[

            index := self makeRoomAtIndex:index.

        ].

    ].

    contentsArray basicAt:index put:anObject.

    ^ anObject

    "

     #(7 3 9 10 99) asSortedCollection add:5; yourself

     #(7 3 9 10 99) asSortedCollection add:1; yourself

     #(7 3 9 10 99) asSortedCollection add:1000; yourself

     #(7 3 9 10 99) asSortedCollection add:1; yourself   

    "

    "Modified: / 22-10-2008 / 17:09:39 / cg"

!

addAll:aCollection

    "add all elements of the argument, aCollection to the receiver.

     Returns the argument, aCollection (sigh)."

    |addedCollection mySize numAdded|

    numAdded := aCollection size.

    mySize := self size.

    (aCollection isSortedCollection

     and:[aCollection sortBlock == sortBlock]) ifTrue:[

        addedCollection := aCollection.

    ] ifFalse:[

        addedCollection := Array withAll:aCollection.

        addedCollection stableSort:sortBlock.

        mySize == 0 ifTrue:[

            "/ special case: I am empty - add them en-bloque.

            contentsArray := addedCollection.

            firstIndex := 1.

            lastIndex := numAdded.

            ^ aCollection

        ].

    ].

    "/

    "/ do a mergeSort with the sortedContents

    "/

    self mergeSorted:addedCollection.

    ^ aCollection

    "

     #(7 3 9 10 99) asSortedCollection addAll:#(77 0 1 16 5); yourself

     ( #(7 3 9 10 99) asSortedCollection:[:a :b | a > b])

         addAll:#(77 0 1 16 5); yourself

     #(7 3 9 10 99) asSortedCollection

        addAll:( #(77 0 1 16 5) asSortedCollection:[:a :b | a > b]); yourself

     (#(7 3 9 10 99) asSortedCollection:[:a :b | a > b])

        addAll:( #(77 0 1 16 5) asSortedCollection:[:a :b | a < b]); yourself

    "

    "

     |x e|

     e := (1 to:100) asSortedCollection.

     TimeDuration toRun:[

         10000 timesRepeat:[

            x := SortedCollection new:100.

            x addAll:e. 

         ].

     ].      

    "

    "Modified: 13.4.1996 / 12:42:15 / cg"

!

mergeSorted:aSortedCollection

    "add all elements of the argument, aSortedCollection to the receiver.

     This leads to an error, if the argument is not sorted.

     This should be used when a number of elements is to be added.

     Notice, that quicksort degenerates to a veeery slow bubble-like

     sort when a collection of already sorted elements is given to it.

     Therefore, adding chunks is better done by sorting the chunk and merging

     it in, instead of resorting the receiver.

     aSortedCollection must be sorted by the same sortBlock as myself!!"

    |newContentsArray

     contentsArray2

     destIndex "{ Class: SmallInteger }"

     n1        "{ Class: SmallInteger }"

     n2        "{ Class: SmallInteger }"

     srcIndex1 "{ Class: SmallInteger }"

     srcIndex2 "{ Class: SmallInteger }"

     last1     "{ Class: SmallInteger }"

     last2     "{ Class: SmallInteger }"

     end1Reached end2Reached

     el1 el2 |

    n2 := aSortedCollection size.

    n2 == 0 ifTrue:[

        ^ self.

    ].

    aSortedCollection isSortedCollection ifTrue:[

        contentsArray2 := aSortedCollection contentsArray.

        srcIndex2 := aSortedCollection firstIndex.

    ] ifFalse:[

        contentsArray2 := aSortedCollection.

        srcIndex2 := 1.

    ].

    n1 := self size.

    n1 == 0 ifTrue:[

        firstIndex := srcIndex2.

        lastIndex := firstIndex + n2 - 1.

        contentsArray := contentsArray2 copy.