Count the number of Abelian groups of order n.

An Abelian group is a commutative group of elements in Abstract Algebra; this function counts the number of Abelian groups of a certain size.

This implementation of size counting for Abelian groups of order n is based on finding the number of partitions (see partition_count/1) of the exponents of the prime factors of n. For instance, when n is 144, the prime factorization is 2^4 * 3^2, with exponents 4 and 2. Finding the product of the partitions of the exponents via p(4) * p(2) yields 5 * 2, or 10.

Examples

iex> Math.abelian_groups_count(1)
1

iex> Math.abelian_groups_count(9984)
22

Find the Aliquot Sum of n.

An Aliquot Sum of an integer n is the sum of the proper divisors (all divisors except n) of n.

Examples

iex> Math.aliquot_sum(1)
0

iex> Math.aliquot_sum(10)
8

iex> Math.aliquot_sum(48)
76

Apply all 1-arity predicates to n, and collect the resulting labels.

This function uses the names of all of the predicate functions as sources for labels, and collects the resulting labels from a number being analyzed. This will work with all integers in the range (-∞..0..+∞).

Some predicate functions can take a long time to run depending on the size of n, so the analyze_number/2 function uses a timeout for each predicate. See the predicate_wait_time option for more details.

Options

• skip_smooth - Boolean, default false. If true, skip all predicates of form is_#_smooth?/1
• predicate_wait_time - Integer, default 100. Maximum number of milliseconds to wait for an answer from each predicate function

Examples

iex> Math.analyze_number(2048)
[:"11_smooth", :"13_smooth", :"17_smooth", :"19_smooth", :"23_smooth",:"3_smooth", :"5_smooth", :"7_smooth", :deficient, :even, :odious_number,:perfect_power, :positive, :powerful_number, :prime_power]

iex> Math.analyze_number(2048, skip_smooth: true)
[:deficient, :even, :odious_number,:perfect_power, :positive, :powerful_number, :prime_power]

iex> Math.analyze_number(-37)
[:negative, :odd]

iex> Math.analyze_number(0)
[:even, :palindromic, :plaindrome, :zero]

iex> Math.analyze_number(105840, skip_smooth: true)
[:abundant, :arithmetic_number, :even, :odious_number, :positive]

iex> Math.analyze_number(105840, skip_smooth: true, predicate_wait_time: 20_000)
[:abundant, :arithmetic_number, :even, :highly_abundant, :odious_number, :positive]

iex> Math.analyze_number(1000, skip_smooth: true)
[:abundant, :even, :multiple_rhonda, :perfect_cube, :perfect_power, :positive, :powerful_number, :rhonda_to_base_16]

iex> Math.analyze_number(1435)
[:arithmetic_number, :cubefree, :deficient, :odd, :odious_number, :positive, :pseudo_vampire_number, :sphenic_number, :squarefree, :vampire_number]

Calculate the Bell Number of n, or the number of possible partitions of a set of size n.

This function implementation relies on caching for efficiency.

Examples

iex> Math.bell_number(3)
5

iex> Math.bell_number(10)
115975

iex> Math.bell_number(15)
1382958545

iex> Math.bell_number(35)
281600203019560266563340426570

Calculate Ω(n) - number of distinct prime factors, with multiplicity.

See also omega/1 - number of distinct prime factors.

Examples

iex> Math.bigomega(3)
1

iex> Math.bigomega(15)
2

iex> Math.bigomega(25)
2

iex> Math.bigomega(99960)
8

Calculate the binomial coefficient (n k).

The binomial coefficient function determines the coefficient on the x^k term in the polynomial expansion of (1 + x)^n.

Rather than run a full expansion, this function relies on the simple formula:

As the factorial/1 function in Chunky.Math uses a cached speed up strategy, the calculation of the binomial by this method is fairly efficient.

Examples

iex> Math.binomial(7, 3)
35

iex> Math.binomial(20, 3)
1140

iex> Math.binomial(20, 10)
184756

iex> Math.binomial(100, 50)
100891344545564193334812497256

Find the Catalan number of n, C(n).

In combinatorial math, the Catalan numbers occur in a wide range of counting problems.

Rather than the factorial or binomial expansion, this implementation uses a product over fractional parts to avoid recursion and precision loss.

Examples

iex> Math.catalan_number(2)
2

iex> Math.catalan_number(20)
6564120420

iex> Math.catalan_number(100)
896519947090131496687170070074100632420837521538745909320

iex> Math.catalan_number(256)
1838728806050447178945542295919013188631170099776194095631629802153953581076132688111479765113051517392441367036708073775588228430597313880732554755142

Calculate Cayley's formula for n - the number of trees on n labeled vertices.

This formula also works for:

• number of spanning trees of a complete graph with labeled vertices
• number of transitive subtree acyclic digraphs on n-1 vertices
• counts parking functions
• the number of nilpotent partial bijections (of an n-element set)

