digiproc 0.1.0

data/lib/probability/binomial_distribution.rb

@@ -0,0 +1,84 @@
+##
+# Allows you to solve problems whose probabilities are dictated by a binomial distribution
+# Does not simulate a problem, but calculates probabilities based off of the binomial distribution equation
+# See examples/binomial_distribution/dice.rb
+
+class Digiproc::Probability::TheoreticalBinomialDistribution
+
+    attr_accessor :n, :k, :p
+
+    ##
+    # == Initialize with n, k, and p
+    # n:: [Integer] Number of trials
+    # k:: [Integer] (optional at initialization) Number of successes
+    # p:: [Numeric] Probability of success
+    def initialize(n: ,k: nil , p: )
+        @n = n.to_f
+        @k = k.to_f
+        @p = p.to_f
+    end
+
+    ##
+    # Returns the Expected Value of a binomial distributed random variable (n * p)
+    ## bd = Digiproc::Probability::TheoreticalBinomialDistribution.new(n:10, p: 0.5)
+    ## bd.expect # => 5
+    # ie in above example, expect 5 successes (heads) in 10 flips of a coin
+    def expect
+        self.n * self.p
+    end
+
+    ##
+    # Return the Variance of the binomial distributed random variable (n * p * (1 - p))
+    # Using above example:
+    ## bd.var # => 2.5
+    def var
+        self.n * self.p * ( 1 - self.p )
+    end
+
+    ##
+    # Will run `probability` method using `self.k` 
+    ## bd.k = 5
+    ## bd.prob # => 0.24609375
+    def prob
+        self.probability(self.k)
+    end 
+
+    ##
+    # Will run `coefficient` method using `self.k`
+    ## bd.coeff # => 252.0
+    def coeff
+        coefficient(self.k)
+    end
+
+    ##
+    # Calculates the probability of `k` number of `wins`
+    # `k` can be an array or a range of numbers, a variable number of args, or a single integer (see example referenced above)
+    # If k is more than one value, the probabilities will be summed together
+    # For example:
+    ## bd.probability(5) # => 0.24609375
+    ## bd.probability(0..5) # => 0.623046875
+    ## bd.probability(1,2,5,6) # => 0.5048828125
+    ## bd.probability([0,1,2,3,4,5]) # => 0.623046875
+    def probability(*k)
+        sum = 0
+        karr = k.map{ |val| val.respond_to?(:to_a) ? val.to_a : val}
+        karr.flatten!
+        karr.each do |k_val| 
+            sum += self.coefficient(k_val) * ((self.p) ** (k_val)) * (1 - self.p) ** (n - k_val)
+        end
+        sum
+    end
+
+    ##
+    # Returns the binomial equation coefficient for a given number of wins, ie returns n! / (k! * (n - k)!)
+    # Can take an argument of `k`, which defaults to `self.k`
+    ## bd.coefficient(4) # => 210.0
+    def coefficient(k = self.k)
+        n_fact = Digiproc::Functions.fact(self.n)
+        k_fact = Digiproc::Functions.fact(k)
+        n_fact / (k_fact.to_f * (Digiproc::Functions.fact(self.n - k)))
+    end
+
+    
+end
+

data/lib/probability/bit_generator.rb

