Jacobi symbol: Difference between revisions

{{trans|Python}}

I n <= 0

X ValueError(‘'n' must be a positive integer.’)

L(k) 0..kmax

print(‘#3’.format(jacobi(k, n)), end' ‘’)

{{out}}

=={{header|Action!}}==

{{libheader|Action! Tool Kit}}

INT FUNC Jacobi(INT a,n)

Put(125) PutE() ;clear the screen

PrintTable(10,39)

{{out}}

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

=={{header|Arturo}}==

{{trans|Nim}}

N: n % k

K: k

'item -> pad.left item 2

]

{{out}}

=={{header|AutoHotkey}}==

loop 20

result .= SubStr(" " A_Index, -1) " "

}

return (n=1) ? t : 0

{{out}}

<pre>n/k| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

=={{header|AWK}}==

{{trans|Go}}

# syntax: GAWK -f JACOBI_SYMBOL.AWK

BEGIN {

return(0)

}

{{out}}

<pre>

=={{header|C}}==

#include <stdio.h>

print_table(20, 21);

return 0;

{{out}}

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

#include <cassert>

#include <iomanip>

print_table(std::cout, 20, 21);

return 0;

{{out}}

=={{header|Crystal}}==

{{trans|Swift}}

raise ArgumentError.new "n must b positive and odd" if n < 1 || n.even?

res = 1

(0..10).each { |a| printf(" % 2d", jacobi(a, n)) }

puts

{{out}}

=={{header|Erlang}}==

jacobi(_, N) when N =< 0 -> jacobi_domain_error;

jacobi(_, N) when (N band 1) =:= 0 -> jacobi_domain_error;

false -> J2

end.

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

//Jacobi Symbol. Nigel Galloway: July 14th., 2020

let J n m=let rec J n m g=match n with

printfn "n\m 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30\n ----------------------------------------------------------------------------------------------------------------------"

[1..2..29]|>List.iter(fun m->printf "%3d" m; [1..30]|>List.iter(fun n->printf "%4d" (J n m)); printfn "")

{{out}}

<pre>

=={{header|FreeBASIC}}==

if b = 0 then return a

return gcdp( b, a mod b )

next k

print outstr

{{out}}

<pre> k 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

This translates the Lua code in the above referenced Wikipedia article to Go (for 8 byte integers) and checks that it gives the same answers for a small table of values - which it does.

import (

fmt.Println()

}

{{out}}

=={{header|Haskell}}==

{{trans|Scheme}}

jacobi 0 1 = 1

jacobi 0 _ = 0

else if rem a_mod_n 4 == 3 && rem n 4 == 3

then negate $ jacobi n a_mod_n

Or, expressing it slightly differently, and adding a tabulation:

import Data.List (replicate, transpose)

import Data.List.Split (chunksOf)

justifyRight :: Int -> a -> [a] -> [a]

{{Out}}

<pre> 0 1 2 3 4 5 6 7 8 9 10

=={{header|J}}==

NB. functionally equivalent translation of the Lua program found

NB. at https://en.wikipedia.org/wiki/Jacobi_symbol

end.

t*x=1

=={{header|Java}}==

public class JacobiSymbol {

}

{{out}}

<pre>

=={{header|jq}}==

{{trans|Julia}}

def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .;

def rpad($len): tostring | ($len - length) as $l | . + (" " * $l)[:$l];

(range( 1; 32; 2) as $n

| "\($n|rpad(3))" + reduce range(1; 13) as $a (""; . + (jacobi($a; $n) | lpad(4) ))

{{out}}

<pre>

=={{header|Julia}}==

{{trans|Python}}

a %= n

result = 1

end

end

<pre>

Table of jacobi(a, n) for a 1 to 12, n 1 to 31

=={{header|Kotlin}}==

assert(N > 0 && N and 1 == 1)

var a = A % N

}

return if (n == 1) result else 0

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

TableHeadings -> {ReplacePart[Range[1, 17, 2], 1 -> "n=1"],

{{out}}

Produces a nicely typeset table.

=={{header|Nim}}==

Translation of the Lua program from Wikipedia page.

template isEven(n: int): bool = (n and 1) == 0

for n in 1..20:

stdout.write align($jacobi(n, k), 3)

{{out}}

=={{header|Perl}}==

{{trans|Raku}}

use warnings;

printf '%4d', J($_, $n) for 1..$maxa;

print "\n"

{{out}}

<pre>n\k 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">jacobi</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">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;">end</span> <span style="color: #008080;">for</span>

{{out}}

<pre>

=={{header|Python}}==

if n <= 0:

raise ValueError("'n' must be a positive integer.")

return result

else:

=={{header|Raku}}==

{{works with|Rakudo|2019.11}}

sub infix:<J> (Int $k is copy, Int $n is copy where * % 2) {

$k %= $n;

}

print "\n";

{{out}}

<pre>n\k 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

<br>A little extra code was added to make a prettier grid.

parse arg rows cols . /*obtain optional arguments from the CL*/

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

end /*while a\==0*/

if n==1 then return $

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

<pre>

=={{header|Ruby}}==

{{trans|Crystal}}

raise ArgumentError.new "n must b positive and odd" if n < 1 || n.even?

res = 1

(0..10).each { |a| printf(" % 2d", jacobi(a, n)) }

puts

{{out}}

=={{header|Rust}}==

{{trans|C++}}

assert!(k > 0 && k % 2 == 1);

n %= k;

fn main() {

print_table(20, 21);

{{out}}

=={{header|Scala}}==

def jacobi(a_p: Int, n_p: Int): Int =

{

} yield println("n = " + n + ", a = " + a + ": " + jacobi(a, n))

}

{{out|output}}

=={{header|Scheme}}==

(let ((a-mod-n (modulo a n)))

(if (zero? a-mod-n)

(if (and (= (modulo a-mod-n 4) 3) (= (modulo n 4) 3))

(- (jacobi n a-mod-n))

=={{header|Sidef}}==

Also built-in as '''kronecker(n,k)'''.

assert(k > 0, "#{k} must be positive")

for n in (0..50), k in (0..50) {

assert_eq(jacobi(n, 2*k + 1), kronecker(n, 2*k + 1))

=={{header|Swift}}==

func jacobi(a: Int, n: Int) -> Int {

print()

{{out}}

=={{header|Vlang}}==

{{trans|Go}}

mut a := aa

mut n := na

}

}

{{out}}

<pre>

{{trans|Python}}

{{libheader|Wren-fmt}}

var jacobi = Fn.new { |a, n|

System.print()

n = n + 2

{{out}}

=={{header|zkl}}==

if(n.isEven or n<1)

throw(Exception.ValueError("'n' must be a positive odd integer"));

}

if(n==1) result else 0

println("n/a 0 1 2 3 4 5 6 7 8 9");

println("---------------------------------");

foreach a in (10){ print(" % d".fmt(jacobi(a,n))) }

println();

{{libheader|GMP}} GNU Multiple Precision Arithmetic Library

println("\nUsing BigInt library function:");

println("n/a 0 1 2 3 4 5 6 7 8 9");

foreach a in (10){ print(" % d".fmt(BI(a).jacobi(n))) }

println();

{{out}}

<pre>