Examples

iex> Math.cayley_number(1)
1

iex> Math.cayley_number(5)
125

iex> Math.cayley_number(18)
121439531096594251776

iex> Math.cayley_number(37)  
7710105884424969623139759010953858981831553019262380893

Check if a number n contains the number m in it's decimal digit representation.

Examples

iex> Math.contains_number?(34, 3)
true

iex> Math.contains_number?(2048, 20)
true

iex> Math.contains_number?(2048, 49)
false

Find all positive coprimes of n, from 2 up to n.

Two numbers a and b are coprime if, and only if, the only positive integer factor that divides both of them is 1.

If you need comprimes of n greater than n, see coprimes/2. If you only need the count of coprimes of n, see totient/1.

Examples

iex> Math.coprimes(2)
[1]

iex> Math.coprimes(3)
[1, 2]

iex> Math.coprimes(10)
[1, 3, 7, 9]

iex> Math.coprimes(36)
[1, 5, 7, 11, 13, 17, 19, 23, 25, 29, 31, 35]

Find all positive coprimes of n from 2 up to d.

Two numbers a and b are coprime if, and only if, the only positive integer factor that divides both of them is 1.

If you only need the coprimes of n less than or equal to n, see coprimes/1.

Examples

iex> Math.coprimes(2, 10)
[1, 3, 5, 7, 9]

iex> Math.coprimes(3, 20)
[1, 2, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17, 19, 20]

iex> Math.coprimes(10, 30)
[1, 3, 7, 9, 11, 13, 17, 19, 21, 23, 27, 29]

iex> Math.coprimes(38, 50)
[1, 3, 5, 7, 9, 11, 13, 15, 17, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49]

Find the number of derangements of a set of size n.

A derangement of a set is a permutation of the set, such that no element is in its original position. Also called the subfactorial of n, the recontres number, or de Montmor number.

This implementation uses the Euler recurrence, a(n) = n * a(n - 1) + -1^n.

Examples

iex> Math.derangement_count(1)
0

iex> Math.derangement_count(8)
14833

iex> Math.derangement_count(17)
130850092279664

iex> Math.derangement_count(134)
733162663744579191293964143415001307906325722892139819974619962654978249255036185299413091417144999745154783570225783145979302466795277487832988219926200862943908125847693470304687165754228414941338831577093697357593753008645129

Count the number of specific digits in n.

Using the base option, you can select which base the number is converted to before counting digits.

The list of digits being counted can have one or more integers, allowing flexible counting of different combinations of digits (see examples).

Options

• base - Integer. Default 10. Numeric base to convert n to before counting.

Examples

Count how many 2s are in a number:

iex> Math.digit_count(200454232, [2])
3

Count the even digits in a number:

iex> Math.digit_count(123456789, [2, 4, 6, 8])
4

Count the 1s and 2s in the ternary expansion (base 3) of a number:

iex> Math.digit_count(245_987_340, [1, 2], base: 3)
12

Count the number of 25s in the base 60 expansion of a number:

iex> Math.digit_count(1173840858356, [25], base: 60)
2

Calculate the sum of the digits of n.

Examples

iex> Math.digit_sum(1234)
10

iex> Math.digit_sum(2048)
14

iex> Math.digit_sum(1234567890987654321)
90

Generate n digits of pi, as a single large integer.

This function uses a non-digit extraction version of Bailey-Borwein-Plouffe summation for generating accurate digits of Pi in base 10. This uses a summation over fractional values to maintain precision:

Using this formula, it is possible to create many hundreds of digits of Pi in less than a second. Generating 5,000 digits takes roughly 30 seconds.

Examples

iex> Math.digits_of_pi(3)
314

iex> Math.digits_of_pi(31)
3141592653589793238462643383279

iex> Math.digits_of_pi(45)
314159265358979323846264338327950288419716939

Find all divisors of n of the form mx + b.

Examples

iex> Math.divisors_of_form_mx_plus_b(4, 1, 5)
[1, 5]

iex> Math.divisors_of_form_mx_plus_b(4, 1, 45)
[1, 5, 9, 45]

iex> Math.divisors_of_form_mx_plus_b(4, 3, 4)
[]

iex> Math.divisors_of_form_mx_plus_b(4, 3, 9975)
[3, 7, 15, 19, 35, 75, 95, 175, 399, 475, 1995, 9975]

Count the number of endofunctions (as endomorphisms) for a set of size n.

This counts endofunctions as an endomorphism over the set of size n, which is equivalent to n^n.

Examples

iex> Math.endomorphism_count(0)
1

iex> Math.endomorphism_count(4)
256

iex> Math.endomorphism_count(40)
12089258196146291747061760000000000000000000000000000000000000000

