flash_math 0.0.1

data/lib/flash_math/modules/geometry/geometric_point.rb

@@ -0,0 +1,19 @@
+class GeometricPoint < Struct.new(:x, :y)
+
+  def self.new_by_array(array)
+    self.new(array[0], array[1])
+  end
+
+  def to_vector
+    GeometricVector.new(x, y)
+  end
+
+  def advance_by(vector)
+    GeometricPoint.new(x + vector.x, y + vector.y)
+  end
+
+  def ==(another_point)
+    x === another_point.x && y === another_point.y
+  end
+
+end

data/lib/flash_math/modules/geometry/geometric_point_in_polygon.rb

@@ -0,0 +1,63 @@
+class GeometricPointInPolygon < Struct.new(:point, :polygon)
+  extend Memoist
+
+  def inside?
+    point_location == :inside
+  end
+
+  def outside?
+    point_location == :outside
+  end
+
+  def on_the_boundary?
+    point_location == :on_the_boundary
+  end
+
+  def point_location
+    return :outside unless bounding_box.contains?(point)
+    return :on_the_boundary if point_is_vertex? || point_on_edge?
+
+    intersection_count(choose_good_ray).odd? ? :inside : :outside
+  end
+
+  delegate :vertices, :edges, :bounding_box, to: :polygon
+  memoize  :point_location, :edges, :bounding_box
+
+  private
+
+  def choose_good_ray
+    ray = random_ray
+    while ! good_ray?(ray) do
+      ray = random_ray
+    end
+    ray
+  end
+
+  def good_ray?(ray)
+    edges.none? { |edge| edge.parallel_to?(ray) } && vertices.none? { |vertex| ray.contains_point?(vertex) }
+  end
+
+  def intersection_count(ray)
+    edges.select { |edge| edge.intersects_with?(ray) }.size
+  end
+
+  def point_is_vertex?
+    vertices.any? { |vertex| vertex == point }
+  end
+
+  def point_on_edge?
+    edges.any? { |edge| edge.contains_point?(point) }
+  end
+
+  def random_ray
+    random_direction = rand * (2 * Math::PI)
+
+    ray_endpoint = GeometricPoint.new(sufficient_ray_radius * Math.cos(random_direction), sufficient_ray_radius * Math.sin(random_direction))
+    GeometricSegment.new(point, ray_endpoint)
+  end
+
+  def sufficient_ray_radius
+    @sufficient_ray_radius ||= bounding_box.diagonal.length * 2
+  end
+
+end

data/lib/flash_math/modules/geometry/geometric_polygon.rb

@@ -0,0 +1,36 @@
+class GeometricPolygon < Struct.new(:vertices)
+
+  def bounding_box
+    leftbottom = GeometricPoint.new(vertices.map(&:x).min, vertices.map(&:y).min)
+    righttop = GeometricPoint.new(vertices.map(&:x).max, vertices.map(&:y).max)
+
+    GeometricBoundingBox.new(leftbottom, righttop)
+  end
+
+  def area
+    sum = 0.0
+    (0..vertices.length-1).each do |i|
+      a = vertices[i-1]
+      b = vertices[i]
+
+      sum = sum + ((a.x * b.y) - (a.y * b.x))
+    end
+    (sum / 2).abs
+  end
+
+  def contains?(point)
+    point_in_polygon = GeometricPointInPolygon.new(point, self)
+    point_in_polygon.inside? || point_in_polygon.on_the_boundary?
+  end
+
+  def edges
+    edges = []
+
+    1.upto(vertices.length - 1) do |vertex_index|
+      edges << GeometricSegment.new(vertices[vertex_index - 1], vertices[vertex_index])
+    end
+
+    edges << GeometricSegment.new(vertices.last, vertices.first)
+  end
+
+end

data/lib/flash_math/modules/geometry/geometric_segment.rb

