interpolate 0.2.0 → 0.2.1

data.tar.gz.sig

@@ -0,0 +1,2 @@
+w���YQ���Ip�YV���5����<��K����+�;VS�5m#3,�I�=Ʒ�UK�1z��(B��q[	}{vD��A�uu�lE�Xo�����6�Fȭ�b1u�����cn˒�ي�=��&�}�ԅf
+���b���~�ߎ<I>���7=�k$i!�X�n*��M�vc��s���iC�4�H+*��a9m���8e
/Z+̿G��Z���H������]e��8��x'����5'S���~�>(��U�

data/CHANGELOG.txt

@@ -0,0 +1,28 @@
+== 0.2.1 (2008.1.27)
+
+* First public release
+
+* Project Cleanup:
+
+  * Documentation enhancements and updates.
+  * +add+ is now +merge+
+
+== 0.2.0 (2008.1.24)
+
+* Changed the library name to "interpolate"
+* Added +interpolate+ (+Array+) that covers uniform arrays and nested arrays
+* Added more tests, documentation, and examples
+
+== 0.1.0 (2008.1.22)
+
+* 2 Major Changes:
+
+* Gadient calls +interpolate+ on values for OOP goodness
+* Checks added for respond_to? +interpolate+ on values
+* Added +interpolate+ (+Numeric+)
+
+== 0.0.1 (2008.1.20)
+
+* Initial coding
+* N-sized arbitrary floating point gradients
+

data/Manifest.txt

@@ -1,5 +1,5 @@
-CHANGELOG
-MIT-LICENSE
+CHANGELOG.txt
+LICENSE.txt
 Manifest.txt
 README.txt
 Rakefile

data/README.txt

@@ -1,11 +1,186 @@
-== Interpolate
+= Interpolate
 
-Library for generic interpolation objects. Useful for such things as generating
+== Author
+
+Adam Collins [adam.w.collins@gmail.com]
+
+
+== Description
+
+Library for generic Interpolation objects. Useful for such things as generating
 linear motion between points (or arrays of points), multi-channel color
 gradients, piecewise functions, or even just placing values within intervals.
 
-== Author
 
-Adam Collins
-adam.w.collins@gmail.com
+== General Usage
+
+Specify the interpolation as a Hash, where keys represent numeric points
+along the gradient and values represent the known values along that gradient.
+
+Here's an example for determining where, in a range of seven zones, each value
+of a set falls into:
+
+  require 'rubygems'
+  require 'interpolate'
+
+  points = {
+    0.000 => 0,
+    0.427 => 1,
+    1.200 => 2,
+    3.420 => 3,
+    27.50 => 4,
+    45.20 => 5,
+    124.4 => 6,
+  }
+
+  zones = Interpolation.new(points)
+
+  values = [
+    -20.2,
+    0.234,
+    65.24,
+    9.234,
+    398.4,
+    4000
+  ]
+
+  values.each do |value|
+    zone = zones.at(value).floor
+    puts "A value of #{value} falls into zone #{zone}"
+  end
+
+
+== Non-Numeric Gradients
+
+For non-Numeric gradient value objects, you'll need to implement +interpolate+
+for the class in question.  Here's an example using an RGB color gradient with
+the help of the 'color' gem:
+
+  require 'rubygems'
+  require 'interpolate'
+  require 'color'
+
+  # we need to implement +interpolate+ for Color::RGB
+  # in order for Interpolation to work
+  class Color::RGB
+    def interpolate(other, balance)
+      mix_with(other, balance * 100.0)
+    end
+  end
+
+  # a nice weathermap-style color gradient
+  points = {
+    0 => Color::RGB::White,
+    1 => Color::RGB::Lime,
+  # 2 => ? (something between Lime and Yellow)
+    3 => Color::RGB::Yellow,
+    4 => Color::RGB::Orange,
+    5 => Color::RGB::Red,
+    6 => Color::RGB::Magenta,
+    7 => Color::RGB::DarkGray
+  }
+
+  gradient = Interpolation.new(points)
+
+  # what are the colors of the gradient from 0 to 7
+  # in increments of 0.2?
+  (0).step(7, 0.2) do |value|
+    color = gradient.at(value)
+    puts "A value of #{value} means #{color.html}"
+  end
+
+
+== Array-based Interpolations
+
+Aside from single value gradient points, you can interpolate over uniformly sized
+arrays.  Between two interpolation points, let's say +a+ and +b+, the final result
+will be +c+ where <tt>c[0]</tt> is the interpolation of <tt>a[0]</tt> and
+<tt>b[0]</tt> and <tt>c[1]</tt> is interpolated between <tt>a[1]</tt> and
+<tt>b[1]</tt> and so on up to <tt>c[n]</tt>.
+
+Here is an example:
+
+  require 'rubygems'
+  require 'interpolate'
+  require 'pp'
+
+  # a non-linear set of multi-dimensional points;
+  # perhaps the location of some actor in relation to time
+  time_frames = {
+    0 => [0, 0, 0],
+    1 => [1, 0, 0],
+    2 => [0, 1, 0],
+    3 => [0, 0, 2],
+    4 => [3, 0, 1],
+    5 => [1, 2, 3],
+    6 => [0, 0, 0]
+  }
+
+  path = Interpolation.new(time_frames)
+
+  # play the actors positions in time increments of 0.25
+  (0).step(6, 0.25) do |time|
+    position = path.at(time)
+    puts ">> At #{time}s, actor is at:"
+    p position
+  end
+
+
+== Nested Array Interpolations
+
+As long as each top level array is uniformly sized in the first dimension
+and each nested array is uniformly sized in the second dimension (and so
+on...), multidimensional interpolation point values will just work.
+
+Here's an example of a set of 2D points being morphed:
+
+  require 'rubygems'
+  require 'interpolate'
+  require 'pp'
+
+
+  # a non-linear set of 2D vertexes;
+  # the shape changes at each frame
+  time_frames = {
+    0 => [[0, 0], [1, 0], [2, 0], [3, 0], [4, 0]], # a horizontal line
+    1 => [[0, 0], [1, 0], [3, 0], [0, 4], [0, 0]], # a triangle
+    2 => [[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]], # a square
+    3 => [[0, 0], [1, 0], [2, 0], [3, 0], [4, 0]], # a horizontal line, again
+    4 => [[0, 0], [0, 1], [0, 2], [0, 3], [0, 4]]  # a vertical line
+  }
+
+
+  paths = Interpolation.new(time_frames)
+
+  # show the vertex positions in time increments of 0.25
+  (0).step(4, 0.25) do |time|
+    points = paths.at(time)
+    puts ">> At #{time}s, points are:"
+    p points
+  end
+
+
+== License
+
+(The MIT License)
+
+Copyright (c) 2008 Adam Collins [adam.w.collins@gmail.com]
+
+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/Rakefile

@@ -6,14 +6,12 @@ require 'interpolate'
 Hoe.new('Interpolate', Interpolation::VERSION) do |p|
   p.name = "interpolate"
   p.author = "Adam Collins"
-  p.description = "Library for creating generic interpolations objects."
   p.email = 'adam.w.collins@gmail.com'
-  p.summary = "Useful for such things as generating linear motion between points (or arrays of points), multi-channel color gradients, piecewise functions, or even just placing values within intervals."
   p.url = "http://interpolate.rubyforge.org"
-  #p.clean_globs = [''] # Remove this directory on "rake clean"
+  p.description = File.read('README.txt').delete("\r").split(/^== /)[2].chomp.chomp
+  p.summary = p.description
+  p.changes = File.read('CHANGELOG.txt').delete("\r").split(/^== /)[1].chomp
   p.remote_rdoc_dir = '' # Release to root
-  p.changes = p.paragraphs_of('CHANGELOG', 0..1).join("\n\n")
-  # * extra_deps - An array of rubygem dependencies.
 end
 
 desc "Release and publish documentation"

data/lib/interpolate.rb

@@ -1,245 +1,58 @@
-=begin rdoc
-
-Library for generic interpolation objects. Useful for such things as generating
-linear motion between points (or arrays of points), multi-channel color
-gradients, piecewise functions, or even just placing values within intervals.
-
-The only requirement is that each interpolation point value must be able to
-figure out how to interpolate itself to its neighbor value(s). Numeric
-objects and uniformly sized arrays are automatically endowed with this
-ability by this gem, but other classes will require an implementation
-of #interpolate. See the second example below for a brief demonstration
-using Color objects.
-
-Interpolation objects are constructed with a Hash object, wherein each key
-is a real number value and each value is can respond to #interpolate and
-determine the resulting value based on its neighbor value and the balance
-ratio between the two points.
-
-At or below the lower bounds of the interpolation, the result will be equal to
-the value of the lower bounds interpolation point.  At or above the upper
-bounds of the graient, the result will be equal to the value of the upper
-bounds interpolation point.
-
-
-==Author
-
-{Adam Collins}[mailto:adam.w.collins@gmail.com]
-
-
-==General Usage
-
-Specify the interpolation as a Hash, where keys represent numeric points
-along the gradient and values represent the known values along that gradient.
-
-Here's an example for determining which of 7 zones a set of values fall into:
-
-  require 'rubygems'
-  require 'interpolate'
-
-  points = {
-    0.000 => 0,
-    0.427 => 1,
-    1.200 => 2,
-    3.420 => 3,
-    27.50 => 4,
-    45.20 => 5,
-    124.4 => 6,
-  }
-
-  zones = Interpolation.new(points)
-
-  values = [
-    -20.2,
-    0.234,
-    65.24,
-    9.234,
-    398.4,
-    4000
-  ]
-
-  values.each do |value|
-    zone = zones.at(value).floor
-    puts "A value of #{value} falls into zone #{zone}"
-  end
-
-
-==Non-Numeric Gradients
-
-For non-Numeric gradient value objects, you'll need to implement :interpolate
-for the class in question.  Here's an example using an RGB color gradient with
-the help of the 'color' gem:
-
-  require 'rubygems'
-  require 'interpolate'
-  require 'color'
-
-  # we need to implement :interpolate for Color::RGB
-  # in order for Interpolation to work
-  class Color::RGB
-    def interpolate(other, balance)
-      mix_with(other, balance * 100.0)
-    end
-  end
-
-  # a nice weathermap-style color gradient
-  points = {
-    0 => Color::RGB::White,
-    1 => Color::RGB::Lime,
-  # 2 => ? (something between Lime and Yellow)
-    3 => Color::RGB::Yellow,
-    4 => Color::RGB::Orange,
-    5 => Color::RGB::Red,
-    6 => Color::RGB::Magenta,
-    7 => Color::RGB::DarkGray
-  }
-
-
-  gradient = Interpolation.new(points)
-
-  # what are the colors of the gradient from 0 to 7
-  # in increments of 0.2?
-  (0).step(7, 0.2) do |value|
-    color = gradient.at(value)
-    puts "A value of #{value} means #{color.html}"
-  end
-
-
-==Array-based Interpolations
-
-Aside from single value gradient points, you can interpolate over uniformly sized
-arrays.  Between two interpolation points, let's say +a+ and +b+, the final
-result will be +c+ where +c[0]+ is the interpolation of +a[0]+ and +b[0]+ and
-+c[1]+ is interpolated between +a[1]+ and +b[1]+ and so on up to +c[n]+.
-
-Here is an example:
-
-  require 'rubygems'
-  require 'interpolate'
-  require 'pp'
-
-  # a non-linear set of multi-dimensional points;
-  # perhaps the location of some actor in relation to time
-  time_frames = {
-    0 => [0, 0, 0],
-    1 => [1, 0, 0],
-    2 => [0, 1, 0],
-    3 => [0, 0, 2],
-    4 => [3, 0, 1],
-    5 => [1, 2, 3],
-    6 => [0, 0, 0]
-  }
-
-  path = Interpolation.new(time_frames)
-
-  # play the actors positions in time increments of 0.25
-  (0).step(6, 0.25) do |time|
-    position = path.at(time)
-    puts ">> At #{time}s, actor is at:"
-    p position
-  end
-
-
-==Nested Array Interpolations
-
-As long as each top level array is uniformly sized in the first dimension
-and each nested array is uniformly sized in the second dimension (and so
-on...), multidimensional interpolation point values will just work.
-
-Here's an example of a set of 2D points being morphed:
-
-  require 'rubygems'
-  require 'interpolate'
-  require 'pp'
-
-
-  # a non-linear set of 2D vertexes;
-  # the shape changes at each frame
-  time_frames = {
-    0 => [[0, 0], [1, 0], [2, 0], [3, 0], [4, 0]], # a horizontal line
-    1 => [[0, 0], [1, 0], [3, 0], [0, 4], [0, 0]], # a triangle
-    2 => [[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]], # a square
-    3 => [[0, 0], [1, 0], [2, 0], [3, 0], [4, 0]], # a horizontal line, again
-    4 => [[0, 0], [0, 1], [0, 2], [0, 3], [0, 4]]  # a vertical line
-  }
-
-
-  paths = Interpolation.new(time_frames)
-
-  # show the vertex positions in time increments of 0.25
-  (0).step(4, 0.25) do |time|
-    points = paths.at(time)
-    puts ">> At #{time}s, points are:"
-    p points
-  end
-
-
-==License
-
-Licensed under the MIT license.
-
-=end
-
-
-# all numeric objects should be supported out of the box
-class Numeric
-  def interpolate(other, balance)
-    left = self.to_f
-    right = other.to_f
-    delta = (right - left).to_f
-    return left + (delta * balance)
-  end
-end
-
-
-# a little more complicated, but there's no reason why we can't
-# interpolate between two equal length arrays as long as each element
-# responds to :interpolate
-class Array
-  def interpolate(other, balance)
-    if (self.length < 1) then
-      raise ArgumentError, "cannot interpolate array with no values"
-    end
-
-    if (self.length != other.length) then
-      raise ArgumentError, "cannot interpolate between arrays of different length"
-    end
-
-    final = Array.new
-
-    self.each_with_index do |left, index|
-      unless (left.respond_to? :interpolate) then
-        raise "array element does not respond to :interpolate"
-      end
-
-      right = other[index]
-
-      final[index] = left.interpolate(right, balance)
-    end
-
-    return final
-  end
-end
-
+# Library for generic interpolation objects. Useful for such things as generating
+# linear motion between points (or arrays of points), multi-channel color
+# gradients, piecewise functions, or even just placing values within intervals.
+#
+# The only requirement is that each interpolation point value must be able to
+# figure out how to interpolate itself to its neighbor value(s). Numeric
+# objects and uniformly sized arrays are automatically endowed with this
+# ability by this gem, but other classes will require an implementation
+# of +interpolate+. See the example color.rb in the examples directory for
+# a brief demonstration using Color objects provided by the 'color' gem.
+#
+# Interpolation objects are constructed with a Hash object, wherein each key
+# is a real number value and each value is can respond to +interpolate+ and
+# determine the resulting value based on its neighbor value and the balance
+# ratio between the two points.
+#
+# At or below the lower bounds of the interpolation, the result will be equal to
+# the value of the lower bounds interpolation point.  At or above the upper
+# bounds of the graient, the result will be equal to the value of the upper
+# bounds interpolation point.
+#
+#
+# ==Author
+#
+# {Adam Collins}[mailto:adam.w.collins@gmail.com]
+#
+#
+# ==License
+#
+# Licensed under the MIT license.
+#
 
 class Interpolation
-  VERSION = '0.2.0'
+  VERSION = '0.2.1' # :nodoc:
 
+  # creates an Interpolation object with Hash object that specifies
+  # each point location (Numeric) and value (up to you)
   def initialize(points = {})
     @points = {}
-    add!(points)
+    merge!(points)
   end
 
-  def add(points = {})
+  # creates an Interpolation object from the receiver object,
+  # merged with the interpolated points you specify
+  def merge(points = {}) 
     Interpolation.new(points.merge(@points))
   end
 
-  def add!(points = {})
+  # merges the interpolation points with the receiver object
+  def merge!(points = {})
     @points.merge!(points)
     normalize_data
   end
 
-
+  # returns the interpolated value of the receiver object at the point specified 
   def at(point)
     # deal with the two out-of-bounds cases first
     if (point <= @min_point)
@@ -285,7 +98,7 @@ class Interpolation
 
   private
 
-  def normalize_data
+  def normalize_data # :nodoc:
     @data = @points.sort
     @min_point = @data.first.first
     @max_point = @data.last.first
@@ -302,3 +115,42 @@ class Interpolation
 end
 
 
+# all numeric objects should be supported
+class Numeric   # :nodoc:
+  def interpolate(other, balance)
+    left = self.to_f
+    right = other.to_f
+    delta = (right - left).to_f
+    return left + (delta * balance)
+  end
+end
+
+
+# a little more complicated, but there's no reason why we can't
+# interpolate between two equal length arrays as long as each element
+# responds to +interpolate+
+class Array   # :nodoc:
+  def interpolate(other, balance)
+    if (self.length < 1) then
+      raise ArgumentError, "cannot interpolate array with no values"
+    end
+
+    if (self.length != other.length) then
+      raise ArgumentError, "cannot interpolate between arrays of different length"
+    end
+
+    final = Array.new
+
+    self.each_with_index do |left, index|
+      unless (left.respond_to? :interpolate) then
+        raise "array element does not respond to :interpolate"
+      end
+
+      right = other[index]
+
+      final[index] = left.interpolate(right, balance)
+    end
+
+    return final
+  end
+end

data/test/test_all.rb

@@ -79,7 +79,7 @@ class InterpolationTest < Test::Unit::TestCase
     assert_in_delta(@dec_gradient.at(3.5701), 0.35701, DELTA)
   end
 
-  def test_gradient_add
+  def test_gradient_merge
     new_points = {
       11 => 1.1,
       12 => 1.2,
@@ -94,7 +94,7 @@ class InterpolationTest < Test::Unit::TestCase
     }
 
     original = @dec_gradient.dup
-    expanded = original.add(new_points)
+    expanded = original.merge(new_points)
 
     assert_equal(original.at(5), 0.5)
     assert_equal(expanded.at(5), 0.5)
@@ -103,7 +103,7 @@ class InterpolationTest < Test::Unit::TestCase
     assert_equal(expanded.at(15), 1.5)
   end
 
-  def test_gradient_add!
+  def test_gradient_merge!
     new_points = {
       11 => 1.1,
       12 => 1.2,
@@ -119,7 +119,7 @@ class InterpolationTest < Test::Unit::TestCase
 
     original = @dec_gradient.dup
     expanded = original.dup
-    expanded.add!(new_points)
+    expanded.merge!(new_points)
 
     assert_equal(original.at(5), 0.5)
     assert_equal(expanded.at(5), 0.5)

metadata

@@ -1,15 +1,36 @@
 --- !ruby/object:Gem::Specification 
 name: interpolate
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors: 
 - Adam Collins
 autorequire: 
 bindir: bin
-cert_chain: []
+cert_chain: 
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDPjCCAiagAwIBAgIBADANBgkqhkiG9w0BAQUFADBFMRcwFQYDVQQDDA5hZGFt
+  LncuY29sbGluczEVMBMGCgmSJomT8ixkARkWBWdtYWlsMRMwEQYKCZImiZPyLGQB
+  GRYDY29tMB4XDTA4MDEyNDA4NTEyOFoXDTA5MDEyMzA4NTEyOFowRTEXMBUGA1UE
+  AwwOYWRhbS53LmNvbGxpbnMxFTATBgoJkiaJk/IsZAEZFgVnbWFpbDETMBEGCgmS
+  JomT8ixkARkWA2NvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMP8
+  3Nz8g1K+Z4p59/keyov5ihFgzJuhlnvbRLr0y2jtDybeyc0TSMnY7sjhx+T0yVI5
+  9tEtUMo3d2m0woaHw7kc3VAo68GQKGAN02bdaPc4ODcObL9DAr8Y3CCwml5CiLtX
+  L5Lz8zO9EU6jv6bTecRW5DsY9nPjc/TLqXjYxDgSL8dppBmHs2k82bJCaCaTFj9M
+  ORRZpdkdTBdecI7p8DKt2WAX12deT/XUan7mpiBChKJsNVpcAe6CUqVfb6hMGA95
+  KtW+GxvK6F6UgkcFG8ljrXks8Dfm4jMYVkpmw1YUGYU9Wj9R8X94ecAi9By/ngJ7
+  svhO6ouvVk9J9hgpWukCAwEAAaM5MDcwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAw
+  HQYDVR0OBBYEFIpBCufIdqpuVqh/Mt46Gq9FKa0pMA0GCSqGSIb3DQEBBQUAA4IB
+  AQBbwpirH1tNzkESxQIBZd10xK3Dca141G9+lHl7OK3UCk1ZF6TiXxgl7Qnug4A5
+  3mEn/catvIdMYcA1GLNWL7qlW2Fpk2w0qgVbx1agK724BrZm5Op6lain+vi6BXd3
+  QM32MqZAL96e40i6UCutsNIdZeRDfR7hRcmqPTkoSUEu/3X6qegnvJHpVw36dsG6
+  trlR7ps6/GSlnZNkD5TayaybO3TiA+KGA19/zQhO6DMPds+swW0Jz7xv2VBzIWg5
+  RAnseWJ5nOAftsE9D1NGp3TEH+ceNKO3IP0OtDl9L2F0a/9XbPJdmsaQR+FPX30Z
+  xJc09X9KG2jBdxa4tp+uy7KZ
+  -----END CERTIFICATE-----
 
-date: 2008-01-24 00:00:00 -08:00
+date: 2008-01-27 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -21,18 +42,20 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 1.4.0
     version: 
-description: Library for creating generic interpolations objects.
+description: Description  Library for generic Interpolation objects. Useful for such things as generating linear motion between points (or arrays of points), multi-channel color gradients, piecewise functions, or even just placing values within intervals.
 email: adam.w.collins@gmail.com
 executables: []
 
 extensions: []
 
 extra_rdoc_files: 
+- CHANGELOG.txt
+- LICENSE.txt
 - Manifest.txt
 - README.txt
 files: 
-- CHANGELOG
-- MIT-LICENSE
+- CHANGELOG.txt
+- LICENSE.txt
 - Manifest.txt
 - README.txt
 - Rakefile
@@ -68,6 +91,6 @@ rubyforge_project: interpolate
 rubygems_version: 1.0.1
 signing_key: 
 specification_version: 2
-summary: Useful for such things as generating linear motion between points (or arrays of points), multi-channel color gradients, piecewise functions, or even just placing values within intervals.
+summary: Description  Library for generic Interpolation objects. Useful for such things as generating linear motion between points (or arrays of points), multi-channel color gradients, piecewise functions, or even just placing values within intervals.
 test_files: 
 - test/test_all.rb

data/CHANGELOG

@@ -1,17 +0,0 @@
-== 0.2.0
-
-* Changed the library name to "interpolate"
-* Added Array#interpolate that covers uniform arrays and nested arrays
-* Added more tests, documentation, and examples
-
-== 0.1.0
-
-* Gadient calls :interpolate on values for OOP goodness
-* Checks added for respond_to? :interpolate on values
-* Added Numeric#interpolate
-
-== 0.0.1
-
-* Initial coding
-* N-sized arbitrary floating point gradients
-