numb 0.152.0 → 0.170.0

data/lib/numb/figurate.rb

@@ -0,0 +1,138 @@
+# coding: utf-8
+class Integer
+  def square?
+    return false unless zero? or (positive? and to_s(16)[-1] =~ /[0149]/)
+    (sq = sqrt).finite? ? sq.integer? : nil
+  end
+
+  def square_triangular?
+    square? and triangular?
+  end
+
+  def squared_triangular?
+    square? and sqrt.to_i.triangular?
+  end
+
+  def square_free?
+     not μ.zero?
+  end
+
+  def centered_n_gonal?(n)
+    raise ArgumentError unless n > 2
+    Rational(
+      -n + Math.sqrt( n**2 - 8 * (n - n * self) ), 
+                  2 * n
+    ).denominator == 1
+  end
+
+  def centered_cube?
+    1.upto(Math.cbrt(self)).any? do |n|
+      self == n**3 + (n - 1) ** 3
+    end
+  end
+
+  def centered_hexagonal?
+    n = self - 1
+    n.divides?(6) and (n/6).triangular?
+  end
+
+  def centered_pentagonal?
+    n = self - 1
+    n.divides?(5) and (n/5).triangular?
+  end
+
+  def centered_square?
+    centered_n_gonal? 4
+  end
+
+  def centered_triangular?
+    centered_n_gonal?(3)
+  end
+
+  def cube?
+    Math.cbrt(self).integer?
+  end
+
+  def decagonal?
+    n_gonal?(10)
+  end
+
+  def n_gonal?(n)
+    raise ArgumentError unless n.is_a?(Integer) and n >= 3
+    return true if zero?
+    ((Math.sqrt((8*n - 16)*self + (n-4)**2) + n - 4) / (2*n - 4)).integer?
+  end
+
+  def dodecagonal?
+    n_gonal?(12)
+  end
+
+  def heptagonal?
+    n_gonal?(7)
+  end
+
+  def hexagonal?
+    return true if zero?
+    ((Math.sqrt((8*self) + 1) + 1)/4).integer?
+  end
+
+  def myriagonal?
+    n_gonal?(10_000)
+  end
+
+  def near_square?(k)
+    (self - k).square?
+  end
+
+  def octagonal?
+    n_gonal?(8)
+  end
+
+  def pyramidal(r)
+    n = self
+    (Rational(1, 6) * n * n.succ * (((r - 2) * n) + (5 - r))).to_i
+  end
+
+  def octahedral
+    (Rational(self, 3) * (2 * self**2 + 1)).to_i
+  end
+
+  def octahedral?
+    in_sequence?(seq: :octahedral)
+  end
+
+  def triangular?
+    n_gonal?(3)
+  end
+
+  def pentagonal?
+    n_gonal?(5)
+  end
+
+  def pentatope
+    (Rational(tetrahedral, 4) * (self + 3)).to_i
+  end
+
+  def star
+    6 * self * (self - 1) + 1
+  end
+
+  def star?
+    return true if self == 1
+    return false unless [1, 4].include?(digital_root) and 
+      to_s.end_with?(*%w{01 13 21 33 37 41 53 61 73 81 93})
+    centered_n_gonal?(12)
+  end
+
+  def tetrahedral
+    pyramidal(3)
+  end
+
+  def stella_octangula
+    octahedral + 8 * (self - 1).tetrahedral
+  end
+
+  def stella_octangula?
+    in_sequence?(seq: :stella_octangula)
+  end
+end

data/lib/numb/in_sequence.rb

@@ -0,0 +1,11 @@
+# coding: utf-8
+class Integer 
+  def in_sequence?(args)
+    args = {range: (1..self), cond: :<, initial: []}.merge(args)
+    return true if Array(args[:initial]).include?(self)
+    args[:range].each do |n|
+      next if (term = n.send(args[:seq])).send(args[:cond], self)
+      return term == self ? true : false
+    end
+  end
+end

data/lib/numb/jacobsthal_lucas.rb

@@ -1,10 +1,9 @@
 class Integer
   def jacobsthal_lucas?
-    [self + 1, self - 1].any? do |n|
-      exp = Math.log2(n)
-      if exp.integer?
-        self == 2**exp + (-1)**exp
-      end
-    end
+    in_sequence?(seq: :jacobsthal_lucas, initial: 2)
+  end
+
+  def jacobsthal_lucas
+    lucas2(1, -2)
   end
 end

data/lib/numb/knuth.rb

@@ -7,9 +7,6 @@ class Integer
   end
 
   def knuth?
