num_seq 0.0.1

data/lib/num_seq.rb

@@ -0,0 +1,220 @@
+class NumSeq
+	include Enumerable	
+	def self.from_array(array, index_origin = 0)
+		len = array.length
+		seq = Sequence.new(len, index_origin) do |n, i|
+			array[i]
+		end
+		return seq	
+	end
+
+
+	class SequenceArray < Array
+		def initialize(n, offset)
+			@offset = offset
+			super(n)
+		end
+	
+		def offset=(new_offset)
+			raise "Wrong point reached" if new_offset >= @offset
+			(@offset-new_offset).times { self.unshift nil }
+			@offset = new_offset
+		end
+		
+		def [](n)
+			super(n - @offset)
+		end
+
+		def []=(n,value)
+			super(n - @offset, value)
+		end
+	end
+
+	def initialize(len, start_at = 0)
+		if len < 0 then 
+			raise ArgumentError, 
+				"Length of a num_seq must be positive"
+		end
+	
+		@@strict = false
+		@undef_value = nil
+
+		if 0 == len then
+			@undef_inf = @undef_sup = start_at
+		else
+			@undef_inf = start_at - 1
+			@undef_sup = start_at + len	
+		end
+		
+
+		@elems = SequenceArray.new(len, @undef_inf + 1)
+
+		if block_given? then
+			((@undef_inf+1)...@undef_sup).each_with_index do |n,i|
+				@elems[n] = yield(n,i)
+			end		
+		end
+	end
+
+	attr_accessor :undef_value
+
+	def self.behave_strict?
+		return @@strict
+	end
+
+	def self.strict_behavior
+		@@strict = true
+	end
+
+	def self.rough_behavior
+		@@strict = false
+	end
+
+	def seq_defined_at?(n)
+		return n > @undef_inf && n < @undef_sup
+	end
+	private :seq_defined_at?
+
+	def [](n)
+		return @undef_value unless seq_defined_at? n 
+		return @elems[n]
+	end
+
+	def []=(n, value)
+		if self.class.behave_strict? and not seq_defined_at?(n) then
+			raise IndexError,
+				%Q%Attempt to assign at index #{n} % +
+				%q%where the num_seq is not defined%
+		end
+		return @elems[n] = value if seq_defined_at? n
+		if n <= @undef_inf then
+			@undef_inf = n - 1
+			@elems.offset = n
+			@elems[n] = value 
+		elsif n >= @undef_sup then
+			@undef_sup = n + 1
+			@elems[n] = value
+		else
+			raise "Impossible  point reached"
+		end
+		
+	end
+
+	def range
+		return (@undef_inf+1..@undef_sup-1)
+	end
+
+	def length
+		return @undef_sup - @undef_inf - 1
+	end
+	alias :size :length
+
+	def min_index
+		return @undef_inf + 1
+	end
+	alias :n_min :min_index
+
+	def max_index
+		return @undef_sup - 1
+	end
+	alias :n_max :max_index
+
+	def first
+		return self[n_min]
+	end
+
+	def last
+		return self[n_max]
+	end
+
+	# y[n] = x[n-k]
+	def shift(k)
+		if k < 0 then
+		# left shift
+			_lshift(-k)
+		elsif k > 0 then
+		# right shift
+			_rshift(k)
+		else
+		# return copy -> CHANGE!!
+			return nil
+		end
+	end
+
+	def rshift(k)
+		if k < 0 then
+			raise ArgumentError, "Argument should be non-negative"
+		end
+		return _rshift(k)
+	end
+
+	def lshift(k)
+		if k < 0 then
+			raise ArgumentError, "Argument should be non-negative"
+		end
+		return _lshift(k)
+	end
+
+	def _rshift(k)
+		start_at = self.n_min
+		length = self.length
+		seq = Sequence.new(length, start_at + k) do |n|
+			self[n-k]
+		end
+		return seq
+	end
+	private :_rshift
+	
+	def _lshift(k)
+		start_at = self.n_min
+		length = self.length
+		seq = Sequence.new(length, start_at - k) do |n|
+			self[n+k]
+		end
+		return seq
+	end
+	private :_lshift
+
+	# x[Mn]
+	def compress(m)
+	end
+
+	# x[n/L]
+	def expand(l)
+	end
+
+	def to_s
+		index = self.n_min
+		@elems.each do |e|
+			puts "#{index} #{e}"
+			index += 1
+		end	
+	end
+end
+
+require 'num_seq/common'
+require 'num_seq/enumerable'
+require 'num_seq/array'
+require 'num_seq/ops'
+require 'num_seq/internal_ops/common'
+require 'num_seq/internal_ops/sum'
+require 'num_seq/internal_ops/sub'
+require 'num_seq/internal_ops/conv'
+require 'num_seq/internal_ops/mul'
+require 'num_seq/internal_ops/div'
+require 'num_seq/internal_ops/exp'
+require 'num_seq/internal_ops/mod'
+require 'num_seq/internal_ops/math'
+require 'num_seq/internal_ops/interpolation'
+require 'num_seq/external_ops/common'
+require 'num_seq/external_ops/sum'
+require 'num_seq/external_ops/sub'
+require 'num_seq/external_ops/mul'
+require 'num_seq/external_ops/div'
+require 'num_seq/external_ops/mod'
+require 'num_seq/external_ops/exp'
+require 'num_seq/external_ops/energetic'
+require 'num_seq/external_ops/stats'
+
+
+

