digiproc 0.1.0

data/lib/strategies/linear_algebra/sor2_strategy.rb

@@ -0,0 +1,98 @@
+##
+# This strategy will solve a system of linear equations using the Successive Over Relaxation 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]
+## sorm = Digiproc::Strategies::SorStrategy.new(a,b)
+## x = sorm.calculate # => Matrix[[0.9998668946614292], [2.000021547671973], [3.000054218557957]]
+
+
+class Digiproc::Strategies::Sor2Strategy
+
+
+    ##
+    # ==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 Successive Over Relaxation 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 
+    ## sorm.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 
+    ## sorm.calculate(safety_net: true)
+    # You can change the weighting factor w by inputting `w` as an argument, ie:
+    ## sorm.calculate(w: 0.35) 
+    # The default value is w = 0.95
+    # The weighting factor does an average on each iteration of x_n between x_n and x_n+1, ie:
+    # x_1_new = ((1-w) * x_1_old) + w (eqn_for_x_1_new using x_k_olds)
+    # Whereas the gauss seidel strategy would just be
+    # x_1_new = (eqn_for_x_1_new using x_k_olds)
+    # Threshold strategy is by default set to test the euclidean norm of the delta x matrix. If euclid_norm is manually
+    # set to false, then it will compare element by element to ensure each term in delta_x is less than the threshold
+    def calculate(w: 0.95, threshold: 0.001, safety_net: false, euclid_norm: true)
+        dinv, b, l, u, d = @dinv, @b, @l, @u, @d
+        c = (l + d).inv * b
+        t = -1 * (l + d).inv * u
+        x_n = Matrix.column_vector(Array.new(@a.column_count, 0))
+        counter = 0
+
+        loop do 
+            x_n_plus_1 = ((1-w) * x_n) + w * (c + t * x_n)
+            x_difference = (x_n_plus_1 - x_n).map{ |el| el.abs }
+            should_break = euclid_norm ? break_euclid?(x_difference, threshold) : break_threshold?(x_difference, threshold)
+            x_n = x_n_plus_1         
+            break if should_break
+            counter += 1
+            if counter > 100000 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
+
+
+    private
+
+    def break_euclid?(delta_x, norm_threshold)
+        euclid_norm = delta_x.map{ |el| el ** 2 }.sum ** 0.5 < norm_threshold
+    end
+
+    def break_threshold?(delta_x, threshold)
+        !delta_x.find{ |el| el > threshold }
+    end
+
+end

data/lib/strategies/linear_algebra/sor_strategy.rb

@@ -0,0 +1,108 @@
+##
+# This strategy will solve a system of linear equations using the Successive Over Relaxation 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]
+## sorm = Digiproc::Strategies::SorStrategy.new(a,b)
+## x = sorm.calculate # => Matrix[[0.9998668946614292], [2.000021547671973], [3.000054218557957]]
+
+
+class Digiproc::Strategies::SorStrategy
+
+
+    ##
+    # ==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 Successive Over Relaxation 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 
+    ## sorm.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 
+    ## sorm.calculate(safety_net: true)
+    # You can change the weighting factor w by inputting `w` as an argument, ie:
+    ## sorm.calculate(w: 0.35) 
+    # The default value is w = 0.95
+    # The weighting factor does an average on each iteration of x_n between x_n and x_n+1, ie:
+    # x_1_new = ((1-w) * x_1_old) + w (eqn_for_x_1_new using x_k_olds)
+    # Whereas the gauss seidel strategy would just be
+    # x_1_new = (eqn_for_x_1_new using x_k_olds)
+    # Threshold strategy is by default set to test the euclidean norm of the delta x matrix. If euclid_norm is manually
+    # set to false, then it will compare element by element to ensure each term in delta_x is less than the threshold
+    def calculate(w: 0.95, threshold: 0.001, safety_net: false, euclid_norm: true)
+        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 = ( Matrix[[(1-w) * x_n[i,0]]] ) + w * (c.row(i).to_matrix + t.row(i).to_matrix.transpose * x_n_plus_1)
+                # puts "#{Matrix[[(1-w) * x_n[0,0]]]} + #{w} * #{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]
+                # puts x_n_plus_1[0,0]
+            end
+            x_difference = (x_n_plus_1 - x_n).map{ |el| el.abs }
+            should_break = euclid_norm ? break_euclid?(x_difference, threshold) : break_threshold?(x_difference, threshold)
+            x_n = x_n_plus_1           
+            break if should_break
+            counter += 1
+            if counter > 100000 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
+
+
+    private
+
+    def break_euclid?(delta_x, norm_threshold)
+        euclid_norm = delta_x.map{ |el| el ** 2 }.sum ** 0.5 < norm_threshold
+    end
+
+    def break_threshold?(delta_x, threshold)
+        !delta_x.find{ |el| el > threshold }
+    end
+
+end