iex> Math.endomorphism_count(123)
114374367934617190099880295228066276746218078451850229775887975052369504785666896446606568365201542169649974727730628842345343196581134895919942820874449837212099476648958359023796078549041949007807220625356526926729664064846685758382803707100766740220839267

Find the n-th Euler number. Also written EulerE.

This calculation of the n-th Euler number is based on the Euler Polynomial:

E_n(1/2) * 2^n

such that the 6th Euler Number would be:

E_6(1/2) * 2^6

or -61

Examples

iex> Math.euler_number(0)
1

iex> Math.euler_number(3)
0

iex> Math.euler_number(6)
-61

iex> Math.euler_number(16)
19391512145

iex> Math.euler_number(64)
45358103330017889174746887871567762366351861519470368881468843837919695760705

Calculate the Euler polynomial E_m(x).

This calculate is based on the explicit double summation:

In this implementation the value of x is always converted to a fraction before calculations begin.

Examples

iex> Math.euler_polynomial(6, Fraction.new(1, 2))
%Chunky.Fraction{den: 4096, num: -3904}

iex> Math.euler_polynomial(6, 4) |> Fraction.get_whole()
1332

iex> Math.euler_polynomial(2, 15) |> Fraction.get_whole()
210

iex> Math.euler_polynomial(8, Fraction.new(1, 3))
%Chunky.Fraction{den: 1679616, num: 7869952}

Find the n-th Euler zig number.

Values for this function are based on the relation of the zig numbers to Euler Numbers, of the form ezig(n) = abs(EulerE(2n))

Examples

iex> Math.euler_zig(0)
1

iex> Math.euler_zig(2)
5

iex> Math.euler_zig(10)
370371188237525

Calculate the Euler zig zag, or up/down, number for n.

The zig zag set is used in combinatorics to count the size of alternating sets of permutations.

Other noted uses of the zig zag numbers (via OEIS A000111):

• Number of linear extensions of the "zig-zag" poset.
• Number of increasing 0-1-2 trees on n vertices.
• ... the number of refinements of partitions.
• For n >= 2, a(n-2) = number of permutations w of an ordered n-set
• The number of binary, rooted, unlabeled histories with n+1 leaves

As the calculation of the Euler Zig Zag is multiply recursive, this implementation uses a cache for efficiency.

Examples

iex> Math.euler_zig_zag(1)
1

iex> Math.euler_zig_zag(10)
50521

iex> Math.euler_zig_zag(20)
370371188237525

iex> Math.euler_zig_zag(99)
45608516616801111821043829531451697185581949239892414478770427720660171869441004793654782298700276817088804993740898668991870306963423232

Calculate the Eulerian Number A(n, m), the number of permutations of the numbers 1 to n in which exactly m elements are greater than the previous element.

The Eulerian numbers form the Euler triangle:

                 1                              
             1       1                          
          1      4       1                      
       1     11      11     1                   
    1     26     66     26    1
  1    57    302    302    57   1   

Where n is the row (starting at 1) and m is the offset in the row (starting at 0). So the value 66 is at row 5, offset 2:

iex> Math.eulerian_number(5, 2)
66

The sum of values at row n is n!

This implementation of Eulerian Number calculation uses a recursive algorithm with caching for efficiency.

Examples

iex> Math.eulerian_number(5, 4)
1

iex> Math.eulerian_number(7, 4)
1191

iex> Math.eulerian_number(9, 3)
88234

iex> Math.eulerian_number(25, 13)
3334612565134607644610436

Extend a Kolakoski sequence by one iteration.

Each iteration of the sequence will add one, or more, elements to the sequence.

See start_kolakoski_sequence/1 and extend_kolakoski_sequence_to_length/2.

Examples

iex> Math.start_kolakoski_sequence() |> Math.extend_kolakoski_sequence()
{[1], 1, {1, 2}}

Extend a Kolakoski sequence by successive iterations until the sequence is at least the given length.

As each iteration of the sequence will add one or more elements to the sequence, the best guarantee that can be made is that the newly extended sequence will have at least a certain number of elements.

Examples

iex> Math.start_kolakoski_sequence() |> Math.extend_kolakoski_sequence_to_length(23)
{[1, 2, 2, 1, 1, 2, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 2, 1, 2, 1, 1], 15, {1, 2}}

iex> {seq, _, _} = Math.start_kolakoski_sequence() |> Math.extend_kolakoski_sequence_to_length(26)
iex> length(seq)
27

Find all pairs of factors of n, with or without duplicates.

This is a variant of the factors/1 function, in that it builds the full pairs of factors of n in tuple form.

Options

• duplicates - Boolean. Default false. If true, include the ordered duplicates of factors (see examples)

Examples

iex> Math.factor_pairs(8)
[{1, 8}, {2, 4}]

