Pythagorean triples: Difference between revisions

*   [[Pythagorean quadruples]]

<br><br>

 

=={{header|360 Assembly}}==

{{trans|Perl}}

PYTHTRI CSECT

USING PYTHTRI,R13 base register

ISQRTSA DS 8A context store

YREGS

{{out}}

<pre>

Max Perimeter: 100000, Total: 64741, Primitive: 7026

Max Perimeter: 1000000, Total: 808950, Primitive: 70229

</pre>

 

Translation of efficient method from C, see [[wp:Pythagorean_triple#Parent.2Fchild_relationships|the WP article]]. Compiles on gnat/gcc.

 

 

procedure Pythagorean_Triples is

Large_Natural'Image(P_Cnt) & " Primitives");

end loop;

 

Output:

Up to 10 ** 9 : 1294080089 Triples, 70230484 Primitives</pre>

 

 

 

 

=={{header|AutoHotkey}}==

SetBatchLines, -1

#SingleInstance, Force

 

Loop, 8

 

{{out}}

 

=={{header|AWK}}==

# syntax: GAWK -f PYTHAGOREAN_TRIPLES.AWK

# converted from Go

}

}

{{out}}

<pre>

</pre>

 

The built-in array arithmetic is very well suited to this task!

U0%() = 1, -2, 2, 2, -1, 2, 2, -2, 3

U1%() = 1, 2, 2, 2, 1, 2, 2, 2, 3

t%() = U2%() . i%()

PROCtri(t%(), mp%, all%, prim%)

'''Output:'''

<pre>

=={{header|Bracmat}}==

{{trans|C}}

total prim max-peri U

. (.(1,-2,2) (2,-1,2) (2,-2,3))

pythagoreanTriples$;

 

Output (under Linux):

With very few changes we can get rid of the stack exhausting recursion. Instead of calling <code>new-tri</code> recursively, be push the triples to test onto a stack and return to the <code>Main</code> function. In the innermost loop we pop a triple from the stack and call <code>new-tri</code>. The memory overhead is only a few megabytes for a max perimeter of 100,000,000. On my Windows XP box the whole computation takes at least 15 minutes! Given enough time (and memory), the program can compute results for larger perimeters.

 

total prim max-peri U stack

. (.(1,-2,2) (2,-1,2) (2,-2,3))

);

 

 

=={{header|C}}==

 

Sample implemention; naive method, patentedly won't scale to larger numbers, despite the attempt to optimize it. Calculating up to 10000 is already a test of patience.

#include <stdlib.h>

 

return 0;

#include <stdlib.h>

#include <stdint.h>

}

return 0;

Up to 100: 17 triples, 7 primitives.

Up to 1000: 325 triples, 70 primitives.

Up to 1000000: 808950 triples, 70229 primitives.

Up to 10000000: 9706567 triples, 702309 primitives.

 

Same as above, but with loop unwound and third recursion eliminated:

#include <stdlib.h>

#include <stdint.h>

}

return 0;

 

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

Based on Ada example, which is a translation of efficient method from C, see [[wp:Pythagorean_triple#Parent.2Fchild_relationships|the WP article]].

 

 

namespace RosettaCode.CSharp

}

}

 

Output:

for each pair ''(m,n)'' such that ''m>n>0'', ''m'' and ''n'' coprime and of opposite polarity (even/odd),

there is a primitive Pythagorean triple. It can be proven that the converse is true as well.

