analog 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d406496d1f9d968519029f39c59cfd4de9d89959
+  data.tar.gz: 6c6594988cb9a366f6125f21a340d1782ee1930c
+SHA512:
+  metadata.gz: fd71860f234567f1f0111c7b723a0b0760ccf02645a1ea6f85f678dbd1e863974af788b45429a93c2708873d128c8ddb72e29597b8b7a2c96266e865dce1ebe7
+  data.tar.gz: 92ef67f94ef2ff5049da82808d8046d4cae7e11a836ea3ee546914d1e0b3dbdfcfa6db991ce401f20bcfcf4fe8b29eec4f55548f63d3b4d5dd87158608ce45ef

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2014 Ari Russo
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,74 @@
+# analog
+
+A Ruby helper for scaling numbers.
+
+#### Background
+
+This helper provides a quick way to take a number and scale it given a source and destination range/set/etc.
+
+It's useful for converting data from raw values to a range used for display or other kinds of output.
+
+I use this all the time in music programming, converting OSC messages to musical notes and things like that and figure it might be useful to others.
+
+A simple example is:
+
+If you want to plot a point on a 500px graph using a data that lies in the 0..1 range, do
+
+```ruby
+Scale.transform(0.5).using(0..1, 0..500)
+=> 250
+```
+
+Please note: I am not a Math Person.  If I've named any concepts here poorly, [please let me know](https://github.com/arirusso/analog/issues).  Or [submit a pull request](https://github.com/arirusso/analog/pulls)
+
+#### Usage
+
+```ruby
+require "scale"
+```
+
+This example will scale a number down by 1/10th`
+
+```ruby
+Scale.transform(22).using(0..150, 0..15)
+=> 2
+
+```
+
+You can use Arrays and Sets
+```ruby
+Scale.transform(8).using(Set.new([0, 2, 4, 8, 16, 64]), 0..10)
+=> 6
+
+Scale.transform(0.40).using(0..1, [0, 2, 4, 8, 12, 16, 32, 64, 128, 512])
+=> 8
+```
+
+See the [examples](https://github.com/arirusso/analog/tree/master/examples) for more
+
+###### Core Extension
+
+There is a Numeric extension that you can optionally include.
+
+```ruby
+require "scale/core_ext"
+
+0.40.scaled_from(0..1).to([0, 2, 4, 8, 12, 16, 32, 64, 128, 512])
+=> 8
+```
+
+See the [core_ext example](https://github.com/arirusso/analog/blob/master/examples/core_ext.rb) for more examples.
+
+#### Installation
+
+    gem install analog
+    
+or with Bundler
+
+    gem "analog"
+
+#### License
+
+Licensed under Apache 2.0, See the file LICENSE
+Copyright (c) 2014 [Ari Russo](http://arirusso.com) 
+

data/lib/scale.rb

@@ -0,0 +1,11 @@
+# classes
+require "scale/destination"
+require "scale/scheme"
+require "scale/source"
+
+# A Ruby helper for scaling numbers
+module Scale
+
+  VERSION = "0.1"
+
+end

data/lib/scale/core_ext.rb

@@ -0,0 +1,46 @@
+require "scale"
+
+# Extend the Numeric class to add a scaling helper. 
+# eg: 0.40.scaled_from(0..1).to([512, 128, 64, 32, 16, 12, 8, 4, 2, 0])
+#
+# This is not included by default with the rest of the library.  use require "scale/core_ext"
+#
+class Numeric
+
+  # Build a Scheme for this numeric as input.
+  # @return [Scale::Scheme]
+  def scaled
+    Scale.transform(self)
+  end
+
+  # Scale using the given source and destination, with this numeric as input.
+  # @param [Scale::Source] source
+  # @param [Scale::Destination] destination
+  # @return [Numeric]
+  def scaled_using(source, destination)
+    Scale.transform(self).using(source, destination)
+  end
+
+  # Build a scheme with this numeric as input and add the given source to it. If 
+  # on calling this method, the scheme has all of its needed properties, the scaled 
+  # value will be returned.  Otherwise # this method will return the updated Scheme 
+  # object.
+  #
+  # @param [Scale::Source] source
+  # @return [Numeric, Scale::Scheme]
+  def scaled_from(source)
+    Scale.transform(self).from(source)
+  end
+
+  # Build a scheme with this numeric as input and add the given destination to it. If 
+  # on calling this method, the scheme has all of its needed properties, the scaled 
+  # value will be returned.  Otherwise # this method will return the updated Scheme 
+  # object.
+  #
+  # @param [Scale::Destination] destination
+  # @return [Numeric, Scale::Scheme]
+  def scaled_to(destination)
+    Scale.transform(self).to(destination)
+  end
+
+end

data/lib/scale/destination.rb

@@ -0,0 +1,73 @@
+module Scale
+
+  # These are the classes that describe what range the transformed number
+  # will wind up in. They're named after the core Ruby class that the input closest
+  # resembles.
+  module Destination
+
+    # Contains logic for dealing with Ruby's core ::Range as input
+    class Range
+
+      # @param [::Range] range A range to operate with
+      def initialize(range)
+        @range = range
+      end
+
+      # Scale the given input and source using this destination
+      # @param [Numeric] input A numeric value to scale
+      # @param [Scale::Source] source The source for the input value
+      # @return [Numeric]
+      def scale(input, source)
+        to_range_len = (@range.last - @range.first).abs
+
+        proportion = to_range_len.to_f / source.denominator
+        abs_output = proportion.to_f * source.numerator(input)
+        output = abs_output + @range.first
+
+        float_requested = [@range.first, @range.last].any? { |n| n.kind_of?(::Float) }
+        float_requested ? output : output.to_i
+      end
+
+    end
+
+    # Contains logic for dealing with input that includes Ruby's core ::Enumerable
+    class Enumerable
+
+      # @param [::Enumerable] enum An enumerable (eg Array, Set) to operate with
+      def initialize(enum)
+        @enum = enum
+      end
+
+      # Scale the given input and source using this destination
+      # @param [Numeric] input A numeric value to scale
+      # @param [Scale::Source] source The source for the input value
+      # @return [Numeric]
+      def scale(input, source)
+        proportion = source.numerator(input) / source.denominator
+        index = [((proportion * @enum.size).to_i - 1), 0].max
+        @enum.to_a.at(index)
+      end
+
+    end
+
+    # Map Ruby classes/modules to scaling destination classes/modules
+    MAP = {
+      ::Enumerable => Destination::Enumerable,
+      ::Range => Destination::Range
+    }
+
+    # Build the appropriate scaling destination class for the given Ruby object
+    # @param [::Enumerable] destination
+    # @return [Scale::Destination::Enumerable, Scale::Destination::Range]
+    def self.new(destination)
+      klass = MAP[destination.class]
+      if klass.nil?
+        klasses = MAP.select { |k,v| destination.kind_of?(k) }
+        klass = klasses.values.first
+      end
+      klass.new(destination) unless klass.nil?
+    end
+
+  end
+
+end

data/lib/scale/scheme.rb

@@ -0,0 +1,65 @@
+module Scale
+
+  # Build a scaling scheme for the given input
+  # @param [Numeric] input
+  # @return [Scale::Scheme]
+  def self.transform(input)
+    Scheme.new(:input => input)
+  end
+
+  # Describes a particular scaling scenario
+  class Scheme
+
+    attr_reader :destination, :input, :source
+
+    # @param [Hash] options
+    # @option options [Scale::Destination] :destination The destination for this scaling scenario
+    # @option options [Scale::Source] :source The source for this scaling scenario
+    def initialize(options = {})
+      @input = options[:input]
+      @source = Source.new(options[:source]) unless options[:source].nil?
+      @destination = Destination.new(options[:destination]) unless options[:destination].nil?
+    end
+
+    # Set the source for this scaling scenario.  If on calling this method, the scenario
+    # has all of its needed properties, the scaled value will be returned.  Otherwise
+    # this method will return the updated Scheme object.
+    #
+    # @param [Scale::Source] source
+    # @return [Fixnum, Scale::Scheme]
+    def from(source)
+      @source = Source.new(source)
+      if @input.nil? || @destination.nil?
+        self
+      else
+        @destination.scale(@input, @source)
+      end
+    end
+
+    # Set the destination for this scaling scenario.  If on calling this method, the 
+    # scenario has all of its needed properties, the scaled value will be returned.  
+    # Otherwise this method will return the updated Scheme object.
+    #
+    # @param [Scale::Destination] destination
+    # @return [Fixnum, Scale::Scheme]
+    def to(destination)
+      @destination = Destination.new(destination)
+      if @input.nil? || @source.nil?
+        self
+      else
+        @destination.scale(@input, @source) 
+      end
+    end
+
+    # Set both the source and destination on this scheme
+    # @param [Scale::Source] source
+    # @param [Scale::Destination] destination
+    def using(source, destination)
+      @source = Source.new(source)
+      @destination = Destination.new(destination)
+      @destination.scale(@input, @source)
+    end
+
+  end
+
+end

data/lib/scale/source.rb

@@ -0,0 +1,70 @@
+module Scale
+
+  # These are the classes that describe what range the transformed number 
+  # starts in.  They're named after the core Ruby class that the input closest
+  # resembles.
+  module Source
+
+    # Contains logic for dealing with Ruby's core ::Range as input
+    class Range
+
+      # @param [::Range] range A range to operate on
+      def initialize(range)
+        @range = range
+      end
+
+      # @param [Numeric] input
+      # @return [Float]
+      def numerator(input)
+        (input - @range.first).to_f
+      end
+
+      # @return [Float]
+      def denominator
+        (@range.last - @range.first).abs.to_f
+      end
+
+    end
+
+    # Contains logic for dealing with input that includes Ruby's core ::Enumerable
+    class Enumerable
+
+      # @param [::Enumerable] enum An enumerable (Array, Set, etc) to operate on
+      def initialize(enum)
+        @enum = enum
+      end
+
+      # @param [Numeric] input
+      # @return [Float]
+      def numerator(input)
+        @enum.to_a.index(input).to_f
+      end
+
+      # @return [Float]
+      def denominator
+        (@enum.size - 1).to_f
+      end
+
+    end
+
+    # Map Ruby classes/modules to scaling source classes/modules
+    MAP = {
+      ::Enumerable => Source::Enumerable,
+      ::Range => Source::Range
+    }      
+
+    # Build the appropriate scaling source class for the given Ruby object
+    # @param [::Enumerable] source
+    # @return [Scale::Source::Enumerable, Scale::Source::Range]
+    def self.new(source)
+      klass = MAP[source.class]
+      if klass.nil?
+        klasses = MAP.select { |k,v| source.kind_of?(k) }
+        klass = klasses.values.first
+      end
+      klass.new(source) unless klass.nil?
+    end
+
+  end
+
+end

data/test/core_ext_test.rb

@@ -0,0 +1,84 @@
+require "helper"
+
+class CoreExtTest < Test::Unit::TestCase
+
+  context "Numeric" do
+
+    setup do
+      require "scale/core_ext"
+    end
+
+    context "#scaled" do
+
+      should "amplify" do
+        output = 0.10.scaled.using(0..1, 0..127)
+        assert_equal(12, output)
+      end
+
+      should "deamplify" do
+        output = 22.scaled.using(0..150, 0..15)
+        assert_equal(2, output)
+      end
+
+      should "scale neg/pos into pos/pos" do
+        output = 10.scaled.using(-24..24, 0..3.0)
+        assert_equal(2.125, output)
+      end
+
+      should "scale neg/pos into another neg/pos" do
+        output = 10.scaled.using(-24..24, -3..3.0)
+        assert_equal(1.25, output)
+      end
+
+    end
+
+    context "#scaled_using" do
+
+      should "scale neg/neg into neg/pos" do
+        output = -14.scaled_using(-24..-12, -3..3.0)
+        assert_equal(2, output)  
+      end
+
+      should "scale neg/neg to another neg/neg" do
+        output = -16.scaled_using(-24..-12, -5..-3.0)
+        assert_equal(-3.666666666666667, output)
+      end
+
+      should "scale neg/neg to pos/pos" do
+        output = -18.scaled_using(-24..-12, 1..3.0)
+        assert_equal(2, output)
+      end
+
+    end
+
+    context "#scaled_to" do
+
+      should "take an array as the source" do
+        output = 8.scaled_to(0..10).from([0, 2, 4, 8, 16, 64])
+        assert_equal(6, output)
+      end
+
+      should "output a float when specified" do
+        output = 12.scaled_to(0..1.0).from(0..120)
+        assert_equal(0.10, output)   
+      end
+
+    end
+
+    context "#scaled_from" do
+
+      should "take an ascending array as the destination" do
+        output = 0.40.scaled_from(0..1).to([0, 2, 4, 8, 12, 16, 32, 64, 128, 512])
+        assert_equal(8, output)
+      end
+
+      should "take a descending array as the destination" do
+        output = 0.40.scaled_from(0..1).to([512, 128, 64, 32, 16, 12, 8, 4, 2, 0])
+        assert_equal(32, output)
+      end
+
+    end
+
+  end
+
+end

data/test/helper.rb

@@ -0,0 +1,8 @@
+dir = File.dirname(File.expand_path(__FILE__))
+$LOAD_PATH.unshift dir + '/../lib'
+
+require 'test/unit'
+require "mocha/test_unit"
+require "shoulda-context"
+
+require "scale"

data/test/scale_test.rb

@@ -0,0 +1,92 @@
+require "helper"
+
+class ScaleTest < Test::Unit::TestCase
+
+  context "Scale" do
+
+    context "#initialize" do
+
+      should "recognize a Range" do
+        scheme = Scale::Scheme.new(:source => 0..1, :destination => 0..100)
+        assert_equal(Scale::Destination::Range, scheme.destination.class)
+      end
+
+      should "recognize an Array" do
+        scheme = Scale::Scheme.new(:source => 0..1, :destination => [0, 10, 20, 50])
+        assert_equal(Scale::Destination::Enumerable, scheme.destination.class)
+      end
+
+    end
+
+    context "#scale" do
+
+      should "amplify" do
+        output = Scale.transform(0.10).using(0..1, 0..127)
+        assert_equal(12, output)
+      end
+
+      should "deamplify" do
+        output = Scale.transform(22).using(0..150, 0..15)
+        assert_equal(2, output)
+      end
+
+      should "scale neg/pos into pos/pos" do
+        output = Scale.transform(10).using(-24..24, 0..3.0)
+        assert_equal(2.125, output)
+      end
+
+      should "scale neg/pos into another neg/pos" do
+        output = Scale.transform(10).using(-24..24, -3..3.0)
+        assert_equal(1.25, output)
+      end
+
+      should "scale neg/neg into neg/pos" do
+        output = Scale.transform(-14).using(-24..-12, -3..3.0)
+        assert_equal(2, output)  
+      end
+
+      should "scale neg/neg to another neg/neg" do
+        output = Scale.transform(-16).using(-24..-12, -5..-3.0)
+        assert_equal(-3.666666666666667, output)
+      end
+
+      should "scale neg/neg to pos/pos" do
+        output = Scale.transform(-18).using(-24..-12, 1..3.0)
+        assert_equal(2, output)
+      end
+
+      should "take an array as the source" do
+        output = Scale.transform(8).using([0, 2, 4, 8, 16, 64], 0..10)
+        assert_equal(6, output)
+      end
+
+      should "take an set as the source" do
+        output = Scale.transform(8).using(Set.new([0, 2, 4, 8, 16, 64]), 0..10)
+        assert_equal(6, output)
+      end
+
+      should "output a float when specified" do
+        output = Scale.transform(12).using(0..120, 0..1.0)
+        assert_equal(0.10, output)   
+      end
+
+      should "take an ascending array as the destination" do
+        output = Scale.transform(0.40).using(0..1, [0, 2, 4, 8, 12, 16, 32, 64, 128, 512])
+        assert_equal(8, output)
+      end
+
+      should "take a descending array as the destination" do
+        output = Scale.transform(0.40).using(0..1, [512, 128, 64, 32, 16, 12, 8, 4, 2, 0])
+        assert_equal(32, output)
+      end
+
+      should "take a set as the destination" do
+        output = Scale.transform(0.40).using(0..1, Set.new([0, 2, 4, 8, 12, 16, 32, 64, 128, 512]))
+        assert_equal(8, output)
+      end
+
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: analog
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Ari Russo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: shoulda-context
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Provides a quick way to take a number and scale it given a source and
+  destination Array, Range, Set, etc
+email:
+- ari.russo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/scale.rb
+- lib/scale/core_ext.rb
+- lib/scale/destination.rb
+- lib/scale/scheme.rb
+- lib/scale/source.rb
+- test/core_ext_test.rb
+- test/helper.rb
+- test/scale_test.rb
+homepage: http://github.com/arirusso/analog
+licenses:
+- Apache License (2.0)
+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: 1.3.6
+requirements: []
+rubyforge_project: analog
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A Ruby helper for scaling numbers
+test_files:
+- test/core_ext_test.rb
+- test/scale_test.rb