Faulhaber's triangle: Difference between revisions

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

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

(*) The C implementation of jq does not have sufficient numeric precision for the "extra credit" task.

 

# Preliminaries

(faulhabersum(1000; 17) | rpp) ;

{{out}}

<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

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

 

Row numbering below is 0-based, so row r has r+1 elements. Rather than use a rational number type, the program scales up row r by (r+1)!, which means that all the entries are integers.

program FaulhaberTriangle;

uses uIntX, uEnums, // units in the library IntXLib4Pascal

WriteLn( 'by direct calc. = ' + sum.ToString);

end.

{{out}}

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

<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: #000000;">pfrac</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span> <span style="color: #000080;font-style:italic;">-- (0.8.0+)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%s \n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">frac_sprint</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">)})</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

{{out}}

<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

=={{header|Scheme}}==

{{works with|Chez Scheme}}

(define faulhabers-triangle

(lambda (row-count)

(term-expt sum-to (* term-expt sum-to))

(sum 0 (+ sum (* (vector-ref coefs inx) term-expt))))

{{out}}

<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

=={{header|Vlang}}==

{{trans|Go}}

import math.big

 

}

println('')

 

{{out}}

{{libheader|Wren-math}}

{{libheader|Wren-big}}

import "/math" for Int

import "/big" for BigRat

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>