iex> Math.factor_pairs(8, duplicates: true)
[{1, 8}, {2, 4}, {4, 2}, {8, 1}]

iex> Math.factor_pairs(84)
[1, 2, 3, 4, 6, 7, 12, 14, 21, 28, 42, 84]
[{1, 84}, {2, 42}, {3, 28}, {4, 21}, {6, 14}, {7, 12}]

The factorial of n, or n!.

A factorial of n is the product of n * (n - 1) * (n - 2) * ... 1.

This implementation uses a cache to speed up efficiency.

Examples

iex> Math.factorial(1)
1

iex> Math.factorial(10)
3628800

iex> Math.factorial(20)
2432902008176640000

iex> Math.factorial(100)
93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

Count the number of possible factorizations of n.

This counts a number as a factor of itself, as well as multi-set factorizations. So 8 has 3 factorizations; 8, 2*4, and 2*2*2.

Examples

iex> Math.factorization_count(1)
1

iex> Math.factorization_count(30)
5

iex> Math.factorization_count(286)
5

iex> Math.factorization_count(9984)
254

Factorize an integer into all divisors.

This will find all divisors, prime and composite, of an integer. The algorithm used for factorization is not optimal for very large numbers, as it uses a multiple pass calculation for co-factors and composite factors.

Example

iex> Math.factors(2)
[1, 2]

iex> Math.factors(84)
[1, 2, 3, 4, 6, 7, 12, 14, 21, 28, 42, 84]

iex> Math.factors(123456)
[1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64, 96, 192, 643, 1286, 1929, 2572, 3858, 5144, 7716, 10288, 15432, 20576, 30864, 41152, 61728, 123456]

Calculate the falling factorial (n)m.

Also called the descending factorial, falling sequential product, or lower factorial, this is the polynomial expansion:

Examples

iex> Math.falling_factorial(4, 0)
1

iex> Math.falling_factorial(6, 3)
120

iex> Math.falling_factorial(8, 10)
0

iex> Math.falling_factorial(21, 7)
586051200

Compare two floating points number using an epsilon error boundary.

Example

iex> Math.floats_equal?(3.11, 3.1)
false

iex> Math.floats_equal?(3.11, 3.1, 0.05)
true

iex> Math.floats_equal?(104.9999999, 104.9999996)
true

Find the n-th Fubini number, the number of ordered partitions of a set size n.

The Fubini numbers are also useful as (via OEIS A000670):

• the number of preferential arrangements of n labeled elements
• the number of weak orders on n labeled elements
• the number of ways n competitors can rank in a competition, allowing for the possibility of ties
• the number of chains of subsets starting with the empty set and ending with a set of n distinct objects
• the number of 'factor sequences' of N for the case in which N is a product of n distinct primes

This implementation is recursive and relies on binomial/2, so it uses a cache for efficiency.

Examples

iex> Math.fubini_number(0)
1

iex> Math.fubini_number(3)
13

iex> Math.fubini_number(19)
92801587319328411133

iex> Math.fubini_number(52)
11012069943086163504795579947992458193990796847590859607173763880168176185195

Find the bases for which n is a Rhonda number.

Via OEIS:

An integer n is a Rhonda number to base b if the product of its digits in base b equals b*Sum of prime factors of n (including multiplicity).

Numbers can be Rhonda to more than one base, see OEIS A100988. By default the get_rhonda_to/1 function evaluates all bases from 4 to 500. You can specify an alternate set of bases with the :bases option.

Options

• :bases - List of Integer. Bases to evaluate.

Examples

iex> Math.get_rhonda_to(1000)
[16, 36]

iex> Math.get_rhonda_to(5670)
[36, 106, 108, 196]

iex> Math.get_rhonda_to(5670, bases: 100..150 |> Enum.to_list())
[106, 108]

Find the gpf(n) or greatest prime factor.

Examples

iex> Math.greatest_prime_factor(1)
1

iex> Math.greatest_prime_factor(39)
13

iex> Math.greatest_prime_factor(99973)
389

Find the Hamming Weight of n in a specific numeric base.

By default, the Hamming Weight is calculated in Base 2.

Hamming weight, binary weight, population count, or (in binary) bit summation, is the number of symbols in a given base representation of an integer that are not 0. See Hamming Weight.

Examples

iex> Math.hamming_weight(29)
4

iex> Math.hamming_weight(29, 10)
2

iex> Math.hamming_weight(100)
3

iex> Math.hamming_weight(100, 10)
1

Find the n-th Hipparchus number.

Also known as Schröder–Hipparchus numbers, super-Catalan numbers, or the little Schröder numbers.

In combinatorics, the Hipparchus numbers are useful for (via Schröder–Hipparchus number on Wikipedia):

