numscaler 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 331c09c6168e5869643abc1cb61b2add72653db9
-  data.tar.gz: 160bedb49e76c394081108b17d6b8b5a39305f34
+  metadata.gz: 7be33f9f41d6a311789c24901c46e282f44577ba
+  data.tar.gz: 14dfbe2d52b7a4535ebc56b1533c0b4fc8877e39
 SHA512:
-  metadata.gz: a586ebb9b32110e06ad3f10ab6618381c946c10416801dc62057f9aef4ed4e530f960a31328a11bbc2370d6e31b3278e8714fd14a79848096bcbd2f1325c3771
-  data.tar.gz: 3af7b7301e3068832b98d05fe225507b601cff23718592e1fe07e17b4eadd6a198f228fb9c9f2bb5cfc7631308fa5f97b168078d3e7d6f0d28a5b530f80b1564
+  metadata.gz: 7fc1433ded6360e54fb7555c19928baa30e89a117b79d31b612ffe60100a919610cc0915ccf8b4b2940c80dd13da890846cbdfcabf87056b68417dac2ba3e23b
+  data.tar.gz: c09f9d90aac10634875d0318ddb3737cab03fbbfea976d918289c2006f81889d33a916e310a5d0ec48ca75ed152951d7827919ee2a66969b0cf4441715e25092

data/.gitignore

@@ -1,3 +1,4 @@
 doc/
 pkg/
 .yardoc/
+.rspec

data/README.md

@@ -29,73 +29,135 @@ and therefore that is the default rounding.
 
 There is a pretty brute-force test suite. Should work with any Ruby version.
 
+## Applications
+
+  * Scaling when graphing
+    ...from `0.0..1.0` to `0..(height-1)`
+  * Bounded unit conversion
+    ...from Celsius to Fahrenheit, Centimeters to Inches
+  * Circular unit conversion
+    ...from degrees to radians
+  * Value to index mapping
+    ...from `0.0..1.0` to 'very bad' - 'very good'
+
 ## Examples
 
-Install and run pry/irb:
+Install:
 
     $ 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
+
+From the `examples/` directory, first some graphing:
+
+    require 'numscaler'
+    
+    s1 = NumScaler.new(0..64, 0.0..Math::PI*2.0)
+    s2 = NumScaler.new(-1.0..1.0, 0..9)
+    
+    graph = (0..64).to_a.collect do |e|
+      i = s2.from(Math.sin(s1.from(e)))
+      a = [' '] * 10
+      a[i] = '#'
+      a
+    end
+    
+    puts graph.transpose.collect {|e| e.join }
+
+Running it will produce a lovely:
+
+                                                #########            
+                                            ####         ####        
+                                         ###                 ###     
+                                       ##                       ##   
+                                     ##                           ## 
+    ###                           ###                               #
+       ##                       ##                                   
+         ###                 ###                                     
+            ####         ####                                        
+                #########                                            
+
+You can also use it for unit conversion if you wish, like so:
+
+    require 'numscaler'
+    
+    distance = NumScaler.new(0.0..100.0, 0.0..39.3701)
+    temperature = NumScaler.new(-30.0..120.0, -22.0..248.0)
+    angle = NumScaler.new(0.0..90.0, 0.0..Math::PI/2.0)
+    
+    puts 'Distance:'
+    [
+      ['9 mm ammo', 0.9],
+      ['max pin distance in an europlug', 1.86],
+      ['average baguette length', 65.0],
+    ].each do |label, cm|
+      print "#{label} (#{cm} cm) is ".rjust(50)
+      puts distance.from(cm).to_s + ' inch'
+    end
+    
+    puts "\nTemperature:"
+    [
+      ['siberian cold', -25.0],
+      ['minimal workplace temp', 18.0],
+      ['usually comfortable', 25.0],
+      ['Polish summer', 35.0],
+    ].each do |label, cent|
+      print "#{label} (#{cent} Celsius) is ".rjust(50)
+      puts temperature.from(cent).to_s + ' Fahrenheit'
+    end
+    
+    puts "\nAngle:"
+    [
+      ['human FOV blind spot width', 5.5],
+      ['decent slope', 23.0],
+      ['in the corner', 90.0],
+    ].each do |label, deg|
+      print "#{label} (#{deg} degrees) is ".rjust(50)
+      puts angle.from(deg).to_s + ' radians'
+    end
+
+Which will produce:
+
+    Distance:
+                                9 mm ammo (0.9 cm) is 0.3543309 inch
+          max pin distance in a europlug (1.86 cm) is 0.73228386 inch
+                 average baguette length (65.0 cm) is 25.590565 inch
+    
+    Temperature:
+                     siberian cold (-25.0 Celsius) is -13.0 Fahrenheit
+             minimal workplace temp (18.0 Celsius) is 64.4 Fahrenheit
+                usually comfortable (25.0 Celsius) is 77.0 Fahrenheit
+                      Polish summer (35.0 Celsius) is 95.0 Fahrenheit
+    
+    Angle:
+          human FOV blind spot width (5.5 degrees) is 0.09599310885969 radians
+                       decent slope (23.0 degrees) is 0.4014257279587 radians
+                      in the corner (90.0 degrees) is 1.5707963267949 radians
+
+You can also do some esoteric stuff, like:
+
+    require 'numscaler'
+    
+    palette = ' ,-\'"\\O/"\'-. '.split('')
+    s = NumScaler.new(-1.0..1.0, 0..(palette.length - 1), :mode => :cycle)
+    c = NumScaler.new(1..32, 0.0..Math::PI*2.0, :mode => :cycle)
     
