tonal-tools 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 691fae166ed9abb7f7bac70c6e28a9a5997faf5c18ac2e18c962763e45b49af7
-  data.tar.gz: 413a77763276622ff1201f2e9cc0fb49d9486843fbd1f1f84d77cfa84a4f2da6
+  metadata.gz: 540d38c024465fdb45af2fbaada5a4fc020857ca03fc9c9e56f6152462e5d38e
+  data.tar.gz: 58637a5d53fe59d3a5feab46e587b3ae08c4d8d837aa3410b5b21d684f90fc12
 SHA512:
-  metadata.gz: cb1ba05cd9cf96e948f25c9a832bfddd7e2e90ff59fbcdb55caf5172ddb13fc65042835ec494e2c39317d520bae8cace1ae832b182c70ee0815b8d09bb1572bf
-  data.tar.gz: 7a813d888fe63b98681f5f6f436106f4a9e3e4c43f697ab705835af59740a26b7cba132f4c2df82e91ddb8180c4160015f6aa1839231578e0070d0f88f3b35aa
+  metadata.gz: d3e97921221dc86faeeae926b23af4c7ed22da2d2c26bc1377493d6442cb9dcafaa2ab60ee430b5b804e550fbfaa6e4c19c8b2379c2941b1d4407f7000649845
+  data.tar.gz: e5850e74a54e375834e7b578e2438146907a6a9107e6b95e72366a531f92cdab734f4d273ac8be48877d0c19ca36940dc2acf9eb3f4ded6baadf4b46eb21c54d

data/lib/tonal/extensions.rb

@@ -5,54 +5,61 @@ class Prime
   # @param lower bound
   # @param upper bound
   #
-  def self.within(lower, upper)
-    self.each(upper).reject{|p| p < lower}
-  end
+  def self.within(lower=0, upper) = self.each(upper).reject{|p| p < lower}
 end
 
 class Numeric
+  # @return [Numeric] translated modularly
+  # @example
+  #   Math::PI.modulo_translate(-3, 3) => -2.858407346410207
+  # @param lower the lower bound of the modulo range
+  # @param upper the upper bound of the modulo range
+  #
+  def modulo_translate(lower=0, upper)
+    range = (upper - lower) == 0 ? 1 : upper - lower
+    (self - lower) % range + lower
+  end
+
   # @return [Array] a tuple of self offset positively/negatively
   # @example
   #   Math::PI.plus_minus(3)
   #     => [6.141592653589793, 0.14159265358979312]
   # @param offset plus and minus distance from self
   #
-  def plus_minus(offset)
-    [self + offset, self - offset]
-  end
+  def plus_minus(offset) = [self + offset, self - offset]
+  alias :min_plus :plus_minus
+
+  # @return [Array] a tuple of self divided and multiplied by factor
+  # @example
+  #   Math::PI.div_times(3) => [1.0471975511965976, 9.42477796076938]
+  # @param [Numeric]
+  #
+  def div_times(factor) = [self / factor, self * factor]
 
   # @return [Tonal::ReducedRatio] the octave reduced ratio of self
   # @example
   #   (2**(1.0/12)).ratio => (4771397596969315/4503599627370496)
   #
-  def to_ratio(reduced: true, equave: 2/1r)
-    reduced ? Tonal::ReducedRatio.new(self, equave: equave) : Tonal::Ratio.new(self, equave: equave)
-  end
+  def to_ratio(reduced: true, equave: 2/1r) = reduced ? Tonal::ReducedRatio.new(self, equave: equave) : Tonal::Ratio.new(self, equave: equave)
   alias :ratio :to_ratio
 
   # @return [Float], the degrees on a circle of self
   # @example
   #   (2**(6.0/12)).period_degrees => 180.0
   #
-  def period_degrees
-    self.ratio.period_degrees
-  end
+  def period_degrees = self.ratio.period_degrees
 
   # @return [Tonal::Log] the log of self to the given base
   # @example
   #   (3/2r).log(10) => 0.17609125905568124
   #
-  def log(base)
-    Tonal::Log.new(logarithmand: self, base: base)
-  end
+  def log(base) = Tonal::Log.new(logarithmand: self, base: base)
 
   # @return [Tonal::Log2] the log2 of self
   # @example
   #   (3/2r).log2 => 0.5849625007211562
   #
-  def log2
-    Tonal::Log2.new(logarithmand: self)
-  end
+  def log2 = Tonal::Log2.new(logarithmand: self)
   alias :to_log2 :log2
   alias :span :log2
 
@@ -60,31 +67,23 @@ class Numeric
   # @example
   #   700.0.cents => 700.0
   #