data/lib/strategies/modulation/phase_shift_keying_strategy.rb

@@ -0,0 +1,96 @@
+class Digiproc::Strategies::PSK
+
+    attr_accessor :m, :modulating_signal , :carrier_signal_eqn, :coding_strategy, :phase_shift_eqn, :signal_to_phase, :coded_signal, :phase_signal, :carrier_frequency, :pulse_length
+
+    ##
+    # == Initialize Args
+    # modulating_signal:: Array[String]; each element is a "symbol" (should be a string reprisenting bits), where a symnbol is a number of bits symbolizing a single character (ie symbol means character)
+    # carrier_signal_eqn (optional):: Lambda (or Proc) default value is: ->(a, fo, t, theta){ a * Math.cos(2*Math::PI * fo * t + theta) }
+    # coding_strategy (optional):: Protocol, see Digiproc::Strategies::XORDifferentialEncodingZeroAngleStrategy, default value is nil
+    # carrier_frequency (optional)::Numeric (in Hz), defaults to 10000
+    # pulse_length (optional):: Float (in seconds), defaults to 0.00015 determines how long to apply a phase shift
+    def initialize(carrier_signal_eqn: ->(a, fo, t, theta){ a * Math.cos(2*Math::PI * fo * t + theta) }, modulating_signal: ,coding_strategy: nil, carrier_frequency: 10000, pulse_length: 0.00015)
+        @carrier_signal_eqn, @modulating_signal, @coding_strategy, @carrier_frequency, @pulse_length = carrier_signal_eqn, modulating_signal, coding_strategy, carrier_frequency, pulse_length
+        @m = 2 ** modulating_signal.first.length 
+        if coding_strategy.nil?
+            @phase_shift_eqn = ->(i){ (2.0 * Math::PI * (i)) / @m }
+            @coded_signal = @modulating_signal
+        else
+            @phase_shift_eqn = coding_strategy.phase_shift_eqn(@m)
+            @coded_signal = coding_strategy.encode modulating_signal, @m, "0"
+        end
+        @signal_to_phase = {}
+        for i in 0...@m do
+            @signal_to_phase[i.to_s] = @phase_shift_eqn[i]
+        end
+
+        @phase_signal = @coded_signal.map{ |coded_symbol| @phase_shift_eqn[coded_symbol.to_i(2)] }
+
+    end
+
+    ##
+    # == Input Args
+    # a (optional):: Numeric for amplitude of the signal (default value = 1)
+    # Return Digiproc::AnalogSignal of the Phase Shift Keyed signal
+    def output(a: 1)
+        eqn = Proc.new do |t|
+            theta_index = (t.to_f / @pulse_length.to_f).floor
+            @carrier_signal_eqn[a, @carrier_frequency, t, @phase_signal[theta_index]]
+        end
+        sample_rate = 0.01 / @carrier_frequency
+        size = @pulse_length.to_f * @phase_signal.length / sample_rate
+        Digiproc::AnalogSignal.new(eqn: eqn, sample_rate: sample_rate, size: size)
+    end 
+
+    ##
+    # Apply inverse of the PSK strategy to decode the PSK signal
+    def decode
+        eqn = coding_strategy.nil? ? decode_eqn : coding_strategy.phase_to_sym(@m)
+        sym = @phase_signal.map{ |phase| eqn[phase] }
+        sym = coding_strategy.decode(sym) if not coding_strategy.nil?
+        return sym
+    end
+
+    ##
+    # Based off of reciever Figure 4-15 INTRODUCTION TO DIGITAL COMMUNICATIONS, ZIEMER, PETERSON pg 237
+    # NOTE: SUBOPTIMUM DETECTOR, optimum detector referenced on the above page, different reference
+    # This simulates a real-life reciever recieving the siglans and decoding them
+    def reciever_decode
+        recieved = output.to_ds.fft.magnitude
+        ts = 1 / (@carrier_frequency / 0.01)
+        max_freq = 1.0 / ts
+        normalized_target = @carrier_frequency / max_freq.to_f
+        bw = (0.57 / ts) / max_freq.to_f
+        plt = Digiproc::QuickPlot
+        factory = Digiproc::Factories::FilterFactory
+        bpf = factory.filter_for(type: "bandpass", wo: normalized_target * Math::PI * 2, bw: bw * Math::PI * 2, transition_width: 0.0001, stopband_attenuation: 80)
+        bpf.fft.calculate_at_size(2 ** 16)
+
+        filtered = (bpf.fft * output.to_ds.fft(2** 16)).ifft.map(&:real)
+        sample_interval = @pulse_length / (0.01 / @carrier_frequency)
+        output = []
+        for i in (sample_interval + 1).to_i...filtered.length do 
+            output << (filtered[i] * filtered[i-sample_interval]) 
+        end
+        lpf = factory.filter_for(type: "lowpass", wc: 2 * Math::PI / 4, transition_width: 0.0001, stopband_attenuation: 80)
+        outft = Digiproc::FFT.new(time_data: output, size: 2 ** 16)
+        
+        # TODO FIND WHERE SIGNAL BEGINS AND OUTPUT THE SIGNAL BASED OFF OF 
+        # SIGNAL SIZE. ALSO, THERE SHOULD BE A RECIEVER METHOD OR SEPERATE CLASS
+        # WHICH OUPUTS THE RAW DATA OF THE RECIEVERS
+        data = (outft * lpf.fft).ifft.map(&:real)
+        all_out = @phase_signal.size > 200 ? data[55000,  200 * sample_interval].concat(data[0, sample_interval * (@phase_signal.size - 200)]) : data[55000,  @phase_signal.size * sample_interval]
+        final_out = []
+        for i in 0...all_out.length do
+            final_out << all_out[i] if (i + 10) %  sample_interval == 0 
+        end
+        final_out
+    end
+
+
+    private
+
+    def decode_eqn
+        ->(phase){ (phase * @m / (2.0 * Math::PI))}
+    end
+end 

