Sylvester's sequence: Difference between revisions

{{trans|Nim}}

 

V result = [BigInt(2)]

L 2..lim

L(item) l

s += 1 / Float(item)

 

{{out}}

{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}

Uses Algol 68G's LONG LONG INT and LONG LONG REAL which have specifiable precision. The sum of the reciprocals in the output has been manually edited to replace a large number of nines with ... to reduce the width.

PR precision 200 PR # set the number of digits for LONG LONG modes #

# returns an array set to the forst n elements of Sylvestor's Sequence #

print( ( "Sum of reciprocals: ", reciprocal sum, newline ) )

END

{{out}}

<pre>

=={{header|Arturo}}==

 

result: new [2]

loop 2..lim 'x [

 

print "Sum of the reciprocals of the first 10 items:"

 

{{out}}

1.0</pre>

=={{header|AWK}}==

# syntax: GAWK --bignum -f SYLVESTERS_SEQUENCE.AWK

BEGIN {

exit(0)

}

{{out}}

<pre>

{{works with|Chipmunk Basic}}

{{trans|FreeBASIC}}

PRINT "10 primeros términos de la sucesión de sylvester:"

PRINT

PRINT "suma de sus recíprocos: "; suma

END

 

 

==={{header|FreeBASIC}}===

'''precisión estándar'''

Dim As Double sylvester, suma = 0

 

Print !"\nSuma de sus rec¡procos:"; suma

Sleep

{{out}}

<pre>

==={{header|PureBasic}}===

{{trans|FreeBASIC}}

OpenConsole()

PrintN("10 primeros términos de la sucesión de Sylvester:")

CloseConsole()

End

 

==={{header|Yabasic}}===

{{trans|FreeBASIC}}

print "10 primeros términos de la sucesión de Sylvester:"

 

print "\nSuma de sus rec¡procos: ", suma

end

 

 

=={{header|C++}}==

{{libheader|Boost}}

#include <iostream>

#include <boost/rational.hpp>

}

std::cout << "Sum of reciprocals: " << sum << '\n';

 

{{out}}

 

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

// Sylvester's sequence: Nigel Galloway. June 7th., 2021

let S10=Seq.unfold(fun(n,g)->printfn "*%A %A" n g; Some(n,(n*g+1I,n*g) ) )(2I,1I)|>Seq.take 10|>List.ofSeq

S10|>List.iteri(fun n g->printfn "%2d -> %A" (n+1) g)

let n,g=S10|>List.fold(fun(n,g) i->(n*i+g,g*i))(0I,1I) in printfn "\nThe sum of the reciprocals of S10 is \n%A/\n%A" n g

{{out}}

<pre>

 

{{works with|Factor|0.99 2021-02-05}}

 

: lsylvester ( -- list ) 2 [ dup sq swap - 1 + ] lfrom-by ;

 

"Sum of the reciprocals of first 10 elements:" print

{{out}}

<pre>

 

=={{header|Fermat}}==

syl[1]:=2;

for i=2 to 10 do syl[i]:=1+Prod<n=1,i-1>[syl[n]] od;

!![syl];

srec:=Sigma<i=1,10>[1/syl[i]];

{{out}}<pre>

syl[1] := 2

=={{header|Go}}==

{{trans|Wren}}

 