-  def cents
-    Tonal::Cents.new(cents: self)
-  end
+  def cents = Tonal::Cents.new(cents: self)
 
   # @return [Tonal::Cents] of self interpreted as a cents quantity
   # @example
   #   700.0.¢ => 700.0
   #
-  def ¢
-    cents
-  end
+  def ¢ = cents
 
   # @return [Tonal::Cents] of self interpreted as a ratio
   # @example
   #   (3/2r).to_cents => 701.96
   #
-  def to_cents
-    self.log2.to_cents
-  end
+  def to_cents = self.log2.to_cents
 
   # @return [Tonal::Hertz] of self
   #
-  def hz
-    Tonal::Hertz.new(self)
-  end
+  def hz = Tonal::Hertz.new(self)
   alias :to_hz :hz
 
   # @return [Step] the step of self in the given modulo
@@ -92,133 +91,89 @@ class Numeric
   #   (5/4r).step(12) => 4\12
   # @param modulo
   #
-  def step(modulo=12)
-    to_log2.step(modulo)
-  end
+  def step(modulo=12) = to_log2.step(modulo)
 
   # @return [Float] the log product complexity of self
   # @example
-  #   (3/2r).tenney_height => 2.584962500721156
+  #   (3/2r).benedetti_height => 6
   #
-  def benedetti_height
-    self.ratio.benedetti_height
-  end
+  def benedetti_height = self.ratio.benedetti_height
   alias :product_complexity :benedetti_height
 
   # @return [Integer] the product complexity of self
   # @example
-  #   (3/2r).benedetti_height => 6
+  #   (3/2r).tenney_height => 2.584962500721156
   #
-  def tenney_height
-    self.ratio.tenney_height
-  end
+  def tenney_height = self.ratio.tenney_height
   alias :log_product_complexity :tenney_height
 
   # @return [Integer] the Weil height
   # @example
   #   (3/2r).weil_height => 3
   #
-  def weil_height
-    self.ratio.weil_height
-  end
+  def weil_height = self.ratio.weil_height
 
   # @return [Tonal::Log2] the log of Weil height
   # @example
   #   (3/2r).log_weil_height => 1.5849625007211563
   #
-  def log_weil_height
-    self.ratio.log_weil_height
-  end
+  def log_weil_height = self.ratio.log_weil_height
 
   # @return [Integer] the Wilson height
   # @example (14/9r).wilson_height => 13
   #
-  def wilson_height(reduced: true, equave: 2/1r, prime_rejects: [2])
-    self.ratio(reduced: reduced, equave: equave).wilson_height(prime_rejects: prime_rejects)
-  end
+  def wilson_height(reduced: true, equave: 2/1r, prime_rejects: [2]) = self.ratio(reduced: reduced, equave: equave).wilson_height(prime_rejects: prime_rejects)
 
   # @return [Float] the cents difference between self and its step in the given modulo
   # @example
   #   (3/2r).efficiency(12) => -1.955000865387433
   # @param modulo
   #
-  def efficiency(modulo)
-    (Tonal::Cents::CENT_SCALE * step(modulo).step / modulo.to_f) - to_cents
-  end
+  def efficiency(modulo) = (Tonal::Cents::CENT_SCALE * step(modulo).step / modulo.to_f) - to_cents
 
   # @return [Interval] beween self (upper) and ratio (lower)
   # @example
   #   (133).interval_with(3/2r) => 133/96 (133/128 / 3/2)
   # @param ratio
   #
-  def interval_with(ratio)
-    Tonal::Interval.new(self.ratio, ratio)
-  end
+  def interval_with(ratio) = Tonal::Interval.new(self.ratio, ratio)
 
   # @return [Vector], self represented as a prime vector
   # @example
   #   (3/2r).prime_vector => Vector[-1, 1]
   #
-  def prime_vector
-    self.ratio.prime_vector
-  end
+  def prime_vector = self.ratio.prime_vector
   alias :monzo :prime_vector
 
   # @return [Array], self decomposed into its prime factors
   # @example
   #   (31/30r).prime_divisions => [[[31, 1]], [[2, 1], [3, 1], [5, 1]]]
   #
-  def prime_divisions
-    self.ratio.prime_divisions
-  end
+  def prime_divisions = self.ratio.prime_divisions
 
   # @return [Integer] the maximum prime factor of self
   # @example
   #   (31/30r).max_prime => 31
   #
-  def max_prime
-    prime_divisions.flatten(1).map(&:first).max
-  end
+  def max_prime = prime_divisions.flatten(1).map(&:first).max
 
   # @return [Integer] the minimum prime factor of self
   # @example
   #   (31/30r).min_prime => 2
   #
