Mertens function: Difference between revisions

{{trans|Python}}

 

‘Generate Mertens numbers’

V m = [-1, 1]

V crosses = sum(zip(ms, ms[1..]).map((a, b) -> Int(a != 0 & b == 0)))

print(‘M(N) equals zero #. times.’.format(zeroes))

 

{{out}}

 

=={{header|8080 Assembly}}==

org 100h

;;; Generate Mertens numbers

tms: db ' times.$'

;;; Numbers are stored page-aligned after program

 

{{out}}

 

=={{header|8086 Assembly}}==

puts: equ 9 ; MS-DOS syscall to print a string

putch: equ 2 ; MS-DOS syscall to print a character

section .bss

mm: resb MAX ; Mertens numbers

 

{{out}}

Calculations on a real Atari 8-bit computer take quite long time. It is recommended to use an emulator capable with increasing speed of Atari CPU.

{{libheader|Action! Tool Kit}}

 

PROC MertensNumbers(INT ARRAY m INT count)

PrintF("%EM(n) is zero %I times for 1<=n<=%I.%E",zeroCnt,MAX-1)

PrintF("%EM(n) crosses zero %I times for 1<=n<=%I.%E",crossCnt,MAX-1)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Mertens_function.png Screenshot from Atari 8-bit computer]

...which is...

{{Trans|Fortran}}

# Generate Mertens numbers #

[ 1 : 1000 ]INT m;

print( ( "M(N) is zero ", whole( zero, -4 ), " times.", newline ) );

print( ( "M(N) crosses zero ", whole( cross, -4 ), " times.", newline ) )

{{out}}

<pre>

=={{header|ALGOL W}}==

{{Trans|Fortran}}

integer array M ( 1 :: 1000 );

integer k, zero, cross;

write( i_w := 2, s_w := 0, "M(N) is zero ", zero, " times." );

write( i_w := 2, s_w := 0, "M(N) crosses zero ", cross, " times." )

{{out}}

<pre>

=={{header|APL}}==

{{works with|Dyalog APL}}

step ← {⍵,-⍨/⌽1,⍵[⌊n÷1↓⍳n←1+≢⍵]}

m1000 ← step⍣999⊢,1

⎕←'M(N) is zero ',(⍕zero),' times.'

⎕←'M(N) crosses zero ',(⍕cross),' times.'

 

{{out}}

=={{header|Arturo}}==

 

if n=0 -> return ""

if n=1 -> return 1

crossed: new 0