import (

fmt.Println("\nThe sum of their reciprocals as a decimal number (to 211 places) is:")

fmt.Println(sumRecip.FloatString(211))

 

{{out}}

 

=={{header|Haskell}}==

sylvester = map s [0 ..]

where

 

putStr "Sum of reciprocals by fold: "

{{out}}

<pre>First 10 elements of Sylvester's sequence:

 

Simpler way of generating sequence:

 

or applicatively:

 

 

=={{header|jq}}==

def sylvester:

foreach range(0; infinite) as $i ({prev: 1, product: 1};

.product *= .prev

| .prev = .product + 1;

Left padding:

def lpad($len; $fill): tostring | ($len - length) as $l | ($fill * $l)[:$l] + .;

def lpad($len): lpad($len; " ");

The task:

| "First 10 Sylvester numbers:",

(range(0;10) as $i | "\($i+1|lpad) => \(.[$i])"),

"",

"Sum of reciprocals of first 10 is approximately: \(map( 1/ .) | add)"

{{out}}

For integer precision, we will use `gojq`, the "go" implementation of jq.

=={{header|Julia}}==

 

 

foreach(n -> println(rpad(n, 3), " => ", sylvester(n)), 1:10)

 

println("Sum of reciprocals of first 10: ", sum(big"1.0" / sylvester(n) for n in 1:10))

<pre>

1 => 2

 

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

{{out}}

<pre>{2,3,7,43,1807,3263443,10650056950807,113423713055421844361000443,12864938683278671740537145998360961546653259485195807,165506647324519964198468195444439180017513152706377497841851388766535868639572406808911988131737645185443}

=={{header|Nim}}==

{{libheader|bignum}}

import bignum

 

var sum = newRat()

for item in list: sum += newRat(1, item)

 

{{out}}

 

=={{header|PARI/GP}}==

S=vector(10)

S[1]=2

for(i=2, 10, S[i]=prod(n=1,i-1,S[n])+1)

print(S)

{{out}}<pre>[2, 3, 7, 43, 1807, 3263443, 10650056950807, 113423713055421844361000443, 12864938683278671740537145998360961546653259485195807, 165506647324519964198468195444439180017513152706377497841851388766535868639572406808911988131737645185443]

 

 

=={{header|Perl}}==

use warnings;

use feature 'say';

 

say "First 10 elements of Sylvester's sequence: @S";

{{out}}

<pre>First 10 elements of Sylvester's sequence: 2 3 7 43 1807 3263443 10650056950807 113423713055421844361000443 12864938683278671740537145998360961546653259485195807 165506647324519964198468195444439180017513152706377497841851388766535868639572406808911988131737645185443

=={{header|Phix}}==

=== standard precision ===

<span style="color: #004080;">atom</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">rn</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">,</span>

<span style="color: #000000;">lim</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">power</span><span style="color: #0000FF;">(</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">machine_bits</span><span style="color: #0000FF;">()=</span><span style="color: #000000;">32</span><span style="color: #0000FF;">?</span><span style="color: #000000;">53</span><span style="color: #0000FF;">:</span><span style="color: #000000;">64</span><span style="color: #0000FF;">))</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</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;">"sum of reciprocals: %g\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">rn</span><span style="color: #0000FF;">})</span>

{{out}}

<pre>

=== mpfr version ===

Note the (minimal) precision settings of 698 and 211 were found by trial and error (ie larger values gain nothing but smaller ones lose accuracy).

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #7060A8;">requires</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"1.0.0"</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- (mpfr_set_default_prec[ision] has been renamed)

<span style="color: #008080;">end</span> <span style="color: #008080;">for</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;">"sum of reciprocals: %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">mpfr_get_fixed</span><span style="color: #0000FF;">(</span><span style="color: #000000;">rn</span><span style="color: #0000FF;">,</span><span style="color: #000000;">211</span><span style="color: #0000FF;">))})</span>

{{out}}

<pre>

<br>It doesn't calculate the reciprocal sum as 8080 PL/M has no floating point...

<br>This sample can be compiled with the original 8080 PL/M compiler and run under CP/M (or an emulator or clone).

 

BDOS: PROCEDURE( FN, ARG ); /* CP/M BDOS SYSTEM CALL */

CALL PRINT$LONG$INTEGER( .PRODUCT );

CALL PRINT$NL;

{{out}}

<pre>

=={{header|Prolog}}==

{{works with|SWI Prolog}}

sylvesters_sequence(N, S, 2, R, 0).

 

N is numerator(Sum),

D is denominator(Sum),

 

{{out}}

=={{header|Python}}==

 

 

from functools import reduce

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>First 10 terms of OEIS A000058:

 

Or as an iteration:

 

from functools import reduce

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>First 10 terms of OEIS A000058:

=={{header|Quackery}}==

 

 

' [ 2 ] 9 times [ dup -1 peek dup 2 ** swap - 1+ join ]

dup witheach [ echo cr ] cr

 

 

{{out}}

 

=={{header|Raku}}==

 

put 'First 10 elements of Sylvester\'s sequence: ', @S[^10];

 

{{out}}

<pre>First 10 elements of Sylvester's sequence: 2 3 7 43 1807 3263443 10650056950807 113423713055421844361000443 12864938683278671740537145998360961546653259485195807 165506647324519964198468195444439180017513152706377497841851388766535868639572406808911988131737645185443

 

=={{header|REXX}}==

parse arg n . /*obtain optional argument from the CL.*/

if n=='' | n=="," then n= 10 /*Not specified? Then use the default.*/

say /*stick a fork in it, we're all done. */

numeric digits digits() - 1

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

 

=={{header|Ruby}}==

(0..9).each {|n| puts "#{n}: #{sylvester n}" }

Sum of reciprocals of first 10 terms:

#{(0..9).sum{|n| 1.0r / sylvester(n)}.to_f }"

{{out}}

<pre>0: 2

</pre>

=={{header|Scheme}}==

(lambda (x)

(if (= x 1)

(print list)

(newline)

{{out}}

<pre>

</pre>

=={{header|Seed7}}==

include "bigint.s7i";

include "bigrat.s7i";

writeln("\nSum of the reciprocals of the first 10 elements:");

writeln(reciprocalSum digits 210);

{{out}}

<pre>

 

=={{header|Sidef}}==

1..n -> reduce({|a| a*(a-1) + 1 }, 2)

}

 

say "\nSum of reciprocals of first 10 terms: "

 

{{out}}

Using mkrd's BigNumber library.

 

 

func sylvester(n: Int) -> BInt {

}

 

 

{{out}}

 

=={{header|Verilog}}==

module main;

integer i;

end

endmodule

{{out}}

<pre>10 primeros términos de la sucesión de sylvester:

=={{header|Wren}}==

{{libheader|Wren-big}}

 

var sylvester = [BigInt.two]

System.print (sumRecip)

System.print("\nThe sum of their reciprocals as a decimal number (to 211 places) is:")

 

{{out}}