@@ -0,0 +1,94 @@
+##
+# Create random bit for testing purposes
+#
+class Digiproc::Probability::RandomBitGenerator
+
+    ##
+    # Returns a string representing a bitstream
+    # == Arguments
+    # size:: [Integer] number of desired bits
+    # p_0:: [Float] (between 0 and 1) probability of a bit 0 occurring (default value: 0.5)
+    # p_1:: [Float] (between 0 and 1) probability of a bit 1 occurring (default value: 0.5)
+    # random_generator:: Any random generator that follows the prototype of ruby's `Random` class. Defaults to `Random.new`
+    #
+    ## bitgen = Digiproc::Probability::RandomBitGenerator
+    ## bitgen.bitstream(size: 10) # => "1000010010"
+    def self.bitstream(size: , p_0: 0.5, p_1: 0.5, random_generator: Random.new)
+        stream = ''
+        size.times do 
+            stream += get_bit(p_0: p_0, p_1: p_1, random_generator: random_generator).to_s
+        end
+        stream
+    end
+
+    ##
+    # Returns an Integer
+    # == Arguments
+    # p_0:: [Float] (between 0 and 1) probability of a bit 0 occurring (default value: 0.5)
+    # p_1:: [Float] (between 0 and 1) probability of a bit 1 occurring (default value: 0.5)
+    # random_generator:: Any random generator that follows the prototype of ruby's `Random` class. Defaults to `Random.new`
+    #
+    ## bitgen.bitstream # => 1
+    def self.get_bit(p_0: 0.5, p_1: 0.5, random_generator: Random.new)
+        raise ArgumentError.new("Probabilities must add up to 1") if p_0 + p_1 != 1
+        rnum = 1 - random_generator.rand
+        return 0 if rnum <= p_0 
+        return 1
+    end
+
+    ##
+    # Constructor for bitstream
+    # == Arguments
+    # p_0:: [Float] between 0 and 1: probability of a 0 bit (defaults to 0.5)
+    # p_1:: [Float] between 0 and 1: probability of a 1 bit (defaults to 0.5)
+    ## bitstream = bitgen.new_bitstream
+    def self.new_bitstream(p_0: 0.5 , p_1: 0.5)
+        self.new(bits_per_symbol: 1, p_0: p_0, p_1: p_1)
+    end
+
+    ##
+    # Constructor for symbol_stream
+    # == Arguments
+    # bits_per_symbol:: [Integer] set the number of bits for each symbol
+    # p_0:: [Float] between 0 and 1: probability of a 0 bit (defaults to 0.5)
+    # p_1:: [Float] between 0 and 1: probability of a 1 bit (defaults to 0.5)
+    ## bitstream = bitgen.new_bitstream
+    def self.new_symbol_stream(bits_per_symbol: , p_0: 0.5, p_1: 0.5)
+        self.new(bits_per_symbol: bits_per_symbol, p_0: p_0, p_1: p_1) 
+    end
+
+    attr_accessor :bits_per_symbol, :p_0, :p_1, :random_generator
+
+    ##
+    # == Arguments
+    # # bits_per_symbol:: [Integer] set the number of bits for each symbol
+    # p_0:: [Float] between 0 and 1: probability of a 0 bit (defaults to 0.5)
+    # p_1:: [Float] between 0 and 1: probability of a 1 bit (defaults to 0.5)
+    #
+    ## bitstream = bitgen.new(bits_per_symbol: 1) => same as bitgen.new_bitstream
+    def initialize(bits_per_symbol: , p_0: 0.5, p_1: 0.5 )
+        raise ArgumentError.new("Probabilities of bits must add up to 1") if p_0 + p_1 != 1
+        @bits_per_symbol, @p_0, @p_1, @random_generator = bits_per_symbol, p_0, p_1, Random.new
+    end
+
+    ##
+    # == Arguments
+    # size:: [Integer] number of symbols to be generated (or bits if self.bits_per_symbol is 1)
+    ## bistream = Digiproc::Probability::RandomBitGenerator.new_bitstream
+    ## symstream = Digiproc::Probability::RandomBitGenerator.new_symbol_stream(bits_per_symbol: 8)
+    ## bitstream.generate(10) # => "0001110010"
+    ## symstream.generate(4) # => ["10100111", "00111100", "00111010", "10000100"]
+    def generate(size)
+        if self.bits_per_symbol == 1
+            return self.class.bitstream(size: size, p_0: @p_0, p_1: @p_1, random_generator: @random_generator)
+        else
+            signal = []
+            size.times do 
+                signal << self.class.bitstream(size: @bits_per_symbol, p_0: @p_0, p_1: @p_1, random_generator: @random_generator)
+            end
+            return signal
+        end
+    end
+    
+    
+end

data/lib/probability/gaussian_distribution.rb

