Modular arithmetic: Difference between revisions

=={{header|Ada}}==

Ada has modular types.

procedure Modular_Demo is

Put (F_10); Put (" mod "); Put (Modul_13'Modulus'Image);

New_Line;

{{out}}

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

{{works with|ALGOL 68G|Any - tested with release 2.8.win32}}

PR precision 200 PR

ESAC;

{{out}}

<pre>

=={{header|C}}==

{{trans|C++}}

struct ModularArithmetic {

return 0;

{{out}}

<pre>f(ModularInteger(10, 13)) = ModularInteger(1, 13)</pre>

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

{{trans|Java}}

namespace ModularArithmetic {

}

}

{{out}}

<pre>x ^ 100 + x + 1 for x = ModInt(10, 13) is ModInt(1, 13)</pre>

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

{{trans|D}}

#include <ostream>

return 0;

{{out}}

<pre>f(ModularInteger(10, 13)) = ModularInteger(1, 13)</pre>

=={{header|D}}==

version(unittest) {

assertEquals(b^^99, ModularInteger(12,13));

assertEquals(b^^100, ModularInteger(3,13));

{{out}}

<pre>

Also note that since <code>^</code> is not a generic word, we employ the strategy of renaming it to <code>**</code> inside our vocabulary and defining a new word named <code>^</code> that can also handle modular integers. This is an acceptable way to handle it because Factor has pretty good word-disambiguation faculties. I just wouldn't want to have to employ them for more frequently-used arithmetic.

parser prettyprint prettyprint.custom sequences ;

IN: rosetta-code.modular-arithmetic

} 2show ;

{{out}}

<pre>

=={{header|Go}}==

Go does not allow redefinition of operators. That element of the task cannot be done in Go. The element of defining f so that it can be used with any ring however can be done, just not with the syntactic sugar of operator redefinition.

import "fmt"

