silicium 0.0.20 → 0.0.21

data/lib/plotter.rb

@@ -1,96 +1,256 @@
-require 'silicium'
-require 'chunky_png'
-
-module Silicium
-  module Plotter
-    ##
-    # Factory method to return a color value, based on the arguments given.
-    #
-    # @overload Color(r, g, b, a)
-    #   @param (see ChunkyPNG::Color.rgba)
-    #   @return [Integer] The rgba color value.
-    #
-    # @overload Color(r, g, b)
-    #   @param (see ChunkyPNG::Color.rgb)
-    #   @return [Integer] The rgb color value.
-    #
-    # @overload Color(hex_value, opacity = nil)
-    #   @param (see ChunkyPNG::Color.from_hex)
-    #   @return [Integer] The hex color value, with the opacity applied if one
-    #     was given.
-    #
-    # @overload Color(color_name, opacity = nil)
-    #   @param (see ChunkyPNG::Color.html_color)
-    #   @return [Integer] The hex color value, with the opacity applied if one
-    #     was given.
-    #
-    # @overload Color(color_value, opacity = nil)
-    #   @param [Integer, :to_i] The color value.
-    #   @return [Integer] The color value, with the opacity applied if one was
-    #     given.
-    #
-    # @return [Integer] The determined color value as RGBA integer.
-    # @raise [ArgumentError] if the arguments weren't understood as a color.
-    def color(*args)
-      case args.length
-      when 1; ChunkyPNG::Color.parse(args.first)
-      when 2; (ChunkyPNG::Color.parse(args.first) & 0xffffff00) | args[1].to_i
-      when 3; ChunkyPNG::Color.rgb(*args)
-      when 4; ChunkyPNG::Color.rgba(*args)
-      else raise ArgumentError, "Don't know how to create a color from #{args.inspect}!"
-      end
-    end
-    ##
-    # A class representing canvas for plotting bar charts and function graphs
-    class Image
-      ##
-      # Creates a new plot with chosen +width+ and +height+ parameters
-      # with background colored +bg_color+
-      def initialize(width, height, bg_color = ChunkyPNG::Color::TRANSPARENT)
-        @image = ChunkyPNG::Image.new(width, height, bg_color)
-      end
-
-      def rectangle(x, y, width, height, color)
-        x_end = x + width - 1
-        y_end = y + height - 1
-        (x..x_end).each do |i|
-          (y..y_end).each do |j|
-            @image[i, j] = color
-          end
-        end
-      end
-
-      ##
-      # Draws a bar chart in the plot using provided +bars+,
-      # each of them has width of +bar_width+ and colored +bars_color+
-      def bar_chart(bars, bar_width, bars_color = ChunkyPNG::Color('red @ 1.0'), axis_color = ChunkyPNG::Color::BLACK)
-        if bars.count * bar_width > @image.width
-          raise ArgumentError, 'Not enough big size of image to plot these number of bars'
-        end
-
-        padding = 5
-        # Values of x and y on borders of plot
-        minx = [bars.collect { |k, _| k }.min, 0].min
-        maxx = [bars.collect { |k, _| k }.max, 0].max
-        miny = [bars.collect { |_, v| v }.min, 0].min
-        maxy = [bars.collect { |_, v| v }.max, 0].max
-        dpux = Float((@image.width - 2 * padding)) / (maxx - minx + bar_width) # Dots per unit for X
-        dpuy = Float((@image.height - 2 * padding)) / (maxy - miny) # Dots per unit for Y
-        rectangle(padding, @image.height - padding - (miny.abs * dpuy).ceil, @image.width - 2 * padding, 1, axis_color) # Axis OX
-        rectangle(padding + (minx.abs * dpux).ceil, padding, 1, @image.height - 2 * padding, axis_color) # Axis OY
-
-        bars.each do |x, y| # Cycle drawing bars
-          rectangle(padding + ((x + minx.abs) * dpux).floor,
-                    @image.height - padding - (([y, 0].max + miny.abs) * dpuy).ceil + (y.negative? ? 1 : 0),
-                    bar_width, (y.abs * dpuy).ceil, bars_color)
-        end
-      end
-
-      ##
-      # Exports plotted image to file +filename+
-      def export(filename)
-        @image.save(filename, :interlace => true)
-      end
-    end
-  end
-end
+require 'silicium'
+require 'chunky_png'
+require 'ruby2d'
+
+
+module Silicium
+  ##
+  # Plotter module
+  # Module contains classes, that are different kinds of plain plotters
+  #
+  module Plotter
+    include Silicium::Geometry
+    # The Color module defines methods for handling colors. Within the Plotter
+    # library, the concepts of pixels and colors are both used, and they are
+    # both represented by a Integer.
+    #
+    # Pixels/colors are represented in RGBA components. Each of the four
+    # components is stored with a depth of 8 bits (maximum value = 255 =
+    # {Plotter::Color::MAX}). Together, these components are stored in a 4-byte
+    # Integer.
+    #
+    # A color will always be represented using these 4 components in memory.
+    # When the image is encoded, a more suitable representation can be used
+    # (e.g. rgb, grayscale, palette-based), for which several conversion methods
+    # are provided in this module.
+    module Color
+      extend ChunkyPNG::Color
+      include ChunkyPNG::Color
+    end
+    ##
+    # Factory method to return a color value, based on the arguments given.
+    #
+    # @overload Color(r, g, b, a)
+    #   @param (see ChunkyPNG::Color.rgba)
+    #   @return [Integer] The rgba color value.
+    #
+    # @overload Color(r, g, b)
+    #   @param (see ChunkyPNG::Color.rgb)
+    #   @return [Integer] The rgb color value.
+    #
+    # @overload Color(hex_value, opacity = nil)
+    #   @param (see ChunkyPNG::Color.from_hex)
+    #   @return [Integer] The hex color value, with the opacity applied if one
+    #     was given.
+    #
+    # @overload Color(color_name, opacity = nil)
+    #   @param (see ChunkyPNG::Color.html_color)
+    #   @return [Integer] The hex color value, with the opacity applied if one
+    #     was given.
+    #
+    # @overload Color(color_value, opacity = nil)
+    #   @param [Integer, :to_i] The color value.
+    #   @return [Integer] The color value, with the opacity applied if one was
+    #     given.
+    #
+    # @return [Integer] The determined color value as RGBA integer.
+    # @raise [ArgumentError] if the arguments weren't understood as a color.
+    def color(*args)
+      case args.length
+      when 1 then Color.parse(args.first)
+      when 2 then (Color.parse(args.first) & 0xffffff00) | args[1].to_i
+      when 3 then Color.rgb(*args)
+      when 4 then Color.rgba(*args)
+      else raise ArgumentError,
+                 "Don't know how to create a color from #{args.inspect}!"
+      end
+    end
+    ##
+    # A class representing canvas for plotting bar charts and function graphs
+    class Image
+      include Silicium::Geometry
+      ##
+      # Creates a new plot with chosen +width+ and +height+ parameters
+      # with background colored +bg_color+
+      def initialize(width, height, bg_color = Color::TRANSPARENT, padding = 5)
+        @image = ChunkyPNG::Image.new(width, height, bg_color)
+        @padding = padding
+      end
+
+      def rectangle(left_upper, width, height, color)
+        x_end = left_upper.x + width - 1
+        y_end = left_upper.y + height - 1
+        (left_upper.x..x_end).each do |i|
+          (left_upper.y..y_end).each { |j| @image[i, j] = color }
+        end
+      end
+
+      private
+
+      def draw_axis(min, dpu, axis_color)
+        # Axis OX
+        rectangle(Point.new(
+                    @padding,
+                    @image.height - @padding - (min.y.abs * dpu.y).ceil
+                  ),
+                  @image.width - 2 * @padding,
+                  1,
+                  axis_color)
+        # Axis OY
+        rectangle(Point.new(@padding + (min.x.abs * dpu.x).ceil, @padding),
+                  1, @image.height - 2 * @padding, axis_color)
+      end
+
+      public
+
+      ##
+      # Draws a bar chart in the plot using provided +bars+,
+      # each of them has width of +bar_width+ and colored +bars_color+
+      def bar_chart(bars, bar_width,
+                    bars_color = Color('red @ 1.0'),
+                    axis_color = Color::BLACK)
+        if bars.count * bar_width > @image.width
+          raise ArgumentError,
+                'Not enough big size of image to plot these number of bars'
+        end
+
+        # Values of x and y on borders of plot
+        min = Point.new([bars.collect { |k, _| k }.min, 0].min,
+                        [bars.collect { |_, v| v }.min, 0].min)
+        max = Point.new([bars.collect { |k, _| k }.max, 0].max,
+                        [bars.collect { |_, v| v }.max, 0].max)
+
+        # Dots per unit
+        dpu = Point.new(
+          (@image.width - 2 * @padding).to_f / (max.x - min.x + bar_width),
+          (@image.height - 2 * @padding).to_f / (max.y - min.y)
+        )
+
+        draw_axis(min, dpu, axis_color)
+
+        bars.each do |x, y| # Cycle drawing bars
+          l_up_x = @padding + ((x + min.x.abs) * dpu.x).floor
+          l_up_y = if y.negative?
+                     @image.height - @padding - (min.y.abs * dpu.y).ceil + 1
+                   else
+                     @image.height - @padding - ((y + min.y.abs) * dpu.y).ceil
+                   end
+          rectangle(Point.new(l_up_x, l_up_y),
+                    bar_width, (y.abs * dpu.y).ceil,
+                    bars_color)
+        end
+      end
+
+      ##
+      # Exports plotted image to file +filename+
+      def export(filename)
+        @image.save(filename, interlace: true)
+      end
+    end
+
+    CENTER_X = Window.width / 2
+    CENTER_Y = Window.height / 2
+
+    mul = 100/1
+
+    ##
+    # draws axes
+    def draw_axes
+      Line.new(x1: 0, y1: CENTER_Y, x2: (get :width), y2: CENTER_Y, width: 1, color: 'white', z: 20)
+      Line.new(x1: CENTER_X, y1: 0, x2: CENTER_X, y2: (get :height), width: 1, color: 'white', z: 20)
+
+      x1 = CENTER_X
+      x2 = CENTER_X
+      while (x1 < Window.width * 1.1) and (x2 > Window.width * -1.1) do
+        Line.new(x1: x1, y1: CENTER_Y - 4, x2: x1, y2: CENTER_Y + 3, width: 1, color: 'white', z: 20)
+        Line.new(x1: x2, y1: CENTER_Y - 4, x2: x2, y2: CENTER_Y + 3, width: 1, color: 'white', z: 20)
+        x1 += mul
+        x2 -= mul
+      end
+
+      y1 = CENTER_Y
+      y2 = CENTER_Y
+      while (y1 < Window.height * 1.1) and (y2 > Window.height * -1.1) do
+        Line.new(x1: CENTER_X - 3, y1: y1, x2: CENTER_X + 3, y2: y1, width: 1, color: 'white', z: 20)
+        Line.new(x1: CENTER_X - 3, y1: y2, x2: CENTER_X + 3, y2: y2, width: 1, color: 'white', z: 20)
+        y1 += mul
+        y2 -= mul
+      end
+    end
+
+    ##
+    # Changes the coordinates to draw the next pixel for the +f+ function
+    # +x+ - current argument. +st+ - step to next point
+    def reset_step(x, st, &f)
+      y1 = f.call(x)
+      y2 = f.call(x + st)
+
+      if (y1 - y2).abs / mul > 1.0
+        [st / (y1 - y2).abs / mul, 0.001].max
+      else
+        st / mul * 2
+      end
+    end
+
+    ##
+    # Draws a point on coordinates +x+ and +y+
+    # with the scale +mul+ and color +col+
+    def draw_point(x, y, mul, col)
+      Line.new(
+          x1: CENTER_X + x * mul, y1: CENTER_Y - y * mul,
+          x2: CENTER_X + 1 + x * mul, y2: CENTER_Y + 2 - y * mul,
+          width: 1,
+          color: col,
+          z: 20
+      )
+    end
+
+    ##
+    # Reduces the interval to the window range. +a+ and +b+ that determine interval
+    def reduce_interval(a, b)
+      a *= mul
+      b *= mul
+      return [a, -(get :width) * 1.1].max / mul, [b, (get :width) * 1.1].min / mul
+    end
+
+    ##
+    # Draws the function +func+ at the interval from +a+ to +b+
+    def draw_fn(a, b, &func)
+      draw_axes
+
+      a, b = reduce_interval(a, b)
+
+      step = 0.38
+      c_step = step
+      arg = a
+
+      while arg < b do
+        c_step = step
+        begin
+          c_step = reset_step(arg, step) {|xx| fn(xx)}
+        rescue Math::DomainError
+          arg += c_step * 0.1
+        else
+          draw_point(arg, func.call(arg), mul, 'lime')
+        ensure
+          arg += c_step
+        end
+      end
+    end
+
+    ##
+    # show plot
+    def show_window
+      show
+    end
+
+    # @param [Integer] sc
+    def set_scale(sc)
+      mul = sc
+    end
+
+  end
+end
+
+
+