-    [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
+    1.upto(256) do |o|
+      puts "\e[H\e[2J"
+      1.upto(32) do |y|
+        1.upto(64) do |x|
+          print palette[s.from(
+            Math.tan(c.from(o)) *\
+            (Math.sin(c.from(x)) +\
+            Math.cos(c.from(y)))
+          )]
+        end
+        print "\n"
+      end
+      print "\n"
+      sleep(0.5)
+    end
+
+For this you'd have to run it in a terminal (and it will probably not work
+as intended on windows).
 
 ## Copyright
 

data/examples/esoteric.rb

@@ -0,0 +1,21 @@
+require 'numscaler'
+
+palette = ' ,-\'"\\O/"\'-. '.split('')
+s = NumScaler.new(-1.0..1.0, 0..(palette.length - 1), :mode => :cycle)
+c = NumScaler.new(1..32, 0.0..Math::PI*2.0, :mode => :cycle)
+
+1.upto(256) do |o|
+  puts "\e[H\e[2J"
+  1.upto(32) do |y|
+    1.upto(64) do |x|
+      print palette[s.from(
+        Math.tan(c.from(o)) *\
+        (Math.sin(c.from(x)) +\
+        Math.cos(c.from(y)))
+      )]
+    end
+    print "\n"
+  end
+  print "\n"
+  sleep(0.5)
+end

data/examples/graphing.rb

@@ -0,0 +1,13 @@
+require 'numscaler'
+
+s1 = NumScaler.new(0..64, 0.0..Math::PI*2.0)
+s2 = NumScaler.new(-1.0..1.0, 0..9)
+
+graph = (0..64).to_a.collect do |e|
+  i = s2.from(Math.sin(s1.from(e)))
+  a = [' '] * 10
+  a[i] = '#'
+  a
+end
+
+puts graph.transpose.collect {|e| e.join }

data/examples/units.rb

@@ -0,0 +1,36 @@
+require 'numscaler'
+
+distance = NumScaler.new(0.0..100.0, 0.0..39.3701)
+temperature = NumScaler.new(-30.0..120.0, -22.0..248.0)
+angle = NumScaler.new(0.0..90.0, 0.0..Math::PI/2.0)
+
+puts 'Distance:'
+[
+  ['9 mm ammo', 0.9],
+  ['max pin distance in an europlug', 1.86],
+  ['average baguette length', 65.0],
+].each do |label, cm|
+  print "#{label} (#{cm} cm) is ".rjust(50)
+  puts distance.from(cm).to_s + ' inch'
+end
+
+puts "\nTemperature:"
+[
+  ['siberian cold', -25.0],
+  ['minimal workplace temp', 18.0],
+  ['usually comfortable', 25.0],
+  ['Polish summer', 35.0],
+].each do |label, cent|
+  print "#{label} (#{cent} Celsius) is ".rjust(50)
+  puts temperature.from(cent).to_s + ' Fahrenheit'
+end
+
+puts "\nAngle:"
+[
+  ['human FOV blind spot width', 5.5],
+  ['decent slope', 23.0],
+  ['in the corner', 90.0],
+].each do |label, deg|
+  print "#{label} (#{deg} degrees) is ".rjust(50)
+  puts angle.from(deg).to_s + ' radians'
+end

data/lib/numscaler.rb

@@ -3,30 +3,34 @@
 # See {file:README.md} for practical examples.
 class NumScaler
   # NumScaler version string
-  VERSION = '0.0.4'
+  VERSION = '0.0.5'
   # Epsilon defines rounding precision
   EPSILON = 14
   # Available clamping modes
   MODES = [:strict, :cycle, :clamp]
 
