flex_array 0.2.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YzZiYThmNDY2YTU2NGE5YmQzNjUxNjRhODdkMzJiMGEwMWNiM2MwZg==
+  data.tar.gz: !binary |-
+    M2NjZmZmMjM2ZmEzMGNkNzc1NjFiNWEwNDE4ZTc3Y2M3ZmVkZjYzOQ==
+SHA512:
+  metadata.gz: !binary |-
+    MmJlZDVkZTRiMzJhMmU3ZTEyNmU3MmQyM2Q0NWQ3MDAxNTRjZDkzMGRlZjE4
+    ZjMyY2EzYzA4N2RjY2U5YzVlNjg3NGM4ZTQwNTAxOGFlNWYzYzAyN2MyNjE1
+    M2FlMWI1N2YwYTk0MGQ4ZTBjMmQ3N2M1MDZjMzYzNjM1YmRmZWY=
+  data.tar.gz: !binary |-
+    MjYwNDJkODI2YzA2YTE0NTY5MmZiZmQxNGYyNzA0NzExYzI0YWI1N2U3MGVm
+    NDliYWIxZTQyYjJhYzQzM2I4NDljOTI0NGZlZDQwNjlhMThmYjU2NDA5OGJk
+    NjQxZGM3YWEzZWIyYmU0MzA4NzNjYjgyYjNlNjkwMTdmZDgwMjg=

data/lib/flex_array/array.rb

@@ -0,0 +1,55 @@
+require_relative '../flex_array'
+
+#Extensions to Array needed to support flex array.
+class Array
+  #Get the specifications of the array index values.
+  #<br>Returns
+  #* An array with one range in it.
+  def limits
+    [0...self.length]
+  end
+  
+  #Quick access to the limits for internal use.
+  #<br>Returns
+  #* An array with one spec component in it.
+  def array_specs
+    [SpecComponent.new(0...self.length, 1)]
+  end
+  
+  #Quick access to the array data for internal use.
+  #<br>Returns
+  #* An array -- self
+  def array_data
+    self
+  end
+  
+  alias :length :count
+  
+  #Convert this array to an range index against the spec.
+  #<br>Parameters
+  #* spec - The spec component used to validate this index.
+  #<br>Returns
+  #* A range.
+  #<br>Exceptions
+  #* IndexError if the range is not valid.
+  def to_index_range(spec)
+    self_min, self_max, spec_max = Integer(self[0]), Integer(self[1]), spec.max
+    self_min = spec_max + self_min + 1 if self_min < 0
+    self_max = spec_max + self_max + 1 if self_max < 0
+    
+    if self.length == 2 && self_min <= self_max && spec === self_min && spec === self_max
+      self_min..self_max
+    else
+      fail IndexError, "Subscript invalid or out of range: #{self.inspect}"
+    end
+  end  
+  
+  #Return this flex array as a flex array!
+  #<br>Returns
+  #* A flex array that references this array.
+  #<br>Note
+  #* To avoid a shared reference, use my_array.dup.to_flex_array instead.
+  def to_flex_array
+    FlexArray.new_from_array(self)
+  end
+end

data/lib/flex_array/flex_array_append.rb

@@ -0,0 +1,51 @@
+#* flex_array_append.rb - The flexible array class << and related methods.
+class FlexArray
+  #Append to the flex array.
+  #<br>Parameters
+  #* data - the data being appended to this array.
+  #<br>Returns
+  #* The array spec of the array being appended.
+  #<br>Exceptions
+  #* ArgumentError if the data may not be appended.
+  def << (data)
+    specs = get_append_specs(data = data.in_array)
+    data.array_data.each {|element| @array_data << element }
+    @array_specs[0].enlarge(specs[0].span)
+    @count += data.count
+    self
+  end
+
+  #Make a copy of the other's data.
+  #<br>Parameters
+  #* other - The flex array whose data is to be copied.
+  def copy_data(other)
+    fail ArgumentError, "Incompatible data copy." unless compatible?(other)
+    @array_data = other.array_data.dup
+  end
+
+  private
+  #Extract and validate the append array_spec
+  #<br>Parameters
+  #* data - the data being appended to this array.
+  #<br>Returns
+  #* The array spec of the array being appended.
+  #<br>Exceptions
+  #* ArgumentError if the data may not be appended.
+  def get_append_specs(data)
+    spec_len = (specs = data.array_specs).length
+    
+    if @dimensions == spec_len+1
+      specs.insert(0, SpecComponent.new(0...1, nil))
+    elsif @dimensions != spec_len
+      fail ArgumentError, "Incompatible dimensionality error on <<."
+    end
+    
+    (1...@dimensions).each do |index|
+      unless @array_specs[index] == specs[index]
+        fail ArgumentError, "Dimension mismatch error on <<."
+      end
+    end
+    
+    specs
+  end
+end

