https://github.com/openlibmathseq/integersequences.jl
Sequences basics
https://github.com/openlibmathseq/integersequences.jl
algorithms enumerations graphs julia math number-theory oeis polynomials sequences series transforms
Last synced: 10 months ago
JSON representation
Sequences basics
- Host: GitHub
- URL: https://github.com/openlibmathseq/integersequences.jl
- Owner: OpenLibMathSeq
- License: mit
- Created: 2019-04-28T10:45:49.000Z (almost 7 years ago)
- Default Branch: master
- Last Pushed: 2020-08-18T00:32:29.000Z (over 5 years ago)
- Last Synced: 2025-05-12T07:19:06.250Z (10 months ago)
- Topics: algorithms, enumerations, graphs, julia, math, number-theory, oeis, polynomials, sequences, series, transforms
- Language: Julia
- Size: 25.5 MB
- Stars: 7
- Watchers: 1
- Forks: 1
- Open Issues: 4
-
Metadata Files:
- Readme: README.md
- License: LICENSE.md
Awesome Lists containing this project
README
[](https://travis-ci.org/OpenLibMathSeq/IntegerSequences.jl)
[](https://openlibmathseq.github.io/IntegerSequences.jl/v0.3.0)
--
The package is tested against Julia 1.3 and above on Linux, macOS, and Windows64.
## Naming conventions
Julia implementations of mathematical sequences.
The function names follow the registration numbers of the
[OEIS](https://oeis.org "Online Encyclopedia of Integer Sequences").
We use the following prefixes to indicate the type of the function.
Prefix | Function Type
------ | -------------
C | Coroutine (channel)
F | Filter (not exceeding n)
G | Generating function
I | Iteration (over n terms)
L | List (array based)
M | Matrix (2-dim square)
R | Real function (Float64)
P | Polynomial (univariate over ℤ)
S | Staircase (list iteration)
T | Triangle (list iteration)
V | Value (single term)
is | is a member (predicate query)
These conventions can be seen as an application programming interface
which we explain by three examples.
### Example 1: Fibonacci numbers
For the Fibonacci numbers we offer 7 functions:
I000045, F000045, G000045, L000045, V000045, R000045, is000045.
Four of those are based on the iteration protocol `FiboIterate` which is kept intern.
The implementations are:
* Iterate over the first ``n`` Fibonacci numbers.
```
I000045(n) = FiboIterate(n)
```
* Iterate over the Fibonacci numbers which do not exceed ``n``.
```
F000045(n) = takewhile(k -> k <= n, FiboIterate(n+1))
```
* Return the first ``n`` Fibonacci numbers in an array.
```
L000045(n) = collect(FiboIterate(n))
```
Alternatively one can use a generating function if available:
```
L000045(n) = coefficients(G000045, n)
```
* Return the ``n``-th Fibonacci number.
```
function V000045(n)
F = ℤ[1 1; 1 0]
Fn = F^n
Fn[2, 1]
end
```
* Fibonacci function for real values, returns a Float64.
```
function R000045(x::Float64)
(Base.MathConstants.golden^x - cos(x Base.MathConstants.pi)
Base.MathConstants.golden^(-x)) / sqrt(5)
end
```
* Query if ``n`` is a Fibonacci number, returns a Bool.
```
function is000045(n)
d = 0
for f in FiboIterate(n+2)
d = n - f
d <= 0 && break
end
d == 0
end
```
### Example 2: Abundant numbers
For the abundant numbers (i.e. numbers n where the sum of divisors exceeds 2n) we offer 5 functions:
is005101, I005101, F005101, L005101, V005101
* Is ``n`` an abundant number, i.e. is ``σ(n) > 2 n `` ?
```
is005101(n) = σ(n) > 2 n
```
* Iterate over the first ``n`` abundant numbers.
```
I005101(n) = takefirst(isAbundant, n)
```
* Iterate over the abundant numbers which do not exceed ``n``.
```
F005101(n) = filter(isAbundant, 1:n)
```
* Return the first ``n`` abundant numbers in an array.
```
L005101(n) = collect(I005101(n))
```
* Return the value of the ``n``-th abundant number.
```
V005101(n) = nth(I005101(n), n)
```
## Number triangles
#### Definition
To construct a number triangle one has to provide a function
t(n, k) defined for all integers n and k with n >= 0 and 0 <= k <= n.
Note that this corresponds to an infinite lower triangular matrix which is (0, 0)-based.
This deviates from the usual indexing of Julia matrices which are (1, 1)-based,
but the mother of all number triangles is Pascal's triangle which is (0, 0)-based
and in our application it is more convenient to follow the lead of Blaise than
that of Julia.
The matrix view of a number triangle of dimension dim has dim rows and the n-th row has length n.
Note that the rows are enumerated like the terms 0, 1, 2, ...
```
T(0,0) row 0
T(1,0) T(1,1) row 1
T(2,0) T(2,1) T(2,2) row 2
T(3,0) T(3,1) T(3,2) T(3,3) row 3
```
However, our model is not that of a matrix, rather that of an iteration,
actually an iteration over lists. In this abstract view a triangle T is a
chain of lists. On the first level a triangle iterates over the rows of the
triangle and on the secondary level over the terms of the rows, which are
given by the user-supplied function t(n, k).
```
T = (row(0), row(1), ..., row(dim-1))
Row(T, n) = [t(n, 0), t(n, 1), ..., t(n, n)]
```
#### Constructing
Sequence A097805 gives the number of ordered partitions of n into k parts.
The corresponding triangle can be constructed like this:
* Triangle T097805 based of explicit value.
```
V097805(n, k) = k == 0 ? k^n : binomial(n-1, k-1)
T097805(dim) = Triangle(dim, V097805)
```
Many number triangles can be efficiently implemented by recurrence.
To support this the type RecTriangle has a buffer which saves the
previously computed row. This buffer can be accessed through a function 'prevrow'.
* Triangle T097805 based on recurrence.
```
R097805(n, k, prevrow) = k == 0 ? k^n : prevrow(k-1) + prevrow(k)
T097805(dim) = RecTriangle(dim, R097805)
```
This function is much more efficient than the version above. Note that you do not have
to provide the function prevrow as long as you use the function R097805 in the definition
of a triangle. The name 'prevrow' is not fixed but recommended as a convention.
A nice alternative for 'prevrow' is 'Tn_1' because Tn_1(k) = T(n-1, k) in matrix notation.
#### Triangle tools
The following functions are supplied:
* Return the row n (0 <= n < dim) of a triangle.
```
Row(T::Triangle, n::Int, rev=true) = rev ? reversed(T(n)) : T(n)
```
If in the call the third -- optional -- parameter `rev` is true the
row is returned in reversed order.
* Return the triangle as a list of rows.
```
TriangularArray(T::Triangle) = [row for row in T]
```
* Return the triangle as a list of integers.
```
TriangleToList(T::Triangle) = [k for row in T for k in row]
```
Thus applying TriangleToList to a triangle of dimension dim
returns a list of integers of length dim(dim + 1)/2. Conversely, given
an integer list of length n(n + 1)/2 the function ListToTriangle returns a
triangle as a chain of iterators.
```
ListToTriangle(A::Array{})
```
## Notebook
More examples can be found in this [Jupyter notebook](https://github.com/OpenLibMathSeq/IntegerSequences.jl/blob/master/demos/SequencesIntro.ipynb).
## Contribute!
Sequences are fun!
* Start with cloning the module [NarayanaCows](https://github.com/OpenLibMathSeq/IntegerSequences.jl/blob/master/src/NarayanaCows.jl)
as a blueprint. Replace what is to be replaced.
* Execute the module 'BuildSequences' which will integrate your module into 'IntegerSequences'.
* Send us a pull request.
We want to include only sequences which are of mathematical interest.
Please make sure that they are already documented in the Online Encyclopedia of
Integer Sequences, otherwise please submit them first to the OEIS.
We prefer parametrized sequences (family of sequences) over single ones and
triangles (family of polynomials) over straight sequences. Implementations of
sequence-to-sequence transformations are always welcome. See the developer guide for more hints.