numb 0.152.0 → 0.170.0

data/VERSION

@@ -1 +1 @@
-0.152.0
+0.170.0

data/lib/numb/bell.rb

@@ -1,16 +1,13 @@
 class Integer
   def bell?
-    triangle = [[1]]
-    r = 1
-    loop do
-      row = [triangle[r - 1][r - 1]]
-      (1..r).each do |c|
-        row << triangle[r - 1][c - 1] + row[c - 1]
-      end
-      triangle[r] = row
-      return false if row.first > self
-      return true if row.first == self
-      r += 1
-    end
+    in_sequence?(seq: :bell)
   end
+
+  def bell
+    n = self
+    return 1 if zero?
+    (0..(n-1)).map{|k| k.bell * (n-1).choose(k)}.reduce(:+)
+  end
+
+  memoize :bell
 end

data/lib/numb/bernoulli.rb

@@ -2,13 +2,12 @@
 class Integer
   # TODO: Consider http://cims.nyu.edu/~harvey/bernmm/
   def bernoulli
-    return -0.5.to_r if self == 1
-    return 0.to_r if odd?
-    a = []
-    0.upto(self) do |m|
-      a[m] = Rational(1, m + 1)
-      m.downto(1){|j| a[j - 1] = j * (a[j - 1] - a[j])}
-    end
-    a.first
+    return 1 if zero?
+    m = self
+    (m.zero? ? 1 : 0) - (0...m).map do |k| 
+      m.choose(k) * Rational(k.bernoulli, m - k + 1)
+    end.reduce(:+)
   end
+
+  memoize :bernoulli
 end

data/lib/numb/catalan.rb

@@ -4,10 +4,6 @@ class Integer
   end
 
   def catalan?
-    n = -1
-    loop do
-      return true if (cat = (n += 1).catalan) == self
-      return false if cat > self
-    end
+    in_sequence?(seq: :catalan)
   end
 end

data/lib/numb/divisors/abundant.rb

@@ -0,0 +1,58 @@
+# coding: utf-8
+class Integer
+  # An abundant number is a number n for which σ(n) > 2n. That is, the sum of
+  # its divisors exceeds 2n. (See Integer#σ to compute the sum of the divisors
+  # of an arbitrary integer).
+  #
+  # Returns true if the number is abundant; false otherwise. Aliased to
+  # Integer#excessive?.
+  #
+  #     96.abundant?   #=> true
+  #     100.abundant?  #=> true
+  #     345.abundant?  #=> false
+  #
+  def abundant?
+    return false unless positive?
+    σ > (2 * self)
+  end
+
+  alias :excessive? :abundant?
+
+  def abundancy
+    Rational(σ, self)
+  end
+
+  memoize :abundancy
+
+  def friendly?(*others)
+    raise ArgumentError unless others.size >= 1 && others.uniq.size == others.size
+    abundancy = self.abundancy
+    others.all? {|o| o.abundancy == abundancy}
+  end
+
+  def highly_abundant?
+    return true if self == 1
+    (self - 1).downto(1).all?{|m| σ > m.σ }
+  end
+  
+  def primitive_abundant?
+    abundant? and proper_divisors.all?(&:deficient?)
+  end
+
+  def superabundant?
+    return true if self == 1
+    # Constraints due to "Abundant Numbers and the Riemann Hypothesis",
+    # Briggs, 2006, Experimental Mathematics, vol. 15, no. 2
+    ex = primaries.map(&:last)
+    return false unless [ex.last, ex.first] == ex.minmax
+    primaries[1..-1].all? do |b, e|
+      (e - (ex[0] * Math.log(b, primaries[0][0])).floor <= 1) and e < 2**(ex[0] + 2)
+    end or return false
+    return false unless [4, 36].include?(self) or ex.last == 1
+    1.upto(self - 1).all? do |m|
+      m.abundancy < abundancy
+    end
+  end
+  memoize :superabundant?
+end
+

data/lib/numb/divisors/aliquot.rb