data/lib/flex_array/flex_array_each.rb

@@ -0,0 +1,98 @@
+#* flex_array_each.rb - The flexible array class each and related methods.
+class FlexArray
+  #Process the standard :each operator.
+  #<br>Parameters
+  #* indexes - An array with as many entries as the flexible array has 
+  #  dimensions. See [] for more details. Note that since indexes is NOT
+  #  a splat parameter, it must be passed as an array explicitly. If omitted
+  #  or passed in as [:all] all elements of the array are processed.
+  #* block - The optional block to be executed for each selected array element.
+  #  The return value is the last value returned by the block. If the block 
+  #  is not present, an enumerator object is returned.
+  #<br>Block Arguments
+  #* value - Each value selected by the iteration.
+  def each(indexes=[:all], &block)
+    if validate_all_or_index_count(indexes)
+      @array_data.each(&block)
+    elsif block_given?
+      process_indexes(indexes) {|_index, posn| block.call(@array_data[posn])}
+    else
+      Enumerator.new do |yielder|
+        process_indexes(indexes) {|_index, posn| yielder.yield(@array_data[posn])}
+      end
+    end
+  end
+
+  #Retrieve data from the array endlessly repeating as needed.
+  #<br>Parameters
+  #* indexes - An array with as many entries as the flexible array has 
+  #  dimensions. See [] for more details. Note that since indexes is NOT
+  #  a splat parameter, it must be passed as an array explicitly. If omitted
+  #  or passed in as [:all] all elements of the array are processed.
+  #* block - The optional block to be executed for each selected array element.
+  #  The return value is the last value returned by the block. If the block 
+  #  is not present, then an enumerator object is returned.
+  #<br>Block Arguments
+  #* value - Each value selected by the iteration.  
+  def cycle(indexes=[:all], &block)
+    if validate_all_or_index_count(indexes)
+      @array_data.cycle(&block)
+    elsif block_given?
+      loop {process_indexes(indexes) {|_index, posn| block.call(@array_data[posn])}}
+    else
+      Enumerator.new do |yielder|
+        loop {process_indexes(indexes) {|_index, posn| yielder.yield(@array_data[posn])}}
+      end
+    end
+  end
+  
+  #Process the standard :each_with_index operator.
+  #<br>Parameters
+  #* indexes - An array with as many entries as the flexible array has 
+  #  dimensions. See [] for more details. Note that since indexes is NOT
+  #  a splat parameter, it must be passed as an array explicitly. If omitted
+  #  or passed in as [:all] all elements of the array are processed.
+  #* block - The optional block to be executed for each selected array element.
+  #  The return value is the last value returned by the block. If the block 
+  #  is not present, then an enumerator object is returned.
+  #<br>Block Arguments
+  #* value - Each value selected by the iteration.
+  #* index - An array with the full index of the selected value.
+  def each_with_index(indexes=[:all], &block)
+    validate_all_or_index_count(indexes)
+
+    if block_given?
+      process_indexes(indexes) {|index, posn| block.call(@array_data[posn], index)}
+    else
+      Enumerator.new do |yielder|
+        process_indexes(indexes) {|index, posn| yielder.yield(@array_data[posn], index)}
+      end
+    end
+  end
+  
+  #A specialized each variant that passes the low level data, the index 
+  #and the position to the block.
+  #<br>Parameters
+  #* indexes - An array with as many entries as the flexible array has 
+  #  dimensions. See [] for more details. Note that since indexes is NOT
+  #  a splat parameter, it must be passed as an array explicitly. If omitted
+  #  or passed in as [:all] all elements of the array are processed.
+  #* block - The optional block to be executed for each selected array element.
+  #  The return value is the last value returned by the block. If the block 
+  #  is not present, then an enumerator object is returned.
+  #<br>Block Arguments
+  #* data - A reference to the low level data store.
+  #* index - An array with the full index of the selected value.
+  #* posn - The position of the data in the low level data store.
+  def _each_raw(indexes=[:all], &block)
+    validate_all_or_index_count(indexes)
+
+    if block_given?
+      process_indexes(indexes) {|index, posn| block.call(@array_data, index, posn)}
+    else
+      Enumerator.new do |yielder|
+        process_indexes(indexes) {|index, posn| yielder.yield(@array_data, index, posn)}
+      end
+    end
+  end
+end