@@ -0,0 +1,29 @@
+##
+# Class to create a sample of Gaussian Distributed values
+class Digiproc::Probability::GaussianDistribution
+
+    attr_accessor :mean, :stddev, :generator, :data
+    attr_reader :size
+
+    include Digiproc::Convolvable::InstanceMethods, Digiproc::Initializable, Digiproc::FourierTransformable
+
+    ##
+    # == Initialize arguments
+    # mean:: [Float] mean of the population
+    # stddev:: [Float] standard deviation of the population
+    # size:: [Integer] number of datapoints
+    # generator:: Strategy for making Gaussian values. Defaults to Digiproc::Strategies::GaussianGeneratorBoxMullerStrategy.new
+    def initialize(mean: , stddev: , size: ,generator: Digiproc::Strategies::GaussianGeneratorBoxMullerStrategy.new)
+        @mean, @stddev, @generator, @size = mean, stddev, generator, size
+        generator.mean = mean
+        generator.stddev = stddev
+        data = []
+        size.times do 
+            data << generator.rand
+        end
+        @data = data
+        initialize_modules(Digiproc::FourierTransformable => {time_data: data})
+    end
+
+
+end

data/lib/probability/probability.rb

@@ -0,0 +1,234 @@
+##
+# Module supplying probability functions 
+module Digiproc::Probability
+
+    ##
+    # Interchangable strategy
+    #Strategy requirements: 
+        #can be initialized with no arguments (gives mean = 0 and stddev = 1), or with a mean and stddev
+        #instance method: #rand returns normal distribution with mean = 0, stddev = 1
+    @gaussian_generator = Digiproc::Strategies::GaussianGeneratorBoxMullerStrategy.new
+
+
+    ##
+    # Returns a new instance of a normal number random generator, which contains an instance method #rand which will return a 
+    # single random number from the normal distribution
+    # == Arguments
+    # mean:: [Float] mean of the distribution defaults to 0
+    # stddev:: [Float] standard deviation of the distribution defaults to 1
+    ## gen = Digiproc::Probability.normal_random_generator(100, 15) # => return rand gen of IQ scores
+    ## scores = []
+    ## 10.times do 
+    ##    scores << gen.rand
+    ## end
+    ## puts scores # => [98.22222989456891, 102.78474153867536, 130.32345913801984, 90.68720464516447, 94.45065665514275, 100.46571157090098, 105.40955807686252, 85.9616084359681, 103.05219341559669, 96.62475435904693]
+    def self.normal_random_generator(mean = 0, stddev = 1)
+       @gaussian_generator.class.new(mean, stddev)
+    end
+
+    ##
+    # == Arguments
+    # size:: [Integer] number of returns expected, defaults to 1
+    # If `size` is 1, returns a single number from the distribution
+    # For `size` > 1, return an array of numbers from the distribution
+    ## Digiproc::Probability.nrand(5) # => [-0.4870987490684469, 0.48974360810927925, -0.3722088483576355, -0.2829898781247938, 0.12540113064787742]
+    ## Digiproc::Probability.nrand # => 0.7978655621417761
+    def self.nrand(size = 1)
+        return @gaussian_generator.rand if size == 1
+        rand_nums = []
+        size.times do 
+            rand_nums << @gaussian_generator.rand
+        end
+        return rand_nums
+    end
+
+    ##
+    # Returns [Float] the mean of the inputted data
+    # == Arguments
+    # data:: [Array] data to be evaluated
+    ## dat = [4,12,19,4,8,9]
+    ## Digiproc::Probability.mean(dat) # => 9.333333333333334
+    def self.mean(data)
+        data.sum / data.length.to_f
+    end
+
+    ##
+    # Returns [Float] the variance of the inputted data
+    # == Arguments
+    # data:: [Array] data to be evaluated
+    # variance = sum_over_datavals( (dataval - mean) ^ 2 ) / (number_of_datavals - 1)
+    ## dat = [4,12,19,4,8,9]
+    ## Digiproc::Probability.variance(dat) # => 31.866666666666664
+    def self.variance(data)
+        mu = mean(data)
+        summation = data.map{ |val| (val - mu) ** 2 }.sum
+        summation.to_f / (data.length - 1)
+    end
+
+    ## 
+    # Returns [Float] the variance of inputted data for a stationary process
+    # (stationary proces = mean, variance, autocorrelation do not change with time)
+    # Will run faster over large datasets because each val in data is not undergoing a subtraction with mu
+    # If the process is not stationary, an incorrect result with be given
+    # == Arguments
+    # data:: [Array] data to be evaluated
+    # stat_var = sum_over_datavals( val^2 ) / number_ov_vals
+    ## dat = [4,12,19,4,8,9]
+    ## Digiproc::Probability.stationary_variance(dat) # => 26.555555555555543
+    def self.stationary_variance(data)
+        mu = mean(data)
+        summation = data.map{ |val| val ** 2 }.sum
+        (summation.to_f / data.length) - (mu ** 2)
+    end
+
+    ##
+    # Returns [Float] the standard deviation of the inputted data
+    # == Arguments 
+    # data:: [Array] data to be evaluated
+    # stddev = sqrt(variance)
+    ## dat = [4,12,19,4,8,9]
+    ## Digiproc::Probability.stddev # => 5.645056834671079
+    def self.stddev(data)
+        variance(data) ** (0.5)
+    end
+ 
+
+    ##
+    # Returns [Float] the covariance (if process is stationary) of two datasets
+    # == Arguments
+    # data1:: [Array] first dataset
+    # data2:: [Array] second datatset
+    ## dat = [4,12,19,4,8,9]
+    ## dat2 = [19, 20, 35, 15, 13, 17]
+    ## Digiproc::Probability.stationary_covariance(dat, dat2) # => 31.22222222222223
+
+    def self.stationary_covariance(data1, data2)
+        raise ArgumentError.new("Datasets must be of equal length") if data1.length != data2.length
+        xcs = data1.dot data2
+        mu1 = mean(data1)
+        mu2 = mean(data2)
+        (xcs / (data1.length.to_f)) - (mu1 * mu2) 
+    end
+
+    ##
+    # Returns [Float] covariance of two datasets
+    # == Arguments
+    # data1:: [Array] first dataset
+    # data2:: [Array] second datatset
+    ## dat = [4,12,19,4,8,9]
+    ## dat2 = [19, 20, 35, 15, 13, 17]
+    ## Digiproc::Probability.ovariance(dat, dat2) # => 37.46666666666667
+    def self.covariance(data1, data2)
+        raise ArgumentError.new("Datasets must be of equal length") if data1.length != data2.length
+        mu1 = mean(data1)
+        mu2 = mean(data2)
+        summation = 0
+        for i in 0...data1.length do
+            summation += ((data1[i] - mu1) * (data2[i] - mu2))
+        end
+        summation.to_f / (data1.length - 1)
+    end
+
+    ##
+    # Calculates Pearson's correlation coefficient of two datasets
+    # == Arguments
+    # data1:: [Array] first dataset
+    # data2:: [Array] second dataset
+    ## dat = [4,12,19,4,8,9]
+    ## dat2 = [19, 20, 35, 15, 13, 17]
+    ## Digiproc::Probability.correlation_coefficient(dat, dat2) # => 0.84450000297225
+    ## cdat = [1,2,3,4,5]
+    ## ddat = cdat.map{ |v| v * -29 }
+    ## Digiproc::Probability.correlation_coefficient(cdat, ddat) # => -1.0
+    def self.correlation_coefficient(data1, data2)
+        covar = covariance(data1, data2)
+        var1 = variance(data1)
+        var2 = variance(data2)
+        return covar.to_f / ((var1 ** 0.5) * (var2 ** 0.5))
+    end
+
+    ##
+    # Alias for #variance
+    def self.var(d)
+        variance(d)
+    end
+
+    ##
+    # Alias for #covariance
+    def self.cov(d1, d2)
+        covariance(d1,d2)
+    end
+
+    ##
+    # Alias for #correlation_coefficient
+    def self.corr_coeff(d1, d2)
+        correlation_coefficient(d1, d2)
+    end
+
+    ##
+    # Returns the error function output [Float] of the input ie:
+    # For an input x and a normal distribution with mean 0 and variance 0.5, it is the probability a random variable will be between -x and x
+    # Mirrors Math.erf(x)
+    # == Arguments
+    # x:: [Float] 
+    ## Digiproc::Prbobability.erf(0.3) # => 0.32862675945912734
+    def self.erf(x)
+        Math.erf(x)
+    end
+
+    ##
+    # Returns the erfc [Float] per Math.erfc
+    # For an input x and a normal distribution with mean 0 and variance 0.5, it is the probability a random variable will not be between -x and x
+    # == Arguments
+    # x:: [Float] 
+    ## Digiproc::Prbobability.erfc(0.3) # => 0.6713732405408727
+    def self.erfc(x)
+        Math.erfc(x)
+    end
+
+    ##
+    # Returns [Float] probability that a random variable from a normal distribution of a certain mean and standard deviation will be less than a value x
+    # == Arguments
+    # x:: [Float] the value which the probability will be evaluated that a random variable will be below
+    # mean:: [Float] the mean of the normal distribution (defaults to 0)
+    # stddev:: [Float] the standard deviation of the normal distribution (defaults to 1)
+    ## Digiproc::Probability.normal_cdf(0.5) # =>  0.691462461274013
+    ## Digiproc::Probability.normal_cdf(140, 100, 15) # => 0.9961696194324102 
+    def self.normal_cdf(x, mean = 0, stddev = 1)
+        1 - normal_q(x, mean, stddev)
+    end
+
+    ##
+    # Returns [Float] the probability that a random variable from a normal distribution of a certain mean and standard deviation will be greater than a value x
+    # == Arguments
+    # x:: [Float] the value which the probability will be evaluated that a random variable will be below
+    # mean:: [Float] the mean of the normal distribution (defaults to 0)
+    # stddev:: [Float] the standard deviation of the normal distribution (defaults to 1)
+    ## Digiproc::Probability.normal_q(0.5) # =>  0.30853753872598694
+    ## Digiproc::Probability.normal_q(140, 100, 15) # => 0.0038303805675897395
+    def self.normal_q(x, mean = 0, stddev = 1)
+        xformed_x = (x - mean) / stddev.to_f
+        0.5 * erfc(xformed_x / (2 ** 0.5))
+    end
+
+    ##
+    # Returns [Hash] the discrete probability distribution function of an inputted array of values
+    # == Arguments
+    # data:: [Array] discrete values in a dataset
+    ## dat = [3,3,4,5,4,5,6,5,6,5,7,6,5,4]
+    ## Digiproc::Probability.pdf(dat) # => {3=>2, 4=>3, 5=>5, 6=>3, 7=>1}
+    def self.pdf(data)
+        pdf = {}
+        data.each do |datapoint|
+            pt = datapoint.round(2)
+            if pdf[pt].nil?
+                pdf[pt] = 1
+            else
+                pdf[pt] += 1
+            end
+        end
+        pdf
+    end
+
+    
+end