-  def min_prime
-    prime_divisions.flatten(1).map(&:first).min
-  end
-
-  # @return [Integer] the product complexity of self
-  # @example
-  #   (3/2r).benedetti_height => 6
-  #
-  def benedetti_height
-    numerator * denominator
-  end
-
-  # @return [Float] the log product complexity of self
-  # @example
-  #   (3/2r).tenney_height => 2.584962500721156
-  #
-  def tenney_height
-    Tonal::Log2.new(logarithmand: benedetti_height)
-  end
+  def min_prime = prime_divisions.flatten(1).map(&:first).min
 
   # @return [Tonal::ReducedRatio], the Ernst Levy negative of self
   # @example
   #  (7/4r).negative => (12/7)
   #
-  def negative
-    self.ratio.negative
-  end
+  def negative = self.ratio.negative
 
   # @return [Tonal::ReducedRatio], the ratio rotated on the given axis, default 1/1
   # @example
   #   (3/2r).mirror => (4/3)
   #
-  def mirror(axis=1/1r)
-    self.ratio.mirror(axis)
-  end
+  def mirror(axis=1/1r) = self.ratio.mirror(axis)
 end
 
 class Rational
@@ -226,34 +181,26 @@ class Rational
   # @example
   #   (3/2r).to_vector => Vector[3, 2]
   #
-  def to_vector
-    Vector[self.numerator, self.denominator]
-  end
+  def to_vector = Vector[self.numerator, self.denominator]
   alias :vector :to_vector
 
   # @return [Array], self decomposed into its prime factors
   # @example
   #   (31/30r).prime_divisions => [[[31, 1]], [[2, 1], [3, 1], [5, 1]]]
   #
-  def prime_divisions
-    self.ratio.prime_divisions
-  end
+  def prime_divisions = self.ratio.prime_divisions
 
   # @return [Integer] the maximum prime factor of self
   # @example
   #   (31/30r).max_prime => 31
   #
-  def max_prime
-    self.ratio.max_prime
-  end
+  def max_prime = self.ratio.max_prime
 
   # @return [Integer] the minimum prime factor of self
   # @example
   #   (31/30r).min_prime => 2
   #
-  def min_prime
-    self.ratio.min_prime
-  end
+  def min_prime = self.ratio.min_prime
 end
 
 class Integer
@@ -263,34 +210,26 @@ class Integer
   # @example
   #  72.max_prime => 3
   #
-  def max_prime
-    self.prime_division.map(&:first).max
-  end
+  def max_prime = self.prime_division.map(&:first).max
 
   # @return [Integer] the minimum prime factor of self
   # @example
   #   72.min_prime => 2
   #
-  def min_prime
-    self.prime_division.map(&:first).min
-  end
+  def min_prime = self.prime_division.map(&:first).min
 
   # @return [Integer] the factorial of self
   # @example
   #   5.factorial => 120
   #
-  def factorial
-    (2..self).reduce(1, :*)
-  end
+  def factorial = (2..self).reduce(1, :*)
 
   # @return [Boolean] if self is coprime with i
   # @example
   #   25.coprime?(7) => true
   #   25.coprime?(5) => false
   #
-  def coprime?(i)
-    self.gcd(i) == 1
-  end
+  def coprime?(i) = self.gcd(i) == 1
 
   # @return [Array] list of integers that are coprime with self, up to the value of self
   # @example
@@ -308,9 +247,7 @@ class Integer
   # @example
   #   10.phi => 4
   #
-  def phi
-    coprimes.count
-  end
+  def phi = coprimes.count
   alias :totient :phi
 
   # @return [Array] of integers that are n-smooth with self
@@ -358,43 +295,33 @@ class Array
   # @param min_size
   # @param value
   #
-  def rpad(min_size, value = nil)
-    self.dup.rpad!(min_size, value)
-  end
+  def rpad(min_size, value = nil) = self.dup.rpad!(min_size, value)
 
   # @return [Vector] self converted to a vector
   # @example
   #   [3,2].to_vector => Vector[3, 2]
   #
-  def to_vector
-    Vector[*self]
-  end
+  def to_vector = Vector[*self]
   alias :vector :to_vector
 
   # @return [Integer] least common multiple of integer elements of self
   # @example
   #   [3, 2, 7].lcm => 42
   #
-  def lcm
-    self.reduce(1, :lcm)
-  end
+  def lcm = self.reduce(1, :lcm)
 
   # @return [Array] of numerators of elements of self
   # @example
   #   [3/2r, 5/4r].numerators => [3, 5]
   #