-    downto(0) do |n|
-      next if (k = n.knuth) > self
-      return k == self ? true : false
-    end
+    in_sequence?(range: downto(0), seq: :knuth, cond: :>)
   end
 end

data/lib/numb/lucas.rb

@@ -1,9 +1,9 @@
 class Integer
   def lucas?
-    return true if (@@lucas ||= [2,1]).include?(self)
-    while @@lucas.last < self
-      @@lucas.push(@@lucas[-2] + @@lucas[-1])
-    end
-    @@lucas.last == self
+    in_sequence?(seq: :lucas, initial: [2])
+  end
+
+  def lucas
+    lucas2(1, -1)
   end
 end

data/lib/numb/lucas2.rb

@@ -0,0 +1,11 @@
+# coding: utf-8
+class Integer
+  def lucas2(p, q)
+    d = (p**2) - (4*q)
+    raise ArgumentError unless d > 0
+    d_root = d.sqrt
+    (Rational(p + d_root, 2)**self + Rational(p - d_root, 2)**self).round
+  end
+
+  memoize :lucas2
+end

data/lib/numb/lychrel.rb

@@ -1,8 +1,4 @@
 class Integer
-  def palindrome?
-    reverse == self
-  end
-
   def lychrel?
     n = self
     # This limit is as arbitrary as it looks

data/lib/numb/palindrome.rb

@@ -0,0 +1,8 @@
+# coding: utf-8
+class Integer
+  def palindrome?(base=10)
+    base(base) == base(base).reverse
+  end
+
+  alias :palindromic? :palindrome?
+end

data/lib/numb/pell_lucas.rb

@@ -0,0 +1,9 @@
+class Integer
+  def pell_lucas?
+    in_sequence?(seq: :pell_lucas, initial: [2])
+  end
+
+  def pell_lucas
+    lucas2(2, -1)
+  end
+end

data/lib/numb/primes.rb

@@ -0,0 +1,164 @@
+# coding: utf-8
+require 'prime'
+
+class Integer
+  def almost_prime?(k)
+    Ω == k
+  end
+
+  def balanced_prime?
+    return false unless prime? and self >= 5
+    primes, before = Prime.each, 2
+    primes.each do |prime|
+      return ((before + primes.next) / 2) == self if prime == self
+      before = prime
+    end
+  end
+
+  # A dihedral prime is a prime number that appears as itself or another prime
+  # when rendered on a seven-segment display of a calculator and... 
+  #
+  # * Rotated 180°.  
+  # * Mirrored.  
+  # * Rotated 180° and mirrored.
+  #
+  # For example, 120121 is a dihedral prime. It is 121021 when rotated,
+  # 151051 (another prime) when mirrored, and 150151 when rotated and
+  # mirrored.
+  #
+  # Returns true if self is a dihedral prime; false otherwise.
+  #
+  #     101.dihedral_prime?  #=> true
+  #     181.dihedral_prime?  #=> true
+  #     7.dihedral_prime?    #=> false
+  #
+  def dihedral_prime?
+    return false unless prime? and to_s.match(/^[01825]+$/)
+    mirror = ->(n){ n.to_s.gsub(/([25])/){|orig| orig == '2' ? '5' : '2'}.to_i }
+    [reverse, mirror[self], mirror[reverse]].all?(&:prime?)
+  end
+
+  # An emrip is a prime whose reversed digits give a different prime. For
+  # example, 17 is an emrip because 71 is also prime.
+  #
+  # Returns true if self is an emrip; false otherwise.
+  #
+  #     1009.emrip?  #=> true
+  #     1193.emrip?  #=> true
+  #     7.emrip?     #=> false
+  #
+  def emrip?
+    prime? and reverse != self and reverse.prime?
+  end
+
+  def full_reptend_prime?
+    prime? and primitive_root?(10)
+  end
+
+  def interprime?
+    return false if prime?
+    self == (next_prime + prev_prime)/2
+  end
+
+  def mersenne_prime?
+    mersenne? and prime?
+  end
+
+  def next_prime
+    p = succ
+    p += 1 until p.prime?
+    p
+  end
+  
+  def prev_prime
+    p = self - 1
+    p -= 1 until p.prime?
+    p
+  end
+
+  def fermat_pseudoprime?(a=10)
+    return false unless composite?
+    q = self
+    raise ArgumentError unless a >= 2
+    raise ArgumentError unless (q - 2) >= a
+    (a**(q-1)).modulo(q) == 1
+  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 primes equal to or less than self
+  def π
+    x = self
+    return 0 if x == 1
+    @prime_count ||= ([2] + (3..x).select(&:odd?)).map do |j|
+      1 + ( ((2 - j.τ)/j).floor ).floor
+    end.reduce(:+)
+  end
+  alias :prime_pi :π
+  alias :prime_count :π
+
+  def prime_signature
+    prime_division.map{|base, exponent| exponent}.sort.reverse
+  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, after many eons, the nth prime, where n = self
+  def nth_prime
+    n = self
+    return 2 if n == 1
+    raise ArgumentError if n < 1
+    (2..( 2*n * Math.log(n) + 2).floor).map do |k|
+      1 - (k.π.fdiv(n)).floor
+    end.reduce(:+) + 2
+  end
+
+  alias :prime :nth_prime
+  
+  def sophie_germain_prime?
+    prime? and (2*self).succ.prime?
+  end
+
+  def safe_prime?
+    prime? and odd? and ((self - 1) / 2).prime?
+  end
+
+  def semiprime?
+    Ω == 2
+  end
+
+  def composite?
+    self > 1 and not prime?
+  end
+
+  def twin_prime?(p)
+    [p, self].all?(&:prime?) and p == self + 2
+  end
+
+
+  alias :primaries :prime_division
+
+  def number_of_distinct_prime_factors
+    prime_factors.uniq.size
+  end
+  alias :omega :number_of_distinct_prime_factors
+  alias :ω :number_of_distinct_prime_factors
+
+  def number_of_prime_factors
+    prime_factors.size
+  end
+  alias :bigomega :number_of_prime_factors
+  alias :Ω :number_of_prime_factors
+
+  def prime_factors
+    return [] if zero?
+    prime_division.map{|pair| [pair.first] * pair.last}.flatten
+  end
+
+  def wieferich_prime?
+    return false unless prime?
+    (2**(self - 1)).modulo(self ** 2) == 1
+  end
+end

