silicium 0.0.2 → 0.0.21

data/lib/polynomial_interpolation.rb

@@ -0,0 +1,94 @@
+module Silicium
+  module Algebra
+
+    ##
+    # A class providing polynomial interpolation methods
+    class PolynomialInterpolation
+
+      ##
+      # x : array of data points
+      # y : array returned by function
+      # z : the node to interpolate
+      def self.lagrange_polynomials(x , y , z )
+        check_variables(x, y, z)
+        result = 0.0
+        y.each_index do |j|
+          p1 = 1.0
+          p2 = 1.0
+          x.each_index do |i|
+            if i != j
+              p1 = p1 * (z - x[i])
+              p2 = p2 * (x[j] - x[i])
+            end
+          end
+          result = result + y[j] * p1 / p2
+        end
+        result
+      end
+
+
+      # x : array of data points
+      # y : array returned by function
+      # r : the node to interpolate
+      def self.newton_polynomials(x, y, r)
+        check_variables(x, y, r)
+        a = Array[]
+        y.each do |elem|
+          a << elem
+        end
+        for j in 1..x.length - 1
+          i = x.length - 1
+          while i != j - 1
+            a[i] = (a[i] - a[i - 1]) / (x[i] - x[i - j])
+            i -= 1
+          end
+        end
+
+        n = a.length - 1
+        res = a[n]
+        i = n - 1
+        while i != -1
+          res = res * (r - x[i]) + a[i]
+          i -= 1
+        end
+        res
+      end
+
+      # helper
+      def self.check_variables(x, y, z)
+        check_types(x, y, z)
+        check_arrays(x, y)
+      end
+
+      #helper for helper
+      def self.check_arrays(x, y)
+
+        if x.size < 2  ||  x.size < 2
+          raise ArgumentError, 'Arrays are too small'
+        end
+
+      end
+
+      #helper for helper
+      def self.check_types(x, y, z)
+
+        if x.class != Array || y.class != Array
+          raise ArgumentError, 'Wrong type of variables x or y'
+        end
+
+        if z.class.superclass != Numeric
+          raise ArgumentError, 'Wrong type of variable z'
+        end
+
+        if x[0].class.superclass != Numeric || y[0].class.superclass != Numeric
+          raise ArgumentError, 'Wrong type of arrays'
+        end
+
+      end
+
+
+    end
+
+  end
+end
+

data/lib/regression.rb

@@ -0,0 +1,120 @@
+module Silicium
+  module Regression
+    class LinearRegressionByGradientDescent
+      # Finds parameters theta0, theta1 for equation theta0 + theta1 * x
+      # for linear regression of given plot of one variable
+      # @param plot Actually hash x => y for different points of the plot
+      # @param alpha Speed of learning (should be little enough not to diverge)
+      # @param start_theta0 Starting value of theta0
+      # @param start_theta1 Starting value of theta1
+      # @return [Numeric] theta0, theta1
+      def self.generate_function(plot, alpha = 0.01, start_theta0 = 0.0, start_theta1 = 0.0)
+        theta0 = start_theta0
+        theta1 = start_theta1
+        m = plot.length.to_f
+        epsilon = 0.000001
+        bias_new = 5.0
+        while bias_new.abs() > epsilon
+          old_theta0, old_theta1 = theta0, theta1
+          oth = theta0
+          theta0 = theta0 - alpha / m * d_dt_for_theta0(plot, theta0, theta1)
+          theta1 = theta1 - alpha / m * d_dt_for_theta1(plot, oth, theta1)
+          bias_new = [(theta0 - old_theta0).abs(), (theta1 - old_theta1).abs()].max()
+        end
+        return theta0, theta1
+      end
+
+      private
+
+      def self.d_dt_for_theta0(plot, theta0, theta1)
+        result = 0.0 
+        plot.each { |x, y| result += (theta0 + theta1 * x) - y }
+
+        result
+      end
+
+      def self.d_dt_for_theta1(plot, theta0, theta1)
+         result = 0 
+         plot.each { |x, y| result += ((theta0 + theta1 * x) - y) * x }
+
+         result
+      end
+
+    end 
+    
+    # Finds parameters as array [1..n] for polynom of n-th degree
+    # @param plot Actually hash x => y for different points of the plot
+    # @param n Degree of expected polynom
+    # @param alpha Speed of learning (should be little enough not to diverge)
+    # @param epsilon Accuracy
+    # @return Array[Numeric] coefficients (little index is lower degree parameter)
+    class PolynomialRegressionByGradientDescent
+      def self.generate_function(given_plot, n = 5, alpha = 0.001, epsilon = 0.000001)
+        scaling = n > 3
+        if scaling
+            plot, avg_x, div = feature_scaled_plot(given_plot, n)
+        else
+            (plot = given_plot)
+        end
+        array = Array.new(n + 1, 1)
+        m = plot.length.to_f
+        bias = old_bias = 0.5
+
+        array = calculate([bias, epsilon, array, alpha, plot, old_bias, m])
+
+        return array.map! {|x| x * div + avg_x } if scaling
+        array
+      end
+
+      private
+
+      def self.calculate(params)
+        while params[0].abs() > params[1]
+          old_array = params[2].dup()
+          i = -1
+          params[2].map! { |elem|
+            i += 1
+            elem - params[3] / params[6] * d_dt(params[4], old_array, i)
+          }
+          params[0] = (params[2].zip(old_array).map {|new, old| (new - old).abs()}).max()
+          raise "Divergence" if params[0] > params[5]
+          params[5] = params[0]
+        end
+        params[2]
+      end
+
+      def self.d_dt(plot, old_array, i)
+        sum = 0.0 
+        plot.each { |x, y| sum += (func(old_array, x) - y) * (i + 1) * (x ** i) }
+
+        sum
+      end 
+      
+      def self.func(array, x)
+        sum = 0.0 
+        i = 0 
+        array.each do |elem|
+          sum += elem * (x ** i)
+          i += 1
+        end 
+        sum
+      end 
+      
+      def self.feature_scaled_plot(given_plot, n)
+        max_x = given_plot[0][0]
+        min_x = given_plot[0][0]
+        sum_x = 0.0
+        given_plot.each do |x, _|
+          max_x = x if x > max_x
+          min_x = x if x < min_x
+          sum_x += x
+        end
+        avg_x = sum_x.to_f / given_plot.length
+        range_x = max_x - min_x
+        div = range_x ** n
+        new_plot = given_plot.map {|x, y| [x, (y.to_f - avg_x) / div]}
+        return new_plot, avg_x, div
+      end
+    end 
+  end
+end

