Chowla numbers: Difference between revisions

Line 74:

:*   the OEIS entry for   [http://oeis.org/A048050 A48050 Chowla's function].

=={{header|11l}}==

<syntaxhighlight lang=11l>F chowla(n)

<syntaxhighlight lang="11l">F chowla(n)

V sum = 0

V i = 2

Line 169:

Line 168:

There are 5 perfect numbers < 350000000

</pre>

=={{header|Ada}}==

<syntaxhighlight lang=~~Ada~~>with Ada.Text_IO;

<syntaxhighlight lang="ada">with Ada.Text_IO;

procedure Chowla_Numbers is

Line 293:

Line 291:

33550336 is a perfect number

There are 5 perfect numbers < 350000000</pre>

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

<syntaxhighlight lang=algol68>BEGIN # find some Chowla numbers ( Chowla n = sum of divisors of n exclusing n and 1 ) #

<syntaxhighlight lang="algol68">BEGIN # find some Chowla numbers ( Chowla n = sum of divisors of n exclusing n and 1 ) #

# returs the Chowla number of n #

PROC chowla = ( INT n )INT:

Line 386:

Line 383:

There are 5 perfect numbers < 350000000

</pre>

=={{header|Arturo}}==

<syntaxhighlight lang=rebol>chowla: function [n]-> sum remove remove factors n 1 n

<syntaxhighlight lang="rebol">chowla: function [n]-> sum remove remove factors n 1 n

countPrimesUpTo: function [limit][

count: 1

Line 465:

Line 461:

8128

33550336</pre>

=={{header|AWK}}==

# syntax: GAWK -f CHOWLA_NUMBERS.AWK

# converted from Go

Line 595:

Line 590:

There are 5 perfect numbers <= 35,000,000

</pre>

=={{header|C}}==

<syntaxhighlight lang=c>#include <stdio.h>

<syntaxhighlight lang="c">#include <stdio.h>

unsigned chowla(const unsigned n) {

Line 679:

Line 673:

33550336 is a perfect number

There are 5 perfect numbers < 350000000</pre>

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

<syntaxhighlight lang=csharp>using System;

<syntaxhighlight lang="csharp">using System;

namespace chowla_cs

Line 792:

Line 785:

There are 5 perfect numbers <= 35,000,000

</pre>

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

<syntaxhighlight lang=cpp>#include <vector>

<syntaxhighlight lang="cpp">#include <vector>

#include <iostream>

Line 902:

Line 894:

33,550,336 is a number that is perfect

There are 5 perfect numbers <= 35,000,000</pre>

=={{header|CLU}}==

<syntaxhighlight lang=clu>% Chowla's function

<syntaxhighlight lang="clu">% Chowla's function

chowla = proc (n: int) returns (int)

sum: int := 0

Line 1,026:

Line 1,017:

=={{header|Cowgol}}==

<syntaxhighlight lang=cowgol>include "cowgol.coh";

<syntaxhighlight lang="cowgol">include "cowgol.coh";

sub chowla(n: uint32): (sum: uint32) is

Line 1,143:

Line 1,134:

33550336 is a perfect number.

There are 5 perfect numbers < 35000000</pre>

=={{header|D}}==

<syntaxhighlight lang=d>import std.stdio;

<syntaxhighlight lang="d">import std.stdio;

int chowla(int n) {

Line 1,259:

Line 1,249:

33550336 is a number that is perfect

There are 5 perfect numbers <= 35,000,000</pre>

=={{header|Delphi}}==

See [[#Pascal]].

Line 1,266:

Line 1,255:

<syntaxhighlight lang=dyalect>func chowla(n) {

<syntaxhighlight lang="dyalect">func chowla(n) {

var sum = 0

var i = 2

Line 1,395:

Line 1,384:

33550336 is a number that is perfect

There are 5 perfect numbers <= 35,000,000</pre>

=={{header|EasyLang}}==

<syntaxhighlight lang=text>func chowla n . sum .

<syntaxhighlight lang="text">func chowla n . sum .

sum = 0

i = 2

Line 1,543:

Line 1,531:

There are 5 perfect mumbers up to 35,000,000

</pre>

=={{header|Factor}}==

<syntaxhighlight lang=factor>USING: formatting fry grouping.extras io kernel math

<syntaxhighlight lang="factor">USING: formatting fry grouping.extras io kernel math

math.primes.factors math.ranges math.statistics sequences

tools.memory.private ;

Line 1,626:

Line 1,613:

33,550,336 is perfect

</pre>

=={{header|FreeBASIC}}==

' Chowla_numbers

Line 1,773:

Line 1,759:

Pulsa una tecla para salir

</pre>

=={{header|Go}}==

<syntaxhighlight lang=go>package main

<syntaxhighlight lang="go">package main

import "fmt"

Line 1,910:

Line 1,895:

There are 5 perfect numbers <= 35,000,000

</pre>

=={{header|Groovy}}==

<syntaxhighlight lang=groovy>class Chowla {

<syntaxhighlight lang="groovy">class Chowla {

static int chowla(int n) {

if (n < 1) throw new RuntimeException("argument must be a positive integer")

Line 2,033:

Line 2,017:

Uses arithmoi Library: https://hackage.haskell.org/package/arithmoi-0.11.0.0

compiled with "-O2 -threaded -rtsopts"

<syntaxhighlight lang=haskell>import Control.Concurrent (setNumCapabilities)

<syntaxhighlight lang="haskell">import Control.Concurrent (setNumCapabilities)

import Control.Monad.Par (runPar, get, spawnP)

import Control.Monad (join, (>=>))

Line 2,147:

Line 2,131:

33,550,336 is a perfect number.

There are 5 perfect numbers < 35,000,000</pre>

=={{header|J}}==

'''Solution:'''

<syntaxhighlight lang=j>chowla=: >: -~ >:@#.~/.~&.q: NB. sum of factors - (n + 1)

<syntaxhighlight lang="j">chowla=: >: -~ >:@#.~/.~&.q: NB. sum of factors - (n + 1)

intsbelow=: (2 }. i.)"0

Line 2,156:

Line 2,139:

findPerfectsbelow=: (#~ <: = chowla)@intsbelow</syntaxhighlight>

'''Tasks:'''

<syntaxhighlight lang=j> (] ,. chowla) >: i. 37 NB. chowla numbers 1-37

<syntaxhighlight lang="j"> (] ,. chowla) >: i. 37 NB. chowla numbers 1-37

1 0

2 0

Line 2,198:

Line 2,181:

findPerfectsbelow 35000000

6 28 496 8128 33550336</syntaxhighlight>

=={{header|Java}}==

public class Chowla {

Line 2,342:

Line 2,324:

There are 5 perfect numbers < 35,000,000

</pre>

=={{header|jq}}==

Line 2,348:

Line 2,329:

The "brute-force" computation of the perfect number beyond 8,128 took many hours.

<syntaxhighlight lang=jq>def add(stream): reduce stream as $x (0; . + $x);

<syntaxhighlight lang="jq">def add(stream): reduce stream as $x (0; . + $x);

# input should be an integer

Line 2,477:

Line 2,458:

33,550,336

</pre>

=={{header|Julia}}==

<syntaxhighlight lang=julia>using Primes, Formatting

<syntaxhighlight lang="julia">using Primes, Formatting

function chowla(n)

Line 2,573:

Line 2,552:

The count of perfect numbers up to 35,000,000 is 5.

</pre>

=={{header|Kotlin}}==

<syntaxhighlight lang=scala>// Version 1.3.21

<syntaxhighlight lang="scala">// Version 1.3.21

fun chowla(n: Int): Int {

Line 2,642:

Line 2,620:

Same as Go example.

</pre>

=={{header|Lua}}==

<syntaxhighlight lang=lua>function chowla(n)

<syntaxhighlight lang="lua">function chowla(n)

local sum = 0

local i = 2

Line 2,773:

Line 2,750:

33550336 is a number that is perfect

There are 5 perfect numbers <= 35,000,000</pre>

=={{header|MAD}}==

<syntaxhighlight lang=~~MAD~~> NORMAL MODE IS INTEGER

<syntaxhighlight lang="mad"> NORMAL MODE IS INTEGER

INTERNAL FUNCTION(N)

Line 2,877:

Line 2,853:

33550336 IS A PERFECT NUMBER.

THERE ARE 5 PERFECT NUMBERS BELOW 35000000</pre>

=={{header|Maple}}==

{{incorrect|Maple| The output for Chowla(1) is incorrect. }}

<syntaxhighlight lang=~~Maple~~>ChowlaFunction := n -> NumberTheory:-SumOfDivisors(n) - n - 1;

<syntaxhighlight lang="maple">ChowlaFunction := n -> NumberTheory:-SumOfDivisors(n) - n - 1;

PrintChowla := proc(n::posint) local i;

Line 2,958:

Line 2,933:

664579

[6, 28, 496, 8128, 33550336]</pre>

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

<syntaxhighlight lang=~~Mathematica~~>ClearAll[Chowla]

<syntaxhighlight lang="mathematica">ClearAll[Chowla]

Chowla[0 | 1] := 0

Chowla[n_] := DivisorSigma[1, n] - 1 - n

Line 2,980:

Line 2,954:

664579

{1, 6, 28, 496, 8128, 33550336}</pre>

=={{header|Nim}}==

<syntaxhighlight lang=nim>import strformat

<syntaxhighlight lang="nim">import strformat

import strutils

Line 3,078:

Line 3,051:

There are 5 perfect numbers < 350,000,000

</pre>

=={{header|Pascal}}==

Line 3,085:

Line 3,056:

{{trans|Go}} but not using a sieve, cause a sieve doesn't need precalculated small primes.

So runtime is as bad as trial division.

<syntaxhighlight lang=pascal>program Chowla_numbers;

<syntaxhighlight lang="pascal">program Chowla_numbers;

{$IFDEF FPC}

Line 3,246:

Line 3,217:

real 1m54,534s

</pre>

=={{header|Perl}}==

<syntaxhighlight lang=perl>use strict;

<syntaxhighlight lang="perl">use strict;

use warnings;

use ntheory 'divisor_sum';

Line 3,333:

Line 3,303:

There are 5 perfect numbers up to 35,000,000: 6 28 496 8,128 33,550,336</pre>

=={{header|Phix}}==

function chowla(atom n)

return sum(factors(n))

Line 3,410:

Line 3,379:

become 4s and 90s respectively, without finding anything else. Obviously 1.4e11 and 2.4e18

were picked to minimise the run times.

=={{header|Picat}}==

table

chowla(1) = 0.

Line 3,507:

Line 3,475:

There are 5 perfect numbers less than 35000000.

</pre>

=={{header|PicoLisp}}==

<syntaxhighlight lang=~~PicoLisp~~>(de accu1 (Var Key)

<syntaxhighlight lang="picolisp">(de accu1 (Var Key)

(if (assoc Key (val Var))

(con @ (inc (cdr @)))

Line 3,621:

Line 3,588:

(6 28 496 8128 33550336)

</pre>

=={{header|PowerBASIC}}==

Line 3,627:

Line 3,593:

<syntaxhighlight lang=powerbasic>#COMPILE EXE

<syntaxhighlight lang="powerbasic">#COMPILE EXE

#DIM ALL

#COMPILER PBCC 6

Line 3,779:

Line 3,745:

There are 8 perfect numbers <= 2,305,843,009,213,693,950

press any key to exit program</pre>

=={{header|Prolog}}==

chowla(1, 0).

chowla(2, 0).

Line 3,900:

Line 3,865:

There are 5 perfect numbers < 35,000,000.

</pre>

=={{header|Python}}==

Uses [https://www.python.org/dev/peps/pep-0515/ underscores to separate digits] in numbers, and th [https://www.sympy.org/en/index.htm sympy library] to aid calculations.

<syntaxhighlight lang=python># https://docs.sympy.org/latest/modules/ntheory.html#sympy.ntheory.factor_.divisors

<syntaxhighlight lang="python"># https://docs.sympy.org/latest/modules/ntheory.html#sympy.ntheory.factor_.divisors

from sympy import divisors

Line 4,001:

Line 3,965:

* Splitting one function for the jit compiler to digest.

<syntaxhighlight lang=python>from numba import jit

<syntaxhighlight lang="python">from numba import jit

# https://docs.sympy.org/latest/modules/ntheory.html#sympy.ntheory.factor_.divisors

Line 4,040:

Line 4,004:

Speedup - not much, subjectively...

=={{header|Racket}}==

<syntaxhighlight lang=racket>#lang racket

<syntaxhighlight lang="racket">#lang racket

(require racket/fixnum)

Line 4,135:

Line 4,098:

Primes < 10000000: 664579

There are 5 perfect numbers <= 35000000: (6 28 496 8128 33550336)</pre>

=={{header|Raku}}==

(formerly Perl 6)

Line 4,144:

Line 4,106:

(For a more reasonable test, reduce the orders-of-magnitude range in the "Primes count" line from 2..7 to 2..5)

<syntaxhighlight lang=raku line>sub comma { $^i.flip.comb(3).join(',').flip }

<syntaxhighlight lang="raku" line>sub comma { $^i.flip.comb(3).join(',').flip }

sub schnitzel (\Radda, \radDA = 0) {

Line 4,226:

Line 4,188:

33,550,336

</pre>

=={{header|REXX}}==

<syntaxhighlight lang=rexx>/*REXX program computes/displays chowla numbers (and may count primes & perfect numbers.*/

<syntaxhighlight lang="rexx">/*REXX program computes/displays chowla numbers (and may count primes & perfect numbers.*/

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

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

Line 4,333:

Line 4,294:

33,550,336 is a perfect number.

</pre>

=={{header|Ruby}}==

<syntaxhighlight lang=ruby>def chowla(n)

<syntaxhighlight lang="ruby">def chowla(n)

sum = 0

i = 2

Line 4,439:

Line 4,399:

33550336 is a perfect number

There are 5 perfect numbers < 350000000</pre>

=={{header|Scala}}==

This solution uses a lazily-evaluated iterator to find and sum the divisors of a number, and speeds up the large searches using parallel vectors.

<syntaxhighlight lang=scala>object ChowlaNumbers {

<syntaxhighlight lang="scala">object ChowlaNumbers {

def main(args: Array[String]): Unit = {

println("Chowla Numbers...")

Line 4,512:

Line 4,471:

4: 8,128

5: 33,550,336</pre>

=={{header|Swift}}==

Uses Grand Central Dispatch to perform concurrent prime counting and perfect number searching

<syntaxhighlight lang=swift>import Foundation

<syntaxhighlight lang="swift">import Foundation

@inlinable

Line 4,652:

Line 4,610:

8128 is a perfect number

33550336 is a perfect number</pre>

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

<syntaxhighlight lang=vb>Option Explicit

<syntaxhighlight lang="vb">Option Explicit

Private Declare Function AllocConsole Lib "kernel32.dll" () As Long

Line 4,818:

Line 4,775:

There are 5 perfect numbers <= 35.000.000

press enter to quit program.</pre>

=={{header|Visual Basic .NET}}==

<syntaxhighlight lang=vbnet>Imports System

<syntaxhighlight lang="vbnet">Imports System

Module Program

Line 4,923:

Line 4,879:

===More Cowbell===

{{libheader|System.Numerics}}One can get a little further, but that 8th perfect number takes nearly a minute to verify. The 9th takes longer than I have patience. If you care to see the 9th and 10th perfect numbers, change the 31 to 61 or 89 where indicated by the comment.

<syntaxhighlight lang=vbnet>Imports System.Numerics

<syntaxhighlight lang="vbnet">Imports System.Numerics

Module Program

Line 5,035:

Line 4,991:

2,305,843,008,139,952,128 is a number that is perfect

There are 8 perfect numbers <= 25,000,000,000,000,000,000</pre>

=={{header|Vlang}}==

<syntaxhighlight lang=vlang>fn chowla(n int) int {

<syntaxhighlight lang="vlang">fn chowla(n int) int {

if n < 1 {

panic("argument must be a positive integer")

Line 5,160:

Line 5,115:

There are 5 perfect numbers <= 35,000,000

</pre>

=={{header|Wren}}==

<syntaxhighlight lang=ecmascript>import "./fmt" for Fmt

<syntaxhighlight lang="ecmascript">import "./fmt" for Fmt

import "./math" for Int, Nums

Line 5,253:

Line 5,207:

There are 5 perfect numbers <= 35,000,000

</pre>

=={{header|XPL0}}==

<syntaxhighlight lang=~~XPL0~~>func Chowla(N); \Return sum of divisors

<syntaxhighlight lang="xpl0">func Chowla(N); \Return sum of divisors

int N, Div, Sum, Quot;

[Div:= 2; Sum:= 0;

Line 5,344:

Line 5,297:

33550336

</pre>

=={{header|zkl}}==

<syntaxhighlight lang=zkl>fcn chowla(n){

<syntaxhighlight lang="zkl">fcn chowla(n){

if(n<1)

throw(Exception.ValueError("Chowla function argument must be positive"));

Line 5,371:

Line 5,323:

c

}</syntaxhighlight>

<syntaxhighlight lang=zkl>fcn testChowla{

<syntaxhighlight lang="zkl">fcn testChowla{

println("The first 37 Chowla numbers:\n",

[1..37].apply(chowla).concat(" ","[","]"), "\n");