digiproc 0.1.0

data/lib/strategies/code/xor_differential_encoding_strategy.rb

@@ -0,0 +1,100 @@
+##
+# Class used as a strategy for differentially encoding a bitstream 
+# by XORing it with a time-delayed version of itself:
+# Differentially encode the binary stream using the XOR operator, 
+# and then map the binary stream using the equation 
+# βn = (2l−1)π %2π, l⩽M, which gives you a mapping of 0=> −π ,1=> π
+# The Differentially Encoded Signal => Cn = Dn ⨁ Cn−1
+# is the signal mapped to phase as described above.
+# The XOR operation in seeded with a 1
+class Digiproc::Strategies::XORDifferentialEncodingStrategy
+
+    ##
+    # Accept an int reprisenting a bit stream. Encode the
+    # bits by XORing it with a time delay of itself via
+    # the `self.encode_str` method below. The first bit is seeded 
+    # with a "1"
+    def self.encode_bits(bits)
+        encode_str(bits.to_s(2))
+    end
+
+    ##
+    # Input a string of bits
+    # Outupt the XOR'd version of the bits, seeded with a beginning "1"
+    def self.encode_str(bits)
+        bits_arr = bits.split("")
+        encoded = ["1"]  
+        for i in 0...bits_arr.length do 
+            encoded << (encoded.last.to_i(2) ^ bits_arr[i].to_i(2)).to_s
+        end
+        encoded.join
+    end
+
+    ##
+    # Encoding an incoming array of bits (as strings) into an array of XOR'd bits
+    # Requires an input of an array, and has optional arguments of m (number of bits per symbol)
+    # And a beginning value (a starting reference phase angle). Outputs an array of 
+    # XOR'd bits
+    def self.encode(arr, m = 2, beginning_val = "1")
+        beginning_val = beginning_val.to_s(2) unless beginning_val.is_a? String
+        encoded = [beginning_val]
+        for i in 0...arr.length do 
+            encoded << (encoded.last.to_i(2) ^ arr[i].to_i(2)).to_s
+        end
+        encoded
+    end
+
+    ##
+    # Input is an integer
+    # The method calls the `decode_str` method below and inputs
+    # a string of the binary of the input integer.
+    # The output will be the original bitstream encoded by this encoding strategy
+    # in string form
+    def self.decode_bits(bits)
+        dencode_str(bits.to_s(2))
+    end
+
+
+
+    ##
+    # Input an encoded binary bit stream in string form
+    # Output a string of the original bitstream 
+    def self.decode_str(bits)
+        bits_arr = bits.split("")
+        encoded = []  
+        for i in 1...bits_arr.length do 
+            encoded << (bits_arr[i - 1].to_i(2) ^ bits_arr[i].to_i(2)).to_s
+        end
+        encoded.join
+    end
+
+    ##
+    # Input an array of encoded bits (as strings)
+    # Output an array of decoded bits
+    def self.decode(bits)
+        encoded = []  
+        for i in 1...bits.length do 
+            encoded << (bits[i - 1].to_i.to_s.to_i(2) ^ bits[i].to_i.to_s.to_i(2)).to_s
+        end
+        encoded
+    end
+
+    ##
+    # Return a lambda which transforms a bit into a phase 
+    # Input an integer specifying the number of bits in a symbol
+    # Input to the returned lambda should be the symbol value in decimal form
+    # Ouptut of the lambda is the encoded phase angle
+    def self.phase_shift_eqn(m)
+        ->(l){ (((2.0 * (l+1) - 1.0) / m) % 2) * Math::PI }
+    end
+
+    ##
+    # Return a lambda which transforms a pahse into a symbol
+    # Input an integer specifying the number of bits in a symbol
+    # Input to the returned lambda is the encoded phase angle
+    # Output of the lambda is the binary symbol
+    def self.phase_to_sym(m)
+        ->(code){ (((code / (Math::PI)) * m) + 1.0) / 2.0 - 1.0 }
+    end
+
+end

data/lib/strategies/code/xor_differential_encoding_zero_angle_strategy.rb