fold mertens1000 [a,b][if and? zero? b not? zero? a -> inc 'crossed, b]

 

{{out}}

 

=={{header|AutoHotkey}}==

loop 100

result .= SubStr(" " Mertens(A_Index), -1) . (Mod(A_Index, 10) ? " " : "`n")

ans.push(Format("{:d}", n))

return ans

{{out}}

<pre>first 100 terms:

a little over 1 hour on the 8086 (using GWBASIC).

 

20 M(1)=1

30 FOR N=2 TO 1000

170 PRINT "M(N) is zero";Z;"times."

180 PRINT "M(N) crosses zero";C;"times."

 

{{out}}

 

=={{header|Bash}}==

MAX=1000

 

 

echo "M(N) is zero $zero times."

 

{{out}}

 

=={{header|BCPL}}==

 

manifest $( limit = 1000 $)

writef("M(N) is zero %N times.*N", eqz)

writef("M(N) crosses zero %N times.*N", crossz)

{{out}}

<pre>The first 99 Mertens numbers are:

 

=={{header|C}}==

#include <stdlib.h>

 

printf("M(n) crosses zero %d times for 1 <= n <= %d.\n", cross, max);

return 0;

 

{{out}}

 

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

#include <iostream>

#include <vector>

std::cout << "M(n) crosses zero " << cross << " times for 1 <= n <= 1000.\n";

return 0;

 

{{out}}

 

=={{header|CLU}}==

mertens = proc (limit: int) returns (array[int])

M: array[int] := array[int]$fill(1,limit,0)

stream$putl(po, "M(N) is zero " || int$unparse(eqz) || " times.")

stream$putl(po, "M(N) crosses zero " || int$unparse(crossz) || " times.")

{{out}}

<pre>The first 99 Mertens numbers are:

 

=={{header|COBOL}}==

PROGRAM-ID. MERTENS.

 

SUBTRACT 1 FROM N GIVING K,

IF M(K) IS NOT EQUAL TO ZERO,

{{out}}

<pre>The first 99 Mertens numbers are:

 

=={{header|Cowgol}}==

 

const MAX := 1000;

 

print("M(n) is zero "); print_i8(zero); print(" times\n");

 

{{out}}

{{libheader| System.SysUtils}}

{{Trans|Go}}

program Mertens_function;

 

writeln(#10'Crosses zero ', m.crosses, ' times between 1 and 1000');

{$IFNDEF UNIX} readln; {$ENDIF}

 

=={{header|Draco}}==

word n,k;

m[1] := 1;

writeln("M(N) is zero ",eqz," times.");

writeln("M(N) crosses zero ",crossz," times.")

{{out}}

<pre>The first 99 Mertens numbers are:

{{trans|Swift}}

 

let mertens = Array.Empty(max + 1, 1)

for n in 2..max {

print("M(n) is zero \(zero) times for 1 <= n <= \(max).")

 

{{out}}

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

This task uses [http://www.rosettacode.org/wiki/Möbius_function#F.23 Möbius_function (F#)]

// Mertens function. Nigel Galloway: January 31st., 2021

let mertens=mobius|>Seq.scan((+)) 0|>Seq.tail

printfn "%d Zeroes\n####" (Seq.length (snd n.[0]))

printfn "Crosses zero %d times" (mertens|>Seq.take 1000|>Seq.pairwise|>Seq.sumBy(fun(n,g)->if n<>0 && g=0 then 1 else 0)))

{{out}}

<pre>

=={{header|Factor}}==

{{works with|Factor|0.99 2020-01-23}}

math.ranges math.statistics prettyprint sequences ;

 

2 <clumps> [ first2 [ 0 = not ] [ zero? ] bi* and ] count bl

pprint bl "zero crossings." print

{{out}}

<pre>

 

=={{header|Forth}}==

 

variable mertens AMOUNT cells allot

." M(N) is zero " . ." times." cr

." M(N) crosses zero " . ." times." cr

 

{{out}}

 

=={{header|Fortran}}==

implicit none

integer M(1000), n, k, zero, cross

50 format("M(N) crosses zero ",I2," times.")

write (*,50) cross

 

{{out}}

 

=={{header|FreeBASIC}}==

return wspace(i-len(str(j)))+str(j)

end function

outstr = ""

end if

{{out}}

<pre>

 

=={{header|Go}}==

 

import "fmt"

fmt.Println("\n\nEquals zero", zeros, "times between 1 and 1000")

fmt.Println("\nCrosses zero", crosses, "times between 1 and 1000")

 

{{out}}

 

=={{header|Haskell}}==

import qualified Data.MemoCombinators as Memo

import Math.NumberTheory.Primes (unPrime, factorise)

mapM_ (\row -> mapM_ (printf "%3d" . mertens) row >> printf "\n") $ chunksOf 10 [10..99]

printf "\nM(n) is zero %d times for 1 <= n <= 1000.\n" $ countZeros [1..1000]

{{out}}

<pre>The first 99 terms for M(1..99):

 

=={{header|J}}==

M =: +/@([: mu 1:+i.)

 

echo 'M(N) is zero ',(":zero),' times.'

echo 'M(N) crosses zero ',(":cross),' times.'

 

{{out}}

 

=={{header|Java}}==

public class MertensFunction {

 

 

}

 

{{out}}

 

'''Preliminaries'''

def sum(s): reduce s as $x (null; . + $x);

 

end

| .prev = $a[$i] )

'''Mertens Numbers'''

# Input: $max >= 1

# Output: an array of size $max with $max mertenNumbers beginning with 1

.[$n-1]=1

| reduce range(2; $n+1) as $k (.;

'''The Tasks'''

def mertens_number:

mertensNumbers[.-1];

(1000 | (task2, task3))

 

{{out}}

<pre>

=={{header|Julia}}==

The OEIS A002321 reference suggests the Mertens function has a negative bias, which it does below 1 million, but this bias seems to switch to a positive bias by 1 billion. There may simply be large swings in the bias overall, which get larger and longer as the sequence continues.

 

function moebius(n::Integer)

 

foreach(maximinM, (1000, 1_000_000, 1_000_000_000))

<pre>

First 99 terms of the Mertens function for positive integers:

 

=={{header|MAD}}==

DIMENSION M(1000)

PRINT FORMAT FC, CROSS

 

{{out}}

 

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

Mertens[n_] := Total[MoebiusMu[Range[n]]]

Grid[Partition[Mertens /@ Range[99], UpTo[10]]]

Count[Mertens /@ Range[1000], 0]

{{out}}

<pre>1 0 -1 -1 -2 -1 -2 -2 -2 -1

 

=={{header|Modula-2}}==

FROM InOut IMPORT WriteString, WriteInt, WriteCard, WriteLn;

 

WriteString(" times.");

WriteLn();

{{out}}

<pre>The first 99 Mertens numbers are:

=={{header|Nim}}==

{{trans|C}}

 

func mertensNumbers(max: int): seq[int] =

echo ""

echo &"M(n) is zero {zero} times for 1 ⩽ n ⩽ {Max}."

 

{{out}}

Nearly the same as [[Square-free_integers#Pascal]]

Instead here marking all multiples, starting at factor 2, of a prime by incrementing the factor count.<BR> runtime ~log(n)*n

{$IFDEF FPC}

{$MODE DELPHI}

setlength(primes,0);

setlength(sieve,0);

{{out}}

<pre>[1 to limit]

 

=={{header|Perl}}==

use strict;

use warnings;

(' 'x4 . sprintf "@{['%4d' x $show]}", @mertens[0..$show-1]) =~ s/((.){80})/$1\n/gr .

sprintf("\nEquals zero %3d times between 1 and $upto", scalar grep { ! $_ } @mertens) .

{{out}}

<pre>Mertens sequence - First 199 terms:

=={{header|Phix}}==

Based on the stackexchange link, short and sweet but not very fast: 1.4s just for the first 1000...

<span style="color: #008080;">function</span> <span style="color: #000000;">Mertens</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: #004080;">integer</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</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;">"\nMertens[1..1000] equals zero %d times and crosses zero %d times\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">zeroes</span><span style="color: #0000FF;">,</span><span style="color: #000000;">crosses</span><span style="color: #0000FF;">})</span>

{{out}}

Matches the wp table:

 

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

%replace MAX by 1000;

put skip list('Zeroes: ',isZero);

put skip list('Crossings:',crossZero);

{{out}}

<pre>The first 99 Mertens numbers are:

=={{header|Prolog}}==

{{works with|SWI Prolog}}

 

mertens_number(1, 1):- !.

count_zeros(1, 1000, Z, C),

writef('M(n) is zero %t times for 1 <= n <= 1000.\n', [Z]),

 

{{out}}

 

=={{header|PureBasic}}==

 

M(1)=1

For n=1 To 99 : Print(RSet(Str(M(n)),4)) : If n%10=9 : PrintN("") : EndIf : Next

PrintN("M(N) is zero "+Str(z)+" times.") : PrintN("M(N) crosses zero "+Str(c)+" times.")

{{out}}

<pre>First 99 Mertens numbers:

 

=={{header|Python}}==

"""Generate Mertens numbers"""

m = [None, 1]

crosses = sum(a!=0 and b==0 for a,b in zip(ms, ms[1:]))

print("M(N) equals zero {} times.".format(zeroes))

 

{{out}}

Mertens number is not defined for n == 0. Raku arrays are indexed from 0 so store a blank value at position zero to keep x and M(x) aligned.

 

 

sub μ (Int \n) {

printf "%4d: M(%d)\n", -$threshold, @mertens.first: * == -$threshold, :k;

printf "%4d: M(%d)\n", $threshold, @mertens.first: * == $threshold, :k;

{{out}}

<pre>Mertens sequence - First 199 terms:

 

The above "feature" was added to make the grid to be aligned with other solutions.

parse arg LO HI grp eqZ xZ . /*obtain optional arguments from the CL*/

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

end /*k*/ /* [↓] a prime (J) has been found. */

#= #+1; @.#=j; sq.j= j*j /*bump P count; P──►@.; compute J**2*/

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

 

 

=={{header|Ruby}}==

 

def μ(n)

puts "\nThe Mertens function is zero #{ar.count(0)} times in the range (1..1000);"

puts "it crosses zero #{ar.each_cons(2).count{|m1, m2| m1 != 0 && m2 == 0}} times."

{{out}}

<pre> 1 0 -1 -1 -2 -1 -2 -2 -2 -1 -2 -2 -3 -2 -1 -1 -2 -2 -3

=={{header|Sidef}}==

Built-in:

 

Algorithm for computing M(n) in sublinear time:

 

 

var lookup_size = (2 * n.iroot(3)**2)

cache{n} = M

}(n)

 

Task:

say "Mertens function in the range 1..#{n}:"

(1..n).map { mertens(_) }.slices(20).each {|line|

say (1..n->count_by { mertens(_)==0 }, " zeros")

say (1..n->count_by { mertens(_)==0 && mertens(_-1)!=0 }, " zero crossings")

{{out}}

<pre>

=={{header|Swift}}==

{{trans|C}}

 

func mertensNumbers(max: Int) -> [Int] {

}

print("M(n) is zero \(zero) times for 1 <= n <= \(max).")

 

{{out}}

=={{header|Vlang}}==

{{trans|go}}

mut to:=t

if to < 1 {

println("\n\nEquals zero $zeros times between 1 and 1000")

println("\nCrosses zero $crosses times between 1 and 1000")

 

{{out}}

{{libheader|Wren-fmt}}

{{libheader|Wren-math}}

import "/math" for Int

 

prev = next

}

 

{{out}}

 

=={{header|zkl}}==

[1..].tweak(fcn(n,pm){

pm.incN(mobius(n));

if(n!=m) acc.append(n/m); // opps, missed last factor

else acc;

.pump(Console.println, T(Void.Read,19,False),

fcn{ vm.arglist.pump(String,"%3d".fmt) });

otm.reduce(fcn(s,m){ s + (m==0) },0) : println(_," zeros");

otm.reduce(fcn(p,m,rs){ rs.incN(m==0 and p!=0); m }.fp2( s:=Ref(0) ));

{{out}}

<pre>