Faulhaber's triangle: Difference between revisions

* [http://www.ww.ingeniousmathstat.org/sites/default/files/Torabi-Dashti-CMJ-2011.pdf Faulhaber's triangle (PDF)]

<br>

 

=={{header|C}}==

{{trans|C++}}

#include <stdio.h>

#include <stdlib.h>

 

return 0;

{{out}}

<pre> 1

=={{header|C sharp|C#}}==

{{trans|Java}}

 

namespace FaulhabersTriangle {

}

}

{{out}}

<pre> 1

{{trans|C#}}

Uses C++ 17

#include <iomanip>

#include <iostream>

return 0;

{{out}}

<pre> 1

=={{header|D}}==

{{trans|Kotlin}}

import std.conv : to;

import std.exception : enforce;

}

writeln;

{{out}}

<pre> 1

=={{header|F_Sharp|F#}}==

===The Function===

// Generate Faulhaber's Triangle. Nigel Galloway: May 8th., 2018

let Faulhaber=let fN n = (1N - List.sum n)::n

yield! Faul t (b+1N)}

Faul [] 0N

===The Task===

Faulhaber |> Seq.take 10 |> Seq.iter (printfn "%A")

{{out}}

<pre>

 

=={{header|Factor}}==

math.ranges prettyprint sequences ;

 

[ [ nCk ] [ -1 swap ^ ] [ bernoulli ] tri * * * ] 2with map ;

 

{{out}}

<pre>

=={{header|FreeBASIC}}==

{{libheader|GMP}}

' compile with: fbc -s console

' uses GMP

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>The first 10 rows

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|Go}}==

{{trans|Kotlin}}

Except that there is no need to roll our own Frac type when we can use the big.Rat type from the Go standard library.

 

import (

}

fmt.Println(sum.RatString())

 

{{out}}

=={{header|Groovy}}==

{{trans|Java}}

import java.util.stream.LongStream

 

println(sum.toBigInteger())

}

{{out}}

<pre> 1

=={{header|Haskell}}==

{{works with|GHC|8.6.4}}

 

------------------------ FAULHABER -----------------------

let widest f xs = maximum $ fmap (length . show . f) xs

in ((,) . widest numerator <*> widest denominator) $

{{Out}}

<pre> 1

{{trans|Kotlin}}

{{works with|Java|8}}

import java.math.MathContext;

import java.util.Arrays;

System.out.println(sum.toBigInteger());

}

{{out}}

<pre> 1

 

(Further progress would entail implementing some hand-crafted representation of arbitrary precision integers – perhaps a bit beyond the intended scope of this task, and good enough motivation to use a different language)

 

// Order of Faulhaber's triangle -> rows of Faulhaber's triangle

]

);

{{Out}}

<pre> 1

faulhaber(4, 1000)

200500333333300</pre>

 

=={{header|Julia}}==

A = Vector{Rational{BigInt}}(undef, n + 1)

for i in 0:n

 

testfaulhaber()

<pre>

1

=={{header|Kotlin}}==

Uses appropriately modified code from the Faulhaber's Formula task:

 

import java.math.BigDecimal

}

println(sum.toBigInteger())

 

{{out}}

=={{header|Lua}}==

{{trans|C}}

if n<0 or k<0 or n<k then return -1 end

if n==0 or k==0 then return 1 end

for i=0,9 do

faulhaber(i)

{{out}}

<pre> 1

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

bernoulliB[1] := 1/2

bernoulliB[n_] := BernoulliB[n]

Faulhaber[n_, p_] := 1/(p + 1) Sum[Binomial[p + 1, j] bernoulliB[j] n^(p + 1 - j), {j, 0, p}]

Table[Rest@CoefficientList[Faulhaber[n, t], n], {t, 0, 9}] // Grid

{{out}}

<pre>1

0 -(3/20) 0 1/2 0 -(7/10) 0 3/4 1/2 1/10