data/lib/num_seq/array.rb

@@ -0,0 +1,5 @@
+class Array
+	def to_seq(index_origin = 0)
+		return NumSeq.from_array(self, index_origin)	
+	end
+end

data/lib/num_seq/internal_ops/common.rb

@@ -0,0 +1,32 @@
+class NumSeq
+	def self.minimal_index(seq_a, seq_b)
+		if seq_a.min_index < seq_b.min_index then
+			seq_a.min_index
+		else	
+			seq_b.min_index
+		end
+	end
+	private_class_method :minimal_index
+	
+	def self.maximal_index(seq_a, seq_b)
+		if seq_a.max_index > seq_b.max_index then
+			seq_a.max_index
+		else	
+			seq_b.max_index
+		end
+	end
+	private_class_method :maximal_index
+
+	def self.operate(elem_a, elem_b, op)
+		if nil != elem_a and nil != elem_b then
+			elem_a.send(op, elem_b)
+		elsif nil != elem_a then
+			elem_a
+		elsif nil != elem_b then
+			elem_b
+		else
+			nil
+		end		
+	end
+	private_class_method :operate
+end

data/lib/num_seq/internal_ops/div.rb

@@ -0,0 +1,14 @@
+class NumSeq
+	def idiv(seq)
+		n_min = self.class.send(:minimal_index, self, seq)
+		n_max = self.class.send(:maximal_index, self, seq)
+
+		len = n_max - n_min + 1
+
+		res = self.class.new(len, n_min) do |n|
+			self.class.send(:operate, self[n], seq[n], :/)
+		end
+		return res
+	end
+	private :idiv	
+end

data/lib/num_seq/internal_ops/exp.rb

@@ -0,0 +1,14 @@
+class NumSeq
+	def iexp(seq)
+		n_min = self.class.send(:minimal_index, self, seq)
+		n_max = self.class.send(:maximal_index, self, seq)
+
+		len = n_max - n_min + 1
+
+		res = self.class.new(len, n_min) do |n|
+			self.class.send(:operate, self[n], seq[n], :**)
+		end
+		return res
+	end
+	private :iexp	
+end

data/lib/num_seq/internal_ops/interpolation.rb

@@ -0,0 +1,35 @@
+class NumSeq
+	def interpolate
+		if block_given? then
+			n_inf = n_sup = self.n_min
+			while true 
+				# find the next defined element
+				n = n_sup + 1
+				n_inf = n_sup
+				while n <= self.n_max
+					begin
+						next if nil == self[n]
+						n_sup = n
+						break	
+					ensure
+						n += 1
+					end 		
+				end
+				(n_inf..n_sup).each do |m|
+					self[m] = yield(n_inf,n_sup, m)
+				end
+			break if self.n_max == n_sup
+			end
+		else
+		# perform linear interpolation by default
+			self.interpolate do |n0,n1,k;m| 
+				m = (self[n1] - self[n0])
+				# to avoid integer divisions
+				m *= 1.0 if m.is_a? Numeric
+				m /= n1 - n0
+				next (self[n0] + m * (k - n0))	
+			end
+		end
+		return self
+	end
+end

