Library

Return the coefficients of the polynomial $p$ with alternating signs.

AltCoeffs(p)

Return the coefficients of the polynomial $p$ divided by $(-1)^k k!$.

AltEgfCoeffs(p)

Return the polynomial $p$ with coefficients in exponential form and alternating signs (i.e. with $(-1)^k c[k] x^k/k!$).

AltEgfPoly(p)

Return the polynomial $p$ with the coefficients C and alternating signs (i.e. with $(-1)^k c[k] x^k)$.

AltPoly(C)

Return the polynomial $p$ with alternating signs attached to the coefficients .

AltPoly(p)

Return the bitwise conjunction of $N$ and $K$.

And(N, K)

Return the generalized André numbers which are the $m$-alternating permutations of length $n$, cf. A181937.

André(m, n)

Return the n-th Bell number. Bell numbers count the ways to partition a set of $n$ labeled elements.

julia> BellNumber(10)
115975

BellNumber(n)

Return a list of the first m Bell numbers (a.k.a. exponential numbers).

BellNumberList(m)

The Bell transform transforms an integer sequence into an integer triangle; also known as incomplete Bell polynomials. Let $X$ be an integer sequence, then

$B_{n,k}(X) = \sum_{m=1}^{n-k+1} \binomial{n-1}{m-1} X[m] B_{n-m,k-1}(X)$

where $B_{0,0} = 1, B_{n,0} = 0$ for $n≥1, B_{0,k} = 0$ for $k≥1$.

BellTrans(n, k, X)

The Bell transform transforms an integer sequence into an integer triangle; also known as incomplete Bell polynomials. Let $F$ be an integer sequence generating function, then

$B_{n,k}(F) = \sum_{m=1}^{n-k+1} \binomial{n-1}{m-1} F(m) B_{n-m,k-1}(F)$

where $B_{0,0} = 1, B_{n,0} = 0$ for $n≥1, B_{0,k} = 0$ for $k≥1$.

BellTrans(n, k, F)

The Bell triangle gathers the results of the Bell transform applied to the initial segments of the input sequence.

Famously the sequence (1,1,1,...) is mapped to the triangle of the Stirling set numbers.

julia> ShowAsΔ(BellTriangle(5, k -> 1))
1
0 1
0 1 1
0 1 3 1
0 1 7 6 1

BellTriangle(n, seq)

Return the rational Bernoulli number $B_n$ (cf. A027641/A027642).

Bernoulli(n)

Return the generalized integer Bernoulli numbers $b_{m}(n) = n ×$André$(m, n-1)$.

BernoulliInt(m, n)

Return a list of length len of the integer Bernoulli numbers $b_{m}(n)$ using Seidel's boustrophedon algorithm.

BernoulliIntList(m, len)

Return a list of the first len Bernoulli numbers $B_n$ (cf. A027641/A027642).

BernoulliList(len)

Alias for the function BinaryIntegerLength.

Bil(n)

Return the 2-adic valuation of $n$.

Bin(n)

Return the binary expansions of nonnegative $n$ and $k$. If algo=max then pad the resulting int arrays with 0 to make them equally long. For example

BinDigits``(12, 17, max) = ([0, 0, 1, 1, 0], [1, 0, 0, 0, 1])``.

If algo=min then the arrays are truncated to the length of the smaller operand.

BinDigits``(12, 17, min) = ([0, 0, 1, 1], [1, 0, 0, 0])``.

These are the lists which are itemwise compared by the logical operators.

BinDigits(n, k)
BinDigits(n, k, algo)

Return the length of the binary extension of an integer $n$, which is defined as $0$ if $n = 0$ and for $n > 0$ as $⌊ \log_{2}(n) ⌋ + 1$.

BinaryIntegerLength(n)

Return the extended binomial coefficients defined for all $n ∈ Z$ and $k ∈ Z$. Behaves like the binomial function in Maple and Mathematica.

$\binom{n}{k} = \lim \limits_{x \rightarrow 1}(Γ(n + x) / (Γ(k + x) Γ(n - k + x))).$

Binomial(n, k)

Return the number of $1$'s in binary expansion of $n$.

BitCount(n)

Return the bitwise boolean operation represented by $op$ applied to the binary expansions of the integers $n$ and $k$. $op$ is an integer $0 <= op < 16$ encoding the result of the operation in terms of the truth table.

Bits(op, n, k)
Bits(op, n, k, algo)

Return the bitwise boolean operation represented by $op$ applied to the binary expansions of the integers $n$ and $k$. $op$ is an acronym as given in the list 'BoolOps'.

Bits(op, n, k)
Bits(op, n, k, algo)

The list of acronyms for the 16 binary boolean operations.

Alias for the (much better named) EuclidTree. See Malter, Schleicher, Zagier, New looks at old number theory, Amer. Math. Monthly, 120(3), 2013, pp. 243-264.

CalkinWilfTree(n)

The boustrophedonic Cantor enumeration of ℕ X ℕ where $ℕ = {0, 1, 2, ...}$. If $(x, y)$ and $(x', y')$ are adjacent points on the trajectory of the map then max$(|x - x'|, |y - y'|)$ is always 1 whereas for the Cantor enumeration this quantity can become arbitrarily large. In this sense the boustrophedonic variant is continuous whereas Cantor's realization is not.

CantorBoustrophedonicEnumeration(len)

The boustrophedonic Cantor enumeration implemented as a state machine to avoid the evaluation of the square root function.

CantorBoustrophedonicMachine(x, y)

The inverse function of the boustrophedonic Cantor enumeration (the pairing function), computes n for given $(x, y)$ and returns $(x + y)(x + y + 1)/2 + m$ where $m = |x - y| - (x > y ? 1 : 0)$.

CantorBoustrophedonicPairing(x, y)

The Cantor enumeration of ℕ X ℕ where ℕ $= {0, 1, 2, ...}$. If $(x, y)$ and $(x', y')$ are adjacent points on the trajectory of the map then max$(|x - x'|, |y - y'|)$ can become arbitrarily large. In this sense Cantor's enumeration is not continous.

CantorEnumeration(len)

The Cantor enumeration implemented as a state machine to avoid the evaluation of the square root function.

CantorMachine(x, y, state)

The inverse function of the Cantor enumeration (the pairing function), computes n for given $(x, y)$ and returns $(x + y)(x + y + 1)/2 + p$ where $p = x$ if $x - y$ is odd and $y$ otherwise.

CantorPairing(x, y)

Return the central column of the coefficients of the sequence of polynomials $P$.

Central(P, len)

Return the bitwise converse implication of $N$ and $K$.

Cimp(N, K)

Return the Clausen number $C_n$ which is the denominator of the Bernoulli number $B_{2n}$.

ClausenNumber(n)

Return the list of length len of Clausen numbers which are the denominators of the Bernoulli numbers $B_{2n}$.

ClausenNumberList(len)

Return the bitwise converse nonimplication of $N$ and $K$.

Cnimp(N, K)

Return the alternating sum of the coefficients of the polynomial $p$.

CoeffAltSum(p)

Return the sequence of the alternating sums of the coefficients of the sequence of polynomials $P$.

CoeffAltSum(P, len)

Return the constant coefficient of the polynomial $p$.

CoeffConst(p)

Return the sequence of the constant coefficients of the sequence of polynomials $P$.

CoeffConst(P, len)

Return the leading coefficient of the polynomial $p$.

CoeffLeading(p)

Return the sum of the coefficients of the polynomial $p$.

CoeffSum(p)

Return the sequence of the sum of coefficients of the sequence of polynomials $P$.

CoeffSum(P, len)

Return the list of coefficients of the power series s.

Coefficients(s, len)

Return the coefficients of the polynomial $p$.

Coeffs(p)

Return the list of the coefficients of the first $len$ polynomials of the sequence of polynomials $P$ as a triangle.

Coeffs(P, len)

Generate all Combinations of $n$ elements from an indexable object $a$. Because the number of Combinations can be very large, this function returns an iterator object. Use collect(Combinations(a, n)) to get an array of all Combinations.

Combinations(a, t)

Generate Combinations of the elements of $a$ of all orders. Chaining of order iterators is eager, but the sequence at each order is lazy.

Combinations(a)

Return the numbers of integers in the range 0:n which are isA.

julia> Count(8, isPrime)
4

Count(n, isAb)

Return the numbers of integers in the range a:b which are isA.

julia> Count(3:8, isPrime)
3

Count(r, isAb)

Compute the $q$-expansion to length len of the Dedekind $η$ function (without the leading factor $q^{1/24}$) raised to the power $r$, i.e. ${(q^{-1/24} η(q))^r = ∏_{k ≥ 1} (1 - q^k)^r.}$ In particular, $r = -1$ returns the generating function of the Partition function $p(k)$ and $r = 24$ gives the Ramanujan tau function $τ(k)$.

DedekindEtaPowers(len, r)

Return the product of two integer sequences introduced by Philippe Deléham in A084938.

DeléhamΔ(n, S, T)

Return the sequence of the leading coefficient of the sequence of polynomials $P$.

Diagonal(P, len)

Return the bitwise difference of $N$ and $K$.

Dif(N, K)

Return true if b is divisible by a, otherwise return false.

Divides(a, b)

Return the positive integers dividing $n$.

Divisors(m)
Divisors(m, dosort)

Return the coefficients of the polynomial $p$ divided by $k!$. Note that integer division is used.

EgfCoeffs(p)

Return the coefficient triangle of the bivariate generating function gf.

EgfExpansion(gf, prec)

Return the polynomial $p$ with the coefficients C used in the form $c[k] x^k/k!$. Note that integer division is used.

EgfPoly(C)

Return the polynomial $p$ with coefficients in exponential form (i.e. with $c[k] x^k/k!$).

EgfPoly(p)

Return the bitwise equivalence of $N$ and $K$.

Eqv(N, K)