data/lib/flex_array/flex_array_index.rb

@@ -0,0 +1,42 @@
+#* flex_array_index.rb - The flexible array indexing and related methods.
+class FlexArray
+  #Retrieve the selected data from the \FlexArray.
+  #<br>Parameters
+  #* indexes - An array with as many entries as the flexible array has 
+  #  dimensions. These entries may be an integer that is in the bounds of
+  #  the range limit of that dimension, or it can be a range where the start
+  #  and end of the range are in the bounds of the range limit of that 
+  #  dimension, or it can be the symbol :all for all of the possible values
+  #  of that dimension.
+  #<br>Returns
+  #* The data selected by the index or an array of data if the index selects
+  #  more than one cell.  
+  #<br>Note 
+  #* If the indexes parameter equals a single :all this maps to all
+  #  elements of the array, regardless of its dimensionality.
+  def [](*indexes)
+    validate_all_or_index_count(indexes)
+    result = []
+    process_indexes(indexes) {|_index, posn| result << @array_data[posn]}
+    result.length == 1 ? result[0] : result
+  end
+
+  #Store the value data into the \FlexArray.
+  #<br>Parameters
+  #* indexes - An array with as many entries as the flexible array has 
+  #  dimensions. These entries may be an integer that is in the bounds of
+  #  the range limit of that dimension, or it can be a range where the start
+  #  and end of the range are in the bounds of the range limit of that 
+  #  dimension, or it can be the symbol :all for all of the possible values
+  #  of that dimension. 
+  #* value - A value to be stored in the selected array entries.
+  #<br>Returns
+  #* The value stored in the array.
+  #<br>Note 
+  #* If the indexes parameter equals a single :all this maps to all
+  #  elements of the array, regardless of its dimensionality.
+  def []=(*indexes, value)
+    validate_all_or_index_count(indexes)
+    process_indexes(indexes) {|_index, posn| @array_data[posn] = value}
+  end
+end

data/lib/flex_array/flex_array_new.rb

@@ -0,0 +1,98 @@
+#* flex_array_new.rb - The flexible array class constructor and related methods.
+class FlexArray
+  #Construct a flexible array object.
+  #<br>Parameters
+  #* array_specs - The specification of the flex array subscript limits. 
+  #  These can either be integers, in which case the limits are 0...n or 
+  #  they can be ranges of integers, in which case the limits are those 
+  #  of the range, or they can be an array of integers and/or ranges of 
+  #  integers to represent arrays of more than one dimension.
+  #* default - The optional default value. Defaults to nil.
+  #* init_block - An optional initialization block. The return values from this
+  #  block are used to initialize the array. This overrides the default value.
+  #<br>Block Arguments
+  #* index - An array with one element per dimension with the fully qualified 
+  #  index of the element being accessed. Note that the same array is passed
+  #  in each time the block is called, so, if this parameter is to stored
+  #  anywhere, it's best that it be cloned or duplicated first.
+  def initialize(array_specs, default=nil, &init_block)
+    @array_specs, @count, @transposed = [], 1, false
+
+    #Parse the array limits.
+    array_specs.in_array.reverse_each do |spec|
+      @array_specs.insert(0, spec.to_spec_component(@count))
+      @count *= @array_specs[0].span
+    end
+    
+    #Cache the dimensionality of the flex array.
+    @dimensions = @array_specs.length
+
+    #Allocate the data for the array.
+    @array_data = Array.new(@count, default)
+    
+    #Set up the array with the optional init_block.
+    if init_block
+      process_all {|index, posn| @array_data[posn] = init_block.call(index)}
+    end
+  end
+
+  alias_method :shallow_dup, :dup
+
+  #Create a duplicate of this array.
+  def dup
+    other = self.shallow_dup
+    other.array_specs = @array_specs.dup
+    other.array_data  = @array_data.dup
+    other
+  end
+
+  #Construct a \FlexArray using other as a template or data source.
+  #<br>Parameters:
+  #* array_specs - The specification of the flex array subscript limits. 
+  #  These can either be integers, in which case the limits are 0...n or 
+  #  they can be ranges of integers, in which case the limits are those 
+  #  of the range, or they can be an array of integers and/or ranges of 
+  #  integers to represent arrays of more than one dimension.
+  #* other - The array or flex array that is the source of the data. 
+  #<br>Note:
+  #* To make a copy of a flex array, use dup instead.
+  def self.new_from(array_specs, other)
+    iterator = other.array_data.cycle
+    FlexArray.new(array_specs) {iterator.next}
+  end
+
+  #Construct a \FlexArray using a all or a portion of portion of another 
+  #\FlexArray as a data source.
+  #<br>Parameters
+  #* array_specs - The specification of the flex array subscript limits. 
+  #  These can either be integers, in which case the limits are 0...n or 
+  #  they can be ranges of integers, in which case the limits are those 
+  #  of the range, or they can be an array of integers and/or ranges of 
+  #  integers to represent arrays of more than one dimension.
+  #* other - The flex array source of the data used to build this flex 
+  #  array. If no limits or other_indexes are specified, the limits of the 
+  #  other array are used instead.
+  #* selection - The indexes of the required sub-set of data to use 
+  #  in setting up the new array.
+  #<br>Notes:
+  #* If the entire source array is to be used, use new_from instead.  
+  #* To make a copy of a flex array, use dup instead.
+  def self.new_from_selection(array_specs, other, selection)
+    iterator = other.cycle(selection)
+    FlexArray.new(array_specs) {iterator.next}
+  end
+  
+  #Construct a \FlexArray as a duplicate of a source array or flex array.
+  #<br>Parameters
+  #* other - the array or flex array that is the source.
+  #<br>Returns
+  #* A flex array.
+  #<br>Note
+  #* The data array of the new flex array is a reference to the source array.
+  def self.new_from_array(other)
+    result = FlexArray.new(0)
+    result.array_specs = other.array_specs.dup
+    result.array_data = other.array_data
+    result.update_count_and_dimensions
+  end
+end

