Bell numbers: Difference between revisions
m
→{{header|ALGOL W}}: fixed trans
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
m (→{{header|ALGOL W}}: fixed trans) |
||
(23 intermediate revisions by 11 users not shown) | |||
Line 35:
{{trans|Python}}
<syntaxhighlight lang="11l">F bellTriangle(n)
[[BigInt]] tri
L(i) 0 .< n
Line 91:
=={{header|Ada}}==
{{works with|GNAT|8.3.0}}
<syntaxhighlight lang=
with Ada.Text_IO; use Ada.Text_IO;
procedure Main is
Line 188:
{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}
Uses Algol 68G's LONG LONG INT to calculate the numbers up to 50. Calculates the numbers using the triangle algorithm but without storing the triangle as a whole - each line of the triangle replaces the previous one.
<syntaxhighlight lang="algol68">BEGIN # show some Bell numbers #
PROC show bell = ( INT n, LONG LONG INT bell number )VOID:
print( ( whole( n, -2 ), ": ", whole( bell number, 0 ), newline ) );
Line 231:
=={{header|ALGOL-M}}==
<syntaxhighlight lang="algolm">begin
integer function index(row, col);
integer row, col;
Line 296:
4140.0 5017.0 6097.0 7432.0 9089.0 11155.0 13744.0 17007.0 21147.0
21147.0 25287.0 30304.0 36401.0 43833.0 52922.0 64077.0 77821.0 94828.0 115975.0</pre>
=={{header|ALGOL W}}==
{{Trans|ALGOL 68|First 15 numbers only}}
<syntaxhighlight lang="algolw">
begin % show some Bell numbers %
integer MAX_BELL;
MAX_BELL := 15;
begin
procedure showBell ( integer value n, bellNumber ) ;
write( i_w := 2, s_w := 0, n, ": ", i_w := 1, bellNumber );
integer array a ( 0 :: MAX_BELL - 2 );
for i := 1 until MAX_BELL - 2 do a( i ) := 0;
a( 0 ) := 1;
showBell( 1, a( 0 ) );
for n := 0 until MAX_BELL - 2 do begin
% replace a with the next line of the triangle %
a( n ) := a( 0 );
for j := n step -1 until 1 do a( j - 1 ) := a( j - 1 ) + a( j );
showBell( n + 2, a( 0 ) )
end for_n
end
end.
</syntaxhighlight>
{{out}}
<pre>
1: 1
2: 1
3: 2
4: 5
5: 15
6: 52
7: 203
8: 877
9: 4140
10: 21147
11: 115975
12: 678570
13: 4213597
14: 27644437
15: 190899322
</pre>
=={{header|APL}}==
{{works with|Dyalog APL}}
<syntaxhighlight lang="apl">bell←{
tr←↑(⊢,(⊂⊃∘⌽+0,+\)∘⊃∘⌽)⍣14⊢,⊂,1
⎕←'First 15 Bell numbers:'
Line 321 ⟶ 362:
21147 25287 30304 36401 43833 52922 64077 77821 94828 115975</pre>
=={{header|Arturo}}==
{{trans|D}}
<syntaxhighlight lang="rebol">bellTriangle: function[n][
tri: map 0..n-1 'x [ map 0..n 'y -> 0 ]
set get tri 1 0 1
Line 422 ⟶ 418:
=={{header|AutoHotkey}}==
<syntaxhighlight lang=
Bell_triangle(maxRows){
row := 1, col := 1, Arr := []
Line 454 ⟶ 450:
}
;-----------------------------------</syntaxhighlight>
Examples:<syntaxhighlight lang=
MsgBox % Show_Bell_triangle(Bell_triangle(10))
return</syntaxhighlight>
Line 484 ⟶ 480:
4140, 5017, 6097, 7432, 9089, 11155, 13744, 17007, 21147
21147, 25287, 30304, 36401, 43833, 52922, 64077, 77821, 94828, 115975</pre>
=={{header|BASIC}}==
==={{header|ANSI BASIC}}===
{{trans|QuickBASIC}}
{{works with|Decimal BASIC}}
<syntaxhighlight lang="basic">
100 REM Bell numbers
110 LET MaxN = 14
120 OPTION BASE 0
130 DIM A(13) ! i.e. DIM A(MaxN - 1), ANSI BASIC does not allow expressions in the bound arguments.
140 FOR I = 0 TO MaxN - 1
150 LET A(I) = 0
160 NEXT I
170 LET N = 0
180 LET A(0) = 1
190 PRINT USING "B(##) = #########": N, A(0)
200 DO WHILE N < MaxN
210 LET A(N) = A(0)
220 FOR J = N TO 1 STEP -1
230 LET A(J - 1) = A(J - 1) + A(J)
240 NEXT J
250 LET N = N + 1
260 PRINT USING "B(##) = #########": N, A(0)
270 LOOP
280 END
</syntaxhighlight>
{{out}}
<pre>
B( 0) = 1
B( 1) = 1
B( 2) = 2
B( 3) = 5
B( 4) = 15
B( 5) = 52
B( 6) = 203
B( 7) = 877
B( 8) = 4140
B( 9) = 21147
B(10) = 115975
B(11) = 678570
B(12) = 4213597
B(13) = 27644437
B(14) = 190899322
</pre>
==={{header|Applesoft BASIC}}===
{{trans|C}}
<syntaxhighlight lang="gwbasic"> 100 LET ROWS = 15
110 LET M$ = CHR$ (13)
120 LET N = ROWS: GOSUB 500"BELLTRIANGLE"
130 PRINT "FIRST FIFTEEN BELL NUMBERS:"
140 FOR I = 1 TO ROWS
150 LET BR = I:BC = 0: GOSUB 350"GETBELL"
160 HTAB T * 13 + 1
170 PRINT RIGHT$ (" " + STR$ (I),2)": "BV; MID$ (M$,1,T = 2);
180 LET T = T + 1 - (T = 2) * 3
190 NEXT I
200 PRINT M$"THE FIRST TEN ROWS OF BELL'S TRIANGLE:";
210 FOR I = 1 TO 10
220 LET BR = I:BC = 0: GOSUB 350"GETBELL"
230 PRINT M$BV;
240 FOR J = 1 TO I - 1
250 IF I - 1 > = J THEN BR = I:BC = J: GOSUB 350"GETBELL": PRINT " "BV;
260 NEXT J,I
270 END
300 LET BI = BR * (BR - 1) / 2 + BC
310 RETURN
350 GOSUB 300"BELLINDEX"
360 LET BV = TRI(BI)
370 RETURN
400 GOSUB 300"BELLINDEX"
410 LET TRI(BI) = BV
420 RETURN
500 DIM TRI(N * (N + 1) / 2)
510 LET BR = 1:BC = 0:BV = 1: GOSUB 400"SETBELL"
520 FOR I = 2 TO N
530 LET BR = I - 1:BC = I - 2: GOSUB 350"GETBELL"
540 LET BR = I:BC = 0: GOSUB 400"SETBELL"
550 FOR J = 1 TO I - 1
560 LET BR = I:BC = J - 1: GOSUB 350"GETBELL":V = BV
570 LET BR = I - 1:BC = J - 1: GOSUB 350"GETBELL"
580 LET BR = I:BC = J:BV = V + BV: GOSUB 400"SETBELL"
590 NEXT J,I
600 RETURN</syntaxhighlight>
==={{header|ASIC}}===
{{trans|Delphi}}
Compile with the ''Extended math'' option.
<syntaxhighlight lang="basic">
REM Bell numbers
DIM A&(13)
FOR I = 0 TO 13
A&(I) = 0
NEXT I
N = 0
A&(0) = 1
GOSUB DisplayRow:
WHILE N <= 13
A&(N) = A&(0)
J = N
WHILE J >= 1
JM1 = J - 1
A&(JM1) = A&(JM1) + A&(J)
J = J - 1
WEND
N = N + 1
GOSUB DisplayRow:
WEND
END
DisplayRow:
PRINT "B(";
SN$ = STR$(N)
SN$ = RIGHT$(SN$, 2)
PRINT SN$;
PRINT ") =";
PRINT A&(0)
RETURN
</syntaxhighlight>
{{out}}
<pre>
B( 0) = 1
B( 1) = 1
B( 2) = 2
B( 3) = 5
B( 4) = 15
B( 5) = 52
B( 6) = 203
B( 7) = 877
B( 8) = 4140
B( 9) = 21147
B(10) = 115975
B(11) = 678570
B(12) = 4213597
B(13) = 27644437
B(14) = 190899322
</pre>
==={{header|Chipmunk Basic}}===
{{works with|Chipmunk Basic|3.6.4}}
{{trans|ASIC}}
<syntaxhighlight lang="qbasic">100 cls
110 dim a(13)
120 for i = 0 to ubound(a) : a(i) = 0 : next i
130 n = 0
140 a(0) = 1
150 displayrow()
160 while n <= ubound(a)
170 a(n) = a(0)
180 j = n
190 while j >= 1
200 jm1 = j-1
210 a(jm1) = a(jm1)+a(j)
220 j = j-1
230 wend
240 n = n+1
250 displayrow()
260 wend
270 end
280 sub displayrow()
290 print "B(";
300 print right$(str$(n),2)") = " a(0)
310 return</syntaxhighlight>
==={{header|FreeBASIC}}===
<syntaxhighlight lang="freebasic">#define MAX 21
#macro ncp(n, p)
(fact(n)/(fact(p))/(fact(n-p)))
#endmacro
dim as ulongint fact(0 to MAX), bell(0 to MAX)
dim as uinteger n=0, k
fact(0) = 1
for k=1 to MAX
fact(k) = k*fact(k-1)
next k
bell(n) = 1
print n, bell(n)
for n=0 to MAX-1
for k=0 to n
bell(n+1) += ncp(n, k)*bell(k)
next k
print n+1, bell(n+1)
next n</syntaxhighlight>
==={{header|GW-BASIC}}===
{{works with|Chipmunk Basic}}
{{works with|PC-BASIC|any}}
{{works with|QBasic}}
{{trans|Chipmunk Basic}}
<syntaxhighlight lang="qbasic">100 CLS
110 DIM A#(13)
120 FOR I = 0 TO UBOUND(A#) : A#(I) = 0 : NEXT I
130 N = 0
140 A#(0) = 1
150 GOSUB 280
160 WHILE N <= 13
170 A#(N) = A#(0)
180 J = N
190 WHILE J >= 1
200 JM1 = J-1
210 A#(JM1) = A#(JM1)+A#(J)
220 J = J-1
230 WEND
240 N = N+1
250 GOSUB 280
260 WEND
270 END
280 REM Display Row
290 PRINT "B(";
300 PRINT RIGHT$(STR$(N),2)") = " A#(0)
310 RETURN</syntaxhighlight>
==={{header|MSX Basic}}===
{{trans|Applesoft BASIC}}
<syntaxhighlight lang="qbasic">100 ROWS = 15
110 M$ = CHR$(13)
120 N = ROWS: GOSUB 500
130 PRINT "FIRST FIFTEEN BELL NUMBERS:"
140 FOR I = 1 TO ROWS
150 BR = I: BC = 0: GOSUB 350
160 PRINT RIGHT$(" " + STR$(I),2); ": "; BV; MID$(M$,1,2)
170 T = T + 1 - (T = 2) * 3
180 NEXT I
190 PRINT
200 PRINT "THE FIRST 10 ROWS OF BELL'S TRIANGLE:";
210 FOR I = 1 TO 10
220 BR = I: BC = 0: GOSUB 350
230 PRINT M$: PRINT BV;
240 FOR J = 1 TO I - 1
250 IF I - 1 >= J THEN BR = I: BC = J: GOSUB 350: PRINT BV;
260 NEXT J, I
270 END
300 BI = BR * (BR-1) / 2 + BC
310 RETURN
350 GOSUB 300
360 BV = TRI(BI)
370 RETURN
400 GOSUB 300
410 TRI(BI) = BV
420 RETURN
500 DIM TRI(N * (N+1) / 2)
510 BR = 1: BC = 0: BV = 1: GOSUB 400
520 FOR I = 2 TO N
530 BR = I - 1: BC = I - 2: GOSUB 350
540 BR = I: BC = 0: GOSUB 400
550 FOR J = 1 TO I - 1
560 BR = I: BC = J - 1: GOSUB 350: V = BV
570 BR = I - 1: BC = J - 1: GOSUB 350
580 BR = I: BC = J: BV = V + BV: GOSUB 400
590 NEXT J, I
600 RETURN</syntaxhighlight>
==={{header|QuickBASIC}}===
{{works with|QBasic|1.1}}
{{trans|Delphi}}
<syntaxhighlight lang="qbasic">
' Bell numbers
CONST MAXN% = 14
DIM A&(MAXN% - 1)
FOR I% = 0 TO MAXN% - 1
A&(I%) = 0
NEXT I%
N% = 0
A&(0) = 1
PRINT USING "B(##) = #########"; N%; A&(0)
WHILE N% < MAXN%
A&(N%) = A&(0)
FOR J% = N% TO 1 STEP -1
A&(J% - 1) = A&(J% - 1) + A&(J%)
NEXT J%
N% = N% + 1
PRINT USING "B(##) = #########"; N%; A&(0)
WEND
END
</syntaxhighlight>
{{out}}
<pre>
B( 0) = 1
B( 1) = 1
B( 2) = 2
B( 3) = 5
B( 4) = 15
B( 5) = 52
B( 6) = 203
B( 7) = 877
B( 8) = 4140
B( 9) = 21147
B(10) = 115975
B(11) = 678570
B(12) = 4213597
B(13) = 27644437
B(14) = 190899322
</pre>
==={{header|RapidQ}}===
{{trans|Delphi}}
{{trans|QuickBASIC|Translated only display statements, the rest is the same.}}
<syntaxhighlight lang="basic">
' Bell numbers
CONST MAXN% = 14
DIM A&(MAXN% - 1)
FOR I% = 0 TO MAXN% - 1
A&(I%) = 0
NEXT I%
N% = 0
A&(0) = 1
PRINT FORMAT$("B(%2d) = %9d", N%, A&(0))
WHILE N% < MAXN%
A&(N%) = A&(0)
FOR J% = N% TO 1 STEP -1
A&(J% - 1) = A&(J% - 1) + A&(J%)
NEXT J%
N% = N% + 1
PRINT FORMAT$("B(%2d) = %9d", N%, A&(0))
WEND
END
</syntaxhighlight>
{{out}}
<pre>
B( 0) = 1
B( 1) = 1
B( 2) = 2
B( 3) = 5
B( 4) = 15
B( 5) = 52
B( 6) = 203
B( 7) = 877
B( 8) = 4140
B( 9) = 21147
B(10) = 115975
B(11) = 678570
B(12) = 4213597
B(13) = 27644437
B(14) = 190899322
</pre>
==={{header|Visual Basic .NET}}===
{{trans|C#}}
<syntaxhighlight lang="vbnet">Imports System.Numerics
Imports System.Runtime.CompilerServices
Module Module1
<Extension()>
Sub Init(Of T)(array As T(), value As T)
If IsNothing(array) Then Return
For i = 0 To array.Length - 1
array(i) = value
Next
End Sub
Function BellTriangle(n As Integer) As BigInteger()()
Dim tri(n - 1)() As BigInteger
For i = 0 To n - 1
Dim temp(i - 1) As BigInteger
tri(i) = temp
tri(i).Init(0)
Next
tri(1)(0) = 1
For i = 2 To n - 1
tri(i)(0) = tri(i - 1)(i - 2)
For j = 1 To i - 1
tri(i)(j) = tri(i)(j - 1) + tri(i - 1)(j - 1)
Next
Next
Return tri
End Function
Sub Main()
Dim bt = BellTriangle(51)
Console.WriteLine("First fifteen Bell numbers:")
For i = 1 To 15
Console.WriteLine("{0,2}: {1}", i, bt(i)(0))
Next
Console.WriteLine("50: {0}", bt(50)(0))
Console.WriteLine()
Console.WriteLine("The first ten rows of Bell's triangle:")
For i = 1 To 10
Dim it = bt(i).GetEnumerator()
Console.Write("[")
If it.MoveNext() Then
Console.Write(it.Current)
End If
While it.MoveNext()
Console.Write(", ")
Console.Write(it.Current)
End While
Console.WriteLine("]")
Next
End Sub
End Module</syntaxhighlight>
{{out}}
<pre>First fifteen Bell numbers:
1: 1
2: 1
3: 2
4: 5
5: 15
6: 52
7: 203
8: 877
9: 4140
10: 21147
11: 115975
12: 678570
13: 4213597
14: 27644437
15: 190899322
50: 10726137154573358400342215518590002633917247281
The first ten rows of Bell's triangle:
[1]
[1, 2]
[2, 3, 5]
[5, 7, 10, 15]
[15, 20, 27, 37, 52]
[52, 67, 87, 114, 151, 203]
[203, 255, 322, 409, 523, 674, 877]
[877, 1080, 1335, 1657, 2066, 2589, 3263, 4140]
[4140, 5017, 6097, 7432, 9089, 11155, 13744, 17007, 21147]
[21147, 25287, 30304, 36401, 43833, 52922, 64077, 77821, 94828, 115975]</pre>
=={{header|C}}==
{{trans|D}}
<syntaxhighlight lang="c">#include <stdio.h>
#include <stdlib.h>
Line 577 ⟶ 1,003:
=={{header|C sharp|C#}}==
{{trans|D}}
<syntaxhighlight lang="csharp">using System;
using System.Numerics;
Line 666 ⟶ 1,092:
{{libheader|Boost}}
Requires C++14 or later. If HAVE_BOOST is defined, we use the cpp_int class from Boost so we can display the 50th Bell number, as shown in the output section below.
<syntaxhighlight lang="cpp">#include <iostream>
#include <vector>
Line 753 ⟶ 1,179:
=={{header|CLU}}==
<syntaxhighlight lang="clu">bell = cluster is make, get
rep = array[int]
Line 831 ⟶ 1,257:
=={{header|Common Lisp}}==
===via Bell triangle===
<syntaxhighlight lang="lisp">;; The triangle is a list of arrays; each array is a
;; triangle's row; the last row is at the head of the list.
(defun grow-triangle (triangle)
Line 930 ⟶ 1,356:
===via Stirling numbers of the second kind===
This solution's algorithm is substantially slower than the algorithm based on the Bell triangle, because of the many nested loops.
<syntaxhighlight lang="lisp">;;; Compute bell numbers analytically
;; Compute the factorial
Line 999 ⟶ 1,425:
=={{header|Cowgol}}==
{{trans|C}}
<syntaxhighlight lang="cowgol">include "cowgol.coh";
typedef B is uint32;
Line 1,101 ⟶ 1,527:
=={{header|D}}==
{{trans|Go}}
<syntaxhighlight lang="d">import std.array : uninitializedArray;
import std.bigint;
import std.stdio : writeln, writefln;
Line 1,169 ⟶ 1,595:
It shows a way of calculating Bell numbers without using a triangle.
Output numbering is as in the statement of the task, namely B_0 = 1, B_1 = 1, B_2 = 2, ....
<syntaxhighlight lang=
program BellNumbers;
Line 1,181 ⟶ 1,607:
const
var
n : integer; // index of Bell number
j : integer; // loop variable
a : array [0..
{ Subroutine to display that a[0] is the Bell number B_n }
Line 1,198 ⟶ 1,624:
a[0] := 1;
Display(); // some programmers would prefer Display;
while (n <
a[n] := a[0];
for j := n downto 1 do inc( a[j - 1], a[j]);
Line 1,235 ⟶ 1,661:
B_25 = 4638590332229999353
</pre>
=={{header|EasyLang}}==
{{trans|Julia}}
<syntaxhighlight lang="easylang">
func bell n .
len list[] n
list[1] = 1
for i = 2 to n
for j = 1 to i - 2
list[i - j - 1] += list[i - j]
.
list[i] = list[1] + list[i - 1]
.
return list[n]
.
for i = 1 to 15
print bell i
.
</syntaxhighlight>
=={{header|Elixir}}==
<syntaxhighlight lang=
defmodule Bell do
def triangle(), do: Stream.iterate([1], fn l -> bell_row l, [List.last l] end)
Line 1,279 ⟶ 1,724:
=={{header|F_Sharp|F#}}==
===The function===
<syntaxhighlight lang="fsharp">
// Generate bell triangle. Nigel Galloway: July 6th., 2019
let bell=Seq.unfold(fun g->Some(g,List.scan(+) (List.last g) g))[1I]
</syntaxhighlight>
===The Task===
<syntaxhighlight lang="fsharp">
bell|>Seq.take 10|>Seq.iter(printfn "%A")
</syntaxhighlight>
Line 1,300 ⟶ 1,745:
[21147; 25287; 30304; 36401; 43833; 52922; 64077; 77821; 94828; 115975]
</pre>
<syntaxhighlight lang="fsharp">
bell|>Seq.take 15|>Seq.iter(fun n->printf "%A " (List.head n));printfn ""
</syntaxhighlight>
Line 1,307 ⟶ 1,752:
1 1 2 5 15 52 203 877 4140 21147 115975 678570 4213597 27644437 190899322
</pre>
<syntaxhighlight lang="fsharp">
printfn "%A" (Seq.head (Seq.item 49 bell))
</syntaxhighlight>
Line 1,318 ⟶ 1,763:
===via Aitken's array===
{{works with|Factor|0.98}}
<syntaxhighlight lang="factor">USING: formatting io kernel math math.matrices sequences vectors ;
: next-row ( prev -- next )
Line 1,353 ⟶ 1,798:
This solution makes use of a [https://en.wikipedia.org/wiki/Bell_number#Summation_formulas recurrence relation] involving binomial coefficients.
{{works with|Factor|0.98}}
<syntaxhighlight lang="factor">USING: formatting kernel math math.combinatorics sequences ;
: next-bell ( seq -- n )
Line 1,373 ⟶ 1,818:
This solution defines Bell numbers in terms of [https://en.wikipedia.org/wiki/Bell_number#Summation_formulas sums of Stirling numbers of the second kind].
{{works with|Factor|0.99 development release 2019-07-10}}
<syntaxhighlight lang="factor">USING: formatting kernel math math.extras math.ranges sequences ;
: bell ( m -- n )
Line 1,383 ⟶ 1,828:
As above.
=={{header|
FB does not yet offer native support for Big Ints.
<syntaxhighlight lang="futurebasic">
local fn BellNumbers( limit as long )
long j, n = 1
mda(0) = 1
printf @"%2llu. %19llu", n, mda_integer(0)
while ( n < limit )
mda(n) = mda(0)
for j = n to 1 step -1
mda(j - 1) = mda_integer(j - 1) + mda_integer(j)
next
n++
printf @"%2llu. %19llu", n, mda_integer(0)
wend
end fn
fn BellNumbers( 25 )
HandleEvents
</syntaxhighlight>
{{output}}
<pre>
1. 1
2. 2
3. 5
4. 15
5. 52
6. 203
7. 877
8.
9.
10. 115975
11. 678570
12. 4213597
13. 27644437
14. 190899322
15. 1382958545
16. 10480142147
17. 82864869804
18. 682076806159
19. 5832742205057
20. 51724158235372
21. 474869816156751
22. 4506715738447323
23. 44152005855084346
24. 445958869294805289
25. 4638590332229999353
</pre>
=={{header|Go}}==
<syntaxhighlight lang="go">package main
import (
Line 1,481 ⟶ 1,953:
=={{header|Groovy}}==
{{trans|Java}}
<syntaxhighlight lang="groovy">class Bell {
private static class BellTriangle {
private List<Integer> arr
Line 1,569 ⟶ 2,041:
=={{header|Haskell}}==
<syntaxhighlight lang="haskell">bellTri :: [[Integer]]
bellTri =
let f xs = (last xs, xs)
Line 1,621 ⟶ 2,093:
And, of course, in terms of ''Control.Arrow'' or ''Control.Applicative'', the triangle function could also be written as:
<syntaxhighlight lang="haskell">import Control.Arrow
bellTri :: [[Integer]]
Line 1,628 ⟶ 2,100:
or:
<syntaxhighlight lang="haskell">import Control.Applicative
bellTri :: [[Integer]]
Line 1,634 ⟶ 2,106:
or, as an applicative without the need for an import:
<syntaxhighlight lang="haskell">bellTri :: [[Integer]]
bellTri = map snd (iterate (((,) . last <*> id) . uncurry (scanl (+))) (1, [1]))</syntaxhighlight>
=={{header|J}}==
<syntaxhighlight lang="text">
bell=: ([: +/\ (,~ {:))&.>@:{:
Line 1,663 ⟶ 2,135:
=={{header|Java}}==
{{trans|Kotlin}}
<syntaxhighlight lang="java">import java.util.ArrayList;
import java.util.List;
Line 1,754 ⟶ 2,226:
=={{header|jq}}==
{{trans|Julia}}
<syntaxhighlight lang="jq"># nth Bell number
def bell:
. as $n
Line 1,799 ⟶ 2,271:
=={{header|Julia}}==
Source: Combinatorics at https://github.com/JuliaMath/Combinatorics.jl/blob/master/src/numbers.jl
<syntaxhighlight lang="julia">"""
bellnum(n)
Compute the ``n``th Bell number.
Line 1,879 ⟶ 2,351:
=={{header|Kotlin}}==
{{trans|C}}
<syntaxhighlight lang="scala">class BellTriangle(n: Int) {
private val arr: Array<Int>
Line 1,963 ⟶ 2,435:
In order to handle arrays, a program for the LMC has to modify its own code. This practice is usually frowned on nowadays, but was standard on very early real-life computers, such as EDSAC.
<syntaxhighlight lang=
// Little Man Computer, for Rosetta Code.
// Calculate Bell numbers, using a 1-dimensional array and addition.
Line 2,052 ⟶ 2,524:
=={{header|Lua}}==
<syntaxhighlight lang="lua">-- Bell numbers in Lua
-- db 6/11/2020 (to replace missing original)
Line 2,114 ⟶ 2,586:
=={{header|Maple}}==
<syntaxhighlight lang="maple">bell1:=proc(n)
option remember;
add(binomial(n-1,k)*bell1(k),k=0..n-1)
Line 2,133 ⟶ 2,605:
=={{header|Mathematica}} / {{header|Wolfram Language}}==
'''Function definition:'''
<syntaxhighlight lang=
BellTriangle[n_Integer?Positive] := NestList[Accumulate[# /. {a___, b_} :> {b, a, b}] &, {1}, n - 1];
BellNumber[n_Integer] := BellTriangle[n][[n, 1]];
Line 2,139 ⟶ 2,611:
'''Output:'''
<syntaxhighlight lang=
In[51]:= Array[BellNumber, 25]
Line 2,155 ⟶ 2,627:
36401, 43833, 52922, 64077, 77821, 94828, 115975}}
</syntaxhighlight>
=={{header|Maxima}}==
It exists in Maxima the belln built-in function.
Below is another way
<syntaxhighlight lang="maxima">
/* Subfactorial numbers */
subfactorial(n):=block(
subf[0]:1,
subf[n]:n*subf[n-1]+(-1)^n,
subf[n])$
/* Bell numbers implementation */
my_bell(n):=if n=0 then 1 else block(
makelist((1/((n-1)!))*subfactorial(j)*binomial(n-1,j)*(n-j)^(n-1),j,0,n-1),
apply("+",%%))$
/* First 50 */
block(
makelist(my_bell(u),u,0,49),
table_form(%%));
</syntaxhighlight>
{{out}}
<pre>
matrix(
[1],
[1],
[2],
[5],
[15],
[52],
[203],
[877],
[4140],
[21147],
[115975],
[678570],
[4213597],
[27644437],
[190899322],
[1382958545],
[10480142147],
[82864869804],
[682076806159],
[5832742205057],
[51724158235372],
[474869816156751],
[4506715738447323],
[44152005855084346],
[445958869294805289],
[4638590332229999353],
[49631246523618756274],
[545717047936059989389],
[6160539404599934652455],
[71339801938860275191172],
[846749014511809332450147],
[10293358946226376485095653],
[128064670049908713818925644],
[1629595892846007606764728147],
[21195039388640360462388656799],
[281600203019560266563340426570],
[3819714729894818339975525681317],
[52868366208550447901945575624941],
[746289892095625330523099540639146],
[10738823330774692832768857986425209],
[157450588391204931289324344702531067],
[2351152507740617628200694077243788988],
[35742549198872617291353508656626642567],
[552950118797165484321714693280737767385],
[8701963427387055089023600531855797148876],
[139258505266263669602347053993654079693415],
[2265418219334494002928484444705392276158355],
[37450059502461511196505342096431510120174682],
[628919796303118415420210454071849537746015761],
[10726137154573358400342215518590002633917247281]
)
</pre>
=={{header|Modula-2}}==
{{trans|QuickBASIC}}
{{works with|ADW Modula-2|any (Compile with the linker option ''Console Application'').}}
<syntaxhighlight lang="modula2">
MODULE BellNumbers;
FROM STextIO IMPORT
WriteLn, WriteString;
FROM SWholeIO IMPORT
WriteInt;
CONST
MaxN = 14;
VAR
A: ARRAY [0 .. MaxN - 1] OF CARDINAL;
I, J, N: CARDINAL;
PROCEDURE DisplayRow(N, BellNum: CARDINAL);
BEGIN
WriteString("B(");
WriteInt(N, 2);
WriteString(") = ");
WriteInt(BellNum, 9);
WriteLn
END DisplayRow;
BEGIN
FOR I := 0 TO MaxN - 1 DO
A[I] := 0
END;
N := 0;
A[0] := 1;
DisplayRow(N, A[0]);
WHILE N < MaxN DO
A[N] := A[0];
FOR J := N TO 1 BY -1 DO
A[J - 1] := A[J - 1] + A[J]
END;
N := N + 1;
DisplayRow(N, A[0])
END
END BellNumbers.
</syntaxhighlight>
{{out}}
<pre>
B( 0) = 1
B( 1) = 1
B( 2) = 2
B( 3) = 5
B( 4) = 15
B( 5) = 52
B( 6) = 203
B( 7) = 877
B( 8) = 4140
B( 9) = 21147
B(10) = 115975
B(11) = 678570
B(12) = 4213597
B(13) = 27644437
B(14) = 190899322
</pre>
=={{header|Nim}}==
===Using Recurrence relation===
<syntaxhighlight lang=
iterator b(): int =
Line 2,217 ⟶ 2,829:
===Using Bell triangle===
<syntaxhighlight lang=
## Iterator yielding the bell numbers.
var row = @[1]
Line 2,227 ⟶ 2,839:
for i in 1..newRow.high:
newRow[i] = newRow[i - 1] + row[i - 1]
row
yield row[^1] # The last value of the row is one step ahead of the first one.
Line 2,239 ⟶ 2,851:
for i in 1..newRow.high:
newRow[i] = newRow[i - 1] + row[i - 1]
row
yield row
Line 2,309 ⟶ 2,921:
4140 5017 6097 7432 9089 11155 13744 17007 21147
21147 25287 30304 36401 43833 52922 64077 77821 94828 115975</pre>
=={{header|PARIGP}}==
From the code at OEIS A000110,
<syntaxhighlight lang="text">
genit(maxx=50)={bell=List();
for(n=0,maxx,q=sum(k=0,n,stirling(n,k,2));
Line 2,322 ⟶ 2,935:
{{Works with|Free Pascal}}
Using bell's triangle. TIO.RUN up to 5000.See talk for more.
<syntaxhighlight lang="pascal">program BellNumbers;
{$Ifdef FPC}
{$optimization on,all}
Line 2,544 ⟶ 3,157:
=={{header|Perl}}==
{{trans|Raku}}
<syntaxhighlight lang="perl">use strict 'vars';
use warnings;
use feature 'say';
Line 2,601 ⟶ 3,214:
{{libheader|Phix/mpfr}}
Started out as a translation of Go, but the main routine has now been completely replaced.
<!--<syntaxhighlight lang=
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">include</span> <span style="color: #004080;">mpfr</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
Line 2,654 ⟶ 3,267:
'''First 18 Bell numbers and b(50).'''
(Port of the Sage solution at the OEIS A000110 page.)
<syntaxhighlight lang=
B50=b(50),
println(B50[1..18]),
Line 2,679 ⟶ 3,292:
'''Bell's Triangle (and the 50th Bell number)'''
{{trans|D}}
<syntaxhighlight lang=
Tri = tri(50),
foreach(I in 1..10)
Line 2,718 ⟶ 3,331:
{{trans|Prolog}}
<syntaxhighlight lang=
bell(49, Bell),
printf("First 15 Bell numbers:\n"),
Line 2,813 ⟶ 3,426:
The symmetry constraint <code>value_precede_chain/2</code> ensures that a value N+1 is not placed in the list (X) before all the values 1..N has been placed ("seen") in the list. This handles the symmetry that the two sets {1,2} and {2,1} are to be considered the same.
<syntaxhighlight lang=
main =>
Line 2,886 ⟶ 3,499:
=={{header|PicoLisp}}==
<syntaxhighlight lang=
(make
(setq L (link (list 1)))
Line 2,938 ⟶ 3,551:
=={{header|Prolog}}==
{{works with|SWI Prolog}}
<syntaxhighlight lang="prolog">bell(N, Bell):-
bell(N, Bell, [], _).
Line 3,022 ⟶ 3,635:
{{trans|D}}
{{Works with|Python|2.7}}
<syntaxhighlight lang="python">def bellTriangle(n):
tri = [None] * n
for i in xrange(n):
Line 3,079 ⟶ 3,692:
{{Trans|Haskell}}
{{Works with|Python|3.7}}
<syntaxhighlight lang="python">'''Bell numbers'''
from itertools import accumulate, chain, islice
Line 3,312 ⟶ 3,925:
=={{header|Quackery}}==
<syntaxhighlight lang=
rot 1 - times
[ dup -1 peek nested
Line 3,355 ⟶ 3,968:
=={{header|Racket}}==
<syntaxhighlight lang="racket">#lang racket
(define (build-bell-row previous-row)
Line 3,404 ⟶ 4,017:
{{works with|Rakudo|2019.03}}
<syntaxhighlight lang="raku" line> my @Aitkens-array = lazy [1], -> @b {
my @c = @b.tail;
@c.push: @b[$_] + @c[$_] for ^@b;
Line 3,451 ⟶ 4,064:
{{works with|Rakudo|2019.03}}
<syntaxhighlight lang="raku" line>sub binomial { [*] ($^n … 0) Z/ 1 .. $^p }
my @bell = 1, -> *@s { [+] @s »*« @s.keys.map: { binomial(@s-1, $_) } } … *;
Line 3,463 ⟶ 4,076:
{{works with|Rakudo|2019.03}}
<syntaxhighlight lang="raku" line>my @Stirling_numbers_of_the_second_kind =
(1,),
{ (0, |@^last) »+« (|(@^last »*« @^last.keys), 0) } … *
Line 3,483 ⟶ 4,096:
Also, see this task's [https://rosettacode.org/wiki/Talk:Bell_numbers#size_of_Bell_numbers ''discussion''] to view how the sizes of Bell numbers increase in relation to its index.
<syntaxhighlight lang="rexx">/*REXX program calculates and displays a range of Bell numbers (index starts at zero).*/
parse arg LO HI . /*obtain optional arguments from the CL*/
if LO=='' & HI=="" then do; LO=0; HI=14; end /*Not specified? Then use the default.*/
Line 3,529 ⟶ 4,142:
Bell(49) = 10,726,137,154,573,358,400,342,215,518,590,002,633,917,247,281
</pre>
=={{header|RPL}}==
{{works with|HP|48}}
≪ → n
≪ { 1 }
'''WHILE''' 'n' DECR '''REPEAT'''
DUP DUP SIZE GET 1 →LIST
1 3 PICK SIZE '''FOR''' j
OVER j GET OVER j GET + +
'''NEXT''' SWAP DROP
'''END''' HEAD
≫ ≫ ‘<span style="color:blue">BELL</span>’ STO
'''Variant with a better use of the stack'''
Slightly faster then, although more wordy:
≪ → n
≪ { 1 } 1
'''WHILE''' 'n' DECR '''REPEAT'''
DUP 1 →LIST
1 4 PICK SIZE '''FOR''' j
3 PICK j GET ROT + SWAP OVER +
'''NEXT''' ROT DROP SWAP
'''END''' DROP HEAD
≫ ≫ ‘<span style="color:blue">BELL</span>’ STO
≪ {} 1 15 '''FOR''' n n <span style="color:blue">BELL</span> + '''NEXT''' ≫ EVAL
{{out}}
<pre>
1: { 1 1 2 5 15 52 203 877 4140 21147 115975 678570 4213597 27644437 190899322 }
</pre>
It makes no sense to display 10 rows of the Bell triangle on a screen limited to 22 characters and 7 lines in the best case.
=={{header|Ruby}}==
{{trans|D}}
<syntaxhighlight lang="ruby">def bellTriangle(n)
tri = Array.new(n)
for i in 0 .. n - 1 do
Line 3,600 ⟶ 4,245:
{{trans|D}}
{{libheader|num|0.2}}
<syntaxhighlight lang="rust">use num::BigUint;
fn main() {
Line 3,655 ⟶ 4,300:
=={{header|Scala}}==
{{trans|Java}}
<syntaxhighlight lang="scala">import scala.collection.mutable.ListBuffer
object BellNumbers {
Line 3,744 ⟶ 4,389:
=={{header|Scheme}}==
{{works with|Chez Scheme}}
<syntaxhighlight lang="scheme">; Given the remainder of the previous row and the final cons of the current row,
; extend (in situ) the current row to be a complete row of the Bell triangle.
; Return the final value in the extended row (for use in computing the following row).
Line 3,832 ⟶ 4,477:
=={{header|Sidef}}==
Built-in:
<syntaxhighlight lang="ruby">say 15.of { .bell }</syntaxhighlight>
Formula as a sum of Stirling numbers of the second kind:
<syntaxhighlight lang="ruby">func bell(n) { sum(0..n, {|k| stirling2(n, k) }) }</syntaxhighlight>
Via Aitken's array (optimized for space):
<syntaxhighlight lang="ruby">func bell_numbers (n) {
var acc = []
Line 3,862 ⟶ 4,507:
Aitken's array:
<syntaxhighlight lang="ruby">func aitken_array (n) {
var A = [1]
Line 3,887 ⟶ 4,532:
Aitken's array (recursive definition):
<syntaxhighlight lang="ruby">func A((0), (0)) { 1 }
func A(n, (0)) { A(n-1, n-1) }
func A(n, k) is cached { A(n, k-1) + A(n-1, k-1) }
Line 3,901 ⟶ 4,546:
{{trans|Kotlin}}
<syntaxhighlight lang="swift">public struct BellTriangle<T: BinaryInteger> {
@usableFromInline
var arr: [T]
Line 3,974 ⟶ 4,619:
21147, 25287, 30304, 36401, 43833, 52922, 64077, 77821, 94828, 115975</pre>
=={{header|
{{trans|Go}}
<syntaxhighlight lang="v (vlang)">import math.big
fn bell_triangle(n int) [][]big.Integer {
Line 4,132 ⟶ 4,690:
{{trans|Go}}
{{libheader|Wren-fmt}}
<syntaxhighlight lang=
import "./fmt" for Fmt
var bellTriangle = Fn.new { |n|
Line 4,189 ⟶ 4,747:
4,140 5,017 6,097 7,432 9,089 11,155 13,744 17,007 21,147
21,147 25,287 30,304 36,401 43,833 52,922 64,077 77,821 94,828 115,975
</pre>
=={{header|XPL0}}==
{{trans|Delphi}}
32-bit integer are required to calculate the first 15 Bell numbers.
{{works with|EXPL-32}}
<syntaxhighlight lang="xpl0">
\Bell numbers
code CrLf=9, IntOut=11, Text=12;
define MaxN = 14;
integer A(MaxN), I, J, N;
begin
for I:= 0 to MaxN - 1 do A(I):= 0;
N:= 0; A(0):= 1;
Text(0, "B("); IntOut(0, N); Text(0, ") = "); IntOut(0, A(0)); CrLf(0);
while N < MaxN do
begin
A(N):= A(0);
for J:= N downto 1 do A(J - 1):= A(J - 1) + A(J);
N:= N + 1;
Text(0, "B("); IntOut(0, N); Text(0, ") = "); IntOut(0, A(0)); CrLf(0)
end;
end
</syntaxhighlight>
{{out}}
<pre>
B(0) = 1
B(1) = 1
B(2) = 2
B(3) = 5
B(4) = 15
B(5) = 52
B(6) = 203
B(7) = 877
B(8) = 4140
B(9) = 21147
B(10) = 115975
B(11) = 678570
B(12) = 4213597
B(13) = 27644437
B(14) = 190899322
</pre>
=={{header|zkl}}==
<syntaxhighlight lang="zkl">fcn bellTriangleW(start=1,wantRow=False){ // --> iterator
Walker.zero().tweak('wrap(row){
row.insert(0,row[-1]);
Line 4,199 ⟶ 4,799:
}.fp(List(start))).push(start,start);
}</syntaxhighlight>
<syntaxhighlight lang="zkl">println("First fifteen Bell numbers:");
bellTriangleW().walk(15).println();</syntaxhighlight>
{{out}}
Line 4,206 ⟶ 4,806:
L(1,1,2,5,15,52,203,877,4140,21147,115975,678570,4213597,27644437,190899322)
</pre>
<syntaxhighlight lang="zkl">println("Rows of the Bell Triangle:");
bt:=bellTriangleW(1,True); do(11){ println(bt.next()) }</syntaxhighlight>
{{out}}
Line 4,224 ⟶ 4,824:
</pre>
{{libheader|GMP}} GNU Multiple Precision Arithmetic Library
<syntaxhighlight lang="zkl">print("The fiftieth Bell number: ");
var [const] BI=Import("zklBigNum"); // libGMP
bellTriangleW(BI(1)).drop(50).value.println();</syntaxhighlight>
Line 4,231 ⟶ 4,831:
The fiftieth Bell number: 10726137154573358400342215518590002633917247281
</pre>
{{omit from|PL/0}}
{{omit from|Tiny BASIC}}
|