data/lib/probability/theoretical_gaussian_distribution.rb

@@ -0,0 +1,59 @@
+##
+# Class to calculate probabilities based off of a gaussian distributed random variable. 
+class Digiproc::Probability::TheoreticalGaussianDistribution
+
+    attr_reader :mean, :stddev, :variance
+    
+    def initialize(mean: , stddev: , generator_strategy: Digiproc::Strategies::GaussianGeneratorBoxMullerStrategy)
+        @mean, @stddev = mean, stddev
+        @variance = stddev ** 2
+        @generator_strategy = generator_strategy.new(mean, stddev)
+    end
+
+    ## 
+    # Return the cdf [Float] of an input x [Float]
+    ## gd = Digiproc::Probability::TheoreticalGaussianDistribution.new(mean: 0, stddev: 1)
+    ## gd.cdf(0.3) # => 0.6179114221889526
+    def cdf(x)
+        1 - q(x)
+    end
+
+    ##
+    # Return the q value [Float] of an input x [Float]
+    ## gd = Digiproc::Probability::TheoreticalGaussianDistribution.new(mean: 0, stddev: 1)
+    ## gd.q(0.3) # => 0.3820885778110474
+    def q(x)
+        xform_x = xform_x_to_standard(x)
+        0.5 * Math.erfc(xform_x  / (2 ** 0.5))
+    end
+
+    ##
+    # Return the probability [Float] of the random variable being between an upper [Float] and lower [Float] value 
+    ## gd = Digiproc::Probability::TheoreticalGaussianDistribution.new(mean: 0, stddev: 1)
+    ## gd.p_between(-1, 1) # => 0.6826894921370859
+    def p_between(lower, upper)
+        cdf(upper) - cdf(lower)
+    end
+
+    ##
+    # Return the probability [Float] of the random variable being outside an upper [Float] and lower [Float] value 
+    ## gd = Digiproc::Probability::TheoreticalGaussianDistribution.new(mean: 0, stddev: 1)
+    ## gd.p_outside(-1, 1) # => 0.31731050786291415
+    def p_outside(lower, upper)
+        cdf(lower) + q(upper)
+    end
+
+    ##
+    # Outputs a single random number from the gaussian distribution
+    ## gd.rand # => 1.4173209026395848
+    def rand
+        @generator_strategy.rand
+    end
+
+    
+    private
+
+    def xform_x_to_standard(x)
+        (x - self.mean) / self.stddev.to_f
+    end
+end

