aparler/RosettaCodeData
1
0
Fork 0
Code Issues 12 Pull requests 3 Projects Releases Packages Wiki Activity Actions

Data update

Browse source
This commit is contained in:
Ingy döt Net 2026-02-01 16:33:20 -08:00
parent 5150844a7d
commit 4bb20c9b71
7735 changed files with 38060 additions and 199180 deletions
Download patch file Download diff file Expand all files Collapse all files

38
Task/Meissel-Mertens-constant/00-TASK.txt
View file

@ -1,37 +1 @@
;Task:
Calculate Meissel–Mertens constant up to a precision your language can handle.
;Motivation:
Analogous to Euler's constant, which is important in determining the sum of reciprocal natural numbers, Meissel-Mertens' constant is important in calculating the sum of reciprocal primes.
;Example:
We consider the finite sum of reciprocal natural numbers:
''1 + 1/2 + 1/3 + 1/4 + 1/5 ... 1/n''
this sum can be well approximated with:
''log(n) + E''
where ''E'' denotes Euler's constant: 0.57721...
''log(n)'' denotes the natural logarithm of ''n''.
Now consider the finite sum of reciprocal primes:
''1/2 + 1/3 + 1/5 + 1/7 + 1/11 ... 1/p''
this sum can be well approximated with:
''log( log(p) ) + M''
where ''M'' denotes Meissel-Mertens constant: 0.26149...
;See:
:*   Details in the Wikipedia article:  [https://en.wikipedia.org/wiki/Meissel%E2%80%93Mertens_constant Meissel–Mertens constant]
<br /><br />
#REDIRECT [[Meissel-Mertens constant]]

22
Task/Meissel-Mertens-constant/11l/meissel-mertens-constant.11l
View file

@ -1,22 +0,0 @@
F primes_up_to_limit(Int limit)
[Int] r
I limit >= 2
r.append(2)
V isprime = [1B] * ((limit - 1) I/ 2)
V sieveend = Int(sqrt(limit))
L(i) 0 .< isprime.len
I isprime[i]
Int p = i * 2 + 3
r.append(p)
I i <= sieveend
L(j) ((p * p - 3) >> 1 .< isprime.len).step(p)
isprime[j] = 0B
R r
V euler = 0.57721566490153286
V m = 0.0
L(x) primes_up_to_limit(10'000'000)
m += log(1 - (1 / x)) + (1 / x)
print(‘MM = #.16’.format(euler + m))

45
Task/Meissel-Mertens-constant/ALGOL-68/meissel-mertens-constant.alg
View file

@ -1,45 +0,0 @@
BEGIN # compute an approximation to the Meissel-Mertens constant #
# construct a sieve of odd primes #
[ 0 : 10 000 000 ]BOOL primes;
BEGIN
FOR i TO UPB primes DO primes[ i ] := TRUE OD;
INT ip := 1;
FOR i WHILE i + ( ip +:= 2 ) <= UPB primes DO
IF primes[ i ] THEN
FOR s FROM i + ip BY ip TO UPB primes DO primes[ s ] := FALSE OD
FI
OD
END;
# sum the reciprocals of the primes #
INT p count := 1;
INT last p := 0;
LONG REAL sum := long ln( 0.5 ) + 0.5;
INT p := 1;
INT p10 := 10;
# Euler's constant from the wikipedia, truncated for LONG REAL #
LONG REAL eulers constant = 0.5772156649015328606 # 0651209008240243104215933593992 #;
FOR i TO UPB primes DO
p +:= 2;
IF primes[ i ] THEN
LONG REAL rp = 1 / LENG p;
sum +:= long ln( 1 - rp ) + rp;
p count +:= 1;
last p := p;
IF p count = p10 THEN
print( ( "after ", whole( p count, -8 ), " primes, the approximation is: "
, fixed( sum + eulers constant, -14, 12 )
, ", last prime considered: ", whole( last p, 0 )
, newline
)
);
p10 := IF p10 < 1 000 000 THEN p10 * 10 ELSE p10 + 1 000 000 FI
FI
FI
OD;
print( ( "after ", whole( p count, -8 ), " primes, the approximation is: "
, fixed( sum + eulers constant, -14, 12 )
, ", last prime considered: ", whole( last p, 0 )
, newline
)
)
END

54
Task/Meissel-Mertens-constant/ALGOL-W/meissel-mertens-constant.alg
View file

@ -1,54 +0,0 @@
begin % compute an approximation to the Meissel-Mertens constant %
integer MAX_PRIME;
MAX_PRIME := 10000000;
begin
logical array primes ( 0 :: MAX_PRIME );
begin % construct a sieve of odd primes %
integer i, ip;
for i := 1 until MAX_PRIME do primes( i ) := true;
ip := 3;
i := 1;
while i + ip <= MAX_PRIME do begin
if primes( i ) then begin
for s := i + ip step ip until MAX_PRIME do primes( s ) := false
end if_primes__i ;
ip := ip + 2;
i := i + 1
end while_i_plus_ip_le_MAX_PRIME
end;
begin % sum the reciprocals of the primes %
integer pCount, lastP, p, p10;
long real sum, eulersConstant;
procedure showProgress ;
write( s_w := 0, i_w := 8
, r_format := "A", r_w := 14, r_d := 12
, "after ", pCount, " primes, the approximation is: "
, ( sum + eulersConstant ), ", last prime considered: "
, i_w := 1
, lastP
);
pCount := 1;
lastP := 0;
sum := longLn( 0.5 ) + 0.5;
p := 1;
p10 := 10;
% Euler's constant from the wikipedia, truncated for long real %
eulersConstant := 0.5772156649015328606 % 0651209008240243104215933593992 %;
for i := 1 until MAX_PRIME do begin
p := p + 2;
if primes( i ) then begin
long real rp;
rp := 1 / long p;
sum := sum + longLn( 1 - rp ) + rp;
pCount := pCount + 1;
lastP := p;
if pCount = p10 then begin
showProgress;
p10 := if p10 < 1000000 THEN p10 * 10 else p10 + 1000000
end if_pCount_eq_p10
end if_primes__i
end for_i ;
showProgress
end
end
end.

11
Task/Meissel-Mertens-constant/Arturo/meissel-mertens-constant.arturo
View file

@ -1,11 +0,0 @@
meisselMertens: function [depth][
Euler: 0.57721566490153286
m: (1//2) + ln 1-1//2
loop range.step:2 3 depth 'x ->
if prime? x ->
m: m + (1//x) + ln 1-1//x
return m + Euler
]
print meisselMertens 10000000

19
Task/Meissel-Mertens-constant/BASIC256/meissel-mertens-constant.basic
View file

@ -1,19 +0,0 @@
Euler = 0.5772156649
m = 0
for x = 2 to 1e6 # more prime numbers do not add more precision
if isPrime(x) then m += log(1-(1/x)) + (1/x)
next x
print "MM = "; Euler + m
print Euler
end
function isPrime(v)
if v < 2 then return False
if v mod 2 = 0 then return v = 2
if v mod 3 = 0 then return v = 3
d = 5
while d * d <= v
if v mod d = 0 then return False else d += 2
end while
return True
end function

38
Task/Meissel-Mertens-constant/C++/meissel-mertens-constant.cpp
View file

@ -1,38 +0,0 @@
#include <cmath>
#include <cstdint>
#include <iomanip>
#include <iostream>
#include <vector>
std::vector<double> list_prime_reciprocals(const int32_t& limit) {
const int32_t half_limit = ( limit % 2 == 0 ) ? limit / 2 : 1 + limit / 2;
std::vector<bool> composite(half_limit);
for ( int32_t i = 1, p = 3; i < half_limit; p += 2, ++i ) {
if ( ! composite[i] ) {
for ( int32_t a = i + p; a < half_limit; a = a + p ) {
composite[a] = true;
}
}
}
std::vector<double> result(composite.size());
result[0] = 0.5;
for ( int32_t i = 1, p = 3; i < half_limit; p += 2, ++i ) {
if ( ! composite[i] ) {
result.emplace_back(1.0 / p);
}
}
return result;
}
int main() {
std::vector<double> prime_reciprocals = list_prime_reciprocals(100000000);
const double euler = 0.577215664901532861;
double sum = 0.0;
for ( double reciprocal : prime_reciprocals ) {
sum += reciprocal + log(1.0 - reciprocal);
}
const double meissel_mertens = euler + sum;
std::cout << "The Meissel-Mertens constant = " << std::setprecision(8) << meissel_mertens << std::endl;
}

18
Task/Meissel-Mertens-constant/Dart/meissel-mertens-constant.dart
View file

@ -1,18 +0,0 @@
import 'dart:math';
bool isPrime(var n) {
if (n <= 1) return false;
if (n == 2) return true;
for (var i = 2; i <= sqrt(n); i++) if (n % i == 0) return false;
return true;
}
void main() {
const double euler = 0.57721566490153286;
double m = 0.0;
for (var x = 2; x <= 1e8; x++)
if (isPrime(x)) m += log(1 - (1 / x)) + (1 / x);
print('MM = ${euler + m}');
}

69
Task/Meissel-Mertens-constant/Delphi/meissel-mertens-constant.pas
View file

@ -1,69 +0,0 @@
function IsPrime(N: int64): boolean;
{Fast, optimised prime test}
var I,Stop: int64;
begin
if (N = 2) or (N=3) then Result:=true
else if (n <= 1) or ((n mod 2) = 0) or ((n mod 3) = 0) then Result:= false
else
begin
I:=5;
Stop:=Trunc(sqrt(N+0.0));
Result:=False;
while I<=Stop do
begin
if ((N mod I) = 0) or ((N mod (I + 2)) = 0) then exit;
Inc(I,6);
end;
Result:=True;
end;
end;
function GetNextPrime(var Start: integer): integer;
{Get the next prime number after Start}
{Start is passed by "reference," so the
{original variable is incremented}
begin
repeat Inc(Start)
until IsPrime(Start);
Result:=Start;
end;
function MeisselMertens(Depth: integer; Prog: TProgress): extended;
{Calculate MM value up a certain Depth}
var I,P: integer;
const Euler = 0.57721566490153286;
begin
Result:=0;
P:=1;
for I:=1 to Depth do
begin
P:=GetNextPrime(P);
Result:=Result+Ln(1-(1/P)) + (1/P);
if Assigned(Prog) and ((I mod 10000)=0) then
HandleProgress(MulDiv(100,I,Depth));
end;
Result:=Result+Euler;
end;
procedure ShowMeisselMertens(Memo: TMemo; Prog: TProgress);
var I,IT,Digits: integer;
var M,Last: extended;
begin
Memo.Lines.Add('Primes Digits M');
Memo.Lines.Add('-----------------------------------------');
Last:=0;
IT:=1;
{Calculate MM to specified Power of 10}
for I:=1 to 7 do
begin
IT:=IT*10;
M:=MeisselMertens(IT,Prog);
{Calculated Digits of accuracy}
Digits:=Trunc(abs(Log(abs(M-Last))));
Memo.Lines.Add(Format('10^%2d %7d %25.18f',[I,Digits,M]));
Last:=M
end;
end;

20
Task/Meissel-Mertens-constant/EasyLang/meissel-mertens-constant.easy
View file

@ -1,20 +0,0 @@
fastfunc isprim num .
if num mod 2 = 0 and num <> 2 : return 0
i = 3
while i <= sqrt num
if num mod i = 0 : return 0
i += 2
.
return 1
.
func log x .
return log10 x / log10 2.7182818284590452354
.
euler = 0.5772156649
for x = 2 to 1e6
if isprim x = 1
m += log (1 - (1 / x)) + (1 / x)
.
.
numfmt 0 11
print "mm = " & euler + m

10
Task/Meissel-Mertens-constant/FreeBASIC/meissel-mertens-constant.basic
View file

@ -1,10 +0,0 @@
'#include "isprime.bas"
Const As Double Euler = 0.57721566490153286
Dim As Double m = 0
For x As Ulongint = 2 To 1e8
If isPrime(x) Then m += Log(1-(1/x)) + (1/x)
Next x
Print "MM ="; Euler + m
Sleep

33
Task/Meissel-Mertens-constant/Go/meissel-mertens-constant.go
View file

@ -1,33 +0,0 @@
package main
import (
"fmt"
"math"
"rcu"
)
func contains(a []int, f int) bool {
for _, e := range a {
if e == f {
return true
}
}
return false
}
func main() {
const euler = 0.57721566490153286
primes := rcu.Primes(1 << 31)
pc := len(primes)
sum := 0.0
fmt.Println("Primes added M")
fmt.Println("------------ --------------")
for i, p := range primes {
rp := 1.0 / float64(p)
sum += math.Log(1.0-rp) + rp
c := i + 1
if (c%1e7) == 0 || c == pc {
fmt.Printf("%11s %0.12f\n", rcu.Commatize(c), sum+euler)
}
}
}

2
Task/Meissel-Mertens-constant/J/meissel-mertens-constant-1.j
View file

@ -1,2 +0,0 @@
Euler=: 0.57721566490153286
MM=: {{ Euler + +/ (+ ^.@-.)@% p: i. y }}

2
Task/Meissel-Mertens-constant/J/meissel-mertens-constant-2.j
View file

@ -1,2 +0,0 @@
0j13 ": MM 1e8
0.2614972128591

1
Task/Meissel-Mertens-constant/J/meissel-mertens-constant-3.j
View file

@ -1 +0,0 @@
mm=: (% 10x(^#)10#.inv]) 26149721284764278375542683860869585905156664826119920619206421392x

2
Task/Meissel-Mertens-constant/J/meissel-mertens-constant-4.j
View file

@ -1,2 +0,0 @@
0j65":mm
0.26149721284764278375542683860869585905156664826119920619206421392

37
Task/Meissel-Mertens-constant/Java/meissel-mertens-constant.java
View file

@ -1,37 +0,0 @@
import java.util.ArrayList;
import java.util.BitSet;
import java.util.List;
public final class MeisselMertensConstant {
public static void main(String[] aArgs) {
List<Double> primeReciprocals = listPrimeReciprocals(1_000_000_000);
final double euler = 0.577_215_664_901_532_861;
double sum = 0.0;
for ( double reciprocal : primeReciprocals ) {
sum += reciprocal + Math.log(1.0 - reciprocal);
}
final double meisselMertens = euler + sum;
System.out.println(String.format("%s%.9f", "The Meissel-Mertens constant = ", meisselMertens));
}
private static List<Double> listPrimeReciprocals(int aLimit) {
BitSet sieve = new BitSet(aLimit + 1);
sieve.set(2, aLimit + 1);
for ( int i = 2; i <= Math.sqrt(aLimit); i = sieve.nextSetBit(i + 1) ) {
for ( int j = i * i; j <= aLimit; j += i ) {
sieve.clear(j);
}
}
List<Double> result = new ArrayList<Double>(sieve.cardinality());
for ( int i = 2; i >= 0; i = sieve.nextSetBit(i + 1) ) {
result.add(1.0 / i);
}
return result;
}
}

135
Task/Meissel-Mertens-constant/JavaScript/meissel-mertens-constant.js
View file

@ -1,135 +0,0 @@
function main() {
// Use a smaller limit to avoid memory issues
// For demonstration, using 10 million instead of 1 billion
const limit = 10_000_000;
const primeReciprocals = listPrimeReciprocals(limit);
const euler = 0.577215664901532861;
let sum = 0.0;
for (const reciprocal of primeReciprocals) {
sum += reciprocal + Math.log(1.0 - reciprocal);
}
const meisselMertens = euler + sum;
console.log(`The Meissel-Mertens constant = ${meisselMertens.toFixed(9)}`);
console.log(`Calculated with primes up to: ${limit.toLocaleString()}`);
}
function listPrimeReciprocals(limit) {
const segmentSize = Math.min(1_000_000, limit); // Process in 1M chunks
const result = [];
// First, find all primes up to sqrt(limit) for marking composites
const sqrtLimit = Math.floor(Math.sqrt(limit));
const basePrimes = sieveOfEratosthenes(sqrtLimit);
// Process the range in segments
for (let segStart = 2; segStart <= limit; segStart += segmentSize) {
const segEnd = Math.min(segStart + segmentSize - 1, limit);
const segmentPrimes = segmentedSieve(segStart, segEnd, basePrimes);
// Add reciprocals of primes found in this segment
for (const prime of segmentPrimes) {
result.push(1.0 / prime);
}
}
return result;
}
function sieveOfEratosthenes(limit) {
const sieve = new Array(limit + 1).fill(true);
sieve[0] = sieve[1] = false;
for (let i = 2; i * i <= limit; i++) {
if (sieve[i]) {
for (let j = i * i; j <= limit; j += i) {
sieve[j] = false;
}
}
}
const primes = [];
for (let i = 2; i <= limit; i++) {
if (sieve[i]) {
primes.push(i);
}
}
return primes;
}
function segmentedSieve(segStart, segEnd, basePrimes) {
const segmentSize = segEnd - segStart + 1;
const sieve = new Array(segmentSize).fill(true);
// Mark multiples of each base prime in this segment
for (const prime of basePrimes) {
// Find the first multiple of prime >= segStart
let start = Math.max(prime * prime, Math.ceil(segStart / prime) * prime);
// Mark all multiples in this segment
for (let j = start; j <= segEnd; j += prime) {
sieve[j - segStart] = false;
}
}
// Collect primes from this segment
const primes = [];
for (let i = 0; i < segmentSize; i++) {
if (sieve[i] && (segStart + i) >= 2) {
primes.push(segStart + i);
}
}
return primes;
}
// Alternative version with even more memory efficiency
function mainMemoryEfficient() {
const limit = 100_000_000; // Can handle larger limits
const euler = 0.577215664901532861;
let sum = 0.0;
let primeCount = 0;
// Process primes incrementally without storing them all
processPrimesInSegments(limit, (prime) => {
const reciprocal = 1.0 / prime;
sum += reciprocal + Math.log(1.0 - reciprocal);
primeCount++;
// Progress indicator for large calculations
if (primeCount % 100000 === 0) {
console.log(`Processed ${primeCount.toLocaleString()} primes...`);
}
});
const meisselMertens = euler + sum;
console.log(`The Meissel-Mertens constant = ${meisselMertens.toFixed(9)}`);
console.log(`Calculated with ${primeCount.toLocaleString()} primes up to: ${limit.toLocaleString()}`);
}
function processPrimesInSegments(limit, callback) {
const segmentSize = 1_000_000;
const sqrtLimit = Math.floor(Math.sqrt(limit));
const basePrimes = sieveOfEratosthenes(sqrtLimit);
// Process first segment (includes base primes)
for (const prime of basePrimes) {
callback(prime);
}
// Process remaining segments
for (let segStart = sqrtLimit + 1; segStart <= limit; segStart += segmentSize) {
const segEnd = Math.min(segStart + segmentSize - 1, limit);
const segmentPrimes = segmentedSieve(segStart, segEnd, basePrimes);
for (const prime of segmentPrimes) {
callback(prime);
}
}
}
// Run the memory-efficient version
console.log("Running memory-efficient version...");
mainMemoryEfficient();

9
Task/Meissel-Mertens-constant/Julia/meissel-mertens-constant.jl
View file

@ -1,9 +0,0 @@
using Base.MathConstants # sets constant γ = 0.5772156649015...
using Primes
""" Approximate the Meissel-Mertons constant. """
function meissel_mertens(iterations = 100_000_000)
return mapreduce(p ->(d = 1/p; log(1 - d) + d), +, primes(prime(iterations))) + γ
end
@show meissel_mertens(100_000_000) # meissel_mertens(100000000) = 0.2614972128591237

4
Task/Meissel-Mertens-constant/Mathematica/meissel-mertens-constant.math
View file

@ -1,4 +0,0 @@
PrimeNumbers = Select[Range[100000000], PrimeQ[#] &]; (*all primes in the first 100 000 000 numbers, this takes a toll on my computer's CPU and RAM*)
MM = N[Total[Log[1 - 1/PrimeNumbers] + 1/PrimeNumbers] + EulerGamma, 10] (*Calculating it up to a precision of 10, this is correct up to 8 digits*)
AnalyticMMto305 = N[EulerGamma + Sum[MoebiusMu[n]/n Log[Zeta[n]], {n, 2, 1000}], 1000] (*Precise up to 305 digits*)
AnalyticMM = N[EulerGamma + Sum[MoebiusMu[n]/n Log[Zeta[n]], {n, 2, 10000}], 1001] (*Precise up to at least 1000 digits*)

1
Task/Meissel-Mertens-constant/Maxima/meissel-mertens-constant.maxima
View file

@ -1 +0,0 @@
meissel_mertens:%gamma+lsum(log(1-(1/i))+(1/i),i,primes(2,10000000)),numer;

43
Task/Meissel-Mertens-constant/Nim/meissel-mertens-constant.nim
View file

@ -1,43 +0,0 @@
import std/[math, strformat, strutils]
proc initPrimes(N: static int): seq[int] =
## Initialize the list of primes.
const M = 2 * N - 1
var composite = newSeq[bool](N)
composite[0] = true # 1 is not prime.
# Conversions from index to value and value to index.
template index(n: int): int = (n - 1) shr 1
template value(idx: int): int = idx shl 1 + 1
# Fill the sieve.
var n = 3
while n * n <= M:
if not composite[n.index]:
for k in countup(n * n, M, 2 * n):
composite[k.index] = true
inc n, 2
# Build list of primes.
result = @[2]
for idx in 0..composite.high:
if not composite[idx]:
result.add idx.value
const N = 2^30
let primes = initPrimes(N)
echo "Primes added M"
echo "──────────── ──────────────"
const γ = 0.57721566490153286 # Euler–Mascheroni constant.
let primeCount = primes.len
var sum = 0.0
var count = 0
for p in primes:
let rp = 1 / p
sum += ln(1 - rp) + rp
inc count
if count mod 10_000_000 == 0 or count == primeCount:
echo &"{insertSep($count):>11} {sum+γ:.12}"

8
Task/Meissel-Mertens-constant/PARI-GP/meissel-mertens-constant-1.parigp
View file

@ -1,8 +0,0 @@
{
MM(t)=
my(s=0);
forprime(p = 2, t,
s += log(1.-1./p)+1./p
);
Euler+s
};

16
Task/Meissel-Mertens-constant/PARI-GP/meissel-mertens-constant-2.parigp
View file

@ -1,16 +0,0 @@
{
Meissel_Mertens(d)=
default(realprecision, d);
my(prec = default(realprecision), z = 0, y = 0, q);
forprime(p = 2 , 7,
z += log(1.-1./p)+1./p
);
for(k = 2, prec,
q = 1;
forprime(p = 2, 7,
q *= 1.-p^-k
);
y += moebius(k)*log(zeta(k)*q)/k
);
Euler+z+y
};

27
Task/Meissel-Mertens-constant/PascalABC.NET/meissel-mertens-constant.pas
View file

@ -1,27 +0,0 @@
function gen_primes_upto(n: integer): sequence of integer;
begin
if n < 3 then exit;
var table := |True| * n;
var sqrtn := n.sqrt.Floor;
for var i := 2 to sqrtn do
if table[i] then
for var j := i * i to n - 1 step i do
table[j] := False;
yield 2;
for var i := 3 to n step 2 do
if table[i] then yield i
end;
begin
var γ := 0.57721566490153286;
var sum := 0.0;
foreach var p in gen_primes_upto(10_000_000_000) index i do
begin
var rp := 1 / p;
sum += ln(1 - rp) + rp;
// inc count
if (i+1) mod 10_000_000 = 0 then
writeln(i+1, sum + γ:20);
end;
end.

6
Task/Meissel-Mertens-constant/Perl/meissel-mertens-constant.pl
View file

@ -1,6 +0,0 @@
use v5.36;
use ntheory qw(forprimes);
my $s;
forprimes { $s += log(1 - 1/$_)+1/$_ } 1e9;
say my $result = $s + .57721566490153286;

33
Task/Meissel-Mertens-constant/Phix/meissel-mertens-constant-1.phix
View file

@ -1,33 +0,0 @@
(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span> <span style="color: #000080;font-style:italic;">-- (but perhaps a bit too slow)</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">mmc</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0.2614972128476427837554268386086958590516</span><span style="color: #0000FF;">,</span>
<span style="color: #000000;">smmc</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"0.2614972128476427837554268386086958590516"</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">t</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0.57721566490153286</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">dpa</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">p10</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">pn</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">adp</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">st</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"0"</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">fmt</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"%.0f"</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;">"Primes added M\n"</span><span style="color: #0000FF;">)</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;">"------------ --------------\n"</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">while</span> <span style="color: #000000;">adp</span><span style="color: #0000FF;"><=</span><span style="color: #000000;">10</span> <span style="color: #008080;">do</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">rp</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">/</span><span style="color: #7060A8;">get_prime</span><span style="color: #0000FF;">(</span><span style="color: #000000;">pn</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">t</span> <span style="color: #0000FF;">+=</span> <span style="color: #7060A8;">log</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">-</span><span style="color: #000000;">rp</span><span style="color: #0000FF;">)</span> <span style="color: #0000FF;">+</span> <span style="color: #000000;">rp</span>
<span style="color: #008080;">if</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">t</span><span style="color: #0000FF;">-</span><span style="color: #000000;">mmc</span><span style="color: #0000FF;">)<</span><span style="color: #000000;">dpa</span> <span style="color: #008080;">then</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">ft</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">fmt</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">trunc</span><span style="color: #0000FF;">(</span><span style="color: #000000;">t</span><span style="color: #0000FF;">*</span><span style="color: #000000;">p10</span><span style="color: #0000FF;">)/</span><span style="color: #000000;">p10</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- (as below)</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">ft</span><span style="color: #0000FF;">=</span><span style="color: #000000;">st</span> <span style="color: #008080;">then</span>
<span style="color: #000080;font-style:italic;">--
-- We have to artifically calculate a "truncated t", aka tt,
-- to prevent say 0.2..299[&gt;5..] being automatically rounded
-- by printf() to 0.2..300, otherwise it just "looks wrong".
--</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">tt</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">trunc</span><span style="color: #0000FF;">(</span><span style="color: #000000;">t</span><span style="color: #0000FF;">*</span><span style="color: #000000;">1e12</span><span style="color: #0000FF;">)/</span><span style="color: #000000;">1e12</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;">"%,11d %0.12f (accurate to %d d.p.)\n"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">pn</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">tt</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">adp</span><span style="color: #0000FF;">})</span>
<span style="color: #000000;">adp</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
<span style="color: #000000;">fmt</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"%%.%df"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">adp</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">st</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">smmc</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">..</span><span style="color: #000000;">2</span><span style="color: #0000FF;">+</span><span style="color: #000000;">adp</span><span style="color: #0000FF;">]</span>
<span style="color: #000000;">dpa</span> <span style="color: #0000FF;">/=</span> <span style="color: #000000;">10</span>
<span style="color: #000000;">p10</span> <span style="color: #0000FF;">*=</span> <span style="color: #000000;">10</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #000000;">pn</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">while</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;">"(actual value 0.26149721284764278375542683860869)\n"</span><span style="color: #0000FF;">)</span>
<!--

54
Task/Meissel-Mertens-constant/Phix/meissel-mertens-constant-2.phix
View file

@ -1,54 +0,0 @@
-->
<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- no mpfr_zeta[_ui]() in mpfr.js, as yet, or mpfr_log() or mpfr_const_euler(), for that matter</span>
<span style="color: #008080;">include</span> <span style="color: #004080;">mpfr</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">moebius</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">then</span> <span style="color: #008080;">return</span> <span style="color: #000000;">1</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">f</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">prime_factors</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #004600;">true</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">2</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">f</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">f</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">f</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span> <span style="color: #008080;">then</span> <span style="color: #008080;">return</span> <span style="color: #000000;">0</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">return</span> <span style="color: #7060A8;">iff</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">odd</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">f</span><span style="color: #0000FF;">))?-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">:+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">Meissel_Mertens</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">d</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpfr_set_default_precision</span><span style="color: #0000FF;">(-</span><span style="color: #000000;">d</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- (d decimal places)</span>
<span style="color: #004080;">mpfr</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #000000;">rp</span><span style="color: #0000FF;">,</span><span style="color: #000000;">z</span><span style="color: #0000FF;">,</span><span style="color: #000000;">y</span><span style="color: #0000FF;">,</span><span style="color: #000000;">q</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpfr_inits</span><span style="color: #0000FF;">(</span><span style="color: #000000;">5</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">p</span> <span style="color: #008080;">in</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">,</span><span style="color: #000000;">7</span><span style="color: #0000FF;">}</span> <span style="color: #008080;">do</span>
<span style="color: #000080;font-style:italic;">-- z += log(1-1/p)+1/p</span>
<span style="color: #7060A8;">mpfr_set_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">rp</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpfr_div_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">rp</span><span style="color: #0000FF;">,</span><span style="color: #000000;">rp</span><span style="color: #0000FF;">,</span><span style="color: #000000;">p</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpfr_add</span><span style="color: #0000FF;">(</span><span style="color: #000000;">z</span><span style="color: #0000FF;">,</span><span style="color: #000000;">z</span><span style="color: #0000FF;">,</span><span style="color: #000000;">rp</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpfr_si_sub</span><span style="color: #0000FF;">(</span><span style="color: #000000;">rp</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">rp</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpfr_log</span><span style="color: #0000FF;">(</span><span style="color: #000000;">rp</span><span style="color: #0000FF;">,</span><span style="color: #000000;">rp</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpfr_add</span><span style="color: #0000FF;">(</span><span style="color: #000000;">z</span><span style="color: #0000FF;">,</span><span style="color: #000000;">z</span><span style="color: #0000FF;">,</span><span style="color: #000000;">rp</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">k</span><span style="color: #0000FF;">=</span><span style="color: #000000;">2</span> <span style="color: #008080;">to</span> <span style="color: #000000;">d</span> <span style="color: #008080;">do</span> <span style="color: #000080;font-style:italic;">-- (see note)</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">m</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">moebius</span><span style="color: #0000FF;">(</span><span style="color: #000000;">k</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">m</span> <span style="color: #008080;">then</span>
<span style="color: #7060A8;">mpfr_set_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">q</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">p</span> <span style="color: #008080;">in</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">,</span><span style="color: #000000;">7</span><span style="color: #0000FF;">}</span> <span style="color: #008080;">do</span>
<span style="color: #000080;font-style:italic;">-- q *= 1-power(p,-k)</span>
<span style="color: #7060A8;">mpfr_set_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">rp</span><span style="color: #0000FF;">,</span><span style="color: #000000;">p</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpfr_pow_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">rp</span><span style="color: #0000FF;">,</span><span style="color: #000000;">rp</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">k</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpfr_si_sub</span><span style="color: #0000FF;">(</span><span style="color: #000000;">rp</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">rp</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpfr_mul</span><span style="color: #0000FF;">(</span><span style="color: #000000;">q</span><span style="color: #0000FF;">,</span><span style="color: #000000;">q</span><span style="color: #0000FF;">,</span><span style="color: #000000;">rp</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #000080;font-style:italic;">-- y += moebius(k)*log(zeta(k)*q)/k</span>
<span style="color: #7060A8;">mpfr_zeta_ui</span><span style="color: #0000FF;">(</span><span style="color: #000000;">rp</span><span style="color: #0000FF;">,</span><span style="color: #000000;">k</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpfr_mul</span><span style="color: #0000FF;">(</span><span style="color: #000000;">rp</span><span style="color: #0000FF;">,</span><span style="color: #000000;">rp</span><span style="color: #0000FF;">,</span><span style="color: #000000;">q</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpfr_log</span><span style="color: #0000FF;">(</span><span style="color: #000000;">rp</span><span style="color: #0000FF;">,</span><span style="color: #000000;">rp</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpfr_div_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">rp</span><span style="color: #0000FF;">,</span><span style="color: #000000;">rp</span><span style="color: #0000FF;">,</span><span style="color: #000000;">k</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpfr_mul_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">rp</span><span style="color: #0000FF;">,</span><span style="color: #000000;">rp</span><span style="color: #0000FF;">,</span><span style="color: #000000;">m</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpfr_add</span><span style="color: #0000FF;">(</span><span style="color: #000000;">y</span><span style="color: #0000FF;">,</span><span style="color: #000000;">y</span><span style="color: #0000FF;">,</span><span style="color: #000000;">rp</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #000080;font-style:italic;">-- res := EULER+z+y</span>
<span style="color: #000000;">mpfr_const_euler</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpfr_add</span><span style="color: #0000FF;">(</span><span style="color: #000000;">z</span><span style="color: #0000FF;">,</span><span style="color: #000000;">z</span><span style="color: #0000FF;">,</span><span style="color: #000000;">y</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpfr_add</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #000000;">z</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">return</span> <span style="color: #000000;">res</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #004080;">mpfr</span> <span style="color: #000000;">m</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">Meissel_Mertens</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1001</span><span style="color: #0000FF;">)</span>
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #000000;">mpfr_get_str</span><span style="color: #0000FF;">(</span><span style="color: #000000;">m</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1001</span><span style="color: #0000FF;">))</span>
<!--

30
Task/Meissel-Mertens-constant/PureBasic/meissel-mertens-constant.basic
View file

@ -1,30 +0,0 @@
Procedure isPrime(v.i)
If v <= 1 : ProcedureReturn #False
ElseIf v < 4 : ProcedureReturn #True
ElseIf v % 2 = 0 : ProcedureReturn #False
ElseIf v < 9 : ProcedureReturn #True
ElseIf v % 3 = 0 : ProcedureReturn #False
Else
Protected r = Round(Sqr(v), #PB_Round_Down)
Protected f = 5
While f <= r
If v % f = 0 Or v % (f + 2) = 0
ProcedureReturn #False
EndIf
f + 6
Wend
EndIf
ProcedureReturn #True
EndProcedure
OpenConsole()
Euler.d = 0.5772156649 ;0153286
For x.i = 2 To 1e8
If isPrime(x)
m.d = m + Log(1-(1/x)) + (1/x)
EndIf
Next x
PrintN("MM = " + StrD(Euler + m))
PrintN(#CRLF$ + "--- terminado, pulsa RETURN---"): Input()
CloseConsole()

19
Task/Meissel-Mertens-constant/Python/meissel-mertens-constant.py
View file

@ -1,19 +0,0 @@
#!/usr/bin/python
from math import log
def isPrime(n):
for i in range(2, int(n**0.5) + 1):
if n % i == 0:
return False
return True
if __name__ == '__main__':
Euler = 0.57721566490153286
m = 0
for x in range(2, 10_000_000):
if isPrime(x):
m += log(1-(1/x)) + (1/x)
print("MM =", Euler + m)

67
Task/Meissel-Mertens-constant/REXX/meissel-mertens-constant.rexx
View file

@ -1,67 +0,0 @@
-- 28 Jul 2025
include Settings
arg n
if n = '' then
n = 16
numeric digits n
say 'MEISSEL-MERTENS CONSTANT'
say version
say
fact. = 0
call Time('r'); a = BruteForce(); e = Format(Time('e'),,3)
say 'BruteForce' a '('e 'seconds)'
call Time('r'); a = UsingSieve(); e = Format(Time('e'),,3)
say 'UsingSieve' a '('e 'seconds)'
call Time('r'); a = Analytic(); e = Format(Time('e'),,3)
say 'Analytic ' a '('e 'seconds)'
call Time('r'); a = TrueValue(); e = Format(Time('e'),,3)
say 'True value' a '('e 'seconds)'
exit
BruteForce:
procedure expose Memo.
numeric digits Digits()+2
y = 0.5-Ln(2)
do n = 3 by 2 to 1000000
if Prime(n) then do
q = 1/n; t = Ln(1-q)+q; y = y+t
end
end
y = Euler()+y
numeric digits Digits()-2
return y+0
UsingSieve:
procedure expose Memo. prim. flag.
numeric digits Digits()+2
n = Primes(1000000); y = 0
do i = 1 to n
q = 1/prim.i; t = Ln(1-q)+q; y = y+t
end
y = Euler()+y
numeric digits Digits()-2
return y+0
Analytic:
procedure expose Memo. fact.
numeric digits Digits()+2
y = 0; v = 0
do n = 2 to 1000
t = Moebius(n) * Ln(Zeta(n)) / n
if t <> 0 then do
y = y+t
if y = v then
leave
v = y
end
end
y = Euler()+y
numeric digits Digits()-2
return y+0
TrueValue:
procedure
return 0.261497212847642783755426838608695859051566648261199206192064213924924510897368209714142631434246651051617+0
include Math

5
Task/Meissel-Mertens-constant/Raku/meissel-mertens-constant.raku
View file

@ -1,5 +0,0 @@
# 20221011 Raku programming solution
my $s;
.is-prime and $s += log(1-1/$_)+1/$_ for 2 .. 10**8;
say $s + .57721566490153286

17
Task/Meissel-Mertens-constant/Run-BASIC/meissel-mertens-constant.basic
View file

@ -1,17 +0,0 @@
function isPrime(n)
if n < 2 then isPrime = 0 : goto [exit]
if n = 2 then isPrime = 1 : goto [exit]
if n mod 2 = 0 then isPrime = 0 : goto [exit]
isPrime = 1
for i = 3 to int(n^.5) step 2
if n mod i = 0 then isPrime = 0 : goto [exit]
next i
[exit]
end function
e = 0.5772156
for x = 2 to 100000 ' more prime numbers do not add more precision
if isPrime(x) then m = m + log(1-(1/x)) + (1/x)
next x
print "MM = "; e + m

39
Task/Meissel-Mertens-constant/Rust/meissel-mertens-constant.rs
View file

@ -1,39 +0,0 @@
fn list_prime_reciprocals(limit: i32) -> Vec<f64> {
let half_limit = if limit % 2 == 0 { limit / 2 } else { 1 + limit / 2 };
let mut composite = vec![false; half_limit as usize];
for i in 1..half_limit as usize {
let p = 3 + 2 * (i as i32 - 1);
if !composite[i] {
let mut a = i + p as usize;
while a < half_limit as usize {
composite[a] = true;
a += p as usize;
}
}
}
let mut result = Vec::with_capacity(half_limit as usize);
result.push(0.5); // Add 1/2 for prime number 2
for i in 1..half_limit as usize {
let p = 3 + 2 * (i as i32 - 1);
if !composite[i] {
result.push(1.0 / p as f64);
}
}
result
}
fn main() {
let prime_reciprocals = list_prime_reciprocals(100000000);
let euler = 0.577215664901532861;
let sum: f64 = prime_reciprocals.iter()
.map(|&reciprocal| reciprocal + (1.0 - reciprocal).ln())
.sum();
let meissel_mertens = euler + sum;
println!("The Meissel-Mertens constant = {:.8}", meissel_mertens);
}

7
Task/Meissel-Mertens-constant/Sidef/meissel-mertens-constant.sidef
View file

@ -1,7 +0,0 @@
var sum = 0
1e7.each_prime {|p|
with (1f/p) {|t|
sum += (log(1 - t) + t)
}
}
say sum+Num.EulerGamma

25
Task/Meissel-Mertens-constant/True-BASIC/meissel-mertens-constant.basic
View file

@ -1,25 +0,0 @@
FUNCTION isPrime (n)
IF n = 2 THEN
LET isPrime = 1
ELSEIF n <= 1 OR REMAINDER(n, 2) = 0 THEN
LET isPrime = 0
ELSE
LET isPrime = 1
FOR i = 3 TO INT(SQR(n)) STEP 2
IF REMAINDER(n, i) = 0 THEN
LET isPrime = 0
EXIT FUNCTION
END IF
NEXT i
END IF
END FUNCTION
LET e = .5772156649
FOR x = 2 to 1e6 !more prime numbers do not add more precision
IF isPrime(x) = 1 THEN
LET m = m + LOG(1-(1/x)) + (1/x)
END IF
NEXT x
PRINT "MM ="; e + m
END

16
Task/Meissel-Mertens-constant/Wren/meissel-mertens-constant-1.wren
View file

@ -1,16 +0,0 @@
import "./math" for Int
import "./fmt" for Fmt
var euler = 0.57721566490153286
var primes = Int.primeSieve(2.pow(31))
var pc = primes.count
var sum = 0
var c = 0
System.print("Primes added M")
System.print("------------ --------------")
for (p in primes) {
var rp = 1/p
sum = (1-rp).log + rp + sum
c = c + 1
if ((c % 1e7) == 0 || c == pc) Fmt.print("$,11d $0.12f", c, sum + euler)
}

51
Task/Meissel-Mertens-constant/Wren/meissel-mertens-constant-2.wren
View file

@ -1,51 +0,0 @@
import "./gmp" for Mpf
import "./math" for Int
import "./fmt" for Fmt
var isSquareFree = Fn.new { |n|
var i = 2
while (i * i <= n) {
if (n%(i*i) == 0) return false
i = (i > 2) ? i + 2 : i + 1
}
return true
}
var mu = Fn.new { |n|
if (n < 1) Fiber.abort("Argument must be a positive integer")
if (n == 1) return 1
var sqFree = isSquareFree.call(n)
var factors = Int.primeFactors(n)
if (sqFree && factors.count % 2 == 0) return 1
if (sqFree) return -1
return 0
}
var meisselMertens = Fn.new { |d|
Mpf.defaultPrec = d
var z = Mpf.zero
var y = Mpf.zero
var r = Mpf.new()
var q = Mpf.new()
var t = Mpf.new()
var m = Mpf.new()
for (p in [2, 3, 5, 7]) {
r.setUi(p).inv
t.uiSub(1, r).log.add(r)
z.add(t, z)
}
for (k in 2..d) {
q.setUi(1)
for (p in [2, 3, 5, 7]) {
r.setUi(p).inv
t.uiSub(1, r.pow(k))
q.mul(t)
}
m.setSi(mu.call(k))
t.zetaUi(k).mul(q).log.mul(m).div(k)
y.add(t, y)
}
return Mpf.euler.add(z).add(y)
}
Fmt.print("$20a", meisselMertens.call(3300).toString(1001))

24
Task/Meissel-Mertens-constant/XPL0/meissel-mertens-constant.xpl0
View file

@ -1,24 +0,0 @@
func IsPrime(N); \Return 'true' if N is prime
int N, D;
[if N < 2 then return false;
if (N&1) = 0 then return N = 2;
if rem(N/3) = 0 then return N = 3;
D:= 5;
while D*D <= N do
[if rem(N/D) = 0 then return false;
D:= D+2;
if rem(N/D) = 0 then return false;
D:= D+4;
];
return true;
];
def Euler = 0.57721566490153286;
real M; int P;
[M:= 0.;
for P:= 2 to 100_000_000 do
if IsPrime(P) then
M:= M + Ln(1. - 1./float(P)) + 1./float(P);
Format(1, 16);
Text(0, "MM = "); RlOut(0, Euler + M); CrLf(0);
]

18
Task/Meissel-Mertens-constant/Yabasic/meissel-mertens-constant.basic
View file

@ -1,18 +0,0 @@
e = 0.5772156
for x = 2 to 1e6 // more prime numbers do not add more precision
if isPrime(x) m = m + log(1-(1/x)) + (1/x)
next x
print "MM = ", e + m
end
sub isPrime(v)
if v < 2 return False
if mod(v, 2) = 0 return v = 2
if mod(v, 3) = 0 return v = 3
d = 5
while d * d <= v
if mod(v, d) = 0 then return False else d = d + 2 : fi
wend
return True
end sub