data/lib/strategies/orthogonalize/gram_schmidt.rb

@@ -0,0 +1,50 @@
+##
+# Class to orthonormalize a set of numbers
+class Digiproc::Strategies::GramSchmidtOrthonormalize
+
+    attr_reader :original_matrix, :orthonormalized_matrix
+
+    ##
+    # == Input Args
+    # matrix:: 2D array, each row is a set of numbers that should be orthogonalized
+    def initialize(matrix)
+        @original_vectors = matrix
+        # if matrix.is_a? Array
+        #     matrix = Vector.elements(matrix)
+        # end
+        vector_matrix = matrix.map { |vector| vector.is_a?(Array) ? Vector.elements(vector) : vector }
+        @orthonormalized_matrix = gram_schmidt(vector_matrix)
+    end
+
+    ##
+    # No input arguments
+    # Output is a 2D array of Orthonormalized sets of numbers corresponding to the input set of numbers
+    def output
+        @orthonormalized_matrix.map{|vector| vector.to_a } 
+    end
+
+    private
+
+    def gram_schmidt(matrix)
+        u = []
+        u << normalize_vector(matrix.first)
+        for i in 1...matrix.length do 
+            u << matrix[i]
+            for j in 0...i
+                u[i] = u[i] - u[i].project_onto(u[j])
+                # puts u.last.to_s if i == matrix.length - 1
+            end
+            u[i] = normalize_vector(u[i])
+        end
+        return u
+    end
+
+    def normalize_vector(vector)
+        begin
+           vector.normalize
+        rescue Vector::ZeroVectorError
+            vector
+        end
+    end
+
+end

data/lib/strategies/strategies.rb

@@ -0,0 +1,3 @@
+module Digiproc::Strategies
+
+end

data/lib/strategies/window/blackman_window.rb

@@ -0,0 +1,32 @@
+## 
+# Blackman Window
+# Used to improve digital filters by using a non-retangular frequency domain window 
+class Digiproc::BlackmanWindow < Digiproc::WindowStrategy
+
+    ##
+    # == Input Args
+    # size (Optional):: Numeric (default: nil), how many datapoings the window should have
+    # norm_trans_freq:: Numeric (default: nil), the desired transition frequency
+    # If you know what size of the the window that you need, you can input size without norm_trans_freq
+    # If you kow the desired transition frequency, the necessary size will be calculated for you based off of 
+    # the window type so it is not necessary to enter the size
+    def initialize(size: nil , norm_trans_freq: nil)
+        super(size: norm_trans_freq.nil? ? size : find_size(norm_trans_freq))
+        #size = @size + 2
+        #@equation = lambda { |n| 0.42 - 0.5 * Math.cos(2 * PI * (n + 1) / (size - 1)) + 0.08 * Math.cos(4*PI*(n + 1) / (size - 1)) }
+        @equation = lambda { |n| 0.42 - 0.5 * Math.cos(2 * PI * (n) / (size - 1)) + 0.08 * Math.cos(4*PI*(n) / (size - 1)) }
+        calculate
+        @values = @values.take(@size)
+    end
+
+    # Given a freqency, return the required size of a BlackmanWindow
+    def find_size(freq)
+        size = 5.5 / freq
+        make_odd(size.ceil)
+    end
+
+    # Return the transition width (in rad/s) based off of the size
+    def transition_width
+        5.5 / @size
+    end
+end