data/lib/flex_array/flex_array_process.rb

@@ -0,0 +1,103 @@
+#* flex_array_process.rb - The flexible array class index processing routines.
+class FlexArray
+  private
+  #Process a \FlexArray index array. This is the heart of the \FlexArray
+  #indexing process.
+  #<br>Parameters
+  #* indexes - An array with as many entries as the flexible array has 
+  #  dimensions. See [] for more details. Note that since indexes is NOT
+  #  a splat parameter, it must be passed as an array explicitly. If passed
+  #  in as [:all] all elements of the array are processed.
+  #* block - a block to be called for each value selected by this process.
+  #<br>Block Arguments
+  #* current - An array with one element per dimension with the fully qualified 
+  #  index of the element being accessed. 
+  #* posn - The position of the element being accessed in the data array.
+  def process_indexes(indexes, &block)
+    current = Array.new(@dimensions, 0)
+    
+    if indexes == [:all]
+      process_all_worker(0, 0, current, &block)
+    else
+      specs = @array_specs.each
+      
+      checked = indexes.collect do |index|
+        index.to_index_range(specs.next)
+      end
+    
+      process_indexes_worker(0, 0, checked, current, &block)
+    end
+  end
+
+  #The worker bee for process_indexes.
+  #<br>Parameters
+  #* depth - The index of the dimension being processed.
+  #* posn - The partially computed position of the element being accessed 
+  #  in the data array.
+  #* indexes - An array of array indexes. See the method [] for details on 
+  #  what sorts of things these can be.
+  #* current - The partial fully qualified index of the element being accessed.
+  #* block - A block to be called for each value selected by this process.
+  #<br>Block Arguments
+  #* current - An array with one element per dimension with the fully qualified 
+  #  index of the element being accessed. 
+  #* posn - The position of the element being accessed in the data array.
+  #<br>Note
+  #This is a recursive function. The recursion runs for index in 0..#dimensions
+  def process_indexes_worker(depth, posn, indexes, current, &block)
+    if depth == @dimensions
+      block.call(current, posn)
+    else
+      spec   = @array_specs[depth]
+      range  = indexes[depth]
+      posn  += spec.index_step(range.min)
+      stride = spec.stride
+      
+      range.each do |index|
+        current[depth] = index
+        process_indexes_worker(depth+1, posn, indexes, current, &block)
+        posn += stride
+      end
+    end
+  end
+  
+  #Special case where all of the array is being processed.
+  #<br>Parameters
+  #* block - A block to be called for each value selected by this process.
+  #<br>Block Arguments
+  #* current - An array with one element per dimension with the fully qualified 
+  #  index of the element being accessed. 
+  #* posn - The position of the element being accessed in the data array.
+  def process_all(&block)
+    current = Array.new(@dimensions, 0)
+    process_all_worker(0, 0, current, &block)
+  end
+  
+  #The worker bee for process_all.
+  #<br>Parameters
+  #* depth - The index of the dimension being processed.
+  #* posn - The partially computed position of the element being accessed 
+  #  in the data array.
+  #* current - The partial fully qualified index of the element being accessed.
+  #* block - A block to be called for each value selected by this process.
+  #<br>Block Arguments
+  #* current - An array with one element per dimension with the fully qualified 
+  #  index of the element being accessed. 
+  #* posn - The position of the element being accessed in the data array.
+  #<br>Note
+  #This is a recursive function. The recursion runs for index in 0..#dimensions
+  def process_all_worker(depth, posn, current, &block)
+    if depth == @dimensions
+      block.call(current, posn)
+    else
+      spec   = @array_specs[depth]
+      stride = spec.stride
+    
+      spec.each do |index|
+        current[depth] = index
+        process_all_worker(depth+1, posn, current, &block)
+        posn += stride
+      end
+    end
+  end
+end

