flash_math 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ce3ea8e05a64b4e3c3d6b526609c6f0c83ac19ee
+  data.tar.gz: d45484f49006f327b0aed556f69264c46b72861e
+SHA512:
+  metadata.gz: a1d77d3c127d7e1ce4fa407b0918e8e54f84ff45c3c4357b45e4b682b5aab3c3ab657e51212814806461fc3295281234b558372afe372137096c90f99ecf63a9
+  data.tar.gz: b88290c99fe047570a92e1b611aae66a3a3f8607b764a967ba813aeafe914379a779893374e6dd6f8c732961e9f1402e1b850578d936eb40803824b4ca932f05

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,4 @@
+--order random
+--colour
+--backtrace
+--format progress

data/.travis.yml

@@ -0,0 +1,13 @@
+before_install:
+  - sudo apt-get install libxml2-dev
+cache: bundler
+language: ruby
+notifications:
+  email:
+    recipients:
+      - j.gomez@drexed.com
+    on_failure: change
+    on_success: never
+rvm:
+  - ruby-head
+script: 'bundle exec rake'

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in flash_math.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Juan Gomez
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,187 @@
+# Flash Math
+
+[![Build Status](https://travis-ci.org/drexed/flash_math.svg?branch=master)](https://travis-ci.org/drexed/flash_math)
+[![Coverage Status](https://coveralls.io/repos/drexed/flash_math/badge.png)](https://coveralls.io/r/drexed/flash_math)
+[![Code Climate](https://codeclimate.com/github/drexed/flash_math.png)](https://codeclimate.com/github/drexed/flash_math)
+
+Flash Validators is a collection of advance math modules.
+
+Currently supported calculations: geometry and statistics.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'flash_math'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install flash_math
+
+## Usage
+
+### Geometry
+
+####Geometrical Point:####
+Use the following methods to generate geometical point:
+`GeometricPoint.new(x, y)` and `GeometricPoint.new_by_array(array)`
+
+Use the following methods to generate geometical point data:
+`advance_by(vector)` and `to_vector`
+
+```ruby
+geo_point = GeometricPoint.new(1, 2)
+geo_vector = GeometricVector.new(2, -1)
+
+geo_point.x #=> 1
+geo_point.2 #=> 2
+geo_point.advance_by(geo_vector) #=> [3, 1]
+```
+
+####Geometrical Vector:####
+Use the following methods to generate geometical vector:
+`GeometricVector.new(x, y)` and `GeometricVector.new_by_array(array)`
+
+Use the following methods to generate geometical vector data:
+`modulus`, `collinear_with?(vector)`, `cross_product(vector)`, and `scalar_product(vector)`
+
+```ruby
+geo_vector1	= GeometricVector.new(1, 2)
+geo_vector2 = GeometricVector.new(2, 4)
+
+geo_vector1.x #=> 1
+geo_vector1.y #=> 2
+geo_vector1.modulus #=> 2.23606797749979
+geo_vector1.collinear_with?(geo_vector2) #=> true
+geo_vector1.cross_product(geo_vector2) #=> 10
+geo_vector1.scalar_product(geo_vector2) #=> 0
+```
+
+####Geometrical Distance:####
+Use the following method to generate geometical distance:
+`GeometricDistance.new(x, y)` and `GeometricDistance.new_by_arrays(array)`
+
+Use the following methods to generate geometical distance data:
+`distance`, `midpoint`, and `midpoint_distance`
+
+```ruby
+geo_distance = GeometricalDistance.new_by_array([1, 1], [2, 4])
+
+geo_distance.distance #=> 1
+geo_distance.midpoint_distance #=> 0.5
+geo_distance.midpoint #=> [2, 3]
+```
+
+####Geometrical Line:####
+Use the following method to generate geometical line:
+`GeometricLine.new(point1, point2)` and `GeometricLine.new_by_arrays(point1, point2)`
+
+Use the following methods to generate geometical line data:
+`angel_to`, `distance_to`, `horizontal?`, `vertical?`, `intersect_x`, `parallel_to?`, `slope`, `x_intercept`, and `y_intercept`
+
+```ruby
+geo_line1 = GeometricLine.new_by_arrays([0, 0], [1, 1])
+geo_line2 = GeometricLine.new_by_arrays([0, 0], [1, -1])
+point = GeometricPoint.new(3, 4)
+
+geo_line1.angle_to(geo_line2) #=> 1.5707963267948966
+geo_line1.distance_to(point) #=> 0.7071067811865475
+geo_line1.horizontal? #=> false
+geo_line1.vertical? #=> false
+geo_line1.intersect_x(geo_line2) #=> 0.0
+geo_line1.parallel_to?(geo_line2) #=> false
+geo_line1.slope #=> 1.0
+geo_line1.x_intercept #=> 0.0
+geo_line1.y_intercept #=> 0.0
+```
+
+####Geometrical Segment:####
+Use the following method to generate geometical segment:
+`GeometricSegment.new(point1, point2)` and `GeometricSegment.new_by_arrays(point1, point2)`
+
+Use the following methods to generate geometical segment data:
+`bottommost_endpoint`, `leftmost_endpoint`, `rightmost_endpoint`, `topmost_endpoint`, `contains_point?`, `distance_to?`, `intersection_point_with`, `intersects_with?`, `length`, `lies_on_one_line_with?`, `overlaps?`, `parallel_to?`, and `to_vector`
+
+```ruby
+geo_segment1 = GeometricSegment.new_by_arrays([0, 0], [1, 1])
+geo_segment2 = GeometricSegment.new_by_arrays([2, 2], [3, 3])
+point = GeometricPoint.new(0, 1)
+
+geo_segment1.bottommost_endpoint #=> [0, 0]
+geo_segment1.leftmost_endpoint #=> [0, 0]
+geo_segment1.rightmost_endpoint #=> [1, 1]
+geo_segment1.topmost_endpoint #=> [1, 1]
+geo_segment1.contains_point?(point) #=> true
+geo_segment1.distance_to?(point) #=> 0.7071067811865476
+geo_segment1.intersection_point_with(geo_segment2) #=> GeometricSegmentsDoNotIntersect error
+geo_segment1.intersects_with?(geo_segment2) #=> false
+geo_segment1.length #=> 1.4142135623730951
+geo_segment1.lies_on_one_line_with?(geo_segment2) #=> true
+geo_segment1.overlaps?(geo_segment2) #=> false
+geo_segment1.parallel_to?(geo_segment2) #=> true
+geo_segment1.to_vector #=> [0, 0]
+```
+
+####Geometrical Bounding Box:####
+Use the following method to generate geometical bounding box:
+`GeometricBoundingBox.new(point1, point2)` and `GeometricBoundingBox.new_by_arrays(point1, point2)`
+
+Use the following methods to generate geometical segment data:
+`contains?` and `diagonal`
+
+```ruby
+geo_bounding_box = GeometricBoundingBox.new_by_arrays([-1, -1], [1, 1])
+
+geo_bounding_box.contains?(GeometricPoint.new(0, 0)) #=> true
+```
+
+####Geometrical Polygon:####
+Use the following method to generate geometical polygon:
+`GeometricBoundingBox.new(vertices)`
+
+Use the following methods to generate geometical polygon data:
+`area`, `bounding_box`, `contains`, and `edges`
+
+```ruby
+geo_polygon = GeometricPolygon.new([GeometricPoint.new(0,0), GeometricPoint.new(1,1), GeometricPoint.new(0,1)]).area
+
+geo_polygon.area #=> 0.5
+geo_polygon.contains?(GeometricPoint.new(0.5, 0.5)) #=> true
+```
+
+### Statistics
+
+####Statistical Spread:####
+Use the following methods to generate the statistical spreads of an array:
+
+`mean`, `median`, `mean`, `range`, `min`, `max`, `percentile_from_value`, `value_from_percentile`, `variance`, `standard_deviation`, `relative_standard_deviation`, `skewness`, and `kurtosis`
+
+```ruby
+stats_spread = StatisticalSpread.new([1,1,2,3,10])
+
+stats_spread.mean #=> 3.4
+stats_spread.median #=> 2
+stats_spread.mode #=> 1
+stats_spread.range #=> 9
+stats_spread.min #=> 1
+stats_spread.max #=> 10
+stats_spread.percentile_from_value(10) #=> 80
+stats_spread.value_from_percentile(60) #=> 3
+stats_spread.variance #=> 14.299999999999999
+stats_spread.standard_deviation #=> 3.7815340802378072
+stats_spread.relative_standard_deviation #=> 99.47961485463391
+stats_spread.skewness #=> 1.188328915820243
+stats_spread.kurtosis #=> 2.405613966453127
+```
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/flash_math/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/flash_math.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'flash_math/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "flash_math"
+  spec.version       = FlashMath::VERSION
+  spec.authors       = ["Juan Gomez"]
+  spec.email         = ["j.gomez@drexed.com"]
+  spec.summary       = %q{Advance math modules.}
+  spec.description   = %q{Modules for advance math calculations.}
+  spec.homepage      = "https://github.com/drexed/flash_math"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport"
+  spec.add_dependency "memoist"
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "coveralls"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.0.0.beta"
+end

data/lib/flash_math.rb

@@ -0,0 +1,3 @@
+require "flash_math/version"
+require 'flash_math/modules/geometry'
+require 'flash_math/modules/statistics'

data/lib/flash_math/modules/geometry.rb

@@ -0,0 +1,10 @@
+require 'active_support/core_ext/module/delegation'
+require 'memoist'
+require 'flash_math/modules/geometry/geometric_bounding_box'
+require 'flash_math/modules/geometry/geometric_distance'
+require 'flash_math/modules/geometry/geometric_line'
+require 'flash_math/modules/geometry/geometric_point'
+require 'flash_math/modules/geometry/geometric_point_in_polygon'
+require 'flash_math/modules/geometry/geometric_polygon'
+require 'flash_math/modules/geometry/geometric_segment'
+require 'flash_math/modules/geometry/geometric_vector'

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

@@ -0,0 +1,16 @@
+class GeometricBoundingBox < Struct.new(:leftbottom, :righttop)
+
+  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 diagonal
+    GeometricSegment.new(leftbottom, righttop)
+  end
+
+  def contains?(point)
+    point.x.between?(leftbottom.x, righttop.x) && point.y.between?(leftbottom.y, righttop.y)
+  end
+
+end

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

@@ -0,0 +1,20 @@
+class GeometricDistance < 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 distance
+    Math.hypot(point1.x - point2.x, point1.y - point2.y)
+  end
+
+  def midpoint
+    [((point2.x + point1.x) / 2), ((point2.y + point1.y) / 2)]
+  end
+
+  def midpoint_distance
+    distance / 2
+  end
+
+end

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

@@ -0,0 +1,87 @@
+class GeometricLine < 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 angle_to(another_line)
+    sa = Math::atan(slope)
+    oa = Math::atan(another_line.slope)
+    (sa-oa).abs
+  end
+
+  def distance_to(point)
+    x0 = point.x
+    y0 = point.y
+
+    x1 = point1.x
+    x2 = point2.x
+    y1 = point1.y
+    y2 = point2.y
+
+    (((x2-x1)*(y1-y0))-((x1-x0)*(y2-y1))).abs/Math.sqrt((x2-x1)**2+(y2-y1)**2)
+  end
+
+  def horizontal?
+    slope == 0
+  end
+
+  def intersect_x(another_line)
+    if vertical? and another_line.vertical?
+      if x_intercept == another_line.x_intercept
+        return x_intercept
+      else
+        return nil
+      end
+    end
+
+    return nil if horizontal? and another_line.horizontal?
+
+    return x_intercept if vertical?
+    return another_line.x_intercept if another_line.vertical?
+
+    d_intercept = another_line.y_intercept - y_intercept
+    d_slope = slope - another_line.slope
+
+    d_intercept / d_slope
+  end
+
+  def parallel_to?(another_line)
+    return true if slope.infinite? and another_line.slope.infinite?
+
+    slope == another_line.slope
+  end
+
+  def slope
+    dy = Float(point2.y - point1.y)
+    dx = Float(point2.x - point1.x)
+
+    return 0.0 if dy == 0
+
+    dy / dx
+  end
+
+  def vertical?
+    if slope.infinite?
+      return true
+    else
+      return false
+    end
+  end
+
+  def x_intercept
+    return nil if horizontal?
+
+    dx = point1.y / slope
+    point1.x - dx
+  end
+
+  def y_intercept
+    return nil if vertical?
+
+    dy = point1.x * slope
+    point1.y - dy
+  end
+
+end