56056972216555580111030077961944183400198333273050000</pre>

 

=={{header|Nim}}==

{{libheader|bignum}}

For the task, we could use the standard module “rationals” but for the extra task we need big numbers (and big rationals). We use third party module “bignum” for this purpose.

import bignum

 

echo ""

let fs18 = faulhaber(17) # 18th row.

 

{{out}}

 

56056972216555580111030077961944183400198333273050000</pre>

 

=={{header|Perl}}==

{{libheader|ntheory}}

use List::Util qw(sum);

use Math::BigRat try => 'GMP';

my $n = Math::BigInt->new(1000);

my @r = faulhaber_triangle($p+1);

{{out}}

<pre>

=={{header|Phix}}==

{{trans|C#}}

{{out}}

<pre>

56056972216555580111030077961944183400198333273050000

</pre>

 

=={{header|Prolog}}==

ft_rows(Lz) :-

lazy_list(ft_row, [], Lz).

drop(N, Lz1, Lz2) :-

append(Pfx, Lz2, Lz1), length(Pfx, N), !.

{{Out}}

<pre>

{{trans|Haskell}}

{{Works with|Python|3.7}}

 

from itertools import accumulate, chain, count, islice

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>Faulhaber's triangle:

=={{header|Racket}}==

 

(require math/number-theory)

 

(require rackunit)

(check-equal? (sum-k^p:formulaic 17 1000)

{{out}}

<pre>'((1) (1/2 1/2) (1/6 1/2 1/3) (0 1/4 1/2 1/4) (-1/30 0 1/3 1/2 1/5) (0 -1/12 0 5/12 1/2 1/6) (1/42 0 -1/6 0 1/2 1/2 1/7) (0 1/12 0 -7/24 0 7/12 1/2 1/8) (-1/30 0 2/9 0 -7/15 0 2/3 1/2 1/9) (0 -3/20 0 1/2 0 -7/10 0 3/4 1/2 1/10))

{{trans|Sidef}}

 

 

sub infix:<reduce> (\prev, \this) { this.key => this.key * (this.value - prev.value) }

my $p = 17;

my $n = 1000;

{{out}}

<pre> 1

 

=={{header|REXX}}==

Do r=0 To 20

ra=r-1

Parse Arg a,b

if b = 0 then return abs(a)

{{out}}

<pre> 1

=={{header|Ruby}}==

{{trans|D}}

attr_accessor:num

attr_accessor:denom

end

 

{{out}}

<pre> 1

=={{header|Scala}}==

{{trans|Java}}

 

import scala.collection.mutable

println()

}

{{out}}

<pre> 1

-1/30 0 2/9 0 -7/15 0 2/3 1/2 1/9

0 -3/20 0 1/2 0 -7/10 0 3/4 1/2 1/10 </pre>

 

=={{header|Sidef}}==

{ binomial(p, _) * bernoulli(_) / p }.map(p ^.. 0)

}

 

say ''

{{out}}

<pre>

 

Alternative solution:

var c = 0

loop {

}

 

{{out}}

<pre>

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Class Frac

End Sub

 

{{out}}

<pre> 1

-1/30 0 2/9 0 -7/15 0 2/3 1/2 1/9

0 -3/20 0 1/2 0 -7/10 0 3/4 1/2 1/10</pre>

 

=={{header|Wren}}==

{{libheader|Wren-math}}

{{libheader|Wren-big}}

 

var bernoulli = Fn.new { |n|

sum = sum + np*c

}

 

{{out}}

{{libheader|GMP}} GNU Multiple Precision Arithmetic Library

Uses the code from [[Faulhaber's formula#zkl]]

faulhaberFormula(p).apply("%7s".fmt).concat().println();

}

.walk() // -->(0, -3617/60 * 1000^2, 0, 595/3 * 1000^4 ...)

.reduce('+) // rat + rat + ...

{{out}}

<pre>