data/lib/silicium/adding.rb

@@ -0,0 +1,37 @@
+module Silicium
+  module Sparse
+    # addition for SparseMatrix class
+    class SparseMatrix
+      ##
+      # @param [SparseMatrix] matrix - second matrix for adding
+      # @raise [ArgumentError] If the size of the first matrix doesn't
+      # match the size of the second matrix
+      # @return [SparseMatrix] Matrix as the sum of the other two matrices
+      #
+      # Makes the sum of two matrix
+      def adding(matrix)
+        raise 'wrong argument' if @n != matrix.m
+
+        res = SparseMatrix.new(@n, @m)
+        (0..@n).each { |i|
+          help_row1 = get_row(i)
+          help_row2 = matrix.get_row(i)
+          res_row = Array.new(@m, 0)
+          j = 0
+          help_row1.each do |elem|
+            res_row[j] = elem + help_row2[j]
+            j = j + 1
+          end
+          k = 0
+          res_row.each do |elem|
+            if (elem != 0)
+              res.add(i, k, elem)
+            end
+            k = k+1
+          end
+        }
+        res
+      end
+    end
+  end
+end

data/lib/silicium/conversions.rb

@@ -0,0 +1,23 @@
+module Silicium
+  module Sparse
+    # here goes the Sparse class
+    class SparseMatrix
+      # #
+      # A static method for initializing sparse matrix from a regular one
+      # @param [Array] mat - Source matrix for conversion
+      def self.sparse(mat)
+        new = SparseMatrix.new(mat.count, mat[0].count)
+        i = 0
+        mat.each do |row|
+          j = 0
+          row.each do |elem|
+            new.add(i, j, elem) unless elem.zero?
+            j += 1
+          end
+          i += 1
+        end
+        new
+      end
+    end
+  end
+end

data/lib/silicium/multi.rb

