numscaler 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 331c09c6168e5869643abc1cb61b2add72653db9
+  data.tar.gz: 160bedb49e76c394081108b17d6b8b5a39305f34
+SHA512:
+  metadata.gz: a586ebb9b32110e06ad3f10ab6618381c946c10416801dc62057f9aef4ed4e530f960a31328a11bbc2370d6e31b3278e8714fd14a79848096bcbd2f1325c3771
+  data.tar.gz: 3af7b7301e3068832b98d05fe225507b601cff23718592e1fe07e17b4eadd6a198f228fb9c9f2bb5cfc7631308fa5f97b168078d3e7d6f0d28a5b530f80b1564

data/.document

@@ -0,0 +1,2 @@
+- 
+LICENSE.txt

data/.gitignore

@@ -0,0 +1,3 @@
+doc/
+pkg/
+.yardoc/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--colour 

data/.yardopts

@@ -0,0 +1,5 @@
+--title "NumScaler Documentation"
+--markup markdown
+--charset utf-8
+--protected
+--private

data/LICENSE.txt

@@ -0,0 +1,23 @@
+Copyright (c) 2014, Piotr S. Staszewski
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without 
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this 
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, 
+   this list of conditions and the following disclaimer in the documentation 
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,104 @@
+# NumScaler
+
+* [Homepage](https://github.com/drbig/numscaler)
+* [Documentation](http://rubydoc.info/gems/numscaler/frames)
+
+## Description
+
+NumScaler will convert for you numbers between ranges using simple linear 
+interpolation. In other words it will scale a number form its source range to a 
+corresponding number within the target range. And vice-versa.
+
+It has three clamping modes that are applied to the input number before 
+conversion, and only if that number is outside its range:
+
+  * `:strict` - will raise an exception (*default*)
+  * `:clamp`  - will cut the number at the edges of the range (e.g. to min or 
+max)
+  * `:cycle`  - will treat the range as circular (think `number % range`)
+
+It should work correctly for any combination of Integer and Float ranges (note 
+that you can't mix numeric types within a single range, as it doesn't make much 
+sense). It expects common-sense on your part, so trying to use it with empty 
+ranges (e.g. `0..0`) is left as undefined (though it might work just as you 
+expect, or not).
+
+All calculations are done internally on `Float`s so there will be inevitable 
+rounding errors. My tests show that the precision is within 14 decimal places, 
+and therefore that is the default rounding.
+
+There is a pretty brute-force test suite. Should work with any Ruby version.
+
+## Examples
+
+Install and run pry/irb:
+
+    $ gem install numscaler
+    $ pry
+
+Simple Integer - Integer conversion:
+
+    [1] pry(main)> require 'numscaler'
+    [2] pry(main)> iti = NumScaler.new(0..15, 0..256)
+    [3] pry(main)> iti.from(0)
+    => 0
+    [4] pry(main)> iti.from(7)
+    => 119
+    [5] pry(main)> iti.from(8)
+    => 137
+    [6] pry(main)> iti.to(128)
+    => 8
+    [7] pry(main)> iti.to(255)
+    => 15
+    [8] pry(main)> iti.from(-1)
+    ArgumentError: Number out of range
+
+Integer - Float conversion:
+
+    [9] pry(main)> itf = NumScaler.new(0..7, 0.0..16.0)
+    [10] pry(main)> itf.from(2)
+    => 4.57142857142857
+    [11] pry(main)> itf.from(7)
+    => 16.0
+    [12] pry(main)> itf.to(4)
+    => 2
+    [13] pry(main)> itf.to(4.234)
+    => 2
+
+Float - Float conversion:
+
+    [14] pry(main)> ftf = NumScaler.new(-2.5..2.5, -5.0..5.0)
+    [15] pry(main)> ftf.from(-2.0)
+    => -4.0
+    [16] pry(main)> ftf.to(-4.0)
+    => -2.0
+    [17] pry(main)> # deg - rad conversion
+    [18] pry(main)> ftf = NumScaler.new(0.0..180.0, 0.0..Math::PI)
+    [19] pry(main)> ftf.from(45.0)
+    => 0.78539816339745
+    [20] pry(main)> ftf.to(1.57079633)
+    => 90.0000001836389
+
+Clamping examples:
+
+    [21] pry(main)> ftf = NumScaler.new(0.0..4.0, -2.5..2.5, :clamp)
+    [22] pry(main)> ftf.from(-1.0)
+    => -2.5
+    [23] pry(main)> ftf.from(5.0)
+    => 2.5
+    [24] pry(main)> ftf.to(15.0)
+    => 4.0
+    
+    [25] pry(main)> ftf = NumScaler.new(0.0..4.0, -2.5..2.5, :cycle)
+    [26] pry(main)> ftf.from(-1.0)
+    => 1.25
+    [27] pry(main)> ftf.from(5.0)
+    => -1.25
+    [28] pry(main)> ftf.to(15.0)
+    => 2.0
+
+## Copyright
+
+Copyright (c) 2014 Piotr S. Staszewski
+
+Absolutely no warranty. See {file:LICENSE.txt} for details.

data/Rakefile

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'rake'
+
+begin
+  gem 'rubygems-tasks', '~> 0.2'
+  require 'rubygems/tasks'
+
+  Gem::Tasks.new
+rescue LoadError => e
+  warn e.message
+  warn "Run `gem install rubygems-tasks` to install Gem::Tasks."
+end
+
+begin
+  gem 'rspec', '~> 2.4'
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new
+rescue LoadError => e
+  task :spec do
+    abort "Please run `gem install rspec` to install RSpec."
+  end
+end
+
+task :test    => :spec
+task :default => :spec
+
+begin
+  gem 'yard', '~> 0.8'
+  require 'yard'
+
+  YARD::Rake::YardocTask.new  
+rescue LoadError => e
+  task :yard do
+    abort "Please run `gem install yard` to install YARD."
+  end
+end
+task :doc => :yard

data/lib/numscaler.rb

@@ -0,0 +1,87 @@
+# encoding: utf-8
+
+# See {file:README.md} for practical examples.
+class NumScaler
+  # NumScaler version string
+  VERSION = '0.0.4'
+  # Epsilon defines rounding precision
+  EPSILON = 14
+  # Available clamping modes
+  MODES = [:strict, :cycle, :clamp]
+
+  # Current clamping modes:
+  #
+  #   * `:strict` - raise ArgumentError for out-of-range number (*default*)
+  #   * `:clamp`  - clamp number to source range
+  #   * `:cycle`  - treat range as a circle of values
+  #
+  # Precision defines number of significant decimal digits for rounding.
+  #
+  # @param from [Range] source range
+  # @param to [Range] target range
+  # @param mode [Symbol] clamping mode
+  # @param precision [Float] rounding precision
+  def initialize(from, to, mode = MODES.first, precision = EPSILON)
+    raise ArgumentError, 'Unknown mode' unless MODES.member? mode
+    raise ArgumentError, 'Precision out of ranger' unless precision > 0
+
+    @mode = mode
+    @prec = precision
+
+    @src = { :orig  => from.min,
+             :range => from.max.to_f - from.min.to_f,
+             :max   => from.max.to_f,
+             :min   => from.min.to_f }
+    @tgt = { :orig  => to.min,
+             :range => to.max.to_f - to.min.to_f,
+             :max   => to.max.to_f,
+             :min   => to.min.to_f }
+  end
+
+  # Convert number from source to target
+  #
+  # @param num [Numeric]
+  # @return [Numeric]
+  def from(num); calc(num, @src, @tgt); end
+
+  # Convert number from target to source
+  #
+  # @param num [Numeric]
+  # @return [Numeric]
+  def to(num);   calc(num, @tgt, @src); end
+
+  private
+  # Perform actual calculation:
+  #
+  #   1. First check and if necessary apply clamping
+  #   1. Then convert between ranges
+  #   1. Lastly check how to exactly return the result and do so
+  #
+  # @param num [Numeric] number to convert
+  # @param a [Hash] source range data
+  # @param b [Hash] target range data
+  # @return [Numeric]
+  def calc(num, a, b)
+    num = num.to_f
+
+    unless num.between?(a[:min], a[:max])
+      num = case @mode
+            when :cycle
+              ((num - a[:min]) % (a[:range])) + a[:min]
+            when :clamp
+              num > a[:max] ? a[:max] : a[:min]
+            when :strict
+              raise ArgumentError, 'Number out of range'
+            end
+    end
+
+    res = (((num - a[:min]) * b[:range]) / a[:range]) + b[:min]
+
+    case b[:orig]
+    when Integer
+      res.round
+    else
+      res.round(@prec)
+    end
+  end
+end

data/numscaler.gemspec

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require File.expand_path('../lib/numscaler', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = 'numscaler'
+  gem.version       = NumScaler::VERSION
+  gem.date          = Time.now
+
+  gem.summary       = 'Easily convert numbers between different ranges'
+  gem.description   = 'Convert numbers e.g. between 0.0 - 1.0 and 0.0 - Math::PI and vice-versa.'
+  gem.license       = 'BSD'
+  gem.authors       = ['Piotr S. Staszewski']
+  gem.email         = 'p.staszewski@gmail.com'
+  gem.homepage      = 'https://github.com/drbig/numscaler'
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = gem.files.grep(%r{^spec/})
+  gem.require_paths = ['lib']
+
+  gem.add_development_dependency 'rspec', '~> 2.4'
+  gem.add_development_dependency 'rubygems-tasks', '~> 0.2'
+  gem.add_development_dependency 'yard', '~> 0.8'
+end

data/spec/numscaler_spec.rb

@@ -0,0 +1,183 @@
+# encoding: utf-8
+
+require 'rspec'
+require 'numscaler'
+
+describe NumScaler do
+  it 'should have a VERSION constant' do
+    NumScaler::VERSION.should_not be_empty
+  end
+
+  it 'should have an EPSILON constant' do
+    NumScaler::EPSILON.should > 0
+  end
+
+  it 'should define clamping MODES' do
+    NumScaler::MODES.should_not be_empty
+  end
+
+  it 'should check arguments' do
+    lambda {
+      NumScaler.new(1..8, 16..32, :nonext)
+    }.should raise_error(ArgumentError)
+  end
+
+  context 'should work with Integer <=> Integer ranges and' do
+    it 'should convert from' do
+      scaler = NumScaler.new(1..8, 16..32)
+
+      scaler.from(1).should eq 16
+      scaler.from(4).should eq 23
+      scaler.from(8).should eq 32
+    end
+
+    it 'should convert to' do
+      scaler = NumScaler.new(1..8, -32..32)
+
+      scaler.to(-32).should eq 1
+      scaler.to(  0).should eq 5
+      scaler.to( 32).should eq 8
+    end
+  end
+
+  context 'should work with Integer <=> Float ranges and' do
+    before(:all) do
+      @prec = NumScaler::EPSILON
+    end
+
+    it 'should convert from' do
+      scaler = NumScaler.new(0..15, 0.0..Math::PI)
+      scaler.from( 0  ).should eq 0.0
+      scaler.from( 7.5).should eq (Math::PI/2.0).round(@prec)
+      scaler.from(15  ).should eq Math::PI.round(@prec)
+
+      scaler = NumScaler.new(-15..15, 0.0..Math::PI)
+      scaler.from(-15).should eq 0.0
+      scaler.from(  0).should eq (Math::PI/2.0).round(@prec)
+      scaler.from( 15).should eq Math::PI.round(@prec)
+    end
+
+    it 'should convert to' do
+      scaler = NumScaler.new(0..15, 0.0..Math::PI)
+      scaler.to(0.0).should          eq  0
+      scaler.to(Math::PI/2.0).should eq  7
+      scaler.to(Math::PI).should     eq 15
+
+      scaler = NumScaler.new(-15..15, 0.0..Math::PI)
+      scaler.to(0.0).should          eq -15
+      scaler.to(Math::PI/2.0).should eq   0
+      scaler.to(Math::PI).should     eq  15
+    end
+  end
+
+  context 'should work with Float <=> Float ranges and' do
+    before(:all) do
+      @prec = NumScaler::EPSILON
+    end
+
+    it 'should convert from' do
+      scaler = NumScaler.new(0.0..256.0, 0.0..Math::PI)
+      scaler.from(  0.0).should eq 0.0
+      scaler.from( 32.0).should eq (Math::PI/8.0).round(@prec)
+      scaler.from( 64.0).should eq (Math::PI/4.0).round(@prec)
+      scaler.from(128.0).should eq (Math::PI/2.0).round(@prec)
+      scaler.from(256.0).should eq Math::PI.round(@prec)
+
+      scaler = NumScaler.new(0.0..256.0, -Math::PI..Math::PI)
+      scaler.from(  0.0).should eq -Math::PI.round(@prec)
+      scaler.from( 64.0).should eq (-Math::PI/2.0).round(@prec)
+      scaler.from(128.0).should eq 0.0
+      scaler.from(192.0).should eq (Math::PI/2.0).round(@prec)
+      scaler.from(256.0).should eq Math::PI.round(@prec)
+    end
+
+    it 'should convert to' do
+      scaler = NumScaler.new(0.0..256.0, 0.0..Math::PI)
+      scaler.to(0.0).should          eq   0.0
+      scaler.to(Math::PI/8.0).should eq  32.0
+      scaler.to(Math::PI/4.0).should eq  64.0
+      scaler.to(Math::PI/2.0).should eq 128.0
+      scaler.to(Math::PI).should     eq 256.0
+
+      scaler = NumScaler.new(0.0..256.0, -Math::PI..Math::PI)
+      scaler.to(-Math::PI).should     eq   0.0
+      scaler.to(-Math::PI/2.0).should eq  64.0
+      scaler.to(0.0).should           eq 128.0
+      scaler.to(Math::PI/2.0).should  eq 192.0
+      scaler.to(Math::PI).should      eq 256.0
+    end
+  end
+
+  context 'should :strict clamp properly' do
+    it 'with Integer ranges' do
+      scaler = NumScaler.new(1..8, -5..5)
+      lambda { scaler.from(-1) }.should raise_error ArgumentError
+      lambda { scaler.from( 0) }.should raise_error ArgumentError
+      lambda { scaler.from( 9) }.should raise_error ArgumentError
+      lambda { scaler.to(-6) }.should raise_error ArgumentError
+      lambda { scaler.to( 6) }.should raise_error ArgumentError
+    end
+
+    it 'with Float ranges' do
+      scaler = NumScaler.new(0.5..1.25, -5.0..5.0)
+      lambda { scaler.from(0.42 ) }.should raise_error ArgumentError
+      lambda { scaler.from(0.499) }.should raise_error ArgumentError
+      lambda { scaler.from(1.26 ) }.should raise_error ArgumentError
+      lambda { scaler.from(1.3  ) }.should raise_error ArgumentError
+      lambda { scaler.to(-5.1) }.should raise_error ArgumentError
+      lambda { scaler.to( 5.1) }.should raise_error ArgumentError
+    end
+  end
+
+  context 'should :clamp clamp properly' do
+    it 'with Integer ranges' do
+      scaler = NumScaler.new(1..8, -32..32, :clamp)
+      scaler.from(-1).should eq -32
+      scaler.from( 0).should eq -32
+      scaler.from( 9).should eq  32
+      scaler.to(-33).should eq 1
+      scaler.to(  0).should eq 5
+      scaler.to( 33).should eq 8
+    end
+
+    it 'with Float ranges' do
+      scaler = NumScaler.new(1.0..8.0, -32.0..32.0, :clamp)
+      scaler.from(0.89).should eq -32.0
+      scaler.from(8.01).should eq  32.0
+      scaler.to(-32.1).should eq 1.0
+      scaler.to( 32.1).should eq 8.0
+    end
+  end
+
+  context 'should :cycle clamp properly' do
+    it 'with Integer ranges' do
+      scaler = NumScaler.new(1..8, -8..-1, :cycle)
+      scaler.from(-2).should eq -4
+      scaler.from( 0).should eq -2
+      scaler.from( 2).should eq -7
+      scaler.from( 9).should eq -7
+      scaler.to(-9).should eq 7
+      scaler.to( 0).should eq 2
+
+      scaler = NumScaler.new(-5..5, 20..30, :cycle)
+      scaler.from(-8).should eq 27
+      scaler.from(-7).should eq 28
+      scaler.from(-6).should eq 29
+      scaler.from( 6).should eq 21
+      scaler.from( 7).should eq 22
+      scaler.to(18).should eq  3
+      scaler.to(19).should eq  4
+      scaler.to(31).should eq -4
+      scaler.to(41).should eq -4
+    end
+
+    it 'with Float ranges' do
+      scaler = NumScaler.new(-2.5..2.5, 20.0..30.0, :cycle)
+      scaler.from(-6.0).should eq 23.0
+      scaler.from(-2.0).should eq 21.0
+      scaler.from( 0.0).should eq 25.0
+      scaler.from( 3.0).should eq 21.0
+      scaler.from( 6.0).should eq 27.0
+    end
+  end
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: numscaler
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+platform: ruby
+authors:
+- Piotr S. Staszewski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: rubygems-tasks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: Convert numbers e.g. between 0.0 - 1.0 and 0.0 - Math::PI and vice-versa.
+email: p.staszewski@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".document"
+- ".gitignore"
+- ".rspec"
+- ".yardopts"
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/numscaler.rb
+- numscaler.gemspec
+- spec/numscaler_spec.rb
+homepage: https://github.com/drbig/numscaler
+licenses:
+- BSD
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Easily convert numbers between different ranges
+test_files:
+- spec/numscaler_spec.rb