tonal-tools 8.8.3 → 8.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d17a66bfeffdbb9b385962d18767b8750d67c36ebf6757ca048f7640e905ebaa
-  data.tar.gz: 74e415a1db46af3cb9345280cb7bc56cfebfba8ea223a445785f2d5637507dbd
+  metadata.gz: ff37192dbedd21f500728f844d7d684053161434a23dbe5625fcf0f7de39da4e
+  data.tar.gz: 94670893a608e9fd758a769b34513d31fc8cfa7c19220dd77d887b2d504be7b5
 SHA512:
-  metadata.gz: 9001c74c1d40419f25f6f63061c72bec1535a947e050495bdb2ceaf15253637b9b1bf752fa221e868e0a76ae7139133981579318277c5d7d205ba8a2df4c04d8
-  data.tar.gz: 6bd3ceb1427d2ba7be06155dbe40e9731e2f66752b5ffdac08c45316ce152de7305a3b4d88d83879edca49ddd649da789c05c3ebfd8663f4968bd1ec8969a39f
+  metadata.gz: e2d30aa302feae75b7efd5e225a7a3363a6dd1fe3b04929c5ceaeaec6daf69dfbc703af3c8710525ddc062145a10a7cae35e72d815d2bd996315445538892242
+  data.tar.gz: f57a435920ae18d8541e5eea3053f56c18d61468383b5a9eb006f9bb35595c06941c5442b7d6146fbb2de33efd05a87700285b902096ec32959b6581e202edb4

data/lib/tonal/approximation.rb

@@ -38,7 +38,7 @@ class Tonal::Ratio
       Set.new(ratio: ratio) do |ratios|
         ContinuedFraction.new(antecedent.to_f/consequent, conv_limit).convergents.each do |convergent|
           ratio2 = ratio.class.new(convergent.numerator,convergent.denominator)
-          ratios << ratio2 if ratio.class.within_cents?(self_in_cents, ratio2.to_cents, within) && (ratio2.max_prime <= max_prime) && (ratio2.min_prime >= min_prime)
+          ratios << ratio2 if ratio.class.within_cents?(self_in_cents, ratio2.to_cents, within) && max_prime_at_most?(ratio2, max_prime) && !prime_factor_at_most?(ratio2, min_prime - 1)
           break if ratios.length >= depth
         end
       end
@@ -61,7 +61,7 @@ class Tonal::Ratio
         FractionTree.node(to_f).path.each do |node|
           next if node.number.infinite?
           ratio2 = ratio.class.new(node.number)
-          ratios << ratio2 if ratio.class.within_cents?(self_in_cents, ratio2.to_cents, within) && (ratio2.max_prime <= max_prime) && (ratio2.min_prime >= min_prime)
+          ratios << ratio2 if ratio.class.within_cents?(self_in_cents, ratio2.to_cents, within) && max_prime_at_most?(ratio2, max_prime) && !prime_factor_at_most?(ratio2, min_prime - 1)
           break if ratios.length >= depth
         end
       end
@@ -78,13 +78,15 @@ class Tonal::Ratio
     # @param superpart if the superior part is the numerator or denominator
     #
     def by_superparticular(cents_tolerance: Tonal::Cents::TOLERANCE, depth: DEFAULT_SUPERPART_DEPTH, max_prime: DEFAULT_MAX_PRIME, min_prime: DEFAULT_MIN_PRIME, superpart: :upper)
+      # One of n and n+1 is even, so every candidate has 2 as a factor and none can meet a higher min_prime
+      return Set.new(ratio: ratio) if min_prime > 2
       self_in_cents = to_cents
       within = cents_tolerance.kind_of?(Tonal::Cents) ? cents_tolerance : Tonal::Cents.new(cents: cents_tolerance)
       Set.new(ratio: ratio) do |ratios|
         n = 1
         while true do
           ratio2 = ratio.class.superparticular(n, factor: ratio.to_r, superpart:)
-          ratios << ratio2 if ratio.class.within_cents?(self_in_cents, ratio2.to_cents, within) && (ratio2 != ratio) && (ratio2.max_prime <= max_prime) && (ratio2.min_prime <= min_prime)
+          ratios << ratio2 if ratio.class.within_cents?(self_in_cents, ratio2.to_cents, within) && (ratio2 != ratio) && max_prime_at_most?(ratio2, max_prime) && !prime_factor_at_most?(ratio2, min_prime - 1)
           break if ratios.length >= depth
           n += 1
         end