data/lib/flex_array/flex_array_reshape.rb

@@ -0,0 +1,46 @@
+#* flex_array_reshape.rb - The flexible array class reshape and related methods.
+class FlexArray
+  #Return a copy of this \FlexArray, recast in a new shape, dropping or 
+  #repeating data elements as required.
+  #<br>Parameters
+  #* array_specs - The specification of the flex array subscript limits. 
+  #  These can either be integers, in which case the limits are 0...n or 
+  #  they can be ranges of integers, in which case the limits are those 
+  #  of the range, or they can be an array of integers and/or ranges of 
+  #  integers to represent arrays of more than one dimension.
+  #<br>Returns
+  #* The reshaped flexible array.
+  def reshape(array_specs)
+    iterator = @array_data.cycle
+    FlexArray.new(array_specs) {iterator.next}
+  end
+
+  #Recast this \FlexArray in a new shape, dropping or 
+  #repeating data elements as required.
+  #<br>Parameters
+  #* array_specs - The specification of the flex array subscript limits. 
+  #  These can either be integers, in which case the limits are 0...n or 
+  #  they can be ranges of integers, in which case the limits are those 
+  #  of the range, or they can be an array of integers and/or ranges of 
+  #  integers to represent arrays of more than one dimension.
+  #<br>Returns
+  #* The reshaped, flexible array.
+  def reshape!(array_specs)
+    iterator = @array_data.cycle
+    temp = FlexArray.new(array_specs) {iterator.next}
+    @array_specs, @array_data, @dimensions = 
+      temp.array_specs, temp.array_data, temp.dimensions
+    self
+  end
+
+  #Unravel the multi-dimensional structure, and any contained arrays into 
+  #a simple array.
+  def flatten
+    @array_data.flatten
+  end
+
+  #Convert the flex array to a simple array. Contained arrays are not affected.  
+  def to_a
+    @array_data.dup
+  end
+end

data/lib/flex_array/flex_array_transpose.rb

@@ -0,0 +1,17 @@
+#* flex_array_transpose.rb - The flexible array class transpose and related methods.
+class FlexArray
+  #Transpose the specified dimensions. This may change the "shape" of the array
+  #if the transposed dimensions were of different limits.
+  #<br>Returns
+  #* The flex array transposed.
+  #<br>Note
+  #* Transposing an array disables the speed-up for processing the array with
+  #  an index of [:all].
+  def transpose(dim_a, dim_b)
+    validate_dimension(dim_a)
+    validate_dimension(dim_b)
+    @array_specs[dim_a], @array_specs[dim_b] = @array_specs[dim_b], @array_specs[dim_a]
+    @transposed = true
+    self
+  end
+end

data/lib/flex_array/flex_array_validate.rb