@@ -0,0 +1,82 @@
+module Silicium
+  module Sparse
+    # here goes tha addition to SparseMatrix class
+    class SparseMatrix
+      ##
+      # @param [Integer] pos - Position of a row to return
+      # @raise [ArgumentError] if position was less or bigger than count of cols
+      # @return [Array] The array contains elements of row
+      #
+      # Returns a row of sparse matrix by its position
+      def get_row(pos)
+        get_dimension({dimension: 0, position: 1}, pos)
+      end
+
+      ##
+      # @param [Integer] pos - Position of a column to return
+      # @raise [ArgumentError] if position was less or bigger than count of rows
+      # @return [Array] The array that contains elements of column
+      #
+      # Returns a column of sparse matrix by its position
+      def get_col(pos)
+        get_dimension({dimension: 1, position: 0}, pos)
+      end
+
+      ##
+      # @return [Array] The array that contains rows of matrix
+      # Returns sparse matrix in its regular view
+      def regular_view
+        Array.new(@n) { |i| get_row(i) }
+      end
+
+      ##
+      # @param [SparseMatrix::Object] matrix - A matrix to multiply to
+      # @raise [ArgumentError] if count of columns of right matrix
+      # doesn't match count of rows of left matrix
+      #
+      # Returns a matrix in its regular view but multiplied by other matrix
+      def multiply(matrix)
+        raise 'wrong argument' if @n != matrix.m
+
+        rows = regular_view
+        result = Array.new(@n) { Array.new }
+        (0...@n).each { |i|
+          (0...matrix.m).each { |j|
+            result[i] << matrix
+                             .get_col(j)
+                             .zip(rows[i])
+                             .inject(0) { |acc, current| acc + current[0] * current[1] }
+          }
+        }
+        result
+      end
+
+      ##
+      # @param [Integer] num - A number to multiply to
+      #
+      # Multiplies matrix by a number
+      def mult_by_num(num)
+        return SparseMatrix.new(@n, @m) if num.zero?
+
+        res = copy
+        res.triplets.each do |triplet|
+          triplet[2] *= num
+        end
+        res
+      end
+
+      private
+
+      def get_dimension(selector, pos)
+        raise 'wrong argument' if pos.negative? || pos > @m
+
+        result = Array.new(@m, 0)
+        @triplets
+            .select { |triplet| triplet[selector[:dimension]] == pos }
+            .each { |triplet| result[triplet[selector[:position]]] = triplet[2] }
+        result
+      end
+
+    end
+  end
+end

data/lib/silicium/sparse.rb

@@ -0,0 +1,76 @@
+module Silicium
+  require_relative 'sugar'
+  require_relative 'conversions'
+  require_relative 'trans'
+  require_relative 'adding'
+  require_relative 'multi'
+
+  # here goes the sparse module
+  module Sparse
+    # here goes the Sparse class
+    class SparseMatrix
+      attr_reader :triplets
+      attr_reader :n
+      attr_reader :m
+      ##
+      # @param [Integer] rows - Count of rows
+      # @param [Integer] cols - Count of columns
+      #
+      # Initialize matrix with count of rows and columns
+      def initialize(rows, cols)
+        @n = rows
+        @m = cols
+        @triplets = []
+      end
+
+      ##
+      # @return [SparseMatrix::Object] - Returns a copy of a SparseMatrix object
+      #
+      # Creates a copy of matrix object
+      def copy
+        new = SparseMatrix.new(@n, @m)
+        triplets.each do |triplet|
+          new.add(triplet[0], triplet[1], triplet[2])
+        end
+        new
+      end
+
+      ##
+      # @param [Integer] i_pos - The i position of an element
+      # @param [Integer] j_pos - The j position of an element
+      # @param [Integer] elem - The value of an element to be added
+      #
+      # Adds an element to matrix by its position and value
+      def add(i_pos, j_pos, elem)
+        if i_pos > @n || j_pos > @m || i_pos.negative? || j_pos.negative?
+          raise 'out of range'
+        end
+
+        f = false
+        @triplets.each do |item|
+          if item[0] == i_pos && item[1] == j_pos
+            item = [i_pos, j_pos, elem]
+            f =  true
+            break
+          end
+        end
+        @triplets.push([i_pos, j_pos, elem]) unless f
+      end
+
+      ##
+      # @param [Integer] i_pos - The i position of an element
+      # @param [Integer] j_pos - The j position of an element
+      # @return [Integer] The element on i,j position
+      #
+      # Returns an element by its position
+      def get(i_pos, j_pos)
+        triplets.each do |triplet|
+          if triplet[0] == i_pos && triplet[1] == j_pos
+            return triplet[2]
+          end
+        end
+        0
+      end
+    end
+  end
+end

data/lib/silicium/sugar.rb

@@ -0,0 +1,37 @@
+module Silicium
+  module Sparse
+    # addition for SparseMatrix class
+    class SparseMatrix
+      ##
+      # @param [SparseMatrix] other - second matrix for adding
+      # @raise [ArgumentError] If the size of the first matrix doesn't match the size of the second matrix
+      # @return [SparseMatrix] Matrix as the sum of the other two matrices
+      #
+      # Makes the sum of two matrix
+      def +(other)
+        adding(other)
+      end
+
+      ##
+      # @param [SparseMatrix] other - second matrix for adding
+      # @raise [ArgumentError] If the size of the first matrix doesn't match the size of the second matrix
+      # @return [SparseMatrix] Matrix as the sum of the other two matrices
+      #
+      # Makes the sum of two matrix
+      def -(other)
+        adding(other.mult_by_num(-1))
+      end
+
+      ##
+      # @param [SparseMatrix::Object] other - A matrix to multiply to
+      # @raise [ArgumentError] if count of columns of right matrix
+      # doesn't match count of rows of left matrix
+      #
+      # Returns a matrix in its regular view but multiplied by other matrix
+      def *(other)
+        multiply(other)
+      end
+
+    end
+  end
+end