@@ -0,0 +1,128 @@
+class GeometricSegmentsDoNotIntersect < Exception; end
+class GeometricSegmentsOverlap < Exception; end
+
+class GeometricSegment < Struct.new(:point1, :point2)
+
+  def self.new_by_arrays(point1_coordinates, point2_coordinates)
+    self.new(GeometricPoint.new_by_array(point1_coordinates),
+             GeometricPoint.new_by_array(point2_coordinates))
+  end
+
+  def bottommost_endpoint
+    ((point1.y <=> point2.y) == -1) ? point1 : point2
+  end
+
+  def leftmost_endpoint
+    ((point1.x <=> point2.x) == -1) ? point1 : point2
+  end
+
+  def rightmost_endpoint
+    ((point1.x <=> point2.x) == 1) ? point1 : point2
+  end
+
+  def topmost_endpoint
+    ((point1.y <=> point2.y) == 1) ? point1 : point2
+  end
+
+  def contains_point?(point)
+    GeometricDistance.new(point1, point2).distance ===
+      GeometricDistance.new(point1, point).distance + GeometricDistance.new(point, point2).distance
+  end
+
+  def distance_to(point)
+    q = point.to_vector
+    p1 = point1.to_vector
+    p2 = point2.to_vector
+
+    u = p2 - p1
+    v = q - p1
+
+    a = u.scalar_product(v)
+    if a < 0
+      p = p1
+    else
+      b = u.scalar_product(u)
+      if a > b
+        p = p2
+      else
+        p = p1 + (a.to_f / b * u)
+      end
+    end
+
+    return GeometricDistance.new(q, p).distance
+  end
+
+  def intersection_point_with(segment)
+    raise GeometricSegmentsDoNotIntersect unless intersects_with?(segment)
+    raise GeometricSegmentsOverlap if overlaps?(segment)
+
+    numerator = (segment.point1.y - point1.y) * (segment.point1.x - segment.point2.x) -
+      (segment.point1.y - segment.point2.y) * (segment.point1.x - point1.x);
+    denominator = (point2.y - point1.y) * (segment.point1.x - segment.point2.x) -
+      (segment.point1.y - segment.point2.y) * (point2.x - point1.x);
+
+    t = numerator.to_f / denominator;
+
+    x = point1.x + t * (point2.x - point1.x)
+    y = point1.y + t * (point2.y - point1.y)
+
+    GeometricPoint.new(x, y)
+  end
+
+  def intersects_with?(segment)
+    GeometricSegment.have_intersecting_bounds?(self, segment) &&
+      lies_on_line_intersecting?(segment) &&
+      segment.lies_on_line_intersecting?(self)
+  end
+
+  def length
+    GeometricDistance.new(point1, point2).distance
+  end
+
+  def lies_on_one_line_with?(segment)
+    GeometricSegment.new(point1, segment.point1).parallel_to?(self) &&
+      GeometricSegment.new(point1, segment.point2).parallel_to?(self)
+  end
+
+  def overlaps?(segment)
+    GeometricSegment.have_intersecting_bounds?(self, segment) &&
+      lies_on_one_line_with?(segment)
+  end
+
+  def parallel_to?(segment)
+    to_vector.collinear_with?(segment.to_vector)
+  end
+
+  def to_vector
+    GeometricVector.new(point2.x - point1.x, point2.y - point1.y)
+  end
+
+  protected
+
+  def self.have_intersecting_bounds?(segment1, segment2)
+    intersects_on_x_axis =
+      (segment1.leftmost_endpoint.x < segment2.rightmost_endpoint.x ||
+      segment1.leftmost_endpoint.x == segment2.rightmost_endpoint.x) &&
+      (segment2.leftmost_endpoint.x < segment1.rightmost_endpoint.x ||
+      segment2.leftmost_endpoint.x == segment1.rightmost_endpoint.x)
+
+    intersects_on_y_axis =
+      (segment1.bottommost_endpoint.y < segment2.topmost_endpoint.y ||
+      segment1.bottommost_endpoint.y == segment2.topmost_endpoint.y) &&
+      (segment2.bottommost_endpoint.y < segment1.topmost_endpoint.y ||
+      segment2.bottommost_endpoint.y == segment1.topmost_endpoint.y)
+
+    intersects_on_x_axis && intersects_on_y_axis
+  end
+
+  def lies_on_line_intersecting?(segment)
+    vector_to_first_endpoint = GeometricSegment.new(self.point1, segment.point1).to_vector
+    vector_to_second_endpoint = GeometricSegment.new(self.point1, segment.point2).to_vector
+
+    #FIXME: '>=' and '<=' method of Fixnum and Float should be overriden too (take precision into account)
+    # there is a rare case, when this method is wrong due to precision
+    self.to_vector.cross_product(vector_to_first_endpoint) *
+      self.to_vector.cross_product(vector_to_second_endpoint) <= 0
+  end
+
+end