@@ -0,0 +1,103 @@
+##
+# Class used as a strategy for differentially encoding a bitstream 
+# by XORing it with a time-delayed version of itself:
+# Differentially encode the binary stream using the XOR operator, 
+# and then map the binary stream using the equation 
+# βn = 2π(i−1) , i = 1..M which gives you a mapping of 0 => 0, 1 => π
+# The Differentially Encoded Signal => Cn = Dn ⨁ Cn−1
+# is the signal mapped to phase as described above.
+# The XOR operation in seeded with a 1
+
+class Digiproc::Strategies::XORDifferentialEncodingZeroAngleStrategy
+
+    ##
+    # Accept an int reprisenting a bit stream. Encode the
+    # bits by XORing it with a time delay of itself via
+    # the `self.encode_str` method below. The first bit is seeded 
+    # with a "1"
+    def self.encode_bits(bits)
+        encode_str(bits.to_s(2))
+    end
+
+
+    ##
+    # Input a string of bits
+    # Outupt the XOR'd version of the bits, seeded with a beginning "1"
+    def self.encode_str(bits)
+        bits_arr = bits.split("")
+        encoded = ["1"]  
+        for i in 0...bits_arr.length do 
+            encoded << (encoded.last.to_i(2) ^ bits_arr[i].to_i(2)).to_s
+        end
+        encoded.join
+    end
+
+    ##
+    # Encoding an incoming array of bits (as strings) into an array of XOR'd bits
+    # Requires an input of an array, and has optional arguments of m (number of bits per symbol)
+    # And a beginning value (a starting reference phase angle). Outputs an array of 
+    # XOR'd bits
+    def self.encode(arr, m = 2, beginning_val = "1")
+        beginning_val = beginning_val.to_s(2) unless beginning_val.is_a? String
+        encoded = [beginning_val]
+        for i in 0...arr.length do 
+            encoded << (encoded.last.to_i(2) ^ arr[i].to_i(2)).to_s(2)
+        end
+        encoded
+    end
+
+
+    ##
+    # Input is an integer
+    # The method calls the `decode_str` method below and inputs
+    # a string of the binary of the input integer.
+    # The output will be the original bitstream encoded by this encoding strategy
+    # in string form
+    def self.decode_bits(bits)
+        dencode_str(bits.to_s(2))
+    end
+
+
+    ##
+    # Input an encoded binary bit stream in string form
+    # Output a string of the original bitstream 
+    def self.decode_str(bits)
+        bits_arr = bits.split("")
+        encoded = []  
+        for i in 1...bits_arr.length do 
+            encoded << (bits_arr[i - 1].to_i(2) ^ bits_arr[i].to_i(2)).to_s(2)
+        end
+        encoded.join
+    end
+
+
+    ##
+    # Input an array of encoded bits (as strings)
+    # Output an array of decoded bits
+    def self.decode(bits)
+        encoded = []  
+        for i in 1...bits.length do 
+            encoded << (bits[i - 1].to_i.to_s.to_i(2) ^ bits[i].to_i.to_s.to_i(2)).to_s(2)
+        end
+        encoded
+    end
+
+     ##
+    # Return a lambda which transforms a bit into a phase 
+    # Input an integer specifying the number of bits in a symbol
+    # Input to the returned lambda should be the symbol value in decimal form
+    # Ouptut of the lambda is the encoded phase angle
+    def self.phase_shift_eqn(m)
+        ->(i){ (2 * Math::PI * (i)) / m }
+    end
+
+    ##
+    # Return a lambda which transforms a pahse into a symbol
+    # Input an integer specifying the number of bits in a symbol
+    # Input to the returned lambda is the encoded phase angle
+    # Output of the lambda is the binary symbol
+    def self.phase_to_sym(m)
+        ->(phase){ (phase * m / (2.0 * Math::PI))}
+    end
+
+end

data/lib/strategies/companding/custom_companding_strategy.rb

@@ -0,0 +1,29 @@
+##
+# A class which allows a custom companding strategy to be used via a lambda function 
+# inputted into the initilizer. 
+
+class Digiproc::Strategies::CustomCompandingStrategy
+
+    attr_accessor :eqn, :inverse
+
+    # initialize wiht a companding equation (via a proc or lambda) as well as the inverse equation
+    def initialize(eqn, inverse)
+        @eqn, @inverse = eqn, inverse
+    end 
+
+    # maps an array (first argument) with a lambda (second argument)
+    def process(data, fn)
+        data.map{ |n| fn.call(n) }
+    end
+
+    # use the compression companding lambda (or proc) to compress an array of numerics
+    def compress(data)
+        self.process(data, eqn)
+    end
+
+    # Use the inverse labda (or proc) to decompress an array of numerics
+    def expand(data)
+        self.process(data, inverse)
+    end
+
+end