data/lib/num_seq/internal_ops/mod.rb

@@ -0,0 +1,14 @@
+class NumSeq
+	def imod(seq)
+		n_min = self.class.send(:minimal_index, self, seq)
+		n_max = self.class.send(:maximal_index, self, seq)
+
+		len = n_max - n_min + 1
+
+		res = self.class.new(len, n_min) do |n|
+			self.class.send(:operate, self[n], seq[n], :%)
+		end
+		return res
+	end
+	private :imod	
+end

data/lib/num_seq/internal_ops/mul.rb

@@ -0,0 +1,14 @@
+class NumSeq
+	def imul(seq)
+		n_min = self.class.send(:minimal_index, self, seq)
+		n_max = self.class.send(:maximal_index, self, seq)
+
+		len = n_max - n_min + 1
+
+		res = self.class.new(len, n_min) do |n|
+			self.class.send(:operate, self[n], seq[n], :*)
+		end
+		return res
+	end
+	private :imul	
+end

data/lib/num_seq/internal_ops/sub.rb

@@ -0,0 +1,15 @@
+class NumSeq
+	def isub(seq)
+		n_min = self.class.send(:minimal_index, self, seq)
+		n_max = self.class.send(:maximal_index, self, seq)
+
+		len = n_max - n_min + 1
+
+		res = self.class.new(len, n_min) do |n|
+			self.class.send(:operate, self[n], seq[n], :-)
+		end
+		return res
+	end
+	private :isub
+	
+end

data/lib/num_seq/internal_ops/sum.rb

@@ -0,0 +1,14 @@
+class NumSeq
+	def isum(seq)
+		n_min = self.class.send(:minimal_index, self, seq)
+		n_max = self.class.send(:maximal_index, self, seq)
+
+		len = n_max - n_min + 1
+
+		res = self.class.new(len, n_min) do |n|
+			self.class.send(:operate, self[n], seq[n], :+)
+		end
+		return res
+	end
+	private :isum
+end

data/lib/num_seq/ops.rb

@@ -0,0 +1,39 @@
+class NumSeq
+	def +(arg)
+		use_proper_operator(arg, :isum, :xsum)
+	end
+	
+	def -(arg)
+		use_proper_operator(arg, :isub, :xsub)
+	end
+	
+	def *(arg)
+		use_proper_operator(arg, :imul, :xmul)
+	end
+
+	def /(arg)
+		use_proper_operator(arg, :idiv, :xdiv)
+	end
+	
+	def %(arg)
+		use_proper_operator(arg, :imod, :xmod)
+	end
+	
+	def **(arg)
+		use_proper_operator(arg, :iexp, :xexp)
+	end
+
+	def use_proper_operator(arg, internal_operator, external_operator)
+		if arg.is_a? Numeric then
+			return self.send(external_operator, arg)	
+		elsif arg.is_a? NumSeq then
+			return self.send(internal_operator, arg)
+		else
+			raise(ArgumentError, "Attempt to operate an object " + 
+			"of the '#{self.class}' class with an object " +
+			"of the '#{arg.class}' class using the " +
+			"'#{caller[0][/`.*'/][1..-2]}' operator")
+		end	 
+	end
+	private :use_proper_operator
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: num_seq
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jorge F.M. Rinaldi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-30 00:00:00.000000000 Z
+dependencies: []
+description: For representing Numerical Sequences, especially Discret-Time signals
+email: jorge.madronal.rinaldi@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/num_seq.rb
+- lib/num_seq/array.rb
+- lib/num_seq/ops.rb
+- lib/num_seq/internal_ops/common.rb
+- lib/num_seq/internal_ops/sum.rb
+- lib/num_seq/internal_ops/sub.rb
+- lib/num_seq/internal_ops/conv.rb
+- lib/num_seq/internal_ops/mul.rb
+- lib/num_seq/internal_ops/div.rb
+- lib/num_seq/internal_ops/mod.rb
+- lib/num_seq/internal_ops/exp.rb
+- lib/num_seq/internal_ops/math.rb
+- lib/num_seq/internal_ops/interpolation.rb
+homepage: http://mrinaldi.net
+licenses:
+- GPLv3
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Numerical Sequences in Ruby
+test_files: []