module Digiproc::Functions

Contains many class methods which perform useful functions

Public Class Methods

bin_str_to_i(bin_str) click to toggle source

Transform a binary number represented in string form into an integer

Input Arg

bin_str

String

Digiproc::Functions.bin_str_to_i("101101") # => 45
# File lib/functions.rb, line 167
def self.bin_str_to_i(bin_str)
    str_arr = bin_str.split("").reverse
    sum = 0
    str_arr.each_with_index do |digit, index|
        sum += digit.to_i * 2 ** index
    end
    sum
end
center_of(max, min) click to toggle source

Return the center of a max and min point

Input args

max

float

min

float

# File lib/functions.rb, line 88
def self.center_of(max, min)
    (max + min) / 2.0
end
cross_correlation(data1, data2) click to toggle source

Performs cross correlation cacluatlino for two arrays of numerics

# File lib/functions.rb, line 9
def self.cross_correlation(data1, data2)
    self.conv(data1, data2.reverse)
end
fact(n) click to toggle source

Given a number, return its factorial

# File lib/functions.rb, line 189
def self.fact(n)
    raise ArgumentError.new("n must be positive") if n < 0
    return 1 if n <= 1
    return @fact_memo[n] if not @fact_memo[n].nil?
    x = n * fact(n - 1)
    @fact_memo[n] = x
    return x
end
linspace(start, stop, number) click to toggle source

Similar to linspace in numpy, return an array of numbers given a min, max, and total number of elements

Input args

start

flaot, the minimum number and index 0 of the output array

stop

float, the maximum number and last index of the output array

number

integer, the number of elements in the output array

# File lib/functions.rb, line 124
def self.linspace(start, stop, number)
    rng = 0...number
    interval = (stop - start).to_f / (number - 1)
    rng.map{ |val| start + interval * val }
end
map_data_to_range(samples, min, max) click to toggle source

Maps an array of numerics to a range defined by a min and max Output an array of samples mapped to within the bounds of the min and max

Input args

samples

Array of Numerics

min

Float, the minimum desired value of the new mapped data

max

Float, the maximum desired value of the new mapped data

# File lib/functions.rb, line 20
def self.map_data_to_range(samples, min, max)
    target_center = (max + min) / 2.0
    target_range = max.to_f - min
    smax, smin = samples.max, samples.min
    sample_center = (smax + smin) / 2.0
    sample_range = smax.to_f - smin
    center_map = target_center - sample_center 
    range_map = target_range / sample_range
    mapping = ->(n){ (n + center_map) * range_map }
    process(samples, mapping)
end
map_to_eqn(starting_min, starting_max, target_min, target_max) click to toggle source

Return a lambda equation which will map a dataset within a starting min and max to a new dataset with a different min and max.

Input Args

starting_min

Float, minimum val of data to be mapped

starting_max

Float, maximum val of data to be mapped

target_min

Float, minimum value of data after mapping

target_max

Float, maximum value of data after mapping

# File lib/functions.rb, line 40
def self.map_to_eqn(starting_min, starting_max, target_min, target_max)
    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)
    range_map = target_range.to_f / starting_range
    ->(n){ (n - starting_center) * range_map + target_center}
end
monotonic?(data) click to toggle source

Return true or false based on if the data is monotoic (ie has a consistant slope direction)

Input Arg

data

Array

# File lib/functions.rb, line 158
def self.monotonic?(data)
    !!monotonic_state(data)
end
monotonic_state(data) click to toggle source

Given an array of numerics, if it is monitonic (ie flat, increaseing, or decreasing), return a symbol representing its state. Return nil of the data is not monotonic

Input args

data

Array

# File lib/functions.rb, line 135
def self.monotonic_state(data)
    last_value = data.first
    state = [:flat, :increasing, :decreasing]
    state_index = 0
    for i in 1...data.length do
        return state[state_index] if state[state_index].nil? 
        slope = data[i] - last_value
        if slope > 0
            state_index = 1 if state[:state_index] == :flat
            return nil if state[:state_index] != :increasing
        elsif slope < 0
            state_index = 2 if state[:state_index] == :flat
            return nil if state[:state_index] != :decreasing
        end
        last_value = data[i]
    end
    return state[:state_index]
end
ones(num) click to toggle source

Return an array of ones of length numn

Input args

num

Integer

# File lib/functions.rb, line 113
def self.ones(num)
    Array.new(num, 1)
end
process(values, eqn) click to toggle source

Maps values using the lambda equation

Input args

values

Collection of values

eqn

lambda

# File lib/functions.rb, line 217
def self.process(values, eqn)
    values.map{ |val| eqn.call(val) }
end
range_of(max, min) click to toggle source

Return the range of a max and min point

Input args

max

float

min

float

# File lib/functions.rb, line 97
def self.range_of(max, min)
    max.to_f - min
end
sinc(x) click to toggle source

Return the value of sinc(x), given an input x (float) sinc = sin(x) / x

# File lib/functions.rb, line 207
def self.sinc(x)
    return 1 if x == 0
    Math.sin(x) / x.to_f
end
str_xor(str1, str2) click to toggle source

XOR two strings representing binary numbers, return the XOR of them in decimal

Digiproc::Functions.str_xor("1011","1001") # => 2
# File lib/functions.rb, line 179
def self.str_xor(str1, str2)
    bin_str_to_i(str1) ^ bin_str_to_i(str2)
end
translate_center_to_origin(*args) click to toggle source

Input args

*args

Can be a variable number of Floats, an array, or a hash with key value pairs of point locations with the value of probability values

If a variable number of floats are an array of floats are given, they will be treated as points on a 1-dimentional line and the return will be an array of numbers which are the sampe points centered around the origin . If a hash is given, the keys will be assumed to be places on the 1D line and the values will be the corresponding probabilities of those points. The same calculation will be carried out, except taking inot account the appropriate weighting. Note: Arguents are X-dimensional ponins as array => optional hash value for probability

# File lib/functions.rb, line 57
def self.translate_center_to_origin(*args)
    args = args[0] if args.length == 1 and args.first.is_a? Enumerable
    points = []
    probabilities = []
    dimensions = 0
    if args.is_a? Hash 
        args.each do |k,v|
            points << k
            probabilities << v
        end
    else
        points = args
        probabilities = points.map{ 1.0 / points.length }
    end

    if probabilities.include?(nil)
        probabilities.map{ 1.0 / points.length }
    end
    dimensions = points.first.length
    weighted_points = points.map.with_index do |point, index|
        point.map{|dimension| -1 * dimension * probabilities[index]}
    end
    a = weighted_points.reduce(Array.new(dimensions,0), :plus)
    points.map{ |vector| vector.plus(a) }
end
zeros(num) click to toggle source

Return an arary of zeros of length num

Input args

num

Integer

# File lib/functions.rb, line 105
def self.zeros(num)
    Array.new(num, 0)
end