+  # Additional `options`:
+  #
+  #   * `:mode` - specify clamping mode (*default: `:strict`*)
+  #   * `:precision` - specify Float rounding (*default: `EPSILON`*)
+  #
+  # Precision defines number of significant decimal digits for rounding.
+  #
   # 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
+  # @param options [Hash] additional options
+  def initialize(from, to, options = {})
+    @mode = options[:mode] || MODES.first
+    @prec = options[:precision] || EPSILON
 
-    @mode = mode
-    @prec = precision
+    raise ArgumentError, 'Unknown mode' unless MODES.member? @mode
+    raise ArgumentError, 'Precision out of range' unless @prec > 0
 
     @src = { :orig  => from.min,
              :range => from.max.to_f - from.min.to_f,

data/numscaler.gemspec

@@ -18,6 +18,8 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^spec/})
   gem.require_paths = ['lib']
 
+  gem.required_ruby_version = '>= 1.8.7'
+
   gem.add_development_dependency 'rspec', '~> 2.4'
   gem.add_development_dependency 'rubygems-tasks', '~> 0.2'
   gem.add_development_dependency 'yard', '~> 0.8'

data/spec/numscaler_spec.rb

@@ -3,40 +3,49 @@
 require 'rspec'
 require 'numscaler'
 
+RSpec.configure do |c|
+  c.expect_with :rspec do |cc|
+    cc.syntax = :expect
+  end
+end
+
 describe NumScaler do
   it 'should have a VERSION constant' do
-    NumScaler::VERSION.should_not be_empty
+    expect(NumScaler::VERSION).to_not be_empty
   end
 
   it 'should have an EPSILON constant' do
-    NumScaler::EPSILON.should > 0
+    expect(NumScaler::EPSILON).to be > 0
   end
 
   it 'should define clamping MODES' do
-    NumScaler::MODES.should_not be_empty
+    expect(NumScaler::MODES).to_not be_empty
   end
 
   it 'should check arguments' do
-    lambda {
-      NumScaler.new(1..8, 16..32, :nonext)
-    }.should raise_error(ArgumentError)
+    expect {
+      NumScaler.new(1..8, 16..32, :mode => :nonext)
+    }.to raise_error(ArgumentError)
+    expect {
+      NumScaler.new(1..8, 16..32, :precision => 0)
+    }.to 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)
+      s = NumScaler.new(1..8, 16..32)
 
-      scaler.from(1).should eq 16
-      scaler.from(4).should eq 23
-      scaler.from(8).should eq 32
+      expect(s.from(1)).to eql 16
+      expect(s.from(4)).to eql 23
+      expect(s.from(8)).to eql 32
     end
 
     it 'should convert to' do
-      scaler = NumScaler.new(1..8, -32..32)
+      s = NumScaler.new(1..8, -32..32)
 
-      scaler.to(-32).should eq 1
-      scaler.to(  0).should eq 5
-      scaler.to( 32).should eq 8
+      expect(s.to(-32)).to eql 1
+      expect(s.to(  0)).to eql 5
+      expect(s.to( 32)).to eql 8
     end
   end
 
@@ -46,27 +55,27 @@ describe NumScaler do
     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)
+      s = NumScaler.new(0..15, 0.0..Math::PI)
+      expect(s.from( 0  )).to eql 0.0
+      expect(s.from( 7.5)).to eql (Math::PI/2.0).round(@prec)
+      expect(s.from(15  )).to eql Math::PI.round(@prec)
+
+      s = NumScaler.new(-15..15, 0.0..Math::PI)
+      expect(s.from(-15)).to eql 0.0
+      expect(s.from(  0)).to eql (Math::PI/2.0).round(@prec)
+      expect(s.from( 15)).to eql 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
+      s = NumScaler.new(0..15, 0.0..Math::PI)
+      expect(s.to(0.0)).to          eql  0
+      expect(s.to(Math::PI/2.0)).to eql  7
+      expect(s.to(Math::PI)).to     eql 15
+
+      s = NumScaler.new(-15..15, 0.0..Math::PI)
+      expect(s.to(0.0)).to          eql -15
+      expect(s.to(Math::PI/2.0)).to eql   0
+      expect(s.to(Math::PI)).to     eql  15
     end
   end
 
@@ -76,108 +85,108 @@ describe NumScaler do
     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)