-  def numerators
-    self.map(&:numerator)
-  end
+  def numerators = self.map(&:numerator)
   alias :antecedents :numerators
 
   # @return [Array] of denominators of elements of self
   # @example
   #   [Tonal::Ratio.new(3,2), Tonal::Ratio.new(5,4)].denominators => [2, 4]
   #
-  def denominators
-    self.map(&:denominator)
-  end
+  def denominators = self.map(&:denominator)
   alias :consequents :denominators
 
   # @return [Array] an array of normalized ratios
@@ -410,25 +337,57 @@ class Array
   # @example
   #   [3/2r, 4/3r].to_cents => [701.96, 498.04]
   #
-  def to_cents
-    self.map{|r| r.to_cents}
-  end
+  def to_cents = self.map{|r| r.to_cents}
   alias :cents :to_cents
 
   # @return [Float] the mean of the elements of self
   # @example
   #   [1, 2].mean => 1.5
   #
-  def mean
-    self.sum / self.count.to_f
-  end
+  def mean = self.sum / self.count.to_f
 
   # @return [Tonal::ReducedRatio] ratio reconstructed from the result of a prime factor decomposition
   # @example
   #   [[[3, 1]], [[2, 1]]].ratio_from_prime_divisions => (3/2)
   #
-  def ratio_from_prime_divisions
-    Tonal::Ratio.new(Prime.int_from_prime_division(self.first), Prime.int_from_prime_division(self.last))
+  def ratio_from_prime_divisions = Tonal::Ratio.new(Prime.int_from_prime_division(self.first), Prime.int_from_prime_division(self.last))
+
+  # @return [Array] translated by value
+  # @example
+  #   [0.24184760813024642, 0.49344034900361244, 0.07231824070126536].translate(-0.07231824070126536) = [0.16952936742898106, 0.4211221083023471, 0.0]
+  # @param value [Numeric] the value that is translating self
+  #
+  def translate(value) = self.map{|e| e + value}
+
+
+  # @return [Array] rescaled by new minimum and new maximum
+  # @example
+  #   [0.47943068514319154, 0.7161083818132802, 0.19855867360591783].rescale(0,3)
+  #   => [1.6280871600341376, 3.0, 0.0]
+  # @param new_min
+  # @param new_max
+  #
+  def rescale(new_min=0, new_max)
+    old_min = min
+    old_max = max
+
+    self.map do |x|
+      new_min + ((x - old_min) * (new_max - new_min)) / (old_max - old_min)
+    end
+  end
+
+  # @return [Array] translated modularly
+  # @example
+  #   [-6.617469071022061, 4.755369851099594, 7.588140911919945, -6.49706614430203].modulo_translate(-3, 5)
+  #   => [2.382530928977939, 4.755369851099594, -1.411859088080055, 2.50293385569797]
+  # @param lower the lower bound of the modulo range
+  # @param upper the upper bound of the modulo range
+  #
+  def modulo_translate(lower=0, upper)
+    range = upper - lower + 1
+    map do |value|
+      (value - lower) % range + lower
+    end
   end
 end
 
@@ -439,9 +398,7 @@ class Vector
   # @param reduced
   # @param equave
   #
-  def to_ratio(reduced: true, equave: 2/1r)
-    reduced ? Tonal::ReducedRatio.new(*self, equave: equave) : Tonal::Ratio.new(*self, equave: equave)
-  end
+  def to_ratio(reduced: true, equave: 2/1r) = reduced ? Tonal::ReducedRatio.new(*self, equave: equave) : Tonal::Ratio.new(*self, equave: equave)
   alias :ratio :to_ratio
 end
 
@@ -451,9 +408,7 @@ module Math
   #   Math.factorial(10) => 3628800
   # @param limit
   #
-  def self.factorial(limit)
-    (2..limit).reduce(1, :*)
-  end
+  def self.factorial(limit) = (2..limit).reduce(1, :*)
 
   PHI = (1 + 5**(1.0/2))/2
 end

data/lib/tonal/ratio.rb

@@ -456,6 +456,7 @@ class Tonal::Ratio
     ratio = ratio.ratio
     [self - ratio, self + ratio]
   end
+  alias :min_plus :plus_minus
 
   # @return [Cents] cent difference between self and other ratio
   # @example

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tonal-tools
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Jose Hales-Garcia
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-01-16 00:00:00.000000000 Z
+date: 2024-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yaml
@@ -191,7 +191,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '3.1'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.5.4
 signing_key:
 specification_version: 4
 summary: Tonal tools