data/lib/strategies/convolution/bf_conv.rb

@@ -0,0 +1,57 @@
+##
+# Strategy for convolving two arrays of numbers
+# This is an O(n^2) operation, it is more time efficient
+# to use FFT to perform this calculation
+class Digiproc::Strategies::BFConvolutionStrategy
+
+    ##
+    # == Input Args
+    # data1:: Array[Numeric]
+    # data2:: Array[Numeric]
+    # == Output 
+    # convolution:: Numeric
+    def self.conv(data1, data2)
+        dynamic_data = data1.dup
+        static_data = data2.dup
+        conv_sum = []
+        n = 0
+        start, stop = conv_overlap_area(static_data.length, dynamic_data.length, n)
+        while start <= stop
+            sum = 0
+            for val in start..stop
+                sum += static_data[val] * dynamic_data[transform_to_local_index(val, n)]
+            end
+            conv_sum << sum
+            n = conv_sum.length
+            start, stop = conv_overlap_area(static_data.length, dynamic_data.length, n)
+        end
+        conv_sum
+      end
+
+      private
+    
+      ##
+      # Gives start and stop values of overlap inclusive
+      def self.conv_overlap_area(static_len, dynamic_len, n)
+          dynamic_lo = transform_to_global_index(dynamic_len - 1, n)
+          dynamic_hi = transform_to_global_index(0, n)
+          static_lo = 0
+          static_hi = static_len - 1
+          start = dynamic_lo > static_lo ? dynamic_lo : static_lo
+          stop = dynamic_hi < static_hi ? dynamic_hi : static_hi
+          return [start, stop]
+      end
+    
+      def self.transform_index(index, xform)
+          xform.call(index)
+      end
+    
+      def self.transform_to_global_index(index, n)
+          transform_index(index, ->(i){ n - i })
+      end
+    
+      def self.transform_to_local_index(index, n)
+          transform_index(index, ->(i){ n - i})
+      end
+
+end 

data/lib/strategies/fft/brute_force_dft_strategy.rb

@@ -0,0 +1,31 @@
+##
+# A brute force Discrete Fourier Transform strategy
+# O(n^2) algorith, no reason to sue it over FFT unless you 
+# don't want to work within the parameters of a Radix2 strategy 
+# (ie data points of DFT size will be a power of 2). This strategy does
+# not have those parameters
+class Digiproc::BFDFTStrategy
+
+    attr_accessor :data
+
+    # initialize with an array of numerics
+    def initialize(data)
+        @data = data.dup
+    end
+
+    # Calculate the DFT with an O(n^2) algorithm
+    # Can accept an array of numerics, with a default value of 
+    # @data
+    def calculate(data = @data)
+        ft = []
+        for k in 0...data.length do
+            tot = 0
+            data.each_with_index do |x_n, n|
+                tot += x_n * Math::E ** (Complex(0,-1) * 2.0 * Math::PI * k * n / data.length.to_f)
+            end
+            ft << tot
+        end
+        ft
+    end
+
+end

data/lib/strategies/fft/inverse_fft_conjugate_strategy.rb

