flash_math 0.0.1

data/spec/lib/geometry/geometric_segment_spec.rb

@@ -0,0 +1,231 @@
+require 'spec_helper'
+
+describe GeometricSegment do
+
+  describe '#initialize_by_points' do
+    point1 = GeometricPoint.new(1, 2)
+    point2 = GeometricPoint.new(3, 4)
+    segment = GeometricSegment.new(point1, point2)
+
+    it 'to be equal' do
+      expect(segment.point1).to eq(point1)
+      expect(segment.point2).to eq(point2)
+    end
+
+    it 'to be not equal' do
+      expect(segment.point1).not_to eq(point2)
+      expect(segment.point2).not_to eq(point1)
+    end
+  end
+
+  describe '#initialize_by_arrays' do
+    point1 = GeometricPoint.new(1, 2)
+    point2 = GeometricPoint.new(3, 4)
+    segment = GeometricSegment.new_by_arrays([1, 2], [3, 4])
+
+    it 'to be equal' do
+      expect(segment.point1).to eq(point1)
+      expect(segment.point2).to eq(point2)
+    end
+
+    it 'to be not equal' do
+      expect(segment.point1).not_to eq(point2)
+      expect(segment.point2).not_to eq(point1)
+    end
+  end
+
+  describe '#bounds' do
+    point1 = GeometricPoint.new(1, 1)
+    point2 = GeometricPoint.new(2, 2)
+    segment = GeometricSegment.new(point1, point2)
+
+    it 'to be the bottommost point' do
+      expect(segment.bottommost_endpoint).to eq(point1)
+    end
+
+    it 'to be the leftmost point' do
+      expect(segment.leftmost_endpoint).to eq(point1)
+    end
+
+    it 'to be the rightmost point' do
+      expect(segment.rightmost_endpoint).to eq(point2)
+    end
+
+    it 'to be the topmost point' do
+      expect(segment.topmost_endpoint).to eq(point2)
+    end
+  end
+
+  describe '#contains_point?' do
+    it 'to be belongs to horizontal segment' do
+      expect(GeometricSegment.new_by_arrays([2, 1], [4, 1]).contains_point?(GeometricPoint.new(3, 1))).to eq(true)
+    end
+
+    it 'to be belongs to inclined segment' do
+      expect(GeometricSegment.new_by_arrays([2, 2], [4, 4]).contains_point?(GeometricPoint.new(3, 3))).to eq(true)
+    end
+
+    it 'to be is segment endpoint' do
+      expect(GeometricSegment.new_by_arrays([2, 1], [4, 1]).contains_point?(GeometricPoint.new(2, 1))).to eq(true)
+    end
+
+    it 'to be not belonging to segment' do
+      expect(GeometricSegment.new_by_arrays([2, 1], [4, 1]).contains_point?(GeometricPoint.new(2, 3))).to eq(false)
+    end
+
+    it 'to be on same horizontal line' do
+      expect(GeometricSegment.new_by_arrays([2, 1], [4, 1]).contains_point?(GeometricPoint.new(1, 1))).to eq(false)
+    end
+
+    it 'to be on same inclined line' do
+      expect(GeometricSegment.new_by_arrays([2, 2], [4, 4]).contains_point?(GeometricPoint.new(1, 1))).to eq(false)
+    end
+  end
+
+  describe '#distance_to' do
+    it 'to be distance to point on segment' do
+      expect(GeometricSegment.new_by_arrays([0, 2], [2, 0]).distance_to(GeometricPoint.new(1, 1))).to eq(0)
+    end
+
+    it 'to be distance to flat segment' do
+      expect(GeometricSegment.new_by_arrays([0, 1], [2, 1]).distance_to(GeometricPoint.new(1, 2))).to eq(1)
+    end
+
+    it 'to be distance to segment start' do
+      expect(GeometricSegment.new_by_arrays([1, 1], [2, 1]).distance_to(GeometricPoint.new(0, 1))).to eq(1)
+    end
+
+    it 'to be distance to segment end' do
+      expect(GeometricSegment.new_by_arrays([0, 1], [0, 2]).distance_to(GeometricPoint.new(0, 3))).to eq(1)
+    end
+  end
+
+  describe '#intersection_point_with' do
+    it 'to be regular case' do
+      expect(GeometricSegment.new_by_arrays([0, 0], [2, 2]).intersection_point_with(GeometricSegment.new_by_arrays([0, 2], [2, 0]))).to eq(GeometricPoint.new(1, 1))
+    end
+
+    it 'to be intersected at the endpoint' do
+      expect(GeometricSegment.new_by_arrays([0, 0], [2, 2]).intersection_point_with(GeometricSegment.new_by_arrays([0, 2], [2, 2]))).to eq(GeometricPoint.new(2, 2))
+    end
+  end
+
+  describe '#intersects_with?' do
+    it 'to be segments intersect' do
+      expect(GeometricSegment.new_by_arrays([0, 0], [2, 0]).intersects_with?(GeometricSegment.new_by_arrays([1, 1], [1, -1]))).to eq(true)
+    end
+
+    it 'to be segments does not intersect but lay on intersecting lines' do
+      expect(GeometricSegment.new_by_arrays([0, 0], [0, 2]).intersects_with?(GeometricSegment.new_by_arrays([1, 1], [3, 1]))).to eq(false)
+    end
+
+    it 'to be segments does not intersect but line contains end point' do
+      expect(GeometricSegment.new_by_arrays([0, 0], [0, 2]).intersects_with?(GeometricSegment.new_by_arrays([1, 0], [3, 0]))).to eq(false)
+    end
+
+    it 'to be segment contains endpoint' do
+      expect(GeometricSegment.new_by_arrays([0, 0], [2, 2]).intersects_with?(GeometricSegment.new_by_arrays([0, 0], [2, 0]))).to eq(true)
+    end
+
+    it 'to be segments parralel' do
+      expect(GeometricSegment.new_by_arrays([0, 1], [2, 1]).intersects_with?(GeometricSegment.new_by_arrays([0, 0], [2, 0]))).to eq(false)
+    end
+
+    it 'to be segments parallel and have common endpoint' do
+      expect(GeometricSegment.new_by_arrays([0, 0], [1, 0]).intersects_with?(GeometricSegment.new_by_arrays([1, 0], [2, 0]))).to eq(true)
+    end
+
+    it 'to be segments overlap' do
+      expect(GeometricSegment.new_by_arrays([0, 0], [2, 0]).intersects_with?(GeometricSegment.new_by_arrays([1, 0], [3, 0]))).to eq(true)
+    end
+
+    it 'to be segments overlap on vertical line' do
+      expect(GeometricSegment.new_by_arrays([0, 0], [0, 2]).intersects_with?(GeometricSegment.new_by_arrays([0, 1], [0, 3]))).to eq(true)
+    end
+
+    it 'to be segments lie on one line' do
+      expect(GeometricSegment.new_by_arrays([0, 0], [1, 0]).intersects_with?(GeometricSegment.new_by_arrays([2, 0], [3, 0]))).to eq(false)
+    end
+
+    it 'to be segments lie on one vertical line' do
+      expect(GeometricSegment.new_by_arrays([0, 0], [0, 1]).intersects_with?(GeometricSegment.new_by_arrays([0, 2], [0, 3]))).to eq(false)
+    end
+  end
+
+  describe '#length' do
+    it 'to be parallel to axis' do
+      expect(GeometricSegment.new_by_arrays([1, 1], [1, 2]).length).to eq(1)
+      expect(GeometricSegment.new_by_arrays([1, 1], [2, 1]).length).to eq(1)
+    end
+
+    it 'to be inclined' do
+      expect(GeometricSegment.new_by_arrays([1, 1], [2, 2]).length).to eq(Math.sqrt(2))
+    end
+  end
+
+  describe '#lies_on_one_line_with?' do
+    it 'to be parralel but on different lines' do
+      expect(GeometricSegment.new_by_arrays([0, 1], [2, 1]).lies_on_one_line_with?(GeometricSegment.new_by_arrays([0, 0], [2, 0]))).to eq(false)
+    end
+
+    it 'to be not parralel' do
+      expect(GeometricSegment.new_by_arrays([0, 0], [2, 0]).lies_on_one_line_with?(GeometricSegment.new_by_arrays([0, 1], [2, 2]))).to eq(false)
+    end
+
+    it 'to be segment that lies on one horizontal line' do
+      expect(GeometricSegment.new_by_arrays([0, 0], [1, 0]).lies_on_one_line_with?(GeometricSegment.new_by_arrays([2, 0], [3, 0]))).to eq(true)
+    end
+
+    it 'to be segment that lies on one vertical line' do
+      expect(GeometricSegment.new_by_arrays([0, 0], [0, 1]).lies_on_one_line_with?(GeometricSegment.new_by_arrays([0, 2], [0, 3]))).to eq(true)
+    end
+  end
+
+  describe '#overlaps?' do
+    it 'to be overlaped' do
+      expect(GeometricSegment.new_by_arrays([0, 0], [2, 0]).overlaps?(GeometricSegment.new_by_arrays([1, 0], [3, 0]))).to eq(true)
+    end
+
+    it 'to be overlapes same segment' do
+      expect(GeometricSegment.new_by_arrays([0, 0], [2, 0]).overlaps?(GeometricSegment.new_by_arrays([0, 0], [2, 0]))).to eq(true)
+    end
+
+    it 'to be overlap intersects on one point' do
+      expect(GeometricSegment.new_by_arrays([0, 0], [1, 0]).overlaps?(GeometricSegment.new_by_arrays([1, 0], [1, 1]))).to eq(false)
+    end
+
+    it 'to be overlap lies on one horizontal line' do
+      expect(GeometricSegment.new_by_arrays([0, 0], [2, 0]).overlaps?(GeometricSegment.new_by_arrays([4, 0], [6, 0]))).to eq(false)
+    end
+
+    it 'to be overlap lies on one vertical line' do
+      expect(GeometricSegment.new_by_arrays([0, 0], [0, 1]).overlaps?(GeometricSegment.new_by_arrays([0, 2], [0, 3]))).to eq(false)
+    end
+  end
+
+  describe '#parallel_to?' do
+    it 'to be parallel' do
+      expect(GeometricSegment.new_by_arrays([0, 0], [2, 1]).parallel_to?(GeometricSegment.new_by_arrays([1, 1], [5, 3]))).to eq(true)
+    end
+
+    it 'to be not parallel' do
+      expect(GeometricSegment.new_by_arrays([0, 0], [2, 1]).parallel_to?(GeometricSegment.new_by_arrays([1, 1], [2, 2]))).to eq(false)
+    end
+
+    it 'to be lays on the same line' do
+      expect(GeometricSegment.new_by_arrays([0, 0], [1, 1]).parallel_to?(GeometricSegment.new_by_arrays([2, 2], [3, 3]))).to eq(true)
+    end
+  end
+
+  describe '#to_vector' do
+    it 'to be parallel' do
+      expect(GeometricSegment.new_by_arrays([1, 1], [3, 2]).to_vector).to eq(GeometricVector.new(2, 1))
+    end
+
+    it 'to be not parallel' do
+      expect(GeometricSegment.new_by_arrays([1, 1], [2, 2]).to_vector).to eq(GeometricVector.new(1, 1))
+      expect(GeometricSegment.new_by_arrays([2, 2], [1, 1]).to_vector).to eq(GeometricVector.new(-1, -1))
+    end
+  end
+
+end