data/lib/numb/pronic.rb

@@ -6,4 +6,5 @@ class Integer
 
   alias :heteromecic? :pronic?
   alias :oblong? :pronic?
+  alias :promic? :pronic?
 end

data/lib/numb/q.rb

@@ -0,0 +1,13 @@
+# coding: utf-8
+class Integer
+  def q
+    return 1 if (n = self) <= 2
+    (n - (n - 1).q).q + (n - (n - 2).q).q
+  end
+
+  memoize :q
+
+  def q?
+    (1..(self ** 2)).any?{|n| n.q == self} or nil
+  end
+end

data/lib/numb/schr/303/266der.rb

@@ -0,0 +1,20 @@
+# coding: utf-8
+class Integer
+  def schröder
+    return 1 if zero?
+    n = self
+    (n-1).schröder + (0...n).map do |k| 
+      k.schröder * (n - 1 - k).schröder
+    end.reduce(:+)
+  end
+  
+  memoize :schröder
+
+  alias :schroder :schröder
+
+  def schröder?
+    in_sequence?(seq: :schröder, initial: 1)
+  end
+
+  alias :schroder? :schröder?
+end

data/lib/numb/segmented.rb

@@ -0,0 +1,29 @@
+# coding: utf-8
+class Integer
+  def segmented
+    return self if self <= 2
+    this = ((n = self)-1).segmented.succ
+
+    sum = Hash.new{|h, k| h[k] = k.map(&:segmented).reduce(:+) }
+    
+    priors_sum = ->(target) do
+      (n - 2).downto(1).any? do |start|
+        (start.succ..(n-1)).any? do |stop|
+          break if (s = sum[ start..stop ]) > target
+          s == target
+        end
+      end
+    end
+
+    this += 1 while priors_sum[ this ]
+    this
+  end
+
+  memoize :segmented
+
+  def segmented?
+    in_sequence?(seq: :segmented)
+  end
+
+  alias :prime_number_of_measurement? :segmented?
+end

data/lib/numb/stirling.rb

@@ -0,0 +1,9 @@
+# coding: utf-8
+class Integer
+  def stirling(m)
+    n = self
+    return 1 if (n.zero? and m.zero?) or m == n 
+    return 0 if m > n or m.zero? or n.zero?
+    (n-1).stirling(m-1) - (n-1)*(n-1).stirling(m)
+  end
+end

data/lib/numb/stirling2.rb

@@ -0,0 +1,9 @@
+# coding: utf-8
+class Integer
+  def stirling2(m)
+    n = self
+    return 1 if (n.zero? and m.zero?) or m == n 
+    return 0 if m > n or m.zero? or n.zero?
+    (n-1).stirling2(m-1) + m * (n-1).stirling2(m)
+  end
+end