@@ -0,0 +1,44 @@
+##
+# Strategy for calculating the Inverse Fast Fourier Transform (IFFT)
+# O(nlgn) runtime, depends on the FFT strategy to calculate thie IFFT
+# Uses "conjugate strategy"
+class Digiproc::Strategies::IFFTConjugateStrategy
+
+    attr_accessor :data, :strategy
+
+    ##
+    # == Input args:
+    # data:: Array[Numeric] (DFT values)
+    # fft_strategy(Optional):: See Digiproc::Strategies::Radix2Strategy for required protocol (This is the default value)
+    def initialize(data, fft_strategy = Digiproc::Strategies::Radix2Strategy)
+        @data = data
+        @strategy = fft_strategy.new
+    end
+
+    ##
+    # No input args
+    # Calculate the IFFT given Discrete Fourier Transform (DFT) values
+    def calculate
+        strategy.data = conjugate(data)
+        fft_out = strategy.calculate
+        n = fft_out.length.to_f
+        conjugate(fft_out){ |real, imag| OpenStruct.new(real: (real / n), imaginary: (imag / n) ) }
+    end
+
+
+    private
+
+    def conjugate(data)
+        data.map do |value|
+            if value.is_a? Complex
+                complex_num = block_given? ? yield(value.real, value.imaginary) : OpenStruct.new(real: value.real, imaginary: value.imaginary)
+                Complex(complex_num.real, -1 * complex_num.imaginary)
+            else
+                real_num = block_given? ? yield(value, 0) : OpenStruct.new(real: value, imaginary: 0)
+                real_num.real
+            end
+        end
+    end
+
+
+end

data/lib/strategies/fft/radix2_strategy.rb

@@ -0,0 +1,84 @@
+##
+# O(n*lgn) FFT algorithm
+# Requires that the number of datapoints be a power of 2
+# if it isn't the calculation will zero pad to the closest 
+# power of 2 above the current data size
+# The size of the outputted DFT will be the size of the zero-padded
+# dataset. Zero-padding causes the "sample locations" of the DFT to
+# be at different locations than if it was not zero padded, but 
+# The resolution of the DFT will INCREASE due to zero padding
+class Digiproc::Strategies::Radix2Strategy 
+
+    E = Math::E
+    PI = Math::PI
+
+    attr_reader :data
+
+    ##
+    # == Initialize Arg
+    # data (Optional):: Array[Numeric] (defaults to nil)
+    def initialize(data = nil)
+        @data = data
+        zero_fill if not data.nil?
+    end
+
+    ## 
+    # == Input arg
+    # data (Optional):: Array[Numiric] (defaults to @data)
+    def calculate(data = @data)
+        recursive_fft(data)
+    end
+
+    # @data writer, and zero fills array to 
+    # obtain a size of the closest power of 2 above current size
+    def data=(data)
+        @data = data
+        zero_fill
+    end
+
+    private
+
+    def recursive_fft(arr)
+        n = arr.length
+        return arr if n == 1
+        w_n = E ** ((-2 * PI * Complex(0,1)) / n)
+        w = 1
+        a0 = get_even(arr)
+        a1 = get_odd(arr)
+        y0 = recursive_fft(a0)
+        y1 = recursive_fft(a1)
+        y = Array.new(n, 0)
+        for k in 0...(n/2) do
+            y[k] = (y0[k] + w * y1[k])
+            y[k + n/2] = (y0[k] - w * y1[k])
+            w = w * w_n
+        end
+        y
+    end
+
+    def get_even(arr)
+        even = []
+        arr.each_with_index { |a, i| even << a.dup if i % 2 == 0 }
+        even
+    end
+
+    def get_odd(arr)
+        odd = []
+        arr.each_with_index { |a, i| odd << a.dup if i % 2 == 1 }
+        odd
+    end
+
+    def zero_fill
+        len = self.data.length
+        @data = @data.concat Array.new(closest_pow_of_2(len) - len, 0)
+    end
+
+    def power_of_two?(num)
+        lg = Math.log(num,2)
+        lg.round.to_f == lg 
+    end
+
+    def closest_pow_of_2(num)
+        2 ** Math.log(num,2).ceil
+    end
+end

data/lib/strategies/gaussian/gaussian_generator.rb