data/lib/quick_plot.rb

@@ -0,0 +1,96 @@
+##
+# Class for quickly plotting data
+class Digiproc::QuickPlot
+
+    extend Digiproc::Plottable::ClassMethods
+
+
+
+    ##
+    # Quickly plot data. Either data OR x AND y are required. If just data is inputted, x values will be the index of the value in the data array
+    # == Input Args
+    # x:: Array[Numeric] (required if data is not included)
+    # y:: Array[Numeric] (required if data is not included)
+    # data:: Array[Numeric] (required if x and y are not included)
+    # title (Optional):: String
+    # x_label (Optional):: String
+    # y_label (Optional):: String
+    # labels (Optional):: Array[String] x value labels
+    # data_name (Optional):: name of data for legend
+    # label_map (Optional):: Lambda - mapping data index to an x label for that index
+    # dark (Optional):: Boolean - whether or not to use dark mode (defaults to false)
+    # path (Optional):: Path to save plot picture to. Defauilts to "./plots"
+    def self.plot(x: nil,y: nil, data: nil, title: nil, x_label: nil, y_label: nil, labels: nil, data_name: "data", label_map: nil, dark: false, path: "./plots/")
+        xyname, dataname = nil, nil
+        if not x.nil?
+            if evenly_spaced?(x)
+                label_map = Digiproc::Functions.map_to_eqn(0, x.length, x.min, x.max)
+                data = y
+                y, x = nil, nil
+            end
+        end
+        data.nil? ? (xyname = data_name) : (dataname = data_name)
+        qplot(x: x, y: y, data: data, data_name: dataname, xyname: xyname, label_map: label_map, filename: to_filename(title), path: path) do |g|
+            g.title = title if not title.nil?
+            g.x_axis_label = x_label if not x_label.nil?
+            g.y_axis_label = y_label if not y_label.nil?
+            g.labels = labels if not labels.nil?
+            g.theme = Digiproc::Plottable::Styles::MIDNIGHT if dark
+        end
+    end
+
+    def self.step()
+    end
+
+    ##
+    # Plots a pi plot
+    def self.pi_plot(label ="0.5")
+        z = Digiproc::Functions.zeros(26)
+        o = Digiproc::Functions.ones(50)
+        y = z + o + z
+        x = Digiproc::Functions.linspace(-2, 2, 102)
+        plot(x: x, y: y, title: "PI fn" ,labels: {-1 => "-#{label}", 0 => "0", 1 => label}) 
+    end
+    
+
+    ##
+    # Plots a lambda plot
+    def self.lambda_plot(label = "1")
+        eqn = ->(t){ t.abs <= 1 ? (1 - t.abs) : 0}
+        x = Digiproc::Functions.linspace(-2, 2, 102)
+        plot(data: x.map{|t| eqn.call(t)},title: "Lambda fn" ,labels: {26 => "-#{label}", 51 => 0 ,76 => label}) 
+    end
+
+    ##
+    # Plots an input equation (lambda)
+    # == Input args
+    # eqn:: lambda, equation to pe plotted
+    # sample_times:: Array[Numeric] input values to lambda equation
+    # title (Optional):: String
+    # x_label (Optional):: String
+    # y_label (Optional):: String
+    def self.plot_eq(eqn: , sample_times: ,title: nil, x_label: nil, y_label: nil)
+        data = process(eqn, sample_times)
+        plot(data: data, title: title, x_label: x_label, y_label: y_label)
+    end
+
+    def process(eqn, locations)
+        locations.map{ |n| eqn.call(n) }
+    end
+
+    private
+
+    def self.evenly_spaced?(data)
+        interval = data[1] - data[0] 
+        for i in 2...data.length do
+            new_int = data[i] - data[i-1]
+            return false if new_int.round(10) != interval.round(10)
+        end
+        true
+    end
+
+    def self.to_filename(title)
+        title.nil? ? "Quickplot Graph" : title.downcase.gsub(" ", "_")
+    end
+
+end