@@ -0,0 +1,37 @@
+#* flex_array_validate.rb - The flexible array class index validation routines.
+class FlexArray
+  #Is this array compatible with other?
+  #<br>Parameters
+  #* other - The object being tested for compatibility.
+  #<br>Returns
+  #* true if the arrays are compatible.
+  def compatible?(other)
+    @array_specs == other.array_specs
+  end
+
+  private
+  
+  #Validate the dimensionality of the indexes passed in.
+  #<br>Parameters
+  #* indexes - An array of indexes to be validated.
+  #<br>Returns
+  #* true if the indexes value is [:all] and the array is not transposed.
+  #<br>Exceptions
+  #* ArgumentError - raised on invalid dimensionality.
+  def validate_all_or_index_count(indexes)
+    if indexes == [:all]
+      !@transposed
+    elsif @dimensions != indexes.length
+      fail ArgumentError, "Incorrect number of indexes: #{@dimensions} expected."
+    end
+  end
+  
+  #Is this a valid dimension selector?
+  #<br>Exceptions
+  #* ArgumentError - raised on invalid dimension.
+  def validate_dimension(dim)
+    unless (0...@dimensions) === dim
+      fail ArgumentError, "Invalid dimesnsion selector: #{dim}"
+    end
+  end
+end

data/lib/flex_array/integer.rb

@@ -0,0 +1,34 @@
+require_relative 'spec_component'
+
+#Extensions to Integer needed to support flex array.
+class Integer
+  #Convert this integer to a limits component.
+  #<br>Parameters
+  #* stride - the number of cells separating data with adjacent indexes.
+  #<br>Returns
+  #* A SpecComponent object of 0...self
+  def to_spec_component(stride)
+    if self >= 0
+      SpecComponent.new(0...self, stride)
+    else
+      fail ArgumentError, "Invalid flex array dimension: #{self.inspect}"
+    end
+  end
+  
+  #Convert this integer to an range index against the spec.
+  #<br>Parameters
+  #* spec - The spec component used to validate this index.
+  #<br>Returns
+  #* A range.
+  #<br>Exceptions
+  #* IndexError if the range is not valid.
+  def to_index_range(spec)
+    alter_ego = (self >= 0) ? self : (spec.max + self + 1)
+  
+    if spec === alter_ego
+      alter_ego..alter_ego
+    else
+      fail IndexError, "Subscript out of range: #{self.inspect}"
+    end
+  end
+end

data/lib/flex_array/object.rb

@@ -0,0 +1,29 @@
+require_relative 'spec_component'
+
+#Extensions to Object needed to support flex array.
+class Object
+  #Fail with message since the array dimension is invalid.
+  #<br>Parameters
+  #* _stride - unused, required to maintain signature.
+  #<br>Returns
+  #* Nothing, always fails.
+  def to_spec_component(_stride)
+    fail ArgumentError, "Invalid flex array dimension: #{self.inspect}"
+  end
+  
+  #Convert this object to an range index against the spec.
+  #<br>Parameters
+  #* spec - The spec component used to validate this index.
+  #<br>Returns
+  #* A range.
+  #<br>Exceptions
+  #* IndexError if the range is not valid.
+  def to_index_range(spec)
+    if self == :all
+      spec.range
+    else
+      fail IndexError, "Invalid subscript: #{self.inspect}"
+    end
+  end
+  
+end

data/lib/flex_array/range.rb

@@ -0,0 +1,44 @@
+require_relative 'spec_component'
+
+#Extensions to Range needed to support flex array.
+class Range
+  #Convert this integer to a limits component.
+  #<br>Parameters
+  #* stride - the number of cells separating data with adjacent indexes.
+  #<br>Returns
+  #* A SpecComponent object with the same range as self.
+  def to_spec_component(stride)
+    min = self.min
+    
+    if self == (0...0)
+      SpecComponent.new(0...0, stride)
+    elsif !self.none? && min.is_a?(Integer) && (min >= 0) && self.max.is_a?(Integer)
+      SpecComponent.new(self, stride)
+    else
+      fail ArgumentError, "Invalid flex array dimension: #{self.inspect}"
+    end
+  end
+  
+  #Convert this range to an range index against the spec.
+  #<br>Parameters
+  #* spec - The spec component used to validate this index.
+  #<br>Returns
+  #* A range.
+  #<br>Exceptions
+  #* IndexError if the range is not valid.
+  def to_index_range(spec)
+    self_min, self_max, spec_max = self.min, self.max, spec.max
+    
+    if self_min < 0 && self_max < 0
+      alter_ego = (spec_max + self_min + 1)..(spec_max + self_max + 1)
+    else
+      alter_ego = self
+    end
+    
+    if spec === alter_ego.min && spec === alter_ego.max
+      alter_ego
+    else
+      fail IndexError, "Subscript out of range: #{self.inspect}"
+    end
+  end
+end