Bernoulli numbers: Difference between revisions
m
→{{header|Fōrmulæ}}
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
|||
| (12 intermediate revisions by 5 users not shown) | |||
Line 32:
* Luschny's [http://luschny.de/math/zeta/The-Bernoulli-Manifesto.html The Bernoulli Manifesto] for a discussion on <big> '''B<sub>1</sub> = -½''' versus '''+½'''. </big>
<br><br>
=={{header|Ada}}==
Using a GMP thick binding available at http://www.codeforge.com/article/422541
<syntaxhighlight lang=
USE GMP.Rationals, GMP.Integers, Ada.Text_IO, Ada.Strings.Fixed, Ada.Strings;
Line 103 ⟶ 102:
B(60)=-1215233140483755572040304994079820246041491 / 56786730
</pre>
=={{header|ALGOL 68}}==
{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}
Uses the LONG LONG INT mode of Algol 68G which allows large precision integers.
<syntaxhighlight lang="algol68">BEGIN
# Show Bernoulli numbers B0 to B60 as rational numbers #
Line 220 ⟶ 218:
B(60) -1215233140483755572040304994079820246041491 / 56786730
</pre>
=={{header|AppleScript}}==
To be able to handle numbers up to B(60) and beyond, this script represents the numbers with lists whose items are the digit values — which of course requires custom math routines.
<syntaxhighlight lang="applescript">on bernoullis(n) -- Return a list of "numerator / denominator" texts representing Bernoulli numbers B(0) to B(n).
set listMathScript to getListMathScript(10) -- Script object providing custom list math routines.
Line 469 ⟶ 466:
{{output}}
<syntaxhighlight lang="applescript">"
B(0) = 1 / 1
B(1) = 1 / 2
Line 502 ⟶ 499:
B(58) = 84483613348880041862046775994036021 / 354
B(60) = -1215233140483755572040304994079820246041491 / 56786730"</syntaxhighlight>
=={{header|Bracmat}}==
<syntaxhighlight lang="bracmat"> ( BernoulliList
= B Bs answer indLn indexLen indexPadding
, n numberPadding p solPos solidusPos sp
Line 596 ⟶ 592:
B(58)= 84483613348880041862046775994036021/354
B(60)=-1215233140483755572040304994079820246041491/56786730</pre>
=={{header|C}}==
{{libheader|GMP}}
<syntaxhighlight lang=
#include <stdlib.h>
#include <gmp.h>
Line 687 ⟶ 682:
B(60) = -1215233140483755572040304994079820246041491 / 56786730
</pre>
=={{header|C sharp|C#}}==
Line 693 ⟶ 687:
{{libheader|Mpir.NET}}
Translation of the C implementation
<syntaxhighlight lang="csharp">
using Mpir.NET;
using System;
Line 787 ⟶ 781:
{{libheader|MathNet.Numerics}}
<syntaxhighlight lang="csharp">
using System;
using System.Console;
Line 879 ⟶ 873:
{{libheader|System.Numerics}}
Algo based on the example provided in the header of this RC page (the one from Wikipedia). <br/> Extra feature - one can override the default of 60 by supplying a suitable number on the command line. The column widths are not hard-coded, but will adapt to the widths of the items listed.
<syntaxhighlight lang="csharp">using System;
using System.Numerics;
using System.Collections.Generic;
Line 1,049 ⟶ 1,043:
B(126) = 5556330281949274850616324408918951380525567307126747246796782304333594286400508981287241419934529638692081513802696639 / 4357878
</pre>
=={{header|C++}}==
{{Works with|C++11}}
{{libheader|boost}}
<syntaxhighlight lang="cpp">/**
* Configured with: --prefix=/Library/Developer/CommandLineTools/usr --with-gxx-include-dir=/usr/include/c++/4.2.1
* Apple LLVM version 9.1.0 (clang-902.0.39.1)
Line 1,124 ⟶ 1,117:
B(60) = -1215233140483755572040304994079820246041491 / 56786730
</pre>
=={{header|Clojure}}==
<syntaxhighlight lang="clojure">
ns test-project-intellij.core
Line 1,190 ⟶ 1,182:
60 : -1215233140483755572040304994079820246041491 / 56786730
</pre>
=={{header|Common Lisp}}==
An implementation of the simple algorithm.
Line 1,196 ⟶ 1,187:
Be advised that the pseudocode algorithm specifies (j * (a[j-1] - a[j])) in the inner loop; implementing that as-is gives the wrong value (1/2) where n = 1, whereas subtracting a[j]-a[j-1] yields the correct value (B[1]=-1/2). See [http://oeis.org/A027641 the numerator list].
<syntaxhighlight lang="lisp">(defun bernouilli (n)
(loop with a = (make-array (list (1+ n)))
for m from 0 to n do
Line 1,275 ⟶ 1,266:
B(60): -1215233140483755572040304994079820246041491/56786730
</pre>
=={{header|Crystal}}==
{{Trans|Ruby}}
<syntaxhighlight lang="ruby">require "big"
class Bernoulli
Line 1,311 ⟶ 1,301:
{{Trans|Python}}
Version 1: compute each number separately.
<syntaxhighlight lang="ruby">require "big"
def bernoulli(n)
Line 1,330 ⟶ 1,320:
{{Trans|Python}}
Version 2: create faster generator to compute array of numbers once.
<syntaxhighlight lang="ruby">require "big"
def bernoulli2(limit)
Line 1,381 ⟶ 1,371:
B(60) = -1215233140483755572040304994079820246041491/56786730
</pre>
=={{header|D}}==
This uses the D module from the Arithmetic/Rational task.
{{trans|Python}}
<syntaxhighlight lang="d">import std.stdio, std.range, std.algorithm, std.conv, arithmetic_rational;
auto bernoulli(in uint n) pure nothrow /*@safe*/ {
Line 1,404 ⟶ 1,393:
}</syntaxhighlight>
The output is exactly the same as the Python entry.
=={{header|Delphi}}==
{{libheader| System.SysUtils}}
Line 1,411 ⟶ 1,399:
Thanks Rudy Velthuis for the [https://github.com/rvelthuis/DelphiBigNumbers Velthuis.BigRationals] library.<br>
<syntaxhighlight lang=
program Bernoulli_numbers;
Line 1,444 ⟶ 1,432:
readln;
end.</syntaxhighlight>
=={{header|EchoLisp}}==
Line 1,450 ⟶ 1,437:
Only 'small' rationals are supported in EchoLisp, i.e numerator and demominator < 2^31. So, we create a class of 'large' rationals, supported by the bigint library, and then apply the magic formula.
<syntaxhighlight lang="lisp">
(lib 'bigint) ;; lerge numbers
(lib 'gloops) ;; classes
Line 1,477 ⟶ 1,464:
</syntaxhighlight>
{{Output}}
<syntaxhighlight lang="lisp">
;; Bernoulli numbers
;; http://rosettacode.org/wiki/Bernoulli_numbers
Line 1,526 ⟶ 1,513:
(B 1) → 1 / 2
</syntaxhighlight>
=={{header|Elixir}}==
<syntaxhighlight lang="elixir">defmodule Bernoulli do
defmodule Rational do
import Kernel, except: [div: 2]
Line 1,619 ⟶ 1,605:
B(60) = -1215233140483755572040304994079820246041491 / 56786730
</pre>
=={{header|F sharp|F#}}==
{{libheader|MathNet.Numerics.FSharp}}
<syntaxhighlight lang="fsharp">
open MathNet.Numerics
open System
Line 1,684 ⟶ 1,669:
B(60) = -1215233140483755572040304994079820246041491 / 56786730
</pre>
=={{header|Factor}}==
One could use the "bernoulli" word from the math.extras vocabulary as follows:
<syntaxhighlight lang="text">IN: scratchpad
[
0 1 1 "%2d : %d / %d\n" printf
Line 1,730 ⟶ 1,714:
Running time: 0.00489444 seconds</syntaxhighlight>
Alternatively a method described by Brent and Harvey (2011) in "Fast computation of Bernoulli, Tangent and Secant numbers" https://arxiv.org/pdf/1108.0286.pdf is shown.
<syntaxhighlight lang="text">:: bernoulli-numbers ( n -- )
n 1 + 0 <array> :> tab
1 1 tab set-nth
Line 1,766 ⟶ 1,750:
;</syntaxhighlight>
It gives the same result as the native implementation, but is slightly faster.
<syntaxhighlight lang="text">[ 30 bernoulli-numbers ] time
...
Running time: 0.004331652 seconds</syntaxhighlight>
=={{header|Fermat}}==
<syntaxhighlight lang="fermat">Func Bern(m) = Sigma<k=0,m>[Sigma<v=0,k>[(-1)^v*Bin(k,v)*(v+1)^m/(k+1)]].;
for i=0, 60 do b:=Bern(i); if b<>0 then !!(i,b) fi od;</syntaxhighlight>
{{out}}<pre>
Line 1,806 ⟶ 1,789:
58 84483613348880041862046775994036021 / 354
60 -1215233140483755572040304994079820246041491 / 56786730</pre>
=={{header|FreeBASIC}}==
{{libheader|GMP}}
<syntaxhighlight lang="freebasic">' version 08-10-2016
' compile with: fbc -s console
' uses gmp
Line 1,896 ⟶ 1,878:
B(58) = 84483613348880041862046775994036021/354
B(60) = -1215233140483755572040304994079820246041491/56786730</pre>
=={{header|Frink}}==
<syntaxhighlight lang="frink">BernoulliNumber[n] :=
{
a = new array
Line 1,959 ⟶ 1,940:
60 -1215233140483755572040304994079820246041491 / 56786730
</pre>
=={{header|FunL}}==
FunL has pre-defined function <code>B</code> in module <code>integers</code>, which is defined as:
<syntaxhighlight lang="funl">import integers.choose
def B( n ) = sum( 1/(k + 1)*sum((if 2|r then 1 else -1)*choose(k, r)*(r^n) | r <- 0..k) | k <- 0..n )
Line 2,004 ⟶ 1,984:
B(60) = -1215233140483755572040304994079820246041491/56786730
</pre>
=={{header|Fōrmulæ}}==
{{FormulaeEntry|page=https://formulae.org/?script=examples/Bernoulli_numbers}}
'''Solution.''' The following function reduces to the n-th Bernoulli number. It is a replica of the Akiyama–Tanigawa algorithm.
[[File:Fōrmulæ - Bernoulli numbers 01.png]]
'''Test case.''' Showing the Bernoulli numbers B<sub>0</sub> to B<sub>60</sub>
[[File:Fōrmulæ - Bernoulli numbers 02.png]]
[[File:Fōrmulæ - Bernoulli numbers 03.png]]
=={{header|GAP}}==
<syntaxhighlight lang="gap">for a in Filtered(List([0 .. 60], n -> [n, Bernoulli(n)]), x -> x[2] <> 0) do
Print(a, "\n");
od;
Line 2,051 ⟶ 2,036:
[ 58, 84483613348880041862046775994036021/354 ]
[ 60, -1215233140483755572040304994079820246041491/56786730 ]</syntaxhighlight>
=={{header|Go}}==
<syntaxhighlight lang="go">package main
import (
Line 2,115 ⟶ 2,099:
B(60) = -1215233140483755572040304994079820246041491/56786730
</pre>
=={{header|Haskell}}==
====Task algorithm====
Line 2,121 ⟶ 2,104:
The implementation of the algorithm is in the function bernoullis. The rest is for printing the results.
<syntaxhighlight lang=
import System.Environment
Line 2,179 ⟶ 2,162:
====Derivation from Faulhaber's triangle====
<syntaxhighlight lang="haskell">import Data.Bool (bool)
import Data.Ratio (Ratio, denominator, numerator, (%))
Line 2,270 ⟶ 2,253:
58 -> 84483613348880041862046775994036021 / 354
60 -> -1215233140483755572040304994079820246041491 / 56786730</pre>
=={{header|Icon}} and {{header|Unicon}}==
The following works in both languages:
<syntaxhighlight lang="unicon">link "rational"
procedure main(args)
Line 2,332 ⟶ 2,314:
->
</pre>
=={{header|J}}==
Line 2,338 ⟶ 2,319:
See [[j:Essays/Bernoulli_Numbers|Bernoulli Numbers Essay]] on the J wiki.
<syntaxhighlight lang="j">B=: {.&1 %. (i. ! ])@>:@i.@x:</syntaxhighlight>
'''Task:'''
<syntaxhighlight lang="j"> 'B' ,. rplc&'r/_-'"1": (#~ 0 ~: {:"1)(i. ,. B) 61
B 0 1
B 1 -1/2
Line 2,375 ⟶ 2,356:
B58 84483613348880041862046775994036021/354
B60 -1215233140483755572040304994079820246041491/56786730</syntaxhighlight>
=={{header|Java}}==
<syntaxhighlight lang="java">import org.apache.commons.math3.fraction.BigFraction;
public class BernoulliNumbers {
Line 2,431 ⟶ 2,411:
B(58) = 84483613348880041862046775994036021 / 354
B(60) = -1215233140483755572040304994079820246041491 / 56786730</pre>
=={{header|jq}}==
{{works with|jq|1.4}}
Line 2,441 ⟶ 2,420:
'''BigInt Stubs''':
<syntaxhighlight lang="jq"># def negate:
# def lessOrEqual(x; y): # x <= y
# def long_add(x;y): # x+y
Line 2,481 ⟶ 2,460:
((x|tonumber) % (y|tonumber)) | tostring;</syntaxhighlight>
'''Fractions''':<syntaxhighlight lang="jq">
# A fraction is represented by [numerator, denominator] in reduced form, with the sign on top
Line 2,538 ⟶ 2,517:
'''Bernoulli Numbers''':
<syntaxhighlight lang="jq"># Using the algorithm in the task description:
def bernoulli(n):
reduce range(0; n+1) as $m
Line 2,550 ⟶ 2,529:
'''The task''':
<syntaxhighlight lang="jq">range(0;61)
| if . % 2 == 0 or . == 1 then "\(.): \(bernoulli(.) )" else empty end</syntaxhighlight>
{{out}}
The following output was obtained using the previously mentioned BigInt library.
<syntaxhighlight lang="sh">$ jq -n -r -f Bernoulli.jq
0: ["1","1"]
1: ["1","2"]
Line 2,587 ⟶ 2,566:
58: ["84483613348880041862046775994036021","354"]
60: ["-1215233140483755572040304994079820246041491","56786730"]</syntaxhighlight>
=={{header|Julia}}==
<syntaxhighlight lang=
A = Vector{Rational{BigInt}}(undef, n + 1)
for m = 0 : n
Line 2,637 ⟶ 2,615:
Produces virtually the same output as the Python version.
=={{header|Kotlin}}==
{{trans|Java}}
{{works with|Commons Math|3.3.5}}
<syntaxhighlight lang="scala">import org.apache.commons.math3.fraction.BigFraction
object Bernoulli {
Line 2,666 ⟶ 2,643:
{{out}}
Produces virtually the same output as the Java version.
=={{header|Lua}}==
LuaJIT version with FFI and GMP library
Line 2,672 ⟶ 2,648:
{{libheader|luagmp}}
{{works with|LuaJIT|2.0-2.1}}
<syntaxhighlight lang="lua">#!/usr/bin/env luajit
local gmp = require 'gmp' ('libgmp')
local ffi = require'ffi'
Line 2,753 ⟶ 2,729:
./bernoulli_gmp.lua 0,02s user 0,00s system 97% cpu 0,022 total</pre>
Time compare: Python 0.591 sec, C 0.023 sec, Lua 0.022-0.025
=={{header|Maple}}==
<syntaxhighlight lang=
{{out}}
<pre>[[0, 1], [1, 1/2], [2, 1/6], [4, -1/30], [6, 1/42], [8, -1/30], [10, 5/66], [12, -691/2730], [14, 7/6], [16, -3617/510], [18, 43867/798], [20, -174611/330], [22, 854513/138], [24, -236364091/2730], [26, 8553103/6], [28, -23749461029/870], [30, 8615841276005/14322], [32, -7709321041217/510], [34, 2577687858367/6], [36, -26315271553053477373/1919190], [38, 2929993913841559/6], [40, -261082718496449122051/13530], [42, 1520097643918070802691/1806], [44, -27833269579301024235023/690], [46, 596451111593912163277961/282], [48, -5609403368997817686249127547/46410], [50, 495057205241079648212477525/66], [52, -801165718135489957347924991853/1590], [54, 29149963634884862421418123812691/798], [56, -2479392929313226753685415739663229/870], [58, 84483613348880041862046775994036021/354], [60, -1215233140483755572040304994079820246041491/56786730]]</pre>
=={{header|Mathematica}} / {{header|Wolfram Language}}==
Mathematica has no native way for starting an array at index 0. I therefore had to build the array from 1 to n+1 instead of from 0 to n, adjusting the formula accordingly.
<syntaxhighlight lang=
Do[
a[[m]] = 1/m;
Line 2,809 ⟶ 2,783:
(Note from task's author: nobody is forced to use any specific algorithm, the one shown is just a suggestion.)
<syntaxhighlight lang=
Select[%, #[[2]] != 0 &] // TableForm</syntaxhighlight>
{{out}}
Line 2,844 ⟶ 2,818:
58 84483613348880041862046775994036021/354
60 -(1215233140483755572040304994079820246041491/56786730)</pre>
=={{header|Maxima}}==
Using built-in function bern
<syntaxhighlight lang="maxima">
block(makelist([sconcat("B","(",i,")","="),bern(i)],i,0,60),
sublist(%%,lambda([x],x[2]#0)),
table_form(%%))
</syntaxhighlight>
{{out}}
<pre>
matrix(
["B(0)=", 1],
["B(1)=", -1/2],
["B(2)=", 1/6],
["B(4)=", -1/30],
["B(6)=", 1/42],
["B(8)=", -1/30],
["B(10)=", 5/66],
["B(12)=", -691/2730],
["B(14)=", 7/6],
["B(16)=", -3617/510],
["B(18)=", 43867/798],
["B(20)=", -174611/330],
["B(22)=", 854513/138],
["B(24)=", -236364091/2730],
["B(26)=", 8553103/6],
["B(28)=", -23749461029/870],
["B(30)=", 8615841276005/14322],
["B(32)=", -7709321041217/510],
["B(34)=", 2577687858367/6],
["B(36)=", -26315271553053477373/1919190],
["B(38)=", 2929993913841559/6],
["B(40)=", -261082718496449122051/13530],
["B(42)=", 1520097643918070802691/1806],
["B(44)=", -27833269579301024235023/690],
["B(46)=", 596451111593912163277961/282],
["B(48)=", -5609403368997817686249127547/46410],
["B(50)=", 495057205241079648212477525/66],
["B(52)=", -801165718135489957347924991853/1590],
["B(54)=", 29149963634884862421418123812691/798],
["B(56)=", -2479392929313226753685415739663229/870],
["B(58)=", 84483613348880041862046775994036021/354],
["B(60)=", -1215233140483755572040304994079820246041491/56786730]
)
</pre>
=={{header|Nim}}==
<syntaxhighlight lang=
import strformat
Line 2,922 ⟶ 2,941:
58: 84483613348880041862046775994036021 / 354
60: -1215233140483755572040304994079820246041491 / 56786730</pre>
=={{header|PARI/GP}}==
<syntaxhighlight lang="parigp">for(n=0,60,t=bernfrac(n);if(t,print(n" "t)))</syntaxhighlight>
{{out}}
<pre>0 1
Line 2,958 ⟶ 2,976:
58 84483613348880041862046775994036021/354
60 -1215233140483755572040304994079820246041491/56786730</pre>
=={{header|Pascal|FreePascal}}==
{{libheader|BigDecimalMath}}
Tested with fpc 3.0.4
<syntaxhighlight lang=
(* Taken from the 'Ada 99' project, https://marquisdegeek.com/code_ada99 *)
Line 3,123 ⟶ 3,140:
B(60) : -1215233140483755572040304994079820246041491 / 56786730
</pre>
=={{header|Perl}}==
The only thing in the suggested algorithm which depends on N is the number of times through the inner block. This means that all but the last iteration through the loop produce the exact same values of A.
Line 3,129 ⟶ 3,145:
Instead of doing the same calculations over and over again, I retain the A array until the final Bernoulli number is produced.
<syntaxhighlight lang="perl">#!perl
use strict;
use warnings;
Line 3,158 ⟶ 3,174:
We can also use modules for faster results. E.g.
{{libheader|ntheory}}
<syntaxhighlight lang="perl">use ntheory qw/bernfrac/;
for my $n (0 .. 60) {
Line 3,165 ⟶ 3,181:
}</syntaxhighlight>
with identical output. Or:
<syntaxhighlight lang="perl">use Math::Pari qw/bernfrac/;
for my $n (0 .. 60) {
Line 3,172 ⟶ 3,188:
}</syntaxhighlight>
with the difference being that Pari chooses <math>B_1</math> = -½.
=={{header|Phix}}==
{{libheader|Phix/mpfr}}
{{trans|C}}
<!--<syntaxhighlight lang=
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">include</span> <span style="color: #000000;">builtins</span><span style="color: #0000FF;">/</span><span style="color: #004080;">mpfr</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
Line 3,244 ⟶ 3,259:
B(60) = -1215233140483755572040304994079820246041491 / 56786730
</pre>
=={{header|PicoLisp}}==
Brute force and method by Srinivasa Ramanujan.
<syntaxhighlight lang=
(de fact (N)
Line 3,321 ⟶ 3,335:
(bye)</syntaxhighlight>
=={{header|PL/I}}==
<syntaxhighlight lang=
declare i fixed binary;
declare B complex fixed (31);
Line 3,381 ⟶ 3,394:
B(36)= -26315271553053477373/1919190
</pre>
=={{header|Python}}==
===Python: Using task algorithm===
<syntaxhighlight lang="python">from fractions import Fraction as Fr
def bernoulli(n):
Line 3,436 ⟶ 3,448:
===Python: Optimised task algorithm===
Using the optimization mentioned in the Perl entry to reduce intermediate calculations we create and use the generator bernoulli2():
<syntaxhighlight lang="python">def bernoulli2():
A, m = [], 0
while True:
Line 3,452 ⟶ 3,464:
Output is exactly the same as before.
=={{header|Quackery}}==
<syntaxhighlight lang=
[ 1+
Line 3,516 ⟶ 3,527:
60 -1215233140483755572040304994079820246041491/56786730
</pre>
=={{header|R}}==
{{incorrect|rsplus|This example is incorrect: It is not executable and if made executable (with 'library(gmp)') it returns completely different and wrong results -- not the ones shown here. The R code needs complete rewrite and the 'pracma' library will not be of any help.}}
<syntaxhighlight lang="rsplus">
library(pracma)
Line 3,567 ⟶ 3,576:
B(60) = -1215233140483755572040304994079820246041491/56786730
</pre>
=={{header|Racket}}==
Line 3,574 ⟶ 3,582:
use the same emmitter... it's just a matter of how long to wait for the emission.
<syntaxhighlight lang="text">#lang racket
;; For: http://rosettacode.org/wiki/Bernoulli_numbers
Line 3,692 ⟶ 3,700:
B(58) = 84483613348880041862046775994036021/354
B(60) = -1215233140483755572040304994079820246041491/56786730</pre>
=={{header|Raku}}==
(formerly Perl 6)
Line 3,700 ⟶ 3,707:
First, a straighforward implementation of the naïve algorithm in the task description.
{{works with|Rakudo|2015.12}}
<syntaxhighlight lang="raku" line>sub bernoulli($n) {
my @a;
for 0..$n -> $m {
Line 3,756 ⟶ 3,763:
{{works with|Rakudo|2015.12}}
<syntaxhighlight lang="raku" line>constant bernoulli = gather {
my @a;
for 0..* -> $m {
Line 3,833 ⟶ 3,840:
{{works with|Rakudo|2016.12}}
<syntaxhighlight lang="raku" line>sub infix:<bop>(\prev, \this) {
this.key => this.key * (this.value - prev.value)
}
Line 3,865 ⟶ 3,872:
<br>
:::::::::::: where <big><big> <math> \binom kr</math> </big></big> is a binomial coefficient. <br>
<syntaxhighlight lang="rexx">/*REXX program calculates N number of Bernoulli numbers expressed as vulgar fractions.*/
parse arg N .; if N=='' | N=="," then N= 60 /*Not specified? Then use the default.*/
numeric digits max(9, n*2) /*increase the decimal digits if needed*/
Line 3,960 ⟶ 3,967:
Output notes: This version of REXX can compute and display all values up to '''B<sub>110</sub>''' in sub─second.
<br><br>
=={{header|RPL}}==
Fractions such as a/b are here handled through the complex number data structure <code>(a,b)</code>.
2 local words support the algorithm suggested by the task: <code>FracSub</code> substracts 2 fractions and <code>FracSimp</code> make a fraction irreducible
Unfortunately, floating-point precision prevents from going beyond B22.
{{works with|Halcyon Calc|4.2.7}}
{| class="wikitable"
! RPL code
! Comment
|-
|
≪ DUP2 IM * ROT IM ROT RE * -
≫ '<span style="color:blue">FracSub</span>' STO
≪ DUP C→R ABS SWAP ABS DUP2 < ≪ SWAP ≫ IFT
'''WHILE''' DUP '''REPEAT''' SWAP OVER MOD '''END'''
DROP /
≫ '<span style="color:blue">FracSimp</span>' STO
≪
{ } 1 ROT 1 + '''FOR''' m
1 m R→C +
'''IF''' m 2 ≥ '''THEN''' m 2 '''FOR''' j
DUP j 1 - GET OVER j GET <span style="color:blue">FracSub</span>
C→R SWAP j 1 - * SWAP R→C
<span style="color:blue">FracSimp</span> j 1 - SWAP PUT
-1 '''STEP END'''
'''NEXT''' 1 GET DUP RE SWAP 0 '''IFTE'''
≫ '<span style="color:blue">BRNOU</span>' STO
|
''( (a,b) (c,d) -- (e,f) )'' with e/f = a/b - c/d
''( (a,b) -- (c,d) )'' with c/d simplified fraction of a/b
get GCD of a and b
divide (a,b) by GCD
''( n -- (a,b) )'' with a/b = B(n)
For m from 1 to n+1 do
A[m] ← 1/m
for j from m to 2 do
(A[j-1] - A[j])
. * (j-1)
A[j-1] ←
return A[1] as a fraction or zero
|}
5 <span style="color:blue">BRNOU</span>
22 <span style="color:blue">BRNOU</span>
{{out}}
<pre>
2: 0
1: (854513,138)
</pre>
===HP-49+ version===
Latest RPL implementations can natively handle long fractions and generate Bernoulli numbers.
{{works with|HP|49}}
≪ { }
0 ROT '''FOR''' n
'''IF''' n 2 > LASTARG MOD AND NOT '''THEN''' n IBERNOULLI + '''END'''
'''NEXT'''
≫ '<span style="color:blue">TASK</span>' STO
60 <span style="color:blue">TASK</span>
{{out}}
<pre>
1: {1 -1/2 1/6 -1/30 1/42 -1/30 5/66 -691/2730 7/6 -3617/510 43867/798 -174611/330 854513/138 -236364091/2730 8553103/6 -23749461029/870 8615841276005/14322 -7709321041217/510 2577687858367/6 -26315271553053477373/1919190 2929993913841559/6 -261082718496449122051/13530 1520097643918070802691/1806 -27833269579301024235023/690 596451111593912163277961/282 -5609403368997817686249127547/46410 495057205241079648212477525/66 -801165718135489957347924991853/1590 9149963634884862421418123812691/798 -2479392929313226753685415739663229/870 84483613348880041862046775994036021/354 -1215233140483755572040304994079820246041491/56786730}
</pre>
Runs in 3 minutes 40 on a HP-50g, against 1 hour and 30 minutes if calculating Bernoulli numbers with the above function.
=={{header|Ruby}}==
{{trans|Python}}
<syntaxhighlight lang="ruby">bernoulli = Enumerator.new do |y|
ar = []
0.step do |m|
Line 4,015 ⟶ 4,093:
=={{header|Rust}}==
<syntaxhighlight lang="rust">// 2.5 implementations presented here: naive, optimized, and an iterator using
// the optimized function. The speeds vary significantly: relative
// speeds of optimized:iterator:naive implementations is 625:25:1.
Line 4,200 ⟶ 4,278:
B(60) = -1215233140483755572040304994079820246041491 / 56786730
</pre>
=={{header|Scala}}==
'''With Custom Rational Number Class'''<br/>
(code will run in Scala REPL with a cut-and-paste without need for a third-party library)
<syntaxhighlight lang="scala">/** Roll our own pared-down BigFraction class just for these Bernoulli Numbers */
case class BFraction( numerator:BigInt, denominator:BigInt ) {
require( denominator != BigInt(0), "Denominator cannot be zero" )
Line 4,290 ⟶ 4,367:
=={{header|Scheme}}==
{{works with|Chez Scheme}}
<syntaxhighlight lang="scheme">; Return the n'th Bernoulli number.
(define bernoulli
Line 4,378 ⟶ 4,455:
B(58) = 84483613348880041862046775994036021/354
B(60) = -1215233140483755572040304994079820246041491/56786730</pre>
=={{header|Seed7}}==
The program below uses [http://seed7.sourceforge.net/manual/types.htm#bigRational bigRational]
Line 4,386 ⟶ 4,462:
function automatically writes repeating decimals in parentheses, when necessary.
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i";
include "bigrat.s7i";
Line 4,456 ⟶ 4,532:
B(60) = -1215233140483755572040304994079820246041491 / 56786730 -21399949257225333665810744765191097.3(926741511617238745742183076926598872659158222352299560126106)
</pre>
=={{header|Sidef}}==
Built-in:
<syntaxhighlight lang="ruby">say bernoulli(42).as_frac #=> 1520097643918070802691/1806</syntaxhighlight>
Recursive solution (with auto-memoization):
<syntaxhighlight lang="ruby">func bernoulli_number(n) is cached {
n.is_one && return 1/2
Line 4,478 ⟶ 4,553:
Using Ramanujan's congruences (pretty fast):
<syntaxhighlight lang="ruby">func ramanujan_bernoulli_number(n) is cached {
return 1/2 if n.is_one
Line 4,489 ⟶ 4,564:
Using Euler's product formula for the Riemann zeta function and the Von Staudt–Clausen theorem (very fast):
<syntaxhighlight lang="ruby">func bernoulli_number_from_zeta(n) {
n.is_zero && return 1
Line 4,506 ⟶ 4,581:
The Akiyama–Tanigawa algorithm:
<syntaxhighlight lang="ruby">func bernoulli_print {
var a = []
for m in (0..60) {
Line 4,555 ⟶ 4,630:
B(60) = -1215233140483755572040304994079820246041491 / 56786730
</pre>
=={{header|SPAD}}==
{{works with|FriCAS, OpenAxiom, Axiom}}
<syntaxhighlight lang=
for n in 0..60 | (b:=bernoulli(n)$INTHEORY; b~=0) repeat print [n,b]
</syntaxhighlight>
Line 4,664 ⟶ 4,738:
Type: Void
</pre>
=={{header|Swift}}==
Line 4,671 ⟶ 4,744:
Uses the Frac type defined in the [http://rosettacode.org/wiki/Arithmetic/Rational#Swift Rational] task.
<syntaxhighlight lang=
public func bernoulli<T: BinaryInteger & SignedNumeric>(n: Int) -> Frac<T> {
Line 4,735 ⟶ 4,808:
B(58) = Frac(84483613348880041862046775994036021 / 354)
B(60) = Frac(-1215233140483755572040304994079820246041491 / 56786730)</pre>
=={{header|Tcl}}==
<syntaxhighlight lang="tcl">proc bernoulli {n} {
for {set m 0} {$m <= $n} {incr m} {
lappend A [list 1 [expr {$m + 1}]]
Line 4,798 ⟶ 4,870:
B_60 = -1215233140483755572040304994079820246041491/56786730
</pre>
=={{header|Visual Basic .NET}}==
{{works with|Visual Basic .NET|2013}}
{{libheader|System.Numerics}}
<syntaxhighlight lang="vbnet">' Bernoulli numbers - vb.net - 06/03/2017
Imports System.Numerics 'BigInteger
Line 4,887 ⟶ 4,958:
B(60)=-1215233140483755572040304994079820246041491/56786730
</pre>
=={{header|Wren}}==
{{libheader|Wren-fmt}}
{{libheader|Wren-big}}
<syntaxhighlight lang=
import "./big" for BigRat
var bernoulli = Fn.new { |n|
Line 4,952 ⟶ 5,022:
{{trans|EchoLisp}}
Uses lib GMP (GNU MP Bignum Library).
<syntaxhighlight lang="zkl">class Rational{ // Weenie Rational class, can handle BigInts
fcn init(_a,_b){ var a=_a, b=_b; normalize(); }
fcn toString{ "%50d / %d".fmt(a,b) }
Line 4,972 ⟶ 5,042:
fcn __opDiv(n){ self(a*n.b,b*n.a) } // Rat / Rat
}</syntaxhighlight>
<syntaxhighlight lang="zkl">var [const] BN=Import.lib("zklBigNum"); // libGMP (GNU MP Bignum Library)
fcn B(N){ // calculate Bernoulli(n)
var A=List.createLong(100,0); // aka static aka not thread safe
Line 4,981 ⟶ 5,051:
A[0]
}</syntaxhighlight>
<syntaxhighlight lang="zkl">foreach b in ([0..1].chain([2..60,2])){ println("B(%2d)%s".fmt(b,B(b))) }</syntaxhighlight>
{{out}}
<pre>
| |||