• The nth number in the sequence counts the number of different ways of subdividing of a polygon with n + 1 sides into smaller polygons by adding diagonals of the original polygon.
• The nth number counts the number of different plane trees with n leaves and with all internal vertices having two or more children.
• The nth number counts the number of different ways of inserting parentheses into a sequence of n symbols, with each pair of parentheses surrounding two or more symbols or parenthesized groups, and without any parentheses surrounding the entire sequence.
• The nth number counts the number of faces of all dimensions of an associahedron Kn + 1 of dimension n − 1, including the associahedron itself as a face, but not including the empty set. For instance, the two-dimensional associahedron K4 is a pentagon; it has five vertices, five faces, and one whole associahedron, for a total of 11 faces.

Sometimes denoted by S(n), this implementation is based on the recurrence relationship:

(n+1) * S(n) = (6*n-3) * S(n-1) - (n-2) * S(n-2)

Because of the double recurrence, this implementation uses a cache for efficiency.

Examples

iex> Math.hipparchus_number(4)
45

iex> Math.hipparchus_number(10)
518859

iex> Math.hipparchus_number(36)
6593381114984955663097869

iex> Math.hipparchus_number(180)
104947841676596807726623444466946904465025819465719020148363699314181613887673617931952223933467760579812079483371393916388262613163133

Calculate the Hurwitz-Radon number for n, the number of independent vector fields on a sphere in n-dimensional euclidean space.

See Vector fields on spheres for more information.

This function uses a set of 2-adic calculations to compute n in a closed form.

Examples

iex> Math.hurwitz_radon_number(9)
1

iex> Math.hurwitz_radon_number(32)
10

iex> Math.hurwitz_radon_number(288)
10

iex> Math.hurwitz_radon_number(9600)
16

Determine if the n-th root of a number is a whole integer, returning a boolean and the root value.

If the result n-th root is within epsilon of a whole integer, we consider the result an integer n-th root. This calcualtion runs the fast converging n-th root at a higher epsilon than it's configured to use for comparison and testing of the result value.

Options

• epsilon - Float. Default 1.0e-6. Error bounds for calculating float equality.

Examples

iex> Math.integer_nth_root(27, 3)
{true, 3}

iex> Math.integer_nth_root(1234, 6)
{false, :no_integer_nth_root, 3.2750594908836885}

iex> Math.integer_nth_root(33_038_369_407, 5)
{true, 127}

Predicate version of integer_nth_root/3 - does x have an integer n-th root.

Examples

iex> Math.integer_nth_root?(27, 3)
true

iex> Math.integer_nth_root?(1234, 6)
false

iex> Math.integer_nth_root?(33_038_369_407, 5)
true

Find the number of involutions, or self-inverse permutations, on n elements.

Also known as Permutation Involution.

This implementation is based on a recursive calculation, and so uses a cache for efficiency.

Examples

iex> Math.involutions_count(1)
1

iex> Math.involutions_count(10)
9496

iex> Math.involutions_count(100)
24053347438333478953622433243028232812964119825419485684849162710512551427284402176

iex> Math.involutions_count(234)
60000243887036070789348415368171135887062020098670503272477698436854394126572492217644586010812169497365274140196122299728842304082915845220986966530354668079910372211697866503760297656388279100434472952800147699927974040547172024320

Check if an integer n is 11-smooth.

See is_b_smooth?/2 for more details.

Examples

iex> Math.is_11_smooth?(3)
true

iex> Math.is_11_smooth?(40)
true

iex> Math.is_11_smooth?(107)
false

iex> Math.is_11_smooth?(2020)
false

Check if an integer n is 13-smooth.

See is_b_smooth?/2 for more details.

Examples

iex> Math.is_13_smooth?(3)
true

iex> Math.is_13_smooth?(40)
true

iex> Math.is_13_smooth?(107)
false

iex> Math.is_13_smooth?(2020)
false

Check if an integer n is 17-smooth.

See is_b_smooth?/2 for more details.

Examples

iex> Math.is_17_smooth?(3)
true

iex> Math.is_17_smooth?(40)
true

iex> Math.is_17_smooth?(107)
false

iex> Math.is_17_smooth?(2020)
false

Check if an integer n is 19-smooth.

See is_b_smooth?/2 for more details.

Examples

iex> Math.is_19_smooth?(3)
true

iex> Math.is_19_smooth?(40)
true

iex> Math.is_19_smooth?(107)
false

iex> Math.is_19_smooth?(2020)
false

Check if an integer n is 23-smooth.

See is_b_smooth?/2 for more details.

Examples

iex> Math.is_23_smooth?(3)
true

iex> Math.is_23_smooth?(40)
true

iex> Math.is_23_smooth?(107)
false

iex> Math.is_23_smooth?(2020)
false

Check if an integer n is 3-smooth.

See is_b_smooth?/2 for more details.

Examples

iex> Math.is_3_smooth?(3)
true

iex> Math.is_3_smooth?(40)
false