data/lib/polynomial_division.rb

@@ -0,0 +1,132 @@
+module Silicium
+
+
+  module Algebra
+    ##
+    # TODO: class docs
+    class PolynomialDivision
+
+      DELTA = 0.01
+
+      # This function returns an array of coefficients obtained by parsing input string in format: "<coeff>*x**<degree>+..."
+      # Even if in your expression don't exist x with some degree, you should to write it with 0 coefficient
+      # Also free term you should to write with 0 degree
+      # Example: "2*x**5-3*x**4+0*x**3+0*x**2-5*x**1-6*x**0"
+      def polynom_parser(str)
+        copy_str = str.clone
+        sgn_array = []                    # Array of signs
+        if copy_str[0] != '-'
+          sgn_array.push('+')
+        else
+          sgn_array.push('-')
+          copy_str[0] = ''
+        end
+        token = copy_str.split(/[-+]/)
+        (0..copy_str.size-1).each do |i|
+          sgn_array.push(copy_str[i]) if copy_str[i] == '-' || copy_str[i] == '+'
+        end
+        size = token.size - 1
+        coeff = []                 # Array of coefficients
+        (0..size).each do |i|
+          degree = token[i].split('*')    # Split by '*' to get coefficient and degree
+          degree[0] == 'x' ? coeff[i] = 1.0 : coeff[i] = degree[0].to_f
+          coeff[i] *= -1 if sgn_array[i] == '-'
+        end
+        coeff
+      end
+
+# String implementation of result
+      def str_res_impl(coeff_res, sgn_array)
+        res_size = coeff_res.size
+        res_exp = ""
+        (0..res_size-1).each do |i|
+          res_exp += ((coeff_res[i].ceil(3)).to_s+"*x**"+(res_size - i - 1).to_s)
+          res_exp += sgn_array[i+1] if sgn_array[i+1] != '-'
+        end
+        res_exp
+      end
+
+# String implementation of remained part
+      def str_rem_impl(coeff_1)
+        c = coeff_1.size
+        rem_exp = ""
+        (0..c-1).each do |i|
+          rem_exp += '+' if coeff_1[i] >= 0.0
+          rem_exp += ((coeff_1[i].ceil(3)).to_s+"*x**"+(c - i - 1).to_s)
+        end
+        rem_exp[0] = '' if rem_exp[0] == '+'
+        rem_exp
+      end
+
+# This function returns array of 2 strings: first is the result of division polynom poly_1 on polynom poly_2
+# Second - remainder
+      def polynom_division(poly_1, poly_2)
+        coeff_1 = polynom_parser(poly_1)
+        coeff_2 = polynom_parser(poly_2)
+        res_size = coeff_1.size - coeff_2.size + 1
+        coeff_result = Array.new(res_size)
+        sgn_array = Array.new(res_size + 1,'')
+        (0..res_size-1).each do |i|
+          cur_coeff = coeff_1[i] / coeff_2[0]
+          coeff_result[i] = cur_coeff
+          coeff_result[i] < 0 ? sgn_array[i] = '-' : sgn_array[i] = '+'
+          (0..coeff_2.size-1).each do |j|
+            coeff_1[i+j] -= coeff_2[j]*cur_coeff
+          end
+        end
+        res_exp = str_res_impl(coeff_result, sgn_array)
+        rem_exp = str_rem_impl(coeff_1[coeff_result.size..coeff_1.size-1])
+        [res_exp, rem_exp]
+      end
+
+      def compare_polynoms(poly1, poly2)
+        polynom_parser(poly1).size - polynom_parser(poly2).size
+      end
+
+      def zero_coeffs?(polynom, delta = DELTA)
+        polynom_parser(polynom).all?{ |item| item.abs < delta }
+      end
+
+      def round_coeffs(coefficients, delta = DELTA)
+        coefficients.map do |element|
+          (element.round - element).abs < delta ? element.round.to_f : element
+        end
+      end
+
+      def build_polynom_from_coeffs(coefficients)
+        "#{coefficients[0]}*x**#{coefficients.size - 1}" +
+          coefficients[1..-1].each_with_index.inject('') do |acc, (coefficient, index)|
+            leading_sign = coefficient >= 0 ? '+' : ''
+            acc + "#{leading_sign}#{coefficient}*x**#{ coefficients.size - index - 2 }"
+          end
+      end
+      
+      # This function returns a string: greatest common integer divisor of two polynoms
+      def polynom_gcd(poly1, poly2, delta = DELTA)
+        divisor, remainder = order_gcd_operands(poly1, poly2)
+        until zero_coeffs?(remainder) do
+          division = polynom_division(divisor, remainder)
+          divisor = remainder
+          remainder = division[1]
+        end
+        normalizer = polynom_parser(divisor)[0]
+        temp_result = polynom_division(divisor, normalizer.to_s+'*x**0')[0]
+        coefficients = round_coeffs(polynom_parser(temp_result), delta)
+        build_polynom_from_coeffs(coefficients)
+      end
+
+      private
+
+      def order_gcd_operands(poly1, poly2)
+        if compare_polynoms(poly1, poly2) >= 0
+          divisor = poly2
+          remainder = polynom_division(poly1, divisor)[1]
+        else
+          divisor = poly1
+          remainder = polynom_division(poly2, divisor)[1]
+        end
+        [divisor, remainder]
+      end
+    end
+  end
+end