Partition function P: Difference between revisions

 

 

 

 

The successive numbers in the above equation have the differences:   1, 3, 2, 5, 3, 7, 4, 9, 5, 11, 6, 13, 7, 15, 8 ...

 

 

In Wolfram Language, this function has been implemented as PartitionsP.

<br><br>

 

 

=={{header|C}}==

{{libheader|GMP}}

#include <stdlib.h>

#include <stdio.h>

(double)(clock() - start) / (double)CLOCKS_PER_SEC);

return 0;

 

{{out}}

</pre>

 

 

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

{{libheader|GMP}}

#include <iostream>

#include <vector>

std::cout << result << '\n';

std::cout << "elapsed time: " << ms.count() << " milliseconds\n";

 

{{out}}

elapsed time: 8.99497 milliseconds

</pre>

=={{header|Delphi}}==

{{libheader| System.SysUtils}}

{{libheader| System.Diagnostics}}

{{Trans|Go}}

program Partition_function_P;

 

writeln('Took ', stopwatch.ElapsedMilliseconds, 'ms');

Readln;

{{out}}

<pre>p[6666] = 193655306161707661080005073394486091998480950338405932486880600467114423441282418165863

Took 131ms</pre>

 

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

An implementation of the formula in the task description. P(123456) is included for comparison with the largest value in the related task.

// PartionP: Nigel Galloway. April 12th., 2021

let pP g=let rec fN i g e l=seq{yield(l,e+i);yield(-l,e+i+g);yield! fN(i+1)(g+2)(e+i+g)(-l)}

let N,G=Array.create(g+1) 1I,seq{yield (1I,1);yield! fN 1 3 1 1I}|>Seq.takeWhile(fun(_,n)->n<=g)|>List.ofSeq

seq{2..g}|>Seq.iter(fun p->N.[p]<-G|>List.takeWhile(fun(_,n)->n<=p)|>Seq.fold(fun Σ (n,g)->Σ+n*N.[p-g]) 0I); N.[g]

{{out}}

<pre>

666->11956824258286445517629485

 

123456->30817659578536496678545317146533980855296613274507139217608776782063054452191537379312358383342446230621170608408020911309259407611257151683372221925128388387168451943800027128045369650890220060901494540459081545445020808726917371699102825508039173543836338081612528477859613355349851184591540231790254269948278726548570660145691076819912972162262902150886818986555127204165221706149989

</pre>

=={{header|Factor}}==

{{works with|Factor|0.99 2020-08-14}}

 

! Compute the nth pentagonal number.

: partitions ( m -- n )

[ seq swap [ <= ] curry lwhile list>array ]

{{out}}

<pre>

Running time: 0.084955341 seconds

 

193655306161707661080005073394486091998480950338405932486880600467114423441282418165863

</pre>

{{trans|Julia}}

I also tried using Euler's generating function but it was about 20 times slower than this version.

 

import (

fmt.Printf("p[%d)] = %d\n", N, p[N])

fmt.Printf("Took %s\n", time.Since(start))

 

{{out}}

 

=={{header|Java}}==

 

public class PartitionFunction {

return p[n];

}

 

{{out}}

elapsed time: 59 milliseconds

</pre>

 

=={{header|Julia}}==

===Recursive===

 

function partDiffDiff(n::Int)::Int

 

n=6666

{{out}}

<pre>p(6666) = 193655306161707661080005073394486091998480950338405932486880600467114423441282418165863

0.260310 seconds (3.58 M allocations: 77.974 MiB, 8.54% gc time)</pre>

 

 

=={{header|Maple}}==

option remember;

local k,s:=0,m;

 

combinat[numbpart](1000);

 

=={{header|Nim}}==

{{trans|C++}}

{{libheader|bignum}}

import bignum

 

let t0 = cpuTime()

echo partitions(6666)

 

{{out}}

 

=={{header|Perl}}==

use warnings;

no warnings qw(recursion);

 

print partitionsP($_) . ' ' for 0..25; print "\n";

{{out}}

<pre>1 1 2 3 5 7 11 15 22 30 42 56 77 101 135 176 231 297 385 490 627 792 1002 1255 1575 1958

 

=={{header|Phix}}==

Not exactly super-fast, but this sort of stuff is not really what Phix does best.

{{out}}

<pre>

</pre>

 

 

=={{header|Prolog}}==

/* SWI-Prolog 8.3.21 */

:- table p/2.

p(0, 1) :- !.

X = 1936553061617076610800050733944860919984809503384

05932486880600467114423441282418165863.

=={{header|Python}}==

===Python: Mathloger===

This follows the algorithm from the Mathloger video closely

 

 

def posd():

print(" pos_gen:", list(islice(pos_gen(), 10)))

print(" plus_minus:", list(islice(plus_minus(), 15)))

 

{{out}}

====Python: Mathloger video prime generator====

Add the following code after that above

"Prime number generator from the partition machine"

p = [1]

yield p

 

 

{{Out}}

===Python: Alternative===

{{trans|C++}}

 

 

 

if __name__ == '__main__':

 

{{out}}

215 ms ± 1.84 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

</pre>

 

=={{header|Raku}}==

{{works with|Rakudo|2020.09}}

Not the fastest, but it gets the job done.

 

put @P[^26];

{{out}}

<pre>1 1 2 3 5 7 11 15 22 30 42 56 77 101 135 176 231 297 385 490 627 792 1002 1255 1575 1958

 

=={{header|REXX}}==

numeric digits 1000 /*able to handle some ginormous numbers*/

parse arg lo hi . /*obtain optional arguments from the CL*/

if hi=='' | hi=="," then hi= lo /* " " " " " " */

@.= 0; @.0= 1; @.1= 1; @.2= 2; @.3= 3; @.4= 5 /*assign default value and low values. */

w= length( commas(hi) ) /*W: is used for aligning the index. */

 

commas: parse arg ?; do jc=length(?)-3 to 1 by -3; ?=insert(',', ?, jc); end; return ?

/*──────────────────────────────────────────────────────────────────────────────────────*/

if @.n\==0 then return @.n /*Is it already computed? Return it. */

#= 0 /*initialize part P number.*/

if z<0 then leave /*Is Z negative? Then leave.*/

if @.z==0 then x= partP(z) /*use recursion if not known.*/

else #= # - (x + y) /*Even? " subtract " " " */

end /*k*/

{{out|output|text=&nbsp; when using the input of: &nbsp; &nbsp; <tt> 6666 </tt>}}

<pre>

66,666 931,283,431,869,095,717,238,416,063,534,148,471,363,928,685,651,267,074,563,360,050,977,549,251,436,058,076,515,262,033,789,845,457,356,081,278,451,246,751,375,974,038,318,319,810,923,102,769,109,446,980,055,567,090,089,060,954,748,065,131,666,952,830,623,286,286,824,837,240,058,805,177,319,865,230,913,417,587,625,830,803,675,380,262,765,598,632,742,903,192,085,254,824,621

</pre>

 

=={{header|Rust}}==

// rug = "1.11"

 

println!("P({}) = {}", n, result);

println!("elapsed time: {} microseconds", time.as_micros());

 

{{out}}

 

Built-in:

 

User-defined:

func (n) is cached {

 

say partitionsP(6666)

 

 

{{out}}

Took 24.5225 seconds

</pre>

 

=={{header|Wren}}==

{{libheader|Wren-big}}

Although it may not look like it, this is actually a decent time for Wren which is interpreted and the above module is written entirely in Wren itself.

 

var p = []

for (n in 2..N) partitionsP.call(n)

System.print("p[%(N)] = %(p[N])")

 

{{out}}