n-array 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a707fc3fefdb36a781b6e95cf03bd682499310a0
+  data.tar.gz: e6810c8c7e1bd895f100f86d9ef05abe888e0318
+SHA512:
+  metadata.gz: 15c6217c2d7f9fe22ed77ea15403181dc598334314173a297d87b538a26c4823d6ff21da35dd6d3014d03e17a6b20a1ae26531d09238a4ccb6efba6b9a3795b5
+  data.tar.gz: 4ab6714b75861f9a3bf8a473bd6ef5b97e81e94b9fd8a944a9ef509feffaaa9786a6bbe4b090dff8f5a2a3f42beea16b226f504b00175af7aef39434aa74516f

data/lib/narray.rb

@@ -0,0 +1,204 @@
+# Multidimensional array for Ruby
+
+class NArray < Array
+	attr_reader :dimensions
+	def initialize dimensions = nil, *values, &blck
+		# Make a difference between no arguments and nil
+		values = NArray::_extract values
+
+		# In case the only parameter is a NArray, duplicate it
+		if dimensions.is_a? NArray and  !NArray::_arg? values
+			self.replace dimensions.dup
+
+		# In case the parameter is an array, multiple possibilities
+		elsif dimensions.is_a? Array
+			# 1) The array decribes dimensions and provide a default value to fill in the blanks
+			if NArray.is_valid_description? dimensions and (NArray::_arg? values or block_given?)
+				# then we build the n-array recursively and fill the values with what has been provided
+				@dimensions = dimensions.length
+				@dimensions == 1 ?
+					# A little detour to avoid warnings on nil values
+					!NArray::_arg?(values) ? super(dimensions[0], &blck) : super(dimensions[0], values) :
+					super( [*0...dimensions[0]].map { NArray.new(dimensions.drop(1), values, &blck) } )
+
+			# 2) the array does not provide a default value
+			elsif !NArray::_arg? values and !block_given?
+				# then we create a NArray fitting the litteral given
+				@dimensions = NArray.count_dimensions dimensions #inefficient but GTD
+				@dimensions == 1 ?
+					super(dimensions) : # giving a block here has no effect with mri and the doc doesn't say anything
+					super(dimensions.map { |e| NArray.new(e) })
+
+			# 3) the array is not a valid description but a default value is given, i.e. user mistake. Scold him!
+			else
+				raise RuntimeError, "#{dimensions} is not a valid description: 
+				An array of striclty positive Integers is expected"
+			end
+
+		# In case the dimension is valid
+		elsif NArray.is_valid_dimension? dimensions
+			@dimensions = dimensions
+			if dimensions == 1
+				super([], &blck)
+			else 
+				super([NArray.new(dimensions - 1, values, &blck)])
+			end
+
+		# Empty constructor
+		elsif dimensions.nil? and !NArray::_arg? values
+			super(&blck)
+
+		# Bad user, bad
+		else
+			raise RuntimeError \
+				"Invalid dimension (expecting an Integer or array of Integer all strictly positives, got #{dimensions}"
+		end
+	end
+
+	# Returns an array of the lengths of each dimension
+	def lengths
+		#NArray.calculate_dimensions(self) # doesn't work for some weird reason
+		dimensions == 1 ? [length] : [length, *self[0].lengths]
+	end
+
+	# Returns the length of the dimension given as parameter
+	#
+	# Starts at 0
+	def length d = 0
+		raise "Expecting positive Integer < #{dimensions}, got #{d}" unless d < dimensions and d >= 0
+		d == 0 ? super() : self[0].length(d - 1)
+	end
+
+
+
+	# Fetch the value at the position of the arguments
+	#
+	# In case the argument contains nil values, returns a NArray of the elements 
+	# satisfying the coordinates given by the arguments (to-do)
+	def [] *pos
+		raise "1..#{dimensions} arguments expected, given #{pos.length}" if pos.length > dimensions or pos.length == 0
+		pos.length == 1 ? super(*pos) : super(pos[0])[*pos.drop(1)]
+	end
+
+	# Sets the value at the position of the arguments
+	def []= *pos, v
+		raise "#{dimensions} arguments expected, given #{pos.length}" if pos.length != dimensions
+		pos.length == 1 ? super(*pos, v) : self[pos[0]][*pos.drop(1)] = v
+	end
+
+	# Returns the total number of elements in the n-array
+	def size
+		lengths.reduce(&:*)
+	end
+
+	# Iterate over the elements of the n-array applying the given block to each element
+	def each &blck
+		if dimensions > 1
+			super() do |e|
+				e.each(&blck)
+			end
+		else
+			super(&blck)
+		end
+	end
+
+	# Iterate over the elements of the n-array apply the given bloc and collect 
+	# the results into a nested collection of arrays identical to the structure of the caller
+	def map &blck
+		if dimensions > 1
+			super() do |e|
+				e.map(&blck)
+			end
+		else
+			super(&blck)
+		end
+	end
+	# See #map
+	def collect
+		map
+	end
+
+	class << self
+		# Returns the number of dimensions that can be generated from the argument while keeping the array well-formed
+		#
+		# Checks the maximum level of nesting so that any n-vector {v1, v2...vn} with 0 <= vm < length(m) 
+		# correctly refers to an element in the structure
+		def count_dimensions array
+			array.class == NArray ? array.dimensions : calculate_dimensions(array).length
+		end
+
+		# Returns an array of lengths for an array (only works with Array, don't ask me why)
+		#
+		# Each dimension in a n-array has a maximum size, those are collected and ordered into an array,
+		# the first being the top array, and the last the deepest group
+		def calculate_dimensions array
+			_count(array).take_while { |e| e >= 0 }
+		end
+
+
+		# Check whether the argument is a valid dimension
+		#
+		# Returns true if dimensions is a strictly positive Integer, false otherwise
+		def is_valid_dimension? dimensions
+			dimensions.is_a? Integer and dimensions > 0
+		end
+
+		# Check whether the argument is a valid description of dimensions
+		#
+		# Returns true if the argument is an Array of values satisfying is_valid_dimension?, false otherwise
+		def is_valid_description? dimensions
+			dimensions.is_a? Array and dimensions.all? { |e| is_valid_dimension? e }
+		end
+
+		# Create a n-array fitting the given description
+		def[] *description
+			NArray.new(description)
+		end
+
+		private
+			def _count array, n = [], d = 0
+				unless array.is_a? Array or array.is_a? NArray # if not an array, set the dimension as beeing incoherent
+					n[d] = -1
+					return n # and abort
+				end
+
+				# if length <= depth it means this dimension hasn't been explored yet, 
+				# so we set it at the first value we encounter, which will not change
+				# if the array is well formed
+				n << array.length if n.length <= d
+
+				if array.length != n[d] #or n[d] < 0  # the second part should never 
+													  # be executed since array.length >= 0 (
+													  # if n[d] < 0 then the first test automatically fails)
+					# The dimension is in an incoherent state, abort
+					n[d] = -1
+					return n
+				end
+
+				# At this point the array is still in a coherent state, 
+				# we just need to check sub elements unless we already know 
+				# that we can't proceed further because of previous results
+				array.each do |e|
+					if n.length > d + 1 and n[d + 1] < 0 # In case the next element has 
+														 # already been decided to be incoherent
+						return n # Abort
+					end
+					_count e, n, d + 1
+				end
+				n
+			end
+
+		public
+			def _extract args
+				raise ParameterError, "Expected 1..2 arguments, got #{args.length + 1}" if args.length > 1	
+				args.length == 1 ? args[0] : NArray::EmptyArgument.new
+			end
+			
+			def _arg? arg
+				!arg.is_a? NArray::EmptyArgument
+			end
+	end
+	private
+	class EmptyArgument
+	end
+end

metadata

@@ -0,0 +1,46 @@
+--- !ruby/object:Gem::Specification
+name: n-array
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Sylvain Leclercq
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-11-02 00:00:00.000000000 Z
+dependencies: []
+description: Manipulating nested arrays in Ruby is a pain and there doesn't seem to
+  be any general purpose solutions (i.e. not math-oriented) available so here is a
+  shot at it.
+email: maisbiensurqueoui@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/narray.rb
+homepage: http://www.github.com/de-passage/narray
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: A n-dimensional storage structure
+test_files: []