@@ -0,0 +1,31 @@
+# coding: utf-8
+class Integer
+  def aliquot_sequence(max_iterations=(self > 100 ? 10 : sqrt),
+                       summatory_function=->(n){ n.aliquot_sum })
+    sequence = [self]
+    max_iterations.floor.times do |limit|
+      sequence << summatory_function[sequence.last]
+      break if sequence[0..-2].include?(sequence.last)
+      return sequence << (1/0.0) if limit.consecutive?(max_iterations)
+    end
+    sequence
+  end
+
+  def sociable?(t)
+    return false unless t >= 3
+    aliquot_sequence(t.succ).last == self
+  end
+
+  def unitary_sociable?(t)
+    return false unless t >= 3
+    seq = aliquot_sequence(t.succ, ->(n){ n.sum_of_unitary_divisors - n})
+    seq.size - 1  == t and seq.last == self
+  end
+
+  def aspiring?(max_iterations=10)
+    return false if perfect? 
+    (last = aliquot_sequence(max_iterations).last).to_f.finite? ? 
+      last.perfect? : 
+      false
+  end
+end

data/lib/numb/divisors/amicable.rb

@@ -0,0 +1,38 @@
+# coding: utf-8
+class Integer
+  def multiamicable?(m, a, b)
+    return false unless m != self and m < self and a.positive? and b.positive?
+    m.σ - m == a*self and σ - self == b*m
+  end
+
+  def amicable?(other)
+    n, m = [self, other].minmax
+    m.multiamicable?(n, 1, 1)
+  end
+
+  def augmented_amicable?(n)
+    m = self
+    [m.σ, n.σ].all?{|sigma| sigma == m + n - 1}
+  end
+
+  def betrothed?(m)
+    σ == m.σ and consecutive?(σ - m)
+  end
+  
+  alias :quasi_amicable? :betrothed?
+  alias :reduced_amicable? :betrothed?
+
+  def breeder?(b)
+    a = self
+    x = (a.σ - a).fdiv(b)
+    abx = a + (b*x)
+    (abx == a.σ) and (abx == b.σ * (x + 1))
+  end
+
+  def unitary_amicable?(n)
+    [n + self, sum_of_unitary_divisors].all? do |other|
+      other == n.sum_of_unitary_divisors
+    end
+  end
+  
+end

data/lib/numb/divisors/perfect.rb

@@ -0,0 +1,73 @@
+# coding: utf-8
+class Integer
+  def k_perfect?(k)
+    σ == k * self
+  end
+
+  alias :multiply_perfect? :k_perfect?
+
+  def perfect?
+    return false if self < 6 or self.odd? or self.to_s !~ /(6|8)$/
+    return false if self != 6 and digital_root != 1  
+    k_perfect?(2)
+  end
+
+ def semiperfect?
+   return false if deficient?
+   return true if perfect?
+   possibles = { 0 => true}
+   proper_sod = (sod = σ || 0) - self
+   proper_divisors.reverse.each do |divisor|
+     possibles.keys.each do |possible|
+       possibles.delete(possible) if possible + sod < self 
+       x = possible + divisor
+       return true if x == self or x == proper_sod 
+       possibles[x] = true if x < self        
+     end
+     sod -= divisor
+   end
+   false
+  end
+  
+ alias :pseudoperfect? :semiperfect?
+ 
+  def almost_perfect?
+    return true if self == 1
+    proper_divisors.reduce(:+) == self - 1
+  end
+
+  alias :least_deficient? :almost_perfect?
+  alias :slightly_defective? :almost_perfect?
+
+  def e_perfect?
+    return false if odd?
+    σe == 2 * self
+  end
+
+  def unitary_perfect?
+    proper_divisors.select do |divisor|
+      unitary_divisor?(divisor)
+    end.reduce(:+) == self
+  end
+
+  def hyperperfect?(k=1)
+    raise ArgumentError unless k >= 1
+    (1 + (k * (σ - self - 1))) == self
+  end
+
+  def superperfect?
+    σ.σ == 2 * self
+  end
+
+  def sublime?
+    number_of_divisors.perfect? and σ.perfect?
+  end
+
+  def primitive_pseudoperfect?
+    pseudoperfect? and proper_divisors.sort.none?(&:pseudoperfect?)
+  end
+
+  def infinitary_perfect?
+    σ∞ == 2*self
+  end
+end

data/lib/numb/divisors.rb