func main() {

fmt.Println(f(modRing(13), uint(10)))

{{out}}

<pre>

=={{header|Haskell}}==

-- use / as an operator and 13 as a literal at the type level. (The library

-- also provides the fancy Zahlen (ℤ) symbol as a synonym for Integer.)

main :: IO ()

{{out}}

J does not allow "operator redefinition", but J's operators are capable of operating consistently on values which represent modular integers:

Task example:

=={{header|Java}}==

{{trans|Kotlin}}

{{works with|Java|8}}

private interface Ring<T> {

Ring<T> plus(Ring<T> rhs);

System.out.flush();

}

{{out}}

<pre>x ^ 100 + x + 1 for x = ModInt(10, 13) is ModInt(1, 13)</pre>

'''Preliminaries'''

def is_integer: type=="number" and floor == .;

# To take advantage of gojq's arbitrary-precision integer arithmetic:

def power($b): . as $in | reduce range(0;$b) as $i (1; . * $in);

'''Modular Arithmetic'''

# The function modint::assert/0 checks the input is of this form with integer values.

# pretty print

''' Ring Functions'''

if $A|is_modint then modint::add($A; $B)

elif $A|is_integer then $A + $B

def ring::f($x):

'''Evaluating ring::f'''

(ring::f(1) | "f(\(1)) => \(.)"),

(modint::make(10;13)

| ring::f(.) as $out

{{out}}

Implements the <tt>Modulo</tt> struct and basic operations.

val::T

mod::T

f(x) = x ^ 100 + x + 1

{{out}}

=={{header|Kotlin}}==

interface Ring<T> {

val y = f(x)

println("x ^ 100 + x + 1 for x == ModInt(10, 13) is $y")

{{out}}

=={{header|Lua}}==

local v = value % modulo

local tbl = {value=v, modulo=modulo}

local x = make(10, 13)

local y = func(x)

{{out}}

<pre>x ^ 100 + x + 1 for ModInt(10, 13) is ModInt(1, 13)</pre>

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

The best way to do it is probably to use the finite fields package.

{{out}}

{1}₁₃

=={{header|Nim}}==

Modular integers are represented as distinct integers with a modulus N managed by the compiler.

const Subscripts: array['0'..'9', string] = ["₀", "₁", "₂", "₃", "₄", "₅", "₆", "₇", "₈", "₉"]

var x = initModInt[13](10)

{{out}}

This feature exists natively in GP:

=={{header|Perl}}==

There is a CPAN module called Math::ModInt which does the job.

sub f { my $x = shift; $x**100 + $x + 1 };

{{out}}

<pre>mod(1, 13)</pre>

Phix does not allow operator overloading, but an f() which is agnostic about whether its parameter is a modular or normal int, we can do.

<span style="color: #008080;">type</span> <span style="color: #000000;">mi</span><span style="color: #0000FF;">(</span><span style="color: #004080;">object</span> <span style="color: #000000;">m</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">return</span> <span style="color: #004080;">sequence</span><span style="color: #0000FF;">(</span><span style="color: #000000;">m</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">and</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">m</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">2</span> <span style="color: #008080;">and</span> <span style="color: #004080;">integer</span><span style="color: #0000FF;">(</span><span style="color: #000000;">m</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">])</span> <span style="color: #008080;">and</span> <span style="color: #004080;">integer</span><span style="color: #0000FF;">(</span><span style="color: #000000;">m</span><span style="color: #0000FF;">[</span><span style="color: #000000;">2</span><span style="color: #0000FF;">])</span>

<span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #000000;">10</span><span style="color: #0000FF;">)</span>

<span style="color: #000000;">test</span><span style="color: #0000FF;">({</span><span style="color: #000000;">10</span><span style="color: #0000FF;">,</span><span style="color: #000000;">13</span><span style="color: #0000FF;">})</span>

{{out}}

=={{header|Prolog}}==

Works with SWI-Prolog versin 6.4.1 and module lambda (found there : http://www.complang.tuwien.ac.at/ulrich/Prolog-inedit/lambda.pl ).

congruence(Congruence, In, Fun, Out) :-

fun_2(L, [R]) :-

sum_list(L, R).

{{out}}

<pre> ?- congruence(13, [10], fun_1, R).

Thanks to duck typing, the function doesn't need to care about the actual type it's given. We also use the dynamic nature of Python to dynamically build the operator overload methods and avoid repeating very similar code.

import functools

print(f(Mod(10,13)))

=={{header|Quackery}}==

The third part fulfils the requirements of this task.

[ this ] is modular ( --> [ )

10 f echo cr

10 modularise f echo

'''Output:'''

<pre>10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011

=={{header|Racket}}==

(require racket/require

;; grab all "mod*" names, but get them without the "mod", so

(define (f x) (+ (expt x 100) x 1))

(with-modulus 13 (f 10))

=={{header|Raku}}==

Relevant portions of code in-lined from [https://raku.land/github:grondilu/Modular Modular].

has ($.residue, $.modulus);

multi method new($n, :$modulus) { self.new: :residue($n % $modulus), :$modulus }

sub f(\x) { x**100 + x + 1};

my $m-new = f( 10 Mod 13 );

{{out}}

<pre>1 「mod 13」</pre>

This implementation of +,-,*,/ uses a loose test (object?) to check operands type.

As soon as one is a modular integer, the other one is treated as a modular integer too.

; defining the modular integer class, and a constructor

print ["f definition is:" mold :f]

print ["f((integer) 10) is:" f 10]

{{out}}

<pre>f definition is: func [x][x ** 100 + x + 1]

=={{header|Ruby}}==

class Modulo

p x**100 + x +1 ##<Modulo:0x00000000ad1998 @n=1, @m=13>

=={{header|Scala}}==

{{Out}}Best seen running in your browser either by [https://scalafiddle.io/sf/jOSxPQu/0 ScalaFiddle (ES aka JavaScript, non JVM)] or [https://scastie.scala-lang.org/ZSeJw1lBRZiHenoQ6coDdA Scastie (remote JVM)].

private val x = new ModInt(10, 13)

private val y = f(x)

println("x ^ 100 + x + 1 for x = ModInt(10, 13) is " + y)

=={{header|Sidef}}==

{{trans|Ruby}}

method init {

func f(x) { x**100 + x + 1 }

{{out}}

<pre>1 「mod 13」</pre>

{{trans|Scala}}

higherThan: MultiplicationPrecedence

}

let y = f(x)

{{out}}

as is shown here.

{{tcllib|pt::pgen}}

package require pt::pgen

list ${opns} variable [string range $sourcecode [expr {$from+1}] $to]

}

None of the code above knows about modular arithmetic at all, or indeed about actual expression evaluation.

Now we define the semantics that we want to actually use.

oo::class create ModEval {

variable mod

# Put all the pieces together

Finally, demonstrating…

set x 10

{{out}}

<pre>

=={{header|VBA}}==

Private Function mi_one(ByVal a As Variant) As Variant

If IsArray(a) Then

test 10

test [{10,13}]

<pre>x^100 + x + 1 for x == 10 is 1E+100

x^100 + x + 1 for x == modint(10,13) is modint(1,13)</pre>

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

{{trans|C#}}

Interface IAddition(Of T)

End Sub

{{out}}

<pre>x ^ 100 + x + 1 for x = ModInt(10, 13) is ModInt(1, 13)</pre>

=={{header|Wren}}==

class Ring {

+(other) {}

var x = ModInt.new(10, 13)

{{out}}

=={{header|zkl}}==

Doing just enough to perform the task:

fcn init(n,mod){ var N=n,M=mod; }

fcn toString { String(N.divr(M)[1],"M",M) }

self(z.divr(M)[1],M)

}

Using GNU GMP lib to do the big math (to avoid writing a powmod function):

fcn f(n){ n.pow(100) + n + 1 }

f(1).println(" <-- 1^100 + 1 + 1");

n:=MC(BN(10),13);

(n+3).println(" <-- 10M13 + 3");

{{out}}

<pre>