numb 0.3.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Run Paint Run Run
+
+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/README.rdoc

@@ -0,0 +1,10 @@
+= numb
+
+Experiments in number theory by extending the Integer class with predicate
+methods such as #perfect? and #weird?.
+
+Requires Ruby 1.9.
+
+== Copyright
+
+Copyright (c) 2009 Run Paint Run Run. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,52 @@
+# coding: utf-8
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "numb"
+    gem.summary = %Q{Experiments in number theory with new predicate methods for Integer.}
+    gem.email = "runrun@runpaint.org"
+    gem.homepage = "http://github.com/runpaint/numb"
+    gem.authors = ["Run Paint Run Run"]
+    gem.required_ruby_version = '>= 1.9.1'
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "numb #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.options << '--line-numbers' << '--inline-source' 
+  rdoc.options << '--charset' << 'utf-8' 
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.3.0

data/lib/numb/abundant.rb

@@ -0,0 +1,20 @@
+# 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 self > 0
+    sum_of_divisors > (2 * self)
+  end
+
+  alias :excessive? :abundant?
+end

data/lib/numb/achilles.rb

@@ -0,0 +1,15 @@
+# coding: utf-8
+class Integer
+
+  # 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
+end

data/lib/numb/automorphic.rb

@@ -0,0 +1,24 @@
+# coding: utf-8
+class Integer
+
+  # An automorphic number is a number whose square terminates in the number
+  # itself. That is, k is automorphic if the final digits of k<sup>2</sup> are
+  # the digits of k.
+  #
+  # More generally, an <i>n</i>-automorphic number is one of the form
+  # <i>nk<sup>2</sup></i> which has its last digits equal to <i>k</i>.
+  # <i>n</i> may be supplied as an argument to this method; otherwise it
+  # defaults to 1.
+  #
+  # Returns true if the number is automorphic; false otherwise. Aliased to
+  # Integer#curious?.
+  #
+  #     25.automorphic?    #=> true
+  #     9376.automorphic?  #=> true
+  #     600.automorphic?   #=> true
+  #
+  def automorphic?(n=1)
+    (n * self ** 2).to_s.end_with? self.to_s
+  end
+  alias :curious? :automorphic?
+end

data/lib/numb/carol.rb

@@ -0,0 +1,21 @@
+# coding: utf-8
+
+class Integer
+
+# A Carol number is an integer of the form <i>4<sup>n</sup> − 2<sup>n +
+# 1</sup> − 1</i>.
+#
+# This method returns true if self is a Carol number; false otherwise.
+#
+#     −1.carol?  #=> true 
+#     959.carol? #=> true 
+#     32.carol?  #=> false
+#
+  def carol?
+    return true if self == 7
+    return true if self == -1
+    a, b = to_s(2).match(/^(1+)0(1+)$/).to_a[1..-1]
+    return false if (a.nil? or b.nil?)
+    b.length == (a.length + 3)
+  end
+end

data/lib/numb/deficient.rb

@@ -0,0 +1,19 @@
+# coding: utf-8
+class Integer
+  # 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 self > 0
+    sum_of_divisors < (2 * self)
+  end
+
+  alias :defective? :deficient?
+end

data/lib/numb/dihedral_prime.rb

@@ -0,0 +1,25 @@
+# coding: utf-8
+class Integer
+
+  # 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?
+    !!to_s.match(/^[01825][018253]*$/)
+  end
+end

data/lib/numb/dudeney.rb

@@ -0,0 +1,15 @@
+# coding: utf-8
+class Integer
+  # A Dudeney number is a positive integer that is a perfect cube such that
+  # the sum of its decimal digits is the cube root of the number. 
+  #
+  # Returns true if self is a Dudeney number; false otherwise.
+  #
+  #     4913.dudeney?  #=> true
+  #     5832.dudeney?  #=> true
+  #     98.dudeney?    #=> false
+  #
+  def dudeney?
+    Math.cbrt(self) == self.digits.reduce(:+)
+  end
+end

data/lib/numb/economical.rb

@@ -0,0 +1,16 @@
+# coding: utf-8
+class Integer
+  # 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
+end

data/lib/numb/emrip.rb