data/spec/lib/geometry/geometric_vector_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe GeometricVector do
+  describe '#initialize_by_numbers' do
+    vector = GeometricVector.new(1, 2)
+
+    it 'to be equal' do
+      expect(vector.x).to eq(1)
+      expect(vector.y).to eq(2)
+    end
+
+    it 'to be not equal' do
+      expect(vector.x).not_to eq(3)
+      expect(vector.y).not_to eq(3)
+    end
+  end
+
+  describe '#initialize_by_array' do
+    vector = GeometricVector.new_by_array([1, 2])
+
+    it 'to be equal' do
+      expect(vector.x).to eq(1)
+      expect(vector.y).to eq(2)
+    end
+
+    it 'to be not equal' do
+      expect(vector.x).not_to eq(3)
+      expect(vector.y).not_to eq(3)
+    end
+  end
+
+  describe '#+' do
+    it 'to be the addition of two vectors' do
+      expect(GeometricVector.new(1, 2) + GeometricVector.new(3, 4)).to eq(GeometricVector.new(4, 6))
+    end
+  end
+
+  describe '#-' do
+    it 'to be subtraction of two vectors' do
+      expect(GeometricVector.new(1, 0) - GeometricVector.new(3, 4)).to eq(GeometricVector.new(-2, -4))
+    end
+  end
+
+  describe '#*' do
+    it 'to be multipal of a point by scalar' do
+      expect(GeometricVector.new(1, 2) * -2).to eq(GeometricVector.new(-2, -4))
+    end
+
+    it 'to be multipal of a point by vector' do
+      expect(-2 * GeometricVector.new(1, 2)).to eq(GeometricVector.new(-2, -4))
+    end
+  end
+
+  describe '#collinear_with?' do
+    it 'to be collinear' do
+      expect(GeometricVector.new(1, 2).collinear_with?GeometricVector.new(2, 4)).to eq(true)
+    end
+
+    it 'to be not collinear' do
+      expect(GeometricVector.new(1, 2).collinear_with?GeometricVector.new(1, 1)).to eq(false)
+    end
+
+    it 'to be oppositely directed' do
+      expect(GeometricVector.new(2, 2).collinear_with?GeometricVector.new(-2, -2)).to eq(true)
+    end
+  end
+
+  describe '#cross_product' do
+    it 'to be positive' do
+      expect(GeometricVector.new(1, 0).cross_product(GeometricVector.new(0, 1))).to eq(1)
+    end
+
+    it 'to be negative' do
+      expect(GeometricVector.new(0, 1).cross_product(GeometricVector.new(1, 0))).to eq(-1)
+    end
+
+    it 'to be zero' do
+      expect(GeometricVector.new(1, 1).cross_product(GeometricVector.new(-2, -2))).to eq(0)
+    end
+
+    it 'to be unnormalized' do
+      expect(GeometricVector.new(1, 1).cross_product(GeometricVector.new(-2, 2))).to eq(4)
+    end
+  end
+
+  describe '#scalar_product' do
+    it 'to be perpendicular' do
+      expect(GeometricVector.new(1, 1).scalar_product(GeometricVector.new(-1, 1))).to eq(0)
+    end
+
+    it 'to be collinear' do
+      expect(GeometricVector.new(1, 1).scalar_product(GeometricVector.new(-2, -2))).to eq(-4)
+    end
+
+    it 'to be inclined' do
+      expect(GeometricVector.new(1, 1).scalar_product(GeometricVector.new(0, 1))).to eq(1)
+    end
+  end
+
+  describe '#modulus' do
+    it 'to be parallel to axis' do
+      expect(GeometricVector.new(0, 1).modulus).to eq(1)
+      expect(GeometricVector.new(1, 0).modulus).to eq(1)
+    end
+
+    it 'to be inclined' do
+      expect(GeometricVector.new(1, 1).modulus).to eq(1.4142135623730951)
+    end
+  end
+end

