Binomial transform
You are encouraged to solve this task according to the task description, using any language you may know.
The binomial transform is a bijective sequence transform based on convolution with binomial coefficients.
It may be thought of as an nth forward difference with odd differences carrying a negative sign.
There are two common variants of binomial transforms, one of which is self-inverting; reapplying the transform to a transformed sequence returns the original sequence, and one which has separate "forward" and "inverse" transform operations.
The two variants only differ in placement and quantity of signs. The variant standardized on by OEIS, with the 'forward' and 'inverse' complementary operations, will be used here.
In this variant, to transform the sequence a to sequence b and back:
the forward binomial transform is defined as:
and the inverse binomial transform is defined as:
where is the binomial operator 'n choose k'
For reference, the self inverting binomial transform is defined as:
- Task
- Implement both a forward, and inverse binomial transform routine.
- Use those routines to compute the forward binomial transform, the inverse binomial transform, and the inverse of the forward transform (should return original sequence) of a few representative sequences.
- Show at least the first 15 values in each sequence.
- You may generate the sequences, or may choose to just hard code the values.
- Use the following sequences for testing:
- Catalan numbers:
1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 - Prime flip flop sequence: (for an: 1 if prime, 0 otherwise):
0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 - Fibonacci sequence:
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 - Padovan sequence: (starting with values 1,0,0):
1 0 0 1 0 1 1 1 2 2 3 4 5 7 9
- Catalan numbers:
- See also
- first sequence
- second sequence
- third sequence
- fourth sequence
Assumes LONG INT is at least 64 bits, as in Algol 68G.
BEGIN # binomial transform - translation of the C sample #
# returns factorial n, n must be at most 20 #
PROC factorial = ( INT n )LONG INT:
IF n > 20 THEN 0 # too big for LONG INT #
ELSE
LONG INT factorial n := 1;
FOR i FROM 2 TO n DO factorial n *:= i OD;
factorial n
FI # factorial # ;
# returns the binomial coefficient ( n k ) #
PROC binomial = ( INT n, k )LONG INT:
factorial( n ) OVER factorial( n - k ) OVER factorial( k );
# sets n to the forward transform of a #
PROC bt forward = ( REF[]LONG INT b, []LONG INT a )VOID:
BEGIN
REF[]LONG INT b0 = b[ AT 0 ];
[]LONG INT a0 = a[ AT 0 ];
FOR n FROM 0 TO UPB b0 DO
b0[ n ] := 0;
FOR k FROM 0 TO n DO b0[ n ] +:= binomial( n, k ) * a0[ k ] OD
OD
END # bt forward # ;
# sets a to the inverse transform of b #
PROC bt inverse = ( REF[]LONG INT a, []LONG INT b )VOID:
BEGIN
REF[]LONG INT a0 = a[ AT 0 ];
[]LONG INT b0 = b[ AT 0 ];
FOR n FROM 0 TO UPB a0 DO
a0[ n ] := 0;
FOR k FROM 0 TO n DO
a0[ n ] +:= binomial( n, k ) * b0[ k ] * IF ODD ( n - k ) THEN -1 ELSE 1 FI
OD
OD
END # bt inverse # ;
# sets b to the self inverse of a #
PROC bt self inverting = ( REF[]LONG INT b, []LONG INT a )VOID:
BEGIN
REF[]LONG INT b0 = b[ AT 0 ];
[]LONG INT a0 = a[ AT 0 ];
FOR n FROM 0 TO UPB b0 DO
b0[ n ] := 0;
FOR k FROM 0 TO n DO
b0[ n ] +:= binomial( n, k ) * a0[ k ] * IF ODD k THEN -1 ELSE 1 FI
OD
OD
END # bt self inverse # ;
# task test cases #
[][]LONG INT seqs = ( ( 1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862
, 16796, 58786, 208012, 742900, 2674440, 9694845
, 35357670, 129644790, 477638700, 1767263190
)
, ( 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0 )
, ( 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144
, 233, 377, 610, 987, 1597, 2584, 4181
)
, ( 1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37 )
);
[ 1 : UPB seqs[ LWB seqs ] ]LONG INT fwd, res;
[]STRING names = ( "Catalan number sequence:"
, "Prime flip-flop sequence:"
, "Fibonacci number sequence:"
, "Padovan number sequence:"
);
FOR i TO UPB seqs DO
print( ( names[ i ], newline ) );
FOR j TO UPB seqs[ i ] DO print( ( whole( seqs[ i ][ j ], 0 ), " " ) ) OD;
print( ( newline, "Forward binomial transform:", newline ) );
bt forward( fwd, seqs[ i ] );
FOR j TO UPB fwd DO print( ( whole( fwd[ j ], 0 ), " " ) ) OD;
print( ( newline, "Inverse binomial transform:", newline ) );
bt inverse( res, seqs[ i ] );
FOR j TO UPB res DO print( ( whole( res[ j ], 0 ), " " ) ) OD;
print( ( newline, "Round trip:", newline ) );
bt inverse( res, fwd );
FOR j TO UPB res DO print( ( whole( res[ j ], 0 ), " " ) ) OD;
print( ( newline, "Self-inverting:", newline ) );
bt self inverting( fwd, seqs[ i ] );
FOR j TO UPB fwd DO print( ( whole( fwd[ j ], 0 ), " " ) ) OD;
print( ( newline, "Re-inverted:", newline ) );
bt self inverting( res, fwd );
FOR j TO UPB res DO print( ( whole( res[ j ], 0 ), " " ) ) OD;
IF i < UPB seqs THEN print( ( newline, newline ) ) ELSE print( ( newline ) ) FI
OD
END- Output:
(same as the C sample)
Catalan number sequence: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 35357670 129644790 477638700 1767263190 Forward binomial transform: 1 2 5 15 51 188 731 2950 12235 51822 223191 974427 4302645 19181100 86211885 390248055 1777495635 8140539950 37463689775 173164232965 Inverse binomial transform: 1 0 1 1 3 6 15 36 91 232 603 1585 4213 11298 30537 83097 227475 625992 1730787 4805595 Round trip: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 35357670 129644790 477638700 1767263190 Self-inverting: 1 0 1 -1 3 -6 15 -36 91 -232 603 -1585 4213 -11298 30537 -83097 227475 -625992 1730787 -4805595 Re-inverted: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 35357670 129644790 477638700 1767263190 Prime flip-flop sequence: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Forward binomial transform: 0 1 3 6 11 20 37 70 134 255 476 869 1564 2821 5201 9948 19793 40562 84271 174952 Inverse binomial transform: 0 1 -1 0 3 -10 25 -56 118 -237 456 -847 1540 -2795 5173 -9918 19761 -40528 84235 -174914 Round trip: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Self-inverting: 0 -1 -1 0 3 10 25 56 118 237 456 847 1540 2795 5173 9918 19761 40528 84235 174914 Re-inverted: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Fibonacci number sequence: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Forward binomial transform: 0 1 3 8 21 55 144 377 987 2584 6765 17711 46368 121393 317811 832040 2178309 5702887 14930352 39088169 Inverse binomial transform: 0 1 -1 2 -3 5 -8 13 -21 34 -55 89 -144 233 -377 610 -987 1597 -2584 4181 Round trip: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Self-inverting: 0 -1 -1 -2 -3 -5 -8 -13 -21 -34 -55 -89 -144 -233 -377 -610 -987 -1597 -2584 -4181 Re-inverted: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Padovan number sequence: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37 Forward binomial transform: 1 1 1 2 5 12 28 65 151 351 816 1897 4410 10252 23833 55405 128801 299426 696081 1618192 Inverse binomial transform: 1 -1 1 0 -3 10 -24 49 -89 145 -208 245 -174 -176 1121 -3185 7137 -13920 24301 -37926 Round trip: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37 Self-inverting: 1 1 1 0 -3 -10 -24 -49 -89 -145 -208 -245 -174 176 1121 3185 7137 13920 24301 37926 Re-inverted: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37
choose: function [n k][
div div factorial n factorial n - k factorial k
]
forward: function [a][
map 0..dec size a 'n ->
sum map 0..n 'k ->
a\[k] * choose n k
]
inverse: function [b][
map 0..dec size b 'n ->
sum map 0..n 'k ->
b\[k] * mul choose n k pow neg 1 n - k
]
loop [
"Catalan" [1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 35357670 129644790 477638700 1767263190]
"Prime flip-flop" [0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0]
"Fibonacci" [0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181]
"Padovan" [1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37]
] [name seq] [
print ~« -~~=====<{ |name| }>=====~~-
print seq
print "Forward binomial transform:"
print fwd: <= forward seq
print "Inverse binomial transform:"
print inverse seq
print "Round trip:"
print inverse fwd
print ""
]
- Output:
-~~=====<{ Catalan }>=====~~-
1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 35357670 129644790 477638700 1767263190
Forward binomial transform:
1 2 5 15 51 188 731 2950 12235 51822 223191 974427 4302645 19181100 86211885 390248055 1777495635 8140539950 37463689775 173164232965
Inverse binomial transform:
1 0 1 1 3 6 15 36 91 232 603 1585 4213 11298 30537 83097 227475 625992 1730787 4805595
Round trip:
1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 35357670 129644790 477638700 1767263190
-~~=====<{ Prime flip-flop }>=====~~-
0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0
Forward binomial transform:
0 1 3 6 11 20 37 70 134 255 476 869 1564 2821 5201 9948 19793 40562 84271 174952
Inverse binomial transform:
0 1 -1 0 3 -10 25 -56 118 -237 456 -847 1540 -2795 5173 -9918 19761 -40528 84235 -174914
Round trip:
0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0
-~~=====<{ Fibonacci }>=====~~-
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181
Forward binomial transform:
0 1 3 8 21 55 144 377 987 2584 6765 17711 46368 121393 317811 832040 2178309 5702887 14930352 39088169
Inverse binomial transform:
0 1 -1 2 -3 5 -8 13 -21 34 -55 89 -144 233 -377 610 -987 1597 -2584 4181
Round trip:
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181
-~~=====<{ Padovan }>=====~~-
1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37
Forward binomial transform:
1 1 1 2 5 12 28 65 151 351 816 1897 4410 10252 23833 55405 128801 299426 696081 1618192
Inverse binomial transform:
1 -1 1 0 -3 10 -24 49 -89 145 -208 245 -174 -176 1121 -3185 7137 -13920 24301 -37926
Round trip:
1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37
#include <stdio.h>
#include <stdint.h>
uint64_t factorial(int n) {
if (n > 20) return 0; // too big for uint64_t
if (n < 2) return 1;
uint64_t fact = 1;
int i = 2;
for (i = 2; i <= n; ++i) fact *= i;
return fact;
}
uint64_t binomial(int n, int k) {
return factorial(n) / factorial(n-k) / factorial(k);
}
void btForward(int64_t b[], const int64_t a[], size_t c) {
int n, k;
for (n = 0; n < c; ++n) {
b[n] = 0;
for (k = 0; k <= n; ++k) {
b[n] += (int64_t)binomial(n, k) * a[k];
}
}
}
void btInverse(int64_t a[], const int64_t b[], size_t c) {
int n, k, sign;
for (n = 0; n < c; ++n) {
a[n] = 0;
for (k = 0; k <= n; ++k) {
sign = (n-k) & 1 ? -1 : 1;
a[n] += (int64_t)binomial(n, k) * b[k] * sign;
}
}
}
void btSelfInverting(int64_t b[], const int64_t a[], size_t c) {
int n, k, sign;
for (n = 0; n < c; ++n) {
b[n] = 0;
for (k = 0; k <= n; ++k) {
sign = k & 1 ? -1 : 1;
b[n] += (int64_t)binomial(n, k) * a[k] * sign;
}
}
}
int main() {
int i, j;
int64_t fwd[20], res[20], seqs[4][20] = {
{1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845, 35357670, 129644790, 477638700, 1767263190},
{0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0},
{0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181},
{1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37}
};
const char *names[4] = {
"Catalan number sequence:",
"Prime flip-flop sequence:",
"Fibonacci number sequence:",
"Padovan number sequence:"
};
for (i = 0; i < 4; ++i) {
printf("%s\n", names[i]);
for (j = 0; j < 20; ++j) printf("%ld ", seqs[i][j]);
printf("\nForward binomial transform:\n");
btForward(fwd, seqs[i], 20);
for (j = 0; j < 20; ++j) printf("%ld ", fwd[j]);
printf("\nInverse binomial transform:\n");
btInverse(res, seqs[i], 20);
for (j = 0; j < 20; ++j) printf("%ld ", res[j]);
printf("\nRound trip:\n");
btInverse(res, fwd, 20);
for (j = 0; j < 20; ++j) printf("%ld ", res[j]);
printf("\nSelf-inverting:\n");
btSelfInverting(fwd, seqs[i], 20);
for (j = 0; j < 20; ++j) printf("%ld ", fwd[j]);
printf("\nRe-inverted:\n");
btSelfInverting(res, fwd, 20);
for (j = 0; j < 20; ++j) printf("%ld ", res[j]);
if (i < 3) printf("\n\n"); else printf("\n");
}
return 0;
}
- Output:
Catalan number sequence: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 35357670 129644790 477638700 1767263190 Forward binomial transform: 1 2 5 15 51 188 731 2950 12235 51822 223191 974427 4302645 19181100 86211885 390248055 1777495635 8140539950 37463689775 173164232965 Inverse binomial transform: 1 0 1 1 3 6 15 36 91 232 603 1585 4213 11298 30537 83097 227475 625992 1730787 4805595 Round trip: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 35357670 129644790 477638700 1767263190 Self-inverting: 1 0 1 -1 3 -6 15 -36 91 -232 603 -1585 4213 -11298 30537 -83097 227475 -625992 1730787 -4805595 Re-inverted: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 35357670 129644790 477638700 1767263190 Prime flip-flop sequence: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Forward binomial transform: 0 1 3 6 11 20 37 70 134 255 476 869 1564 2821 5201 9948 19793 40562 84271 174952 Inverse binomial transform: 0 1 -1 0 3 -10 25 -56 118 -237 456 -847 1540 -2795 5173 -9918 19761 -40528 84235 -174914 Round trip: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Self-inverting: 0 -1 -1 0 3 10 25 56 118 237 456 847 1540 2795 5173 9918 19761 40528 84235 174914 Re-inverted: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Fibonacci number sequence: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Forward binomial transform: 0 1 3 8 21 55 144 377 987 2584 6765 17711 46368 121393 317811 832040 2178309 5702887 14930352 39088169 Inverse binomial transform: 0 1 -1 2 -3 5 -8 13 -21 34 -55 89 -144 233 -377 610 -987 1597 -2584 4181 Round trip: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Self-inverting: 0 -1 -1 -2 -3 -5 -8 -13 -21 -34 -55 -89 -144 -233 -377 -610 -987 -1597 -2584 -4181 Re-inverted: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Padovan number sequence: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37 Forward binomial transform: 1 1 1 2 5 12 28 65 151 351 816 1897 4410 10252 23833 55405 128801 299426 696081 1618192 Inverse binomial transform: 1 -1 1 0 -3 10 -24 49 -89 145 -208 245 -174 -176 1121 -3185 7137 -13920 24301 -37926 Round trip: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37 Self-inverting: 1 1 1 0 -3 -10 -24 -49 -89 -145 -208 -245 -174 176 1121 3185 7137 13920 24301 37926 Re-inverted: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37
using System;
public static class BinomialTransform
{
public static void Main()
{
long[][] sequences = new long[][]
{
new long[] { 1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845 },
new long[] { 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0 },
new long[] { 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181 },
new long[] { 1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37 }
};
string[] names = new string[]
{
"Catalan number sequence:",
"Prime flip-flop sequence:",
"Fibonacci number sequence:",
"Padovan number sequence:"
};
for (int i = 0; i < sequences.Length; i++)
{
Console.WriteLine(names[i]);
Console.WriteLine("[" + string.Join(", ", sequences[i]) + "]");
Console.WriteLine("Forward binomial transform:");
Console.WriteLine("[" + string.Join(", ", Forward(sequences[i])) + "]");
Console.WriteLine("Inverse binomial transform:");
Console.WriteLine("[" + string.Join(", ", Inverse(sequences[i])) + "]");
Console.WriteLine("Round trip:");
Console.WriteLine("[" + string.Join(", ", Inverse(Forward(sequences[i]))) + "]");
Console.WriteLine("Self-inverting:");
Console.WriteLine("[" + string.Join(", ", SelfInverting(sequences[i])) + "]");
Console.WriteLine("Round trip self-inverting:");
Console.WriteLine("[" + string.Join(", ", SelfInverting(SelfInverting(sequences[i]))) + "]");
Console.WriteLine();
}
}
private static long[] SelfInverting(long[] numbers)
{
long[] transform = new long[numbers.Length];
for (int n = 0; n < numbers.Length; n++)
{
for (int k = 0; k <= n; k++)
{
int sign = (k % 2 == 1) ? -1 : 1;
transform[n] += Binomial(n, k) * numbers[k] * sign;
}
}
return transform;
}
private static long[] Inverse(long[] numbers)
{
long[] transform = new long[numbers.Length];
for (int n = 0; n < numbers.Length; n++)
{
for (int k = 0; k <= n; k++)
{
int sign = ((n - k) % 2 == 1) ? -1 : 1;
transform[n] += Binomial(n, k) * numbers[k] * sign;
}
}
return transform;
}
private static long[] Forward(long[] numbers)
{
long[] transform = new long[numbers.Length];
for (int n = 0; n < numbers.Length; n++)
{
for (int k = 0; k <= n; k++)
{
transform[n] += Binomial(n, k) * numbers[k];
}
}
return transform;
}
private static long Binomial(int n, int k)
{
return Factorial(n) / Factorial(n - k) / Factorial(k);
}
private static long Factorial(int number)
{
if (number > 20)
{
throw new ArgumentException("Factorial of number is too large: " + number);
}
if (number < 2)
{
return 1;
}
long factorial = 1;
for (int i = 2; i <= number; i++)
{
factorial *= i;
}
return factorial;
}
}
- Output:
Catalan number sequence: [1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845] Forward binomial transform: [1, 2, 5, 15, 51, 188, 731, 2950, 12235, 51822, 223191, 974427, 4302645, 19181100, 86211885, 390248055] Inverse binomial transform: [1, 0, 1, 1, 3, 6, 15, 36, 91, 232, 603, 1585, 4213, 11298, 30537, 83097] Round trip: [1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845] Self-inverting: [1, 0, 1, -1, 3, -6, 15, -36, 91, -232, 603, -1585, 4213, -11298, 30537, -83097] Round trip self-inverting: [1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845] Prime flip-flop sequence: [0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0] Forward binomial transform: [0, 1, 3, 6, 11, 20, 37, 70, 134, 255, 476, 869, 1564, 2821, 5201, 9948, 19793, 40562, 84271, 174952] Inverse binomial transform: [0, 1, -1, 0, 3, -10, 25, -56, 118, -237, 456, -847, 1540, -2795, 5173, -9918, 19761, -40528, 84235, -174914] Round trip: [0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0] Self-inverting: [0, -1, -1, 0, 3, 10, 25, 56, 118, 237, 456, 847, 1540, 2795, 5173, 9918, 19761, 40528, 84235, 174914] Round trip self-inverting: [0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0] Fibonacci number sequence: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181] Forward binomial transform: [0, 1, 3, 8, 21, 55, 144, 377, 987, 2584, 6765, 17711, 46368, 121393, 317811, 832040, 2178309, 5702887, 14930352, 39088169] Inverse binomial transform: [0, 1, -1, 2, -3, 5, -8, 13, -21, 34, -55, 89, -144, 233, -377, 610, -987, 1597, -2584, 4181] Round trip: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181] Self-inverting: [0, -1, -1, -2, -3, -5, -8, -13, -21, -34, -55, -89, -144, -233, -377, -610, -987, -1597, -2584, -4181] Round trip self-inverting: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181] Padovan number sequence: [1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37] Forward binomial transform: [1, 1, 1, 2, 5, 12, 28, 65, 151, 351, 816, 1897, 4410, 10252, 23833, 55405, 128801, 299426, 696081, 1618192] Inverse binomial transform: [1, -1, 1, 0, -3, 10, -24, 49, -89, 145, -208, 245, -174, -176, 1121, -3185, 7137, -13920, 24301, -37926] Round trip: [1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37] Self-inverting: [1, 1, 1, 0, -3, -10, -24, -49, -89, -145, -208, -245, -174, 176, 1121, 3185, 7137, 13920, 24301, 37926] Round trip self-inverting: [1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37]
#include <algorithm>
#include <cstdint>
#include <iostream>
#include <iterator>
#include <ranges>
#include <stdexcept>
#include <string>
#include <vector>
template <typename T>
void print_vector(const std::vector<T>& vec) {
std::ranges::copy(vec, std::ostream_iterator<T>(std::cout, " "));
}
uint64_t factorial(const uint32_t& number) {
if ( number > 20 ) {
throw std::invalid_argument("Too large for 64 bit number: " + std::to_string(number));
}
if ( number < 2 ) {
return 1;
}
uint64_t factorial = 1;
for ( uint32_t i = 2; i <= number; ++i ) {
factorial *= i;
}
return factorial;
}
uint64_t binomial(const uint32_t& n, const uint32_t& k) {
return factorial(n) / factorial(n - k) / factorial(k);
}
std::vector<int64_t> forward(const std::vector<int64_t>& vec) {
std::vector<int64_t> transform(vec.size(), 0);
for ( uint32_t n = 0; n < vec.size(); ++n ) {
for ( uint32_t k = 0; k <= n; ++k ) {
transform[n] += binomial(n, k) * vec[k];
}
}
return transform;
}
std::vector<int64_t> inverse(const std::vector<int64_t>& vec) {
std::vector<int64_t> transform(vec.size(), 0);
for ( uint32_t n = 0; n < vec.size(); ++n ) {
for ( uint32_t k = 0; k <= n; ++k ) {
const int32_t sign = ( ( n - k ) & 1 ) ? -1 : 1;
transform[n] += binomial(n, k) * vec[k] * sign;
}
}
return transform;
}
std::vector<int64_t> self_inverting(const std::vector<int64_t> vec) {
std::vector<int64_t> transform(vec.size(), 0);
for ( uint32_t n = 0; n < vec.size(); ++n ) {
for ( uint32_t k = 0; k <= n; ++k ) {
const int32_t sign = ( k & 1 ) ? -1 : 1;
transform[n] += binomial(n, k) * vec[k] * sign;
}
}
return transform;
}
int main() {
const std::vector<std::vector<int64_t>> sequences = {
{ 1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845 },
{ 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0 },
{ 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181 },
{ 1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37 }
};
const std::vector<std::string> names = {
"Catalan number sequence:",
"Prime flip-flop sequence:",
"Fibonacci number sequence:",
"Padovan number sequence:"
};
for ( uint32_t i = 0; i < sequences.size(); ++i ) {
std::cout << names[i] << std::endl;
print_vector(sequences[i]);
std::cout << "\n" << "Forward binomial transform:" << std::endl;
print_vector(forward(sequences[i]));
std::cout << "\n" << "Inverse binomial transform:" << std::endl;
print_vector(inverse(sequences[i]));
std::cout << "\n" << "Round trip:" << std::endl;
print_vector(inverse(forward(sequences[i])));
std::cout << "\n" << "Self-inverting:" << std::endl;
print_vector(self_inverting(sequences[i]));
std::cout << "\n" << "Round trip self-inverting:" << std::endl;
print_vector(self_inverting(self_inverting(sequences[i])));
std::cout << std::endl << std::endl;
}
}
- Output:
Catalan number sequence: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 Forward binomial transform: 1 2 5 15 51 188 731 2950 12235 51822 223191 974427 4302645 19181100 86211885 390248055 Inverse binomial transform: 1 0 1 1 3 6 15 36 91 232 603 1585 4213 11298 30537 83097 Round trip: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 Self-inverting: 1 0 1 -1 3 -6 15 -36 91 -232 603 -1585 4213 -11298 30537 -83097 Round trip self-inverting: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 Prime flip-flop sequence: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Forward binomial transform: 0 1 3 6 11 20 37 70 134 255 476 869 1564 2821 5201 9948 19793 40562 84271 174952 Inverse binomial transform: 0 1 -1 0 3 -10 25 -56 118 -237 456 -847 1540 -2795 5173 -9918 19761 -40528 84235 -174914 Round trip: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Self-inverting: 0 -1 -1 0 3 10 25 56 118 237 456 847 1540 2795 5173 9918 19761 40528 84235 174914 Round trip self-inverting: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Fibonacci number sequence: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Forward binomial transform: 0 1 3 8 21 55 144 377 987 2584 6765 17711 46368 121393 317811 832040 2178309 5702887 14930352 39088169 Inverse binomial transform: 0 1 -1 2 -3 5 -8 13 -21 34 -55 89 -144 233 -377 610 -987 1597 -2584 4181 Round trip: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Self-inverting: 0 -1 -1 -2 -3 -5 -8 -13 -21 -34 -55 -89 -144 -233 -377 -610 -987 -1597 -2584 -4181 Round trip self-inverting: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Padovan number sequence: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37 Forward binomial transform: 1 1 1 2 5 12 28 65 151 351 816 1897 4410 10252 23833 55405 128801 299426 696081 1618192 Inverse binomial transform: 1 -1 1 0 -3 10 -24 49 -89 145 -208 245 -174 -176 1121 -3185 7137 -13920 24301 -37926 Round trip: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37 Self-inverting: 1 1 1 0 -3 -10 -24 -49 -89 -145 -208 -245 -174 176 1121 3185 7137 13920 24301 37926 Round trip self-inverting: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37
import 'dart:math' as math;
void printVector(List<int> vec) {
print(vec.join(' '));
}
int factorial(int number) {
if (number > 20) {
throw ArgumentError('Too large for 64 bit number: $number');
}
if (number < 2) {
return 1;
}
int result = 1;
for (int i = 2; i <= number; i++) {
result *= i;
}
return result;
}
int binomial(int n, int k) {
return factorial(n) ~/ factorial(n - k) ~/ factorial(k);
}
List<int> forward(List<int> vec) {
List<int> transform = List.filled(vec.length, 0);
for (int n = 0; n < vec.length; n++) {
for (int k = 0; k <= n; k++) {
transform[n] += binomial(n, k) * vec[k];
}
}
return transform;
}
List<int> inverse(List<int> vec) {
List<int> transform = List.filled(vec.length, 0);
for (int n = 0; n < vec.length; n++) {
for (int k = 0; k <= n; k++) {
int sign = ((n - k) & 1) != 0 ? -1 : 1;
transform[n] += binomial(n, k) * vec[k] * sign;
}
}
return transform;
}
List<int> selfInverting(List<int> vec) {
List<int> transform = List.filled(vec.length, 0);
for (int n = 0; n < vec.length; n++) {
for (int k = 0; k <= n; k++) {
int sign = (k & 1) != 0 ? -1 : 1;
transform[n] += binomial(n, k) * vec[k] * sign;
}
}
return transform;
}
void main() {
final List<List<int>> sequences = [
[1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845],
[0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0],
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181],
[1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37]
];
final List<String> names = [
"Catalan number sequence:",
"Prime flip-flop sequence:",
"Fibonacci number sequence:",
"Padovan number sequence:"
];
for (int i = 0; i < sequences.length; i++) {
print(names[i]);
printVector(sequences[i]);
print("Forward binomial transform:");
printVector(forward(sequences[i]));
print("Inverse binomial transform:");
printVector(inverse(sequences[i]));
print("Round trip:");
printVector(inverse(forward(sequences[i])));
print("Self-inverting:");
printVector(selfInverting(sequences[i]));
print("Round trip self-inverting:");
printVector(selfInverting(selfInverting(sequences[i])));
print("\n");
}
}
- Output:
Catalan number sequence: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 Forward binomial transform: 1 2 5 15 51 188 731 2950 12235 51822 223191 974427 4302645 19181100 86211885 390248055 Inverse binomial transform: 1 0 1 1 3 6 15 36 91 232 603 1585 4213 11298 30537 83097 Round trip: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 Self-inverting: 1 0 1 -1 3 -6 15 -36 91 -232 603 -1585 4213 -11298 30537 -83097 Round trip self-inverting: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 Prime flip-flop sequence: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Forward binomial transform: 0 1 3 6 11 20 37 70 134 255 476 869 1564 2821 5201 9948 19793 40562 84271 174952 Inverse binomial transform: 0 1 -1 0 3 -10 25 -56 118 -237 456 -847 1540 -2795 5173 -9918 19761 -40528 84235 -174914 Round trip: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Self-inverting: 0 -1 -1 0 3 10 25 56 118 237 456 847 1540 2795 5173 9918 19761 40528 84235 174914 Round trip self-inverting: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Fibonacci number sequence: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Forward binomial transform: 0 1 3 8 21 55 144 377 987 2584 6765 17711 46368 121393 317811 832040 2178309 5702887 14930352 39088169 Inverse binomial transform: 0 1 -1 2 -3 5 -8 13 -21 34 -55 89 -144 233 -377 610 -987 1597 -2584 4181 Round trip: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Self-inverting: 0 -1 -1 -2 -3 -5 -8 -13 -21 -34 -55 -89 -144 -233 -377 -610 -987 -1597 -2584 -4181 Round trip self-inverting: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Padovan number sequence: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37 Forward binomial transform: 1 1 1 2 5 12 28 65 151 351 816 1897 4410 10252 23833 55405 128801 299426 696081 1618192 Inverse binomial transform: 1 -1 1 0 -3 10 -24 49 -89 145 -208 245 -174 -176 1121 -3185 7137 -13920 24301 -37926 Round trip: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37 Self-inverting: 1 1 1 0 -3 -10 -24 -49 -89 -145 -208 -245 -174 176 1121 3185 7137 13920 24301 37926 Round trip self-inverting: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37
To simplify exposition and usage, the main DuckDB program is shown separately from a DuckDB script (here called rc-sequence.sql) that can be run separately for each of the named number sequences.
# nCk assuming n >= r
# The caller should ensure 2r < n
create or replace function binomial(n, r) as
(with recursive cte as
(SELECT 1::HUGEINT as c, n as numerator, 1::HUGEINT as m
UNION ALL
SELECT (c * numerator / m) as c,
(numerator - 1) as numerator,
(m + 1) as m
FROM cte
WHERE m <= r
)
SELECT last(c order by m)
FROM cte
);
create or replace function forward(a) as (
select array_agg((select sum( binomial(n, k) * a[k+1] )
from range(0, n+1) as u(k) ))
from range(0, length(a)) as t(n)
);
create or replace function inverse(b) as (
select array_agg((select sum( binomial(n, k) * b[k+1]
* if ( (n - k) % 2 = 0, 1, -1))
from range(0, n+1) as u(k)))
from range (0, length(b)) as t(n)
);
create or replace function selfInverting(a) as (
select array_agg((select sum( binomial(n, k) * a[k+1]
* if( k % 2 = 0, 1, -1) )
from range(0, n+1) as u(k) ))
from range(0, length(a)) as t(n)
);
create or replace function roundTrip(a) as (
inverse( (select forward(a)) )
);
create or replace function selfInvertSelfInvert(a) as (
selfInverting( (select selfInverting(a)) )
);
## Pretty print
create or replace function pp(lst) as array_to_string(lst, ' ');
### The names of the integer sequences
set variable sequenceName = [
'Catalan number sequence:',
'Prime flip-flop sequence:',
'Fibonacci number sequence:',
'Padovan number sequence:'
];
set variable sequence = [
[1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845, 35357670, 129644790, 477638700, 1767263190],
[0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0],
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181],
[1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37]
];
Contents of rc-sequence.sql
.mode list
.header off
select getvariable('sequenceName')[getvariable('i')];
select repeat('-', length(getvariable('sequenceName')[getvariable('i')]));
select pp(getvariable('sequence')[getvariable('i')]);
.print
.print Forward binomial transform:
select pp( forward( getvariable('sequence')[getvariable('i') ]));
.print
.print Inverse binomial transform:
select pp( inverse( getvariable('sequence')[getvariable('i') ]));
select eq as "round-trip"
from (select getvariable('sequence')[getvariable('i')] as l, l = roundTrip(l) as eq);
.print
.print Self-inverting:
select pp( selfInverting( getvariable('sequence')[getvariable('i') ]));
select eq as "self-inverting"
from (select getvariable('sequence')[getvariable('i')] as l, l = selfInvertSelfInvert(l) as eq);
.print
- Output:
In conjunction with the main program, the following two lines produce the output shown below: set variable i=1; .read rc-sequence.sql
Catalan number sequence: ------------------------ 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 35357670 129644790 477638700 1767263190 Forward binomial transform: 1 2 5 15 51 188 731 2950 12235 51822 223191 974427 4302645 19181100 86211885 390248055 1777495635 8140539950 37463689775 173164232965 Inverse binomial transform: 1 0 1 1 3 6 15 36 91 232 603 1585 4213 11298 30537 83097 227475 625992 1730787 4805595 true Self-inverting: 1 0 1 -1 3 -6 15 -36 91 -232 603 -1585 4213 -11298 30537 -83097 227475 -625992 1730787 -4805595 true
And similarly for other valid values of i:
Prime flip-flop sequence: ------------------------- 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Forward binomial transform: 0 1 3 6 11 20 37 70 134 255 476 869 1564 2821 5201 9948 19793 40562 84271 174952 Inverse binomial transform: 0 1 -1 0 3 -10 25 -56 118 -237 456 -847 1540 -2795 5173 -9918 19761 -40528 84235 -174914 true Self-inverting: 0 -1 -1 0 3 10 25 56 118 237 456 847 1540 2795 5173 9918 19761 40528 84235 174914 true Fibonacci number sequence: -------------------------- 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Forward binomial transform: 0 1 3 8 21 55 144 377 987 2584 6765 17711 46368 121393 317811 832040 2178309 5702887 14930352 39088169 Inverse binomial transform: 0 1 -1 2 -3 5 -8 13 -21 34 -55 89 -144 233 -377 610 -987 1597 -2584 4181 true Self-inverting: 0 -1 -1 -2 -3 -5 -8 -13 -21 -34 -55 -89 -144 -233 -377 -610 -987 -1597 -2584 -4181 true Padovan number sequence: ------------------------ 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37 Forward binomial transform: 1 1 1 2 5 12 28 65 151 351 816 1897 4410 10252 23833 55405 128801 299426 696081 1618192 Inverse binomial transform: 1 -1 1 0 -3 10 -24 49 -89 145 -208 245 -174 -176 1121 -3185 7137 -13920 24301 -37926 true Self-inverting: 1 1 1 0 -3 -10 -24 -49 -89 -145 -208 -245 -174 176 1121 3185 7137 13920 24301 37926 true
func factorial n .
f = 1
for i = 2 to n : f *= i
return f
.
func binomial n k .
return factorial n / factorial (n - k) / factorial k
.
func[] btForward a[] .
len b[] len a[]
for n range0 len a[]
for k = 0 to n
b[n + 1] += binomial n k * a[k + 1]
.
.
return b[]
.
func[] btInverse b[] .
len a[] len b[]
for n range0 len b[]
for k = 0 to n
h = binomial n k * b[k + 1]
if bitand (n - k) 1 > 0 : h *= -1
a[n + 1] += h
.
.
return a[]
.
func[] btSelfInverting a[] .
len b[] len a[]
for n range0 len a[]
for k = 0 to n
h = binomial n k * a[k + 1]
if bitand k 1 > 0 : h *= -1
b[n + 1] += h
.
.
return b[]
.
seqs[][] = [ [ 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 35357670 129644790 477638700 1767263190 ] [ 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 ] [ 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 ] [ 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37 ] ]
names$[] = [ "Catalan number sequence:" "Prime flip-flop sequence:" "Fibonacci number sequence:" "Padovan number sequence:" ]
for i to 4
print names$[i]
print seqs[i][]
print "Forward binomial transform:"
fwd[] = btForward seqs[i][]
print fwd[]
print "Inverse binomial transform:"
print btInverse seqs[i][]
print "Round trip:"
print btInverse fwd[]
print "Self-inverting:"
fwd[] = btSelfInverting seqs[i][]
print fwd[]
print "Re-inverted:"
print btSelfInverting fwd[]
print ""
.- Output:
Catalan number sequence: [ 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 35357670 129644790 477638700 1767263190 ] Forward binomial transform: [ 1 2 5 15 51 188 731 2950 12235 51822 223191 974427 4302645 19181100 86211885 390248055 1777495635 8140539950 37463689775 173164232965 ] Inverse binomial transform: [ 1 0 1 1 3 6 15 36 91 232 603 1585 4213 11298 30537 83097 227475 625992 1730787 4805595 ] Round trip: [ 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 35357670 129644790 477638700 1767263190 ] Self-inverting: [ 1 0 1 -1 3 -6 15 -36 91 -232 603 -1585 4213 -11298 30537 -83097 227475 -625992 1730787 -4805595 ] Re-inverted: [ 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 35357670 129644790 477638700 1767263190 ] Prime flip-flop sequence: [ 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 ] Forward binomial transform: [ 0 1 3 6 11 20 37 70 134 255 476 869 1564 2821 5201 9948 19793 40562 84271 174952 ] Inverse binomial transform: [ 0 1 -1 0 3 -10 25 -56 118 -237 456 -847 1540 -2795 5173 -9918 19761 -40528 84235 -174914 ] Round trip: [ 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 ] Self-inverting: [ 0 -1 -1 0 3 10 25 56 118 237 456 847 1540 2795 5173 9918 19761 40528 84235 174914 ] Re-inverted: [ 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 ] Fibonacci number sequence: [ 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 ] Forward binomial transform: [ 0 1 3 8 21 55 144 377 987 2584 6765 17711 46368 121393 317811 832040 2178309 5702887 14930352 39088169 ] Inverse binomial transform: [ 0 1 -1 2 -3 5 -8 13 -21 34 -55 89 -144 233 -377 610 -987 1597 -2584 4181 ] Round trip: [ 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 ] Self-inverting: [ 0 -1 -1 -2 -3 -5 -8 -13 -21 -34 -55 -89 -144 -233 -377 -610 -987 -1597 -2584 -4181 ] Re-inverted: [ 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 ] Padovan number sequence: [ 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37 ] Forward binomial transform: [ 1 1 1 2 5 12 28 65 151 351 816 1897 4410 10252 23833 55405 128801 299426 696081 1618192 ] Inverse binomial transform: [ 1 -1 1 0 -3 10 -24 49 -89 145 -208 245 -174 -176 1121 -3185 7137 -13920 24301 -37926 ] Round trip: [ 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37 ] Self-inverting: [ 1 1 1 0 -3 -10 -24 -49 -89 -145 -208 -245 -174 176 1121 3185 7137 13920 24301 37926 ] Re-inverted: [ 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37 ]
Type LongNumber
As Double value
End Type
' Calculate binomial coefficient
Function binomial(n As Integer, k As Integer) As Double
If k > n Then Return 0
If k = 0 Or k = n Then Return 1
Dim As Double result = 1
k = Iif(k > n - k, n - k, k)
For i As Integer = 0 To k - 1
result *= (n - i)
result /= (i + 1)
Next
Return result
End Function
' Forward binomial transform
Sub binomialFwd(seq() As Double, result() As Double, longit As Integer)
Dim As Integer n, k
For n = 0 To longit - 1
result(n) = 0
For k = 0 To n
result(n) += binomial(n, k) * seq(k)
Next
Next
End Sub
' Inverse binomial transform
Sub binomialInv(seq() As Double, result() As Double, longit As Integer)
Dim As Integer n, k, sign
For n = 0 To longit - 1
result(n) = 0
For k = 0 To n
sign = Iif((n - k) Mod 2 = 0, 1, -1)
result(n) += sign * binomial(n, k) * seq(k)
Next
Next
End Sub
' Self-inverting binomial transform
Sub binomialSelfInv(seq() As Double, result() As Double, longit As Integer)
Dim As Integer n, k, sign
For n = 0 To longit - 1
result(n) = 0
For k = 0 To n
sign = Iif(k Mod 2 = 0, 1, -1)
result(n) += sign * binomial(n, k) * seq(k)
Next
Next
End Sub
' Print array helper
Sub printSequence(seq() As Double, longit As Integer)
For i As Integer = 0 To longit - 1
Print Str(Int(seq(i))); " ";
Next
Print
End Sub
' Test sequences
Const LIM = 20
Dim Shared As Double catalan(LIM-1) = {1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845, 35357670, 129644790, 477638700, 1767263190}
Dim Shared As Double primes(LIM-1) = {0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0}
Dim Shared As Double fibonacci(LIM-1) = {0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181}
Dim Shared As Double padovan(LIM-1) = {1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37}
Dim As Double forwardResult(LIM-1)
Dim As Double inverseResult(LIM-1)
Dim As Double selfResult(LIM-1)
Dim As Double tempResult(LIM-1)
Dim As Double tempSeq(LIM-1)
' Test each sequence
Dim As String sequences(3) = { _
"Catalan number sequence:", "Prime flip-flop sequence:", _
"Fibonacci number sequence:", "Padovan number sequence:" }
Dim As Integer i, j
For i = 0 To 3
Print sequences(i)
' Copy the appropriate sequence to tempSeq
Select Case i
Case 0: For j = 0 To LIM-1: tempSeq(j) = catalan(j) : Next
Case 1: For j = 0 To LIM-1: tempSeq(j) = primes(j) : Next
Case 2: For j = 0 To LIM-1: tempSeq(j) = fibonacci(j): Next
Case 3: For j = 0 To LIM-1: tempSeq(j) = padovan(j) : Next
End Select
printSequence(tempSeq(), LIM)
Print "Forward binomial transform:"
binomialFwd(tempSeq(), forwardResult(), LIM)
printSequence(forwardResult(), LIM)
Print "Inverse binomial transform:"
binomialInv(tempSeq(), inverseResult(), LIM)
printSequence(inverseResult(), LIM)
Print "Round trip:"
binomialInv(forwardResult(), tempResult(), LIM)
printSequence(tempResult(), LIM)
Print "Self-inverting:"
binomialSelfInv(tempSeq(), selfResult(), LIM)
printSequence(selfResult(), LIM)
Print "Re-inverted:"
binomialSelfInv(selfResult(), tempResult(), LIM)
printSequence(tempResult(), LIM)
If i < 3 Then Print
Next
Sleep
- Output:
Catalan number sequence: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 35357670 129644790 477638700 1767263190 Forward binomial transform: 1 2 5 15 51 188 731 2950 12235 51822 223191 974427 4302645 19181100 86211885 390248055 1777495635 8140539950 37463689775 173164232965 Inverse binomial transform: 1 0 1 1 3 6 15 36 91 232 603 1585 4213 11298 30537 83097 227475 625992 1730787 4805595 Round trip: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 35357670 129644790 477638700 1767263190 Self-inverting: 1 0 1 -1 3 -6 15 -36 91 -232 603 -1585 4213 -11298 30537 -83097 227475 -625992 1730787 -4805595 Re-inverted: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 35357670 129644790 477638700 1767263190 Prime flip-flop sequence: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Forward binomial transform: 0 1 3 6 11 20 37 70 134 255 476 869 1564 2821 5201 9948 19793 40562 84271 174952 Inverse binomial transform: 0 1 -1 0 3 -10 25 -56 118 -237 456 -847 1540 -2795 5173 -9918 19761 -40528 84235 -174914 Round trip: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Self-inverting: 0 -1 -1 0 3 10 25 56 118 237 456 847 1540 2795 5173 9918 19761 40528 84235 174914 Re-inverted: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Fibonacci number sequence: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Forward binomial transform: 0 1 3 8 21 55 144 377 987 2584 6765 17711 46368 121393 317811 832040 2178309 5702887 14930352 39088169 Inverse binomial transform: 0 1 -1 2 -3 5 -8 13 -21 34 -55 89 -144 233 -377 610 -987 1597 -2584 4181 Round trip: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Self-inverting: 0 -1 -1 -2 -3 -5 -8 -13 -21 -34 -55 -89 -144 -233 -377 -610 -987 -1597 -2584 -4181 Re-inverted: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Padovan number sequence: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37 Forward binomial transform: 1 1 1 2 5 12 28 65 151 351 816 1897 4410 10252 23833 55405 128801 299426 696081 1618192 Inverse binomial transform: 1 -1 1 0 -3 10 -24 49 -89 145 -208 245 -174 -176 1121 -3185 7137 -13920 24301 -37926 Round trip: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37 Self-inverting: 1 1 1 0 -3 -10 -24 -49 -89 -145 -208 -245 -174 176 1121 3185 7137 13920 24301 37926 Re-inverted: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37
package main
import "fmt"
func factorial(n int) uint64 {
if n > 20 {
return 0 // too big for uint64
}
if n < 2 {
return 1
}
fact := uint64(1)
i := 2
for i <= n {
fact *= uint64(i)
i++
}
return fact
}
func binomial(n, k int) uint64 {
return factorial(n) / factorial(n-k) / factorial(k)
}
func btForward(a []int64) []int64 {
c := len(a)
b := make([]int64, c)
for n := 0; n < c; n++ {
b[n] = int64(0)
for k := 0; k <= n; k++ {
b[n] += int64(binomial(n, k)) * a[k]
}
}
return b
}
func btInverse(b []int64) []int64 {
c := len(b)
a := make([]int64, c)
for n := 0; n < c; n++ {
a[n] = int64(0)
for k := 0; k <= n; k++ {
sign := int64(-1)
if (n-k)&1 == 0 {
sign = 1
}
a[n] += int64(binomial(n, k)) * b[k] * sign
}
}
return a
}
func btSelfInverting(a []int64) []int64 {
c := len(a)
b := make([]int64, c)
for n := 0; n < c; n++ {
b[n] = int64(0)
for k := 0; k <= n; k++ {
sign := int64(-1)
if k&1 == 0 {
sign = 1
}
b[n] += int64(binomial(n, k)) * a[k] * sign
}
}
return b
}
func main() {
seqs := [][]int64{
{1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845, 35357670, 129644790, 477638700, 1767263190},
{0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0},
{0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181},
{1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37},
}
names := []string{
"Catalan number sequence:",
"Prime flip-flop sequence:",
"Fibonacci number sequence:",
"Padovan number sequence:",
}
for i, seq := range seqs {
fmt.Println(names[i])
fmt.Println(seq)
fmt.Println("Forward binomial transform:")
fwd := btForward(seq)
fmt.Println(fwd)
fmt.Println("Inverse binomial transform:")
fmt.Println(btInverse(seq))
fmt.Println("Round trip:")
fmt.Println(btInverse(fwd))
fmt.Println("Self-inverting:")
si := btSelfInverting(seq)
fmt.Println(si)
fmt.Println("Re-inverted:")
fmt.Println(btSelfInverting(si))
if i < len(seqs)-1 {
fmt.Println()
}
}
}
- Output:
Catalan number sequence: [1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 35357670 129644790 477638700 1767263190] Forward binomial transform: [1 2 5 15 51 188 731 2950 12235 51822 223191 974427 4302645 19181100 86211885 390248055 1777495635 8140539950 37463689775 173164232965] Inverse binomial transform: [1 0 1 1 3 6 15 36 91 232 603 1585 4213 11298 30537 83097 227475 625992 1730787 4805595] Round trip: [1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 35357670 129644790 477638700 1767263190] Self-inverting: [1 0 1 -1 3 -6 15 -36 91 -232 603 -1585 4213 -11298 30537 -83097 227475 -625992 1730787 -4805595] Re-inverted: [1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 35357670 129644790 477638700 1767263190] Prime flip-flop sequence: [0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0] Forward binomial transform: [0 1 3 6 11 20 37 70 134 255 476 869 1564 2821 5201 9948 19793 40562 84271 174952] Inverse binomial transform: [0 1 -1 0 3 -10 25 -56 118 -237 456 -847 1540 -2795 5173 -9918 19761 -40528 84235 -174914] Round trip: [0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0] Self-inverting: [0 -1 -1 0 3 10 25 56 118 237 456 847 1540 2795 5173 9918 19761 40528 84235 174914] Re-inverted: [0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0] Fibonacci number sequence: [0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181] Forward binomial transform: [0 1 3 8 21 55 144 377 987 2584 6765 17711 46368 121393 317811 832040 2178309 5702887 14930352 39088169] Inverse binomial transform: [0 1 -1 2 -3 5 -8 13 -21 34 -55 89 -144 233 -377 610 -987 1597 -2584 4181] Round trip: [0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181] Self-inverting: [0 -1 -1 -2 -3 -5 -8 -13 -21 -34 -55 -89 -144 -233 -377 -610 -987 -1597 -2584 -4181] Re-inverted: [0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181] Padovan number sequence: [1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37] Forward binomial transform: [1 1 1 2 5 12 28 65 151 351 816 1897 4410 10252 23833 55405 128801 299426 696081 1618192] Inverse binomial transform: [1 -1 1 0 -3 10 -24 49 -89 145 -208 245 -174 -176 1121 -3185 7137 -13920 24301 -37926] Round trip: [1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37] Self-inverting: [1 1 1 0 -3 -10 -24 -49 -89 -145 -208 -245 -174 176 1121 3185 7137 13920 24301 37926] Re-inverted: [1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37]
Main:
module Main (main) where
import Control.Monad (forM_)
import Lib
main :: IO ()
main = forM_ seqs testSeq
where
testSeq (n, s) = do
print $ n <> ": " <> show s
print $ " Forward: " <> show (forward s)
print $ " Inverse: " <> show (inverse s)
print $ " Self: " <> show (self s)
print $ " Inverse of Forward: " <> show (inverse (forward s))
print $ " Self of Self: " <> show (self (self s))
seqs :: [(String, [Integer])]
seqs =
[
("Catalan", [1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440]),
("Prime flip flop", [0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0]),
("Fibonacci", [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377]),
("Padovan", [1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9])
]
Library:
module Lib (forward, inverse, self) where
-- Forward, inverse and self-inverting transformation differ only in potential negation of some summands
-- expressed as a list (for each term) of lists (for each summand) of negation or no negation (identity).
forward :: [Integer] -> [Integer]
forward = transform (repeat $ repeat id)
-- No negation at all.
inverse :: [Integer] -> [Integer]
inverse = transform (iterate (drop 1) $ cycle [id, negate])
-- Summands alternate between negation and no negation, next term starts with the opposite correction.
self :: [Integer] -> [Integer]
self = transform (repeat $ cycle [id, negate])
-- Summands alternate between negation and no negation, all terms use the same correction.
transform :: [[Integer -> Integer]] -> [Integer] -> [Integer]
transform sgn a = zipWith compute sgn (take (length a) pascal)
where
-- Compute a new term: First, multiply binomial coefficient from the respective pascal's triangle
-- row with all previous terms, then apply signum correction to individual summands and sum them.
compute fun row = sum $ zipWith ($) fun $ zipWith (*) row a
-- Generate the Pascal's triangle as an infinite List
pascal :: [[Integer]]
pascal = iterate (\row -> zipWith (+) (0 : row) (row ++ [0])) [1]
- Output:
"Catalan: [1,1,2,5,14,42,132,429,1430,4862,16796,58786,208012,742900,2674440]" " Forward: [1,2,5,15,51,188,731,2950,12235,51822,223191,974427,4302645,19181100,86211885]" " Inverse: [1,0,1,1,3,6,15,36,91,232,603,1585,4213,11298,30537]" " Self: [1,0,1,-1,3,-6,15,-36,91,-232,603,-1585,4213,-11298,30537]" " Inverse of Forward: [1,1,2,5,14,42,132,429,1430,4862,16796,58786,208012,742900,2674440]" " Self of Self: [1,1,2,5,14,42,132,429,1430,4862,16796,58786,208012,742900,2674440]" "Prime flip flop: [0,1,1,0,1,0,1,0,0,0,1,0,1,0,0]" " Forward: [0,1,3,6,11,20,37,70,134,255,476,869,1564,2821,5201]" " Inverse: [0,1,-1,0,3,-10,25,-56,118,-237,456,-847,1540,-2795,5173]" " Self: [0,-1,-1,0,3,10,25,56,118,237,456,847,1540,2795,5173]" " Inverse of Forward: [0,1,1,0,1,0,1,0,0,0,1,0,1,0,0]" " Self of Self: [0,1,1,0,1,0,1,0,0,0,1,0,1,0,0]" "Fibonacci: [0,1,1,2,3,5,8,13,21,34,55,89,144,233,377]" " Forward: [0,1,3,8,21,55,144,377,987,2584,6765,17711,46368,121393,317811]" " Inverse: [0,1,-1,2,-3,5,-8,13,-21,34,-55,89,-144,233,-377]" " Self: [0,-1,-1,-2,-3,-5,-8,-13,-21,-34,-55,-89,-144,-233,-377]" " Inverse of Forward: [0,1,1,2,3,5,8,13,21,34,55,89,144,233,377]" " Self of Self: [0,1,1,2,3,5,8,13,21,34,55,89,144,233,377]" "Padovan: [1,0,0,1,0,1,1,1,2,2,3,4,5,7,9]" " Forward: [1,1,1,2,5,12,28,65,151,351,816,1897,4410,10252,23833]" " Inverse: [1,-1,1,0,-3,10,-24,49,-89,145,-208,245,-174,-176,1121]" " Self: [1,1,1,0,-3,-10,-24,-49,-89,-145,-208,-245,-174,176,1121]" " Inverse of Forward: [1,0,0,1,0,1,1,1,2,2,3,4,5,7,9]" " Self of Self: [1,0,0,1,0,1,1,1,2,2,3,4,5,7,9]"
Implementation:
forward=: {{ y +/ .* !/~ i.#y }}
reverse=: {{ y +/ .* (!/~ * _1^+/~) i.#y }}
selfinv=: {{ y +/ .* (!/~ * _1^]) i.#y }}
Task examples:
NB. Catalan
((! +:) % >:) i.15x
1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440
forward ((! +:) % >:) i.15x
1 2 5 15 51 188 731 2950 12235 51822 223191 974427 4302645 19181100 86211885
reverse ((! +:) % >:) i.15x
1 0 1 1 3 6 15 36 91 232 603 1585 4213 11298 30537
selfinv ((! +:) % >:) i.15x
1 0 1 _1 3 _6 15 _36 91 _232 603 _1585 4213 _11298 30537
reverse forward ((! +:) % >:) i.15x
1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440
selfinv selfinv ((! +:) % >:) i.15x
1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440
NB. natural number is prime
1 p: 1+i.15
0 1 1 0 1 0 1 0 0 0 1 0 1 0 0
forward 1 p: 1+i.15
0 1 3 6 11 20 37 70 134 255 476 869 1564 2821 5201
reverse 1 p: 1+i.15
0 1 _1 0 3 _10 25 _56 118 _237 456 _847 1540 _2795 5173
selfinv 1 p: 1+i.15
0 _1 _1 0 3 10 25 56 118 237 456 847 1540 2795 5173
reverse forward 1 p: 1+i.15
0 1 1 0 1 0 1 0 0 0 1 0 1 0 0
selfinv selfinv 1 p: 1+i.15
0 1 1 0 1 0 1 0 0 0 1 0 1 0 0
NB. Fibonacci
(, _1 _2 +/@:{ ])^:15] 0 1
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
forward (, _1 _2 +/@:{ ])^:15] 0 1
0 1 3 8 21 55 144 377 987 2584 6765 17711 46368 121393 317811 832040 2178309
reverse (, _1 _2 +/@:{ ])^:15] 0 1
0 1 _1 2 _3 5 _8 13 _21 34 _55 89 _144 233 _377 610 _987
selfinv (, _1 _2 +/@:{ ])^:15] 0 1
0 _1 _1 _2 _3 _5 _8 _13 _21 _34 _55 _89 _144 _233 _377 _610 _987
reverse forward (, _1 _2 +/@:{ ])^:15] 0 1
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
selfinv selfinv (, _1 _2 +/@:{ ])^:15] 0 1
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
NB. Padovan
(],+/@(_2 _3{]))^:([-3:)&1 0 0(15)
1 0 0 1 0 1 1 1 2 2 3 4 5 7 9
forward (],+/@(_2 _3{]))^:([-3:)&1 0 0(15)
1 1 1 2 5 12 28 65 151 351 816 1897 4410 10252 23833
reverse (],+/@(_2 _3{]))^:([-3:)&1 0 0(15)
1 _1 1 0 _3 10 _24 49 _89 145 _208 245 _174 _176 1121
selfinv (],+/@(_2 _3{]))^:([-3:)&1 0 0(15)
1 1 1 0 _3 _10 _24 _49 _89 _145 _208 _245 _174 176 1121
reverse forward (],+/@(_2 _3{]))^:([-3:)&1 0 0(15)
1 0 0 1 0 1 1 1 2 2 3 4 5 7 9
selfinv selfinv (],+/@(_2 _3{]))^:([-3:)&1 0 0(15)
1 0 0 1 0 1 1 1 2 2 3 4 5 7 9
import java.util.Arrays;
public final class BinomialTransform {
public static void main(String[] args) {
long[][] sequences = new long[][] {
{ 1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845 },
{ 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0 },
{ 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181 },
{ 1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37 }
};
String[] names = new String[] {
"Catalan number sequence:",
"Prime flip-flop sequence:",
"Fibonacci number sequence:",
"Padovan number sequence:"
};
for ( int i = 0; i < sequences.length; i++ ) {
System.out.println(names[i]);
System.out.println(Arrays.toString(sequences[i]));
System.out.println("Forward binomial transform:");
System.out.println(Arrays.toString(forward(sequences[i])));
System.out.println("Inverse binomial transform:");
System.out.println(Arrays.toString(inverse(sequences[i])));
System.out.println("Round trip:");
System.out.println(Arrays.toString(inverse(forward(sequences[i]))));
System.out.println("Self-inverting:");
System.out.println(Arrays.toString(self_inverting(sequences[i])));
System.out.println("Round trip self-inverting:");
System.out.println(Arrays.toString(self_inverting(self_inverting(sequences[i]))));
System.out.println();
}
}
private static long[] self_inverting(long[] numbers) {
long[] transform = new long[numbers.length];
for ( int n = 0; n < numbers.length; n++ ) {
for ( int k = 0; k <= n; k++ ) {
final int sign = ( k % 2 == 1 ) ? -1 : 1;
transform[n] += binomial(n, k) * numbers[k] * sign;
}
}
return transform;
}
private static long[] inverse(long[] numbers) {
long[] transform = new long[numbers.length];
for ( int n = 0; n < numbers.length; n++ ) {
for ( int k = 0; k <= n; k++ ) {
final int sign = ( ( n - k ) % 2 == 1 ) ? -1 : 1;
transform[n] += binomial(n, k) * numbers[k] * sign;
}
}
return transform;
}
private static long[] forward(long[] numbers) {
long[] transform = new long[numbers.length];
for ( int n = 0; n < numbers.length; n++ ) {
for ( int k = 0; k <= n; k++ ) {
transform[n] += binomial(n, k) * numbers[k];
}
}
return transform;
}
private static long binomial(int n, int k) {
return factorial(n) / factorial(n - k) / factorial(k);
}
private static long factorial(int number) {
if ( number > 20 ) {
throw new AssertionError("Factorial of number is too large: " + number);
}
if ( number < 2 ) {
return 1;
}
long factorial = 1;
for ( int i = 2; i <= number; i++ ) {
factorial *= i;
}
return factorial;
}
}
- Output:
Catalan number sequence: [1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845] Forward binomial transform: [1, 2, 5, 15, 51, 188, 731, 2950, 12235, 51822, 223191, 974427, 4302645, 19181100, 86211885, 390248055] Inverse binomial transform: [1, 0, 1, 1, 3, 6, 15, 36, 91, 232, 603, 1585, 4213, 11298, 30537, 83097] Round trip: [1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845] Self-inverting: [1, 0, 1, -1, 3, -6, 15, -36, 91, -232, 603, -1585, 4213, -11298, 30537, -83097] Round trip self-inverting: [1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845] Prime flip-flop sequence: [0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0] Forward binomial transform: [0, 1, 3, 6, 11, 20, 37, 70, 134, 255, 476, 869, 1564, 2821, 5201, 9948, 19793, 40562, 84271, 174952] Inverse binomial transform: [0, 1, -1, 0, 3, -10, 25, -56, 118, -237, 456, -847, 1540, -2795, 5173, -9918, 19761, -40528, 84235, -174914] Round trip: [0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0] Self-inverting: [0, -1, -1, 0, 3, 10, 25, 56, 118, 237, 456, 847, 1540, 2795, 5173, 9918, 19761, 40528, 84235, 174914] Round trip self-inverting: [0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0] Fibonacci number sequence: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181] Forward binomial transform: [0, 1, 3, 8, 21, 55, 144, 377, 987, 2584, 6765, 17711, 46368, 121393, 317811, 832040, 2178309, 5702887, 14930352, 39088169] Inverse binomial transform: [0, 1, -1, 2, -3, 5, -8, 13, -21, 34, -55, 89, -144, 233, -377, 610, -987, 1597, -2584, 4181] Round trip: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181] Self-inverting: [0, -1, -1, -2, -3, -5, -8, -13, -21, -34, -55, -89, -144, -233, -377, -610, -987, -1597, -2584, -4181] Round trip self-inverting: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181] Padovan number sequence: [1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37] Forward binomial transform: [1, 1, 1, 2, 5, 12, 28, 65, 151, 351, 816, 1897, 4410, 10252, 23833, 55405, 128801, 299426, 696081, 1618192] Inverse binomial transform: [1, -1, 1, 0, -3, 10, -24, 49, -89, 145, -208, 245, -174, -176, 1121, -3185, 7137, -13920, 24301, -37926] Round trip: [1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37] Self-inverting: [1, 1, 1, 0, -3, -10, -24, -49, -89, -145, -208, -245, -174, 176, 1121, 3185, 7137, 13920, 24301, 37926] Round trip self-inverting: [1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37]
function printVector(vec) {
console.log(vec.join(" "));
}
function factorial(number) {
if (number > 20) {
throw new Error("Too large for 64 bit number: " + number);
}
if (number < 2) {
return 1n;
}
let result = 1n;
for (let i = 2; i <= number; ++i) {
result *= BigInt(i);
}
return result;
}
function binomial(n, k) {
return factorial(n) / factorial(n - k) / factorial(k);
}
function forward(vec) {
const transform = Array(vec.length).fill(0);
for (let n = 0; n < vec.length; ++n) {
for (let k = 0; k <= n; ++k) {
transform[n] += Number(binomial(n, k)) * vec[k];
}
}
return transform;
}
function inverse(vec) {
const transform = Array(vec.length).fill(0);
for (let n = 0; n < vec.length; ++n) {
for (let k = 0; k <= n; ++k) {
const sign = ((n - k) & 1) ? -1 : 1;
transform[n] += Number(binomial(n, k)) * vec[k] * sign;
}
}
return transform;
}
function selfInverting(vec) {
const transform = Array(vec.length).fill(0);
for (let n = 0; n < vec.length; ++n) {
for (let k = 0; k <= n; ++k) {
const sign = (k & 1) ? -1 : 1;
transform[n] += Number(binomial(n, k)) * vec[k] * sign;
}
}
return transform;
}
function main() {
const sequences = [
[1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845],
[0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0],
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181],
[1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37]
];
const names = [
"Catalan number sequence:",
"Prime flip-flop sequence:",
"Fibonacci number sequence:",
"Padovan number sequence:"
];
for (let i = 0; i < sequences.length; ++i) {
console.log(names[i]);
printVector(sequences[i]);
console.log("\nForward binomial transform:");
printVector(forward(sequences[i]));
console.log("\nInverse binomial transform:");
printVector(inverse(sequences[i]));
console.log("\nRound trip:");
printVector(inverse(forward(sequences[i])));
console.log("\nSelf-inverting:");
printVector(selfInverting(sequences[i]));
console.log("\nRound trip self-inverting:");
printVector(selfInverting(selfInverting(sequences[i])));
console.log("\n");
}
}
main();
- Output:
Catalan number sequence: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 Forward binomial transform: 1 2 5 15 51 188 731 2950 12235 51822 223191 974427 4302645 19181100 86211885 390248055 Inverse binomial transform: 1 0 1 1 3 6 15 36 91 232 603 1585 4213 11298 30537 83097 Round trip: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 Self-inverting: 1 0 1 -1 3 -6 15 -36 91 -232 603 -1585 4213 -11298 30537 -83097 Round trip self-inverting: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 Prime flip-flop sequence: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Forward binomial transform: 0 1 3 6 11 20 37 70 134 255 476 869 1564 2821 5201 9948 19793 40562 84271 174952 Inverse binomial transform: 0 1 -1 0 3 -10 25 -56 118 -237 456 -847 1540 -2795 5173 -9918 19761 -40528 84235 -174914 Round trip: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Self-inverting: 0 -1 -1 0 3 10 25 56 118 237 456 847 1540 2795 5173 9918 19761 40528 84235 174914 Round trip self-inverting: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Fibonacci number sequence: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Forward binomial transform: 0 1 3 8 21 55 144 377 987 2584 6765 17711 46368 121393 317811 832040 2178309 5702887 14930352 39088169 Inverse binomial transform: 0 1 -1 2 -3 5 -8 13 -21 34 -55 89 -144 233 -377 610 -987 1597 -2584 4181 Round trip: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Self-inverting: 0 -1 -1 -2 -3 -5 -8 -13 -21 -34 -55 -89 -144 -233 -377 -610 -987 -1597 -2584 -4181 Round trip self-inverting: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Padovan number sequence: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37 Forward binomial transform: 1 1 1 2 5 12 28 65 151 351 816 1897 4410 10252 23833 55405 128801 299426 696081 1618192 Inverse binomial transform: 1 -1 1 0 -3 10 -24 49 -89 145 -208 245 -174 -176 1121 -3185 7137 -13920 24301 -37926 Round trip: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37 Self-inverting: 1 1 1 0 -3 -10 -24 -49 -89 -145 -208 -245 -174 176 1121 3185 7137 13920 24301 37926 Round trip self-inverting: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37
Adapted from Wren
Works with both jq and gojq, the C and Go implementations of jq
The following can also easily be adapted to work with jaq, the Rust implementation of jq.
# nCk assuming n >= k
def binomial(n; k):
if k > n / 2 then binomial(n; n-k)
else reduce range(1; k+1) as $i (1; . * (n - $i + 1) / $i)
end;
def forward:
. as $a
| reduce range(0; $a|length) as $n (null;
reduce range(0;$n+1) as $k (.;
.[$n] += binomial($n; $k) * $a[$k] ) );
def inverse:
. as $b
| reduce range (0; $b|length) as $n (null;
reduce range(0; $n+1) as $k (.;
(if (($n - $k) % 2 == 0) then 1 else -1 end) as $sign
| .[$n] += binomial($n; $k) * $b[$k] * $sign ));
def selfInverting:
. as $a
| reduce range(0; $a|length) as $n (null;
reduce range(0; $n+1) as $k (.;
(if $k % 2 == 0 then 1 else -1 end) as $sign
| .[$n] += binomial($n; $k) * $a[$k] * $sign ));
def seqs: [
[1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845, 35357670, 129644790, 477638700, 1767263190],
[0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0],
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181],
[1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37]
];
def names: [
"Catalan number sequence:",
"Prime flip-flop sequence:",
"Fibonacci number sequence:",
"Padovan number sequence:"
];
def task:
range(0; seqs|length) as $i
| names[$i],
(seqs[$i]|join(" ")),
"Forward binomial transform:",
( (seqs[$i]|forward)
| join(" "),
"Inverse binomial transform:",
((seqs[$i]|inverse)|join(" ")),
"Round trip:",
(inverse|join(" ")) ),
"Self-inverting:",
( (seqs[$i]|selfInverting)
| join(" "),
"Re-inverted:",
(selfInverting|join(" ")) ),
(select($i < (seqs|length - 1) ) | "") ;
task- Output:
Exactly as at Wren.
The binomial function is a built-in function in Julia.
""" forward binomial transform """
binomial_transform(seq) =
[sum(binomial(n, k) * seq[k+1] for k in 0:n) for n in 0:length(seq)-1]
""" inverse binomial transform """
function inverse_binomial_transform(seq)
return [sum((-1)^(n - k) * binomial(n, k) * seq[k+1] for k in 0:n) for n in 0:length(seq)-1]
end
const test_sequences = [
"Catalan number sequence" => [
1,
1,
2,
5,
14,
42,
132,
429,
1430,
4862,
16796,
58786,
208012,
742900,
2674440,
9694845,
35357670,
129644790,
477638700,
1767263190,
],
"Prime flip-flop sequence" =>
[0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0],
"Fibonacci number sequence" => [
0,
1,
1,
2,
3,
5,
8,
13,
21,
34,
55,
89,
144,
233,
377,
610,
987,
1597,
2584,
4181,
],
"Padovan number sequence" =>
[1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37],
]
for (s, a) in test_sequences
println("\n$s:\n", join(a, " "))
println("Forward binomial transform:\n", join(binomial_transform(a), " "))
println("Inverse binomial transform:\n", join(inverse_binomial_transform(a), " "))
println("Re-inverted:\n", join(inverse_binomial_transform(binomial_transform(a)), " "))
end
- Output:
Same as C, Go, etc.
object MainKt {
@JvmStatic
fun main(args: Array<String>) {
val sequences = arrayOf(
longArrayOf(1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845),
longArrayOf(0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0),
longArrayOf(0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181),
longArrayOf(1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37)
)
val names = arrayOf(
"Catalan number sequence:",
"Prime flip-flop sequence:",
"Fibonacci number sequence:",
"Padovan number sequence:"
)
for (i in sequences.indices) {
println(names[i])
println(sequences[i].contentToString())
println("Forward binomial transform:")
println(forward(sequences[i]).contentToString())
println("Inverse binomial transform:")
println(inverse(sequences[i]).contentToString())
println("Round trip:")
println(inverse(forward(sequences[i])).contentToString())
println("Self-inverting:")
println(selfInverting(sequences[i]).contentToString())
println("Round trip self-inverting:")
println(selfInverting(selfInverting(sequences[i])).contentToString())
println()
}
}
private fun selfInverting(numbers: LongArray): LongArray {
val transform = LongArray(numbers.size)
for (n in numbers.indices) {
for (k in 0..n) {
val sign = if (k % 2 == 1) -1 else 1
transform[n] += binomial(n, k) * numbers[k] * sign
}
}
return transform
}
private fun inverse(numbers: LongArray): LongArray {
val transform = LongArray(numbers.size)
for (n in numbers.indices) {
for (k in 0..n) {
val sign = if ((n - k) % 2 == 1) -1 else 1
transform[n] += binomial(n, k) * numbers[k] * sign
}
}
return transform
}
private fun forward(numbers: LongArray): LongArray {
val transform = LongArray(numbers.size)
for (n in numbers.indices) {
for (k in 0..n) {
transform[n] += binomial(n, k) * numbers[k]
}
}
return transform
}
private fun binomial(n: Int, k: Int): Long {
return factorial(n) / factorial(n - k) / factorial(k)
}
private fun factorial(number: Int): Long {
require(number <= 20) { "Factorial of number is too large: $number" }
if (number < 2) {
return 1
}
var factorial = 1L
for (i in 2..number) {
factorial *= i
}
return factorial
}
}
- Output:
Catalan number sequence: [1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845] Forward binomial transform: [1, 2, 5, 15, 51, 188, 731, 2950, 12235, 51822, 223191, 974427, 4302645, 19181100, 86211885, 390248055] Inverse binomial transform: [1, 0, 1, 1, 3, 6, 15, 36, 91, 232, 603, 1585, 4213, 11298, 30537, 83097] Round trip: [1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845] Self-inverting: [1, 0, 1, -1, 3, -6, 15, -36, 91, -232, 603, -1585, 4213, -11298, 30537, -83097] Round trip self-inverting: [1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845] Prime flip-flop sequence: [0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0] Forward binomial transform: [0, 1, 3, 6, 11, 20, 37, 70, 134, 255, 476, 869, 1564, 2821, 5201, 9948, 19793, 40562, 84271, 174952] Inverse binomial transform: [0, 1, -1, 0, 3, -10, 25, -56, 118, -237, 456, -847, 1540, -2795, 5173, -9918, 19761, -40528, 84235, -174914] Round trip: [0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0] Self-inverting: [0, -1, -1, 0, 3, 10, 25, 56, 118, 237, 456, 847, 1540, 2795, 5173, 9918, 19761, 40528, 84235, 174914] Round trip self-inverting: [0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0] Fibonacci number sequence: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181] Forward binomial transform: [0, 1, 3, 8, 21, 55, 144, 377, 987, 2584, 6765, 17711, 46368, 121393, 317811, 832040, 2178309, 5702887, 14930352, 39088169] Inverse binomial transform: [0, 1, -1, 2, -3, 5, -8, 13, -21, 34, -55, 89, -144, 233, -377, 610, -987, 1597, -2584, 4181] Round trip: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181] Self-inverting: [0, -1, -1, -2, -3, -5, -8, -13, -21, -34, -55, -89, -144, -233, -377, -610, -987, -1597, -2584, -4181] Round trip self-inverting: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181] Padovan number sequence: [1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37] Forward binomial transform: [1, 1, 1, 2, 5, 12, 28, 65, 151, 351, 816, 1897, 4410, 10252, 23833, 55405, 128801, 299426, 696081, 1618192] Inverse binomial transform: [1, -1, 1, 0, -3, 10, -24, 49, -89, 145, -208, 245, -174, -176, 1121, -3185, 7137, -13920, 24301, -37926] Round trip: [1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37] Self-inverting: [1, 1, 1, 0, -3, -10, -24, -49, -89, -145, -208, -245, -174, 176, 1121, 3185, 7137, 13920, 24301, 37926] Round trip self-inverting: [1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37]
Module Binomial_transform {
' Test sequences
Stack New {
Data (1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845, 35357670, 129644790, 477638700, 1767263190)
Data (0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0)
Data (0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181)
Data (1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37)
Dim TestArr()
TestArr()=Array([])
}
Dim forwardResult(), selfResult(), tempSeq()
' Test each sequence
sequences=("Catalan number sequence:", "Prime flip-flop sequence:", "Fibonacci number sequence:", "Padovan number sequence:" )
Integer i, j
For i = 0 To 3
Print sequences#val$(i)
' Copy the appropriate sequence to tempSeq
tempSeq() = TestArr(i)
print tempSeq()#str$()
Print "Forward binomial transform:"
forwardResult()=@binomialFwd(&tempSeq())
print forwardResult()#str$()
Print "Inverse binomial transform:"
print @binomialInv(&tempSeq())#str$()
Print "Round trip:"
print @binomialInv(&forwardResult())#str$()
Print "Self-inverting:"
selfResult()=@binomialSelfInv(&tempSeq())
print selfResult()#str$()
Print "Re-inverted:"
print @binomialSelfInv(&selfResult())#str$()
If i < 3 Then Print
Next
' Calculate binomial coefficient
Function binomial(n As Integer, k As Integer)
If k > n Then =0: Exit Function
If k = 0 Or k = n Then =1: Exit Function
Local Double result = 1
k = if(k > n - k -> n - k, k)
local Integer i
if k>0 then
For i = 0 To k - 1
result *= n - i
result /= i + 1
Next
end if
= result
End Function
' Forward binomial transform
Function binomialFwd(&seq())
Local Integer n, k, lim=len(seq())
Local result(lim)
For n = 0 To lim - 1
For k = 0 To n
result(n) += @binomial(n, k) * seq(k)
Next
Next
=result()
End Function
' Inverse binomial transform
Function binomialInv(&seq())
Local Integer n, k, sign, lim=len(seq())
Local result(lim)
For n = 0 To lim - 1
For k = 0 To n
sign = if((n - k) Mod 2 = 0 -> 1, -1)
result(n) += sign * @binomial(n, k) * seq(k)
Next
Next
=result()
End Function
' Self-inverting binomial transform
Function binomialSelfInv(&seq())
Local Integer n, k, sign, lim=len(seq())
Local result(lim)
For n = 0 To lim - 1
For k = 0 To n
sign = if(k Mod 2 = 0-> 1, -1)
result(n) += sign * @binomial(n, k) * seq(k)
Next
Next
=result()
End Function
}
Binomial_transform
- Output:
Exactly as at Free Basic.
ClearAll[forwardBinomialTransform, inverseBinomialTransform, primeFlipFlop, P];
forwardBinomialTransform[a_] := Sum[Binomial[#, k] a[k], {k, 0, #}] &;
inverseBinomialTransform[b_] := Sum[(-1)^(# - k) Binomial[#, k] b[k], {k, 0, #}] &;
selfInvertingBinaryTransform[a_] := Sum[(-1)^k Binomial[#, k] a[k], {k, 0, #}] &;
(* Prime flip flop sequence *)
primeFlipFlop[n_] := If[PrimeQ[n], 1, 0];
(* Padovan sequence *)
P[0] = 1;
P[1] = P[2] = 0;
P[n_Integer?Positive] = P[n - 2] + P[n - 3];
transforms[seq_, domain_] := {
seq /@ domain,
forwardBinomialTransform@seq /@ domain,
inverseBinomialTransform@seq /@ domain,
inverseBinomialTransform@forwardBinomialTransform@seq /@ domain,
selfInvertingBinaryTransform@seq /@ domain,
selfInvertingBinaryTransform@selfInvertingBinaryTransform@seq /@
domain};
labels[seqName_String] := {
seqName <> ":",
"Forward binomial transform:",
"Inverse binomial transform:",
"Round trip:",
"Self-inverting binary transform:",
"Re-inverted:"
};
(* Output *)
Print[
Riffle[labels["Catalan number sequence"], ToString /@ transforms[CatalanNumber, Range[0, 14]]] // TableForm, "\n",
Riffle[labels["Prime flip-flop sequence"],ToString /@ transforms[primeFlipFlop, Range[0, 14]]] // TableForm, "\n",
Riffle[labels["Fibonacci sequence"], ToString /@ transforms[Fibonacci, Range[0, 14]]] // TableForm, "\n",
Riffle[labels["Padovan sequence"], ToString /@ transforms[P, Range[0, 14]]] // TableForm
];
- Output:
Catalan number sequence:
{1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440}
Forward binomial transform:
{1, 2, 5, 15, 51, 188, 731, 2950, 12235, 51822, 223191, 974427, 4302645, 19181100, 86211885}
Inverse binomial transform:
{1, 0, 1, 1, 3, 6, 15, 36, 91, 232, 603, 1585, 4213, 11298, 30537}
Round trip:
{1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440}
Self-inverting binary transform:
{1, 0, 1, -1, 3, -6, 15, -36, 91, -232, 603, -1585, 4213, -11298, 30537}
Re-inverted:
{1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440}
Prime flip-flop sequence:
{0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0}
Forward binomial transform:
{0, 0, 1, 4, 10, 21, 41, 78, 148, 282, 537, 1013, 1882, 3446, 6267}
Inverse binomial transform:
{0, 0, 1, -2, 2, 1, -11, 36, -92, 210, -447, 903, -1750, 3290, -6085}
Round trip:
{0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0}
Self-inverting binary transform:
{0, 0, 1, 2, 2, -1, -11, -36, -92, -210, -447, -903, -1750, -3290, -6085}
Re-inverted:
{0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0}
Fibonacci sequence:
{0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377}
Forward binomial transform:
{0, 1, 3, 8, 21, 55, 144, 377, 987, 2584, 6765, 17711, 46368, 121393, 317811}
Inverse binomial transform:
{0, 1, -1, 2, -3, 5, -8, 13, -21, 34, -55, 89, -144, 233, -377}
Round trip:
{0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377}
Self-inverting binary transform:
{0, -1, -1, -2, -3, -5, -8, -13, -21, -34, -55, -89, -144, -233, -377}
Re-inverted:
{0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377}
Padovan sequence:
{1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9}
Forward binomial transform:
{1, 1, 1, 2, 5, 12, 28, 65, 151, 351, 816, 1897, 4410, 10252, 23833}
Inverse binomial transform:
{1, -1, 1, 0, -3, 10, -24, 49, -89, 145, -208, 245, -174, -176, 1121}
Round trip:
{1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9}
Self-inverting binary transform:
{1, 1, 1, 0, -3, -10, -24, -49, -89, -145, -208, -245, -174, 176, 1121}
Re-inverted:
{1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9}
import std/[math, strutils]
const
Sequences = {"Catalan":
[1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440],
"Prime flip-flop":
[0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0],
"Fibonacci":
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377],
"Padovan":
[1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9]}
func binomialTransform(a: openArray[int]): seq[int] =
for n in 0..a.high:
var val = 0
for k in 0..n:
val += binom(n, k) * a[k]
result.add val
func invBinomialSequence(b: openArray[int]): seq[int] =
for n in 0..b.high:
var val = 0
var sign = ord((n and 1) == 0) shl 1 - 1
for k in 0..n:
val += binom(n, k) * b[k] * sign
sign = -sign
result.add val
for (name, sequence) in Sequences:
echo name, " sequence:"
echo sequence.join(" ")
let forward = binomialTransform(sequence)
echo "Forward binomial transform:"
echo forward.join(" ")
echo "Inverse binomial transform:"
let inverse = invBinomialSequence(sequence)
echo inverse.join(" ")
echo "Inverse of the forward transform:"
let invForward = invBinomialSequence(forward)
echo invForward.join(" ")
echo()
- Output:
Catalan sequence: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 Forward binomial transform: 1 2 5 15 51 188 731 2950 12235 51822 223191 974427 4302645 19181100 86211885 Inverse binomial transform: 1 0 1 1 3 6 15 36 91 232 603 1585 4213 11298 30537 Inverse of the forward transform: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 Prime flip-flop sequence: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 Forward binomial transform: 0 1 3 6 11 20 37 70 134 255 476 869 1564 2821 5201 Inverse binomial transform: 0 1 -1 0 3 -10 25 -56 118 -237 456 -847 1540 -2795 5173 Inverse of the forward transform: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 Fibonacci sequence: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 Forward binomial transform: 0 1 3 8 21 55 144 377 987 2584 6765 17711 46368 121393 317811 Inverse binomial transform: 0 1 -1 2 -3 5 -8 13 -21 34 -55 89 -144 233 -377 Inverse of the forward transform: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 Padovan sequence: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 Forward binomial transform: 1 1 1 2 5 12 28 65 151 351 816 1897 4410 10252 23833 Inverse binomial transform: 1 -1 1 0 -3 10 -24 49 -89 145 -208 245 -174 -176 1121 Inverse of the forward transform: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9
You can try it online!
\\ Define helper functions
forwardBinomialTransform(seq) = {
n -> sum(k=0, n, binomial(n, k) * seq(k));
};
inverseBinomialTransform(seq) = {
n -> sum(k=0, n, (-1)^(n-k) * binomial(n, k) * seq(k));
};
selfInvertingBinaryTransform(seq) = {
n -> sum(k=0, n, (-1)^k * binomial(n, k) * seq(k));
};
\\ Prime flip-flop sequence
primeFlipFlop(n) = isprime(n+1);
\\ Padovan sequence (with memoization)
padovan_cache = Map();
P(n) = {
if (n < 0, return(0));
if (mapisdefined(padovan_cache, n), return(mapget(padovan_cache, n)));
my(result);
if (n == 0, result = 1,
n <= 2, result = 0,
result = P(n-2) + P(n-3));
mapput(padovan_cache, n, result);
return(result);
};
\\ Transform functions
transforms(seq, domain) = {
my(results = vector(6));
my(fbt = forwardBinomialTransform(seq));
my(ibt = inverseBinomialTransform(seq));
my(sibt = selfInvertingBinaryTransform(seq));
results[1] = vector(#domain, i, seq(domain[i]));
results[2] = vector(#domain, i, fbt(domain[i]));
results[3] = vector(#domain, i, ibt(domain[i]));
results[4] = vector(#domain, i, inverseBinomialTransform(fbt)(domain[i]));
results[5] = vector(#domain, i, sibt(domain[i]));
results[6] = vector(#domain, i, selfInvertingBinaryTransform(sibt)(domain[i]));
return(results);
};
labels(seqName) = {
return([
concat(seqName, ":"),
"Forward binomial transform:",
"Inverse binomial transform:",
"Round trip:",
"Self-inverting binary transform:",
"Re-inverted:"
]);
};
\\ Print function
printTransforms(seqName, seq, domain) = {
my(labs = labels(seqName));
my(tr = transforms(seq, domain));
for(i = 1, #labs,
print(labs[i]);
print(tr[i]);
print("");
);
};
\\ Main execution
domain = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14];
print("Catalan number sequence:");
printTransforms("Catalan number sequence", n -> if(n < 0, 0, binomial(2*n, n)/(n+1)), domain);
print("Prime flip-flop sequence:");
printTransforms("Prime flip-flop sequence", primeFlipFlop, domain);
print("Fibonacci sequence:");
printTransforms("Fibonacci sequence", fibonacci, domain);
print("Padovan sequence:");
printTransforms("Padovan sequence", P, domain);- Output:
Catalan number sequence: Catalan number sequence: [1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440] Forward binomial transform: [1, 2, 5, 15, 51, 188, 731, 2950, 12235, 51822, 223191, 974427, 4302645, 19181100, 86211885] Inverse binomial transform: [1, 0, 1, 1, 3, 6, 15, 36, 91, 232, 603, 1585, 4213, 11298, 30537] Round trip: [1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440] Self-inverting binary transform: [1, 0, 1, -1, 3, -6, 15, -36, 91, -232, 603, -1585, 4213, -11298, 30537] Re-inverted: [1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440] Prime flip-flop sequence: Prime flip-flop sequence: [0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0] Forward binomial transform: [0, 1, 3, 6, 11, 20, 37, 70, 134, 255, 476, 869, 1564, 2821, 5201] Inverse binomial transform: [0, 1, -1, 0, 3, -10, 25, -56, 118, -237, 456, -847, 1540, -2795, 5173] Round trip: [0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0] Self-inverting binary transform: [0, -1, -1, 0, 3, 10, 25, 56, 118, 237, 456, 847, 1540, 2795, 5173] Re-inverted: [0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0] Fibonacci sequence: Fibonacci sequence: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377] Forward binomial transform: [0, 1, 3, 8, 21, 55, 144, 377, 987, 2584, 6765, 17711, 46368, 121393, 317811] Inverse binomial transform: [0, 1, -1, 2, -3, 5, -8, 13, -21, 34, -55, 89, -144, 233, -377] Round trip: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377] Self-inverting binary transform: [0, -1, -1, -2, -3, -5, -8, -13, -21, -34, -55, -89, -144, -233, -377] Re-inverted: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377] Padovan sequence: Padovan sequence: [1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9] Forward binomial transform: [1, 1, 1, 2, 5, 12, 28, 65, 151, 351, 816, 1897, 4410, 10252, 23833] Inverse binomial transform: [1, -1, 1, 0, -3, 10, -24, 49, -89, 145, -208, 245, -174, -176, 1121] Round trip: [1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9] Self-inverting binary transform: [1, 1, 1, 0, -3, -10, -24, -49, -89, -145, -208, -245, -174, 176, 1121] Re-inverted: [1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9]
program BinomialTransforms;
{$mode objfpc}{$H+}
uses
SysUtils;
type
Int64Array = array[0..19] of Int64;
const
facs: array[1..20] of UInt64 = (
1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800,
39916800, 479001600, 6227020800, 87178291200, 1307674368000,
20922789888000, 355687428096000, 6402373705728000, 121645100408832000,
2432902008176640000
);
Seqs: array[0..3] of Int64Array = (
(1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900,
2674440, 9694845, 35357670, 129644790, 477638700, 1767263190),
(0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0),
(0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181),
(1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37)
);
Names: array[0..3] of string = (
'Catalan number sequence:',
'Prime flip-flop sequence:',
'Fibonacci number sequence:',
'Padovan number sequence:'
);
function Factorial(N: Integer): UInt64;
begin
if (N > 20) or (N < 2) then
Exit(1);
Result := facs[N];
end;
function Binomial(N, K: Integer): UInt64;
begin
Result := Factorial(N) div (Factorial(N - K) * Factorial(K));
end;
procedure BtForward(var B: Int64Array; const A: Int64Array; C: Integer);
var
N, K: Integer;
begin
for N := 0 to C - 1 do
begin
B[N] := 0;
for K := 0 to N do
B[N] := B[N] + Binomial(N, K) * A[K];
end;
end;
procedure BtInverse(var A: Int64Array; const B: Int64Array; C: Integer);
var
N, K, Sign: Integer;
begin
for N := 0 to C - 1 do
begin
A[N] := 0;
for K := 0 to N do
begin
Sign := Ord((N - K) and 1 <> 0) * -2 + 1;
A[N] := A[N] + Binomial(N, K) * B[K] * Sign;
end;
end;
end;
procedure BtSelfInverting(var B: Int64Array; const A: Int64Array; C: Integer);
var
N, K, Sign: Integer;
begin
for N := 0 to C - 1 do
begin
B[N] := 0;
for K := 0 to N do
begin
Sign := Ord(K and 1 <> 0) * -2 + 1;
B[N] := B[N] + Binomial(N, K) * A[K] * Sign;
end;
end;
end;
function LeastSquareDiff(Limit: UInt32): UInt32;
var
N: UInt32;
begin
N := Trunc(Sqrt(Limit)) + 1;
while (N * N) - ((N - 1) * (N - 1)) <= Limit do
Inc(N);
Result := N;
end;
var
I, J: Integer;
Fwd, Res: Int64Array;
begin
for I := 0 to 3 do
begin
WriteLn(Names[I]);
for J := 0 to 19 do
Write(Seqs[I][J], ' ');
WriteLn;
WriteLn('Forward binomial transform:');
BtForward(Fwd, Seqs[I], 20);
for J := 0 to 19 do
Write(Fwd[J], ' ');
WriteLn;
WriteLn('Inverse binomial transform:');
BtInverse(Res, Seqs[I], 20);
for J := 0 to 19 do
Write(Res[J], ' ');
WriteLn;
WriteLn('Round trip:');
BtInverse(Res, Fwd, 20);
for J := 0 to 19 do
Write(Res[J], ' ');
WriteLn;
WriteLn('Self-inverting:');
BtSelfInverting(Fwd, Seqs[I], 20);
for J := 0 to 19 do
Write(Fwd[J], ' ');
WriteLn;
WriteLn('Re-inverted:');
BtSelfInverting(Res, Fwd, 20);
for J := 0 to 19 do
Write(Res[J], ' ');
end;
end.
- Output:
Same as C
# 20240926 Perl programming solution
use strict;
use warnings;
sub factorial {
my $n = shift;
my ($i, $result) = (1, 1);
for ( ; $i <= $n or return $result; $i++) { $result *= $i }
}
sub binomial {
my ($n, $k) = @_;
return factorial($n) / (factorial($k) * factorial($n - $k));
}
sub binomial_transform {
my @seq = @_;
my @result;
for my $n (0 .. $#seq) {
my $sum = 0;
for my $k (0 .. $n) {
my $binom = binomial($n, $k);
my $term = $binom * $seq[$k];
$sum += $term;
}
push @result, $sum;
}
return @result;
}
sub inverse_binomial_transform {
my @seq = @_;
my @result;
for my $n (0 .. $#seq) {
my $sum = 0;
for my $k (0 .. $n) {
my $binom = binomial($n, $k);
my $term = ((-1) ** ($n - $k)) * $binom * $seq[$k];
$sum += $term;
}
push @result, $sum;
}
return @result;
}
sub self_inverting_transform {
my @seq = @_;
my @result;
for my $n (0 .. $#seq) {
my $sum = 0;
for my $k (0 .. $n) {
my $sign = ($k % 2 == 0) ? 1 : -1;
my $binom = binomial($n, $k);
my $term = $sign * $binom * $seq[$k];
$sum += $term;
}
push @result, $sum;
}
return @result;
}
my @sequences = (
{
name => 'Catalan number sequence',
seq => [1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845, 35357670, 129644790, 477638700, 1767263190],
},
{
name => 'Prime flip-flop sequence',
seq => [0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0],
},
{
name => 'Fibonacci number sequence',
seq => [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181],
},
{
name => 'Padovan number sequence',
seq => [1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37],
}
);
for my $test_case (@sequences) {
my $name = $test_case->{name};
my @seq = @{$test_case->{seq}};
print "$name:\n@seq[0 .. $#seq]\n";
my @forward = binomial_transform(@seq);
print "Forward binomial transform:\n@forward[0 .. $#forward]\n";
my @inverse = inverse_binomial_transform(@seq);
print "Inverse binomial transform:\n@inverse[0 .. $#inverse]\n";
my @round_trip = inverse_binomial_transform(@forward);
print "Round trip:\n@round_trip[0 .. $#round_trip]\n";
my @self_inverting = self_inverting_transform(@seq);
print "Self inverting:\n@self_inverting[0 .. $#self_inverting]\n";
my @re_inverted = self_inverting_transform(@self_inverting);
print "Re inverted:\n@re_inverted[0 .. $#re_inverted]\n\n";
}
You may Attempt This Online!
with javascript_semantics
function bt_forward(sequence a)
sequence b = {}
for n=1 to length(a) do
atom bn = 0
for k=1 to n do
bn += choose(n-1, k-1) * a[k]
end for
b &= bn
end for
return b
end function
function bt_inverse(sequence b)
sequence a = {}
for n=1 to length(b) do
atom an = 0
for k=1 to n do
integer sgn = iff(odd(n-k) ? -1 : 1)
an += choose(n-1, k-1) * b[k] * sgn
end for
a &= an
end for
return a
end function
function bt_self_inverting(sequence a)
sequence b = {}
for n=1 to length(a) do
atom bn = 0
for k=1 to n do
integer sgn = iff(even(k) ? -1 : 1)
bn += choose(n-1, k-1) * a[k] * sgn
end for
b &= bn
end for
return b
end function
sequence tests = {{"Catalan number sequence:",
{1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012,
742900, 2674440, 9694845, 35357670, 129644790, 477638700, 1767263190}},
{"Prime flip-flop sequence:",
{0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0}},
{"Fibonacci number sequence:",
{0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181}},
{"Padovan number sequence:",
{1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37}}}
function jd(sequence s) return join(s," ",fmt:="%d") end function
for t in tests do
sequence {name, s} = t, fwd = bt_forward(s), inv = bt_inverse(s),
si = bt_self_inverting(s)
printf(1,"%s\n%s\n", {name,jd(s)})
printf(1,"Forward binomial transform:\n%s\n",jd(fwd))
printf(1,"Inverse binomial transform:\n%s\n",jd(inv))
printf(1,"Round trip:\n%s\n",jd(bt_inverse(fwd)))
printf(1,"Self-inverting:\n%s\n",jd(si))
printf(1,"Re-inverted:\n%s\n\n",jd(bt_self_inverting(si)))
end for
- Output:
Same as C, etc.
from math import factorial
from math import pow
from typing import Iterable
from typing import Sequence
def binomial(n: int, k: int) -> int:
return factorial(n) // (factorial(n - k) * factorial(k))
def binomial_transform(seq: Sequence) -> Iterable[int]:
for n in range(len(seq)):
yield sum(binomial(n, k) * seq[k] for k in range(n + 1))
def inverse_binomial_transform(seq: Sequence) -> Iterable[int]:
for n in range(len(seq)):
yield int(sum(pow(-1, n - k) * binomial(n, k) * seq[k] for k in range(n + 1)))
test_sequences = {
"Catalan number sequence": [
1,
1,
2,
5,
14,
42,
132,
429,
1430,
4862,
16796,
58786,
208012,
742900,
2674440,
9694845,
35357670,
129644790,
477638700,
1767263190,
],
"Prime flip-flop sequence": [
0,
1,
1,
0,
1,
0,
1,
0,
0,
0,
1,
0,
1,
0,
0,
0,
1,
0,
1,
0,
],
"Fibonacci number sequence": [
0,
1,
1,
2,
3,
5,
8,
13,
21,
34,
55,
89,
144,
233,
377,
610,
987,
1597,
2584,
4181,
],
"Padovan number sequence": [
1,
0,
0,
1,
0,
1,
1,
1,
2,
2,
3,
4,
5,
7,
9,
12,
16,
21,
28,
37,
],
}
if __name__ == "__main__":
import pprint
for desc, seq in test_sequences.items():
print(desc + ":")
pprint.pprint(seq, compact=True, indent=2)
print("Forward binomial transform:")
pprint.pprint(list(binomial_transform(seq)), compact=True, indent=2)
print("Inverse binomial transform:")
pprint.pprint(list(inverse_binomial_transform(seq)), compact=True, indent=2)
print("Round trip:")
pprint.pprint(
list(inverse_binomial_transform(list(binomial_transform(seq)))),
compact=True,
indent=2,
)
print()
- Output:
Catalan number sequence: [ 1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845, 35357670, 129644790, 477638700, 1767263190] Forward binomial transform: [ 1, 2, 5, 15, 51, 188, 731, 2950, 12235, 51822, 223191, 974427, 4302645, 19181100, 86211885, 390248055, 1777495635, 8140539950, 37463689775, 173164232965] Inverse binomial transform: [ 1, 0, 1, 1, 3, 6, 15, 36, 91, 232, 603, 1585, 4213, 11298, 30537, 83097, 227475, 625992, 1730787, 4805595] Round trip: [ 1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845, 35357670, 129644790, 477638700, 1767263190] Prime flip-flop sequence: [0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0] Forward binomial transform: [ 0, 1, 3, 6, 11, 20, 37, 70, 134, 255, 476, 869, 1564, 2821, 5201, 9948, 19793, 40562, 84271, 174952] Inverse binomial transform: [ 0, 1, -1, 0, 3, -10, 25, -56, 118, -237, 456, -847, 1540, -2795, 5173, -9918, 19761, -40528, 84235, -174914] Round trip: [0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0] Fibonacci number sequence: [ 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181] Forward binomial transform: [ 0, 1, 3, 8, 21, 55, 144, 377, 987, 2584, 6765, 17711, 46368, 121393, 317811, 832040, 2178309, 5702887, 14930352, 39088169] Inverse binomial transform: [ 0, 1, -1, 2, -3, 5, -8, 13, -21, 34, -55, 89, -144, 233, -377, 610, -987, 1597, -2584, 4181] Round trip: [ 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181] Padovan number sequence: [1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37] Forward binomial transform: [ 1, 1, 1, 2, 5, 12, 28, 65, 151, 351, 816, 1897, 4410, 10252, 23833, 55405, 128801, 299426, 696081, 1618192] Inverse binomial transform: [ 1, -1, 1, 0, -3, 10, -24, 49, -89, 145, -208, 245, -174, -176, 1121, -3185, 7137, -13920, 24301, -37926] Round trip: [1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37]
Generates the sequences on the fly.
sub binomial { [×] ($^n … 0) Z/ 1 .. $^p }
sub binomial-transform (*@seq) {
@seq.keys.map: -> \n { sum (0..n).map: -> \k { binomial(n,k) × @seq[k] } }
}
sub inverse-binomial-transform (*@seq) {
@seq.keys.map: -> \n { sum (0..n).map: -> \k { binomial(n,k) × @seq[k] × exp(n - k, -1) } }
}
sub si-binomial-transform (*@seq) { #self inverting
@seq.keys.map: -> \n { sum (0..n).map: -> \k { binomial(n,k) × @seq[k] × exp(k, -1) } }
}
my $upto = 20;
for 'Catalan number', (1, {[+] @_ Z× @_.reverse}…*),
'Prime flip-flop', (1..*).map({.is-prime ?? 1 !! 0}),
'Fibonacci number', (0,1,*+*…*),
'Padovan number', (1,0,0, -> $c,$b,$ {$b+$c}…*)
-> $name, @seq {
say qq:to/BIN/;
$name sequence:
{@seq[^$upto]}
Forward binomial transform:
{binomial-transform(@seq)[^$upto]}
Inverse binomial transform:
{inverse-binomial-transform(@seq)[^$upto]}
Round trip:
{inverse-binomial-transform(binomial-transform(@seq))[^$upto]}
Self inverting:
{si-binomial-transform(@seq)[^$upto]}
Re inverted:
{si-binomial-transform(si-binomial-transform(@seq))[^$upto]}
BIN
}
- Output:
Catalan number sequence: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 35357670 129644790 477638700 1767263190 Forward binomial transform: 1 2 5 15 51 188 731 2950 12235 51822 223191 974427 4302645 19181100 86211885 390248055 1777495635 8140539950 37463689775 173164232965 Inverse binomial transform: 1 0 1 1 3 6 15 36 91 232 603 1585 4213 11298 30537 83097 227475 625992 1730787 4805595 Round trip: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 35357670 129644790 477638700 1767263190 Self inverting: 1 0 1 -1 3 -6 15 -36 91 -232 603 -1585 4213 -11298 30537 -83097 227475 -625992 1730787 -4805595 Re inverted: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 35357670 129644790 477638700 1767263190 Prime flip-flop sequence: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Forward binomial transform: 0 1 3 6 11 20 37 70 134 255 476 869 1564 2821 5201 9948 19793 40562 84271 174952 Inverse binomial transform: 0 1 -1 0 3 -10 25 -56 118 -237 456 -847 1540 -2795 5173 -9918 19761 -40528 84235 -174914 Round trip: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Self inverting: 0 -1 -1 0 3 10 25 56 118 237 456 847 1540 2795 5173 9918 19761 40528 84235 174914 Re inverted: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Fibonacci number sequence: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Forward binomial transform: 0 1 3 8 21 55 144 377 987 2584 6765 17711 46368 121393 317811 832040 2178309 5702887 14930352 39088169 Inverse binomial transform: 0 1 -1 2 -3 5 -8 13 -21 34 -55 89 -144 233 -377 610 -987 1597 -2584 4181 Round trip: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Self inverting: 0 -1 -1 -2 -3 -5 -8 -13 -21 -34 -55 -89 -144 -233 -377 -610 -987 -1597 -2584 -4181 Re inverted: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Padovan number sequence: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37 Forward binomial transform: 1 1 1 2 5 12 28 65 151 351 816 1897 4410 10252 23833 55405 128801 299426 696081 1618192 Inverse binomial transform: 1 -1 1 0 -3 10 -24 49 -89 145 -208 245 -174 -176 1121 -3185 7137 -13920 24301 -37926 Round trip: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37 Self inverting: 1 1 1 0 -3 -10 -24 -49 -89 -145 -208 -245 -174 176 1121 3185 7137 13920 24301 37926 Re inverted: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37
You may Attempt This Online!
# Function to compute binomial coefficient "n choose k"
binomial_coeff <- function(n, k) {
if (k > n || k < 0) return(0)
return(choose(n, k))
}
# Forward binomial transform
binomial_transform <- function(seq) {
n <- length(seq)
result <- numeric(n)
for (i in 1:n) {
result[i] <- sum(sapply(1:i, function(k) binomial_coeff(i - 1, k - 1) * seq[k]))
}
return(result)
}
# Inverse binomial transform
inverse_binomial_transform <- function(seq) {
n <- length(seq)
result <- numeric(n)
for (i in 1:n) {
result[i] <- sum(sapply(1:i, function(k)
(-1)^(i - k) * binomial_coeff(i - 1, k - 1) * seq[k]))
}
return(result)
}
# Test sequences
test_sequences <- list(
"Catalan number sequence" = c(
1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862,
16796, 58786, 208012, 742900, 2674440, 9694845,
35357670, 129644790, 477638700, 1767263190
),
"Prime flip-flop sequence" = c(
0, 1, 1, 0, 1, 0, 1, 0, 0, 0,
1, 0, 1, 0, 0, 0, 1, 0, 1, 0
),
"Fibonacci number sequence" = c(
0, 1, 1, 2, 3, 5, 8, 13, 21, 34,
55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181
),
"Padovan number sequence" = c(
1, 0, 0, 1, 0, 1, 1, 1, 2, 2,
3, 4, 5, 7, 9, 12, 16, 21, 28, 37
)
)
# Main execution
for (desc in names(test_sequences)) {
seq <- test_sequences[[desc]]
cat(desc, ":\n")
print(seq)
forward <- binomial_transform(seq)
cat("Forward binomial transform:\n")
print(forward)
inverse <- inverse_binomial_transform(seq)
cat("Inverse binomial transform:\n")
print(inverse)
round_trip <- inverse_binomial_transform(binomial_transform(seq))
cat("Round trip:\n")
print(round_trip)
cat("\n")
}
- Output:
Catalan number sequence : [1] 1 1 2 5 14 42 [7] 132 429 1430 4862 16796 58786 [13] 208012 742900 2674440 9694845 35357670 129644790 [19] 477638700 1767263190 Forward binomial transform: [1] 1 2 5 15 51 [6] 188 731 2950 12235 51822 [11] 223191 974427 4302645 19181100 86211885 [16] 390248055 1777495635 8140539950 37463689775 173164232965 Inverse binomial transform: [1] 1 0 1 1 3 6 15 36 91 [10] 232 603 1585 4213 11298 30537 83097 227475 625992 [19] 1730787 4805595 Round trip: [1] 1 1 2 5 14 42 [7] 132 429 1430 4862 16796 58786 [13] 208012 742900 2674440 9694845 35357670 129644790 [19] 477638700 1767263190 Prime flip-flop sequence : [1] 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Forward binomial transform: [1] 0 1 3 6 11 20 37 70 134 255 [11] 476 869 1564 2821 5201 9948 19793 40562 84271 174952 Inverse binomial transform: [1] 0 1 -1 0 3 -10 25 -56 118 [10] -237 456 -847 1540 -2795 5173 -9918 19761 -40528 [19] 84235 -174914 Round trip: [1] 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Fibonacci number sequence : [1] 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 [16] 610 987 1597 2584 4181 Forward binomial transform: [1] 0 1 3 8 21 55 144 377 [9] 987 2584 6765 17711 46368 121393 317811 832040 [17] 2178309 5702887 14930352 39088169 Inverse binomial transform: [1] 0 1 -1 2 -3 5 -8 13 -21 34 -55 89 [13] -144 233 -377 610 -987 1597 -2584 4181 Round trip: [1] 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 [16] 610 987 1597 2584 4181 Padovan number sequence : [1] 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37 Forward binomial transform: [1] 1 1 1 2 5 12 28 65 151 [10] 351 816 1897 4410 10252 23833 55405 128801 299426 [19] 696081 1618192 Inverse binomial transform: [1] 1 -1 1 0 -3 10 -24 49 -89 145 [11] -208 245 -174 -176 1121 -3185 7137 -13920 24301 -37926 Round trip: [1] 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37
We use here the SEQ and ∑LISTinstructions, available for HP-48G or newer models only.
| RPL code | Comment |
|---|---|
≪ DUP SIZE → seq n
≪ { 1 } 2 n FOR j
'COMB(j-1,k)' 'k' 0 j 1 - 1 SEQ
seq 1 j SUB
* ∑LIST +
NEXT
≫ ≫ ‘FBITR’ STO
≪ DUP SIZE → seq n
≪ { 1 } 2 n FOR j
'(-1)^(j-k-1)*COMB(j-1,k)' 'k' 0 j 1 - 1 SEQ
seq 1 j SUB * ∑LIST +
NEXT
≫ ≫ ‘RBITR’ STO
|
FBITR ( { a(n) } -- { b(n) } )
output = { 2 } ; loop for j=2 to n
get a j-list of c(j-1,k) with k from 0 to j-1
get a j-list of a(k)
multiply the 2 lists, reduce and append result to output
end loop
return list
RBITR ( { b(n) } -- { a(n) } )
same implementation as FBITR
only the formula for kth term is different here
|
If wanting to stick to the basic HP-28 instruction set and no algebraic expressions:
≪ DUP SIZE → seq n
≪ { } 1 n FOR j
0 1 j FOR k
seq k GET j 1 - k 1 - COMB * +
NEXT + NEXT
≫ ≫ ‘FBITR’ STO
≪ DUP SIZE → seq n
≪ { } 1 n FOR j
0 1 j FOR k
seq k GET j 1 - k 1 - COMB * -1 j k - ^ * +
NEXT + NEXT
≫ ≫ ‘RBITR’ STO
- Input:
{ 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 } 'ZCAT' STO
{ 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 } 'ZPFF' STO
{ 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 } 'ZFIB' STO
{ 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 } 'ZPAD' STO
ZCAT FBITR ZCAT RBITR ZCAT FBITR RBITR
ZPFF FBITR ZPFF RBITR ZPFF FBITR RBITR
ZFIB FBITR ZFIB RBITR ZFIB FBITR RBITR
ZPAD FBITR ZPAD RBITR ZPAD FBITR RBITR
- Output:
12: { 1 2 5 15 51 188 731 2950 12235 51822 223191 974427 4302645 19181100 86211885 }
11: { 1 0 1 1 3 6 15 36 91 232 603 1585 4213 11298 30537 }
10: { 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 }
9: { 0 1 3 6 11 20 37 70 134 255 476 869 1564 2821 5201 }
8: { 0 1 -1 0 3 -10 25 -56 118 -237 456 -847 1540 -2795 5173 }
7: { 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 }
6: { 0 1 3 8 21 55 144 377 987 2584 6765 17711 46368 121393 317811 }
5: { 0 1 -1 2 -3 5 -8 13 -21 34 -55 89 -144 233 -377 }
4: { 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 }
3: { 1 1 1 2 5 12 28 65 151 351 816 1897 4410 10252 23833 }
2: { 1 -1 1 0 -3 10 -24 49 -89 145 -208 245 -174 -176 1121 }
1: { 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 }
use std::convert::TryInto;
use std::fmt;
fn print_vector<T: fmt::Display>(vec: &Vec<T>) {
for element in vec {
print!("{} ", element);
}
}
fn factorial(number: u32) -> Result<u64, String> {
if number > 20 {
return Err(format!("Too large for 64 bit number: {}", number));
}
if number < 2 {
return Ok(1);
}
let mut factorial: u64 = 1;
for i in 2..=number {
factorial *= u64::from(i);
}
Ok(factorial)
}
fn binomial(n: u32, k: u32) -> Result<u64, String> {
let n_fact = factorial(n)?;
let n_minus_k_fact = factorial(n - k)?;
let k_fact = factorial(k)?;
Ok(n_fact / n_minus_k_fact / k_fact)
}
fn forward(vec: &Vec<i64>) -> Result<Vec<i64>, String> {
let size = vec.len();
let mut transform: Vec<i64> = vec![0; size];
for n in 0..size {
for k in 0..=n {
let binomial_coeff = binomial(n.try_into().unwrap(), k.try_into().unwrap())?;
transform[n] += (binomial_coeff as i64) * vec[k];
}
}
Ok(transform)
}
fn inverse(vec: &Vec<i64>) -> Result<Vec<i64>, String> {
let size = vec.len();
let mut transform: Vec<i64> = vec![0; size];
for n in 0..size {
for k in 0..=n {
let binomial_coeff = binomial(n.try_into().unwrap(), k.try_into().unwrap())?;
let sign: i32 = if (n - k) % 2 == 1 { -1 } else { 1 };
transform[n] += (binomial_coeff as i64) * vec[k] * (sign as i64);
}
}
Ok(transform)
}
fn self_inverting(vec: &Vec<i64>) -> Result<Vec<i64>, String> {
let size = vec.len();
let mut transform: Vec<i64> = vec![0; size];
for n in 0..size {
for k in 0..=n {
let binomial_coeff = binomial(n.try_into().unwrap(), k.try_into().unwrap())?;
let sign: i32 = if k % 2 == 1 { -1 } else { 1 };
transform[n] += (binomial_coeff as i64) * vec[k] * (sign as i64);
}
}
Ok(transform)
}
fn main() -> Result<(), String> {
let sequences: Vec<Vec<i64>> = vec![
vec![
1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440,
9694845,
],
vec![0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0],
vec![
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181,
],
vec![
1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37,
],
];
let names: Vec<String> = vec![
"Catalan number sequence:".to_string(),
"Prime flip-flop sequence:".to_string(),
"Fibonacci number sequence:".to_string(),
"Padovan number sequence:".to_string(),
];
for i in 0..sequences.len() {
println!("{}", names[i]);
print_vector(&sequences[i]);
println!("\nForward binomial transform:");
print_vector(&forward(&sequences[i])?);
println!("\nInverse binomial transform:");
print_vector(&inverse(&sequences[i])?);
println!("\nRound trip:");
print_vector(&inverse(&forward(&sequences[i])?)?);
println!("\nSelf-inverting:");
print_vector(&self_inverting(&sequences[i])?);
println!("\nRound trip self-inverting:");
print_vector(&self_inverting(&self_inverting(&sequences[i])?)?);
println!("\n\n");
}
Ok(())
}
- Output:
Catalan number sequence: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 Forward binomial transform: 1 2 5 15 51 188 731 2950 12235 51822 223191 974427 4302645 19181100 86211885 390248055 Inverse binomial transform: 1 0 1 1 3 6 15 36 91 232 603 1585 4213 11298 30537 83097 Round trip: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 Self-inverting: 1 0 1 -1 3 -6 15 -36 91 -232 603 -1585 4213 -11298 30537 -83097 Round trip self-inverting: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 Prime flip-flop sequence: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Forward binomial transform: 0 1 3 6 11 20 37 70 134 255 476 869 1564 2821 5201 9948 19793 40562 84271 174952 Inverse binomial transform: 0 1 -1 0 3 -10 25 -56 118 -237 456 -847 1540 -2795 5173 -9918 19761 -40528 84235 -174914 Round trip: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Self-inverting: 0 -1 -1 0 3 10 25 56 118 237 456 847 1540 2795 5173 9918 19761 40528 84235 174914 Round trip self-inverting: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Fibonacci number sequence: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Forward binomial transform: 0 1 3 8 21 55 144 377 987 2584 6765 17711 46368 121393 317811 832040 2178309 5702887 14930352 39088169 Inverse binomial transform: 0 1 -1 2 -3 5 -8 13 -21 34 -55 89 -144 233 -377 610 -987 1597 -2584 4181 Round trip: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Self-inverting: 0 -1 -1 -2 -3 -5 -8 -13 -21 -34 -55 -89 -144 -233 -377 -610 -987 -1597 -2584 -4181 Round trip self-inverting: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Padovan number sequence: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37 Forward binomial transform: 1 1 1 2 5 12 28 65 151 351 816 1897 4410 10252 23833 55405 128801 299426 696081 1618192 Inverse binomial transform: 1 -1 1 0 -3 10 -24 49 -89 145 -208 245 -174 -176 1121 -3185 7137 -13920 24301 -37926 Round trip: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37 Self-inverting: 1 1 1 0 -3 -10 -24 -49 -89 -145 -208 -245 -174 176 1121 3185 7137 13920 24301 37926 Round trip self-inverting: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37
import Foundation
func printVector(_ vec: [Int]) {
print(vec.map { String($0) }.joined(separator: " "))
}
func factorial(_ number: Int) -> Int {
if number > 20 {
fatalError("Too large for 64 bit number: \(number)")
}
if number < 2 {
return 1
}
var result = 1
for i in 2...number {
result *= i
}
return result
}
func binomial(_ n: Int, _ k: Int) -> Int {
return factorial(n) / factorial(n - k) / factorial(k)
}
func forward(_ vec: [Int]) -> [Int] {
var transform = [Int](repeating: 0, count: vec.count)
for n in 0..<vec.count {
for k in 0...n {
transform[n] += binomial(n, k) * vec[k]
}
}
return transform
}
func inverse(_ vec: [Int]) -> [Int] {
var transform = [Int](repeating: 0, count: vec.count)
for n in 0..<vec.count {
for k in 0...n {
let sign = ((n - k) & 1) != 0 ? -1 : 1
transform[n] += binomial(n, k) * vec[k] * sign
}
}
return transform
}
func selfInverting(_ vec: [Int]) -> [Int] {
var transform = [Int](repeating: 0, count: vec.count)
for n in 0..<vec.count {
for k in 0...n {
let sign = (k & 1) != 0 ? -1 : 1
transform[n] += binomial(n, k) * vec[k] * sign
}
}
return transform
}
let sequences: [[Int]] = [
[1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845],
[0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0],
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181],
[1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37]
]
let names = [
"Catalan number sequence:",
"Prime flip-flop sequence:",
"Fibonacci number sequence:",
"Padovan number sequence:"
]
for i in 0..<sequences.count {
print(names[i])
printVector(sequences[i])
print("Forward binomial transform:")
printVector(forward(sequences[i]))
print("Inverse binomial transform:")
printVector(inverse(sequences[i]))
print("Round trip:")
printVector(inverse(forward(sequences[i])))
print("Self-inverting:")
printVector(selfInverting(sequences[i]))
print("Round trip self-inverting:")
printVector(selfInverting(selfInverting(sequences[i])))
print()
}
- Output:
Catalan number sequence: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 Forward binomial transform: 1 2 5 15 51 188 731 2950 12235 51822 223191 974427 4302645 19181100 86211885 390248055 Inverse binomial transform: 1 0 1 1 3 6 15 36 91 232 603 1585 4213 11298 30537 83097 Round trip: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 Self-inverting: 1 0 1 -1 3 -6 15 -36 91 -232 603 -1585 4213 -11298 30537 -83097 Round trip self-inverting: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 Prime flip-flop sequence: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Forward binomial transform: 0 1 3 6 11 20 37 70 134 255 476 869 1564 2821 5201 9948 19793 40562 84271 174952 Inverse binomial transform: 0 1 -1 0 3 -10 25 -56 118 -237 456 -847 1540 -2795 5173 -9918 19761 -40528 84235 -174914 Round trip: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Self-inverting: 0 -1 -1 0 3 10 25 56 118 237 456 847 1540 2795 5173 9918 19761 40528 84235 174914 Round trip self-inverting: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Fibonacci number sequence: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Forward binomial transform: 0 1 3 8 21 55 144 377 987 2584 6765 17711 46368 121393 317811 832040 2178309 5702887 14930352 39088169 Inverse binomial transform: 0 1 -1 2 -3 5 -8 13 -21 34 -55 89 -144 233 -377 610 -987 1597 -2584 4181 Round trip: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Self-inverting: 0 -1 -1 -2 -3 -5 -8 -13 -21 -34 -55 -89 -144 -233 -377 -610 -987 -1597 -2584 -4181 Round trip self-inverting: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Padovan number sequence: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37 Forward binomial transform: 1 1 1 2 5 12 28 65 151 351 816 1897 4410 10252 23833 55405 128801 299426 696081 1618192 Inverse binomial transform: 1 -1 1 0 -3 10 -24 49 -89 145 -208 245 -174 -176 1121 -3185 7137 -13920 24301 -37926 Round trip: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37 Self-inverting: 1 1 1 0 -3 -10 -24 -49 -89 -145 -208 -245 -174 176 1121 3185 7137 13920 24301 37926 Round trip self-inverting: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37
const sequences = [
[i64(1), 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845]
[i64(0), 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0]
[i64(0), 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181]
[i64(1), 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37]
]
const names = [
'Catalan number sequence:',
'Prime flip-flop sequence:',
'Fibonacci number sequence:',
'Padovan number sequence:',
]
fn main() {
for i, seq in sequences {
println(names[i])
println(seq.str())
println('Forward binomial transform:')
println(forward(seq).str())
println('Inverse binomial transform:')
println(inverse(seq).str())
println('Round trip:')
println(inverse(forward(seq)).str())
println('Self-inverting:')
println(self_inverting(seq).str())
println('Round trip self-inverting:')
println(self_inverting(self_inverting(seq)).str())
println('')
}
}
fn self_inverting(numbers []i64) []i64 {
mut transform := []i64{len: numbers.len, init: 0}
for n in 0 .. numbers.len {
for k in 0 .. n + 1 {
sign := if k % 2 == 1 { -1 } else { 1 }
transform[n] += binomial(n, k) * numbers[k] * sign
}
}
return transform
}
fn inverse(numbers []i64) []i64 {
mut transform := []i64{len: numbers.len, init: 0}
for n in 0 .. numbers.len {
for k in 0 .. n + 1 {
sign := if (n - k) % 2 == 1 { -1 } else { 1 }
transform[n] += binomial(n, k) * numbers[k] * sign
}
}
return transform
}
fn forward(numbers []i64) []i64 {
mut transform := []i64{len: numbers.len, init: 0}
for n in 0 .. numbers.len {
for k in 0 .. n + 1 {
transform[n] += binomial(n, k) * numbers[k]
}
}
return transform
}
fn binomial(n int, k int) i64 {
return factorial(n) / factorial(n - k) / factorial(k)
}
fn factorial(number int) i64 {
mut fact := i64(1)
if number > 20 { panic('Factorial of number is too large: $number') }
if number < 2 { return 1 }
for i in 2 .. number + 1 {
fact *= i
}
return fact
}
- Output:
Catalan number sequence: [1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845] Forward binomial transform: [1, 2, 5, 15, 51, 188, 731, 2950, 12235, 51822, 223191, 974427, 4302645, 19181100, 86211885, 390248055] Inverse binomial transform: [1, 0, 1, 1, 3, 6, 15, 36, 91, 232, 603, 1585, 4213, 11298, 30537, 83097] Round trip: [1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845] Self-inverting: [1, 0, 1, -1, 3, -6, 15, -36, 91, -232, 603, -1585, 4213, -11298, 30537, -83097] Round trip self-inverting: [1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845] Prime flip-flop sequence: [0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0] Forward binomial transform: [0, 1, 3, 6, 11, 20, 37, 70, 134, 255, 476, 869, 1564, 2821, 5201, 9948, 19793, 40562, 84271, 174952] Inverse binomial transform: [0, 1, -1, 0, 3, -10, 25, -56, 118, -237, 456, -847, 1540, -2795, 5173, -9918, 19761, -40528, 84235, -174914] Round trip: [0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0] Self-inverting: [0, -1, -1, 0, 3, 10, 25, 56, 118, 237, 456, 847, 1540, 2795, 5173, 9918, 19761, 40528, 84235, 174914] Round trip self-inverting: [0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0] Fibonacci number sequence: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181] Forward binomial transform: [0, 1, 3, 8, 21, 55, 144, 377, 987, 2584, 6765, 17711, 46368, 121393, 317811, 832040, 2178309, 5702887, 14930352, 39088169] Inverse binomial transform: [0, 1, -1, 2, -3, 5, -8, 13, -21, 34, -55, 89, -144, 233, -377, 610, -987, 1597, -2584, 4181] Round trip: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181] Self-inverting: [0, -1, -1, -2, -3, -5, -8, -13, -21, -34, -55, -89, -144, -233, -377, -610, -987, -1597, -2584, -4181] Round trip self-inverting: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181] Padovan number sequence: [1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37] Forward binomial transform: [1, 1, 1, 2, 5, 12, 28, 65, 151, 351, 816, 1897, 4410, 10252, 23833, 55405, 128801, 299426, 696081, 1618192] Inverse binomial transform: [1, -1, 1, 0, -3, 10, -24, 49, -89, 145, -208, 245, -174, -176, 1121, -3185, 7137, -13920, 24301, -37926] Round trip: [1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37] Self-inverting: [1, 1, 1, 0, -3, -10, -24, -49, -89, -145, -208, -245, -174, 176, 1121, 3185, 7137, 13920, 24301, 37926] Round trip self-inverting: [1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37]
This hard-codes the sequences to be tested as I couldn't see much point in repeating code from the related tasks.
import "./long" for Long, ULong
class BT {
static forward(a) {
var c = a.count
var b = List.filled(c, null)
for (n in 0...c) {
b[n] = Long.zero
for (k in 0..n) b[n] = b[n] + ULong.binomial(n, k).toLong * a[k]
}
return b
}
static inverse(b) {
var c = b.count
var a = List.filled(c, null)
for (n in 0...c) {
a[n] = Long.zero
for (k in 0..n) {
var sign = ((n - k) % 2 == 0) ? 1 : -1
a[n] = a[n] + ULong.binomial(n, k).toLong * b[k] * sign
}
}
return a
}
static selfInverting(a) {
var c = a.count
var b = List.filled(c, null)
for (n in 0...c) {
b[n] = Long.zero
for (k in 0..n) {
var sign = k % 2 == 0 ? 1 : -1
b[n] = b[n] + ULong.binomial(n, k).toLong * a[k] * sign
}
}
return b
}
}
var seqs = [
[1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845, 35357670, 129644790, 477638700, 1767263190],
[0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0],
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181],
[1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37]
]
var names = [
"Catalan number sequence:",
"Prime flip-flop sequence:",
"Fibonacci number sequence:",
"Padovan number sequence:"
]
var saved
for (i in 0...seqs.count) {
System.print(names[i])
System.print(seqs[i].join(" "))
System.print("Forward binomial transform:")
System.print((saved = BT.forward(seqs[i])).join(" "))
System.print("Inverse binomial transform:")
System.print(BT.inverse(seqs[i]).join(" "))
System.print("Round trip:")
System.print(BT.inverse(saved).join(" "))
System.print("Self-inverting:")
System.print((saved = BT.selfInverting(seqs[i])).join(" "))
System.print("Re-inverted:")
System.print(BT.selfInverting(saved).join(" "))
if (i < seqs.count - 1) System.print()
}
- Output:
Catalan number sequence: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 35357670 129644790 477638700 1767263190 Forward binomial transform: 1 2 5 15 51 188 731 2950 12235 51822 223191 974427 4302645 19181100 86211885 390248055 1777495635 8140539950 37463689775 173164232965 Inverse binomial transform: 1 0 1 1 3 6 15 36 91 232 603 1585 4213 11298 30537 83097 227475 625992 1730787 4805595 Round trip: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 35357670 129644790 477638700 1767263190 Self-inverting: 1 0 1 -1 3 -6 15 -36 91 -232 603 -1585 4213 -11298 30537 -83097 227475 -625992 1730787 -4805595 Re-inverted: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 35357670 129644790 477638700 1767263190 Prime flip-flop sequence: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Forward binomial transform: 0 1 3 6 11 20 37 70 134 255 476 869 1564 2821 5201 9948 19793 40562 84271 174952 Inverse binomial transform: 0 1 -1 0 3 -10 25 -56 118 -237 456 -847 1540 -2795 5173 -9918 19761 -40528 84235 -174914 Round trip: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Self-inverting: 0 -1 -1 0 3 10 25 56 118 237 456 847 1540 2795 5173 9918 19761 40528 84235 174914 Re-inverted: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Fibonacci number sequence: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Forward binomial transform: 0 1 3 8 21 55 144 377 987 2584 6765 17711 46368 121393 317811 832040 2178309 5702887 14930352 39088169 Inverse binomial transform: 0 1 -1 2 -3 5 -8 13 -21 34 -55 89 -144 233 -377 610 -987 1597 -2584 4181 Round trip: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Self-inverting: 0 -1 -1 -2 -3 -5 -8 -13 -21 -34 -55 -89 -144 -233 -377 -610 -987 -1597 -2584 -4181 Re-inverted: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Padovan number sequence: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37 Forward binomial transform: 1 1 1 2 5 12 28 65 151 351 816 1897 4410 10252 23833 55405 128801 299426 696081 1618192 Inverse binomial transform: 1 -1 1 0 -3 10 -24 49 -89 145 -208 245 -174 -176 1121 -3185 7137 -13920 24301 -37926 Round trip: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37 Self-inverting: 1 1 1 0 -3 -10 -24 -49 -89 -145 -208 -245 -174 176 1121 3185 7137 13920 24301 37926 Re-inverted: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37
func real Factorial(N);
int N, I;
real F;
[F:= 1.;
for I:= 2 to N do F:= F * float(I);
return F;
];
func real Binomial(N, K);
int N, K;
return Factorial(N) / Factorial(N-K) / Factorial(K);
proc BinomialFwd(A, B, M);
real A, B; int M;
int N, K;
[for N:= 0 to M-1 do
[B(N):= 0.;
for K:= 0 to N do
B(N):= B(N) + Binomial(N, K) * A(K);
];
];
proc BinomialInv(A, B, M);
real A, B; int M;
int N, K, Sign;
[for N:= 0 to M-1 do
[A(N):= 0.;
for K:= 0 to N do
[Sign:= if N-K & 1 then -1 else 1;
A(N):= A(N) + float(Sign) * Binomial(N, K) * B(K);
];
];
];
real Fwd(20), Inv(20), Seqs;
int Title, I, J;
[Seqs:= [
[1., 1., 2., 5., 14., 42., 132., 429., 1430., 4862., 16796., 58786., 208012.,
742900., 2674440., 9694845., 35357670., 129644790., 477638700., 1767263190.],
[0., 1., 1., 0., 1., 0., 1., 0., 0., 0., 1., 0., 1., 0., 0., 0., 1., 0., 1., 0.],
[0., 1., 1., 2., 3., 5., 8., 13., 21., 34., 55., 89., 144., 233., 377., 610.,
987., 1597., 2584., 4181.],
[1., 0., 0., 1., 0., 1., 1., 1., 2., 2., 3., 4., 5., 7., 9., 12., 16., 21., 28., 37.]];
Title:= [
"Catalan number sequence:",
"Prime flip-flop sequence:",
"Fibonacci number sequence:",
"Padovan number sequence:" ];
Format(1,0);
for I:= 0 to 4-1 do
[Text(0, Title(I)); CrLf(0);
for J:= 0 to 20-1 do [RlOut(0, Seqs(I,J)); ChOut(0, ^ )];
Text(0, "^m^jForward binomial transform:^m^j");
BinomialFwd(Seqs(I), Fwd, 20);
for J:= 0 to 20-1 do [RlOut(0, Fwd(J)); ChOut(0, ^ )];
Text(0, "^m^jInverse binomial transform:^m^j");
BinomialInv(Inv, Seqs(I), 20);
for J:= 0 to 20-1 do [RlOut(0, Inv(J)); ChOut(0, ^ )];
Text(0, "^m^jRound trip:^m^j");
BinomialInv(Inv, Fwd, 20);
for J:= 0 to 20-1 do [RlOut(0, Inv(J)); ChOut(0, ^ )];
if I < 3 then CrLf(0);
CrLf(0);
];
]- Output:
Catalan number sequence: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 35357670 129644790 477638700 1767263190 Forward binomial transform: 1 2 5 15 51 188 731 2950 12235 51822 223191 974427 4302645 19181100 86211885 390248055 1777495635 8140539950 37463689775 173164232965 Inverse binomial transform: 1 0 1 1 3 6 15 36 91 232 603 1585 4213 11298 30537 83097 227475 625992 1730787 4805595 Round trip: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 35357670 129644790 477638700 1767263190 Prime flip-flop sequence: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Forward binomial transform: 0 1 3 6 11 20 37 70 134 255 476 869 1564 2821 5201 9948 19793 40562 84271 174952 Inverse binomial transform: 0 1 -1 0 3 -10 25 -56 118 -237 456 -847 1540 -2795 5173 -9918 19761 -40528 84235 -174914 Round trip: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Fibonacci number sequence: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Forward binomial transform: 0 1 3 8 21 55 144 377 987 2584 6765 17711 46368 121393 317811 832040 2178309 5702887 14930352 39088169 Inverse binomial transform: 0 1 -1 2 -3 5 -8 13 -21 34 -55 89 -144 233 -377 610 -987 1597 -2584 4181 Round trip: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Padovan number sequence: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37 Forward binomial transform: 1 1 1 2 5 12 28 65 151 351 816 1897 4410 10252 23833 55405 128801 299426 696081 1618192 Inverse binomial transform: 1 -1 1 0 -3 10 -24 49 -89 145 -208 245 -174 -176 1121 -3185 7137 -13920 24301 -37926 Round trip: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37
const std = @import("std");
const print = std.debug.print;
const ArrayList = std.ArrayList;
const Allocator = std.mem.Allocator;
const BinomialError = error{
TooLarge,
OutOfMemory,
};
fn printVector(comptime T: type, vec: []const T) void {
for (vec) |element| {
print("{} ", .{element} );
}
}
fn factorial(number: u32) BinomialError!u64 {
if (number > 20) {
print("Too large for 64 bit number: {}\n", .{number});
return BinomialError.TooLarge;
}
if (number < 2) {
return 1;
}
var fact: u64 = 1;
var i: u32 = 2;
while (i <= number) : (i += 1) {
fact *= @as(u64, i);
}
return fact;
}
fn binomial(n: u32, k: u32) BinomialError!u64 {
const n_fact = try factorial(n);
const n_minus_k_fact = try factorial(n - k);
const k_fact = try factorial(k);
return n_fact / n_minus_k_fact / k_fact;
}
fn forward(allocator: Allocator, vec: []const i64) BinomialError![]i64 {
const size = vec.len;
var transform = try allocator.alloc(i64, size);
// Initialize to zero
for (transform) |*elem| {
elem.* = 0;
}
for (0..size) |n| {
for (0..n + 1) |k| {
const binomial_coeff = try binomial(@intCast(n), @intCast(k));
transform[n] += @as(i64, @intCast(binomial_coeff)) * vec[k];
}
}
return transform;
}
fn inverse(allocator: Allocator, vec: []const i64) BinomialError![]i64 {
const size = vec.len;
var transform = try allocator.alloc(i64, size);
// Initialize to zero
for (transform) |*elem| {
elem.* = 0;
}
for (0..size) |n| {
for (0..n + 1) |k| {
const binomial_coeff = try binomial(@intCast(n), @intCast(k));
const sign: i32 = if ((n - k) % 2 == 1) -1 else 1;
transform[n] += @as(i64, @intCast(binomial_coeff)) * vec[k] * @as(i64, sign);
}
}
return transform;
}
fn selfInverting(allocator: Allocator, vec: []const i64) BinomialError![]i64 {
const size = vec.len;
var transform = try allocator.alloc(i64, size);
// Initialize to zero
for (transform) |*elem| {
elem.* = 0;
}
for (0..size) |n| {
for (0..n + 1) |k| {
const binomial_coeff = try binomial(@intCast(n), @intCast(k));
const sign: i32 = if (k % 2 == 1) -1 else 1;
transform[n] += @as(i64, @intCast(binomial_coeff)) * vec[k] * @as(i64, sign);
}
}
return transform;
}
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const allocator = gpa.allocator();
const sequences = [_][]const i64{
&[_]i64{ 1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845 },
&[_]i64{ 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0 },
&[_]i64{ 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181 },
&[_]i64{ 1, 0, 0, 1, 0, 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37 },
};
const names = [_][]const u8{
"Catalan number sequence:",
"Prime flip-flop sequence:",
"Fibonacci number sequence:",
"Padovan number sequence:",
};
for (sequences, 0..) |sequence, i| {
print("{s}\n", .{names[i]});
printVector(i64, sequence);
print("\nForward binomial transform:\n" , .{});
const forward_result = try forward(allocator, sequence);
defer allocator.free(forward_result);
printVector(i64, forward_result);
print("\nInverse binomial transform:\n", .{});
const inverse_result = try inverse(allocator, sequence);
defer allocator.free(inverse_result);
printVector(i64, inverse_result);
print("\nRound trip:\n", .{});
const round_trip = try inverse(allocator, forward_result);
defer allocator.free(round_trip);
printVector(i64, round_trip);
print("\nSelf-inverting:\n", .{});
const self_inv_result = try selfInverting(allocator, sequence);
defer allocator.free(self_inv_result);
printVector(i64, self_inv_result);
print("\nRound trip self-inverting:\n", .{});
const self_inv_round_trip = try selfInverting(allocator, self_inv_result);
defer allocator.free(self_inv_round_trip);
printVector(i64, self_inv_round_trip);
print("\n\n", .{});
}
}
- Output:
Catalan number sequence: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 Forward binomial transform: 1 2 5 15 51 188 731 2950 12235 51822 223191 974427 4302645 19181100 86211885 390248055 Inverse binomial transform: 1 0 1 1 3 6 15 36 91 232 603 1585 4213 11298 30537 83097 Round trip: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 Self-inverting: 1 0 1 -1 3 -6 15 -36 91 -232 603 -1585 4213 -11298 30537 -83097 Round trip self-inverting: 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 Prime flip-flop sequence: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Forward binomial transform: 0 1 3 6 11 20 37 70 134 255 476 869 1564 2821 5201 9948 19793 40562 84271 174952 Inverse binomial transform: 0 1 -1 0 3 -10 25 -56 118 -237 456 -847 1540 -2795 5173 -9918 19761 -40528 84235 -174914 Round trip: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Self-inverting: 0 -1 -1 0 3 10 25 56 118 237 456 847 1540 2795 5173 9918 19761 40528 84235 174914 Round trip self-inverting: 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 1 0 Fibonacci number sequence: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Forward binomial transform: 0 1 3 8 21 55 144 377 987 2584 6765 17711 46368 121393 317811 832040 2178309 5702887 14930352 39088169 Inverse binomial transform: 0 1 -1 2 -3 5 -8 13 -21 34 -55 89 -144 233 -377 610 -987 1597 -2584 4181 Round trip: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Self-inverting: 0 -1 -1 -2 -3 -5 -8 -13 -21 -34 -55 -89 -144 -233 -377 -610 -987 -1597 -2584 -4181 Round trip self-inverting: 0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 Padovan number sequence: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37 Forward binomial transform: 1 1 1 2 5 12 28 65 151 351 816 1897 4410 10252 23833 55405 128801 299426 696081 1618192 Inverse binomial transform: 1 -1 1 0 -3 10 -24 49 -89 145 -208 245 -174 -176 1121 -3185 7137 -13920 24301 -37926 Round trip: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37 Self-inverting: 1 1 1 0 -3 -10 -24 -49 -89 -145 -208 -245 -174 176 1121 3185 7137 13920 24301 37926 Round trip self-inverting: 1 0 0 1 0 1 1 1 2 2 3 4 5 7 9 12 16 21 28 37