@@ -0,0 +1,389 @@
+# coding: utf-8
+class Integer
+  def weird?
+    return false unless positive?
+    return false if odd? && self < (10 ** 17)
+    not semiperfect? and abundant?
+  end
+  
+  def unusual?
+    prime_factors.max > sqrt
+  end
+
+  def untouchable?
+    # * The first untouchable integer is 2
+    # * Perfect numbers are never untouchable because they can be expressed
+    #   as the sum of their own proper divisors
+    # * If p is prime, the sum of the proper divisors of p**2 is p + 1;
+    #   therefore, no untouchable number is one more than a prime.
+    return false if self < 2 or perfect? or (self - 1).prime?
+    (1..((self - 1)**2)).none? do |m|
+      m.σ - m == self
+    end
+  end
+
+  def unitary_divisor?(x)
+    x.coprime?(self/x)
+  end
+
+  def powerful?
+    return false unless positive?
+    divisors = self.divisors
+    divisors.select {|d| d.prime? }.all?{|prime| divisors.include? (prime ** 2)}
+  end
+
+  alias :handsome? :powerful?
+
+  # An Achilles number is powerful but not a perfect power.
+  #
+  # Returns true if self is an Achilles number; false otherwise.
+  #
+  #     1152.achilles?  #=> true
+  #     4563.achilles?  #=> true
+  #     100.achilles?   #=> false
+  #
+  def achilles?
+    powerful? and not perfect_power?
+  end
+
+  def perfect_power?
+    return false unless positive?
+    return true if self == 1
+    divisors = self.divisors
+    (2..Math.log2(self)).any? { |pow| divisors.any? {|div| (div ** pow) == self} } 
+  end
+
+  def brilliant?
+    pfacts = prime_factors
+    pfacts.size == 2 and pfacts.map{|f| f.to_s.size}.uniq.size == 1
+  end
+
+  def coprime?(x)
+    gcd(x) == 1
+  end
+
+  alias :⊥ :coprime?
+  alias :stranger? :coprime?
+
+  # A deficient number is a number n for which σ(n) < 2n. That is, the sum of
+  # its divisors are less than the number. (To calculate the sum of divisors
+  # for an arbitrary integer see Integer#σ).
+  #
+  # Returns true if the number is deficient; false otherwise.
+  #
+  #     8.deficient?  #=> true
+  #     27.deficient? #=> true
+  #     6.deficient?  #=> false
+  #
+  def deficient?
+    return false unless positive?
+    σ < (2 * self)
+  end
+
+  alias :defective? :deficient?
+
+  def e_divisors
+    return [1] if self == 1
+    pfacts = primaries
+    comb = pfacts.map{|p,a| (1..a).select{|b| a.divides?(b)}.map{|b| p**b}}
+    comb.flatten.permutation(pfacts.size).select do |perm|
+      perm.each_with_index.all?{|x,i| comb[i].include? x}
+    end.map{|perm| perm.reduce(:*)}
+  end
+
+  # An extravagant number has fewer digits than the number of digits in its
+  # prime factorization (including exponents).
+  #
+  # Returns true if self is extravagant; false otherwise. Aliased to
+  # Integer#wasteful?.
+  #
+  #     234.extravagant?  #=> true
+  #     87.extravagant?   #=> true
+  #     81.extravagant?   #=> false
+  #
+  def extravagant?
+    digits.size < prime_division.flatten.reject{|d|d==1}.join.to_i.digits.size
+  end
+
+  alias :wasteful? :extravagant?
+
+  def politeness
+    divisors.select{|d| d > 1}.select{|d| d.odd?}.size
+  end
+
+  def impolite? 
+    not polite?
+  end
+
+  def polite? 
+    return true if self == 1
+    politeness.positive?
+  end
+
+  def proper_divisors
+    divisors.reject {|d| d == self }
+  end
+
+  def divisors
+    return [] unless positive?
+    return [1, self] if prime?
+    (1..isqrt).select { |n| (self % n).zero? }.
+               map {|n| [n, self/n]}.flatten.uniq
+  end
+  memoize :divisors
+
+  def sum_of_divisors
+    @sod ||= divisors.reduce(:+)
+  end
+  alias :σ :sum_of_divisors
+
+  def aliquot_sum
+    return 0 if zero?
+    σ - self
+  end
+
+  def divides?(n)
+    not n.zero? and (self % n).zero?
+  end
+
+  def σe
+    # TODO: If squarefree, the sum of a number’s e-divisors is the number
+    # itself. Do we gain anything significant by special-casing this?
+    e_divisors.reduce(:+)
+  end
+
+  alias :sum_of_e_divisors :σe
+
+  def σ∞
+    infinitary_divisors.reduce :+
+  end
+
+  alias :sum_of_infinitary_divisors :σ∞
+  alias :isigma :σ∞
+
+  def sum_of_unitary_divisors
+    divisors.select{|d| unitary_divisor?(d)}.reduce(:+) or 0
+  end
+
+  def highly_composite?
+    return false if self > 6 and not (abundant? or primorial_product?)
+    return true if [1,4,36].include?(self)
+    minimal? and (self - 1).downto(1).all?{|n| τ > n.τ}
+  end
+
+  alias :julian? :highly_composite?
+
+  def d?
+    knödel?(3)
+  end
+
+  # A number which is either frugal or equidigital.
+  #
+  # Returns true if self is economical; false otherwise.
+  #
+  # See also Integer#equidigital? and Integer#frugal?.
+  #
+  #     243.economical?  #=> true
+  #     7.economical?    #=> true
+  #     989.economical?  #=> false
+  #
+  def economical?
+    equidigital? or frugal?
+  end
+
+  # An equidigital number has the same number of digits as
+  # the number of digits in its prime factorization (including exponents). 
+  #
+  # For example, 35 is equidigital because it has two digits and two 1-digit
+  # prime factors (5 and 7).
+  #
+  # Returns true if self is equidigital; false otherwise.
+  #
+  #     81.equidigital?    #=> true
+  #     49.equidigital?    #=> true
+  #     1287.equidigital?  #=> false
+  #
+  def equidigital?
+    digits.size == prime_division.flatten.reject{|d|d==1}.join.to_i.digits.size
+  end
+
+  def giuga?
+    composite? and prime_factors.uniq.all? do |p|
+      ((self / p) - 1).divides?(p)
+    end
+  end
+
+  def harshad?
+    self >= 1 and (self % digital_sum).zero?
+  end
+
+  alias :niven? :harshad?
+  alias :multidigital? :harshad?
+
+  def hoax?
+    return false unless composite?
+    sum_of_digits == prime_factors.uniq.map{|f| f.sum_of_digits}.reduce(:+)
+  end
+
+  def infinitary_divisors
+    pf = Hash[prime_factors.uniq.map{|f| [f, 0]}]
+    bin = divisors.map do |d|
+      prime_divisors = pf.map(&:first)
+      [d, pf.merge(Hash[d.primaries]).
+        values.
+        map{|v| sprintf("%.#{to_s(2).size}b", v)}.join]
+    end
+    bin = Hash[bin]
+    target = bin[self].chars.map.with_index.to_a.select{|a,b| a == '0'}.map(&:last)
+    bin.select{|d,b| target.all?{|i| b[i] == '0'}}.keys.sort
+  end
+
+  def ore?
+    div = divisors
+    Rational(div.size, div.map{|d| Rational(1, d)}.reduce(:+)).denominator == 1
+  end
+
+  alias :harmonic_divisor? :ore?
+
+  # Implementation of Stewart, B. M. (1954), "Sums of distinct divisors",
+  # American Journal of Mathematics 76: 779–785, doi:10.2307/2372651,
+  # MR0064800
+  def practical?
+    sum = 1
+    k = 2
+    n = self
+    while (n >= k)
+      s = 1
+      u = 0
+      while (n % k == 0)
+        n = n/k
+        s = s * k + 1
+        u += 1
+      end
+      unless (u == 0)
+        return false if (k > sum + 1)
+        sum *= s
+      end
+      k += (k == 2) ? 1 : 2
+    end
+    true
+  end
+
+  def rhonda?(base=10)
+    d = base == 10 ? digits : to_s(base).split(//).map{|_| _.to_i(base)} 
+    d.reduce(:*) == base * (prime_factors.reduce(:+) || 0)
+  end
+
+  def smith?
+    return false if prime?
+    digital_sum == prime_division.map{|d,e| d.digital_sum * e}.reduce(:+)
+  end
+
+  def smooth?(b)
+    prime_factors.none?{|f| f > b}
+  end
+
+  def rough?(k)
+    prime_factors.all?{|f| f >= k}
+  end
+
+  def super_poulet?
+    poulet? and divisors.all?{|d|  ((2**d) - 2).divides?(d)}
+  end
+
+  # Algorithm derived from Formulas for pi(n) and the n-th prime by Sebastian
+  # Martin Ruiz and Jonathan Sondow [arXiv:math/0210312v2 [math.NT]]
+
+  # Returns the number of divisors of self
+  def τ 
+    # TODO: Consider something simpler, and perhaps faster, like
+    # primaries.map(&:last).map(&:succ).reduce(:*)
+    n = self
+    return @nod if defined?(@nod)
+    @nod = (1..isqrt).
+      map {|i|  n.quo(i).to_i - (n - 1).quo(i).to_i }.
+      reduce(:+) * 2
+    @nod -= 1 if square?
+    @nod
+  end
+
+  alias :number_of_divisors :τ 
+  alias :d :τ 
+  memoize :τ 
+
+  def perfect_power
+    return 1 if (n = self) <= 1
+    this = (n - 1).perfect_power.succ
+    this += 1 while (this.prime? or not this.perfect_power?)
+    this
+  end
+  memoize :perfect_power
+
+  def first_with_n_divisors
+    if zero? then 0
+    elsif self == 1 then 1
+    elsif not positive? then nil
+    else
+      pf = prime_factors
+      if pf.uniq == [2]
+        list = []
+        Prime.each do |prime|
+          break if prime > self
+          list << prime
+          exp = 1
+          loop do
+            pow2 = 2 ** exp
+            break if pow2 > self
+            prime **= pow2
+            break if prime > self
+            list << prime
+          end
+        end
+        list.sort.uniq.first(pf.size).reduce(:*)
+      else
+        limit = Prime.first(pf.size).zip(pf.reverse).map{|b,e| b**(e-1)}.reduce(:*)
+        neighbour = ->(e) { (self/e).divisors.reject{|d| d > e} }
+        x, div, exponents = self, divisors, {}
+
+        # TODO: Consider using limit's primaries as an upper limit on the
+        # exponents
+        Prime.each do |b| 
+          max_exponent = Math.log(limit, b).floor
+          d = div.reject{|d| d > max_exponent}.sort.reverse - [1]
+          unless b == 2
+            prev_neighbours = exponents[exponents.keys.last].values.flatten
+            d.reject!{|e, n| not prev_neighbours.include?(e)}
+          end
+          exponents[b] = Hash[d.map{|e| [e, neighbour.(e)]}]
+          break if (x /= b) < 1
+        end
+
+        complete_chain = ->(b, e, goal=self, chain=nil) do
+          chain ||= {chain: [[b, e]]}
+          return chain unless exponents.key?(b) and exponents[b].key?(e)
+          exponents[b][e].map do |n|
+            this = {chain: chain[:chain].dup}
+            this[:chain].pop if this[:chain].last.first == b.next_prime
+            this[:chain] << [b.next_prime, n]
+            e * n < goal ? complete_chain[b.next_prime, n, goal/e, this] : this
+          end
+        end
+
+        exponents[2].keys.map do |e,|
+          complete_chain[2, e].flatten.map{|c| Hash[c[:chain]]}.
+            select{|c| c.values.reduce(:*) == self}.
+            map{|c| c.map{|b,e| b**(e-1)}.reduce(:*)}.
+            reject{|prod| prod > limit}
+        end.flatten.min or limit
+      end
+    end
+  end
+
+  def minimal?
+    τ.first_with_n_divisors == self
+  end
+
+  def square_part
+    divisors.sort.reverse.each{|d| return d if d.square?}
+  end
+end

data/lib/numb/entringer.rb

@@ -5,5 +5,7 @@ class Integer
     return 0 if (self < k or k < 0)
     entringer(k - 1) + (self - 1).entringer(self - k)
   end
+
+  memoize :entringer
 end