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>

#include <sstream>

#include <vector>

class Frac {

public:

if (d == 0) {

}

 

 

}

Frac operator-() const {

return Frac(-num, denom);

}

Frac operator+(const Frac& rhs) const {

return Frac(num*rhs.denom + denom * rhs.num, rhs.denom*denom);

}

Frac operator-(const Frac& rhs) const {

return Frac(num*rhs.denom - denom * rhs.num, rhs.denom*denom);

}

Frac operator*(const Frac& rhs) const {

return Frac(num*rhs.num, denom*rhs.denom);

}

 

}

 

private:

};

std::ostream & operator<<(std::ostream & os, const Frac &f) {

if (f.num == 0 || f.denom == 1) {

return os << f.num;

}

std::stringstream ss;

ss << f.num << "/" << f.denom;

return os << ss.str();

}

Frac bernoulli(int n) {

if (n < 0) {

}

std::vector<Frac> a;

for (int m = 0; m <= n; m++) {

a.push_back(Frac(1, m + 1));

for (int j = m; j >= 1; j--) {

}

}

// returns 'first' Bernoulli number

if (n != 1) return a[0];

return -a[0];

}

int binomial(int n, int k) {

if (n < 0 || k < 0 || n < k) {

}

if (n == 0 || k == 0) return 1;

int num = 1;

for (int i = k + 1; i <= n; i++) {

num *= i;

}

int denom = 1;

for (int i = 2; i <= n - k; i++) {

denom *= i;

}

return num / denom;

}

std::vector<Frac> faulhaberTraingle(int p) {

Frac q{ 1, p + 1 };

int sign = -1;

for (int j = 0; j <= p; j++) {

sign *= -1;

}

return coeffs;

}

int main() {

for (int i = 0; i < 10; i++) {

}

}

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}}

56056972216555580111030077961944183400198333273050000

</pre>

 

=={{header|Haskell}}==

 

faulhaberTriangle :: [[Rational]]

faulhaberTriangle =

tail $

 

 

justifyRatio (wn, wd) n c nd =

 

center n c s =

let (q, r) = quotRem (n - length s) 2

 

maxWidths :: [[Rational]] -> (Int, Int)

maxWidths xss =

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

{{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

-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|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}}

 

 

 

'''List of rows of Faulhaber fractions.'''

def go(rs, n):

return [Fraction(1 - sum(xs), 1)] + xs

return list(accumulate(

[[]] + list(islice(count(0), 1 + m)),

positive integers.

'''

return sum(

)

 

 

def main():

'''Tests'''

 

 

 

# fTable :: String -> (a -> String) ->

def fTable(s):

'''

 

 

 

# compose (<<<) :: (b -> c) -> (a -> b) -> a -> c

def concat(xs):

'''The concatenation of all the elements

def f(ys):

zs = list(chain(*ys))

f lifted to a function over a list.

'''

 

 

representation of the ratio r.

'''

)

 

 

# 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>