@@ -113,7 +115,7 @@ class Tonal::Ratio
           while boundary <= max_boundary
             vacinity = ratio.respond_to?(:to_basic_ratio) ? to_basic_ratio.scale(scale) : ratio.scale(scale)
             self.class.neighbors(away: boundary, vacinity: vacinity).each do |neighbor|
-              ratios << neighbor if (neighbor != ratio) && ratio.class.within_cents?(self_in_cents, neighbor.to_cents, within) && (neighbor.max_prime <= max_prime) && (neighbor.min_prime >= min_prime)
+              ratios << neighbor if (neighbor != ratio) && ratio.class.within_cents?(self_in_cents, neighbor.to_cents, within) && max_prime_at_most?(neighbor, max_prime) && !prime_factor_at_most?(neighbor, min_prime - 1)
             end
             boundary += 1
           end
@@ -140,6 +142,22 @@ class Tonal::Ratio
                        end.flatten).to_a
     end
 
+    # Filters approximations without fully factoring them (a Float's convergents
+    # can have huge prime factors). Float::INFINITY skips the factoring.
+    def max_prime_at_most?(candidate, max_prime)
+      return true if max_prime.infinite?
+      Prime.each(max_prime).inject([candidate.antecedent, candidate.consequent]) do |(ante, cons), p|
+        ante /= p while (ante % p).zero?
+        cons /= p while (cons % p).zero?
+        [ante, cons]
+      end.all?{|n| n == 1 }
+    end
+
+    def prime_factor_at_most?(candidate, prime)
+      Prime.each(prime).any?{|p| (candidate.antecedent % p).zero? || (candidate.consequent % p).zero? }
+    end
+    private :max_prime_at_most?, :prime_factor_at_most?
+
     # @return [Array] an array of Tonal::Ratio neighbors in the scaled ratio's grid neighborhood
     # @example
     #   Tonal::Ratio::Approximation.neighbors(vacinity: (3/2r).ratio(reduced:false).scale(256), away: 1)

data/lib/tonal/attributions.rb

@@ -1,4 +1,4 @@
 module Tonal
   TOOLS_PRODUCER = "mTonal"
-  TOOLS_VERSION = "8.8.3"
+  TOOLS_VERSION = "8.9.0"
 end

data/lib/tonal/extensions.rb

@@ -180,28 +180,32 @@ class Numeric
   # @example
   #   (3/2r).prime_vector => Vector[-1, 1]
   # @param reduced
+  # @param limit [Integer] the largest prime to factor by, see Tonal::Ratio#prime_divisions
   #
-  def prime_vector(reduced: false) = ratio(reduced:).prime_vector
+  def prime_vector(reduced: false, limit: Tonal::Ratio::PRIME_LIMIT) = ratio(reduced:).prime_vector(limit:)
   alias :monzo :prime_vector
   alias :prime_exponent_vector :prime_vector
 
-  # @return [Array], self decomposed into its prime factors
+  # @return [Array, nil], self decomposed into its prime factors, or nil if self has a prime factor above limit
   # @example
   #   (31/30r).prime_divisions => [[[31, 1]], [[2, 1], [3, 1], [5, 1]]]
+  # @param limit [Integer] the largest prime to factor by, see Tonal::Ratio#prime_divisions
   #
-  def prime_divisions = [self.numerator.prime_division, self.denominator.prime_division]
+  def prime_divisions(limit: Tonal::Ratio::PRIME_LIMIT) = ratio.prime_divisions(limit:)
 
-  # @return [Integer] the maximum prime factor of self
+  # @return [Integer, nil] the maximum prime factor of self, or nil if self has a prime factor above limit
   # @example
   #   (31/30r).max_prime => 31
+  # @param limit [Integer] the largest prime to factor by, see Tonal::Ratio#prime_divisions
   #
-  def max_prime = prime_divisions.flatten(1).map(&:first).max
+  def max_prime(limit: Tonal::Ratio::PRIME_LIMIT) = ratio.max_prime(limit:)
 
-  # @return [Integer] the minimum prime factor of self
+  # @return [Integer, nil] the minimum prime factor of self, or nil if self has a prime factor above limit
   # @example
   #   (31/30r).min_prime => 2
+  # @param limit [Integer] the largest prime to factor by, see Tonal::Ratio#prime_divisions
   #
-  def min_prime = prime_divisions.flatten(1).map(&:first).min
+  def min_prime(limit: Tonal::Ratio::PRIME_LIMIT) = ratio.min_prime(limit:)
 
   # @return [Vector], self expressed as a Vector
   # @example