data/lib/strategies/window/hamming_window.rb

@@ -0,0 +1,31 @@
+##
+# Hamming Window
+# Used to improve digital filters by using a non-retangular frequency domain window 
+class Digiproc::HammingWindow < Digiproc::WindowStrategy
+
+    ##
+    # == Input Args
+    # size (Optional):: Numeric (default: nil), how many datapoings the window should have
+    # norm_trans_freq:: Numeric (default: nil), the desired transition frequency
+    # If you know what size of the the window that you need, you can input size without norm_trans_freq
+    # If you kow the desired transition frequency, the necessary size will be calculated for you based off of 
+    # the window type so it is not necessary to enter the size
+    def initialize(size: nil , norm_trans_freq: nil)
+        super(size: norm_trans_freq.nil? ? size : find_size(norm_trans_freq))
+        size = @size + 2
+        @equation = lambda { |n| 0.54 - 0.46 * Math.cos(2 * PI * (n + 1) / (size - 1)) }
+        calculate
+        @values = @values.take(@size)
+    end
+
+    # Given a freqency, return the required size of a HammingWindow
+    def find_size(freq)
+        size = 3.3 / freq
+        make_odd(size.ceil)
+    end
+
+    # Return the transition width (in rad/s) based off of the size
+    def transition_width
+        3.3 / @size
+    end
+end

data/lib/strategies/window/hanning_window.rb

@@ -0,0 +1,31 @@
+## 
+# Hanning Window
+# Used to improve digital filters by using a non-retangular frequency domain window 
+class Digiproc::HanningWindow < Digiproc::WindowStrategy
+
+    ##
+    # == Input Args
+    # size (Optional):: Numeric (default: nil), how many datapoings the window should have
+    # norm_trans_freq:: Numeric (default: nil), the desired transition frequency
+    # If you know what size of the the window that you need, you can input size without norm_trans_freq
+    # If you kow the desired transition frequency, the necessary size will be calculated for you based off of 
+    # the window type so it is not necessary to enter the size
+    def initialize(size: nil , norm_trans_freq: nil)
+        super(size: norm_trans_freq.nil? ? size : find_size(norm_trans_freq))
+        size = @size + 2
+        @equation = lambda { |n| 0.5 - 0.5 * Math.cos(2 * PI * (n + 1) / (size - 1)) }
+        calculate
+        @values = @values.take(@size)
+    end
+
+    # Given a freqency, return the required size of a HanningWindow
+    def find_size(freq)
+        size = 3.1 / freq
+        make_odd(size.ceil)
+    end
+
+    # Return the transition width (in rad/s) based off of the size
+    def transition_width
+        3.1 / @size
+    end
+end

data/lib/strategies/window/kaiser_window.rb

@@ -0,0 +1,27 @@
+## 
+# kaiser Window
+# Used to improve digital filters by using a non-retangular frequency domain window 
+# NOT COMPLETE
+# TODO: Finish this Window
+class Digiproc::KaiserWindow < Digiproc::WindowStrategy
+    
+    
+    def initialize(size: , stopband_db: nil, beta: nil)
+        raise ArgumentError.new("Must have a stopband or a beta") if stopband_db.nil? && beta.nil?
+        super(size: size)
+        size = @size
+        @equation = lambda { |n|  }
+        calculate
+        @values = @values.take(@size)
+    end
+
+    def beta_for_db(db)
+        if db <= 21
+            return 0
+        elsif db < 50
+            return 0.5842*((db - 21) ** 0.4) + 0.07886 * (db - 21)
+        else
+            return 0.1102*(db - 8.7)
+        end
+    end
+end

data/lib/strategies/window/rectangular_window.rb

@@ -0,0 +1,22 @@
+##
+# A basic ReactangularWindow used when making a digital filter
+class Digiproc::RectangularWindow < Digiproc::WindowStrategy
+
+    # Initialize with a size: Integer
+    # Number of datapoints
+    def initialize(size: )
+        super(size: size)
+        calculate
+    end
+
+    # Find the size given an input frequency in rad/s
+    def find_size(freq)
+        size = 0.9 / freq
+        make_odd(size.ceil)
+    end
+
+    # Return the transition width based on the @size
+    def transition_width
+        0.9 / @size
+    end
+end