@@ -0,0 +1,49 @@
+##
+# Class for generating random numbers from a Gaussin Population
+# of a given mean or standard deviation
+class Digiproc::Strategies::GaussianGeneratorBoxMullerStrategy
+    
+    ##
+    # No input args
+    # Returns 2 random numbers from a gaussain population with 
+    # stddev of 1 and mean of 0
+    def self.rand2
+        uniform_random = Random.new
+        r = (-2 * Math.log(1 - uniform_random.rand)) ** 0.5
+        theta = 2 * Math::PI * (1 - uniform_random.rand)
+        return r * Math.cos(theta), r * Math.sin(theta)    
+    end
+
+    attr_accessor :mean, :stddev
+
+    ## 
+    # == Input Args:
+    # mean (Optional):: Numeric (default 0)
+    # stddev (Optional):: Numeric (default 1)
+    def initialize(mean = 0, stddev = 1)
+        @mean, @stddev = mean, stddev
+        @needs_gen = true
+        @next = nil
+    end
+
+    # Get a single random number from a Gaussian distribution with a 
+    # mean and stddev as defined by @mean and @stddev
+    # Use the .rand2 method to get 2 random numbers. Save one, return the other
+    def rand
+        if @needs_gen
+            x,y = self.class.rand2
+            @next = y
+            @needs_gen = false
+            return self.mean + self.stddev * x
+        else
+            @needs_gen = true
+            return self.mean + self.stddev * @next
+        end
+    end
+
+    # Calls the .rand2 method
+    def rand2
+        self.class.rand2
+    end
+
+end

data/lib/strategies/linear_algebra/gauss_seidel_strategy.rb

@@ -0,0 +1,90 @@
+##
+# This strategy will solve a system of linear equations using the Gauss Seidel iterative strategy
+# Constructor Inputs: (a_arr, b_arr) correspond to A and B in the equation Ax = B (a should be an nxn 2D array, and b should be a 1D array (even though in the equation it is a column vector))
+#
+## a = [[4,1,-1],[2,7,1],[1,-3,12]]
+## b = [3,19,31]
+## gs = Digiproc::Strategies::GaussSeidelStrategy.new(a,b)
+## x = gs.calculate # => Matrix[[0.9998668946614292], [2.000021547671973], [3.000054218557957]]
+
+
+class Digiproc::Strategies::GaussSeidelStrategy
+
+
+    ##
+    # ==Initialize args
+    # a_arr:: 2D array representing your A matrix
+    # b_arr:: 1D array representing your B matrix
+    # Where B = Ax defines your series of linear equations
+    def initialize(a_arr,b_arr)
+        # TODO: Raise exception if a_arr is not square and b_arr row_count != a_arr row count
+        @b = Matrix.column_vector(b_arr)
+        @a = Matrix.rows(a_arr, true)
+        d_arr, l_arr, u_arr = [],[],[]
+        num_cols = @a.column_count
+        @a.row_count.times do 
+            d_arr << Array.new(num_cols, 0)
+            l_arr << Array.new(num_cols, 0)
+            u_arr << Array.new(num_cols, 0)
+        end
+
+        @a.each_with_index do |el, row, col| 
+            if row > col
+                l_arr[row][col] = el
+            elsif row < col
+                u_arr[row][col] = el
+            else
+                d_arr[row][col] = el
+            end
+        end
+        @d = Matrix.rows(d_arr)
+        @l = Matrix.rows(l_arr)
+        @u = Matrix.rows(u_arr)
+        #TODO: Ensure no zeros on diagonal
+        @dinv = @d.map{ |el| el == 0 ? 0 : 1.0 / el }
+    end
+
+    ##
+    # Iteratively solves the linear system of equations using the Gauss Seidel method
+    # accepts an optional parameter which is the threshold value x(n+1) - x(n) should achieve before returning. 
+    # Must be used with a key-value pair ie 
+    ## gs.calculate(threshold: 0.001)
+    # default threshold = 0.001
+    # Returns a column vector Matrix => access via matrix_return[row,col]
+    # If run with the option safety_net: true and the equation diverges, performs A_inverse * B to solve 
+    # ie 
+    ## s.calculate(safety_net: true)
+    #
+    def calculate(threshold: 0.001, safety_net: false)
+        dinv, b, l, u = @dinv, @b, @l, @u
+        c = dinv * b
+        t = -1 * dinv * (l + u)
+        x_n = Matrix.column_vector(Array.new(@a.column_count, 0))
+        counter = 0
+
+        #TODO: Investigate speed difference of using 
+        # x_new = c + t*x_old , where:
+        # c = (l + d).inv * b
+        # t = -1 * (l + d).inv * u
+        loop do 
+            x_n_plus_1 = x_n.dup
+            for i in 0...x_n.row_count do 
+                x_n_i = c.row(i).to_matrix + t.row(i).to_matrix.transpose * x_n_plus_1
+                # puts "#{c.row(i).to_matrix} + #{t.row(i).to_matrix.transpose} * #{x_n_plus_1} = #{x_n_i}"
+                x_n_plus_1[i,0] = x_n_i[0,0]
+            end
+            x_difference = (x_n_plus_1 - x_n).map{ |el| el.abs }
+            should_break = !x_difference.find{ |el| el > threshold }
+            x_n = x_n_plus_1           
+            break if should_break
+            counter += 1
+            if counter > 1000000 and safety_net 
+                return (@a.inv * b).map{ |el| el.to_f}
+            end
+        end 
+        return (safety_net and x_n.find{ |el| el.to_f.nan? }) ? (@a.inv * b).map{ |el| el.to_f} : x_n
+    end
+
+
+
+end