data/lib/numb/strictly_non_palindromic.rb

@@ -1,10 +1,6 @@
-class String
-  def palindrome?; self == reverse; end
-end
-
 class Integer
   def strictly_non_palindromic?
     return true if (0..4).include?(self) or self == 6
-    prime? and (2..(isqrt)).none?{|base| base(base).palindrome?}
+    prime? and (2..isqrt).none?{|base| palindrome?(base)}
   end
 end

data/lib/numb/super_catalan.rb

@@ -0,0 +1,17 @@
+# coding: utf-8
+class Integer
+  def super_catalan
+    n = self
+    return 1 if n <= 2
+    Rational(
+      3 * ((2 * n) - 3) * (n - 1).super_catalan - (n - 3) * (n - 2).super_catalan,
+      n
+    ).to_i
+  end
+
+  memoize :super_catalan
+
+  def super_catalan?
+    in_sequence?(seq: :super_catalan)
+  end
+end

data/lib/numb/super_d.rb

@@ -0,0 +1,6 @@
+# coding: utf-8
+class Integer
+  def super_d?(d)
+    (d * self**d).to_s.include?(d.to_s * d)
+  end
+end

data/lib/numb/takeuchi.rb

@@ -0,0 +1,18 @@
+# coding: utf-8
+class Integer
+  def takeuchi
+    n = self
+    return n if n <= 1
+    (0..n-2).map do |k|
+      (
+        (2 * (n + k - 1).choose(k)) - (n + k).choose(k)
+      ) * (n - k - 1).takeuchi
+    end.reduce(:+) + (1..n).map(&:catalan).reduce(:+)
+  end
+
+  memoize :takeuchi
+
+  def takeuchi?
+    in_sequence?(seq: :takeuchi)
+  end
+end

data/lib/numb/unhappy.rb

@@ -2,4 +2,6 @@ class Integer
   def unhappy?
     not happy?
   end
+
+  alias :sad? :unhappy?
 end

data/lib/numb.rb

@@ -17,27 +17,6 @@ end
 end
   
 class Integer
-  def number_of_distinct_prime_factors
-    prime_factors.uniq.size
-  end
-  alias :omega :number_of_distinct_prime_factors
-  alias :ω :number_of_distinct_prime_factors
-
-  def number_of_prime_factors
-    prime_factors.size
-  end
-  alias :bigomega :number_of_prime_factors
-  alias :Ω :number_of_prime_factors
-
-  def prime_factors
-    return [] if zero?
-    prime_division.map{|pair| [pair.first] * pair.last}.flatten
-  end
-
-  def politeness
-    divisors.select{|d| d > 1}.select{|d| d.odd?}.size
-  end
-
   def sqrt
     Math.sqrt(self)
   end
@@ -46,28 +25,6 @@ class Integer
     sqrt.floor
   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 digital_root
     self == 0 ? 0 : 1 + ((self - 1) % 9)
   end
@@ -81,16 +38,7 @@ class Integer
   def digits
     self.to_s.split(//).map{|d| d.to_i}
   end
-
-  def divides?(n)
-    not n.zero? and (self % n).zero?
-  end
 end
 
-require 'prime'
-
-class Integer
-  alias :primaries :prime_division
-end
 
-Dir.glob(File.dirname(__FILE__) + '/numb/*.rb').each {|file| require file}
+Dir.glob(File.dirname(__FILE__) + '/numb/**/*.rb').each {|file| require file}

data/spec/numb/first_with_n_divisors_spec.rb

@@ -0,0 +1,15 @@
+# coding: utf-8
+describe Integer, "#first_with_n_divisors" do
+  # A005179
+  @seq = [1,2,4,6,16,12,64,24,36,48,1024,60,4096,192,144,
+          120,65536,180,262144,240,576,3072,4194304,360,
+          1296,12288,900,960,268435456,720,1073741824,840,
+          9216,196608,5184,1260,68719476736,786432,36864,
+          1680,1099511627776,2880]
+
+  @seq.to_enum.with_index(1).each do |d, n|
+    it "returns #{d} as the first number with exactly #{n} divisors" do
+      n.first_with_n_divisors.should == d
+    end
+  end
+end

data/spec/numb/highly_composite_spec.rb

@@ -6,7 +6,7 @@ describe Integer, "#highly_composite?" do
           221760,277200,332640,498960,554400,665280,720720,
           1081080,1441440,2162160].to_seq
 
-  @seq.first(20).sample(5).each do |n|
+  @seq.first(18).sample(10).each do |n|
     it "should return true for highly composite integer #{n}" do
       n.should be_highly_composite
     end