A void AddSorted<U>(IEnumerable<U> items) 
Add all the items from another collection with an enumeration order that
is increasing in the items.
Throws   System.ArgumentException  if the enumerated items turns out
not to be in increasing order. 
Type parameters:   U   Constraints:    U : T 
Parameters:  items:  The collection to add. 

A bool Cut(System.IComparable<T> cutFunction, out T low, out bool lowIsValid, out T high, out bool highIsValid) 
Given a "cut" function from the items of the sorted collection to int
whose only sign changes when going through items in increasing order
can be
 from positive to zero
 from positive to negative
 from zero to negative
The "cut" function is supplied as the CompareTo method
of an object c implementing
IComparable<T> .
A typical example is the case where T is comparable and
cutFunction is itself of type T .
This method performs a search in the sorted collection for the ranges in which the
"cut" function is negative, zero respectively positive. If T is comparable
and c is of type T , this is a safe way (no exceptions thrown)
to find predecessor and successor of c .
If the supplied cut function does not satisfy the signchange condition,
the result of this call is undefined.
Returns:  True if the cut function is zero somewhere
on this collection.  Parameters:  cutFunction:  The cut function T to int , given
by the CompareTo method of an object implementing
IComparable<T> .  low:  Returns the largest item in the collection, where the
cut function is positive (if any).  lowIsValid:  Returns true if the cut function is positive somewhere
on this collection.  high:  Returns the least item in the collection, where the
cut function is negative (if any).  highIsValid:  Returns true if the cut function is negative somewhere
on this collection. 

A T DeleteMax() 
Remove the largest item from this sorted collection.
Returns:  The removed item. 

A T DeleteMin() 
Remove the least item from this sorted collection.
Returns:  The removed item. 

A T FindMax() 
Find the current largest item of this sorted collection.
Returns:  The largest item. 

A T FindMin() 
Find the current least item of this sorted collection.

A T Predecessor(T item) 
Find the strict predecessor in the sorted collection of a particular value,
that is, the largest item in the collection less than the supplied value.
Throws   NoSuchItemException  if no such element exists (the
supplied value is less than or equal to the minimum of this collection.) 
Returns:  The predecessor.  Parameters:  item:  The item to find the predecessor for. 

A IDirectedCollectionValue<T> RangeAll() 
Create a directed collection with the same items as this collection.
The returned collection is not a copy but a view into the collection. The view is fragile in the sense that changes to the underlying collection will
invalidate the view so that further operations on the view throws InvalidView exceptions. Returns:  The result directed collection. 

A IDirectedEnumerable<T> RangeFrom(T bot) 
Query this sorted collection for items greater than or equal to a supplied value.
The returned collection is not a copy but a view into the collection. The view is fragile in the sense that changes to the underlying collection will
invalidate the view so that further operations on the view throws InvalidView exceptions. Returns:  The result directed collection.  Parameters:  bot:  The lower bound (inclusive). 

A IDirectedEnumerable<T> RangeFromTo(T bot, T top) 
Query this sorted collection for items between two supplied values.
The returned collection is not a copy but a view into the collection. The view is fragile in the sense that changes to the underlying collection will
invalidate the view so that further operations on the view throws InvalidView exceptions. Returns:  The result directed collection.  Parameters:  bot:  The lower bound (inclusive).  top:  The upper bound (exclusive). 

A IDirectedEnumerable<T> RangeTo(T top) 
Query this sorted collection for items less than a supplied value.
The returned collection is not a copy but a view into the collection. The view is fragile in the sense that changes to the underlying collection will
invalidate the view so that further operations on the view throws InvalidView exceptions. Returns:  The result directed collection.  Parameters:  top:  The upper bound (exclusive). 

A void RemoveRangeFrom(T low) 
Remove all items of this collection above or at a supplied threshold.
Parameters:  low:  The lower threshold (inclusive). 

A void RemoveRangeFromTo(T low, T hi) 
Remove all items of this collection between two supplied thresholds.
Parameters:  low:  The lower threshold (inclusive).  hi:  The upper threshold (exclusive). 

A void RemoveRangeTo(T hi) 
Remove all items of this collection below a supplied threshold.
Parameters:  hi:  The upper threshold (exclusive). 

A T Successor(T item) 
Find the strict successor in the sorted collection of a particular value,
that is, the least item in the collection greater than the supplied value.
Throws   NoSuchItemException  if no such element exists (the
supplied value is greater than or equal to the maximum of this collection.) 
Returns:  The successor.  Parameters:  item:  The item to find the successor for. 

A T WeakPredecessor(T item) 
Find the weak predecessor in the sorted collection of a particular value,
that is, the largest item in the collection less than or equal to the supplied value.
Throws   NoSuchItemException  if no such element exists (the
supplied value is less than the minimum of this collection.) 
Returns:  The weak predecessor.  Parameters:  item:  The item to find the weak predecessor for. 

A T WeakSuccessor(T item) 
Find the weak successor in the sorted collection of a particular value,
that is, the least item in the collection greater than or equal to the supplied value.
Throws   NoSuchItemException  if no such element exists (the
supplied value is greater than the maximum of this collection.) 
Returns:  The weak successor.  Parameters:  item:  The item to find the weak successor for. 