data/lib/strategies/linear_algebra/jacobi_strategy.rb

@@ -0,0 +1,81 @@
+
+##
+# This strategy will solve a system of linear equations using the Jacobi iterative strategy
+# Constructor Inputs: (a_arr, b_arr) correspond to A and B in the equation Ax = B (a should be an nxn 2D array, and b should be a 1D array (even though in the equation it is a column vector))
+#
+## a = [[4,1,-1],[2,7,1],[1,-3,12]]
+## b = [3,19,31]
+## gs = Digiproc::Strategies::JacobiStrategy.new(a,b)
+## x = gs.calculate # => Matrix[[0.9998668946614292], [2.000021547671973], [3.000054218557957]]
+
+class Digiproc::Strategies::JacobiStrategy
+
+    attr_reader :a, :b, :d, :u, :l, :dinv
+
+    ##
+    # ==Initialize args
+    # a_arr:: 2D array representing your A matrix
+    # b_arr:: 1D array representing your B matrix
+    # Where B = Ax defines your series of linear equations
+    def initialize(a_arr,b_arr)
+        # TODO: Raise exception if a_arr is not square and b_arr row_count != a_arr row count
+        @b = Matrix.column_vector(b_arr)
+        @a = Matrix.rows(a_arr, true)
+        d_arr, l_arr, u_arr = [],[],[]
+        num_cols = @a.column_count
+        @a.row_count.times do 
+            d_arr << Array.new(num_cols, 0)
+            l_arr << Array.new(num_cols, 0)
+            u_arr << Array.new(num_cols, 0)
+        end
+
+        @a.each_with_index do |el, row, col| 
+            if row > col
+                l_arr[row][col] = el
+            elsif row < col
+                u_arr[row][col] = el
+            else
+                d_arr[row][col] = el
+            end
+        end
+        @d = Matrix.rows(d_arr)
+        @l = Matrix.rows(l_arr)
+        @u = Matrix.rows(u_arr)
+        #TODO: Ensure no zeros on diagonal
+        @dinv = @d.map{ |el| el == 0 ? 0 : 1.0 / el }
+    end
+
+    ##
+    # Iteratively solves the linear system of equations using the jacobi method
+    # accepts an optional parameter which is the threshold value x(n+1) - x(n) should achieve before returning. 
+    # Must be used with a key-value pair ie 
+    ## gs.calculate(threshold: 0.001)
+    # default threshold = 0.001
+    # Returns a column vector Matrix => access via matrix_return[row,col]
+    # If run with the option safety_net: true and the equation diverges, performs A_inverse * B to solve 
+    # ie 
+    ## gs.calculate(safety_net: true)
+    #
+    def calculate(threshold: 0.001, safety_net: false)
+        dinv, b, l, u = @dinv, @b, @l, @u
+        c = dinv * b
+        t = -1 * dinv * (l + u)
+        x_n = Matrix.column_vector(Array.new(@a.column_count, 0))
+        counter = 0
+        loop do 
+            x_n_plus_1 = c + t * x_n
+            x_difference = (x_n_plus_1 - x_n).map{ |el| el.abs }
+            # puts x_n_plus_1
+            should_break = !x_difference.find{ |el| el > threshold }
+            x_n = x_n_plus_1           
+            break if should_break
+            counter += 1
+            if counter > 10000000 and safety_net 
+                return (@a.inv * b).map{ |el| el.to_f}
+            end
+        end 
+        return (safety_net and x_n.find{ |el| el.to_f.nan? }) ? (@a.inv * b).map{ |el| el.to_f} : x_n
+    end
+
+
+end