@@ -271,18 +275,6 @@ class Integer
   #
   def ed(modulo, equave: 2/1r) = Tonal::ReducedRatio.ed(self, modulo, equave:)
 
-  # @return [Integer] the maximum prime factor of self
-  # @example
-  #  72.max_prime => 3
-  #
-  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
-
   # @return [Integer] the factorial of self
   # @example
   #   5.factorial => 120

data/lib/tonal/ratio.rb

@@ -6,6 +6,7 @@ class Tonal::Ratio
 
   PRECISION = 2
   DEFAULT_EQUAVE = 2/1r
+  PRIME_LIMIT = 10_000
 
   attr_reader :antecedent, :consequent, :equave, :reduced_antecedent, :reduced_consequent
 
@@ -356,21 +357,25 @@ class Tonal::Ratio
     Math.atan2(consequent, antecedent).round(round)
   end
 
-  # @return [Array], self decomposed into its prime factors
+  # @return [Array, nil], self decomposed into its prime factors, or nil if self has a prime factor above limit (e.g. an irrational ratio built from a Float)
   # @example
   #   Tonal::Ratio.new(31/30r).prime_divisions => [[[31, 1]], [[2, 1], [3, 1], [5, 1]]]
+  # @param limit [Integer] the largest prime to factor by
   #
-  def prime_divisions
-    [antecedent.prime_division, consequent.prime_division]
+  def prime_divisions(limit: PRIME_LIMIT)
+    ante = prime_division_within(antecedent, limit)
+    cons = prime_division_within(consequent, limit)
+    [ante, cons] if ante && cons
   end
 
-  # @return [Vector], self represented as a prime vector
+  # @return [Vector, nil], self represented as a prime vector, or nil if self is 1/1 or has a prime factor above limit
   # @example
   #   Tonal::Ratio.new(3/2r).prime_vector => Vector[-1, 1]
+  # @param limit [Integer] the largest prime to factor by
   #
-  def prime_vector
-    pds = prime_divisions
-    return nil if pds.all?(&:empty?)
+  def prime_vector(limit: PRIME_LIMIT)
+    pds = prime_divisions(limit:)
+    return nil if pds.nil? || pds.all?(&:empty?)
 
     max = [pds.first.max{|p| p.first}, pds.last.max{|p| p.first}].compact.max.first
 
@@ -384,20 +389,22 @@ class Tonal::Ratio
   alias :monzo :prime_vector
   alias :prime_exponent_vector :prime_vector
 
-  # @return [Integer] the maximum prime factor of self
+  # @return [Integer, nil] the maximum prime factor of self, or nil if self has a prime factor above limit
   # @example
   #   Tonal::Ratio.new(31/30r).max_prime => 31
+  # @param limit [Integer] the largest prime to factor by
   #
-  def max_prime
-    prime_divisions.flatten(1).map(&:first).max
+  def max_prime(limit: PRIME_LIMIT)
+    prime_divisions(limit:)&.flatten(1)&.map(&:first)&.max
   end
 
-  # @return [Integer] the minimum prime factor of self
+  # @return [Integer, nil] the minimum prime factor of self, or nil if self has a prime factor above limit
   # @example
   #   Tonal::Ratio.new(31/30r).min_prime => 2
+  # @param limit [Integer] the largest prime to factor by
   #
-  def min_prime
-    prime_divisions.flatten(1).map(&:first).min
+  def min_prime(limit: PRIME_LIMIT)
+    prime_divisions(limit:)&.flatten(1)&.map(&:first)&.min
   end
 
   # =================================
@@ -684,6 +691,24 @@ class Tonal::Ratio
     @approximation = Approximation.new(ratio: self)
   end
 
+  # Trial-divides n by the primes up to limit, so a Float's huge binary
+  # fraction is rejected without a full (and very slow) factorization.
+  # A cofactor left below limit**2 has no factor up to limit, so it is prime.
+  def prime_division_within(n, limit)
+    division = []
+    Prime.each(limit) do |prime|
+      break if n <= 1
+      exponent = 0
+      while (n % prime).zero?
+        n /= prime
+        exponent += 1
+      end
+      division << [prime, exponent] if exponent > 0
+    end
+    return division if n <= 1
+    division << [n, 1] if n < limit**2
+  end
+
   def raise_if_negative(*args)
     raise ArgumentError, "Arguments must be greater than zero" if args.any?{|i| i < 0 }
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tonal-tools
 version: !ruby/object:Gem::Version
-  version: 8.8.3
+  version: 8.9.0
 platform: ruby
 authors:
 - Jose Hales-Garcia