data/lib/strategies/window/window.rb

@@ -0,0 +1,42 @@
+##
+# Parent class to all types of windows
+
+class Digiproc::WindowStrategy
+
+    PI = Math::PI
+
+
+    attr_accessor :size
+    attr_reader :values, :equation, :data
+
+    # Initialize with size: Numeric (numnber of datapoints in window)
+    def initialize(size: )
+        @size = size
+        @equation = lambda { |n| 1 }
+    end
+
+    ##
+    # No input args
+    # calculate the window values 
+    def calculate
+        values = []
+        for n in 0...size
+            values << @equation.call(n)
+        end
+        @values = values
+        @data = values
+    end
+
+    #
+    # Make the number of datapoints in the window odd so that 
+    # it can be used for all types of filters
+    def make_odd(num)
+        num.odd? ? num : num + 1
+    end
+
+    # Return window values as a Digiproc::DigitalSignal
+    def to_signal
+        Digiproc::DigitalSignal.new(data: values)
+    end
+
+end

data/lib/systems/custom_system.rb

@@ -0,0 +1,13 @@
+class Dsp::Systems::CustomSystems < Dsp::Systems::System
+
+    def initialize(eqn: , size: , sample_rate: , data: )
+        raise ArgumentError.new("Must have signal_eqn, sample_rate, and size XOR data") if (signal_eqn.nil? or sample_rate.nil? or size.nil?) and (data.nil?)
+        if data.nil?
+            data = Dsp::AnalogSignal.new(eqn: signal_eqn, sample_rate: sample_rate, size: size).digitize.map(:&conjugate).reverse
+            super(data)
+        else
+            super(data)
+        end
+    end
+
+end

data/lib/systems/hilbert_transform.rb

@@ -0,0 +1,6 @@
+class Dsp::Systems::HilbertTransform  < Dsp::Systems::System
+
+    def initialize()
+
+    end
+end

data/lib/systems/matched_filter.rb

@@ -0,0 +1,21 @@
+class Dsp::Systems::MatchedFilter < Dsp::Systems::System
+
+    def new_from_analog_signal(signal)
+        self.new(signal_data: signal.digitize)
+    end
+
+    def new_from_digital_signal(signal)
+        self.new(signal_data: signal.data)
+    end
+
+    def initialize(signal_eqn: nil, sample_rate: nil, size: nil, signal_data: nil)
+        raise ArgumentError.new("Must have signal_eqn, sample_rate, and size XOR signal_data") if (signal_eqn.nil? or sample_rate.nil? or size.nil?) and (signal_data.nil?)
+        if signal_data.nil?
+            data = Dsp::AnalogSignal.new(eqn: signal_eqn, sample_rate: sample_rate, size: size).digitize.map(:&conjugate).reverse
+            super(data)
+        else
+            data = signal_data.map(&:conjugate).reverse
+            super(data)
+        end
+    end
+end

data/lib/systems/raised_cosine_filter.rb

@@ -0,0 +1,11 @@
+class Dsp::Systems::RaisedCosineFilter < Dsp::Systems::System
+
+
+    def initialize(tb: ,beta: ,sample_rate: ,size: )
+        @eqn = ->(t, tb, beta){ (tb / (2 * beta.to_f) or (-tb / (2 * beta.to_f))) ? Math::PI * Dsp::Functions.sinc(1.0 / (2 * beta)) / (4.0 * tb) : (1 / tb.to_f) * Dsp::Functions.sinc(t / tb.to_f) * Math.cos((Math::PI * beta * t) / tb.to_f) / (1 - ((2*beta*t) / tb.to_f) ** 2)}
+        # super(eqn: @eqn, sample_rate: sample_rate, size: size)
+        data = Dsp::AnalogSignal.new(eqn: @eqn, sample_rate: sample_rate, size: size).digitize
+        super(data)
+    end
+
+end

data/lib/systems/system.rb

@@ -0,0 +1,19 @@
+class Dsp::Systems::System
+
+    attr_accessor :data
+    include Dsp::Convolvable::InstanceMethods, Dsp::Initializable, Dsp::FourierTransformable
+
+    def initialize(data)
+        @data = data
+        initialize_modules(Dsp::FourierTransformable => {time_data: data})
+    end
+
+    def to_ds
+        Dsp::DigitalSignal.new(data: self.data)
+    end
+
+    def to_a
+        self.data
+    end
+
+end

data/lib/systems/systems.rb

@@ -0,0 +1,3 @@
+module Dsp::Systems
+
+end