julia> for n ∈ 1:4 Println(EuclidTree(n)) end
[1//1]
[1//2, 2//1]
[1//3, 3//2, 2//3, 3//1]
[1//4, 4//3, 3//5, 5//2, 2//5, 5//3, 3//4, 4//1]

EuclidTree(n)

Return the Euler transform of f.

EulerTransform(f)

Return the even part of $n$.

EvenPart(n)

Return the number of permutations of n letters, $n! = ∏(1, n)$, the factorial of $n$. (The notation is a shortcut breaking Julia conventions.)

F!(n)

Return factors of $n$.

Factors(n)

Return the falling factorial which is the product of $i$ ∈ $(n - k + 1):n$.

FallingFactorial(n, k)

Return $Γ(a)$ Hypergeometric$1F1(b, c, d).$

GammaHyp(a, b, c, d)

Return $∏_{1 ≤ j ≤ N, j ⊥ n} j$, the product of the positive integers which are $≤ N$ and are prime to $n$.

GaussFactorial(N, n)

Return $∏_{1 ≤ j ≤ n, j ⊥ n} j$, the product of the positive integers which are $≤ n$ and are prime to $n$.

GaussFactorial(n)

Test to generate sequences from a given list of sequences.

GenerateAllTest(A)

Trick described by David Hilbert in a 1924 lecture "Über das Unendliche".

HilbertHotel(guest, hotel)

Return the bitwise implication of $N$ and $K$.

Imp(N, K)

Return an iterator over all partitions of $n$. List the parts of the partitions according to the $PartitionOrder$ given as second parameter. By default the partition order is 'byNumPart'.

IntegerPartitions(n)
IntegerPartitions(n, o)

Return an iterator over all weakly descending lists with $m$ integers that sum to $n$. List the parts of the partitions of $n$ in graded colexicographic order.

IntegerPartitions(n, m)

Return the inverse of the coefficients of the orthogonal polynomials generated by $s$ and $t$ as a triangular array with dim rows.

InvOrthoPoly(dim, s, t)

The $q$-expansion to length len of the Jacobi theta function raised to the power $r$, i.e. $ϑ(q)^r$ where $ϑ(q) = 1 + ∑_{k ≥ 1} q^{k^2}$. Number of ways of writing $n$ as a sum of $r$ squares.

JacobiTheta3Powers(len, r)

Return the $q$-expansion to length $len$ of the Jacobi theta function raised to the power $r$, i.e. $ϑ(-q)^r$ where $ϑ(q) = 1 + ∑_{k ≥ 1} q^{k^2} .$

JacobiTheta4Powers(len, r)

Return the list of the first $n$ terms of the Kolakoski sequence.

KolakoskiList(len)

Return the $n$-th row of the Lah number triangle.

Lah(n)

Return the $k$-th term of the $n$-th row of the Lah number triangle.

Lah(n, k)

Return the unsigned Lah number triangle. (A271703)

LahTriangle(size)

Return a list of length len of integers $≥ 0$ which are isA.

List(len, isA)

$n$ is an abundant number if $σ(n) > 2n$. An abundant number is a number for which the sum of its proper divisors is greater than the number itself.

• isAbundant, is005101, I005101, F005101, L005101, V005101.

Generalized André numbers count the $m$-alternating permutations of length $n$, cf. A181937.

[  SEQ  ] n|k [0][1][2][3][4] [5] [6]  [7]   [8]   [9]  [10]
[V000012] [1]  1, 1, 1, 1, 1,  1,  1,   1,    1,    1,     1
[V000111] [2]  1, 1, 1, 2, 5, 16, 61, 272, 1385, 7936, 50521
[V178963] [3]  1, 1, 1, 1, 3,  9, 19,  99,  477, 1513, 11259
[V178964] [4]  1, 1, 1, 1, 1,  4, 14,  34,   69,  496,  2896
[V181936] [5]  1, 1, 1, 1, 1,  1,  5,  20,   55,  125,   251
[V250283] [6]  1, 1, 1, 1, 1,  1,  1,   6,   27,   83,   209

• André, C000111, V000111, V178963, V178964, V181936, V250283.

The Bell transform transforms an integer sequence into an integer triangle; also known as incomplete Bell polynomials. Let $X$ be an integer sequence, then

$B_{n, k}(X) = \sum_{m=1}^{n-k+1} \binomial{n-1}{m-1} X[m] B_{n-m,k-1}(X)$

where $B_{0,0} = 1, B_{n,0} = 0$ for $n≥1, B_{0,k} = 0$ for $k≥1$.

The Bell transform is (0,0)-based and the associated triangle always has as first column 1,0,0,0,... This column is often missing in the OEIS. Other Stirling number related sequences are implemented in the module StirlingLahNumbers.

• BellTrans, BellTriangle, BellNumberList, BellNumber
• V000110, L000110, T137452, T264428, T137513, T104556, T001497, T132062, T039683, T203412, T004747, T051141, T265606, T119274, T000369, T051142

We are primarily concerned with the integer Bernoulli numbers.

Cf. $A000182 (m=2), A293951 (m=3), A273352 (m=4), A318258 (m=5).$

[1] [0, 1,    0,       0,             0,                  0]
[2] [0, 1,   -2,      16,          -272,               7936]
[3] [0, 1,   -9,     477,        -74601,           25740261]
[4] [0, 1,  -34,   11056,     -14873104,        56814228736]
[5] [0, 1, -125,  249250,   -2886735625,    122209131374375]
[6] [0, 1, -461, 5699149, -574688719793, 272692888959243481]

The rational Bernoulli numbers are defined here with $B(1) = 1/2$. Why this is preferred over $B(1) = -1/2$ is explained in the Bernoulli Manifesto.

• BernoulliInt, BernoulliIntList, Bernoulli, BernoulliList
• V195441, V065619, V281586, V281588, V027641, L065619

For positive n, BinaryIntegerLength is $⌊ \log_{2}(n) ⌋ + 1$, BinaryIntegerLength(0) = 0.

• BinaryIntegerLength, Bil, V001855, V003314, V033156, V054248, V061168, V083652, V097383, V123753, V295513

A binary quadratic form over Z is a quadratic homogeneous polynomial in two variables with integer coefficients, $q(x, y) = ax^2 + bxy + cy^2$.

A quadratic form $q(x, y)$ represents an integer $n$ if there exist integers $x$ and $y$ with $q(x, y) = n$. We say that $q$ primitively represents $n$ if there exist relatively prime integers $x$ and $y$ such that $q(x, y) = n$.

Ported from BinaryQuadraticForms where you can find much more information on this subject.

• L002476, L008784, L031363, L034017, L035251, L038872, L038873, L042965, L057126, L057127, L068228, L084916, L089270, L141158, L242660, L243655, L244779, L244780, L244819, L243168, L244291, L007522

Cantor's enumeration of N X N revisited.

• Cantor-Machine, Cantor-Enumeration, Cantor-Pairing, Cantor-BoustrophedonicMachine, Cantor-BoustrophedonicEnumeration, Cantor-BoustrophedonicPairing, RosenbergStrong-BoustrophedonicMachine, RosenbergStrong-BoustrophedonicEnumeration, RosenbergStrong-BoustrophedonicPairing

• isCarmichael, I002997, F002997, L002997
• isweakCarmichael, I225498, F225498, L225498

• ClausenNumber, ClausenNumberList, V002445, L002445, V027642

• Combinations

• T097805, L097805, V097805, M097805

• PreviousPrime, NextPrime, PrimePiList, takeFirst, Nth, Count, List, HilbertHotel
• L000961, L002808, L005117, L013928, L025528, L065515, L065855, L069637, L246547, L246655, L000720, V007917, V151800, V257993

E. Fouvry, C. Levesque, M. Waldschmidt, Representation of integers by cyclotomic binary forms, arXiv:1712.09019 [math.NT], 2017.

• is206864, F206864, I206864, L206864, is206942, F206942, I206942, L206942, is293654, F293654, I293654, L293654, is296095, F296095, I296095, L296095, V299214, L299214, is299498, F299498, I299498, L299498, is299733, L299733, is299928, F299928, I299928, L299928, is299929, F299929, I299929, L299929, is299930, F299930, I299930, L299930, is325143, F325143, I325143, L325143, is325145, F325145, I325145, L325145

• DedekindEtaPowers, RamanujanTau, RamanujanTauList, PartitionNumberList

Philippe Deléham’s Δ-operation maps, similar to the Riordan product, two integer sequences on a lower triangular matrix. It effectively computes a continued fraction depending on the two input sequences!

Applying Deléham's Δ-operation often gives an additional first column or an additional main diagonal in the resulting triangle compared to what is listed in the OEIS.

Introduction to the Riordan Square

• DeléhamΔ, T084938, T060693, T106566, T094665, T090238, T225478, T055883, T184962, T088969, T090981, T011117

• V006171, L006171, V107895, L107895, V061256, L061256, V190905, L190905, V275585, L275585, V290351, L290351

• I000045, F000045, L000045, V000045, R000045, is000045

• PolygonalNumber, PyramidalNumber, V014107, V095794, V067998, V080956, V001477, V000217, V000290, V000326, V000384, V000566, V000567, V001106, V001107, V005564, V058373, V254749, V000292, V000330, V002411, V002412, V002413, V002414, V007584, V007585

The Gauß factorial is $∏_{1 ≤ j ≤ N, j ⊥ n} j$, the product of the positive integers which are $≤ N$ and are prime to $n$.

• GaussFactorial, I193338, F193338, L193338, V193338, I193339, F193339, L193339, V193339, V216919, V001783, V055634, V232980, V232981, V232982, V124441, V124442, V066570

P. Luschny, Generalized Binomial, OEIS Wiki.

• Binomial, Pascal, T007318

• The classical Fibonacci numbers are exported from the module Fibonacci. See I000045, F000045, L000045, V000045, R000045 and is000045.

• Fibonacci(n) is defined as the number of compositions of n with no part equal to 1. They are the special case Fibonacci(n) = Multinacci(2, n).

[m
] 0  1  2   3   4   5    6    7     8     9    10    11
----------------------------------------------------------------
[0]   1, 0, 0,  0,  0,  0,   0,   0,    0,    0,    0,    0, ...
[1]   1, 1, 1,  1,  1,  1,   1,   1,    1,    1,    1,    1, ...
[2]   1, 1, 2,  3,  5,  8,  13,  21,   34,   55,   89,  144, ...
[3]   1, 1, 3,  4,  9, 14,  28,  47,   89,  155,  286,  507, ...
[4]   1, 1, 4,  5, 14, 20,  48,  75,  165,  274,  571,  988, ...
[5]   1, 1, 5,  6, 20, 27,  75, 110,  275,  429, 1001, 1637, ...
[6]   1, 1, 6,  7, 27, 35, 110, 154,  429,  637, 1638, 2548, ...

• Multinacci, V309896, V006053, V188021, V231181

• I002093, F002093, L002093, V002093, I034885, F034885, L034885, V034885

GammaHyp: $(a, b, c, d)$ ↦ $Γ(a)$ Hypergeometric$1F1(b, c, d).$

• GammaHyp, V000255, V000262, V001339, V007060, V033815, V099022, V251568

All integer partitions are listed by two orderings: IntegerPartitions(n, byNumPart) IntegerPartitions(n, byMaxPart)

Or restricted to partitions of length m: IntegerPartitions(n, m)

The partition coefficients, which are the multinomial coefficients applied to partitions, are given in both orderings (L036038, L078760).

The partition numbers and the number of partitions of n into k parts are given as PartitionNumber(n) and PartitionNumber(n, k), (V000041, L072233).

The sum of all partition coefficients of n is efficiently computed with L005651.

• V000041, V088887, I072233, L072233, L036038, L078760, L005651, L262071, L292222, L115621, L328917

The $q$-expansion of the Jacobi theta functions 3 and 4 raised to the power $r$ is computed for various values of $r$.

• JacobiTheta3Powers, JacobiTheta4Powers, L000122, L002448, L004018, L104794, L005875, L213384, L000118, L035016, L008452, L096727, L000132, L000141, L008451, L000143, L000144, L008453, L000145, L276285, L276286, L276287, L004402, L004406, L004407, L015128, L004403, L001934, L004404, L004405, L004408, L004409, L004410, L004411, L004412, L004413, L004414, L004420, L004421, L004415, L004416, L004417, L004418, L004419, L004422, L004423, L004424, L004425

• KolakoskiList, C000002, I000002, L000002

• NarayanasCows, L214551

For background information see

• J.-P. Allouche, T. Johnson, Narayana's Cows and Delayed Morphisms.
• C.M. Wilmott, From Fibonacci to the mathematics of cows and quantum circuitry.

• τ, σ, σ2, ϕ, ω, Ω, ⊥, ⍊
• Divisors, PrimeDivisors, Factors, Radical, mods, Divides, isPrime, isCyclic, isStrongCyclic, isOdd, PrimeList, isPrimeTo, isStrongPrimeTo, isNonnegative, isPositive, isEven, isSquare, isComposite, isSquareFree, isPrimePower, isPowerOfPrimes, isPerfectPower
• V000005, V000010, V000203, V001222, V001221, V008683, V181830, V034444, I003277, L003277, V061142, V034386, V002110, I050384, L050384, V001157

A collection of utilities for handling OEIS related tasks.

• OrthoPoly, InvOrthoPoly, T053121, T216916, T217537, T064189, T202327, T111062, T099174, T066325, T049310, T137338, T104562, T037027, T049218, T159834, T137286, T053120, T053117, T111593, T059419, L217924, L005773, L108624, L005425, L000085, L001464, L003723, L006229

Mostly convenient functions to deal with polynomials as often used in connection with ordinary and exponential generating functions. The naming scheme used is roughly described by:

   Poly       <-> Coeffs
   AltPoly    <-> Poly(AltCoeffs)
   EgfPoly    <-> Poly(EgfCoeffs)
   OgfPoly    <-> Poly(OgfCoeffs)
   AltEgfPoly <-> Poly(AltEgfCoeffs)

Here 'Alt' stands for alternating, 'Egf' for exponential generating function, 'Ogf' for ordinary generating function.

• Coeffs, CoeffSum, CoeffAltSum, CoeffConst, CoeffLeading, AltCoeffs, Diagonal, Central, EgfCoeffs, AltEgfCoeffs, Poly, AltPoly, EgfPoly, AltEgfPoly, ReflectPoly.

Cf. P. Luschny, Swing, divide and conquer the factorial, excerpt.

• PSfactorial, Swing

• Primes, PrimePi, PrimeSieve

• ∏, Product, F!, RisingFactorial, ↑, FallingFactorial, ↓, MultiFactorial
• V000407, V124320, V265609, V000142, V081125, V001147, V000165, V032031, V007559, V008544, V007696, V001813, V008545, V047053

For some background see: Backtracking with profiles.

• Queens, L319284

Rational trees as understood here are binary trees enumerating the positive or nonnegative rational numbers. Examples are the Euclid tree, the Kepler tree and the Stern-Brocot tree (a.k.a. Farey tree). They are closely related to binary partitions and to Stern's diatomic sequence or Dijkstra's fusc function.

Malter, Schleicher, Zagier, New looks at old number theory, Amer. Math. Monthly, 120(3), 2013, pp. 243-264.

• EuclidTree, CalkinWilfTree, SchinzelSierpinskiEncoding

The type object to construct an iterated search for records in sequences.

• Records

The Riordan product is a map a, b ↦ [a, b] associating two formal power series a, b with a lower triangular matrix [a, b]. The Riordan square is the case a = b of the Riordan product. Formally we can describe the Riordan square as a transform RS: Z[[x]] ↦ Mat[Z] which maps power series over the integers to (lower triangular) integer matrices.

• RiordanProduct, RiordanSquare
• T039599, T116392, T172094, T321620, T321621, T321623, T321624, T322942

Introduction to the Riordan Square

Some exactly solvable self-convolutive recurrences.

• SelfConvRec, L000698, L001710, L003319, L005411, L005412, L006012, L006318, L047891, L062980, L082298, L082301, L082302, L105523, L107716, L111529, L111530, L111531, L111532, L111533, L146559, L167872

Nemo is a library designed, developed and maintained by William Hart with the help of others. Many functions in our project are based on Nemo.

The generating functions of various combinatorial and number-theoretic functions.

• Coefficients, EgfExpansion, G000045, G000257, L000257, G000032, L000032, G000073, L000073, G000108, L000108, G000957, L000957, G001003, L001003, G001006, L001006, G001045, L001045, G002426, L002426, G005043, L005043, G006318, G068875, L068875

• SetPartitions(s::AbstractVector)

Return an iterator over all set partitions of the elements of the array $s$, represented as arrays of arrays.

• SetPartitions(n::Int)

Return an iterator over all set partitions of the elements of the array $[1,2,...,n]$, represented as arrays of arrays.

• SetPartitions(s::AbstractVector, m::Int)

Return all set partitions of the elements of the array $s$ into exactly $m$ subsets, represented as arrays of arrays.

• SetPartitions(n::Int, m::Int)

Return all set partitions of the elements of the array ${1,2,3,...,n}$ into exactly $m$ subsets, represented as arrays of arrays.

• SetNumber(n::Int)

Return the numbers of partitions of an $n$-set into nonempty subsets.

• SetNumber(n::Int, m::Int)

Return the numbers of partitions of an $n$-set into $m$ nonempty subsets.

• T132393, L132393, V132393, M132393, T048993, L048993, V048993, M048993, T271703, L271703, V271703, M271703, T094587, L094587, V094587, M094587, T008279, L008279, V008279, M008279

Basic implementation of the swing algorithm using no primes. Claims to be the most efficient simple algorithm to compute the factorial. An advanced version based on prime-factorization is available as the prime-swing factorial factorialPS.

• Sfactorial

• Triangle, ZTriangle, QTriangle, RecTriangle, TriangularNumber, isTriangular, assertTriangular, ShowAsΔ, ShowAsMatrix, Row, RowSums, fromΔ, toΔ, TriangleToList

An Ulam number $u(n)$ is the least number $> u(n-1)$ which is a unique sum of two distinct earlier terms; $u(1) = 1$ and $u(2) = 2$.

• UlamList, isUlam, L002858

Two alternative implementations of integer partitions. The first one implements the 'visit-pattern' in Fortran style. Compared to the implementation in JuliaMath/Combinatorics:

For n = 50 the benchmark shows:

• 0.141849 seconds ( 9 allocations: 1.672 KiB) [NEXPAR]
• 0.111040 seconds (408.45 k allocations: 40.882 MiB, 21.10% gc time) [JuliaMath]

For n = 100 the benchmark shows:

• 167.598273 seconds ( 15 allocations: 4.813 KiB) [NEXPAR]
• 86.960344 seconds (381.14 M allocations: 48.735 GiB, 11.29% gc time) [JuliaMath]

Our function is slower but the Combinatorics function takes vastly more space.

In the second alternative implementation the representation of the partitions for fixed n is a weakly increasing lists ordered lexicographicaly. It has a nice algorithm implemented directly (i.e. without iteration).

• Partition, V080577, V026791

A Zumkeller number $n$ is an integer whose divisors can be partitioned into two disjoint sets whose sums are both $σ(n)/2$.

• isZumkeller, is083207, I083207, F083207, L083207, V083207

Return the multi-factorial which is the function $n → ∏(a + b, a(n-1) + b)$

MultiFactorial(a, b)

Return the $n$-th term of the $m$-th Multinacci sequence.

Multinacci(m, n)

Return the multinomial coefficient of a list.

Multinomial(lst)

Return the bitwise nonconjunction of $N$ and $K$.

Nand(N, K)

The type object to construct a new instance of the modified Narayanas cows sequence with given length.

Return least prime $> n$. The next_prime function of Mathematica, Maple, Magma and SageMath (cf. V151800).

NextPrime(n)

Return the bitwise joint denial of $N$ and $K$.

Nor(N, K)

Return the bitwise negation of $N$.

Not(N)

Return the Nth integer which is isA. (For N ≤ 0 return 0.)

julia> Nth(7, isPrime)
17

Nth(N, isA)

Return the odd part of $n$.

OddPart(n)

Return the bitwise disjunction of $N$ and $K$.

Or(N, K)

By the theorem of Favard an orthogonal polynomial systems $p_{n}(x)$ is a sequence of real polynomials with deg$(p_{n}(x)) = n$ for all $n$ if and only if

$p_{n+1}(x) = (x - s_n)p_n(x) - t_n p_{n-1}(x)$

with $p_{0}(x)=1$ for some pair of seq's $s_k$ and $t_k$. Return the coefficients of the polynomials as a triangular array with dim rows.

OrthoPoly(dim, s, t)

Return the factorial $n! = 1×2× ... ×n$, which is the order of the symmetric group S_n or the number of permutations of n letters (cf. A000142).

PSfactorial(n)

Conventional names for orderings of integer partitions of $n$. byMaxPart means first order by the biggest part. byNumPart means first order by the number of parts. The secondary order is in both cases colexicographic.

Return the partition coefficients of $n$, first ordered by biggest part.

PartitionCoefficientsByBiggestPart(n)

Return the partition coefficients of $n$, first ordered by length.

PartitionCoefficientsByLength(n)

Return the number of partitions of $n$ into $k$ parts. Cf. A072233.

PartitionNumber(n, k)

Return the number of partitions of $n$. Cf. A000041.

PartitionNumber(n)

Return the first n numbers of integer partitions.

PartitionNumberList(len)

The classical binomial coefficients defined for $n≥0$ and $0≤k≤n$ (a.k.a. Pascal's triangle).

Pascal(n, k)

Return the decimal expansion of π up to $n$ digits as a string. Note the feature that the precision is increased only in steps of 4, i.e. only if $n$ is divisible by 4. If $n$ is not divisible by 4 then the number of digits in the output is rounded down to the largest number divisible by 4 smaller than $n$.

julia> Pi(8)
31415926
julia> Pi(10)
31415926
julia> Pi(12)
314159265358

Pi(digits)

Return the polynomial $p$ with the coefficients C.

Poly(C)

Return the polygonal number with shape k.

PolygonalNumber(n, k)

Return the largest prime in $Z$ (the ring of all integers) less than $n$ for $n ≥ 0$ (cf. V007917).

PreviousPrime(n)

Return the prime numbers dividing $n$.

PrimeDivisors(n)

Return the number of primes $≤ n$.

PrimePi(n)

Return the list of number of primes $≤ n$ for $n ≥ 0$.

julia> PrimePiList(8)

[0, 0, 1, 2, 2, 3, 3, 4]

PrimePiList(len)

Return the prime sieve, as a BitArray, of the positive integers (from lo, if specified) up to hi. Useful when working with either primes or composite numbers.

PrimeSieve(lo, hi)

Return the collection of the prime numbers (from lo, if specified) up to hi.

Primes(lo, hi)

Print the array without typeinfo.

Println(v)

Print the array without typeinfo.

Println(V)

If $a ≤ b$ then return the product of $i$ ∈ $a:b$ else return $1$.

Product(a, b)

Return the accumulated product of an array.

Product(A)

Return the pyramidal number with shape k.

PyramidalNumber(n, k)

Return a trianguler array with $n$ rows set to $0$ (type QQ).

QTriangle(dim)

Returns the profile of the backtrack tree for the n queens problem (see A319284).

Queens(n)

Return the radical of $n$ which is the product of the prime numbers dividing $n$ (also called the squarefree kernel of $n$).

Radical(n)

Return Ramanujan's tau(n).

RamanujanTau(n)

List of the first values of the Ramanujan tau function, the Fourier coefficients of the Weierstrass Delta-function.

RamanujanTauList(len)

A recursive triangle RecTriangle is a subtype of AbstractTriangle. The rows of the triangle are generated by a function gen(n, k, prevrow) defined for $n ≥ 0$ and $0 ≤ k ≤ n$. The function returns value of type fmpz.

The parameter prevrow is a function which returns the values of row(n-1) of the triangle and 0 if $k < 0$ or $k > n$. The function prevrow is provided by an instance of RecTriangle and must not be defined by the user.

The type object to construct an iterated search for records in sequences.

Return the reflected polynomial of $p$.

ReflectPoly(p)

Return the Riordan array associated with the generating functions a and b.

RiordanProduct(a, b, dim)
RiordanProduct(a, b, dim, expo)

Return the Riordan array (Riordan product) $a \times a$.

RiordanSquare(a, n)
RiordanSquare(a, n, expo)

Return the rising factorial which is the product of $i$ ∈ $n:(n + k - 1)$.

RisingFactorial(n, k)

The boustrophedonic Rosenberg-Strong enumeration of ℕ X ℕ where ℕ $= {0, 1, 2, ...}$. If $(x, y)$ and $(x', y')$ are adjacent points on the trajectory of the map then max$(|x - x'|, |y - y'|)$ is always 1 whereas the Rosenberg-Strong realization is not.

RosenbergStrongBoustrophedonicEnumeration(len)

The boustrophedonic Rosenberg-Strong enumeration as considered by Pigeon implemented as a state machine to avoid the evaluation of the square root function.

RosenbergStrongBoustrophedonicMachine(x, y, state)

The inverse function of the boustrophedonic Rosenberg-Strong enumeration (the pairing function), computes $n$ for given $(x, y)$.

RosenbergStrongBoustrophedonicPairing(x, y)

Return row $n (0 ≤ n)$ of the lower triangular matrix T or the row $n$ in reversed order if reversed is set true.

Row(T, n)
Row(T, n, reversed)

Return the row sums of a triangle, if alternate=true then the alternating row sums.

RowSums(T)
RowSums(T, alternate)

Return the Schinzel-Sierpinski encoding of the positive rational number r.

julia> for n ∈ 1:4 println([SchinzelSierpinski(l) for l ∈ EuclidTree(n)]) end
[1//1]
[2//5, 5//2]
[3//11, 5//3, 3//5, 11//3]
[2//11, 3//2, 11//19, 19//7, 7//19, 19//11, 2//3, 11//2]

SchinzelSierpinskiEncoding(l)
SchinzelSierpinskiEncoding(l, searchLimit)

An exactly solvable self-convolutive recurrence studied by R. J. Martin and M. J. Kearney.

SelfConvRec(len, a, b, c)

Return the name of a OEIS sequence given a similar named function as a string.

SeqName(fun)

Return the A-number of a OEIS sequence given a similar named function as an integer.

SeqNum(seq)

Print the array with or without typeinfo.

SeqPrint(v)
SeqPrint(v, typeinfo)

Print the array $A$ in the format $n ↦ A[n]$ for n in the given range.

SeqShow(A, R)
SeqShow(A, R, offset)

Print the array $A$ in the format $n ↦ A[n]$ for n in the range first:last.

SeqShow(A, first, last)

Print the array $A$ in the format $n ↦ A[n]$.

SeqShow(A)
SeqShow(A, offset)

Perform tests for an array of sequences of given type assuming the given offset.

SeqTest(seqarray, kind)
SeqTest(seqarray, kind, offset)

Return the numbers of partitions of an $n$-set into $m$ nonempty subsets.

SetNumber(n, m)

Return the numbers of partitions of an $n$-set into nonempty subsets.

SetNumber(n)

Return an iterator over all set partitions of the elements of an array $s$, represented as arrays of arrays.

SetPartitions(s)

Return an iterator over all set partitions of the elements of the array $[1,2,...,n]$, represented as arrays of arrays.

SetPartitions(n)

Return all set partitions of the elements of an array $s$ into exactly $m$ subsets, represented as arrays of arrays.

SetPartitions(s, m)

Return all set partitions of the elements of the array ${1,2,3,...,n}$ into exactly $m$ subsets, represented as arrays of arrays.

SetPartitions(n, m)

Return the factorial of $n$. Basic implementation of the swing algorithm using no primes. An advanced version based on prime-factorization is available as the prime-swing factorial factorialPS.

Sfactorial(n)

Print the triangle in matrix form.

ShowAsMatrix(T)

Display a lower triangular matrix.

ShowAsΔ(T)
ShowAsΔ(T, separator)

Display an array as a lower triangular matrix.

ShowAsΔ(T)
ShowAsΔ(T, separator)

Computes the swinging factorial (a.k.a. Swing numbers n≀) (cf. A056040).

Swing(n)

A Triangle is a list of rows. The rows of the triangle are generated by a function (n::Int, k::Int) → gen::fmpz for $0 ≤ k ≤ n$ and $0 ≤ n <$dim.

Return the triangle as a list of integers.

TriangleToList(T)

Return the$n$-th triangular number.

TriangularNumber(n)

Return a list of Ulam numbers. An Ulam number $u(n)$ is the least number $> u(n-1)$ which is a unique sum of two distinct earlier terms; $u(1) = 1$ and $u(2) = 2$.

UlamList(len)

Return the integer partitions of $n$ in graded reverse lexicographic order, the canonical ordering of partitions.

VisitPartition(n, fun)

Return the bitwise exclusive disjunction of $N$ and $K$.

Xor(N, K)

Return an array of type fmpz of length $n$ preset with $0$.

ZArray(len)

Return an array of type fmpz and of size $n$ filled by the values of the function $f$ in the range offset:n.

ZArray(n, f)
ZArray(n, f, offset)

Return a trianguler array with $n$ rows set to $0$ (type ZZ).

ZTriangle(dim)

Return the square root of $2n$ or throw an ArgumentError if $n$ is not a triangular number.

assertTriangular(n)

Order the partitions by greatest part.

Order the partitions by number of parts.

Alias for isoeisinstalled.

data_installed()

Return the positive integers dividing $n$.

divisors(m)

Convert a lower triangular array to a square matrix.

fromΔ(T)

Is $n$ an abundant number, i.e. is $σ(n) > 2n$ ?

isAbundant(n)

Is $n$ a Carmichael (or Šimerka) number?

isCarmichael(n)

Is the integer $n$ a composite number?

isComposite(n)

Is $n$ a cyclic number? $n$ such that there is just one group of order $n$.

isCyclic(n)

Is $n$ divisble by 2?

isEven(n)

Is the integer $n$ nonnegative?

isNonnegative(n)

Is $n$ indivisble by 2?

isOdd(n)

Is the integer $n$ a perfect powers?

isPerfectPower(n)

Is the integer $n$ positive?

isPositive(n)

Is the integer $n$ a power of primes?

isPowerOfPrimes(n)

Return true if n is prime false otherwise.

isPrime(n)

Is the integer $n$ a prime power?

isPrimePower(n)

Query if $m$ is prime to $n$.

isPrimeTo(m, n)

Is the integer $n$ a square number?

isSquare(n)

Is the integer $n$ a squarefree number?

isSquareFree(n)

Is $n$ a strong cyclic number?

isStrongCyclic(n)

Query if $m$ is strong prime to $n$. $m$ is strong prime to $n$ iff $m$ is prime to $n$ and $m$ does not divide $n-1$.

isStrongPrimeTo(m, n)

Is $n$ a triangular number?

isTriangular(n)

Is $n$ an Ulam number?

isUlam(u, n, h, i, r)

Is $n$ a Zumkeller number? A Zumkeller number $n$ is an integer whose divisors can be partitioned into two disjoint sets whose sums are both $σ(n)/2$.

isZumkeller(n)

Indicates if the local copy of the OEIS data (the so-called 'stripped' file) is installed (in ../data).

is_oeis_installed()

Is $n$ a weak Carmichael number?

isweakCarmichael(n)

Return the least absolute remainder. mods uses the symmetric representation for integers modulo m, i.e. remainders will be reduced to integers in the range $[-$div$(|m| - 1, 2),$div$(|m|, 2)]$.

mods(b, a)

Get the sequence with A-number 'anum' from a local copy of the expanded 'stripped.gz' file which can be downloaded from the OEIS. 'bound' is an upper bound for the number of terms returned. The 'stripped' file is assumed to be in the '../data' directory.

oeis_local(anum, bound)

Indicates if the local copy of the OEIS data (the so-called 'stripped' file) is not installed and warns.

oeis_notinstalled()

Returns the path where the oeis data is expected.

oeis_path()

Read a file in the so-called b-file format of the OEIS.

oeis_readbfile(filename)

Download the sequence with A-number 'anum' from the OEIS to a file in json format. The file is saved in the 'data' directory.

oeis_remote(anum)

Search for a sequence in the local OEIS database ('../data/stripped'). Input the sequence as a comma separated string. The search is redone 'restarts' times in the case that no match was found with the first remaining term removed from the search string. Prints the matches.

oeis_search(seq, restarts)
oeis_search(seq, restarts, verbose)

Search for a sequence in the local OEIS database starting from the second term.

oeis_search(seq, restarts)
oeis_search(seq, restarts, verbose)

Make sure that the length of the data section of an OEIS entry does not exceed 260 characters.

oeis_trimdata(fun, offset)

Write a so-called b-file for submission to the OEIS. The file is saved in the 'data' directory.

oeis_writebfile(anum, fun, range)

Return the first $n$ numbers satisfying the predicate isA.

takeFirst(isA, n)

Convert a square matrix to a list using only the $T(n,k)$ with $0 ≤ k ≤ n$. Returns a ZArray.

toΔ(M)

Return $Ω(n)$, the number of prime divisors of $n$ counted with multiplicity (cf. A001222).

Ω(n)

Return $σ(n)$ (a.k.a. $σ_1(n)$), the sum of the divisors of $n$ (cf. A000203).

σ(n)

Return $σ2(n)$ (a.k.a. $σ_2(n)$), the sum of squares of the divisors of $n$ (cf. A001157).

σ2(n)

Return $τ(n)$ (a.k.a. $σ_0(n)$), the number of divisors of $n$ (cf A000005).

τ(n)

Return $ω(n)$, the number of distinct prime divisors of $n$ (cf. A001221).

ω(n)

Return the Euler totient $ϕ(n)$, numbers which are $≤ n$ and prime to $n$.

ϕ(n)

Return the rising factorial which is the product of $i$ ∈ $n:(n + k - 1)$. A convenient infix syntax for the rising factorial is n ↑ k.

↑(n, k)

Return the falling factorial which is the product of $i$ ∈ $(n - k + 1):n$. A convenient infix syntax for the falling factorial is n ↓ k.

↓(n, k)

If $a ≤ b$ then return the product of $i$ ∈ $a:b$ else return $1$.

∏(a, b)

Return the accumulated product of an array.

∏(A)

Query if $m$ is prime to $n$. Knuth, Graham and Patashnik write in "Concrete Mathematics": "Hear us, O mathematicians of the world! Let us not wait any longer! We can make many formulas clearer by defining a new notation now! Let us agree to write m ⊥ n, and to say "m is prime to n", if m and n are relatively prime."

⊥(m, n)

Query if $m$ is strong prime to $n$. $m$ is strong prime to $n$ iff $m$ is prime to $n$ and $m$ does not divide $n-1$.

⍊(m, n)

Generate the Kolakoski sequence which is the unique sequence over the alphabet ${1, 2}$ starting with $1$ and having the sequence of run lengths identical with itself.

C000002()

Iterate over the first $n$ Kolakoski numbers.

I000002(n)

Return the list of the first $n$ terms of the Kolakoski sequence.

L000002(n)

Return the number of divisors of $n$.

V000005(n)

Return the number of integers $≤ n$ and prime to $n$.

V000010(n)

The generating function of the Lucas numbers.

G000032(x)

Return a list of Lucas numbers.

L000032(n)

Return the first n numbers of integer partitions.

L000041(len)

Return the number of partitions of $n$.

V000041(n)

Iterate over the Fibonacci numbers which do not exceed $n$.

F000045(n)

The generating function of the Fibonacci numbers.

G000045(x)

Iterate over the first $n$ Fibonacci numbers.

I000045(n)

Return the first $n$ Fibonacci numbers in an array.

L000045(n)

Fibonacci function for real values, returns a Float64.

R000045(x)

Return the $n$-th Fibonacci number.

V000045(n)

Query if $n$ is a Fibonacci number, returns a Bool.

is000045(n)

Return the number of trees with $n$ unlabeled nodes.

V000055(n)

The generating function of the Tribonacci numbers.

G000073(x)

Return a list of Tribonacci numbers.

L000073(n)

Return the number of unlabeled rooted trees with $n$ nodes.

V000081(n)

Return the number of involutions.

L000085(len)

Return the number of graphs on $n$ unlabeled nodes.

V000088(n)

Return the number of linear forests of 2-rooted trees.

V000106(n)

The generating function of the Catalan numbers.

G000108(x)

Return a list of Catalan numbers.

L000108(n)

Return a list of Bell numbers of length len.

julia> L000110(10)
[1, 1, 2, 5, 15, 52, 203, 877, 4140, 21147]

L000110(len)

Return the n-th Bell number $B_n$.

julia> V000110(11)
678570

V000110(n)

Generate the André numbers (a.k.a. Euler-up-down numbers A000111). Don't confuse with the Euler numbers A122045.

C000111()

Return the up-down numbers (2-alternating permutations).

V000111(n)

Number of ways of writing a nonnegative integer n as a sum of 4 squares.

L000118(len)

Return the number of $1$'s in binary expansion of $n$.

V000120(n)

Return the number of ways of writing a nonnegative integer n as a square.

L000122(len)

Return the number of ways of writing a nonnegative integer n as a sum of 5 squares.

L000132(len)

Return the number of ways of writing a nonnegative integer n as a sum of 6 squares.

L000141(len)

Return the factorial numbers.

V000142(n)

Return the number of ways of writing a nonnegative integer n as a sum of 8 squares.

L000143(len)

Return the number of ways of writing a nonnegative integer n as a sum of 10 squares.

L000144(len)

Return the number of ways of writing a nonnegative integer n as a sum of 12 squares.

L000145(len)

Return the double factorial of even numbers: $2^n n! = (2n)!!$.

V000165(n)

Return the sum of the divisors of $n$.

V000203(n)

Return the polygonal numbers of shape 3 (the triangular numbers).

V000217(n)

Return $(n+1)!$ Hypergeometric1F1$[-n, -n-1, -1]$. Number of fixedpoint-free permutations beginning with 2. (L. Euler).

V000255(n)

The generating function of the number of rooted bicubic maps.

G000257(x)

Return a list of the number of rooted bicubic maps.

L000257(n)

Return $n!$ Hypergeometric1F1$[1-n, 2, -1]$. Number of partitions of ${1,...,n}$ into any number of ordered subsets.

V000262(n)

Return the odd part of $n$.

V000265(n)

Return the polygonal numbers of shape 4 (the squares).

V000290(n)

Return the pyramidal numbers of shape 3 (tetrahedral numbers).

V000292(n)

Return the polygonal numbers of shape 5 (the pentagonal numbers).

V000326(n)

Return the pyramidal numbers of shape 4 (square pyramidal numbers).

V000330(n)

Return the Bell transform of the MultiFactorial numbers of type (4,3).

julia> ShowAsΔ(T000369(5))
1
0 1
0 3 1
0 21 9 1
0 231 111 18 1

T000369(n)

Return the polygonal numbers of shape 6 (the hexagonal numbers).

V000384(n)

Return the central rising factorial $(n+1) ↑ (n+1) = (2n+1)! / n!$.

V000407(n)

Return the polygonal numbers of shape 7 (the heptagonal numbers).

V000566(n)

Return the polygonal numbers of shape 8 (the octagonal numbers).

V000567(n)

Compute the expansion of $∏_{m≥1} (1 - q^m)^{24}$.

L000594(len)

Return the number of indecomposable perfect matchings on $[2n]$.

L000698(len)

Return the number of partitions of n into parts of 2 kinds.

L000712(len)

Return the number of partitions of n into parts of 3 kinds.

L000716(len)

Return the list of number of primes $≤ n$ for $n ≥ 0$.

julia> L000720(8)

[0, 0, 1, 2, 2, 3, 3, 4]

L000720(len)

Compute the expansion of $∏ _{m≥1} (1 - q^m)^4$.

L000727(len)

Compute the expansion of $∏ _{m≥1} (1 - q^m)^5$.

L000728(len)

Compute the expansion of $∏ _{m≥1} (1 - q^m)^6$.

L000729(len)

Compute the expansion of $∏ _{m≥1} (1 - q^m)^7$.

L000730(len)

Compute the expansion of $∏ _{m≥1} (1 - q^m)^8$.

L000731(len)

Compute the expansion of $∏_{m≥1} (1 - q^m)^{12}$.

L000735(len)

Compute the expansion of $∏_{m≥1} (1 - q^m)^{16}$.

L000739(len)

Return the decimal expansion of π up to $n$ digits as a string. (Note what the docstring of 'Pi'' says about the number of digits in the output.)

V000796(digits)

The generating function of the Fine numbers (with a(0) = 1).

G000957(x)

Return a list of Fine numbers.

L000957(n)

Return a list of powers of primes of length len. (Numbers of the form $p^k$ where $p$ is a prime and $k ≥ 0$.)

julia> L000961(8)
[1, 2, 3, 4, 5, 7, 8, 9]

L000961(len)

The generating function of the little Schröder numbers.

G001003(x)

Return a list of little Schröder numbers.

L001003(n)

The generating function of the Motzkin numbers.

G001006(x)

Return a list of Motzkin numbers.

L001006(n)

The generating function of the Jacobsthal numbers (with a(0) = 1).

G001045(x)

Return a list of Jacobsthal numbers.

L001045(n)

Return the polygonal numbers of shape 9 (the nonagonal numbers).

V001106(n)

Return the polygonal numbers of shape 10 (decagonal numbers).

V001107(n)

Return the double factorial of odd numbers, $1×3×5×...×(2n-1) = (2n-1)!!$.

V001147(n)

Return $σ2(n)$ (a.k.a. $σ_2(n)$), the sum of squares of the divisors of $n$.

V001157(n)

Return the number of distinct prime divisors of $n$.

V001221(n)

Return the number of prime divisors of $n$ counted with multiplicity.

V001222(n)

Return 2^BitCount(n). Should be called Glaisher's sequence since James Glaisher showed that odd binomial coefficients are counted by this sequence.

V001316(n)

Return $(n+1)!$ Hypergeometric1F1$[-n, -n-1, 1]$. Number of arrangements of ${1, 2, ..., n+1}$ containing the element 1.

V001339(n)

Return the sequence defined by $a(n) = n! [x^n] \exp(-x-(x^2)/2)$.

L001464(len)

Return the polygonal numbers of shape 2 (these are the natural numbers).

V001477(n)

Return a triangle of coefficients of Bessel polynomials (better use A132062).

T001497(n)

Return the 2-adic valuation of $2n$.

V001511(n)

Return the order of alternating group $A_n$, or number of even permutations of $n$ letters.

L001710(len)

Return $∏_{1 ≤ j ≤ n, j ⊥ n} j$, the product of the positive integers which are $≤ N$ and are prime to $n$, a.k.a. the phi-torial of n.

V001783(n)

Return the odd part of the swinging factorial of $2n$.

V001790(n)

Return the odd part of the swinging factorial of $2n+1$.

V001803(n)

Return the quadruple factorial numbers with shift 2, $(2n)!/n!$.

V001813(n)

Maximal number of comparisons for sorting $n$ elements by binary insertion.

V001855(n)

Return the expansion of $1/ϑ_4(q)^2$ in powers of q.

L001934(len)

Iterate over the highly abundant numbers which do not exceed $n$ ($1 ≤ i ≤ n$).

F002093(n)

Iterate over the first $n$ highly abundant numbers.

I002093(n)

Return the first $n$ highly abundant numbers as an array.

L002093(n)

Return the $n$-th highly abundant number. Indexing starts with 1.

V002093(n)

Compute the expansion of $∏ _{m≥1} (1 - q^m)^2$.

L002107(len)

Return the product of first $n$ primes.

V002110(n)

Return the pyramidal numbers of shape 5 (pentagonal pyramidal numbers).

V002411(n)

Return the pyramidal numbers of shape 6 (hexagonal pyramidal numbers).

V002412(n)

Return the pyramidal numbers of shape 7 (heptagonal pyramidal numbers).

V002413(n)

Return the pyramidal numbers of shape 8 (octagonal pyramidal numbers).

V002414(n)

The generating function of the central trinomial.

G002426(x)

Return a list of the central trinomials.

L002426(n)

Return the list of length len of Clausen numbers which are the denominators of the Bernoulli numbers $B_{2n}$.

L002445(len)

Return the Clausen number $C(n)$ which is the denominator of the Bernoulli number $B_{2n}$.

V002445(n)

Return the expansion of Jacobi theta function $ϑ(-q)$.

L002448(len)

Return primes of the form $6m + 1$.

L002476(bound)

Return the number of $n$-node graphs without isolated nodes.

V002494(n)

Return a list of composite numbers of length len. (Numbers which have more than one prime divisor.)

julia> L002808(8)
[4, 6, 8, 9, 10, 12, 14, 15]

L002808(len)

Return a list of Ulam numbers.

L002858(len)

Iterate over the Carmichael (or Šimerka) numbers which do not exceed $n$.

F002997(n)

Iterate over the first $n$ Carmichael (or Šimerka) numbers.

I002997(n)

Return the first $n$ Carmichael (or Šimerka) numbers in an array.

L002997(n)

Return $n$ XOR $n>>1$, using max length.

V003188(n)

Iterate over the first $n$ cyclic numbers.

I003277(n)

Return the first $n$ cyclic numbers in an array.

L003277(n)

Binary entropy function: $a(n) = n +$ min $( a(k) + a(n-k) : 1 ≤ k ≤ n-1 )$ for $n > 1,$ and $a(1) = 0$.

V003314(n)

Return the number of connected permutations of $[1..n]$. Also called indecomposable permutations.

L003319(len)

Return the sequence defined by $A(n) = n! [x^n] \exp \tan(x)$ as an array of length len.

L003723(len)

Return $n$ EQV $n$.

V003817(n)

Return the number of ways of writing a nonnegative integer n as a sum of 2 squares.

L004018(len)

Return the expansion of $1/ϑ_3(q)$ in powers of q.

L004402(len)

Return the expansion of $1/ϑ_3(q)^2$ in powers of q.

L004403(len)

Return the expansion of $1/ϑ_3(q)^3$ in powers of q.

L004404(len)

Return the expansion of $1/ϑ_3(q)^4$ in powers of q.

L004405(len)

Return the expansion of $1/ϑ_3(q)^5$ in powers of q.

L004406(len)

Return the expansion of $1/ϑ_3(q)^6$ in powers of q.

L004407(len)

Return the expansion of $1/ϑ_3(q)^7$ in powers of q.

L004408(len)

Return the expansion of $1/ϑ_3(q)^8$ in powers of q.

L004409(len)

Return the expansion of $1/ϑ_3(q)^9$ in powers of q.

L004410(len)

Return the expansion of $1/ϑ_3(q)^{10}$ in powers of q.

L004411(len)

Return the expansion of $1/ϑ_3(q)^{11}$ in powers of q.

L004412(len)

Return the expansion of $1/ϑ_3(q)^{12}$ in powers of q.

L004413(len)

Return the expansion of $1/ϑ_3(q)^{13}$ in powers of q.

L004414(len)

Return the expansion of $1/ϑ_3(q)^{14}$ in powers of q.

L004415(len)

Return the expansion of $1/ϑ_3(q)^{15}$ in powers of q.

L004416(len)

Return the expansion of $1/ϑ_3(q)^{16}$ in powers of q.

L004417(len)

Return the expansion of $1/ϑ_3(q)^{17}$ in powers of q.

L004418(len)

Return the expansion of $1/ϑ_3(q)^{18}$ in powers of q.

L004419(len)

Return the expansion of $1/ϑ_3(q)^{19}$ in powers of q.

L004420(len)

Return the expansion of $1/ϑ_3(q)^{20}$ in powers of q.

L004421(len)

Return the expansion of $1/ϑ_3(q)^{21}$ in powers of q.

L004422(len)

Return the expansion of $1/ϑ_3(q)^{22}$ in powers of q.

L004423(len)

Return the expansion of $1/ϑ_3(q)^{23}$ in powers of q.

L004424(len)

Return the expansion of $1/ϑ_3(q)^{24}$ in powers of q.

L004425(len)

Return the Bell transform of the MultiFactorial numbers of type (3,2).

julia> ShowAsΔ(T004747(5))
1
0 1
0 2 1
0 10 6 1
0 80 52 12 1

T004747(n)

The generating function of the Riordan numbers with 1 prepended.

G005043(x)

Return a list of the Riordan numbers (1 prepended).

L005043(n)

Iterate over the abundant numbers which do not exceed $n (1 ≤ i ≤ n)$.

F005101(n)

Iterate over the first $n$ abundant numbers.

I005101(n)

Return a list of the first $n$ abundant numbers.

L005101(n)

Return the value of the $n$-th abundant number.

V005101(n)

Is $n$ a term of sequence A005101?

is005101(n)

Return a list of squarefree numbers of length len. (Numbers which are not divisible by a square greater than 1.)

julia> L005117(8)
[1, 2, 3, 5, 6, 7, 10, 11]

L005117(len)

Return $2n$ - BitCount(n).

V005187(n)

Return the number of non-vanishing Feynman diagrams of order $2n$ for the electron or the photon propagators in quantum electrodynamics.

L005411(len)

Return the number of non-vanishing Feynman diagrams of order $2n$ for the vacuum polarization in quantum electrodynamics.

L005412(len)

Return the number of self-inverse partial permutations.

L005425(len)

Return the pyramidal numbers of shape -1.

V005564(n)

Sum of all partition coefficients of n.

L005651(len)

Return the number of partitions of n into parts of 12 kinds.

L005758(len)

Return the number of directed animals of size n as an array of length len.

L005773(len)

Return the number of ways of writing a nonnegative integer n as a sum of 3 squares.

L005875(len)

Counting some sets of permutations.

L006012(len)

Return the $n$-th term of the third Multinacci sequence.

V006053(n)

Return a list of length len of the Euler transform of tau.

L006171(len)

Return the number of factorization patterns of polynomials of degree n over integers.

V006171(n)

Return the expansion of exp(tan(x)).

L006229(len)

Return max$(1, 2n) - (n$ EQV $n)$, using max length.

V006257(n)

The generating function of the large Schröder numbers.

G006318(x)

Return the large Schröder numbers.

L006318(len)

Return the even part of $n$.

V006519(n)

Is $n$ a prime of the form $𝚽_k(m)$ with $k > 2$ and $|m| > 1$ where $𝚽_k(m)$ denotes the $k$-th cyclotomic polynomial evaluated at $m$.

is206864(n)

Return the number of partitions of n into parts of 24 kinds.

L006922(len)

Is $n$ a numbers of the form $𝚽_k(m)$ with $k > 2$ and $|m| > 1$ where $𝚽_k(m)$ denotes the $k$-th cyclotomic polynomial evaluated at $m$.

is206942(n)

Return $(2n)!$ Hypergeometric1F1$[-n, -2n, -2]$. Number of ways $n$ couples can sit in a row without any spouses next to each other.

V007060(n)

Pascal's triangle.

T007318(n)

Return primes of the form $8n+7$, that is, primes congruent to -1 mod 8.

L007522(bound)

Return the triple factorial numbers with shift 1, $3^n n! = (3n)!!!$.

V007559(n)

Return the pyramidal numbers of shape 9 (enneagonal pyramidal numbers).

V007584(n)

Return the pyramidal numbers of shape 10 (decagonal pyramidal numbers).

V007585(n)

Return the quadruple factorial numbers with shift 1.

V007696(n)

Return the 2-adic valuation of $n$.

V007814(n)

Return the largest prime in $N$ (the semiring of natural numbers including zero) less than n for $n ≥ 0$. (The prev_prime function of Mathematica, Maple, Magma and SageMath.)

V007917(n)

Lists the first n rows of A008279 by concatenating.

L008279(n)

Return the triangular array as a square matrix with dim rows.

M008279(dim)

Iterates over the first n rows of A008279.

T008279(n)

Return row n of A008279 based on the iteration T008279(n).

V008279(n)

Return the nnumber of ways of writing a nonnegative integer n as a sum of 7 squares.

L008451(len)

Return the number of ways of writing a nonnegative integer n as a sum of 9 squares.

L008452(len)

Return the number of ways of writing a nonnegative integer n as a sum of 11 squares.

L008453(len)

Return the triple factorial numbers with shift 2.

V008544(n)

Return the quadruple factorial numbers with shift 3.

V008545(n)

Return the value of the Möbius function $μ(n)$ which is the sum of the primitive n-th roots of unity.

V008683(n)

Return numbers $n$ that are primitively represented by $x^2 + y^2$. Also numbers $n$ such that $√(-1)$ mod $n$ exists.

L008784(bound)

Compute the expansion of $∏ _{m≥1} (1 - q^m)$.

L010815(len)

Compute the expansion of $∏ _{m≥1} (1 - q^m)^3$.

L010816(len)

Compute the expansion of $∏ _{m≥1} (1 - q^m)^9$.

L010817(len)

Compute the expansion of $∏_{m≥1} (1 - q^m)^{11}$.

L010819(len)

Compute the expansion of $∏_{m≥1} (1 - q^m)^{13}$.

L010820(len)

Compute the expansion of $∏_{m≥1} (1 - q^m)^{14}$.

L010821(len)

Compute the expansion of $∏_{m≥1} (1 - q^m)^{15}$.

L010822(len)

Compute the expansion of $∏_{m≥1} (1 - q^m)^{17}$.

L010823(len)

Compute the expansion of $∏_{m≥1} (1 - q^m)^{18}$.

L010824(len)

Compute the expansion of $∏_{m≥1} (1 - q^m)^{19}$.

L010825(len)

Compute the expansion of $∏_{m≥1} (1 - q^m)^{20}$.

L010826(len)

Compute the expansion of $∏_{m≥1} (1 - q^m)^{21}$.

L010827(len)

Compute the expansion of $∏_{m≥1} (1 - q^m)^{22}$.

L010828(len)

Compute the expansion of $∏_{m≥1} (1 - q^m)^{23}$.

L010829(len)

Compute the expansion of $∏_{m≥1} (1 - q^m)^{25}$.

L010830(len)

Compute the expansion of $∏_{m≥1} (1 - q^m)^{26}$.

L010831(len)

Compute the expansion of $∏_{m≥1} (1 - q^m)^{27}$.

L010832(len)

Compute the expansion of $∏_{m≥1} (1 - q^m)^{28}$.

L010833(len)

Compute the expansion of $∏_{m≥1} (1 - q^m)^{29}$.

L010834(len)

Compute the expansion of $∏_{m≥1} (1 - q^m)^{30}$.

L010835(len)

Compute the expansion of $∏_{m≥1} (1 - q^m)^{31}$.

L010836(len)

Compute the expansion of $∏_{m≥1} (1 - q^m)^{32}$.

L010837(len)

Compute the expansion of $∏_{m≥1} (1 - q^m)^{44}$.

L010838(len)

Compute the expansion of $∏_{m≥1} (1 - q^m)^{48}$.

L010839(len)

Compute the expansion of $∏_{m≥1} (1 - q^m)^{40}$.

L010840(len)

Compute the expansion of $∏_{m≥1} (1 - q^m)^{64}$.

L010841(len)

Return the number of lattice paths from $(0,0)$ to $(x,y)$ that never pass below $y = x$ and use step set ${(0,1), (1,0), (2,0), (3,0), ...}$.

T011117(n)

Return $n$ - BitCount(n).

V011371(n)

Return a list of the number of squarefree numbers $< n$.

julia> L013928(8)
[0, 1, 2, 3, 3, 4, 5, 6]

L013928(len)

Return the polygonal numbers of shape -2.

V014107(n)

Return the expansion of $1/ϑ_4(q)$ in powers of q.

L015128(len)

Return the number of partitions of n into parts of 4 kinds.

L023003(len)

Return the number of partitions of n into parts of 5 kinds.

L023004(len)

Return the number of partitions of n into parts of 6 kinds.

L023005(len)

Return the number of partitions of n into parts of 7 kinds.

L023006(len)

Return the number of partitions of n into parts of 8 kinds.

L023007(len)

Return the number of partitions of n into parts of 9 kinds.

L023008(len)

Return the number of partitions of n into parts of 10 kinds.

L023009(len)

Return the number of partitions of n into parts of 11 kinds.

L023010(len)

Return the number of partitions of n into parts of 13 kinds.

L023011(len)

Return the number of partitions of n into parts of 14 kinds.

L023012(len)

Return the number of partitions of n into parts of 15 kinds.

L023013(len)

Return the number of partitions of n into parts of 16 kinds.

L023014(len)

Return the number of partitions of n into parts of 17 kinds.

L023015(len)

Return the number of partitions of n into parts of 18 kinds.

L023016(len)

Return the number of partitions of n into parts of 19 kinds.

L023017(len)

Return the number of partitions of n into parts of 20 kinds.

L023018(len)

Return the number of partitions of n into parts of 21 kinds.

L023019(len)

Return the number of partitions of n into parts of 22 kinds.

L023020(len)

Return the number of partitions of n into parts of 23 kinds.

L023021(len)

Is $n$ a prime represented by a cyclotomic binary form?

is325143(n)

Is $n$ a prime unrepresentable by a cyclotomic binary form?

is325145(n)

Return a list of the number of prime powers $≤ n$ with exponents $k ≥ 1$.

julia> L025528(8)
[0, 0, 1, 2, 3, 4, 4, 5]

L025528(len)

Return the partitions of $n$ as a weakly increasing lists of parts in lexicographic order.

V026791(n)

Return the numerator of the Bernoulli number $B_n$.

V027641(n)

Return the denominator of Bernoulli number $B_n$.

V027642(n)

Is V327987(n) = ∑$_{d|n} d & (n/d) = 0$ ?

is327988(n)

Return positive numbers of the form $x^2+xy-y^2$; or, of the form $5x^2-y^2$.

L031363(bound)

Return the triple factorial numbers with shift 3.

V032031(n)

Recurrence $a(n) = a(n-1) + ⌊ a(n-1)/(n-1) ⌋ + 2$ for $m ≥ 2$ and $a(1) = 1$.

V033156(n)

Return $(2n)!$ Hypergeometric1F1$[-n, -2n, -1]$. Number of acyclic orientations of the Turán graph $T(2n,n)$.

V033815(n)

Return positive integers that are primitively represented by $x^2 + xy + y^2$.

L034017(bound)

Return the primorial of $n$, the product of the primes $≤ n$.

V034386(n)

Return the number of unitary divisors of $n$, $d$ such that $d$ divides $n$ and $d ⊥ n/d$.

V034444(n)

Iterate over the record values of sigma the indices of which do not exceed $n$ ($1 ≤ r ≤ n$).

F034885(n)

Iterate over the first $n$ record values of sigma.

I034885(n)

Return the first $n$ record values of sigma as an array.

L034885(n)

Return the $n$-th record of sigma. Indexing starts with 1.

V034885(n)

Return the expansion of $ϑ_4(q)^8$ in powers of q.

L035016(len)

Return positive numbers of the form $x^2 - 2y^2$ with integers $x, y$ (discriminant is 8).

L035251(bound)

Return $n$ NAND $n$.

V035327(n)

Return the partition coefficients of $n$, first ordered by length.

L036038(n)

Return the multinomial coefficients of the integer partitions of $n$. Gives the number of permutations whose cycle structure is the given partition.

julia> L036039(5)
[24, 30, 20, 20, 15, 10, 1]

L036039(n)

Return the skew Fibonacci-Pascal triangle with dim rows.

T037027(dim)

Return $n$ XOR $n>>1$, using min length.

V038554(n)

Return $n$ XOR $n+1$, using max length.

V038712(n)

Return primes congruent to ${0, 1, 4}$ mod 5 (cf. also [A141158]).

L038872(bound)

Return primes p such that 2 is a square mod p; or, primes congruent to ${1, 2, 7}$ mod $8$.

L038873(bound)

The Riordan square of the Catalan numbers.

T039599(n)

Return the signed double Pochhammer triangle: expansion of $x(x-2)(x-4)..(x-2n+2)$.

julia> ShowAsΔ(T039683(5))
1
0 1
0 2 1
0 8 6 1
0 48 44 12 1

T039683(n)

Return the signed Fibonacci numbers, dubbed negaFibonacci numbers.

L039834(n)

Return positive integers not congruent to 2 mod 4; regular numbers modulo 4.

L042965(bound)

Return $2^{2n - bc(n)}$ where bc(n) is BitCount(n).

V046161(n)

Return the quadruple factorial numbers $4^n n!$.

V047053(n)

Return the number of planar rooted trees with $n$ nodes and tricolored end nodes.

L047891(len)

Return $n$ XOR $2n$, using max length.

V048724(n)

Return $n$ AND $n>>1$, using min length.

V048735(n)

Lists the first n rows of A048993 by concatenating.

L048993(n)

Return the triangular array as a square matrix with dim rows.

M048993(dim)

Iterates over the first n rows of A048993.

T048993(n)

Return row n of A048993 based on the iteration T048993(n).

V048993(n)

Return the arctangent numbers (expansion of arctan$(x)^n/n!$).

T049218(dim)

Return the coefficients of Chebyshev's U$(n, x/2)$ polynomials.

T049310(dim)

Iterate over the first $n$ strong cyclic numbers.

I050384(n)

Return the first $n$ strong cyclic numbers in an array.

L050384(n)

Return the triangle $3^{n-m}S1(n, m)$ where S1 are the signed Stirling numbers of first kind.

julia> ShowAsΔ(T051141(5))
1
0 1
0 3 1
0 18 9 1
0 162 99 18 1

T051141(n)

Return the Bell transform of the MultiFactorial numbers of type (4,4).

julia> ShowAsΔ(T051142(5))
1
0 1
0 4 1
0 32 12 1
0 384 176 24 1

T051142(n)

Return $n$ XOR $k$, using max length.

V051933(n, k)

Return a list of length len of the Euler transform of [0, 1, 2, 3, ...].

L052847(len)

Return the Euler transform of [0, 1, 2, 3, ...].

V052847(n)

Return the coefficients of the Chebyshev-U polynomials.

T053117(len)

Return the coefficients of the Chebyshev-T polynomials.

T053120(len)

Return the Catalan triangle (with 0's) read by rows.

T053121(dim)

Binary entropy: $a(n) = n +$ min ${ a(k) + a(n-k) : 1 ≤ k ≤ n-1 }.$

V054248(n)

Return the total number of nodes in all simple graphs of $n$ nodes.

V055542(n)

Total number of nodes in all trees with n nodes.

V055543(n)

Total number of nodes in all rooted trees with $n$ nodes.

V055544(n)

Return the 2-adic factorial of n.

V055634(n)

Return the exponential transform of Pascal's triangle.

T055883(n)

Return $4^{2n - bc(n)}$ where bc(n) is BitCount(n).

V056982(n)

Return mumbers n such that 2 is a square mod n.

L057126(bound)

Return positive integers primitively represented by $x^2 + 2y^2$.

L057127(bound)

Return the pyramidal numbers of shape 0.

V058373(n)

Return the triangle $T(n,k)$ of tangent numbers, coefficient of $x^n/n!$ in the expansion of $(tan x)^k/k!$.

T059419(dim)

Return the number of Schroeder paths (i.e., consisting of steps $U=(1,1), D=(1,-1), H=(2,0)$ and never going below the x-axis) from $(0,0)$ to $(2n,0)$, having $k$ peaks.

T060693(n)

Return $2^{n - bc(n)}$ where bc(n) is BitCount(n).

V060818(n)

Return the result of replacing each prime factor of n with 2.

V061142(n)

Partial sums of the sequence $⌊ \log[2](n) ⌋$.

V061168(n)

Return a list of length len of the Euler transform of sigma.

L061256(len)

Return the Euler transform of sigma.

V061256(n)

Return the number of rooted unlabeled connected triangular maps on a compact closed oriented surface with $2n$ faces.

L062980(len)

Return the (reflected) Motzkin triangle.

T064189(dim)

Return the number of powers of primes $≤ n$. (Powers of primes are numbers of the form $p^k$ where $p$ is a prime and $k ≥ 0$.)

julia> L065515(8)
[0, 1, 2, 3, 4, 5, 5, 6]

L065515(len)

Computes a list of length len of the integer Bernoulli numbers $b_{2}(n)$ using Seidel's boustrophedon algorithm.

L065619(len)

Return the number of down-up permutations w on $[n+1]$ such that $w_2 = 1$.

V065619(n)

Return a list of the number of composite numbers $≤ n$.

julia> L065855(8)
[0, 0, 0, 0, 1, 1, 2, 2]

L065855(len)

Return the coefficients of unitary Hermite polynomials He$_n(x)$.

T066325(dim)

Return GaussFactorial(n, 1)/GaussFactorial(n, n).

V066570(n)

Return the polygonal numbers of shape 0.

V067998(n)

Return primes congruent to 1 (mod 12).

L068228(bound)

The generating function of twice the Catalan numbers.

G068875(x)

Return a list of twice the Catalan numbers.

L068875(n)

Return a list of the number of prime powers $≤ n$ with exponents $k ≥ 2$.

julia> L069637(8)
[0, 0, 0, 0, 1, 1, 1, 1]

L069637(len)

Return an iterator over the list of partitions of $n$ into $k$ parts.

I072233(n)

Return a list of the number of partitions of $n$ into $k$ parts.

L072233(n)

Return the partition coefficients of $n$, first ordered by biggest part.

L078760(n)

Return $n$ NEG1 $n+1$, using max length.

V080079(n)

Return the integer partitions of $n$ in graded reverse lexicographic order, the canonical ordering of partitions.

V080577(n)

Return $n$ CNIMP $n+1$, using min length.

V080940(n)

Return the polygonal numbers of shape 1.

V080956(n)

Return $rac{n!}{⌊n/2⌋!}$.

V081125(n)

Return the number of lattice paths from $(0,0)$ to $(n+1,n+1)$ that consist of steps $(i,0)$ and $(0,j)$ with $i,j≥1$ and stay strictly below the diagonal line $y=x$ except at the endpoints.

L082298(len)

Return the number of Schröder paths of semilength n in which the (2,0)-steps come in 4 colors.

L082301(len)

Return the coefficients in the expansion of $(1-5x-√(25x^2-14x+1))/(2x)$.

L082302(len)

Return the number of partitions of n into parts of 30 kinds.

L082556(len)

Return the number of partitions of n into parts of 32 kinds.

L082557(len)

Return the number of partitions of n into parts of 48 kinds.

L082558(len)

Return the number of partitions of n into parts of 64 kinds.

L082559(len)

Iterate over the Zumkeller numbers $z$ which are below $n, (1 ≤ z ≤ n)$.

F083207(n)

Iterate over the first $n$ Zumkeller numbers.

I083207(n)

List the first $n$ Zumkeller numbers.

L083207(n)

Return the $n$-th Zumkeller number.

V083207(n)

Is $n$ a Zumkeller number?

is083207(n)

Return the sum of lengths of binary expansions of $0$ through $n$.

V083652(n)

Return positive numbers of the form $n = x^2-3y^2$ of discriminant 12.

L084916(bound)

Return the number of permutations of ${1,2,...,n}$ having $k$ cycles such that the elements of each cycle of the permutation form an interval. (Ran Pan)

T084938(n)

Return $n$ OR $n+1$, using max length.

V086799(n)

Number of unlabeled rooted trees with at most n nodes.

L087803(len)

Return the number of types of signatures of partitions of n.

V088887(n)

Return a triangle related to the median Euler numbers.

T088969(n)

Return positive numbers represented by the integer binary quadratic form $x^2+xy-y^2$ with $x$ and $y$ relatively prime.

L089270(bound)

Return the number of lists of $k$ unlabeled permutations whose total length is $n$.

T090238(n)

Return the number of Schroeder paths of length $2n$ and having $k$ ascents.

T090981(n)

Is $n$ unrepresentable by a cyclotomic binary forms?

is293654(n)

Lists the first n rows of A094587 by concatenating.

L094587(n)

Return the triangular array as a square matrix with dim rows.

M094587(dim)

Iterates over the first n rows of A094587.

T094587(n)

Return row n of A094587 based on the iteration T094587(n).

V094587(n)

Return the number of increasing 0-2 trees (A002105) on $2n$ edges in which the minimal path from the root has length $k$.

T094665(n)

Return total number of edges in all rooted trees with $n$ nodes.

V095350(n)

Return the polygonal numbers of shape -1.

V095794(n)

Is $n$ represented by a cyclotomic binary form?

is296095(n)

Return the expansion of $ϑ_4(q)^4$ in powers of q.

L096727(len)

Minimum total number of comparisons to find each of the values $1$ through $n$ using a binary search with $3$-way comparisons.

V097383(n)

Lists the first $n$ rows of A097805 by concatinating. This is the format for submissions to the OEIS.

L097805(n)

Return the triangular array as a square matrix.

M097805(dim)

Iterates over the first $n$ rows of A097805.

T097805(n)

Return row $n$ of A097805 based on the iteration T097805(n).

V097805(n)

Return $(2n)!$ Hypergeometric1F1$[-n, -2n, 1]$.

V099022(n)

Return the coefficients of the modified Hermite polynomials.

T099174(dim)

Is $n$ primitively represented by a cyclotomic binary forms?

is299498(n)

Is n a prime represented in more than one way by cyclotomic binary forms f(x,y) with x and y prime numbers and y < x?

is299733(n)

Is $n$ represented by a cyclotomic binary form f(x, y) where x and y are prime numbers and 0 < y < x?

is299928(n)

Is $n$ a prime represented by a cyclotomic binary form f(x, y) where x and y are prime numbers and 0 < y < x?

is299929(n)

Is $n$ a prime represented by a cyclotomic binary form f(x, y) with x and y odd prime numbers and x > y.

is299930(n)

Return 4^BitCount(n).

V102376(n)

Return the matrix inverse of coefficients of Bessel polynomials; essentially the same as coefficients of modified Hermite polynomials T096713.

julia> ShowAsΔ(T104556(5))
1
0 1
0 -1 1
0 0 -3 1
0 0 3 -6 1

T104556(n)

Return the inverse of the Motzkin triangle (cf. A064189).

T104562(dim)

Return the expansion of $ϑ_4(q)^2$ in powers of q.

L104794(len)

Return the coefficients in the expansion of $(1+2x-√(1+4x^2))/(2x)$.

L105523(len)

Return the the Catalan convolution triangle.

T106566(n)

A transform the of triple factorial numbers.

L107716(len)

Return a list of length len of the Euler transform of the factorial.

L107895(len)

Return the Euler transform of the factorial.

V107895(n)

Return the sequence with generating function satisfying $x = (A(x)+(A(x))^2)/(1-A(x)-(A(x))^2)$.

L108624(len)

Return the triangle $T(n, k) = \binom{n}{k} \times$ involutions$(n - k)$.

T111062(dim)

A convolutory inverse of the factorial sequence.

L111529(len)

A convolutory inverse of the factorial sequence.

L111530(len)