@@ -0,0 +1,17 @@
+# coding: utf-8
+class Integer
+  # 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?
+    return false unless prime?
+    reversed = to_s.reverse.to_i
+    reversed != self and reversed.prime?
+  end
+end

data/lib/numb/equidigital.rb

@@ -0,0 +1,18 @@
+# coding: utf-8
+class Integer
+  # 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
+end

data/lib/numb/extravagant.rb

@@ -0,0 +1,18 @@
+# coding: utf-8
+class Integer
+  # 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?
+end

data/lib/numb/factorion.rb

@@ -0,0 +1,15 @@
+# coding: utf-8
+class Integer
+  # A factorion is a number equal to the sum of the factorials of its decimal
+  # digits.
+  #
+  # Returns true if self is a factorion; false otherwise.
+  #
+  #     145.factorion?    #=> true
+  #     40585.factorion?  #=> true
+  #     200.factorion?    #=> false
+  #
+  def factorion?
+    [1, 2, 145, 40585].include? self
+  end
+end

data/lib/numb/frugal.rb

@@ -0,0 +1,16 @@
+# coding: utf-8
+class Integer
+
+  # A frugal number has more digits than the number of digits in its prime
+  # factorization (including exponents).
+  #
+  # Returns true if self is frugal; false otherwise.
+  #
+  #     128.frugal?  #=> true
+  #     256.frugal?  #=> true
+  #     300.frugal?  #=> false
+  #
+  def frugal?
+    digits.size > prime_division.flatten.reject{|d|d==1}.join.to_i.digits.size
+  end
+end

data/lib/numb/happy.rb

@@ -0,0 +1,15 @@
+# coding: utf-8
+class Integer
+  def happy?
+    return false unless self > 0
+    n = self
+    sad = '4 16 37 58 89 145 42 20'
+    seq = ""
+    loop do
+      n = n.digits.map{|d| d ** 2}.reduce(:+)
+      seq << n.to_s  << ' '
+      return true if n == 1
+      return false if seq.include? sad   
+    end
+  end
+end

data/lib/numb/harshad.rb

@@ -0,0 +1,8 @@
+# coding: utf-8
+class Integer
+  def harshad?
+    return false unless self >= 0
+    (self %  digital_sum) == 0
+  end
+  alias :niven? :harshad?
+end

data/lib/numb/hilbert.rb

@@ -0,0 +1,7 @@
+# coding: utf-8
+class Integer
+  def hilbert?
+    return false unless self > 0
+    ((self - 1) % 4) == 0
+  end
+end

data/lib/numb/hyperperfect.rb

@@ -0,0 +1,7 @@
+# coding: utf-8
+class Integer
+  def hyperperfect?(k=1)
+    raise ArgumentError unless k >= 1
+    (1 + (k * (sum_of_divisors - self - 1))) == self
+  end
+end

data/lib/numb/impolite.rb

@@ -0,0 +1,6 @@
+# coding: utf-8
+class Integer
+  def impolite? 
+    not polite?
+  end
+end

data/lib/numb/kaprekar.rb

@@ -0,0 +1,14 @@
+# coding: utf-8
+class Integer
+  def kaprekar?
+    return true if self == 1
+    sdigits = (self ** 2).digits
+    (1..sdigits.size-1).each do |first|
+      a = sdigits.first(first).join.to_i
+      b = sdigits.last(sdigits.size-first).join.to_i
+      next if [a,b].any?{|n| n.zero?}
+      return true if (a + b) == self
+    end
+    false
+  end
+end

data/lib/numb/keith.rb

