Library
IntegerSequences.AltCoeffs
— FunctionReturn the coefficients of the polynomial $p$ with alternating signs.
AltCoeffs(p)
IntegerSequences.AltEgfCoeffs
— FunctionReturn the coefficients of the polynomial $p$ divided by $(-1)^k k!$.
AltEgfCoeffs(p)
IntegerSequences.AltEgfPoly
— FunctionReturn the polynomial $p$ with coefficients in exponential form and alternating signs (i.e. with $(-1)^k c[k] x^k/k!$).
AltEgfPoly(p)
IntegerSequences.AltPoly
— FunctionReturn 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)
IntegerSequences.And
— FunctionReturn the bitwise conjunction of $N$ and $K$.
And(N, K)
IntegerSequences.André
— FunctionReturn the generalized André numbers which are the $m$-alternating permutations of length $n$, cf. A181937.
André(m, n)
IntegerSequences.BellNumber
— FunctionReturn the n-th Bell number. Bell numbers count the ways to partition a set of $n$ labeled elements.
julia> BellNumber(10)
115975
BellNumber(n)
IntegerSequences.BellNumberList
— FunctionReturn a list of the first m Bell numbers (a.k.a. exponential numbers).
BellNumberList(m)
IntegerSequences.BellTrans
— FunctionThe 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)
IntegerSequences.BellTriangle
— FunctionThe 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)
IntegerSequences.Bernoulli
— FunctionReturn the rational Bernoulli number $B_n$ (cf. A027641/A027642).
Bernoulli(n)
IntegerSequences.BernoulliInt
— FunctionReturn the generalized integer Bernoulli numbers $b_{m}(n) = n ×$André$(m, n-1)$.
BernoulliInt(m, n)
IntegerSequences.BernoulliIntList
— FunctionReturn a list of length len
of the integer Bernoulli numbers $b_{m}(n)$ using Seidel's boustrophedon algorithm.
BernoulliIntList(m, len)
IntegerSequences.BernoulliList
— FunctionReturn a list of the first len
Bernoulli numbers $B_n$ (cf. A027641/A027642).
BernoulliList(len)
IntegerSequences.Bil
— FunctionAlias for the function BinaryIntegerLength.
Bil(n)
IntegerSequences.Bin
— FunctionReturn the 2-adic valuation of $n$.
Bin(n)
IntegerSequences.BinDigits
— FunctionReturn 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)
IntegerSequences.BinaryIntegerLength
— FunctionReturn 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)
IntegerSequences.Binomial
— FunctionReturn 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)
IntegerSequences.BitCount
— FunctionReturn the number of $1$'s in binary expansion of $n$.
BitCount(n)
IntegerSequences.Bits
— FunctionReturn 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)
IntegerSequences.BoolOps
— ConstantThe list of acronyms for the 16 binary boolean operations.
IntegerSequences.CalkinWilfTree
— FunctionAlias 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)
IntegerSequences.CantorBoustrophedonicEnumeration
— FunctionThe 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)
IntegerSequences.CantorBoustrophedonicMachine
— FunctionThe boustrophedonic Cantor enumeration implemented as a state machine to avoid the evaluation of the square root function.
CantorBoustrophedonicMachine(x, y)
IntegerSequences.CantorBoustrophedonicPairing
— FunctionThe 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)
IntegerSequences.CantorEnumeration
— FunctionThe 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)
IntegerSequences.CantorMachine
— FunctionThe Cantor enumeration implemented as a state machine to avoid the evaluation of the square root function.
CantorMachine(x, y, state)
IntegerSequences.CantorPairing
— FunctionThe 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)
IntegerSequences.Central
— FunctionReturn the central column of the coefficients of the sequence of polynomials $P$.
Central(P, len)
IntegerSequences.Cimp
— FunctionReturn the bitwise converse implication of $N$ and $K$.
Cimp(N, K)
IntegerSequences.ClausenNumber
— FunctionReturn the Clausen number $C_n$ which is the denominator of the Bernoulli number $B_{2n}$.
ClausenNumber(n)
IntegerSequences.ClausenNumberList
— FunctionReturn the list of length len of Clausen numbers which are the denominators of the Bernoulli numbers $B_{2n}$.
ClausenNumberList(len)
IntegerSequences.Cnimp
— FunctionReturn the bitwise converse nonimplication of $N$ and $K$.
Cnimp(N, K)
IntegerSequences.CoeffAltSum
— FunctionReturn 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)
IntegerSequences.CoeffConst
— FunctionReturn 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)
IntegerSequences.CoeffLeading
— FunctionReturn the leading coefficient of the polynomial $p$.
CoeffLeading(p)
IntegerSequences.CoeffSum
— FunctionReturn 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)
IntegerSequences.Coefficients
— FunctionReturn the list of coefficients of the power series s.
Coefficients(s, len)
IntegerSequences.Coeffs
— FunctionReturn 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)
IntegerSequences.Combinations
— FunctionGenerate 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)
IntegerSequences.Count
— FunctionReturn 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)
IntegerSequences.DedekindEtaPowers
— FunctionCompute 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)
IntegerSequences.DeléhamΔ
— FunctionReturn the product of two integer sequences introduced by Philippe Deléham in A084938.
DeléhamΔ(n, S, T)
IntegerSequences.Diagonal
— FunctionReturn the sequence of the leading coefficient of the sequence of polynomials $P$.
Diagonal(P, len)
IntegerSequences.Dif
— FunctionReturn the bitwise difference of $N$ and $K$.
Dif(N, K)
IntegerSequences.Divides
— FunctionReturn true
if b is divisible by a, otherwise return false
.
Divides(a, b)
IntegerSequences.Divisors
— FunctionReturn the positive integers dividing $n$.
Divisors(m)
Divisors(m, dosort)
IntegerSequences.EgfCoeffs
— FunctionReturn the coefficients of the polynomial $p$ divided by $k!$. Note that integer division is used.
EgfCoeffs(p)
IntegerSequences.EgfExpansion
— FunctionReturn the coefficient triangle of the bivariate generating function gf.
EgfExpansion(gf, prec)
IntegerSequences.EgfPoly
— FunctionReturn 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)
IntegerSequences.Eqv
— FunctionReturn the bitwise equivalence of $N$ and $K$.
Eqv(N, K)
IntegerSequences.EuclidTree
— Functionjulia> 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)
IntegerSequences.EulerTransform
— FunctionReturn the Euler transform of f.
EulerTransform(f)
IntegerSequences.EvenPart
— FunctionReturn the even part of $n$.
EvenPart(n)
IntegerSequences.F!
— FunctionReturn the number of permutations of n letters, $n! = ∏(1, n)$, the factorial of $n$. (The notation is a shortcut breaking Julia conventions.)
F!(n)
IntegerSequences.Factors
— FunctionReturn factors of $n$.
Factors(n)
IntegerSequences.FallingFactorial
— FunctionReturn the falling factorial which is the product of $i$ ∈ $(n - k + 1):n$.
FallingFactorial(n, k)
IntegerSequences.GammaHyp
— FunctionReturn $Γ(a)$ Hypergeometric$1F1(b, c, d).$
GammaHyp(a, b, c, d)
IntegerSequences.GaussFactorial
— FunctionReturn $∏_{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)
IntegerSequences.GenerateAllTest
— FunctionTest to generate sequences from a given list of sequences.
GenerateAllTest(A)
IntegerSequences.HilbertHotel
— FunctionTrick described by David Hilbert in a 1924 lecture "Über das Unendliche".
HilbertHotel(guest, hotel)
IntegerSequences.Imp
— FunctionReturn the bitwise implication of $N$ and $K$.
Imp(N, K)
IntegerSequences.IntegerPartitions
— FunctionReturn 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)
IntegerSequences.InvOrthoPoly
— FunctionReturn 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)
IntegerSequences.JacobiTheta3Powers
— FunctionThe $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)
IntegerSequences.JacobiTheta4Powers
— FunctionReturn 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)
IntegerSequences.KolakoskiList
— FunctionReturn the list of the first $n$ terms of the Kolakoski sequence.
KolakoskiList(len)
IntegerSequences.Lah
— FunctionReturn 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)
IntegerSequences.LahTriangle
— FunctionReturn the unsigned Lah number triangle. (A271703)
LahTriangle(size)
IntegerSequences.List
— FunctionReturn a list of length len of integers $≥ 0$ which are isA.
List(len, isA)
IntegerSequences.ModuleAbundant
— Constant$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.
IntegerSequences.ModuleAndreNumbers
— ConstantGeneralized 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.
IntegerSequences.ModuleBellNumbers
— ConstantThe 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
IntegerSequences.ModuleBernoulliNumbers
— ConstantWe 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
IntegerSequences.ModuleBinaryInteger
— ConstantFor positive n, BinaryIntegerLength is $⌊ \log_{2}(n) ⌋ + 1$, BinaryIntegerLength(0) = 0.
- BinaryIntegerLength, Bil, V001855, V003314, V033156, V054248, V061168, V083652, V097383, V123753, V295513
IntegerSequences.ModuleBinaryQF
— ConstantA 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
IntegerSequences.ModuleCantorMachines
— ConstantCantor'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
IntegerSequences.ModuleCarmichaelNumbers
— Constant- isCarmichael, I002997, F002997, L002997
- isweakCarmichael, I225498, F225498, L225498
IntegerSequences.ModuleClausenNumbers
— Constant- ClausenNumber, ClausenNumberList, V002445, L002445, V027642
IntegerSequences.ModuleCombinationsIterator
— Constant- Combinations
IntegerSequences.ModuleCompositions
— Constant- T097805, L097805, V097805, M097805
IntegerSequences.ModuleCounts
— Constant- PreviousPrime, NextPrime, PrimePiList, takeFirst, Nth, Count, List, HilbertHotel
- L000961, L002808, L005117, L013928, L025528, L065515, L065855, L069637, L246547, L246655, L000720, V007917, V151800, V257993
IntegerSequences.ModuleCyclotomicBinaryForms
— ConstantE. 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
IntegerSequences.ModuleDedekindEta
— Constant- DedekindEtaPowers, RamanujanTau, RamanujanTauList, PartitionNumberList
IntegerSequences.ModuleDelehamDelta
— ConstantPhilippe 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
IntegerSequences.ModuleEulerTransforms
— Constant- V006171, L006171, V107895, L107895, V061256, L061256, V190905, L190905, V275585, L275585, V290351, L290351
IntegerSequences.ModuleFibonacci
— Constant- I000045, F000045, L000045, V000045, R000045, is000045
IntegerSequences.ModuleFigurativeNumbers
— Constant- 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
IntegerSequences.ModuleGaussFactorials
— ConstantThe 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
IntegerSequences.ModuleGeneralizedBinomial
— ConstantP. Luschny, Generalized Binomial, OEIS Wiki.
- Binomial, Pascal, T007318
IntegerSequences.ModuleGeneralizedFibonacci
— ConstantThe 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
IntegerSequences.ModuleHighlyAbundant
— Constant- I002093, F002093, L002093, V002093, I034885, F034885, L034885, V034885
IntegerSequences.ModuleHyper1F1
— ConstantGammaHyp: $(a, b, c, d)$ ↦ $Γ(a)$ Hypergeometric$1F1(b, c, d).$
- GammaHyp, V000255, V000262, V001339, V007060, V033815, V099022, V251568
IntegerSequences.ModuleIntPartitions
— ConstantAll 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
IntegerSequences.ModuleJacobiTheta
— ConstantThe $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
IntegerSequences.ModuleKolakoski
— Constant- KolakoskiList, C000002, I000002, L000002
IntegerSequences.ModuleNarayanaCows
— Constant- 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.
IntegerSequences.ModuleNumberTheory
— Constant- τ, σ, σ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
IntegerSequences.ModuleOEISUtils
— ConstantA collection of utilities for handling OEIS related tasks.
IntegerSequences.ModuleOrthoPolynomials
— Constant- 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
IntegerSequences.ModulePolynomials
— ConstantMostly 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.
IntegerSequences.ModulePrimeSwingFactorial
— ConstantCf. P. Luschny, Swing, divide and conquer the factorial, excerpt.
- PSfactorial, Swing
IntegerSequences.ModulePrimesIterator
— Constant- Primes, PrimePi, PrimeSieve
IntegerSequences.ModuleProducts
— Constant- ∏, Product, F!, RisingFactorial, ↑, FallingFactorial, ↓, MultiFactorial
- V000407, V124320, V265609, V000142, V081125, V001147, V000165, V032031, V007559, V008544, V007696, V001813, V008545, V047053
IntegerSequences.ModuleQueensProblems
— ConstantFor some background see: Backtracking with profiles.
- Queens, L319284
IntegerSequences.ModuleRationalTrees
— ConstantRational 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
IntegerSequences.ModuleRecordSearch
— ConstantThe type object to construct an iterated search for records in sequences.
- Records
IntegerSequences.ModuleRiordanSquares
— ConstantThe 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
IntegerSequences.ModuleSelfConvolutive
— ConstantSome 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
IntegerSequences.ModuleSeqUtils
— ConstantNemo is a library designed, developed and maintained by William Hart with the help of others. Many functions in our project are based on Nemo.
IntegerSequences.ModuleSeriesExpansion
— ConstantThe 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
IntegerSequences.ModuleSetPartitions
— Constant- 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.
IntegerSequences.ModuleStirlingNumbers
— Constant- T132393, L132393, V132393, M132393, T048993, L048993, V048993, M048993, T271703, L271703, V271703, M271703, T094587, L094587, V094587, M094587, T008279, L008279, V008279, M008279
IntegerSequences.ModuleSwingFactorial
— ConstantBasic 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
IntegerSequences.ModuleTriangles
— Constant- Triangle, ZTriangle, QTriangle, RecTriangle, TriangularNumber, isTriangular, assertTriangular, ShowAsΔ, ShowAsMatrix, Row, RowSums, fromΔ, toΔ, TriangleToList
IntegerSequences.ModuleUlamNumbers
— ConstantAn 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
IntegerSequences.ModuleVisitPartitions
— ConstantTwo 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
IntegerSequences.ModuleZumkellerNumbers
— ConstantA 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
IntegerSequences.MultiFactorial
— FunctionReturn the multi-factorial which is the function $n → ∏(a + b, a(n-1) + b)$
MultiFactorial(a, b)
IntegerSequences.Multinacci
— FunctionReturn the $n$-th term of the $m$-th Multinacci sequence.
Multinacci(m, n)
IntegerSequences.Multinomial
— FunctionReturn the multinomial coefficient of a list.
Multinomial(lst)
IntegerSequences.Nand
— FunctionReturn the bitwise nonconjunction of $N$ and $K$.
Nand(N, K)
IntegerSequences.NarayanasCows
— TypeThe type object to construct a new instance of the modified Narayanas cows sequence with given length.
IntegerSequences.NextPrime
— FunctionReturn least prime $> n$. The next_prime function of Mathematica, Maple, Magma and SageMath (cf. V151800).
NextPrime(n)
IntegerSequences.Nor
— FunctionReturn the bitwise joint denial of $N$ and $K$.
Nor(N, K)
IntegerSequences.Not
— FunctionReturn the bitwise negation of $N$.
Not(N)
IntegerSequences.Nth
— FunctionReturn the Nth integer which is isA. (For N ≤ 0 return 0.)
julia> Nth(7, isPrime)
17
Nth(N, isA)
IntegerSequences.OddPart
— FunctionReturn the odd part of $n$.
OddPart(n)
IntegerSequences.Or
— FunctionReturn the bitwise disjunction of $N$ and $K$.
Or(N, K)
IntegerSequences.OrthoPoly
— FunctionBy 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)
IntegerSequences.PSfactorial
— FunctionReturn 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)
IntegerSequences.PartOrder
— TypeConventional 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.
IntegerSequences.PartitionCoefficientsByBiggestPart
— FunctionReturn the partition coefficients of $n$, first ordered by biggest part.
PartitionCoefficientsByBiggestPart(n)
IntegerSequences.PartitionCoefficientsByLength
— FunctionReturn the partition coefficients of $n$, first ordered by length.
PartitionCoefficientsByLength(n)
IntegerSequences.PartitionNumber
— FunctionReturn 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)
IntegerSequences.PartitionNumberList
— FunctionReturn the first n numbers of integer partitions.
PartitionNumberList(len)
IntegerSequences.Pascal
— FunctionThe classical binomial coefficients defined for $n≥0$ and $0≤k≤n$ (a.k.a. Pascal's triangle).
Pascal(n, k)
IntegerSequences.Pi
— FunctionReturn 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)
IntegerSequences.Poly
— FunctionReturn the polynomial $p$ with the coefficients C.
Poly(C)
IntegerSequences.PolygonalNumber
— FunctionReturn the polygonal number with shape k.
PolygonalNumber(n, k)
IntegerSequences.PreviousPrime
— FunctionReturn the largest prime in $Z$ (the ring of all integers) less than $n$ for $n ≥ 0$ (cf. V007917).
PreviousPrime(n)
IntegerSequences.PrimeDivisors
— FunctionReturn the prime numbers dividing $n$.
PrimeDivisors(n)
IntegerSequences.PrimePi
— FunctionReturn the number of primes $≤ n$.
PrimePi(n)
IntegerSequences.PrimePiList
— FunctionReturn the list of number of primes $≤ n$ for $n ≥ 0$.
julia> PrimePiList(8)
[0, 0, 1, 2, 2, 3, 3, 4]
PrimePiList(len)
IntegerSequences.PrimeSieve
— FunctionReturn 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)
IntegerSequences.Primes
— FunctionReturn the collection of the prime numbers (from lo
, if specified) up to hi
.
Primes(lo, hi)
IntegerSequences.Println
— FunctionPrint the array without typeinfo.
Println(v)
Print the array without typeinfo.
Println(V)
IntegerSequences.Product
— FunctionIf $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)
IntegerSequences.PyramidalNumber
— FunctionReturn the pyramidal number with shape k.
PyramidalNumber(n, k)
IntegerSequences.QTriangle
— FunctionReturn a trianguler array with $n$ rows set to $0$ (type QQ).
QTriangle(dim)
IntegerSequences.Queens
— FunctionReturns the profile of the backtrack tree for the n queens problem (see A319284
).
Queens(n)
IntegerSequences.Radical
— FunctionReturn the radical of $n$ which is the product of the prime numbers dividing $n$ (also called the squarefree kernel of $n$).
Radical(n)
IntegerSequences.RamanujanTau
— FunctionReturn Ramanujan's tau(n).
RamanujanTau(n)
IntegerSequences.RamanujanTauList
— FunctionList of the first values of the Ramanujan tau function, the Fourier coefficients of the Weierstrass Delta-function.
RamanujanTauList(len)
IntegerSequences.RecTriangle
— TypeA 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.
IntegerSequences.Records
— TypeThe type object to construct an iterated search for records in sequences.
IntegerSequences.ReflectPoly
— FunctionReturn the reflected polynomial of $p$.
ReflectPoly(p)
IntegerSequences.RiordanProduct
— FunctionReturn the Riordan array associated with the generating functions a and b.
RiordanProduct(a, b, dim)
RiordanProduct(a, b, dim, expo)
IntegerSequences.RiordanSquare
— FunctionReturn the Riordan array (Riordan product) $a \times a$.
RiordanSquare(a, n)
RiordanSquare(a, n, expo)
IntegerSequences.RisingFactorial
— FunctionReturn the rising factorial which is the product of $i$ ∈ $n:(n + k - 1)$.
RisingFactorial(n, k)
IntegerSequences.RosenbergStrongBoustrophedonicEnumeration
— FunctionThe 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)
IntegerSequences.RosenbergStrongBoustrophedonicMachine
— FunctionThe 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)
IntegerSequences.RosenbergStrongBoustrophedonicPairing
— FunctionThe inverse function of the boustrophedonic Rosenberg-Strong enumeration (the pairing function), computes $n$ for given $(x, y)$.
RosenbergStrongBoustrophedonicPairing(x, y)
IntegerSequences.Row
— FunctionReturn 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)
IntegerSequences.RowSums
— FunctionReturn the row sums of a triangle, if alternate=true
then the alternating row sums.
RowSums(T)
RowSums(T, alternate)
IntegerSequences.SchinzelSierpinskiEncoding
— FunctionReturn 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)
IntegerSequences.SelfConvRec
— FunctionAn exactly solvable self-convolutive recurrence studied by R. J. Martin and M. J. Kearney.
SelfConvRec(len, a, b, c)
IntegerSequences.SeqName
— FunctionReturn the name of a OEIS sequence given a similar named function as a string.
SeqName(fun)
IntegerSequences.SeqNum
— FunctionReturn the A-number of a OEIS sequence given a similar named function as an integer.
SeqNum(seq)
IntegerSequences.SeqPrint
— FunctionPrint the array with or without typeinfo.
SeqPrint(v)
SeqPrint(v, typeinfo)
IntegerSequences.SeqShow
— FunctionPrint 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)
IntegerSequences.SeqTest
— FunctionPerform tests for an array of sequences of given type assuming the given offset.
SeqTest(seqarray, kind)
SeqTest(seqarray, kind, offset)
IntegerSequences.SetNumber
— FunctionReturn 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)
IntegerSequences.SetPartitions
— FunctionReturn 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)
IntegerSequences.Sfactorial
— FunctionReturn 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)
IntegerSequences.ShowAsMatrix
— FunctionPrint the triangle in matrix form.
ShowAsMatrix(T)
IntegerSequences.ShowAsΔ
— FunctionDisplay a lower triangular matrix.
ShowAsΔ(T)
ShowAsΔ(T, separator)
Display an array as a lower triangular matrix.
ShowAsΔ(T)
ShowAsΔ(T, separator)
IntegerSequences.Swing
— FunctionComputes the swinging factorial (a.k.a. Swing numbers n≀) (cf. A056040).
Swing(n)
IntegerSequences.Triangle
— TypeA 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.
IntegerSequences.TriangleToList
— FunctionReturn the triangle as a list of integers.
TriangleToList(T)
IntegerSequences.TriangularNumber
— FunctionReturn the$n$-th triangular number.
TriangularNumber(n)
IntegerSequences.UlamList
— FunctionReturn 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)
IntegerSequences.VisitPartition
— FunctionReturn the integer partitions of $n$ in graded reverse lexicographic order, the canonical ordering of partitions.
VisitPartition(n, fun)
IntegerSequences.Xor
— FunctionReturn the bitwise exclusive disjunction of $N$ and $K$.
Xor(N, K)
IntegerSequences.ZArray
— FunctionReturn 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)
IntegerSequences.ZTriangle
— FunctionReturn a trianguler array with $n$ rows set to $0$ (type ZZ).
ZTriangle(dim)
IntegerSequences.assertTriangular
— FunctionReturn the square root of $2n$ or throw an ArgumentError if $n$ is not a triangular number.
assertTriangular(n)
IntegerSequences.byMaxPart
— ConstantOrder the partitions by greatest part.
IntegerSequences.byNumPart
— ConstantOrder the partitions by number of parts.
IntegerSequences.data_installed
— FunctionAlias for isoeisinstalled.
data_installed()
IntegerSequences.divisors
— FunctionReturn the positive integers dividing $n$.
divisors(m)
IntegerSequences.fromΔ
— FunctionConvert a lower triangular array to a square matrix.
fromΔ(T)
IntegerSequences.isAbundant
— FunctionIs $n$ an abundant number, i.e. is $σ(n) > 2n$ ?
isAbundant(n)
IntegerSequences.isCarmichael
— FunctionIs $n$ a Carmichael (or Šimerka) number?
isCarmichael(n)
IntegerSequences.isComposite
— FunctionIs the integer $n$ a composite number?
isComposite(n)
IntegerSequences.isCyclic
— FunctionIs $n$ a cyclic number? $n$ such that there is just one group of order $n$.
isCyclic(n)
IntegerSequences.isEven
— FunctionIs $n$ divisble by 2?
isEven(n)
IntegerSequences.isNonnegative
— FunctionIs the integer $n$ nonnegative?
isNonnegative(n)
IntegerSequences.isOdd
— FunctionIs $n$ indivisble by 2?
isOdd(n)
IntegerSequences.isPerfectPower
— FunctionIs the integer $n$ a perfect powers?
isPerfectPower(n)
IntegerSequences.isPositive
— FunctionIs the integer $n$ positive?
isPositive(n)
IntegerSequences.isPowerOfPrimes
— FunctionIs the integer $n$ a power of primes?
isPowerOfPrimes(n)
IntegerSequences.isPrime
— FunctionReturn true if n is prime false otherwise.
isPrime(n)
IntegerSequences.isPrimePower
— FunctionIs the integer $n$ a prime power?
isPrimePower(n)
IntegerSequences.isPrimeTo
— FunctionQuery if $m$ is prime to $n$.
isPrimeTo(m, n)
IntegerSequences.isSquare
— FunctionIs the integer $n$ a square number?
isSquare(n)
IntegerSequences.isSquareFree
— FunctionIs the integer $n$ a squarefree number?
isSquareFree(n)
IntegerSequences.isStrongCyclic
— FunctionIs $n$ a strong cyclic number?
isStrongCyclic(n)
IntegerSequences.isStrongPrimeTo
— FunctionQuery 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)
IntegerSequences.isTriangular
— FunctionIs $n$ a triangular number?
isTriangular(n)
IntegerSequences.isUlam
— FunctionIs $n$ an Ulam number?
isUlam(u, n, h, i, r)
IntegerSequences.isZumkeller
— FunctionIs $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)
IntegerSequences.is_oeis_installed
— FunctionIndicates if the local copy of the OEIS data (the so-called 'stripped' file) is installed (in ../data).
is_oeis_installed()
IntegerSequences.isweakCarmichael
— FunctionIs $n$ a weak Carmichael number?
isweakCarmichael(n)
IntegerSequences.mods
— FunctionReturn 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)
IntegerSequences.oeis_local
— FunctionGet 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)
IntegerSequences.oeis_notinstalled
— FunctionIndicates if the local copy of the OEIS data (the so-called 'stripped' file) is not installed and warns.
oeis_notinstalled()
IntegerSequences.oeis_path
— FunctionReturns the path where the oeis data is expected.
oeis_path()
IntegerSequences.oeis_readbfile
— FunctionRead a file in the so-called b-file format of the OEIS.
oeis_readbfile(filename)
IntegerSequences.oeis_remote
— FunctionDownload 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)
IntegerSequences.oeis_search
— FunctionSearch 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)
IntegerSequences.oeis_trimdata
— FunctionMake sure that the length of the data section of an OEIS entry does not exceed 260 characters.
oeis_trimdata(fun, offset)
IntegerSequences.oeis_writebfile
— FunctionWrite a so-called b-file for submission to the OEIS. The file is saved in the 'data' directory.
oeis_writebfile(anum, fun, range)
IntegerSequences.takeFirst
— FunctionReturn the first $n$ numbers satisfying the predicate isA.
takeFirst(isA, n)
IntegerSequences.toΔ
— FunctionConvert a square matrix to a list using only the $T(n,k)$ with $0 ≤ k ≤ n$. Returns a ZArray.
toΔ(M)
IntegerSequences.Ω
— FunctionReturn $Ω(n)$, the number of prime divisors of $n$ counted with multiplicity (cf. A001222).
Ω(n)
IntegerSequences.σ
— FunctionReturn $σ(n)$ (a.k.a. $σ_1(n)$), the sum of the divisors of $n$ (cf. A000203).
σ(n)
IntegerSequences.σ2
— FunctionReturn $σ2(n)$ (a.k.a. $σ_2(n)$), the sum of squares of the divisors of $n$ (cf. A001157).
σ2(n)
IntegerSequences.τ
— FunctionReturn $τ(n)$ (a.k.a. $σ_0(n)$), the number of divisors of $n$ (cf A000005).
τ(n)
IntegerSequences.ω
— FunctionReturn $ω(n)$, the number of distinct prime divisors of $n$ (cf. A001221).
ω(n)
IntegerSequences.ϕ
— FunctionReturn the Euler totient $ϕ(n)$, numbers which are $≤ n$ and prime to $n$.
ϕ(n)
IntegerSequences.:↑
— FunctionReturn 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)
IntegerSequences.:↓
— FunctionReturn 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)
IntegerSequences.∏
— FunctionIf $a ≤ b$ then return the product of $i$ ∈ $a:b$ else return $1$.
∏(a, b)
Return the accumulated product of an array.
∏(A)
IntegerSequences.⊥
— FunctionQuery 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)
IntegerSequences.⍊
— FunctionQuery 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)
IntegerSequences.C000002
— FunctionGenerate 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()
IntegerSequences.I000002
— FunctionIterate over the first $n$ Kolakoski numbers.
I000002(n)
IntegerSequences.L000002
— FunctionReturn the list of the first $n$ terms of the Kolakoski sequence.
L000002(n)
IntegerSequences.V000005
— FunctionReturn the number of divisors of $n$.
V000005(n)
IntegerSequences.V000010
— FunctionReturn the number of integers $≤ n$ and prime to $n$.
V000010(n)
IntegerSequences.G000032
— FunctionThe generating function of the Lucas numbers.
G000032(x)
IntegerSequences.L000032
— FunctionReturn a list of Lucas numbers.
L000032(n)
IntegerSequences.L000041
— FunctionReturn the first n numbers of integer partitions.
L000041(len)
IntegerSequences.V000041
— FunctionReturn the number of partitions of $n$.
V000041(n)
IntegerSequences.F000045
— FunctionIterate over the Fibonacci numbers which do not exceed $n$.
F000045(n)
IntegerSequences.G000045
— FunctionThe generating function of the Fibonacci numbers.
G000045(x)
IntegerSequences.I000045
— FunctionIterate over the first $n$ Fibonacci numbers.
I000045(n)
IntegerSequences.L000045
— FunctionReturn the first $n$ Fibonacci numbers in an array.
L000045(n)
IntegerSequences.R000045
— FunctionFibonacci function for real values, returns a Float64.
R000045(x)
IntegerSequences.V000045
— FunctionReturn the $n$-th Fibonacci number.
V000045(n)
IntegerSequences.is000045
— FunctionQuery if $n$ is a Fibonacci number, returns a Bool.
is000045(n)
IntegerSequences.V000055
— FunctionReturn the number of trees with $n$ unlabeled nodes.
V000055(n)
IntegerSequences.G000073
— FunctionThe generating function of the Tribonacci numbers.
G000073(x)
IntegerSequences.L000073
— FunctionReturn a list of Tribonacci numbers.
L000073(n)
IntegerSequences.V000081
— FunctionReturn the number of unlabeled rooted trees with $n$ nodes.
V000081(n)
IntegerSequences.L000085
— FunctionReturn the number of involutions.
L000085(len)
IntegerSequences.V000088
— FunctionReturn the number of graphs on $n$ unlabeled nodes.
V000088(n)
IntegerSequences.V000106
— FunctionReturn the number of linear forests of 2-rooted trees.
V000106(n)
IntegerSequences.G000108
— FunctionThe generating function of the Catalan numbers.
G000108(x)
IntegerSequences.L000108
— FunctionReturn a list of Catalan numbers.
L000108(n)
IntegerSequences.L000110
— FunctionReturn a list of Bell numbers of length len.
julia> L000110(10)
[1, 1, 2, 5, 15, 52, 203, 877, 4140, 21147]
L000110(len)
IntegerSequences.V000110
— FunctionReturn the n-th Bell number $B_n$.
julia> V000110(11)
678570
V000110(n)
IntegerSequences.C000111
— FunctionGenerate the André numbers (a.k.a. Euler-up-down numbers A000111). Don't confuse with the Euler numbers A122045.
C000111()
IntegerSequences.V000111
— FunctionReturn the up-down numbers (2-alternating permutations).
V000111(n)
IntegerSequences.L000118
— FunctionNumber of ways of writing a nonnegative integer n as a sum of 4 squares.
L000118(len)
IntegerSequences.V000120
— FunctionReturn the number of $1$'s in binary expansion of $n$.
V000120(n)
IntegerSequences.L000122
— FunctionReturn the number of ways of writing a nonnegative integer n as a square.
L000122(len)
IntegerSequences.L000132
— FunctionReturn the number of ways of writing a nonnegative integer n as a sum of 5 squares.
L000132(len)
IntegerSequences.L000141
— FunctionReturn the number of ways of writing a nonnegative integer n as a sum of 6 squares.
L000141(len)
IntegerSequences.V000142
— FunctionReturn the factorial numbers.
V000142(n)
IntegerSequences.L000143
— FunctionReturn the number of ways of writing a nonnegative integer n as a sum of 8 squares.
L000143(len)
IntegerSequences.L000144
— FunctionReturn the number of ways of writing a nonnegative integer n as a sum of 10 squares.
L000144(len)
IntegerSequences.L000145
— FunctionReturn the number of ways of writing a nonnegative integer n as a sum of 12 squares.
L000145(len)
IntegerSequences.V000165
— FunctionReturn the double factorial of even numbers: $2^n n! = (2n)!!$.
V000165(n)
IntegerSequences.V000203
— FunctionReturn the sum of the divisors of $n$.
V000203(n)
IntegerSequences.V000217
— FunctionReturn the polygonal numbers of shape 3 (the triangular numbers).
V000217(n)
IntegerSequences.V000255
— FunctionReturn $(n+1)!$ Hypergeometric1F1$[-n, -n-1, -1]$. Number of fixedpoint-free permutations beginning with 2. (L. Euler).
V000255(n)
IntegerSequences.G000257
— FunctionThe generating function of the number of rooted bicubic maps.
G000257(x)
IntegerSequences.L000257
— FunctionReturn a list of the number of rooted bicubic maps.
L000257(n)
IntegerSequences.V000262
— FunctionReturn $n!$ Hypergeometric1F1$[1-n, 2, -1]$. Number of partitions of ${1,...,n}$ into any number of ordered subsets.
V000262(n)
IntegerSequences.V000265
— FunctionReturn the odd part of $n$.
V000265(n)
IntegerSequences.V000290
— FunctionReturn the polygonal numbers of shape 4 (the squares).
V000290(n)
IntegerSequences.V000292
— FunctionReturn the pyramidal numbers of shape 3 (tetrahedral numbers).
V000292(n)
IntegerSequences.V000326
— FunctionReturn the polygonal numbers of shape 5 (the pentagonal numbers).
V000326(n)
IntegerSequences.V000330
— FunctionReturn the pyramidal numbers of shape 4 (square pyramidal numbers).
V000330(n)
IntegerSequences.T000369
— FunctionReturn 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)
IntegerSequences.V000384
— FunctionReturn the polygonal numbers of shape 6 (the hexagonal numbers).
V000384(n)
IntegerSequences.V000407
— FunctionReturn the central rising factorial $(n+1) ↑ (n+1) = (2n+1)! / n!$.
V000407(n)
IntegerSequences.V000566
— FunctionReturn the polygonal numbers of shape 7 (the heptagonal numbers).
V000566(n)
IntegerSequences.V000567
— FunctionReturn the polygonal numbers of shape 8 (the octagonal numbers).
V000567(n)
IntegerSequences.L000594
— FunctionCompute the expansion of $∏_{m≥1} (1 - q^m)^{24}$.
L000594(len)
IntegerSequences.L000698
— FunctionReturn the number of indecomposable perfect matchings on $[2n]$.
L000698(len)
IntegerSequences.L000712
— FunctionReturn the number of partitions of n into parts of 2 kinds.
L000712(len)
IntegerSequences.L000716
— FunctionReturn the number of partitions of n into parts of 3 kinds.
L000716(len)
IntegerSequences.L000720
— FunctionReturn the list of number of primes $≤ n$ for $n ≥ 0$.
julia> L000720(8)
[0, 0, 1, 2, 2, 3, 3, 4]
L000720(len)
IntegerSequences.L000727
— FunctionCompute the expansion of $∏ _{m≥1} (1 - q^m)^4$.
L000727(len)
IntegerSequences.L000728
— FunctionCompute the expansion of $∏ _{m≥1} (1 - q^m)^5$.
L000728(len)
IntegerSequences.L000729
— FunctionCompute the expansion of $∏ _{m≥1} (1 - q^m)^6$.
L000729(len)
IntegerSequences.L000730
— FunctionCompute the expansion of $∏ _{m≥1} (1 - q^m)^7$.
L000730(len)
IntegerSequences.L000731
— FunctionCompute the expansion of $∏ _{m≥1} (1 - q^m)^8$.
L000731(len)
IntegerSequences.L000735
— FunctionCompute the expansion of $∏_{m≥1} (1 - q^m)^{12}$.
L000735(len)
IntegerSequences.L000739
— FunctionCompute the expansion of $∏_{m≥1} (1 - q^m)^{16}$.
L000739(len)
IntegerSequences.V000796
— FunctionReturn 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)
IntegerSequences.G000957
— FunctionThe generating function of the Fine numbers (with a(0) = 1).
G000957(x)
IntegerSequences.L000957
— FunctionReturn a list of Fine numbers.
L000957(n)
IntegerSequences.L000961
— FunctionReturn 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)
IntegerSequences.G001003
— FunctionThe generating function of the little Schröder numbers.
G001003(x)
IntegerSequences.L001003
— FunctionReturn a list of little Schröder numbers.
L001003(n)
IntegerSequences.G001006
— FunctionThe generating function of the Motzkin numbers.
G001006(x)
IntegerSequences.L001006
— FunctionReturn a list of Motzkin numbers.
L001006(n)
IntegerSequences.G001045
— FunctionThe generating function of the Jacobsthal numbers (with a(0) = 1).
G001045(x)
IntegerSequences.L001045
— FunctionReturn a list of Jacobsthal numbers.
L001045(n)
IntegerSequences.V001106
— FunctionReturn the polygonal numbers of shape 9 (the nonagonal numbers).
V001106(n)
IntegerSequences.V001107
— FunctionReturn the polygonal numbers of shape 10 (decagonal numbers).
V001107(n)
IntegerSequences.V001147
— FunctionReturn the double factorial of odd numbers, $1×3×5×...×(2n-1) = (2n-1)!!$.
V001147(n)
IntegerSequences.V001157
— FunctionReturn $σ2(n)$ (a.k.a. $σ_2(n)$), the sum of squares of the divisors of $n$.
V001157(n)
IntegerSequences.V001221
— FunctionReturn the number of distinct prime divisors of $n$.
V001221(n)
IntegerSequences.V001222
— FunctionReturn the number of prime divisors of $n$ counted with multiplicity.
V001222(n)
IntegerSequences.V001316
— FunctionReturn 2^BitCount(n). Should be called Glaisher's sequence since James Glaisher showed that odd binomial coefficients are counted by this sequence.
V001316(n)
IntegerSequences.V001339
— FunctionReturn $(n+1)!$ Hypergeometric1F1$[-n, -n-1, 1]$. Number of arrangements of ${1, 2, ..., n+1}$ containing the element 1.
V001339(n)
IntegerSequences.L001464
— FunctionReturn the sequence defined by $a(n) = n! [x^n] \exp(-x-(x^2)/2)$.
L001464(len)
IntegerSequences.V001477
— FunctionReturn the polygonal numbers of shape 2 (these are the natural numbers).
V001477(n)
IntegerSequences.T001497
— FunctionReturn a triangle of coefficients of Bessel polynomials (better use A132062).
T001497(n)
IntegerSequences.V001511
— FunctionReturn the 2-adic valuation of $2n$.
V001511(n)
IntegerSequences.L001710
— FunctionReturn the order of alternating group $A_n$, or number of even permutations of $n$ letters.
L001710(len)
IntegerSequences.V001783
— FunctionReturn $∏_{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)
IntegerSequences.V001790
— FunctionReturn the odd part of the swinging factorial of $2n$.
V001790(n)
IntegerSequences.V001803
— FunctionReturn the odd part of the swinging factorial of $2n+1$.
V001803(n)
IntegerSequences.V001813
— FunctionReturn the quadruple factorial numbers with shift 2, $(2n)!/n!$.
V001813(n)
IntegerSequences.V001855
— FunctionMaximal number of comparisons for sorting $n$ elements by binary insertion.
V001855(n)
IntegerSequences.L001934
— FunctionReturn the expansion of $1/ϑ_4(q)^2$ in powers of q.
L001934(len)
IntegerSequences.F002093
— FunctionIterate over the highly abundant numbers which do not exceed $n$ ($1 ≤ i ≤ n$).
F002093(n)
IntegerSequences.I002093
— FunctionIterate over the first $n$ highly abundant numbers.
I002093(n)
IntegerSequences.L002093
— FunctionReturn the first $n$ highly abundant numbers as an array.
L002093(n)
IntegerSequences.V002093
— FunctionReturn the $n$-th highly abundant number. Indexing starts with 1.
V002093(n)
IntegerSequences.L002107
— FunctionCompute the expansion of $∏ _{m≥1} (1 - q^m)^2$.
L002107(len)
IntegerSequences.V002110
— FunctionReturn the product of first $n$ primes.
V002110(n)
IntegerSequences.V002411
— FunctionReturn the pyramidal numbers of shape 5 (pentagonal pyramidal numbers).
V002411(n)
IntegerSequences.V002412
— FunctionReturn the pyramidal numbers of shape 6 (hexagonal pyramidal numbers).
V002412(n)
IntegerSequences.V002413
— FunctionReturn the pyramidal numbers of shape 7 (heptagonal pyramidal numbers).
V002413(n)
IntegerSequences.V002414
— FunctionReturn the pyramidal numbers of shape 8 (octagonal pyramidal numbers).
V002414(n)
IntegerSequences.G002426
— FunctionThe generating function of the central trinomial.
G002426(x)
IntegerSequences.L002426
— FunctionReturn a list of the central trinomials.
L002426(n)
IntegerSequences.L002445
— FunctionReturn the list of length len of Clausen numbers which are the denominators of the Bernoulli numbers $B_{2n}$.
L002445(len)
IntegerSequences.V002445
— FunctionReturn the Clausen number $C(n)$ which is the denominator of the Bernoulli number $B_{2n}$.
V002445(n)
IntegerSequences.L002448
— FunctionReturn the expansion of Jacobi theta function $ϑ(-q)$.
L002448(len)
IntegerSequences.L002476
— FunctionReturn primes of the form $6m + 1$.
L002476(bound)
IntegerSequences.V002494
— FunctionReturn the number of $n$-node graphs without isolated nodes.
V002494(n)
IntegerSequences.L002808
— FunctionReturn 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)
IntegerSequences.L002858
— FunctionReturn a list of Ulam numbers.
L002858(len)
IntegerSequences.F002997
— FunctionIterate over the Carmichael (or Šimerka) numbers which do not exceed $n$.
F002997(n)
IntegerSequences.I002997
— FunctionIterate over the first $n$ Carmichael (or Šimerka) numbers.
I002997(n)
IntegerSequences.L002997
— FunctionReturn the first $n$ Carmichael (or Šimerka) numbers in an array.
L002997(n)
IntegerSequences.V003188
— FunctionReturn $n$ XOR $n>>1$, using max length.
V003188(n)
IntegerSequences.I003277
— FunctionIterate over the first $n$ cyclic numbers.
I003277(n)
IntegerSequences.L003277
— FunctionReturn the first $n$ cyclic numbers in an array.
L003277(n)
IntegerSequences.V003314
— FunctionBinary entropy function: $a(n) = n +$ min $( a(k) + a(n-k) : 1 ≤ k ≤ n-1 )$ for $n > 1,$ and $a(1) = 0$.
V003314(n)
IntegerSequences.L003319
— FunctionReturn the number of connected permutations of $[1..n]$. Also called indecomposable permutations.
L003319(len)
IntegerSequences.L003723
— FunctionReturn the sequence defined by $A(n) = n! [x^n] \exp \tan(x)$ as an array of length len
.
L003723(len)
IntegerSequences.V003817
— FunctionReturn $n$ EQV $n$.
V003817(n)
IntegerSequences.L004018
— FunctionReturn the number of ways of writing a nonnegative integer n as a sum of 2 squares.
L004018(len)
IntegerSequences.L004402
— FunctionReturn the expansion of $1/ϑ_3(q)$ in powers of q.
L004402(len)
IntegerSequences.L004403
— FunctionReturn the expansion of $1/ϑ_3(q)^2$ in powers of q.
L004403(len)
IntegerSequences.L004404
— FunctionReturn the expansion of $1/ϑ_3(q)^3$ in powers of q.
L004404(len)
IntegerSequences.L004405
— FunctionReturn the expansion of $1/ϑ_3(q)^4$ in powers of q.
L004405(len)
IntegerSequences.L004406
— FunctionReturn the expansion of $1/ϑ_3(q)^5$ in powers of q.
L004406(len)
IntegerSequences.L004407
— FunctionReturn the expansion of $1/ϑ_3(q)^6$ in powers of q.
L004407(len)
IntegerSequences.L004408
— FunctionReturn the expansion of $1/ϑ_3(q)^7$ in powers of q.
L004408(len)
IntegerSequences.L004409
— FunctionReturn the expansion of $1/ϑ_3(q)^8$ in powers of q.
L004409(len)
IntegerSequences.L004410
— FunctionReturn the expansion of $1/ϑ_3(q)^9$ in powers of q.
L004410(len)
IntegerSequences.L004411
— FunctionReturn the expansion of $1/ϑ_3(q)^{10}$ in powers of q.
L004411(len)
IntegerSequences.L004412
— FunctionReturn the expansion of $1/ϑ_3(q)^{11}$ in powers of q.
L004412(len)
IntegerSequences.L004413
— FunctionReturn the expansion of $1/ϑ_3(q)^{12}$ in powers of q.
L004413(len)
IntegerSequences.L004414
— FunctionReturn the expansion of $1/ϑ_3(q)^{13}$ in powers of q.
L004414(len)
IntegerSequences.L004415
— FunctionReturn the expansion of $1/ϑ_3(q)^{14}$ in powers of q.
L004415(len)
IntegerSequences.L004416
— FunctionReturn the expansion of $1/ϑ_3(q)^{15}$ in powers of q.
L004416(len)
IntegerSequences.L004417
— FunctionReturn the expansion of $1/ϑ_3(q)^{16}$ in powers of q.
L004417(len)
IntegerSequences.L004418
— FunctionReturn the expansion of $1/ϑ_3(q)^{17}$ in powers of q.
L004418(len)
IntegerSequences.L004419
— FunctionReturn the expansion of $1/ϑ_3(q)^{18}$ in powers of q.
L004419(len)
IntegerSequences.L004420
— FunctionReturn the expansion of $1/ϑ_3(q)^{19}$ in powers of q.
L004420(len)
IntegerSequences.L004421
— FunctionReturn the expansion of $1/ϑ_3(q)^{20}$ in powers of q.
L004421(len)
IntegerSequences.L004422
— FunctionReturn the expansion of $1/ϑ_3(q)^{21}$ in powers of q.
L004422(len)
IntegerSequences.L004423
— FunctionReturn the expansion of $1/ϑ_3(q)^{22}$ in powers of q.
L004423(len)
IntegerSequences.L004424
— FunctionReturn the expansion of $1/ϑ_3(q)^{23}$ in powers of q.
L004424(len)
IntegerSequences.L004425
— FunctionReturn the expansion of $1/ϑ_3(q)^{24}$ in powers of q.
L004425(len)
IntegerSequences.T004747
— FunctionReturn 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)
IntegerSequences.G005043
— FunctionThe generating function of the Riordan numbers with 1 prepended.
G005043(x)
IntegerSequences.L005043
— FunctionReturn a list of the Riordan numbers (1 prepended).
L005043(n)
IntegerSequences.F005101
— FunctionIterate over the abundant numbers which do not exceed $n (1 ≤ i ≤ n)$.
F005101(n)
IntegerSequences.I005101
— FunctionIterate over the first $n$ abundant numbers.
I005101(n)
IntegerSequences.L005101
— FunctionReturn a list of the first $n$ abundant numbers.
L005101(n)
IntegerSequences.V005101
— FunctionReturn the value of the $n$-th abundant number.
V005101(n)
IntegerSequences.is005101
— FunctionIs $n$ a term of sequence A005101?
is005101(n)
IntegerSequences.L005117
— FunctionReturn 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)
IntegerSequences.V005187
— FunctionReturn $2n$ - BitCount(n).
V005187(n)
IntegerSequences.L005411
— FunctionReturn the number of non-vanishing Feynman diagrams of order $2n$ for the electron or the photon propagators in quantum electrodynamics.
L005411(len)
IntegerSequences.L005412
— FunctionReturn the number of non-vanishing Feynman diagrams of order $2n$ for the vacuum polarization in quantum electrodynamics.
L005412(len)
IntegerSequences.L005425
— FunctionReturn the number of self-inverse partial permutations.
L005425(len)
IntegerSequences.V005564
— FunctionReturn the pyramidal numbers of shape -1.
V005564(n)
IntegerSequences.L005651
— FunctionSum of all partition coefficients of n.
L005651(len)
IntegerSequences.L005758
— FunctionReturn the number of partitions of n into parts of 12 kinds.
L005758(len)
IntegerSequences.L005773
— FunctionReturn the number of directed animals of size n as an array of length len.
L005773(len)
IntegerSequences.L005875
— FunctionReturn the number of ways of writing a nonnegative integer n as a sum of 3 squares.
L005875(len)
IntegerSequences.L006012
— FunctionCounting some sets of permutations.
L006012(len)
IntegerSequences.V006053
— FunctionReturn the $n$-th term of the third Multinacci sequence.
V006053(n)
IntegerSequences.L006171
— FunctionReturn a list of length len of the Euler transform of tau.
L006171(len)
IntegerSequences.V006171
— FunctionReturn the number of factorization patterns of polynomials of degree n over integers.
V006171(n)
IntegerSequences.L006229
— FunctionReturn the expansion of exp(tan(x)).
L006229(len)
IntegerSequences.V006257
— FunctionReturn max$(1, 2n) - (n$ EQV $n)$, using max length.
V006257(n)
IntegerSequences.G006318
— FunctionThe generating function of the large Schröder numbers.
G006318(x)
IntegerSequences.L006318
— FunctionReturn the large Schröder numbers.
L006318(len)
IntegerSequences.V006519
— FunctionReturn the even part of $n$.
V006519(n)
IntegerSequences.is206864
— FunctionIs $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)
IntegerSequences.L006922
— FunctionReturn the number of partitions of n into parts of 24 kinds.
L006922(len)
IntegerSequences.is206942
— FunctionIs $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)
IntegerSequences.V007060
— FunctionReturn $(2n)!$ Hypergeometric1F1$[-n, -2n, -2]$. Number of ways $n$ couples can sit in a row without any spouses next to each other.
V007060(n)
IntegerSequences.T007318
— FunctionPascal's triangle.
T007318(n)
IntegerSequences.L007522
— FunctionReturn primes of the form $8n+7$, that is, primes congruent to -1 mod 8.
L007522(bound)
IntegerSequences.V007559
— FunctionReturn the triple factorial numbers with shift 1, $3^n n! = (3n)!!!$.
V007559(n)
IntegerSequences.V007584
— FunctionReturn the pyramidal numbers of shape 9 (enneagonal pyramidal numbers).
V007584(n)
IntegerSequences.V007585
— FunctionReturn the pyramidal numbers of shape 10 (decagonal pyramidal numbers).
V007585(n)
IntegerSequences.V007696
— FunctionReturn the quadruple factorial numbers with shift 1.
V007696(n)
IntegerSequences.V007814
— FunctionReturn the 2-adic valuation of $n$.
V007814(n)
IntegerSequences.V007917
— FunctionReturn 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)
IntegerSequences.L008279
— FunctionLists the first n rows of A008279
by concatenating.
L008279(n)
IntegerSequences.M008279
— FunctionReturn the triangular array as a square matrix with dim rows.
M008279(dim)
IntegerSequences.T008279
— FunctionIterates over the first n rows of A008279
.
T008279(n)
IntegerSequences.V008279
— FunctionReturn row n of A008279 based on the iteration T008279
(n).
V008279(n)
IntegerSequences.L008451
— FunctionReturn the nnumber of ways of writing a nonnegative integer n as a sum of 7 squares.
L008451(len)
IntegerSequences.L008452
— FunctionReturn the number of ways of writing a nonnegative integer n as a sum of 9 squares.
L008452(len)
IntegerSequences.L008453
— FunctionReturn the number of ways of writing a nonnegative integer n as a sum of 11 squares.
L008453(len)
IntegerSequences.V008544
— FunctionReturn the triple factorial numbers with shift 2.
V008544(n)
IntegerSequences.V008545
— FunctionReturn the quadruple factorial numbers with shift 3.
V008545(n)
IntegerSequences.V008683
— FunctionReturn the value of the Möbius function $μ(n)$ which is the sum of the primitive n-th roots of unity.
V008683(n)
IntegerSequences.L008784
— FunctionReturn numbers $n$ that are primitively represented by $x^2 + y^2$. Also numbers $n$ such that $√(-1)$ mod $n$ exists.
L008784(bound)
IntegerSequences.L010815
— FunctionCompute the expansion of $∏ _{m≥1} (1 - q^m)$.
L010815(len)
IntegerSequences.L010816
— FunctionCompute the expansion of $∏ _{m≥1} (1 - q^m)^3$.
L010816(len)
IntegerSequences.L010817
— FunctionCompute the expansion of $∏ _{m≥1} (1 - q^m)^9$.
L010817(len)
IntegerSequences.L010819
— FunctionCompute the expansion of $∏_{m≥1} (1 - q^m)^{11}$.
L010819(len)
IntegerSequences.L010820
— FunctionCompute the expansion of $∏_{m≥1} (1 - q^m)^{13}$.
L010820(len)
IntegerSequences.L010821
— FunctionCompute the expansion of $∏_{m≥1} (1 - q^m)^{14}$.
L010821(len)
IntegerSequences.L010822
— FunctionCompute the expansion of $∏_{m≥1} (1 - q^m)^{15}$.
L010822(len)
IntegerSequences.L010823
— FunctionCompute the expansion of $∏_{m≥1} (1 - q^m)^{17}$.
L010823(len)
IntegerSequences.L010824
— FunctionCompute the expansion of $∏_{m≥1} (1 - q^m)^{18}$.
L010824(len)
IntegerSequences.L010825
— FunctionCompute the expansion of $∏_{m≥1} (1 - q^m)^{19}$.
L010825(len)
IntegerSequences.L010826
— FunctionCompute the expansion of $∏_{m≥1} (1 - q^m)^{20}$.
L010826(len)
IntegerSequences.L010827
— FunctionCompute the expansion of $∏_{m≥1} (1 - q^m)^{21}$.
L010827(len)
IntegerSequences.L010828
— FunctionCompute the expansion of $∏_{m≥1} (1 - q^m)^{22}$.
L010828(len)
IntegerSequences.L010829
— FunctionCompute the expansion of $∏_{m≥1} (1 - q^m)^{23}$.
L010829(len)
IntegerSequences.L010830
— FunctionCompute the expansion of $∏_{m≥1} (1 - q^m)^{25}$.
L010830(len)
IntegerSequences.L010831
— FunctionCompute the expansion of $∏_{m≥1} (1 - q^m)^{26}$.
L010831(len)
IntegerSequences.L010832
— FunctionCompute the expansion of $∏_{m≥1} (1 - q^m)^{27}$.
L010832(len)
IntegerSequences.L010833
— FunctionCompute the expansion of $∏_{m≥1} (1 - q^m)^{28}$.
L010833(len)
IntegerSequences.L010834
— FunctionCompute the expansion of $∏_{m≥1} (1 - q^m)^{29}$.
L010834(len)
IntegerSequences.L010835
— FunctionCompute the expansion of $∏_{m≥1} (1 - q^m)^{30}$.
L010835(len)
IntegerSequences.L010836
— FunctionCompute the expansion of $∏_{m≥1} (1 - q^m)^{31}$.
L010836(len)
IntegerSequences.L010837
— FunctionCompute the expansion of $∏_{m≥1} (1 - q^m)^{32}$.
L010837(len)
IntegerSequences.L010838
— FunctionCompute the expansion of $∏_{m≥1} (1 - q^m)^{44}$.
L010838(len)
IntegerSequences.L010839
— FunctionCompute the expansion of $∏_{m≥1} (1 - q^m)^{48}$.
L010839(len)
IntegerSequences.L010840
— FunctionCompute the expansion of $∏_{m≥1} (1 - q^m)^{40}$.
L010840(len)
IntegerSequences.L010841
— FunctionCompute the expansion of $∏_{m≥1} (1 - q^m)^{64}$.
L010841(len)
IntegerSequences.T011117
— FunctionReturn 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)
IntegerSequences.V011371
— FunctionReturn $n$ - BitCount(n).
V011371(n)
IntegerSequences.L013928
— FunctionReturn a list of the number of squarefree numbers $< n$.
julia> L013928(8)
[0, 1, 2, 3, 3, 4, 5, 6]
L013928(len)
IntegerSequences.V014107
— FunctionReturn the polygonal numbers of shape -2.
V014107(n)
IntegerSequences.L015128
— FunctionReturn the expansion of $1/ϑ_4(q)$ in powers of q.
L015128(len)
IntegerSequences.L023003
— FunctionReturn the number of partitions of n into parts of 4 kinds.
L023003(len)
IntegerSequences.L023004
— FunctionReturn the number of partitions of n into parts of 5 kinds.
L023004(len)
IntegerSequences.L023005
— FunctionReturn the number of partitions of n into parts of 6 kinds.
L023005(len)
IntegerSequences.L023006
— FunctionReturn the number of partitions of n into parts of 7 kinds.
L023006(len)
IntegerSequences.L023007
— FunctionReturn the number of partitions of n into parts of 8 kinds.
L023007(len)
IntegerSequences.L023008
— FunctionReturn the number of partitions of n into parts of 9 kinds.
L023008(len)
IntegerSequences.L023009
— FunctionReturn the number of partitions of n into parts of 10 kinds.
L023009(len)
IntegerSequences.L023010
— FunctionReturn the number of partitions of n into parts of 11 kinds.
L023010(len)
IntegerSequences.L023011
— FunctionReturn the number of partitions of n into parts of 13 kinds.
L023011(len)
IntegerSequences.L023012
— FunctionReturn the number of partitions of n into parts of 14 kinds.
L023012(len)
IntegerSequences.L023013
— FunctionReturn the number of partitions of n into parts of 15 kinds.
L023013(len)
IntegerSequences.L023014
— FunctionReturn the number of partitions of n into parts of 16 kinds.
L023014(len)
IntegerSequences.L023015
— FunctionReturn the number of partitions of n into parts of 17 kinds.
L023015(len)
IntegerSequences.L023016
— FunctionReturn the number of partitions of n into parts of 18 kinds.
L023016(len)
IntegerSequences.L023017
— FunctionReturn the number of partitions of n into parts of 19 kinds.
L023017(len)
IntegerSequences.L023018
— FunctionReturn the number of partitions of n into parts of 20 kinds.
L023018(len)
IntegerSequences.L023019
— FunctionReturn the number of partitions of n into parts of 21 kinds.
L023019(len)
IntegerSequences.L023020
— FunctionReturn the number of partitions of n into parts of 22 kinds.
L023020(len)
IntegerSequences.L023021
— FunctionReturn the number of partitions of n into parts of 23 kinds.
L023021(len)
IntegerSequences.is325143
— FunctionIs $n$ a prime represented by a cyclotomic binary form?
is325143(n)
IntegerSequences.is325145
— FunctionIs $n$ a prime unrepresentable by a cyclotomic binary form?
is325145(n)
IntegerSequences.L025528
— FunctionReturn 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)
IntegerSequences.V026791
— FunctionReturn the partitions of $n$ as a weakly increasing lists of parts in lexicographic order.
V026791(n)
IntegerSequences.V027641
— FunctionReturn the numerator of the Bernoulli number $B_n$.
V027641(n)
IntegerSequences.V027642
— FunctionReturn the denominator of Bernoulli number $B_n$.
V027642(n)
IntegerSequences.is327988
— FunctionIs V327987(n) = ∑$_{d|n} d & (n/d) = 0$ ?
is327988(n)
IntegerSequences.L031363
— FunctionReturn positive numbers of the form $x^2+xy-y^2$; or, of the form $5x^2-y^2$.
L031363(bound)
IntegerSequences.V032031
— FunctionReturn the triple factorial numbers with shift 3.
V032031(n)
IntegerSequences.V033156
— FunctionRecurrence $a(n) = a(n-1) + ⌊ a(n-1)/(n-1) ⌋ + 2$ for $m ≥ 2$ and $a(1) = 1$.
V033156(n)
IntegerSequences.V033815
— FunctionReturn $(2n)!$ Hypergeometric1F1$[-n, -2n, -1]$. Number of acyclic orientations of the Turán graph $T(2n,n)$.
V033815(n)
IntegerSequences.L034017
— FunctionReturn positive integers that are primitively represented by $x^2 + xy + y^2$.
L034017(bound)
IntegerSequences.V034386
— FunctionReturn the primorial of $n$, the product of the primes $≤ n$.
V034386(n)
IntegerSequences.V034444
— FunctionReturn the number of unitary divisors of $n$, $d$ such that $d$ divides $n$ and $d ⊥ n/d$.
V034444(n)
IntegerSequences.F034885
— FunctionIterate over the record values of sigma the indices of which do not exceed $n$ ($1 ≤ r ≤ n$).
F034885(n)
IntegerSequences.I034885
— FunctionIterate over the first $n$ record values of sigma.
I034885(n)
IntegerSequences.L034885
— FunctionReturn the first $n$ record values of sigma as an array.
L034885(n)
IntegerSequences.V034885
— FunctionReturn the $n$-th record of sigma. Indexing starts with 1.
V034885(n)
IntegerSequences.L035016
— FunctionReturn the expansion of $ϑ_4(q)^8$ in powers of q.
L035016(len)
IntegerSequences.L035251
— FunctionReturn positive numbers of the form $x^2 - 2y^2$ with integers $x, y$ (discriminant is 8).
L035251(bound)
IntegerSequences.V035327
— FunctionReturn $n$ NAND $n$.
V035327(n)
IntegerSequences.L036038
— FunctionReturn the partition coefficients of $n$, first ordered by length.
L036038(n)
IntegerSequences.L036039
— FunctionReturn 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)
IntegerSequences.T037027
— FunctionReturn the skew Fibonacci-Pascal triangle with dim
rows.
T037027(dim)
IntegerSequences.V038554
— FunctionReturn $n$ XOR $n>>1$, using min length.
V038554(n)
IntegerSequences.V038712
— FunctionReturn $n$ XOR $n+1$, using max length.
V038712(n)
IntegerSequences.L038872
— FunctionReturn primes congruent to ${0, 1, 4}$ mod 5 (cf. also [A141158]
).
L038872(bound)
IntegerSequences.L038873
— FunctionReturn primes p such that 2 is a square mod p; or, primes congruent to ${1, 2, 7}$ mod $8$.
L038873(bound)
IntegerSequences.T039599
— FunctionThe Riordan square of the Catalan numbers.
T039599(n)
IntegerSequences.T039683
— FunctionReturn 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)
IntegerSequences.L039834
— FunctionReturn the signed Fibonacci numbers, dubbed negaFibonacci numbers.
L039834(n)
IntegerSequences.L042965
— FunctionReturn positive integers not congruent to 2 mod 4; regular numbers modulo 4.
L042965(bound)
IntegerSequences.V046161
— FunctionReturn $2^{2n - bc(n)}$ where bc(n) is BitCount(n).
V046161(n)
IntegerSequences.V047053
— FunctionReturn the quadruple factorial numbers $4^n n!$.
V047053(n)
IntegerSequences.L047891
— FunctionReturn the number of planar rooted trees with $n$ nodes and tricolored end nodes.
L047891(len)
IntegerSequences.V048724
— FunctionReturn $n$ XOR $2n$, using max length.
V048724(n)
IntegerSequences.V048735
— FunctionReturn $n$ AND $n>>1$, using min length.
V048735(n)
IntegerSequences.L048993
— FunctionLists the first n rows of A048993
by concatenating.
L048993(n)
IntegerSequences.M048993
— FunctionReturn the triangular array as a square matrix with dim rows.
M048993(dim)
IntegerSequences.T048993
— FunctionIterates over the first n rows of A048993
.
T048993(n)
IntegerSequences.V048993
— FunctionReturn row n of A048993 based on the iteration T048993
(n).
V048993(n)
IntegerSequences.T049218
— FunctionReturn the arctangent numbers (expansion of arctan$(x)^n/n!$).
T049218(dim)
IntegerSequences.T049310
— FunctionReturn the coefficients of Chebyshev's U$(n, x/2)$ polynomials.
T049310(dim)
IntegerSequences.I050384
— FunctionIterate over the first $n$ strong cyclic numbers.
I050384(n)
IntegerSequences.L050384
— FunctionReturn the first $n$ strong cyclic numbers in an array.
L050384(n)
IntegerSequences.T051141
— FunctionReturn 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)
IntegerSequences.T051142
— FunctionReturn 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)
IntegerSequences.V051933
— FunctionReturn $n$ XOR $k$, using max length.
V051933(n, k)
IntegerSequences.L052847
— FunctionReturn a list of length len of the Euler transform of [0, 1, 2, 3, ...].
L052847(len)
IntegerSequences.V052847
— FunctionReturn the Euler transform of [0, 1, 2, 3, ...].
V052847(n)
IntegerSequences.T053117
— FunctionReturn the coefficients of the Chebyshev-U polynomials.
T053117(len)
IntegerSequences.T053120
— FunctionReturn the coefficients of the Chebyshev-T polynomials.
T053120(len)
IntegerSequences.T053121
— FunctionReturn the Catalan triangle (with 0's) read by rows.
T053121(dim)
IntegerSequences.V054248
— FunctionBinary entropy: $a(n) = n +$ min ${ a(k) + a(n-k) : 1 ≤ k ≤ n-1 }.$
V054248(n)
IntegerSequences.V055542
— FunctionReturn the total number of nodes in all simple graphs of $n$ nodes.
V055542(n)
IntegerSequences.V055543
— FunctionTotal number of nodes in all trees with n nodes.
V055543(n)
IntegerSequences.V055544
— FunctionTotal number of nodes in all rooted trees with $n$ nodes.
V055544(n)
IntegerSequences.V055634
— FunctionReturn the 2-adic factorial of n.
V055634(n)
IntegerSequences.T055883
— FunctionReturn the exponential transform of Pascal's triangle.
T055883(n)
IntegerSequences.V056982
— FunctionReturn $4^{2n - bc(n)}$ where bc(n) is BitCount(n).
V056982(n)
IntegerSequences.L057126
— FunctionReturn mumbers n such that 2 is a square mod n.
L057126(bound)
IntegerSequences.L057127
— FunctionReturn positive integers primitively represented by $x^2 + 2y^2$.
L057127(bound)
IntegerSequences.V058373
— FunctionReturn the pyramidal numbers of shape 0.
V058373(n)
IntegerSequences.T059419
— FunctionReturn the triangle $T(n,k)$ of tangent numbers, coefficient of $x^n/n!$ in the expansion of $(tan x)^k/k!$.
T059419(dim)
IntegerSequences.T060693
— FunctionReturn 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)
IntegerSequences.V060818
— FunctionReturn $2^{n - bc(n)}$ where bc(n) is BitCount(n).
V060818(n)
IntegerSequences.V061142
— FunctionReturn the result of replacing each prime factor of n with 2.
V061142(n)
IntegerSequences.V061168
— FunctionPartial sums of the sequence $⌊ \log[2](n) ⌋$.
V061168(n)
IntegerSequences.L061256
— FunctionReturn a list of length len of the Euler transform of sigma.
L061256(len)
IntegerSequences.V061256
— FunctionReturn the Euler transform of sigma.
V061256(n)
IntegerSequences.L062980
— FunctionReturn the number of rooted unlabeled connected triangular maps on a compact closed oriented surface with $2n$ faces.
L062980(len)
IntegerSequences.T064189
— FunctionReturn the (reflected) Motzkin triangle.
T064189(dim)
IntegerSequences.L065515
— FunctionReturn 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)
IntegerSequences.L065619
— FunctionComputes a list of length len
of the integer Bernoulli numbers $b_{2}(n)$ using Seidel's boustrophedon algorithm.
L065619(len)
IntegerSequences.V065619
— FunctionReturn the number of down-up permutations w on $[n+1]$ such that $w_2 = 1$.
V065619(n)
IntegerSequences.L065855
— FunctionReturn a list of the number of composite numbers $≤ n$.
julia> L065855(8)
[0, 0, 0, 0, 1, 1, 2, 2]
L065855(len)
IntegerSequences.T066325
— FunctionReturn the coefficients of unitary Hermite polynomials He$_n(x)$.
T066325(dim)
IntegerSequences.V066570
— FunctionReturn GaussFactorial(n, 1)/GaussFactorial(n, n).
V066570(n)
IntegerSequences.V067998
— FunctionReturn the polygonal numbers of shape 0.
V067998(n)
IntegerSequences.L068228
— FunctionReturn primes congruent to 1 (mod 12).
L068228(bound)
IntegerSequences.G068875
— FunctionThe generating function of twice the Catalan numbers.
G068875(x)
IntegerSequences.L068875
— FunctionReturn a list of twice the Catalan numbers.
L068875(n)
IntegerSequences.L069637
— FunctionReturn 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)
IntegerSequences.I072233
— FunctionReturn an iterator over the list of partitions of $n$ into $k$ parts.
I072233(n)
IntegerSequences.L072233
— FunctionReturn a list of the number of partitions of $n$ into $k$ parts.
L072233(n)
IntegerSequences.L078760
— FunctionReturn the partition coefficients of $n$, first ordered by biggest part.
L078760(n)
IntegerSequences.V080079
— FunctionReturn $n$ NEG1 $n+1$, using max length.
V080079(n)
IntegerSequences.V080577
— FunctionReturn the integer partitions of $n$ in graded reverse lexicographic order, the canonical ordering of partitions.
V080577(n)
IntegerSequences.V080940
— FunctionReturn $n$ CNIMP $n+1$, using min length.
V080940(n)
IntegerSequences.V080956
— FunctionReturn the polygonal numbers of shape 1.
V080956(n)
IntegerSequences.V081125
— FunctionReturn $rac{n!}{⌊n/2⌋!}$.
V081125(n)
IntegerSequences.L082298
— FunctionReturn 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)
IntegerSequences.L082301
— FunctionReturn the number of Schröder paths of semilength n in which the (2,0)-steps come in 4 colors.
L082301(len)
IntegerSequences.L082302
— FunctionReturn the coefficients in the expansion of $(1-5x-√(25x^2-14x+1))/(2x)$.
L082302(len)
IntegerSequences.L082556
— FunctionReturn the number of partitions of n into parts of 30 kinds.
L082556(len)
IntegerSequences.L082557
— FunctionReturn the number of partitions of n into parts of 32 kinds.
L082557(len)
IntegerSequences.L082558
— FunctionReturn the number of partitions of n into parts of 48 kinds.
L082558(len)
IntegerSequences.L082559
— FunctionReturn the number of partitions of n into parts of 64 kinds.
L082559(len)
IntegerSequences.F083207
— FunctionIterate over the Zumkeller numbers $z$ which are below $n, (1 ≤ z ≤ n)$.
F083207(n)
IntegerSequences.I083207
— FunctionIterate over the first $n$ Zumkeller numbers.
I083207(n)
IntegerSequences.L083207
— FunctionList the first $n$ Zumkeller numbers.
L083207(n)
IntegerSequences.V083207
— FunctionReturn the $n$-th Zumkeller number.
V083207(n)
IntegerSequences.is083207
— FunctionIs $n$ a Zumkeller number?
is083207(n)
IntegerSequences.V083652
— FunctionReturn the sum of lengths of binary expansions of $0$ through $n$.
V083652(n)
IntegerSequences.L084916
— FunctionReturn positive numbers of the form $n = x^2-3y^2$ of discriminant 12.
L084916(bound)
IntegerSequences.T084938
— FunctionReturn 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)
IntegerSequences.V086799
— FunctionReturn $n$ OR $n+1$, using max length.
V086799(n)
IntegerSequences.L087803
— FunctionNumber of unlabeled rooted trees with at most n nodes.
L087803(len)
IntegerSequences.V088887
— FunctionReturn the number of types of signatures of partitions of n.
V088887(n)
IntegerSequences.T088969
— FunctionReturn a triangle related to the median Euler numbers.
T088969(n)
IntegerSequences.L089270
— FunctionReturn positive numbers represented by the integer binary quadratic form $x^2+xy-y^2$ with $x$ and $y$ relatively prime.
L089270(bound)
IntegerSequences.T090238
— FunctionReturn the number of lists of $k$ unlabeled permutations whose total length is $n$.
T090238(n)
IntegerSequences.T090981
— FunctionReturn the number of Schroeder paths of length $2n$ and having $k$ ascents.
T090981(n)
IntegerSequences.is293654
— FunctionIs $n$ unrepresentable by a cyclotomic binary forms?
is293654(n)
IntegerSequences.L094587
— FunctionLists the first n rows of A094587
by concatenating.
L094587(n)
IntegerSequences.M094587
— FunctionReturn the triangular array as a square matrix with dim rows.
M094587(dim)
IntegerSequences.T094587
— FunctionIterates over the first n rows of A094587
.
T094587(n)
IntegerSequences.V094587
— FunctionReturn row n of A094587 based on the iteration T094587
(n).
V094587(n)
IntegerSequences.T094665
— FunctionReturn the number of increasing 0-2 trees (A002105) on $2n$ edges in which the minimal path from the root has length $k$.
T094665(n)
IntegerSequences.V095350
— FunctionReturn total number of edges in all rooted trees with $n$ nodes.
V095350(n)
IntegerSequences.V095794
— FunctionReturn the polygonal numbers of shape -1.
V095794(n)
IntegerSequences.is296095
— FunctionIs $n$ represented by a cyclotomic binary form?
is296095(n)
IntegerSequences.L096727
— FunctionReturn the expansion of $ϑ_4(q)^4$ in powers of q.
L096727(len)
IntegerSequences.V097383
— FunctionMinimum total number of comparisons to find each of the values $1$ through $n$ using a binary search with $3$-way comparisons.
V097383(n)
IntegerSequences.L097805
— FunctionLists the first $n$ rows of A097805 by concatinating. This is the format for submissions to the OEIS.
L097805(n)
IntegerSequences.M097805
— FunctionReturn the triangular array as a square matrix.
M097805(dim)
IntegerSequences.T097805
— FunctionIterates over the first $n$ rows of A097805.
T097805(n)
IntegerSequences.V097805
— FunctionReturn row $n$ of A097805 based on the iteration T097805(n).
V097805(n)
IntegerSequences.V099022
— FunctionReturn $(2n)!$ Hypergeometric1F1$[-n, -2n, 1]$.
V099022(n)
IntegerSequences.T099174
— FunctionReturn the coefficients of the modified Hermite polynomials.
T099174(dim)
IntegerSequences.is299498
— FunctionIs $n$ primitively represented by a cyclotomic binary forms?
is299498(n)
IntegerSequences.is299733
— FunctionIs 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)
IntegerSequences.is299928
— FunctionIs $n$ represented by a cyclotomic binary form f(x, y) where x and y are prime numbers and 0 < y < x?
is299928(n)
IntegerSequences.is299929
— FunctionIs $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)
IntegerSequences.is299930
— FunctionIs $n$ a prime represented by a cyclotomic binary form f(x, y) with x and y odd prime numbers and x > y.
is299930(n)
IntegerSequences.V102376
— FunctionReturn 4^BitCount(n).
V102376(n)
IntegerSequences.T104556
— FunctionReturn 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)
IntegerSequences.T104562
— FunctionReturn the inverse of the Motzkin triangle (cf. A064189).
T104562(dim)
IntegerSequences.L104794
— FunctionReturn the expansion of $ϑ_4(q)^2$ in powers of q.
L104794(len)
IntegerSequences.L105523
— FunctionReturn the coefficients in the expansion of $(1+2x-√(1+4x^2))/(2x)$.
L105523(len)
IntegerSequences.T106566
— FunctionReturn the the Catalan convolution triangle.
T106566(n)
IntegerSequences.L107716
— FunctionA transform the of triple factorial numbers.
L107716(len)
IntegerSequences.L107895
— FunctionReturn a list of length len of the Euler transform of the factorial.
L107895(len)
IntegerSequences.V107895
— FunctionReturn the Euler transform of the factorial.
V107895(n)
IntegerSequences.L108624
— FunctionReturn the sequence with generating function satisfying $x = (A(x)+(A(x))^2)/(1-A(x)-(A(x))^2)$.
L108624(len)
IntegerSequences.T111062
— FunctionReturn the triangle $T(n, k) = \binom{n}{k} \times$ involutions$(n - k)$.
T111062(dim)
IntegerSequences.L111529
— FunctionA convolutory inverse of the factorial sequence.
L111529(len)
IntegerSequences.L111530
— FunctionA convolutory inverse of the factorial sequence.
L111530(len)
IntegerSequences.L111531
— FunctionA convolutory inverse of the factorial sequence.
L111531(len)
IntegerSequences.L111532
— FunctionA convolutory inverse of the factorial sequence.
L111532(len)
IntegerSequences.L111533
— FunctionA convolutory inverse of the factorial sequence.
L111533(len)
IntegerSequences.T111593
— FunctionReturn the triangle of tanh numbers.
T111593(dim)
IntegerSequences.L115621
— FunctionReturn the signature of partitions in Hindenburg order.
L115621(n)
IntegerSequences.T116392
— FunctionThe Riordan square of the central trinomial.
T116392(n)
IntegerSequences.T119274
— FunctionReturn the triangle of coefficients of numerators in Pade approximation to $e^x$.
julia> ShowAsΔ(T119274(5))
1
0 1
0 2 1
0 12 6 1
0 120 60 12 1
T119274(n)
IntegerSequences.V120738
— FunctionReturn $4n$ - BitCount(n).
V120738(n)
IntegerSequences.V123753
— FunctionPartial sums of the sequence of length of the binary expansion of $2n+1$.
V123753(n)
IntegerSequences.V124320
— FunctionReturn the restricted rising factorial which is zero for $n < 0$ or $k > n$.
V124320(n, k)
IntegerSequences.V124399
— FunctionReturn $4^{n - bc(n)}$ where bc(n) is BitCount(n).
V124399(n)
IntegerSequences.V124441
— FunctionReturn GaussFactorial(div(n, 2), n).
V124441(n)
IntegerSequences.V124442
— FunctionReturn GaussFactorial(n, n)/GaussFactorial(div(n, 2), n).
V124442(n)
IntegerSequences.V129760
— FunctionReturn $n$ AND $n+1$, using max length.
V129760(n)
IntegerSequences.T132062
— FunctionReturn the triangle of coefficients of Bessel polynomials, also the Sheffer triangle $(1, 1 - √(1 - 2x))$ (Cf. A001497).
julia> ShowAsΔ(T132062(5))
1
0 1
0 1 1
0 3 3 1
0 15 15 6 1
T132062(n)
IntegerSequences.L132393
— FunctionLists the first n rows of A132393
by concatenating.
L132393(n)
IntegerSequences.M132393
— FunctionReturn the triangular array as a square matrix with dim rows.
M132393(dim)
IntegerSequences.T132393
— FunctionIterates over the first n rows of A132393
.
T132393(n)
IntegerSequences.V132393
— FunctionReturn row n of A132393 based on the iteration T132393
(n).
V132393(n)
IntegerSequences.V135481
— FunctionReturn $n+1$ CNIMP $n$, using max length.
V135481(n)
IntegerSequences.V135521
— FunctionReturn $n$ XOR $n+1$, using min length.
V135521(n)
IntegerSequences.T137286
— FunctionReturn the coefficients of a variant of the Hermite polynomials.
T137286(dim)
IntegerSequences.T137338
— FunctionReturn the coefficients of the Charlier polynomials with parameter $a = 1$.
T137338(dim)
IntegerSequences.T137452
— FunctionReturn the coefficients of the first $n$ Abel polynomials.
julia> ShowAsΔ(T137452(5))
1
0 1
0 -2 1
0 9 -6 1
0 -64 48 -12 1
T137452(n)
IntegerSequences.T137513
— FunctionReturn the triangle of the coefficients of the Mittag-Leffler polynomials.
julia> ShowAsΔ(T137513(5))
1
0 2
0 0 4
0 4 0 8
0 0 32 0 16
T137513(n)
IntegerSequences.L141158
— FunctionReturn primes represented by the integer binary quadratic form $x^2+xy-y^2$.
L141158(bound)
IntegerSequences.V142151
— FunctionReturn $n$ CIMP $n+1$, using max length.
V142151(n)
IntegerSequences.L146559
— FunctionReturn the expansion of $(1-x)/(1 - 2x + 2x^2)$.
L146559(len)
IntegerSequences.V151800
— FunctionReturn least prime $> n$. The next_prime
function of Mathematica, Maple, Magma and SageMath.
V151800(n)
IntegerSequences.T159834
— FunctionReturn the coefficients of Hermite polynomials $H(n, (x-1)/√(2))/(√(2))^n$.
T159834(dim)
IntegerSequences.V163590
— FunctionReturn the odd part of the swinging factorial $n! / ⌊n/2⌋!^2$.
V163590(n)
IntegerSequences.V163617
— FunctionReturn $n$ OR $2n$, using max length.
V163617(n)
IntegerSequences.L167872
— FunctionReturn half the number of Feynman diagrams of order $2(n+1)$, for the electron self-energy in quantum electrodynamics.
L167872(len)
IntegerSequences.T172094
— FunctionThe Riordan square of the little Schröder numbers.
T172094(n)
IntegerSequences.V178963
— FunctionReturn the number of 3-alternating permutations.
V178963(n)
IntegerSequences.V178964
— FunctionReturn the number of 4-alternating permutations.
V178964(n)
IntegerSequences.V181830
— FunctionReturn the number of integers $≤ n$ which are strong prime to $n$.
V181830(n)
IntegerSequences.V181936
— FunctionReturn the number of 5-alternating permutations.
V181936(n)
IntegerSequences.T184962
— FunctionReturn the Bell transform of the Fubini numbers.
T184962(n)
IntegerSequences.V188021
— FunctionReturn the $n$-th term of the fourth Multinacci sequence.
V188021(n)
IntegerSequences.L190905
— FunctionReturn a list of length len of the Euler transform of the swinging factorial.
L190905(len)
IntegerSequences.V190905
— FunctionReturn the Euler transform of the swinging factorial (A056040).
V190905(n)
IntegerSequences.F193338
— FunctionIterate over the record values of the Gauß factorial which do not exceed $n$ ($1 ≤ i ≤ n$).
F193338(n)
IntegerSequences.I193338
— FunctionIterate over the first $n$ record values of the Gauß factorial ($1 ≤ r$).
I193338(n)
IntegerSequences.L193338
— FunctionReturn the first $n$ record values of the Gauß factorial as an array.
L193338(n)
IntegerSequences.V193338
— FunctionReturn the (value of the) $n$-th record of the Gauß factorial. Indexing starts with 1.
V193338(n)
IntegerSequences.F193339
— FunctionIterate over indices of the record values of the Gauß factorial which do not exceed $n$ ($1 ≤ i ≤ n$).
F193339(n)
IntegerSequences.I193339
— FunctionIterate over the indices of the first $n$ record values of the Gauß factorial.
I193339(n)
IntegerSequences.L193339
— FunctionReturn the indices of the first $n$ record values of the Gauß factorial as an array.
L193339(n)
IntegerSequences.V193339
— FunctionReturn the index of the $n$-th record value of the Gauß factorial. Indexing starts with 1.
V193339(n)
IntegerSequences.V195441
— FunctionReturn denominator(Bernoulli $_{n+1}(x) -$ Bernoulli $_{n+1})$.
V195441(n)
IntegerSequences.T202327
— FunctionReturn the coefficients of $x^n$ in the expansion of $((-1-x+√(1+2x+5x^2))/2)^k$ as a triangle with dim rows.
T202327(dim)
IntegerSequences.T203412
— FunctionReturn the Bell transform of the MultiFactorial numbers of type (3,1).
julia> ShowAsΔ(T203412(5))
1
0 1
0 1 1
0 4 3 1
0 28 19 6 1
T203412(n)
IntegerSequences.F206864
— FunctionFilter the integers which are A206864 and $<= n$.
F206864(n)
IntegerSequences.I206864
— FunctionIterate over the first $n$ integers which are A206864.
I206864(n)
IntegerSequences.L206864
— FunctionReturn the list of the first $n$ integers which are A206864.
L206864(n)
IntegerSequences.F206942
— FunctionFilter the integers which are A206942 and $<= n$.
F206942(n)
IntegerSequences.I206942
— FunctionIterate over the first $n$ integers which are A206942.
I206942(n)
IntegerSequences.L206942
— FunctionReturn the list of the first $n$ integers which are A206942.
L206942(n)
IntegerSequences.V209397
— FunctionReturn $∑_{d|n}$ d V000081(d).
V209397(n)
IntegerSequences.V213370
— FunctionReturn $n$ AND $n<<1$, using min length.
V213370(n)
IntegerSequences.L213384
— FunctionReturn the expansion of $ϑ_4(q)^3$ in powers of q.
L213384(len)
IntegerSequences.L214551
— FunctionReturn a list of the first n terms of the modified Narayanas cows sequence.
L214551(n)
IntegerSequences.T216916
— FunctionReturn the coefficients of some orthogonal polynomials related to set partitions without singletons (cf. A000296).
T216916(dim)
IntegerSequences.V216919
— FunctionReturn GaussFactorial(N, n).
V216919(N, n)
IntegerSequences.V217420
— FunctionReturn the number of rooted unlabeled trees where the root node has degree 2 and both branches are distinct.
V217420(n)
IntegerSequences.T217537
— FunctionReturn the coefficients of some orthogonal polynomials related to indecomposable set partitions without singletons (cf. A098742).
T217537(dim)
IntegerSequences.L217924
— FunctionReturn the first len integers defined as $a(n) = n! [x^n] \exp(2 \exp (x) - x - 2)$.
L217924(len)
IntegerSequences.T225478
— FunctionReturn the triangle $4^k S_4(n, k)$ where $S_m(n, k)$ are the Stirling-Frobenius cycle numbers of order $m$.
T225478(n)
IntegerSequences.F225498
— FunctionIterate over the weak Carmichael numbers which do not exceed $n$.
F225498(n)
IntegerSequences.I225498
— FunctionIterate over the first $n$ weak Carmichael numbers.
I225498(n)
IntegerSequences.L225498
— FunctionReturn the first $n$ weak Carmichael numbers in an array.
L225498(n)
IntegerSequences.V231181
— FunctionReturn the $n$-th term of the fiveth Multinacci sequence.
V231181(n)
IntegerSequences.V232980
— FunctionReturn GaussFactorial(n, 3).
V232980(n)
IntegerSequences.V232981
— FunctionReturn GaussFactorial(n, 5).
V232981(n)
IntegerSequences.V232982
— FunctionReturn GaussFactorial(n, 6).
V232982(n)
IntegerSequences.L242660
— FunctionReturn positive numbers of the form $x^2+xy-2y^2$.
L242660(bound)
IntegerSequences.L243168
— FunctionReturn positive integers of the form $x^2+6xy-3y^2$.
L243168(bound)
IntegerSequences.L243655
— FunctionReturn positive numbers that are primitively represented by the indefinite quadratic form $x^2 - 3y^2$ of discriminant 12.
L243655(bound)
IntegerSequences.L244291
— FunctionReturn positive numbers primitively represented by the binary quadratic form (1, 6, -3).
L244291(bound)
IntegerSequences.L244779
— FunctionReturn positive numbers primitively represented by the binary quadratic form (1, 1, 2).
L244779(bound)
IntegerSequences.L244780
— FunctionReturn positive numbers primitively represented by the binary quadratic form (1, 1, 3).
L244780(bound)
IntegerSequences.L244819
— FunctionReturn positive numbers primitively represented by the binary quadratic form (1, 0, 3).
L244819(bound)
IntegerSequences.L246547
— FunctionReturn a list of perfect powers of length len. (Numbers of the form $p^k$ where $p$ is a prime and $k ≥ 2$.
julia> L246547(8)
[4, 8, 9, 16, 25, 27, 32, 49]
L246547(len)
IntegerSequences.L246655
— FunctionReturn a list of prime powers of length len. (Numbers of the form $p^k$ where $p$ is a prime and $k ≥ 1$.)
julia> L246655(8)
[2, 3, 4, 5, 7, 8, 9, 11]
L246655(len)
IntegerSequences.V250283
— FunctionReturn the number of 6-alternating permutations.
V250283(n)
IntegerSequences.V251568
— FunctionReturn $((2n)!/(n+1)!)$ Hypergeometric1F1$[1-n, n+2, -1]$. Egf. exp $(x C(x)^2)$ where $C(x) = 1 + xC(x)^2$ is the generating function of the Catalan numbers.
V251568(n)
IntegerSequences.V254749
— FunctionReturn the pyramidal numbers of shape 1.
V254749(n)
IntegerSequences.V257993
— FunctionReturn the index of the least prime not dividing $n$. a(0)=1 by convention.
V257993(n)
IntegerSequences.L262071
— FunctionReturn the number of ordered partitions of an n-set with nondecreasing block sizes and maximal block size equal to k.
L262071(n)
IntegerSequences.T264428
— FunctionReturn the Bell transform of the Bell numbers.
julia> ShowAsΔ(T264428(5))
1
0 1
0 1 1
0 2 3 1
0 5 11 6 1
T264428(n)
IntegerSequences.T265606
— FunctionReturn the Bell transform of the quartic factorial numbers.
julia> ShowAsΔ(T265606(5))
1
0 1
0 1 1
0 5 3 1
0 45 23 6 1
T265606(n)
IntegerSequences.V265609
— FunctionReturn the rising factorial i.e. the product of $i$ ∈ $n:(n + k - 1)$.
V265609(n, k)
IntegerSequences.L271703
— FunctionLists the first n rows of A271703
by concatenating.
L271703(n)
IntegerSequences.M271703
— FunctionReturn the triangular array as a square matrix with dim rows.
M271703(dim)
IntegerSequences.T271703
— FunctionIterates over the first n rows of A271703
.
T271703(n)
IntegerSequences.V271703
— FunctionReturn row n of A271703 based on the iteration T271703
(n).
V271703(n)
IntegerSequences.L275585
— FunctionReturn a list of length len of the Euler transform of sigma_2.
L275585(len)
IntegerSequences.V275585
— FunctionReturn the Euler transform of sigma_2.
V275585(n)
IntegerSequences.L276285
— FunctionReturn the number of ways of writing a nonnegative integer n as a sum of 13 squares.
L276285(len)
IntegerSequences.L276286
— FunctionReturn the number of ways of writing a nonnegative integer n as a sum of 14 squares.
L276286(len)
IntegerSequences.L276287
— FunctionReturn the nnumber of ways of writing a nonnegative integer n as a sum of 15 squares.
L276287(len)
IntegerSequences.V277233
— FunctionReturn the numerators of the Landau constants.
V277233(n)
IntegerSequences.L280172
— FunctionReturn $(k-1$ XOR $n-k) + 1$, using max length.
L280172(n)
IntegerSequences.V281586
— FunctionReturn the generalized integer Bernoulli numbers $b_{3}(n) = n ×$André$_{3}(n-1)$.
V281586(n)
IntegerSequences.V281588
— FunctionReturn the generalized integer Bernoulli numbers $b_{4}(n) = n ×$ André$_{4}(n-1)$.
V281588(n)
IntegerSequences.L290351
— FunctionReturn a list of length len of the Euler transform of the Bell numbers.
L290351(len)
IntegerSequences.V290351
— FunctionReturn the Euler transform of the Bell numbers.
V290351(n)
IntegerSequences.L292222
— FunctionReturn the triangle of multinomial coefficients of $n$. [Defined as in the 'Handbook of Mathematical Functions', p. 831, as $M1$.]
L292222(n)
IntegerSequences.F293654
— FunctionFilter the integers which are A293654 and <= $n$.
F293654(n)
IntegerSequences.I293654
— FunctionIterate over the first $n$ integers which are A293654.
I293654(n)
IntegerSequences.L293654
— FunctionReturn the list of the first $n$ integers which are A293654.
L293654(n)
IntegerSequences.V295513
— FunctionReturn $n$ Bil$(n) - 2^{\text{Bil}(n)}$ where Bil$(n)$ is the binary integer length of $n$.
V295513(n)
IntegerSequences.F296095
— FunctionFilter the integers which are A296095 and <= $n$.
F296095(n)
IntegerSequences.I296095
— FunctionIterate over the first $n$ integers which are A296095.
I296095(n)
IntegerSequences.L296095
— FunctionReturn the list of the first $n$ integers which are A296095.
L296095(n)
IntegerSequences.L299214
— FunctionReturn the initial list of V299214 of length len .
L299214(len)
IntegerSequences.V299214
— FunctionReturn the number of representations of $n$ by cyclotomic binary forms.
V299214(n)
IntegerSequences.F299498
— FunctionFilter the integers which are A299498 and <= $n$.
F299498(n)
IntegerSequences.I299498
— FunctionIterate over the first $n$ integers which are A299498.
I299498(n)
IntegerSequences.L299498
— FunctionReturn the list of the first $n$ integers which are A299498.
L299498(n)
IntegerSequences.L299733
— FunctionReturn the list of the first $n$ integers which are A299733.
L299733(n)
IntegerSequences.F299928
— FunctionFilter the integers which are A299928 and <= $n$.
F299928(n)
IntegerSequences.I299928
— FunctionIterate over the first $n$ integers which are A299928.
I299928(n)
IntegerSequences.L299928
— FunctionReturn the list of the first $n$ integers which are A299928.
L299928(n)
IntegerSequences.F299929
— FunctionFilter the integers which are A299929 and <= $n$.
F299929(n)
IntegerSequences.I299929
— FunctionIterate over the first $n$ integers which are A299929.
I299929(n)
IntegerSequences.L299929
— FunctionReturn the list of the first $n$ integers which are A299929.
L299929(n)
IntegerSequences.F299930
— FunctionFilter the integers which are A299930 and <= $n$.
F299930(n)
IntegerSequences.I299930
— FunctionIterate over the first $n$ integers which are A299930.
I299930(n)
IntegerSequences.L299930
— FunctionReturn the list of the first $n$ integers which are A299930.
L299930(n)
IntegerSequences.V309896
— FunctionReturn the $k$-th term of the $n$-th Multinacci sequence.
V309896(n, k)
IntegerSequences.L319284
— FunctionReturns the profile of the backtrack tree for the n queens problem.
L319284(n)
IntegerSequences.L319514
— FunctionReturn a list of pairs $(x, y)$ given by the boustrophedonic Rosenberg-Strong enumeration.
L319514(len)
IntegerSequences.V319514
— FunctionReturn the pair $(x, y)$ for given n as given by the boustrophedonic Rosenberg-Strong enumeration.
V319514(n)
IntegerSequences.T321620
— FunctionThe Riordan square of the Riordan numbers (with 1 prepended).
T321620(n)
IntegerSequences.T321621
— FunctionThe Riordan square of the Motzkin numbers.
T321621(n)
IntegerSequences.T321623
— FunctionThe Riordan square of the large Schröder numbers.
T321623(n)
IntegerSequences.T321624
— FunctionThe Riordan square of the Lucas numbers.
T321624(n)
IntegerSequences.T322942
— FunctionThe Riordan square of the Jacobsthal numbers.
T322942(n)
IntegerSequences.F325143
— FunctionFilter the integers which are A325143 and <= $n$.
F325143(n)
IntegerSequences.I325143
— FunctionIterate over the first $n$ integers which are A325143.
I325143(n)
IntegerSequences.L325143
— FunctionReturn the list of the first $n$ integers which are A325143.
L325143(n)
IntegerSequences.F325145
— FunctionFilter the integers which are A325145 and <= $n$.
F325145(n)
IntegerSequences.I325145
— FunctionIterate over the first $n$ integers which are A325145.
I325145(n)
IntegerSequences.L325145
— FunctionReturn the list of the first $n$ integers which are A325145.
L325145(n)
IntegerSequences.V327491
— FunctionReturn valuation $(n, 2)$ if $4$ divides $n$ else $1 + (n mod 2)$.
V327491(n)
IntegerSequences.V327492
— FunctionReturn $2n - bc(n) + mod(n, 2)$ where bc(n) is BitCount(n).
V327492(n)
IntegerSequences.V327493
— FunctionReturn $2^{2n - bc(n) + mod(n, 2)}$ where bc(n) is BitCount(n).
V327493(n)
IntegerSequences.V327494
— FunctionReturn the numerator of $∑_{j=0..n} j!/(2^j ⌊j/2⌋!)^2$.
V327494(n)
IntegerSequences.V327495
— FunctionReturn the numerators of the swinging Landau constants.
V327495(n)
IntegerSequences.V327987
— FunctionReturn ∑$_{d|n} d & (n/d)$, where & is the bitwise AND operator.
V327987(n)
IntegerSequences.L327988
— FunctionReturn a list of the zeros of V327987 below (inc.) $max$.
L327988(max)
IntegerSequences.L328917
— FunctionReturn the types of signatures of partitions of n, ordered firstly by decreasing greatest parts, then decreasing sum of parts, then by increasing number of parts.
L328917(n)