data/spec/lib/statistics/statistics_spread_spec.rb

@@ -0,0 +1,219 @@
+require 'spec_helper'
+
+describe StatisticalSpread do
+  describe '#sum' do
+    it 'to be the sum of array values' do
+      expect(StatisticalSpread.new([1,2,6]).sum).to eq(9)
+    end
+
+    it 'to be a block passed' do
+      expect(StatisticalSpread.new([1,2,6]).sum{ |x| x * 2 }).to eq(18)
+    end
+
+    it 'to be 0 if empty' do
+      expect(StatisticalSpread.new([]).sum).to eq(0)
+    end
+  end
+
+  describe "#mean" do
+    it "to be the sum of array values divided by number of array values" do
+      expect(StatisticalSpread.new([1,2,6]).mean).to eq(3)
+    end
+
+    it "to be nil if empty" do
+      expect(StatisticalSpread.new([]).mean).to be_nil
+    end
+  end
+
+  describe '#median' do
+    it 'to be the value lying at the midpoint of the array' do
+      expect(StatisticalSpread.new([1,2,6]).median).to eq(2)
+    end
+
+    it 'to be the mean of the two midpoint values if the array length is even' do
+      expect(StatisticalSpread.new([1,2,3,6]).median).to eq(2.5)
+    end
+
+    it 'to be nil if empty' do
+      expect(StatisticalSpread.new([]).median).to be_nil
+    end
+  end
+
+  describe '#mode' do
+    it 'to be the most frequent value' do
+      expect(StatisticalSpread.new([1,1,2,46]).mode).to eq(1)
+    end
+
+    it 'to be the first value if there is only one' do
+      expect(StatisticalSpread.new([3.5]).mode).to eq(3.5)
+    end
+
+    it 'to be nil if nil if there is no most frequent value' do
+      expect(StatisticalSpread.new([1,2,3]).mode).to be_nil
+    end
+
+    it 'to be nil if empty' do
+      expect(StatisticalSpread.new([]).mode).to be_nil
+    end
+  end
+
+  describe '#range' do
+    it 'to be the mean squared deviation of the sample (n - 1 denominator)' do
+      expect(StatisticalSpread.new([1,2,6]).range).to eq(5)
+    end
+
+    it 'to be nil if empty' do
+      expect(StatisticalSpread.new([]).range).to be_nil
+    end
+  end
+
+  describe '#max' do
+    it 'to be the highest value' do
+      expect(StatisticalSpread.new([1,2,6]).max).to eq(6)
+    end
+
+    it 'to be nil if empty' do
+      expect(StatisticalSpread.new([]).max).to be_nil
+    end
+  end
+
+  describe '#min' do
+    it 'to be the lowest value' do
+      expect(StatisticalSpread.new([1,2,6]).min).to eq(1)
+    end
+
+    it 'to be nil if empty' do
+      expect(StatisticalSpread.new([]).min).to be_nil
+    end
+  end
+
+  describe '#percentile_from_value' do
+    it 'to be the precise percentile of each value' do
+      data = [95.1772, 95.1567, 95.1937, 95.1959, 95.1442, 95.061, 95.1591, 95.1195,95.1065, 95.0925, 95.199, 95.1682]
+      percentiles = [0,9,17,25,34,42,50,59,67,75,84,92]
+      stats = StatisticalSpread.new(data)
+      data.sort.each_with_index do |datum, i|
+        expect(stats.percentile_from_value(datum)).to eq(percentiles[i])
+      end
+    end
+
+    it 'to be nil if empty' do
+      expect(StatisticalSpread.new([]).percentile_from_value(1)).to be_nil
+    end
+  end
+
+  describe '#value_from_percentile' do
+    it 'to be the precise percentile of each value' do
+      data = [95.1772, 95.1567, 95.1937, 95.1959, 95.1442, 95.061, 95.1591, 95.1195,95.1065, 95.0925, 95.199, 95.1682]
+      percentiles = [0,10,20,30,40,50,60,70,80,90]
+      values = [95.061,95.1065,95.1195,95.1442,95.1567,95.1591,95.1772,95.1937,95.1959,95.199]
+      stats = StatisticalSpread.new(data)
+      percentiles.sort.each_with_index do |percentile, i|
+        expect(stats.value_from_percentile(percentile)).to eq(values[i])
+      end
+    end
+
+    it 'to be nil if empty' do
+      expect(StatisticalSpread.new([]).value_from_percentile(1)).to be_nil
+    end
+  end
+
+  describe '#variance' do
+    it 'to be the mean squared deviation of the sample (n - 1 denominator)' do
+      expect(StatisticalSpread.new([1,2,6]).variance).to eq(7)
+    end
+
+    it 'to be nil if empty' do
+      expect(StatisticalSpread.new([]).variance).to be_nil
+    end
+  end
+
+  describe '#population_variance' do
+    it 'to be the mean squared deviation of the sample' do
+      expect(StatisticalSpread.new([1,2,3,4]).population_variance).to eq(1.25)
+    end
+
+    it 'to be nil if empty' do
+      expect(StatisticalSpread.new([]).population_variance).to be_nil
+    end
+  end
+
+  describe '#standard_deviation' do
+    it 'to be the square root of the #variance' do
+      expect(StatisticalSpread.new([1,2,6]).standard_deviation).to eq(2.6457513110645907)
+    end
+
+    it 'to be nil for single element arrays' do
+      expect(StatisticalSpread.new([1]).standard_deviation).to be_nil
+    end
+
+    it 'to be nil if empty' do
+      expect(StatisticalSpread.new([]).standard_deviation).to be_nil
+    end
+  end
+
+  describe '#relative_standard_deviation' do
+    it 'to be 0 for constant values' do
+      expect(StatisticalSpread.new([100,100,100]).relative_standard_deviation).to eq(0)
+    end
+
+    it 'to be the #population_standard_deviation divided by the mean * 100' do
+      expect(StatisticalSpread.new([90,100,110]).relative_standard_deviation).to be_within(0.01).of(8.16)
+      expect(StatisticalSpread.new([1,5,6,8,10,40,65,88]).relative_standard_deviation).to be_within(0.01).of(110.41)
+    end
+
+    it 'to be nil if empty' do
+      expect(StatisticalSpread.new([]).relative_standard_deviation).to be_nil
+    end
+  end
+
+  describe '#population_standard_deviation' do
+    it 'to be the square root of the #population_variance' do
+      expect(StatisticalSpread.new([1,2,6]).population_standard_deviation).to eq(2.160246899469287)
+    end
+
+    it 'to be 0 for single element arrays' do
+      expect(StatisticalSpread.new([1]).population_standard_deviation).to eq(0)
+    end
+
+    it 'to be nil if empty' do
+      expect(StatisticalSpread.new([]).population_standard_deviation).to be_nil
+    end
+  end
+
+  describe '#skewness' do
+    it 'to be the measure of skewness of the data as close to 0 when not skewed' do
+      expect(StatisticalSpread.new([1,3,5,3,1]).skewness).to eq(0.30734449954312965)
+    end
+
+    it 'to be the measure of skewness of the data as high when skewed' do
+      expect(StatisticalSpread.new([50,10,1,1,1]).skewness).to eq(1.2374536958450908)
+    end
+
+    it 'to be 0 if only one element' do
+      expect(StatisticalSpread.new([1]).skewness).to eq(0)
+    end
+
+    it 'to be nil if empty' do
+      expect(StatisticalSpread.new([]).skewness).to be_nil
+    end
+  end
+
+  describe '#kurtosis' do
+    it 'to be the measure of kurtosis of the data as close to 0 when not skewed' do
+      expect(StatisticalSpread.new([1,3,5,3,1]).kurtosis).to eq(1.477551020408163)
+    end
+
+    it 'to be the measure of skewness of the data as high when skewed' do
+      expect(StatisticalSpread.new([99,10,1,1,1]).kurtosis).to eq(2.56586117539186)
+    end
+
+    it 'to be 0 if only one element' do
+      expect(StatisticalSpread.new([1]).kurtosis).to eq(0)
+    end
+
+    it 'to be nil if empty' do
+      expect(StatisticalSpread.new([]).kurtosis).to be_nil
+    end
+  end
+end