data/lib/flash_math/modules/geometry/geometric_vector.rb

@@ -0,0 +1,46 @@
+class GeometricVector < Struct.new(:x, :y)
+
+  def self.new_by_array(array)
+    self.new(array[0], array[1])
+  end
+
+  def ==(vector)
+    x === vector.x && y === vector.y
+  end
+
+  def +(vector)
+    GeometricVector.new(x + vector.x, y + vector.y)
+  end
+
+  def -(vector)
+    self + (-1) * vector
+  end
+
+  def *(scalar)
+    GeometricVector.new(x * scalar, y * scalar)
+  end
+
+  def coerce(scalar)
+    if scalar.is_a?(Numeric)
+      [self, scalar]
+    else
+      raise ArgumentError, "GeometricVector: cannot coerce #{scalar.inspect}"
+    end
+  end
+
+  def cross_product(vector)
+    x * vector.y - y * vector.x
+  end
+
+  def scalar_product(vector)
+    x * vector.x + y * vector.y
+  end
+
+  def collinear_with?(vector)
+    cross_product(vector) === 0
+  end
+
+  def modulus
+    Math.hypot(x ,y)
+  end
+end

data/lib/flash_math/modules/statistics.rb

@@ -0,0 +1 @@
+require 'flash_math/modules/statistics/statistical_spread'

data/lib/flash_math/modules/statistics/statistical_spread.rb

@@ -0,0 +1,129 @@
+class StatisticalSpread < Struct.new(:values)
+
+  def sum(identity=0, &block)
+    if block_given?
+      StatisticalSpread.new(values.map(&block)).sum(identity)
+    else
+      values.inject(:+) || identity
+    end
+  end
+
+  def mean
+    return if values.length < 1
+    sum / values.length.to_f
+  end
+
+  def median
+    return if values.length < 1
+    sorted = values.sort
+
+    if values.length % 2 == 0
+      (sorted[(values.length / 2) -1] + sorted[values.length / 2]) / 2.0
+    else
+      sorted[values.length / 2]
+    end
+  end
+
+  def mode
+    return if values.length < 1
+    frequency_distribution = values.inject(Hash.new(0)) { |hash, value| hash[value] += 1; hash }
+    top_2 = frequency_distribution.sort { |a,b| b[1] <=> a[1] } .take(2)
+    if top_2.length == 1
+      top_2.first.first
+    elsif top_2.first.last == top_2.last.last
+      nil
+    else
+      top_2.first.first
+    end
+  end
+
+  def range
+    return if values.length < 1
+    sorted = values.sort
+    sorted.last - sorted.first
+  end
+
+  def max
+    return if values.length < 1
+    values.sort.last
+  end
+
+  def min
+    return if values.length < 1
+    values.sort.first
+  end
+
+  def percentile_from_value(value)
+    return if values.length < 1
+    (values.sort.index(value) / values.length.to_f * 100).ceil
+  end
+
+  def value_from_percentile(percentile)
+    return if values.length < 1
+    value_index = (percentile.to_f / 100 * values.length).ceil
+    values.sort[value_index]
+  end
+
+  def variance
+    return if values.length < 1
+    precalculated_mean = StatisticalSpread.new(values).mean
+    sum = values.inject(0) { |accumulator, value| accumulator + (value - precalculated_mean) ** 2 }
+    sum / (values.length.to_f - 1)
+  end
+
+  def population_variance
+    return if values.length < 1
+    precalculated_mean = StatisticalSpread.new(values).mean
+    sum = values.inject(0) { |accumulator, value| accumulator + (value - precalculated_mean) ** 2 }
+    sum / values.length.to_f
+  end
+
+  def standard_deviation
+    return if values.length < 2
+    Math.sqrt(StatisticalSpread.new(values).variance)
+  end
+
+  def relative_standard_deviation
+    return if values.length < 1
+    precalculated_mean = StatisticalSpread.new(values).mean
+    (StatisticalSpread.new(values).population_standard_deviation / precalculated_mean) * 100.0
+  end
+
+  def population_standard_deviation
+    return if values.length < 1
+    Math.sqrt(StatisticalSpread.new(values).population_variance)
+  end
+
+  def skewness
+    return if values.length == 0
+    return 0 if values.length == 1
+    StatisticalSpread.new(values).sum_cubed_deviation / ((values.length - 1) * StatisticalSpread.new(values).cubed_standard_deviation.to_f)
+  end
+
+  def kurtosis
+    return if values.length == 0
+    return 0 if values.length == 1
+    StatisticalSpread.new(values).sum_quarted_deviation / ((values.length - 1) * StatisticalSpread.new(values).quarted_standard_deviation.to_f)
+  end
+
+  protected
+
+  def sum_cubed_deviation
+    precalculated_mean = StatisticalSpread.new(values).mean
+    values.inject(0) { |sum, value| sum + (value - precalculated_mean) ** 3}
+  end
+
+  def cubed_standard_deviation
+    StatisticalSpread.new(values).standard_deviation ** 3
+  end
+
+  def sum_quarted_deviation
+    precalculated_mean = StatisticalSpread.new(values).mean
+    values.inject(0) { |sum, value| sum + (value - precalculated_mean) ** 4}
+  end
+
+  def quarted_standard_deviation
+    StatisticalSpread.new(values).standard_deviation ** 4
+  end
+
+end