+      s = NumScaler.new(0.0..256.0, 0.0..Math::PI)
+      expect(s.from(  0.0)).to eql 0.0
+      expect(s.from( 32.0)).to eql (Math::PI/8.0).round(@prec)
+      expect(s.from( 64.0)).to eql (Math::PI/4.0).round(@prec)
+      expect(s.from(128.0)).to eql (Math::PI/2.0).round(@prec)
+      expect(s.from(256.0)).to eql Math::PI.round(@prec)
+
+      s = NumScaler.new(0.0..256.0, -Math::PI..Math::PI)
+      expect(s.from(  0.0)).to eql -Math::PI.round(@prec)
+      expect(s.from( 64.0)).to eql (-Math::PI/2.0).round(@prec)
+      expect(s.from(128.0)).to eql 0.0
+      expect(s.from(192.0)).to eql (Math::PI/2.0).round(@prec)
+      expect(s.from(256.0)).to eql 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
+      s = NumScaler.new(0.0..256.0, 0.0..Math::PI)
+      expect(s.to(0.0)).to          eql   0.0
+      expect(s.to(Math::PI/8.0)).to eql  32.0
+      expect(s.to(Math::PI/4.0)).to eql  64.0
+      expect(s.to(Math::PI/2.0)).to eql 128.0
+      expect(s.to(Math::PI)).to     eql 256.0
+
+      s = NumScaler.new(0.0..256.0, -Math::PI..Math::PI)
+      expect(s.to(-Math::PI)).to     eql   0.0
+      expect(s.to(-Math::PI/2.0)).to eql  64.0
+      expect(s.to(0.0)).to           eql 128.0
+      expect(s.to(Math::PI/2.0)).to  eql 192.0
+      expect(s.to(Math::PI)).to      eql 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
+      s = NumScaler.new(1..8, -5..5)
+      expect { s.from(-1) }.to raise_error ArgumentError
+      expect { s.from( 0) }.to raise_error ArgumentError
+      expect { s.from( 9) }.to raise_error ArgumentError
+      expect { s.to(-6) }.to raise_error ArgumentError
+      expect { s.to( 6) }.to 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
+      s = NumScaler.new(0.5..1.25, -5.0..5.0)
+      expect { s.from(0.42 ) }.to raise_error ArgumentError
+      expect { s.from(0.499) }.to raise_error ArgumentError
+      expect { s.from(1.26 ) }.to raise_error ArgumentError
+      expect { s.from(1.3  ) }.to raise_error ArgumentError
+      expect { s.to(-5.1) }.to raise_error ArgumentError
+      expect { s.to( 5.1) }.to 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
+      s = NumScaler.new(1..8, -32..32, :mode => :clamp)
+      expect(s.from(-1)).to eql -32
+      expect(s.from( 0)).to eql -32
+      expect(s.from( 9)).to eql  32
+      expect(s.to(-33)).to eql 1
+      expect(s.to(  0)).to eql 5
+      expect(s.to( 33)).to eql 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
+      s = NumScaler.new(1.0..8.0, -32.0..32.0, :mode => :clamp)
+      expect(s.from(0.89)).to eql -32.0
+      expect(s.from(8.01)).to eql  32.0
+      expect(s.to(-32.1)).to eql 1.0
+      expect(s.to( 32.1)).to eql 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
+      s = NumScaler.new(1..8, -8..-1, :mode => :cycle)
+      expect(s.from(-2)).to eql -4
+      expect(s.from( 0)).to eql -2
+      expect(s.from( 2)).to eql -7
+      expect(s.from( 9)).to eql -7
+      expect(s.to(-9)).to eql 7
+      expect(s.to( 0)).to eql 2
+
+      s = NumScaler.new(-5..5, 20..30, :mode => :cycle)
+      expect(s.from(-8)).to eql 27
+      expect(s.from(-7)).to eql 28
+      expect(s.from(-6)).to eql 29
+      expect(s.from( 6)).to eql 21
+      expect(s.from( 7)).to eql 22
+      expect(s.to(18)).to eql  3
+      expect(s.to(19)).to eql  4
+      expect(s.to(31)).to eql -4
+      expect(s.to(41)).to eql -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
+      s = NumScaler.new(-2.5..2.5, 20.0..30.0, :mode => :cycle)
+      expect(s.from(-6.0)).to eql 23.0
+      expect(s.from(-2.0)).to eql 21.0
+      expect(s.from( 0.0)).to eql 25.0
+      expect(s.from( 3.0)).to eql 21.0
+      expect(s.from( 6.0)).to eql 27.0
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: numscaler
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Piotr S. Staszewski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-27 00:00:00.000000000 Z
+date: 2014-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -60,11 +60,13 @@ extra_rdoc_files: []
 files:
 - ".document"
 - ".gitignore"
-- ".rspec"
 - ".yardopts"
 - LICENSE.txt
 - README.md
 - Rakefile
+- examples/esoteric.rb
+- examples/graphing.rb
+- examples/units.rb
 - lib/numscaler.rb
 - numscaler.gemspec
 - spec/numscaler_spec.rb
@@ -80,7 +82,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.8.7
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/.rspec

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