(defn pyth [peri]

(reduce (fn [[total prims] t] [(inc total), (if (first t) (inc prims) prims)])

[0 0]

To handle really large perimeters, we can dispense with actually generating the triples and just calculate the counts:

(reduce (fn [[total prims] k] [(+ total k), (inc prims)]) [0 0]

(for [m (range 2 (Math/sqrt (/ peri 2)))

:while (<= p peri)

:when (= 1 (gcd m n))]

 

=={{header|CoffeeScript}}==

This algorithm scales linearly with the max perimeter. It uses two loops that are capped by the square root of the half-perimeter to examine/count provisional values of m and n, where m and n generate a, b, c, and p using simple number theory.

 

gcd = (x, y) ->

return x if y == 0

max_perim = Math.pow 10, 9 # takes under a minute

count_triples(max_perim)

output

<pre>

 

=={{header|Common Lisp}}==

(loop for x in a collect

(loop for y in x

(format t "~a: ~a prim, ~a all~%" lim prim cnt)))

 

1000: 70 prim, 325 all

10000: 703 prim, 4858 all

1000000: 70229 prim, 808950 all

10000000: 702309 prim, 9706567 all

 

=={{header|Crystal}}==

{{trans|Ruby}}

def initialize(limit = 0)

@limit = limit

p [perim, c.total, c.primitives]

perim *= 10

 

output

===Lazy Functional Version===

With hints from the Haskell solution.

import std.stdio, std.range, std.algorithm, std.typecons, std.numeric;

 

writeln("Up to 100 there are ", xs.count, " triples, ",

xs.filter!q{ a[0] }.count, " are primitive.");

{{out}}

<pre>Up to 100 there are 17 triples, 7 are primitive.</pre>

 

===Shorter Version===

pure nothrow @safe @nogc {

immutable l = a + b + c;

foreach (immutable p; 1 .. 9)

writeln(10 ^^ p, ' ', tri(10 ^^ p));

{{out}}

<pre>10 [0, 0]

===Short SIMD Version===

With LDC compiler this is a little faster than the precedent version (remove @nogc to compile it with the current version of LDC compiler).

 

ulong2 tri(in ulong lim, in ulong a=3, in ulong b=4, in ulong c=5)

foreach (immutable p; 1 .. 9)

writeln(10 ^^ p, ' ', tri(10 ^^ p).array);

The output is the same. Run-time (32 bit system): about 0.67 seconds with ldc2.

 

===Faster Version===

{{trans|C}}

 

alias Xuint = uint; // ulong if going over 1 billion.

limit, nTriples, nPrimitives);

}

{{out}}

<pre>Up to 10: 0 triples, 0 primitives.

Up to 10000000000: 14557915466 triples, 702304875 primitives.

Up to 100000000000: 161750315680 triples, 7023049293 primitives.</pre>

 

=={{header|EDSAC order code}}==

The number of primitive triples divided by the maximum perimeter seems to tend to a limit,

which looks very much like (ln 2)/pi^2 = 0.07023049277 (see especially the FreeBASIC output below).

[Pythagorean triples for Rosetta code.

Counts (1) all Pythagorean triples (2) primitive Pythagorean triples,

with perimeter not greater than a given value.

Library subroutine M3, Prints header and is then overwritten.

Here, the last character sets the teleprinter to figures.]

@&*!MAX!PERIM!!!!!TOTAL!!!!!!PRIM@&#.

..PZ

[Library subroutine P7, prints long strictly positive integer;

10 characters, right justified, padded left with spaces.

GKA3FT26@H28#@NDYFLDT4DS27@TFH8@S8@T1FV4DAFG31@SFLDUFOFFFSFL4F

T4DA1FA27@G11@XFT28#ZPFT27ZP1024FP610D@524D!FO30@SFL8FE22@

[Subroutine for positive integer division.

Input: 4D = dividend, 6D = divisor.

GKA3FT35@A6DU8DTDA4DRDSDG13@T36@ADLDE4@T36@T6DA4DSDG23@

T4DA6DYFYFT6DT36@A8DSDE35@T36@ADRDTDA6DLDT6DE15@EFPF

[Subroutine to return GCD of two non-negative 35-bit integers.

Input: Integers at 4D, 6D.

GKA3FT39@S4DE37@T40@A4DTDA6DRDSDG15@T40@ADLDE6@T40@A6DSDG20@T6D

T40@A4DSDE29@T40@ADRDTDE16@S6DE39@TDA4DT6DSDT4DE5@A6DT4DEFPF

[************************ ROSETTA CODE TASK *************************

Subroutine to count Pythagorean triples with given maximum perimeter.

A 3 F [make link]

E 16 @ [jump over variables and constants]

[Double values are put here to ensure even address]

[Variables]

[10] P F P F [n]

[Constants]

[12] P D P F [double-value 1]

[14] P1F P F [double-value 2]

[Continue with code]

[16] T 69 @ [plant link for return]

T 6 D [return in 6D]

[69] E F

[2nd-level subroutine to count triangles arising from m, n.

Assumes m, n are coprime and of opposite parity,

T 6 D [return count = 0]

[91] E F

[Main routine. Load at an even address.]

T 500 K

G K

[The initial maximum perimeter is repeatedly multiplied by 10]

[0] P50F PF [initial maximum perimeter <---------- EDIT HERE]

[2] P 3 F [number of values to calculate <---------- EDIT HERE]

E 15 Z [define entry point]

P F [acc = 0 on entry]

{{out}}

<pre>

 

=={{header|Eiffel}}==

class

APPLICATION

 

end

{{out}}

<pre>

=={{header|Elixir}}==

{{trans|Ruby}}

def count_triples(limit), do: count_triples(limit,3,4,5)

 

list = for n <- 1..8, do: Enum.reduce(1..n, 1, fn(_,acc)->10*acc end)

 

{{out}}

=={{header|Erlang}}==

 

%% Pythagorian triples in Erlang, J.W. Luiten

%%

L = lists:seq(1, Max),

Answer = lists:map(fun(X) -> count_triples(X) end, L),

 

Output:

 

=={{header|ERRE}}==

 

BEGIN

 

PRINT PRINT("** End **")

{{out}}

<pre>16:08:39

=={{header|Euphoria}}==

{{trans|D}}

sequence r

atom p

? tri(max_peri, {3, 4, 5})

max_peri *= 10

 

Output:

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

{{trans|OCaml}}

let rec iter t =

let d = n - t*t

printfn "For perimeters up to %d there are %d total and %d primitive" i s p;;

{{out}}

<pre>For perimeters up to 100 there are 17 total and 7 primitive

Pretty slow (100 times slower than C)...

 

math.functions math.matrices math.ranges sequences ;

IN: rosettacode.pyth

"Up to %d: %d triples, %d primitives.\n" printf ;

: pyth ( -- )

 

<pre>Up to 10: 0 triples, 0 primitives.

 

 

 

 

ok

 

 

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

{{trans|C efficient method}}

implicit none

max_peri = max_peri * 10

end do

Output:<pre>Up to 10 0 triples 0 primitives

Up to 100 17 triples 7 primitives

===Version 1===

Normal version

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>below triples primitive time

Attempt to make a faster version (about 20% faster)

 

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>below triples primitive time

 

=={{header|Go}}==

 

import "fmt"

maxPeri, total, prim)

}

Output:

<pre>

===Parent/Child Algorithm===

Solution:

BigInteger a, b, c

def getPerimeter() { this.with { a + b + c } }

}

}

 

Test:

findPythagTriples().sort().each { perimeterLimit, result ->

def exponent = perimeterLimit.toString().size() - 1

printf ('a+b+c <= 10E%2d %9d %12d\n', exponent, result.primative, result.total)

 

Output:

=={{header|Haskell}}==

 

pytr n =

filter

(\(_, a, b, c) -> a + b + c <= n)

[ (prim a b c, a, b, c)

where

xs = [1 .. n]

main =

putStrLn $

where

 

{{Out}}

 

Or equivalently (desugaring the list comprehension down to nested concatMaps, and pruning back the search space a little):

pythagoreanTriplesBelow n =

 

main :: IO ()

main =

mapM_

(print . length)

{{Out}}

<pre>17

 

Recursive primitive generation:

triangles max_peri

| max_peri < 12 = []

map

(map (sum . zipWith (*) t))

]

 

main =

mapM_

{{out}}

<pre>10 (0,0)

This uses the elegant formula (#IV) from [[wp:Formulas_for_generating_Pythagorean_triples|Formulas for generating Pythagorean triples]]

 

link numbers

link printf

every (s := "") ||:= !sort(x) do s ||:= ","

return s[1:-1]

 

{{libheader|Icon Programming Library}}

Brute force approach:

 

r=. i. 0 3

for_a. 1 + i. <.(y-1)%3 do.

)

 

 

Example use:

First column indicates whether the triple is primitive, and the remaining three columns are a, b and c.

 

1 3 4 5

1 5 12 13

325 70

(# , [: {. +/) pytr 10000

 

pytr 10000 takes 4 seconds on this laptop, and time to complete grows with square of perimeter, so pytr 1e6 should take something like 11 hours using this algorithm on this machine.

A slightly smarter approach:

 

'm n'=. |:(#~ 1 = 2 | +/"1)(#~ >/"1) ,/ ,"0/~ }. i. <. %: y

prim=. (#~ 1 = 2 +./@{. |:) (#~ y >: +/"1)m (-&*: ,. +:@* ,. +&*:) n

/:~ ; <@(,.~ # {. 1:)@(*/~ 1 + y i.@<.@% +/)"1 prim

 

usage for trips is the same as for pytr. Thus:

 

0 0

(# , 1 {. +/) trips 100

808950 70229

(# , 1 {. +/) trips 10000000

 

The last line took about 16 seconds.

That said, we do not actually have to generate all the triples, we just need to count them. Thus:

 

'm n'=. |:(#~ 1 = 2 | +/"1)(#~ >/"1) ,/ ,"0/~ }. i. <. %: y

<.y%+/"1 (#~ 1 = 2 +./@{. |:) (#~ y >: +/"1)m (-&*: ,. +:@* ,. +&*:) n

 

The result is a list of positive integers, one number for each primitive triple which fits within the limit, giving the number of triples which are multiples of that primitive triple whose perimeter is no greater than the limiting perimeter.

 

 

But note that J's memory footprint reached 6.7GB during the computation, so to compute larger values the computation would have to be broken up into reasonable sized blocks.

 

=={{header|Java}}==

===Brute force===

[[Category:Arbitrary precision]]Theoretically, this can go "forever", but it takes a while, so only the minimum is shown. Luckily, <code>BigInteger</code> has a GCD method built in.

import java.math.BigInteger;

import static java.math.BigInteger.ONE;

+ tripCount + " triples, of which " + primCount + " are primitive.");

}

Output:

<pre>3, 4, 5 primitive

{{works with|Java|1.5+}}

This can also go "forever" theoretically. Letting it go to another order of magnitude overflowed the stack on the computer this was tested on. This version also does not show the triples as it goes, it only counts them.

 

public class Triples{

}

}

Output:

<pre>100: 17 triples, 7 primitive.

===ES6===

Exhaustive search of a full cartesian product. Not scalable.

 

// Arguments: predicate, maximum perimeter

// pythTripleCount :: ((Int, Int, Int) -> Bool) -> Int -> Int

 

 

 

 

 

 

 

 

{{Out}}

{"maxPerimeter":100, "triples":17, "primitives":7},

 

=={{header|jq}}==

The implementation illustrates how an inner function with arity 0 can

attain a high level of efficiency with both jq 1.4 and later. A simpler implementation is possible with versions of jq greater than 1.4.

def _gcd:

if .[1] == 0 then .[0]

 

range(1; 9) | . as $i | 10|pow($i) as $i | "\($i): \(count($i) )"

{{Out}}

10: [0,0]

100: [17,7]

10000000: [9706567,702309]

100000000: [113236940,7023027]

 

=={{header|Julia}}==

This solution uses the the Euclidian concept of m and n as generators of Pythagorean triplets. When m and n are coprime and have opposite parity, the generated triplets are primitive. It works reasonably well up to a limit of 10^10.

function primitiven{T<:Integer}(m::T)

1 < m || return T[]

println(@sprintf " 10^%02d %11d %9d" om fcnt pcnt)

end

 

{{out}}

{{trans|Go}}

Due to deep recursion, I needed to increase the stack size to 4MB to get up to a maximum perimeter of 10 billion. Expect a run time of around 30 seconds on a typical laptop.

 

var total = 0L

maxPeri *= 10

}

 

{{out}}

 

=={{header|Lasso}}==

define num_pythagorean_triples(max_perimeter::integer) => {

local(max_b) = (#max_perimeter / 3)*2

stdout(`Number of Pythagorean Triples in a Perimeter of 100: `)

stdoutnl(num_pythagorean_triples(100))

Output:

<pre>Number of Pythagorean Triples in a Perimeter of 100: 17

 

=={{header|Liberty BASIC}}==

print time$()

 

print "End"

end

<pre>

17:59:34

</pre>

 

 

{{out}}

 

 

 

=={{header|MATLAB}} / {{header|Octave}}==

a = 1:N;

b = a(ones(N,1),:).^2;

 

printf('There are %i Pythagorean Triples and %i primitive triples with a perimeter smaller than %i.\n',...

 

Output:

<pre> There are 17 Pythagorean Triples and 7 primitive triples with a perimeter smaller than 100.</pre>

 

=={{header|Mercury}}==

From [[List comprehensions]]:

 

:- module comprehension.

:- interface.

solutions((pred(Triple::out) is nondet :- pythTrip(20,Triple)),Result),

write(Result,!IO).

 

=={{header|Modula-3}}==

Note that this code only works on 64bit machines (where <tt>INTEGER</tt> is 64 bits). Modula-3 provides a <tt>LONGINT</tt> type, which is 64 bits on 32 bit systems, but there is a bug in the implementation apparently.

 

IMPORT IO, Fmt;

i := i * 10;

UNTIL i = 10000000;

 

Output:

===Brute force method===

{{trans|Java}}

 

// a function to check if three numbers are a valid triple

 

print "Up to a perimeter of " + perimeter + ", there are " + ts

{{out}}

<pre>3, 4, 5 primitive

 

=={{header|Nim}}==

{{trans|C}}

[ 1, 2, 2, 2, 1, 2, 2, 2, 3],

[-1, 2, 2, -2, 1, 2, -2, 2, 3]]

newTri([3, 4, 5])

echo "Up to ", maxPeri, ": ", total, " triples, ", prim, " primitives"

Output:

<pre>Up to 10: 0 triples, 0 primitives

 

=={{header|OCaml}}==

let rec iter t =

let d = n - t*t in

Printf.printf "For perimeters up to %d there are %d total and %d primitive\n%!" i s p;;

 

Output:

<pre>For perimeters up to 100 there are 17 total and 7 primitive

 

=={{header|Ol}}==

; triples generator based on Euclid's formula, creates lazy list

(define (euclid-formula max)

(print max ": " (calculate max)))

(map (lambda (n) (expt 10 n)) (iota 6 1)))

 

{{out}}

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

This version is reasonably efficient and can handle inputs like a million quickly.

my(prim,total,P);

lim\=1;

[prim,total]

};

 

=={{header|Pascal}}==

 

var

maxPeri := maxPeri * 10;

end;

Output (on Core2Duo 2GHz laptop):

<pre>time ./PythagoreanTriples

 

=={{header|Perl}}==

my ($n, $m) = @_;

while($n){

 

tripel 10**$_ for 1..8;

{{out}}

<pre>Max. perimeter: 10, Total: 0, Primitive: 0

=={{header|Phix}}==

{{Trans|Pascal}}

{{out}}

<pre>

 

=={{header|PHP}}==

function gcd($a, $b)

}

 

{{out}}<pre>Up to 100, there are 17 triples, of which 7 are primitive.</pre>

 

=={{header|PicoLisp}}==

{{trans|C}}

(let (Total 0 Prim 0 In (3 4 5))

(recur (In)

(recurse

(mapcar '((U) (sum * U In)) Row) ) ) ) ) )

Output:

<pre>Up to 10: 0 triples, 0 primitives.

=={{header|PL/I}}==

Version 1

/*********************************************************************

* REXX pgm counts number of Pythagorean triples

End;

 

Version 2

pythagorean: procedure options (main, reorder); /* 23 January 2014 */

declare (a, b, c) fixed (3);

end GCD;

 

Output:

<pre>

 

=={{header|PowerShell}}==

function triples($p) {

if($p -gt 4) {

"There are $(($triples).Count) Pythagorean triples with perimeter no larger than 100

and $(($coprime).Count) of them are coprime."

<b>Output:</b>

<pre>

 

=={{header|Prolog}}==

show :-

Data = [100, 1_000, 10_000, 100_000, 1_000_000, 10_000_000, 100_000_000],

order2(A, B, A, B) :- A < B, !.

order2(A, B, B, A).

 

{{Out}}

<math>n \le 10,000</math><br /><br />

 

 

Procedure.i ConsoleWrite(t.s) ; compile using /CONSOLE option

ConsoleWrite("")

et=ElapsedMilliseconds()-st:ConsoleWrite("Elapsed time = "+str(et)+" milliseconds")

 

 

=={{header|Python}}==

Two methods, the second of which is much faster

 

 

for maxperimeter in range(mn, mx+1, mn):

printit(maxperimeter, algo)

 

;Output:

Up to a perimeter of 19500 there are 10388 triples, of which 1373 are primitive

Up to a perimeter of 20000 there are 10689 triples, of which 1408 are primitive</pre>

setrecursionlimit(2000) # 2000 ought to be big enough for everybody

 

 

for peri in [10 ** e for e in range(1, 8)]:

100 (7, 17)

1000 (70, 325)

100000 (7026, 64741)

1000000 (70229, 808950)

 

=={{header|Racket}}==

 

#| Euclid's enumeration formula and counting is fast enough for extra credit.

113236940, 7023027.

cpu time: 11976 real time: 12215 gc time: 2381

 

=={{header|Raku}}==

(formerly Perl 6)

{{works with|Rakudo|2018.09}}

 

for [X] [^limit] xx 3 -> (\a, \b, \c) {

{{out}}

Here is a slightly less naive brute force implementation, but still not practical for large perimeter limits.

my atomicint $i = 0;

my @triples[$limit/2];

 

say my $result = "There are {+@triples.grep:{$_ !eqv Any}} Pythagorean Triples with a perimeter <= $limit,"

{{out}}

<pre>There are 4858 Pythagorean Triples with a perimeter <= 10000,

of which 703 are primitive.</pre>

Here's a much faster version. Hint, "oyako" is Japanese for "parent/child". <tt>:-)</tt>

my $primitive = 0;

my $civilized = 0;

for 10,100,1000 ... * -> $limit {

say triples $limit;

Output:

<pre>10 => (0 0)

 

Here is an alternate version that avoids naming any scalars that can be handled by vector processing instead. Using vectorized ops allows a bit more potential for parallelization in theory, but techniques like the use of complex numbers to add two numbers in parallel, and the use of <tt>gather</tt>/<tt>take</tt> generate so much overhead that this version runs 70-fold slower than the previous one.

[[+1, +2, +2], [+2, +1, +2], [+2, +2, +3]],

[[-1, +2, +2], [-2, +1, +2], [-2, +2, +3]];

for 10, 100, 1000, 10000 -> $limit {

say triples $limit;

{{out}}

<pre>10 => (0 0)

=={{header|REXX}}==

===using GCD for determinacy===

/*──────────────────── perimeter of N, and also counts how many of them are primitives.*/

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

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

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

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

<pre>

max perimeter = 100 Pythagorean triples = 17 primitives = 7

</pre>

<pre>

max perimeter = 1000 Pythagorean triples = 325 primitives = 70

 

Non-primitive Pythagorean triples are generated after a primitive triple is found.

/*──────────────────── perimeter of N, and also counts how many of them are primitives.*/

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

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

_= left('', 7) /*for padding the output with 7 blanks.*/

{{out|output|text= &nbsp; is identical to the 1^st REXX version.}}<br><br>

 

<pre>

max perimeter = 10000 Pythagorean triples = 4858 primitives = 703

 

=={{header|Ring}}==

size = 100

sum = 0

end

return gcd

Output:

<pre>

=={{header|Ruby}}==

{{trans|Java}}

def initialize(limit)

@limit = limit

p [perim, c.total, c.primitives]

perim *= 10

 

output

 

=={{header|Rust}}==

 

fn f1 (a : u64, b : u64, c : u64, d : u64) -> u64 {

new_th_1.join().unwrap();

new_th_2.join().unwrap();

{{out}}

<pre> Primitive triples below 100 : 7

=={{header|Scala}}==

{{Out}}Best seen running in your browser either by [https://scalafiddle.io/sf/CAz60TW/0 ScalaFiddle (ES aka JavaScript, non JVM)] or [https://scastie.scala-lang.org/soOLJ673Q82l78OCgIx4oQ Scastie (remote JVM)].

 

println(" Limit Primatives All")

println(f"a + b + c <= ${limit.toFloat}%3.1e $primCount%9d $tripCount%12d")

}

 

=={{header|Scheme}}==

{{works with|Gauche Scheme}}

 

(define (py perim)

(begin (when (= 1 (gcd a b)) (inc! prim)))

1)

<b>Testing:</b>

<pre>

The example below uses [http://seed7.sourceforge.net/libraries/bigint.htm bigInteger] numbers:

 

include "bigint.s7i";

 

max_peri *:= 10_;

end while;

 

Output:

=={{header|Sidef}}==

{{trans|Raku}}

var primitive = 0

var civilized = 0

for n (1..Inf) {

say triples(10**n)

 

{{out}}

=={{header|Swift}}==

{{trans|Pascal}}

var prim = 0

var maxPeri = 100

print("Up to \(maxPeri) : \(total) triples \( prim) primitives.")

maxPeri *= 10

 

{{out}}

Using the efficient method based off the Wikipedia article:

<!--There's no technical reason to limit the code to just these values, but generation does get progressively slower with larger maximum perimiters. 10M is about as much as I have patience for; I'm generally impatient! -->

lappend q 3 4 5

set idx [set count [set prim 0]]

lassign [countPythagoreanTriples $i] count primitive

puts "perimeter limit $i => $count triples, $primitive primitive"

Output:

<pre>

 

=={{header|VBA}}==

Private Sub newTri(s0 As Variant, s1 As Variant, s2 As Variant)

Dim p As Variant

maxPeri = maxPeri * 10

Loop

<pre>Up to 100 : 17 triples, 7 primitives.

Up to 1000 : 325 triples, 70 primitives.

=={{header|VBScript}}==

{{trans|Perl}}

For i=1 To 8

WScript.StdOut.WriteLine triples(10^i)

Loop

End Function

 

=={{header|Visual Basic}}==

{{works with|VBA|6.5}}

{{works with|VBA|7.1}}

 

Dim total As Long, prim As Long, maxPeri As Long

maxPeri = maxPeri * 10

Loop

{{out}}

<pre>Up to 100 : 17 triples, 7 primitives.

{{trans|Go}}

Limited to a maximum perimeter of 10 billion in order to finish in a reasonable time.

var total = 0

var prim = 0

var p = s0 + s1 + s2

if (p <= maxPeri) {

total = total + (maxPeri/p).floor

newTri.call( 1*s0-2*s1+2*s2, 2*s0-1*s1+2*s2, 2*s0-2*s1+3*s2)

newTri.call( 1*s0+2*s1+2*s2, 2*s0+1*s1+2*s2, 2*s0+2*s1+3*s2)

total = 0

newTri.call(3, 4, 5)

System.print("Up to %(maxPeri): %(total) triples, %(prim) primitives, %(secs) seconds")

maxPeri = 10 * maxPeri

 

{{out}}

<pre>

Up to 100: 17 triples, 7 primitives, 0 seconds

Up to 100000: 64741 triples, 7026 primitives, 0 seconds

Up to 1000000: 808950 triples, 70229 primitives, 0 seconds

</pre>

 

=={{header|zkl}}==

{{trans|D}}

p:=a + b + c;

if(p>lim) return(0,0);

tri(lim, -a + 2*b + 2*c, -2*a + b + 2*c, -2*a + 2*b + 3*c)

);

{{out}}

<pre>10: L(0,0)

Set in line nr: 11 IF L<=1000 THEN GO TO 2

 

2 FOR U=2 TO INT (SQR (L/2)): LET Y=U-INT (U/2)*2: LET N=N+4: LET M=U*U*2: IF Y=0 THEN LET M=M-U-U

3 FOR V=1+Y TO U-1 STEP 2: LET M=M+N: LET X=U: LET Y=V

9 NEXT U

10 PRINT L;TAB 8;T;TAB 16;P

{{out}}

<pre>limit trip. prim.