data/lib/flash_math/version.rb

@@ -0,0 +1,3 @@
+module FlashMath
+  VERSION = "0.0.1"
+end

data/spec/lib/geometry/geometric_bounding_box_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe GeometricBoundingBox do
+
+  describe '#initialize_by_points' do
+    point1 = GeometricPoint.new(1, 2)
+    point2 = GeometricPoint.new(3, 4)
+    bounding_box = GeometricBoundingBox.new(point1, point2)
+
+    it 'to be equal' do
+      expect(bounding_box.leftbottom).to eq(point1)
+      expect(bounding_box.righttop).to eq(point2)
+    end
+
+    it 'to be not equal' do
+      expect(bounding_box.leftbottom).not_to eq(point2)
+      expect(bounding_box.righttop).not_to eq(point1)
+    end
+  end
+
+  describe '#initialize_by_arrays' do
+    point1 = GeometricPoint.new(1, 2)
+    point2 = GeometricPoint.new(3, 4)
+    bounding_box = GeometricBoundingBox.new_by_arrays([1, 2], [3, 4])
+
+    it 'to be equal' do
+      expect(bounding_box.leftbottom).to eq(point1)
+      expect(bounding_box.righttop).to eq(point2)
+    end
+
+    it 'to be not equal' do
+      expect(bounding_box.leftbottom).not_to eq(point2)
+      expect(bounding_box.righttop).not_to eq(point1)
+    end
+  end
+
+  describe '#contains' do
+    bounding_box = GeometricBoundingBox.new(GeometricPoint.new(-1, -1), GeometricPoint.new(1, 1))
+
+    it 'to be containing point' do
+      expect(bounding_box.contains?(GeometricPoint.new(0, 0))).to eq(true)
+    end
+
+    it 'to be not containing point' do
+      expect(bounding_box.contains?(GeometricPoint.new(2, 2))).to eq(false)
+      expect(bounding_box.contains?(GeometricPoint.new(-2, -2))).to eq(false)
+      expect(bounding_box.contains?(GeometricPoint.new(1, 2))).to eq(false)
+      expect(bounding_box.contains?(GeometricPoint.new(0, -1.1))).to eq(false)
+    end
+
+    it 'to be not containing point' do
+      expect(bounding_box.contains?(GeometricPoint.new(2, 2))).to eq(false)
+      expect(bounding_box.contains?(GeometricPoint.new(-2, -2))).to eq(false)
+      expect(bounding_box.contains?(GeometricPoint.new(1, 2))).to eq(false)
+      expect(bounding_box.contains?(GeometricPoint.new(0, -1.1))).to eq(false)
+    end
+
+    it 'to be containing point at edge' do
+      expect(bounding_box.contains?(GeometricPoint.new(1, 0))).to eq(true)
+    end
+
+    it 'to be containing point at vertex' do
+      expect(bounding_box.contains?(GeometricPoint.new(1, 1))).to eq(true)
+    end
+  end
+
+end