iex> Math.is_3_smooth?(107)
false

iex> Math.is_3_smooth?(2020)
false

Check if an integer n is 5-smooth.

See is_b_smooth?/2 for more details.

Examples

iex> Math.is_5_smooth?(3)
true

iex> Math.is_5_smooth?(40)
true

iex> Math.is_5_smooth?(107)
false

iex> Math.is_5_smooth?(2020)
false

Check if an integer n is 7-smooth.

See is_b_smooth?/2 for more details.

Examples

iex> Math.is_7_smooth?(3)
true

iex> Math.is_7_smooth?(40)
true

iex> Math.is_7_smooth?(107)
false

iex> Math.is_7_smooth?(2020)
false

Determine if an integer is abundant.

An abundant number is an integer n, such that the sum of all proper divisors of n (including itself) is greater than 2 * n.

Alternatively, an abundant number is a number that satisfies: 𝜎(n) > 2n

See also; is_deficient?/1, is_perfect?/1, is_highly_abundant?/1, next_abundant/1.

Examples

iex> Math.is_abundant?(3)
false

iex> Math.is_abundant?(12)
true

iex> Math.is_abundant?(945)
true

Check if a number is an Achilles Number.

Achilles numbers are n that are powerful (see is_powerful_number?/1 but not perfect powers (see is_perfect_power?/1).

See Chunky.Sequence.OEIS.Factor, sequence A052486.

Examples

iex> Math.is_achilles_number?(70)
false

iex> Math.is_achilles_number?(72)
true

iex> Math.is_achilles_number?(2700)
true

iex> Math.is_achilles_number?(784)
false

Determine if an integer is an arithmetic number.

An arithmetic number n such that the average of the sum of the proper divisors of n is a whole integer. Alternatively, n that satisfy 𝜎(n) / 𝜏(n) == 0.

Examples

iex> Math.is_arithmetic_number?(11)
true

iex> Math.is_arithmetic_number?(32)
false

iex> Math.is_arithmetic_number?(12953)
true

Determine if an integer n is b-smooth, a composite of prime factors less than or equal to b.

Numbers can be b-smooth for any b that is prime. For instance, the number 8 is 3-smooth, as it's factors would be: 1^1 * 2^3 * 3^0, whereas 15 is not 3-smooth, as it's factors would be 1^1 * 2^0 * 3^1 * 5^1 - it has prime factors whose value is greater than 3.

Shortcut Functions

There are a collection of pre-defined predicate functions for checking b-smooth for the primes 3 to 23:

- [`is_3_smooth?/1`](#is_3_smooth?/1)
- [`is_5_smooth?/1`](#is_5_smooth?/1)
- [`is_7_smooth?/1`](#is_7_smooth?/1)
- [`is_11_smooth?/1`](#is_11_smooth?/1)
- [`is_13_smooth?/1`](#is_13_smooth?/1)
- [`is_17_smooth?/1`](#is_17_smooth?/1)
- [`is_19_smooth?/1`](#is_19_smooth?/1)
- [`is_23_smooth?/1`](#is_23_smooth?/1)

Examples

iex> Math.is_b_smooth?(1944, 3)
true

iex> Math.is_b_smooth?(101, 5)
false

iex> Math.is_b_smooth?(705, 47)
true

Check if n is a Carmichael number.

A Carmichael number n is a composite number that satisfies the congruence:

for all b that are coprime to n.

Examples

iex> Math.is_carmichael_number?(517)
false

iex> Math.is_carmichael_number?(561)
true

iex> Math.is_carmichael_number?(1105)
true

iex> Math.is_carmichael_number?(1107)
false

iex> Math.is_carmichael_number?(41041)
true

Is n a circular prime?

A circular prime is a number n that remains a prime number through all possible rotations of the digits of n. For instance, 1193 is a circular prime because 1193, 1931, 9311, and 3119 are all prime.

Examples

iex> Math.is_circular_prime?(1193)
true

iex> Math.is_circular_prime?(3)
true

iex> Math.is_circular_prime?(193939)
true

iex> Math.is_circular_prime?(135)
false

Determine if two numbers, a and b, are co-prime.

From Wikipedia:

In number theory, two integers a and b are said to be relatively prime, mutually prime,[1] or coprime (also written co-prime) if the only positive integer (factor) that divides both of them is 1

Examples

iex> Math.is_coprime?(14, 15)
true

iex> Math.is_coprime?(14, 21)
false

iex> Math.is_coprime?(17, 2048)
true

Check if an integer n has no factors greater than 1 that are perfect cubes.

Examples

iex> Math.is_cubefree?(3)
true

iex> Math.is_cubefree?(64)
false

iex> Math.is_cubefree?(2744)
false

Determine if an integer is deficient.

A deficient number is an integer n, such that the sum of all proper divisors of n (including itself) is less than 2 * n.

Alternatively, a deficient number is a number that satisfies: 𝜎(n) < 2n

See also; is_abundant?/1, is_highly_abundant?/1, is_perfect?/1, next_deficient/1.

Examples

iex> Math.is_deficient?(1)
true

iex> Math.is_deficient?(71)
true

iex> Math.is_deficient?(33550336)
false

iex> Math.is_deficient?(60)
false

Check of n is a double vampire number.

Double vampire numbers meet all the criteria of a regular vampire number (see is_vampire_number?/1) with the additional constraint:

1. The two factors of n, a and b, must also be vampire numbers

Examples

iex> Math.is_double_vampire_number?(6880)
false

iex> Math.is_double_vampire_number?(1047527295416280)
true

Is n an emirp - a prime number that is a different prime number when reversed?

Emirp primes are related to palindromic primes (see is_palindromic_prime?/1), except that the reverse of n must be a different prime number.

Examples

iex> Math.is_emirp_prime?(373)
false

iex> Math.is_emirp_prime?(13)
true

iex> Math.is_emirp_prime?(983)
true

iex> Math.is_emirp_prime?(947351)
true

Check if n is an Euler-Jacobi pseudo-prime to base 10.

See is_euler_jacobi_pseudo_prime?/2 for more.

Examples

iex> Math.is_euler_jacobi_pseudo_prime?(17)
false

iex> Math.is_euler_jacobi_pseudo_prime?(481)
true

iex> Math.is_euler_jacobi_pseudo_prime?(487)
false

iex> Math.is_euler_jacobi_pseudo_prime?(6601)
true

Check if n is an Euler-Jacobi pseudo-prime to base a.

These numbers are like Euler pseudo-primes, but with a stricter congruence:

where is the Jacobi symbol (see jacobi_symbol/1).

Examples

iex> Math.is_euler_jacobi_pseudo_prime?(91, 10)
true

iex> Math.is_euler_jacobi_pseudo_prime?(52633, 12)
true

iex> Math.is_euler_jacobi_pseudo_prime?(15, 16)
true

iex> Math.is_euler_jacobi_pseudo_prime?(169, 22)
true

iex> Math.is_euler_jacobi_pseudo_prime?(133, 102)
true

Check if n is an Euler pseudo-prime in base 10.

See is_euler_pseudo_prime?/2 for a definition.

Examples

iex> Math.is_euler_pseudo_prime?(9)
true

iex> Math.is_euler_pseudo_prime?(14)
false

iex> Math.is_euler_pseudo_prime?(33)
true

iex> Math.is_euler_pseudo_prime?(91)
true

Check if n is an Euler pseudo-prime in base a.

Euler pseudo-primes are similar to the more standard definition of Euler-Jacobi pseudo-primes, but only need to satisfy the more permissive assertion that if a and n are coprime:

See also is_euler_pseudo_prime?/1 for implicit base 10 check, or is_euler_jacobi_pseudo_prime?/2 for the more commonly accepted pseudo-prime check.

Examples

iex> Math.is_euler_pseudo_prime?(185, 5)
false

iex> Math.is_euler_pseudo_prime?(185, 6)
true

iex> Math.is_euler_pseudo_prime?(91, 9)
true

iex> Math.is_euler_pseudo_prime?(1105, 16)
true

Predicate version of is_even/1 Integer guard.

Examples

iex> Math.is_even?(34)
true

iex> Math.is_even?(0)
true

iex> Math.is_even?(3)
false

Check if a number n is highly abundant.

A number n is highly abundant when the sum of the proper factors of n is greater than the sum of the proper factors of any number m that is in 0 < m < n.

Alternatively, for all natural numbers, m < n ; 𝜎(m) < 𝜎(n).

See also; is_deficient?/1, is_perfect?/1, is_abundant?/1.

Examples

iex> Math.is_highly_abundant?(1)
true

iex> Math.is_highly_abundant?(5)
false

iex> Math.is_highly_abundant?(30)
true

iex> Math.is_highly_abundant?(2099)
false

iex> Math.is_highly_abundant?(2100)
true

Check if a number n is a highly powerful number.

Highly powerful numbers are similar in concept to highly abundant numbers. For highly powerful numbers, the product of the exponents of prime factors of the number n need to be greater than the same property for any number m, such that 0 < m < n.

If you need a sequence of highly powerful numbers, use the A005934 sequence in Chunky.Sequence.OEIS.Factors, which uses an max/compare method for building the sequence, which is vastly more efficient than repeated calls to is_highly_powerful_number?/1.

See also is_powerful_number?/1, and Highly powerful number.

Examples

iex> Math.is_highly_powerful_number?(4)
true

iex> Math.is_highly_powerful_number?(256)
false

iex> Math.is_highly_powerful_number?(62208)
true

Check if n is a valid number in base b.

A number n that contains only valid digits in base b will be considered to be a valid number in that base. This test assumes that the value being provided is already in base b.

If the value being tested is a number, this will only check number up to base 10. To check bases above 10, provide a list of digits, like [10, 17, 1, 29] (285359 in base 30).

Examples

iex> Math.is_in_base?(123456, 5)
false

iex> Math.is_in_base?(101011101, 2)
true

iex> Math.is_in_base?(2430432, 6)
true

iex> Math.is_in_base?([1, 17, 4, 10], 17)
false

iex> Math.is_in_base?([1, 17, 4, 10], 18)
true

Is n a left/right truncatable prime?

Truncatable primes are prime number that remain prime when successive digits are removed. For a left/right truncatable prime, the number will start, and remain, prime as the left and right digits of the number are recursively dropped at the same time, until the number is a single or double digit prime. For instance, 99729779 is a left/right-truncatable prime, because 99729779, 972977, 7297, and 29 are all prime. For left/right truncation the final number can be a one or two digit prime, depending on if the original number nad an odd or even number of digits.

For numbers that are both left truncatable and right trucatable, see is_two_sided_prime?/1.

Examples

iex> Math.is_left_right_truncatable_prime?(433)
true

iex> Math.is_left_right_truncatable_prime?(1193)
true

iex> Math.is_left_right_truncatable_prime?(89)
true

iex> Math.is_left_right_truncatable_prime?(7)
true

iex> Math.is_left_right_truncatable_prime?(99729779)
true

Is n a left truncatable prime?

Truncatable primes are prime number that remain prime when successive digits are removed. For a left truncatable prime, the number will start, and remain, prime as the left digit of the number is recursively dropped, until the number is a single digit prime. For instance, 967 is a left-truncatable prime, because 967, 67, and 7 are all prime.

Examples

iex> Math.is_left_truncatable_prime?(967)
true

iex> Math.is_left_truncatable_prime?(9137)
true

iex> Math.is_left_truncatable_prime?(9656934675)
false

iex> Math.is_left_truncatable_prime?(396334245663786197)
true

Check if the integer n is a Rhonda number to more than one base.

This is a predicate wrapper around the get_rhonda_to/2 function.

Examples

iex> Math.is_multiple_rhonda?(1000)
true

iex> Math.is_multiple_rhonda?(1230)
false

Determine if a number is a negative integer.

Examples

iex> Math.is_negative?(-34)
true

iex> Math.is_negative?(0)
false

iex> Math.is_negative?(34)
false

Predicate version of is_odd?/1 Integer guard.

Examples

iex> Math.is_odd?(33)
true

iex> Math.is_odd?(0)
false

iex> Math.is_odd?(34)
false

Odious numbers have an odd number of 1s in their binary expansion.

See definition on MathWorld or Wikipedia.

Examples

iex> Math.is_odious_number?(2)
true

iex> Math.is_odious_number?(37)
true

iex> Math.is_odious_number?(144)
false

iex> Math.is_odious_number?(280)
true

iex> Math.is_odious_number?(19897)
true

Determine if n is a value of the form mx + b or mk + b, for specific values of m and b.

This function checks if an integer n is of a specific form, and is not an interpolation of the line formula.

Examples

Check if numbers are of the form 4k + 3:

iex> Math.is_of_mx_plus_b?(4, 3, 1)
false

iex> Math.is_of_mx_plus_b?(4, 3, 27)
true

iex> Math.is_of_mx_plus_b?(4, 3, 447)
true

Check if n is a palindromic number in base 10.

Palindromic numbers, like palindromic words, are the same value when read forward and reversed.

Examples

iex> Math.is_palindromic?(1234)
false

iex> Math.is_palindromic?(123454321)
true

iex> Math.is_palindromic?(1004006004001)
true

Check if n is palindromic in base b.

The number n is converted from base 10 to base b before being checked as a palindrome.

Examples

iex> Math.is_palindromic_in_base?(27, 2)
true

iex> Math.to_base(27, 2)
11011

iex> Math.is_palindromic_in_base?(105, 20)
true

iex> Math.to_base(105, 20)
[5, 5]

iex> Math.is_palindromic_in_base?(222, 3)
false

iex> Math.to_base(222, 3)
22020

Is n a palindromic prime number?

Palindromic prime numbers are both palindromes (the same digits/number when the digits are reversed) and prime numbers. By definition palindromic primes are prime when their digits are reversed.

Examples

iex> Math.is_palindromic_prime?(373)
true

iex> Math.is_palindromic_prime?(78247074287)
true

iex> Math.is_palindromic_prime?(55)
false

Check if n is pandigital in base 10.

See is_pandigital_in_base?/2 for more details.

Examples

iex> Math.is_pandigital?(123456789)
false

iex> Math.is_pandigital?(1023456789)
true