digiproc 0.1.0

data/lib/rbplot.rb

@@ -0,0 +1,219 @@
+##
+# Plotting API built on top of Gruff meant to have similar characterstics to matplotlib
+class Digiproc::Rbplot
+
+    MIDNIGHT = {
+        :colors => [
+          '#00dae5',  #teal
+          '#FF1A1A',  # red
+          '#3FFC07',  # green
+          '#FDD84E',  # yellow
+          '#6886B4',  # blue
+          '#8A6EAF',  # purple
+          '#EFAA43',  # orange
+          'white'
+        ],
+        :marker_color => '#7e7c7f',
+        :font_color => '#cccccc',
+        :background_colors => %w(black #2a2a2a)
+      }
+
+      SUBMARINE = {
+        :colors => [
+          '#FF1A1A',  # red
+          '#3FFC07',  # green
+          '#FDD84E',  # yellow
+          '#6886B4',  # blue
+          '#8A6EAF',  # purple
+          '#EFAA43',  # orange
+          'white'
+        ],
+        :marker_color => '#3d007a',
+        :font_color => '#cccccc',
+        :background_colors => %w(black #2a2a2a)
+      }
+
+      BLUESCALE = {
+        :colors => [
+          '#0b0b70', #Blue
+          '#981598', #Purple
+          '#181000', #Dark gray
+          '#B50202', #
+          '#c8c8c8', #
+          '#e8e8e8', #
+        ],
+        :marker_color => '#aea9a9', # Grey
+        :font_color => 'black',
+        :background_colors => 'white'
+      }
+
+
+    ##
+    # Constuctor for a line plot instnace
+    ## x = Digiproc::Functions.linspace(1,100,100)
+    ## y = Digiproc::Probability.nrand(100)
+    ## plt = Digiproc::Rbplot.line(x, y, "random vals")
+    def self.line(x = nil, y = nil, label="data")
+        LinePlot.new(x, y, label)
+    end
+
+    ##
+    # Class for a line plot
+    class LinePlot
+        include Digiproc::OS
+        def initialize(x, y, label = "data 1")
+            @methods = {
+                line_width: 2.5, 
+                dot_radius: 0.1,
+                theme: BLUESCALE,
+                title: 'RbPlot'
+            }
+            @dataxy = [[label, x, y]]
+            @path = './'
+            @filename = nil
+            @size = '1000x1000'
+            self.xsteps(5)
+        end
+
+        ##
+        # sets filename for the image to be written
+        # downcases, strips, and replaces spaces with dashes
+        def filename(name)
+            @filename = name.downcase.strip.gsub(' ', '-')
+        end
+        ##
+        #Sets title for the graph
+        ## plt.title('Plot Title')
+        def title(title)
+            filename(title)
+            @methods[:title] = title
+        end
+
+        ##
+        # Sets the x label:
+        ## plt.xlabel('time')
+        def xlabel(label)
+            @methods[:x_axis_label] = label
+        end
+
+        ##
+        # Sets the y label
+        ## plt.ylabel('y axis')
+        def ylabel(label)
+            @methods[:y_axis_label] = label
+        end
+
+        ##
+        # Sets data label for the last inputted line data
+        ## plt.data_label('Set 3')
+        def data_label(label)
+            @dataxy.last[0] = label
+        end
+
+        ##
+        # Sets the labels for each line entered (variable array input)
+        ## plt.legend("Data 1", "Data 2")
+        def legend(*labels)
+            labels.each.with_index do |l, i|
+                @dataxy[i][0] = l
+            end
+        end
+
+        ##
+        # Add another line to the plot
+        # y2 = Digiproc::Probability.nrand(100)
+        ## plt.add_line(x, y2, "Data 2")
+        def add_line(x, y, label="data #{@dataxy.length + 1}")
+            @dataxy << [label, x, y]
+        end
+
+        ##
+        # Sets the number of labels on the x axis
+        ## plt.xsteps(5)
+        def xsteps(steps)
+            len = @dataxy.first[1].length
+            steps = len if(steps >= len)
+            labels = {}
+            every = (len.to_f / steps).floor
+            for i in 0..steps do
+                index = i == 0 ? 0 : (i * every) - 1
+                labels_val = i == 0 ? 1 : i * every
+                # labels[labels_val] = @dataxy.first[1][index].round(2)
+                labels[@dataxy.first[1][index]] = @dataxy.first[1][index].round(2)
+            end
+            @methods[:labels] = labels
+        end
+
+        ##
+        # Sets the path where the image will be written
+        # Defaults to "./"
+        ## plt.path("./")
+        def path(path)
+            @path = path
+        end
+
+        ##
+        # Sets the theme of the graph
+        # Accepts :dark, :light, or :deep
+        ## plt.theme(:dark)
+        def theme(theme)
+            case theme
+            when :dark
+                @methods[:theme] = MIDNIGHT
+            when :deep
+                @methods[:theme] = SUBMARINE
+            when :light
+                @methods[:theme] = BLUESCALE
+            else
+                throw ArgumentError.new('Not a valid theme')
+            end
+        end
+
+        ##
+        # Set size of the graph in pixels. Takes two integers
+        ## plt.size(2000, 2000). Defaults upon initialization to 1000,1000
+        def size(w,h)
+            @size = "#{w}x#{h}"
+        end
+
+        ##
+        # Writes the image and opens it with the default program depending on the os
+        ## plt.show
+        def show(path = @path)    
+            write(path)
+            file = path + @filename + '.png'
+            if windows?
+                system %{cmd /c "start #{file}"}
+            elsif mac?
+                file_to_open = "/path/to/file.txt"
+                system %{open "#{file}"}
+            elsif linux?
+                begin 
+                    system %{xdg-open "#{file}"}
+                    system %{cmd.exe /c "start #{file}"}
+                rescue 
+                    system %{cmd.exe /c "start #{file}"}
+                end
+            end
+        end
+
+        ##
+        # Writes the image to the saved path, does not open it
+        ## plt.write
+        def write(path = @path)
+            
+            gline = Gruff::Line.new(@size)
+            @methods.each do |m, args|
+                gline.send("#{m}=", args)
+            end
+            @dataxy.each do |dxy| 
+                gline.dataxy(dxy[0], dxy[1], dxy[2]) 
+            end
+
+            @filename ||= filename(@methods[:title])
+            @filename ||= "rbPlot"
+            gline.write(path + @filename + '.png')
+        end
+
+    end
+end

data/lib/signals/analog_signal.rb

@@ -0,0 +1,143 @@
+##
+# Class for performing actions upon an Analog, Continuous Time signal defined by an equation
+# Initialized with a lambda or proc, the signal is sampled, companded, quantized, and can be turned into a `Digiproc::DigitalSignal`
+class Digiproc::AnalogSignal
+
+    attr_accessor :sample_rate, :size, :companding_strategy, :signal, :quantization_bits, :quant_max, :quant_min
+    attr_reader :raw_samples, :quantized_samples, :eqn
+
+    ##
+    # See examples/analog_signals/companding for full options in initializer
+    ## fn = ->(x){ Math.sin(x) }
+    ## asig = Digiproc::AnalogSignal.new(eqn: fn) 
+    def initialize(eqn: ,sample_rate: 0.0001, size: 100, companding_strategy: nil, quantization_bits: Float::INFINITY, quant_max: nil, quant_min: nil)
+        @eqn, @sample_rate, @size, @quantization_bits, @quant_max, @quant_min = eqn, sample_rate, size, quantization_bits, quant_max, quant_min
+        @signal = eqn
+        @companding_strategy = (companding_strategy.is_a?(Class) and !!companding_strategy) ? companding_strategy.new : companding_strategy 
+    end
+
+    ##
+    # No arguments, outputs [Array] digital samples
+    # Will sample, compand (compress, expand), and quantize samples (companding and quantizing optional)
+    # See analog_signals examples
+    def digitize
+        samples = sample
+        @raw_samples = samples
+        samples = compress(samples) if not companding_strategy.nil?
+        samples = quantize(samples, self.quantization_bits, self.quant_max, self.quant_min) if self.quantization_bits < Float::INFINITY
+        samples = expand(samples) if not companding_strategy.nil?
+        @quantized_samples = samples
+        samples
+    end
+
+    ##
+    # Returns a Digiproc::DigitalSignal of the digital signals
+    def to_ds
+        Digiproc::DigitalSignal.new(data: digitize)
+    end
+
+    ##
+    # Returns [Float] normalized quantization RMS error. See examples/analog_signal/companding
+    def normalized_quantization_rms_error
+        total = 0
+        x_max = self.raw_samples.max
+        self.raw_samples.each_with_index do |x, i|
+            total += ((x.to_f - quantized_samples[i]) / x_max) ** 2
+        end
+        (1.0 / size) * (total ** (0.5))
+    end
+
+    private
+
+    ##
+    # Quantize signals to a certain number of bits over a specified range
+    # == Args
+    # samples:: [Array] input data
+    # bits:: [Integer] number of bits used to reprisent each sample
+    # max:: maximum possible sample values (to be reprisented by max bits in quantization)
+    # min:: minimum possible sample value (to be reprisented by minimum bits value in quantization)
+    # bit quantization is mapped back to original max and min values, returning what they would look like upon
+    # attempted reconstruction of the analog signal.
+    def quantize(samples, bits, max, min)
+        sample_bits = quantize_bit_reprisentation(samples, bits, max, min)
+        process(sample_bits, map_to_eqn(bits**2 / 2.0 , -(bits**2) / 2.0 , max, min))
+    end
+
+
+    def quantize_positive_bits(samples, bits, max, min)
+        levels = bits ** 2
+        quantize_bit_reprisentation(samples, bits, max, min) + (levels / 2.0)
+    end
+
+    ## 
+    # Based off max and min (defined by samples.max and samples.min if not provided), the samples are mapped from -1 to 1.
+    # Then they are multiplied by the number of "levels" of quantization (ie: number_of_bits ^ 2 / 2). 
+    # Then, the samples are rounded, thus quantizing the samples to the number of bits
+    def quantize_bit_reprisentation(samples, bits, max, min)
+        max = samples.max if max.nil? 
+        min = samples.min if min.nil?
+        levels = bits ** 2
+        mapped = map_to_unit_centered(samples, max, min)
+        process(mapped, ->(n){ (n * levels / 2.0).round})
+    end
+
+    ##
+    # Compress samples for companding before quantization
+    def compress(samples)
+        self.companding_strategy.compress(samples)
+    end
+
+    ##
+    # Expand samples for companding after quantization
+    def expand(samples)
+        self.companding_strategy.expand(samples)
+    end
+
+    ##
+    # Sample the signal and return [Array] of sampled values
+    def sample
+        sample_times = process(0...size, ->(n){ n * self.sample_rate })
+        process(sample_times, self.signal)
+    end
+
+    ##
+    # Helper for processing an array of values with a lambda function
+    def process(inputs , equation)
+        inputs.map{ |n| equation.call(n) }
+    end
+
+    ##
+    # Map values to range -1 to 1
+    def map_to_unit_centered(samples, max, min)
+        center = center_of(max, min)
+        range = range_of(max, min)
+        a_range = range / 2.0
+        mapping = ->(n){ (n - center) / a_range }
+        process(samples, mapping)
+    end
+
+    ##
+    # Return a lambda function which will map a dataset to a target maximum and minimum
+    def map_to_eqn(starting_max, starting_min, target_max, target_min)
+        target_center = center_of(target_max, target_min)
+        target_range = range_of(target_max, target_min)
+        starting_center = center_of(starting_max, starting_min) 
+        starting_range = range_of(starting_max.to_f, starting_min)
+        center_map = target_center - starting_center
+        range_map = target_range / starting_range
+        ->(n){ (n - starting_center) * range_map + target_center}
+    end
+
+    ##
+    # Return center [Float]
+    def center_of(max, min)
+        (max + min) / 2.0
+    end
+
+    ##
+    # Return range [Float]
+    def range_of(max, min)
+        max.to_f - min
+    end
+
+end

data/lib/signals/digital_signal.rb

@@ -0,0 +1,181 @@
+##
+# Class for performing actions on Digital Signals easily
+class Digiproc::DigitalSignal
+    attr_accessor :data
+    include Digiproc::Convolvable::InstanceMethods, Digiproc::FourierTransformable
+
+    ##
+    # Construct an instance from a Proc (or a Lambda) and a size
+    ## ds = Digiproc::DigitalSignal.new_from_eqn(eqn: ->(t){ Math.sin(t) }, size: 100)
+    def self.new_from_eqn(eqn: , size: )
+        rng = (0...size)
+        self.new(data: rng.map{ |n| eqn.call(n) })
+    end
+
+    ##
+    # Make a digital signal which is defined by one equation in one range, and another eqn in another range
+    ## eqn1 = ->(t){ (1 - Math::E ** (-0.08*t)) } 
+    ## eqn2 = ->(t){ Math::E ** (-0.002*(t - 100)) }
+    ## ds = Digiproc::DigitalSignal.new_from_equations(eqns: [eqn1, eqn2], ranges: [0...100, 100...1000])
+    def self.new_from_equations(eqns: , ranges: )
+        data = []
+        eqns.each_with_index do |eqn, i|
+            ranges[i].each do |n|
+                data[n] = eqn.call(n)
+            end
+        end
+        data.map!{ |val| val.nil? ? 0 : val }
+        self.new(data: data)
+    end
+    
+
+    ##
+    # Make a new digital signal from fft data
+    def new_from_spectra(fft)
+        self.new(data: Digiproc::Functions.ifft(fft))
+    end
+    
+    ##
+    # Initialize with `data`
+    def initialize(data: )
+        raise ArgumentError.new("Data must be an Array, not a #{data.class}") if not data.is_a? Array
+        @data = data
+        initialize_modules(Digiproc::FourierTransformable => {time_data: data})
+    end
+
+    ##
+    # Helper method to allow user to process a ds data using a block
+    ## ds = Digiproc::DigitalSignal.new_from_eqn(eqn: ->(t){ Math.sin(t) }, size: 100)
+    ## ds.process { |el| el * 10 } # Change signal gain from 1 to 10.
+    # Does not change @data, just returns processed array
+    def process 
+        processed_data = []
+        for i in 0...data.length do
+            processed_data << (yield data[i])
+        end
+        processed_data
+    end
+
+    ##
+    # Same as `#process` except @data is replaced by the output
+    def process!
+        processed_data = []
+        for i in 0...data.length do
+            processed_data << (yield data[i])
+        end
+        self.data = processed_data
+    end
+
+    ##
+    # Updates data while processing, allowing recursive processing (ie using prev outputs to create new ones)
+    def process_in_place!
+        for i in 0...data.length do 
+            self.data[i] = yield data[i]
+        end
+        self.data
+    end
+
+    ##
+    # Allows multiplication of two digital signal objects
+    # Performs element by element multiplicaiton of the data vectors
+    def *(ds)
+        raise ArgumentError.new("Object must have a data property") unless ds.respond_to? :data
+        raise ArgumentError.new("Object must have a data array") unless ds.data.respond_to? :times
+        self.data.length < ds.data.length ? self.class.new(data:self.data.times(ds.data.take(self.data.length))) : self.class.new(data: ds.data.times(self.data.take(ds.data.length))) 
+        # self.data.times ds.data
+    end
+
+    ##
+    # Get data values from @data by index
+    ## ds = Digiproc::DigitalSignal.new_from_eqn(eqn: ->(t){ Math.sin(t) }, size: 100)
+    ## vals = ds.i(10..12) # => [-0.5440211108893699, -0.9999902065507035, -0.5365729180004349]
+    def i(*n)
+        indices = n.map{ |input| input.respond_to?(:to_a) ? input.to_a : input}
+        indices.flatten!
+        indices.map!{ |val| self.value_at val }
+        return indices.length == 1 ? indices.first : indices
+    end
+
+    ##
+    # Get the value at a specific data index. If index falls outside of the `data` array, return 0 
+    # This is useful when simulating a signal multiplied by a unit step which is zero outside the bounds defined in the data array
+    def value_at(n)
+        data[n].nil? ? 0 : data[n]
+    end
+
+    ##
+    # Get values in the data array from a start index to a start index (inclusive). Does not turn data outside array into a 0 value
+    def values_between(start,stop)
+        data[start, stop - start + 1]
+    end
+
+    ##
+    # Convolves data with incoming signal, returns a new Digiproc::DigitalSignal whose data is the result of the convolution
+    def ds_convolve(signal)
+        Digiproc::DigitalSignal.new(data: self.conv(signal))
+    end
+
+    ##
+    # Alias to ds_convolve
+    def ds_conv(signal)
+        Digiproc::DigitalSignal.new(data: self.conv(signal))
+    end
+
+    ## 
+    # Performs cross correlation with an incoming signal, returns a Digiproc::DigitalSignal whose data is the result of the cross correlation
+    def ds_cross_correlation(signal)
+        Digiproc::DigitalSignal.new(data: self.cross_correlation(signal))
+    end
+
+    ##
+    # Alias for #ds_cross_correlation
+    def ds_xcorr(sig)
+        ds_cross_correlation(sig)
+    end
+
+    ##
+    # Performs an autocorrelation of the `data` array and retursn a Digiproc::DigitalSignal whose data is the result of the autocorrelation
+    def ds_auto_correlation
+        Digiproc::DigitalSignal.new(data: self.auto_correlation)
+    end
+
+    ##
+    # Alias to #ds_auto_correlation
+    def ds_acorr
+        ds_auto_correlation
+    end
+
+    ##
+    # Returns the Power Spectral Density (PSD) of the signal by multiplying the signal's FFT by the conjugate of the FFT (ie squaring the FFT)
+    # The result is in the frequency spectrum (as a Digiproc::FFT object)
+    def power_spectral_density
+        self.fft * self.fft.conjugate
+    end
+
+    ##
+    # Alias to #power_spectral_density
+    def psd
+        self.power_spectral_density
+    end
+
+    ##
+    # Returns the cross_spectral_density of the digital signal with an incoming signal (accepts an array of numeric data)
+    # Returns a Digiproc::FFT object 
+    def cross_spectral_density(signal)
+        ft = Digiproc::FFT.new(time_data: self.xcorr(signal))
+        ft.calculate
+        ft
+    end
+
+    ##
+    # Alias for #cross_spectral_density
+    def csd(signal)
+        self.cross_spectral_density(signal)
+    end
+
+    ##
+    # Returns data as an array
+    def to_a
+        self.data
+    end
+end

data/lib/strategies/code/differential_encoding_strategy.rb

@@ -0,0 +1,69 @@
+## Class/Strategy for for encoding a string of bits
+# ENCODES SIGNAL PER M-ARY PSK CODING STRATEGY, SEE HW6 ELEG 635
+# use the generic DPSK equation for M = 2. We will apply the ORIGINAL signal Dn 
+# to the equation βn = (2l−1)π % 2π, l ⩽ M for 
+# the phase mapping, and M then the differential signal will be 
+# created by saying our transmitted bit will be αn = αn−1 + βn
+
+class Digiproc::Strategies::DifferentialEncodingStrategy
+
+    
+    ##
+    # Encoding an incoming array of bits into an array of encoded phase angles
+    # 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 
+    # phase angles
+    # Unline previous encoding strategies, this does not XOR the bits and then phase shift those 
+    # encoded bits. Instead, the bits are transformed into frequencies which are then 
+    # added to dealyed versions of themselves modulo 2pi
+    def self.encode(arr, m = 2, beginning_val = "0")
+        beginning_val = beginning_val.to_s(2) unless beginning_val.is_a? String
+        encoded = [beginning_val]
+        arr = arr.map(&:to_s)
+        for i in 0...arr.length do 
+            curr_phase = to_phase(m)[arr[i].to_i(2).to_f]
+            last_phase = encoded.last.to_f
+            encoded << ((curr_phase + last_phase) % (2 * Math::PI)).to_s
+        end
+        encoded
+    end
+
+    ##
+    # Does not simulate a reciever, it just does the inverse algorithm 
+    # to retrieve the original message
+    # Currently incorrect
+    # TODO: fix this method
+    def self.decode(bits, m = 2)
+        encoded = []  
+        for i in 1...bits.length do 
+            encoded << ((-1 * bits[i - 1].to_f + bits[i].to_f) % (2 * Math::PI)).to_s
+        end
+        encoded.map{|phase| decode_phase(m)[phase.to_f]}
+    end
+
+    ##
+    # Required via the protocol for an encoding strategy, but this
+    # algorithm does not require a phase shift so the lambda will return the input
+    def self.phase_shift_eqn(m = nil)
+        ->(l){ l }
+    end
+
+    ##
+    # Required via the protocol for an encoding strategy, but this
+    # algorithm does not require a phase shift so the lambda will return the input
+    def self.phase_to_sym(m = nil)
+        ->(l){ l }
+    end
+
+    private 
+    def self.to_phase(m)
+        ->(l){ (((2.0 * (l+1) - 1.0) / m) % 2) * Math::PI }
+    end
+
+    def self.decode_phase(m)
+        ->(code){ (((code / (Math::PI)) * m) + 1.0) / 2.0 - 1.0 }
+    end
+
+    # TODO: IMPLEMENT DECODING STRATEGY PER FIGURE 4-15 in INTRODUCTION TO DIGITAL COMMUNICATIONS, ZIEMER, PETERSON
+
+end

data/lib/strategies/code/gray_code.rb

@@ -0,0 +1,75 @@
+## 
+# Strategy for creating the Gray Code of a big stream.
+# Capable of encoding or decoding gray code
+# Gray code ensures that all adjacent numbers only differ by
+# one bit. This will reduce errors caused by a transmission/recieving process
+# For information on Gray Code, try looking at https://www.allaboutcir- cuits.com/technical-articles/gray-code-basics/
+
+class Digiproc::Strategies::GrayCode
+
+    ##
+    # Input argument = integer indicating how many bits you want 
+    # The output will be an array of incrememnting gray code numbers with the 
+    # number of specified bits. The output array's length wlll be 2^n where
+    # `n` is the input number.
+    def self.generate(size)
+        if size == 1
+            ["0", "1"]
+        else
+            prepend("0", generate(size - 1)) + prepend("1", generate(size - 1).reverse)
+        end
+    end
+
+    ##
+    # Accepts a n integer.
+    # The input integer is the decimal version of a gray code number
+    # This method will output a binary number in string form
+    # The ouput number is the "regular" number counterpart to the 
+    # gray code input number. The output will be in binary form.
+    def self.to_binary(bin)
+        bits = bin.size
+        gray_code = 0
+        bit_number = bits - 1
+        bit = 0
+        while bit_number >= 0
+        bit ^= bin >> bit_number & 1
+        gray_code |= (1 << bit_number) * bit
+        bit_number -= 1
+        end
+        gray_code.to_s(2)
+    end
+
+    ##
+    # Accepts a n integer.
+    # The input integer is the decimal version of a gray code number
+    # This method will output a decimal number in string form
+    # The ouput number is the "regular" number counterpart to the 
+    # gray code input number. The output will be in decimal form.
+    def self.to_dec(bin)
+        bits = bin.size
+        gray_code = 0
+        bit_number = bits - 1
+        bit = 0
+        while bit_number >= 0
+        bit ^= bin >> bit_number & 1
+        gray_code |= (1 << bit_number) * bit
+        bit_number -= 1
+        end
+        gray_code.to_s
+    end
+
+    ##
+    # Accepts a n integer.
+    # The input integer is a decimal number that you want to convert to gray code
+    # This method will output a binary number in string form
+    # The ouput number is the the gray code number counterpart to the input integer.
+    def self.to_gray(binary)
+        (binary ^ (binary >> 1)).to_s(2)
+    end
+
+    private
+
+    def self.prepend(prefix, code)
+        code.map { |bit| prefix + bit}
+    end
+end