Section Header
  
  
    + name     := FAST_ARRAY[E];
    
  
    - author      :="Boutet Jerome (boutet@loria.fr)";
  
  
    - comment     :="Resizable, fixed lower bound array.\
                  \Unlike ARRAY, the `lower' bound of a FAST_ARRAY is frozen \
                  \to 0. Thus, some memory is saved and looping toward `lower' \
                  \bound (which is 0) run a little bit faster.";
		  		  
  
 General purpose resizable FAST_ARRAYs. The only difference with ARRAY is the 
  
 fact that the `lower' bound is actually frozen to 0. The `item' access is likely
  
 to be more efficient as well as loop going from `upper' to `lower' just because 
  
 `lower' is 0. Keep in mind that even if the `lower' is frozen to 0
  
 it is really better to use the `lower' attribute, and not 0 directly, just because 
  
 you may decide in the future to use another COLLECTION implementation.
  
  
 Like ARRAY, the FAST_ARRAY implementation uses only one chunk of memory, the 
  
 `storage' area which is a NATIVE_ARRAY. One must keep in mind that this internal 
  
 `storage' area is always kept left align. Thus, you can expect good performances 
  
 while using a FAST_ARRAY to modelize a stack behavior with 
  
 `add_last' / `last' / `remove_last'. Conversely `add_first' and `remove_first' are 
  
 likely to slow down your program if they are too often used. If the fact that 
  
 `lower' is stuck to 0 do matter, also consider ARRAY.
		  
Section Inherit
  
  
    + parent_arrayed_collection:Expanded ARRAYED_COLLECTION[E];
  
Section Public
  
  
    - lower:INTEGER :=  
         Frozen lower bound.
  
  
  
 Creation and modification:
  
  
  
    - create new_count:INTEGER :SELF <-
  
         Make array with range [0 .. `new_count' - 1].
  
         When `new_count' = 0 the array is empty.
    
  
    - create_with_capacity new_count:INTEGER :SELF <-
  
         Create an empty array with at least `needed_capacity'.
    
  
    - create_with_native_array_byte na:NATIVE_ARRAY[UINTEGER_8] size s:INTEGER :SELF <-
    
  
    - make_with_map_object obj:OBJECT <-
  
         BSBS: A revoir.
    
  
    - make_with_native_array_byte na:NATIVE_ARRAY[UINTEGER_8] size s:INTEGER <-
    
  
    - make new_count:INTEGER <-
  
         Make array with range [0 .. `new_count' - 1].
  
         When `new_count' = 0 the array is empty.
      
  
    - with_capacity needed_capacity:INTEGER <-
  
         Create an empty array with at least `needed_capacity'.
    
  
  
 Hashable.
  
  
  
    - hash_code:INTEGER <-
    
  
  
 Modification:
  
  
    - set_capacity new_capacity:INTEGER <-
  
         Resize capacity the array, but not count.
    
  
    - resize new_count:INTEGER <-
  
         Resize the array. When `new_count' is greater than
  
         `count', new positions are initialized with appropriate
  
         default values.
    
  
  
 Implementation of deferred:
  
  
  
    - is_empty:BOOLEAN <-  
         end is_empty
    
  
    - item i:INTEGER :E <- 
      
  
    - put element:E to i:INTEGER <-
      
  
    - add_first element:E <-
      
  
    - add_last element:E <-
    
  
    - count:INTEGER <-  
         end count
    
  
    - clear <-
      
  
    - copy other:FAST_ARRAY[E] <-
  
         Copy `other' onto Current.
    
  
    - set_all_with v:E <-
   
    
  
  
 Sort    
  
  
  
    - bubble_sort <-
  
         Bubble sort :-( => BSBS: Optmize with Quick sort...
    
  
  
  
  
  
    - from_collection model:COLLECTION[E] <-
      
  
    - '=='  Right 60 other:COLLECTION[E] :BOOLEAN <-
      
  
    - is_equal_map other:SELF :BOOLEAN <- 
      
  
    - all_default:BOOLEAN <- 
      
  
    - occurrences element:E :INTEGER <- 
      
  
    - fast_occurrences element:E :INTEGER <- 
    
  
    - first_index_of element:E :INTEGER <- 
  
  
    - index_of element:E start start_index:INTEGER :INTEGER <- 
    
  
    - reverse_index_of element:E start start_index:INTEGER :INTEGER <-
      
  
    - fast_first_index_of element:E :INTEGER <- 
  
  
    - fast_index_of element:E start start_index:INTEGER :INTEGER <- 
    
  
    - fast_reverse_index_of element:E start start_index:INTEGER :INTEGER <-
  	  
  
    - subarray min:INTEGER to max:INTEGER :SELF <-  
         slice
      
  
    - force element:E to index:INTEGER <- 
      
  
    - remove_first <- 
      
  
    - remove_head n:INTEGER <-
      
  
    - remove index:INTEGER <- 
    
  
    - remove beg:INTEGER to end:INTEGER <-
  
  
    - remove_since beg:INTEGER <-
      
  
  
 Guru Section.
  
  
  
    - set_upper new_up:INTEGER <-