Summation of primes: Difference between revisions

=={{header|ALGOL 68}}==

{{libheader|ALGOL 68-primes}}

PR read "primes.incl.a68" PR

# return s space-separated into groups of 3 digits #

OD;

print( ( space separate( whole( sum, 0 ) ), newline ) )

{{out}}

<pre>

This isn't something that's likely to needed more than once — if at all — so you'd probably just throw together code like the following. The result's interesting in that although it's way outside AppleScript's integer range, its class is returned as integer in macOS 10.14 (Mojave)!

if ((n < 4) or (n is 5)) then return (n > 1)

if ((n mod 2 = 0) or (n mod 3 = 0) or (n mod 5 = 0)) then return false

end sumPrimes

{{output}}

The result can be obtained in 4 seconds rather than 14 if the summing's instead combined with an Eratosthenean sieve:

set limit to this - 1

-- Is the limit 2 or lower?

end sumPrimes

=={{header|AWK}}==

# syntax: GAWK -f SUMMATION_OF_PRIMES.AWK

BEGIN {

return(1)

}

{{out}}

<pre>

=={{header|BASIC}}==

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

dim as integer sum = 2, i, n=1

next i

{{out}}<pre>142913828922</pre>

==={{header|GW-BASIC}}===

20 FOR P = 3 TO 1999999! STEP 2

30 GOSUB 80

140 Q = 1

150 RETURN

{{out}}<pre>142913828922</pre>

=={{header|C}}==

#include<stdlib.h>

printf( "%ld\n", s );

return 0;

{{out}}<pre>142913828922</pre>

=={{header|CLU}}==

x0: int := s/2

if x0=0 then

start_up = proc ()

stream$putl(stream$primary_output(), int$unparse(sum_primes_to(2000000)))

{{out}}

<pre>142913828922</pre>

=={{header|Crystal}}==

return false unless (n | 1 == 3 if n < 5) || (n % 6) | 4 == 5

sqrt = Math.isqrt(n)

puts "The sum of all primes below 2 million is #{(0i64..2000000i64).sum { |n| prime?(n) ? n : 0u64 }}"

{{out}}

<pre>The sum of all primes below 2 million is 142913828923.

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

This task uses [http://www.rosettacode.org/wiki/Extensible_prime_generator#The_functions Extensible Prime Generator (F#)]

// Summation of primes. Nigel Galloway: November 9th., 2021

printfn $"%d{primes64()|>Seq.takeWhile((>)2000000L)|>Seq.sum}"

{{out}}

<pre>

=={{header|Factor}}==

{{out}}

<pre>

=={{header|Fermat}}==

for p=3 to 1999999 by 2 do if Isprime(p) then s:=s+p fi od;

{{out}}<pre>142913828922</pre>

=={{header|Go}}==

{{libheader|Go-rcu}}

import (

}

fmt.Printf("The sum of all primes below 2 million is %s.\n", rcu.Commatize(sum))

{{out}}

=={{header|Haskell}}==

sumOfPrimesBelow :: Integral a => a -> a

main :: IO ()

{{Out}}

<pre>142913828922</pre>

See [[Erd%C5%91s-primes#jq]] for a suitable definition of `is_prime/1` as used here.

{{out}}

<pre>

=={{header|Julia}}==

@show sum(primes(2_000_000)) # sum(primes(2000000)) = 142913828922

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

{{out}}<pre>

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

s=2; p=3

while(p<2000000,if(isprime(p),s=s+p);p=p+2)

print(s)

{{out}}<pre>

142913828922

=={{header|Pascal}}==

uses {{libheader|primTrial}}

program SumPrimes;

{$IFDEF FPC}{$MODE DELPHI}{$OPTIMIZATION ON,ALL}

writeln(sum);

{$IFDEF WINDOWS} readln;{$ENDIF}

{{out}}

<pre>

=={{header|Perl}}==

use strict; # https://rosettacode.org/wiki/Summation_of_primes

use List::Util qw( sum );

{{out}}

<pre>

=={{header|Phix}}==

<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;">"The sum of primes below 2 million is %,d\n"</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sum</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">get_primes_le</span><span style="color: #0000FF;">(</span><span style="color: #000000;">2e6</span><span style="color: #0000FF;">)))</span>

{{out}}

<pre>

=={{header|Python}}==

===Procedural===

def isPrime(n):

suma += i

n+=1

{{out}}

<pre>142913828922</pre>

===Functional===

from functools import reduce

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>142913828922</pre>

Or, more efficiently, assuming that we have a generator of primes:

from itertools import count, takewhile

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>142913828922</pre>

=={{header|Raku}}==

Slow, but only using compiler built-ins (about 5 seconds)

{{out}}

<pre>142913828922</pre>

Much faster using external libraries (well under half a second)

my $sieve = Math::Primesieve.new;

Same output

=={{header|Ring}}==

load "stdlib.ring"

see "working..." + nl

see "" + sum + nl

see "done..." + nl

{{out}}

<pre>

=={{header|Ruby}}==

{{out}}

<pre>142913828922

Built-in:

Linear algorithm:

var sum = 0

for (var p = 2; p < limit; p.next_prime!) {

}

Sublinear algorithm:

return 0 if (n <= 1)

}

{{out}}

<pre>

{{libheader|Wren-math}}

{{libheader|Wren-fmt}}

import "./fmt" for Fmt

{{out}}

=={{header|XPL0}}==

Takes 3.7 seconds on Pi4.

int N, I;

[if (N&1) = 0 then return false; \N is even

Format(1, 0); \don't show places after decimal point

RlOut(0, Sum);

{{out}}

=={{header|Yabasic}}==

{{trans|Python}}

// by Galileo, 04/2022

if isPrime(i) suma = suma + i

next