@@ -0,0 +1,15 @@
+# coding: utf-8
+class Integer
+  def keith?
+    return false unless (n = self) > 9
+    terms = n.to_s.split(//).map{|d| d.to_i}
+    loop do
+      return true if (n = terms.reduce(:+)) == self
+      return false if n > self
+      terms.shift
+      terms << n
+    end
+    false
+  end
+end
+

data/lib/numb/kynea.rb

@@ -0,0 +1,9 @@
+# coding: utf-8
+class Integer
+  def kynea?
+    return true if self == 7
+    a, b = to_s(2).match(/^(10+)(1+)$/).to_a[1..-1]
+    return false if (a.nil? or b.nil?)
+    a.length == (b.length - 1)
+  end
+end

data/lib/numb/mms_pair.rb

@@ -0,0 +1,11 @@
+# coding: utf-8
+class Integer
+  def mms_pair?(other)
+    return false unless (self == other.succ) || (other == self.succ)
+    sum = [self,other].map do |n|
+      (n.digits + n.prime_factors.map{|p| p.digits}.flatten).reduce(:+)
+    end
+    sum.first == sum.last
+  end
+  alias :maris_mcgwire_sosa_pair? :mms_pair?
+end

data/lib/numb/mobius.rb

@@ -0,0 +1,11 @@
+# coding: utf-8
+class Integer
+  def mobius
+    case
+      when (self < 1)                 then nil
+      when (square_free? and number_of_distinct_prime_factors.even?) then 1
+      when (square_free? and number_of_distinct_prime_factors.odd?)  then -1
+      when (not square_free?)         then 0
+    end
+  end
+end

data/lib/numb/narcissistic.rb

@@ -0,0 +1,8 @@
+# coding: utf-8
+class Integer
+  def narcissistic?
+    self == digits.map{|d| d ** digits.size}.reduce(:+)
+  end
+  alias :armstrong? :narcissistic?
+  alias :plus_perfect? :narcissistic?
+end

data/lib/numb/nivenmorphic.rb

@@ -0,0 +1,9 @@
+# coding: utf-8
+class Integer
+  def nivenmorphic?
+    return true if self == 0
+    return false unless self > 0
+    niven? && self.to_s.end_with?(digital_sum.to_s)
+  end
+  alias :harshadmorphic? :nivenmorphic?
+end

data/lib/numb/ordinal.rb

@@ -0,0 +1,11 @@
+class Integer
+  def ordinal
+    case to_s
+      when /^1\d$/ then 'th'
+      when /1$/    then 'st'
+      when /2$/    then 'nd'
+      when /3$/    then 'rd'
+      else              'th'
+    end
+  end
+end

data/lib/numb/parasitic.rb

@@ -0,0 +1,10 @@
+# coding: utf-8
+class Integer
+  def parasitic?(n=nil)
+    return (1..9).any?{|x| parasitic?(x)} if n.nil?
+    return true if (n == 1 && self == 1)
+    return false unless self > 9
+    raise ArgumentError unless (n > 0 && n < 10)
+    (n*self) == [digits.last, digits[0..-2]].join.to_i
+  end
+end

data/lib/numb/perfect.rb

@@ -0,0 +1,10 @@
+# coding: utf-8
+class Integer
+  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  
+    divisors = proper_positive_divisors
+    return false unless (divisors.size + 1).even?
+    divisors.reduce(:+) == self
+  end
+end

data/lib/numb/perfect_power.rb

@@ -0,0 +1,9 @@
+# coding: utf-8
+class Integer
+  def perfect_power?
+    return false unless self > 0
+    return true if self == 1
+    divisors = positive_divisors
+    (2..Math.log2(self)).any? { |pow| divisors.any? {|div| (div ** pow) == self} } 
+  end
+end

data/lib/numb/polite.rb

@@ -0,0 +1,7 @@
+# coding: utf-8
+class Integer
+  def polite? 
+    return true if self == 1
+    politeness > 0
+  end
+end

data/lib/numb/polydivisible.rb

@@ -0,0 +1,10 @@
+# coding: utf-8
+class Integer
+  def polydivisible?
+    return true if self == 1
+    return false if digits.first == 0
+    1.upto(digits.size).all? do |first|
+      (digits.first(first).join.to_i % first) == 0
+    end
+  end
+end

data/lib/numb/powerful.rb

@@ -0,0 +1,8 @@
+# coding: utf-8
+class Integer
+  def powerful?
+    return false unless self > 0
+    divisors = positive_divisors
+    divisors.select {|d| d.prime? }.all?{|prime| divisors.include? (prime ** 2)}
+  end
+end

data/lib/numb/practical.rb

@@ -0,0 +1,26 @@
+# coding: utf-8
+class Integer
+  # 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
+end