Modulo -Betrieb

Im Computer, das Modulo -Betrieb Gibt die zurück Rest oder unterschriebene Rest von a Aufteilung, nachdem eine Nummer durch eine andere geteilt wurde (genannt die Modul der Operation).

Bei zwei positiven Zahlen $a$ und $n$ , $a$ Modulo $n$ (oft abgekürzt wie $a Mod n$ oder wie $a % n$ ) ist der Rest der Euklidische Division von $a$ durch $n$ , wo $a$ ist der Dividende und $n$ ist der Divisor. Die Modulo -Operation ist vom Symbol zu unterscheiden $Mod$ , was sich auf den Modul bezieht^[1] (oder Divisor) Man arbeitet aus.

Zum Beispiel würde der Ausdruck "5 mod 2" auf 1 bewertet, da 5 geteilt durch 2 a Quotient von 2 und einem Rest von 1, während "9 mod 3" auf 0 bewerten würde, da die Aufteilung von 9 bis 3 einen Quotienten von 3 und einen Rest von 0 hat; Es gibt nichts zu subtrahieren von 9 nach dem Multiplizieren von 3 mal 3.

Obwohl normalerweise mit $a$ und $n$ beides sein GanzzahlenViele Computersysteme ermöglichen nun andere Arten von numerischen Operanden. Der Wertebereich für einen Ganzzahlmodulo -Betrieb von $n$ ist 0 bis $n - 1$ inklusive ( $a$ Mod 1 ist immer 0; $a Mod 0$ ist undefiniert, möglicherweise zu einem Durch Null teilen Fehler in einigen Programmiersprachen). Sehen Modulararithmetik für eine ältere und verwandte Konvention in angewendet in Zahlentheorie.

Wann genau einer von $a$ oder $n$ ist negativ, die naive Definition bricht zusammen und die Programmiersprachen unterscheiden sich in der Definition dieser Werte.

Varianten der Definition

Im Mathematikdas Ergebnis der Modulo Operation ist ein Äquivalenzklasseund jedes Mitglied der Klasse kann als ausgewählt werden als Vertreter; Der übliche Vertreter ist jedoch der am wenigsten positive Rückstände, die kleinste nicht negative Ganzzahl, die zu dieser Klasse gehört (d. H. Der Rest der Euklidische Division).^[2] Andere Konventionen sind jedoch möglich. Computer und Taschenrechner haben verschiedene Möglichkeiten, Zahlen zu speichern und darzustellen; Somit hängt ihre Definition des Modulo -Vorgangs von der ab Programmiersprache oder das zugrunde liegende Hardware-.

In fast allen Computersystemen der Quotient $q$ und der Rest $r$ von $a$ geteilt durch $n$ Erfüllen Sie die folgenden Bedingungen:

oder

(1)

Dies hinterlässt jedoch immer noch ein Vorzeichen-Unklarheit, wenn der Rest ungleich Null ist: Zwei mögliche Auswahlmöglichkeiten für den Rest treten auf, eine negative und die andere positiv und zwei mögliche Auswahlmöglichkeiten für den Quotienten. In der Zahlentheorie wird der positive Rest immer ausgewählt, aber bei der Berechnung, Programmiersprachen wählen abhängig von der Sprache und den Zeichen von $a$ oder $n$ .^[a] Standard Pascal und Algol 68Geben Sie zum Beispiel einen positiven Rest (oder 0) auch für negative Divisors und einige Programmiersprachen wie C90 an, die es der Implementierung, wenn einer von $n$ oder $a$ ist negativ (siehe die Tabelle unter § in Programmiersprachen für Details). $a$ Modulo 0 ist in den meisten Systemen undefiniert, obwohl einige es definieren als $a$ .

Quotienten ( $q$ ) und Rest ( $r$ ) als Funktionen der Dividende ( $a$ ) unter Verwendung einer verkürzten Division

Viele Implementierungen verwenden abgeschnittene Abteilung, wo der Quotient definiert wird durch Kürzung (ganzzahliger Teil) $oder$ und damit gemäß Gleichung (1) Der Rest hätte das Gleiches Zeichen wie die Dividende. Der Quotient ist gerundet In Richtung Null: gleich der ersten Ganzzahl in Richtung Null aus dem genauen rationalen Quotienten.
${\ displayStyle r = a-n \ operatorname {trunc} \ links ({\ frac {a} {n}} \ rechts)}$
Quotient und Rest mit Bodendivision

Donald Knuth^[3] beschrieben Bodendivision wo der Quotient durch die definiert wird Bodenfunktion $oder$ und damit gemäß Gleichung (1) Der Rest hätte das Gleiches Zeichen wie der Teiler. Aufgrund der Bodenfunktion ist der Quotient immer nach unten abgerundet, auch wenn er bereits negativ ist.
$oder$
Quotient und Rest der euklidischen Division

Raymond T. Boute^[4] beschreibt die euklidische Definition, in der der Rest immer nicht negativ ist, $0 \leq r$ und ist somit mit dem überein Euklidische Division Algorithmus. In diesem Fall,
$oder$

${\ displayStyle n <0 \ impliziert q = \ links \ lceil {\ frac {a} {n}} \ rechts \ rceil}$

oder gleichwertig

$oder$

wo $sgn$ ist der Zeichenfunktion, und somit

$oder$
Quotient und Rest mit der Rundungsabteilung

In einer Rundkabine ist der Quotient ${\ textstyle q = \ operatorname {rund} \ links ({\ frac {a} {n}} \ rechts)}$ , d.h. auf die nächste Ganzzahl abgerundet. Es wird in gemeinsam Lisp und gefunden und IEEE 754 (Siehe Runde zum nächsten Tagung in IEEE-754). Somit wird das Zeichen des Restes ausgewählt, um zu sein am nächsten zu Null.
Quotient und Rest mit Deckenabteilung

Common Lisp definiert auch Deckenbindungen (Rest verschiedener Zeichen als Divisor), bei dem der Quotient gegeben wird ${\ textStyle q = \ links \ lceil {\ frac {a} {n}} \ rechts \ rceil}$ . Somit wird das Zeichen des Restes ausgewählt, um zu sein anders als der des Teils.

Wie von Leijen beschrieben,

Boute argumentiert, dass die euklidische Division den anderen in Bezug auf Regelmäßigkeit und nützliche mathematische Eigenschaften überlegen ist, obwohl die von Knuth geförderte Bodendivision auch eine gute Definition ist. Trotz seiner weit verbreiteten Verwendung wird gezeigt, dass die verkürzte Teilung den anderen Definitionen unterlegen ist.

-Daan Leijen, Teilung und Modul für Informatiker^[5]

Die verkürzte Abteilung erfüllt jedoch die Identität ${\ displayStyle ({-a})/b = {-(a/b)} = a/({-b})}$ .^[6]

Notation

Einige Taschenrechner haben a $mod ()$ Funktionstaste und viele Programmiersprachen haben eine ähnliche Funktion, ausgedrückt als $mod (a, n)$ , zum Beispiel. Einige unterstützen auch Ausdrücke, die "%", "Mod" oder "Mod" als Modulo oder Rest verwenden Operator, wie zum Beispiel a % n oder a mod n.

Für Umgebungen, in denen eine ähnliche Funktion fehlt, kann eine der drei oben genannten Definitionen verwendet werden.

Häufige Fehler

Wenn das Ergebnis einer Modulo -Operation das Zeichen der Dividende hat (Definitionsdefinition), kann dies zu überraschenden Fehlern führen.

Zum Beispiel zu testen, ob eine Ganzzahl ist seltsamMan könnte geneigt sein zu testen, ob der Rest von 2 gleich 1 ist:

bool ist ungerade(int n) {   Rückkehr n % 2 == 1; }

Aber in einer Sprache, in der Modulo das Zeichen der Dividende hat, ist das falsch, denn wann $n$ (Die Dividende) ist negativ und ungerade, $n$ MOD 2 gibt –1 zurück und die Funktion gibt false zurück.

Eine korrekte Alternative ist zu testen, dass der Rest nicht 0 ist (da der Rest 0 unabhängig von den Zeichen gleich ist):

bool ist ungerade(int n) {   Rückkehr n % 2 ! = 0; }

Eine andere Alternative besteht darin, die Tatsache zu verwenden, dass der Rest für jede ungerade Zahl entweder 1 oder -1 sein kann:

bool ist ungerade(int n) {   Rückkehr n % 2 == 1 || n % 2 == -1; }

Eine einfachere Alternative besteht darin, das Ergebnis von n% 2 so zu behandeln, als ob es sich um einen booleschen Wert handelt, bei dem ein Wert ungleich Null ist:

bool ist ungerade(int n) {   Rückkehr n % 2; }

Performance-Probleme

Modulo -Operationen können so implementiert werden, dass jedes Mal eine Abteilung mit einem Rest berechnet wird. Für besondere Fälle gibt es bei einigen Hardware schnellere Alternativen. Zum Beispiel das Modulo von Kräfte von 2 kann alternativ als ausgedrückt werden bitweise Und Operation (Annahme $x$ ist eine positive Ganzzahl oder verwendet eine nicht verwolkte Definition):

x% 2n == x & (2n - 1)

Beispiele:

x % 2 == x & 1

x % 4 == x & 3

x % 8 == x & 7

In Geräten und Software, die bitweise Vorgänge effizienter als Modulo implementieren, können diese alternativen Formen zu schnelleren Berechnungen führen.^[7]

Compiler -Optimierungen kann Ausdrücke der Form erkennen expression % constant wo constant ist eine Leistung von zwei und implementieren sie automatisch als expression & (constant-1), damit der Programmierer klarerer Code schreiben kann, ohne die Leistung zu beeinträchtigen. Diese einfache Optimierung ist für Sprachen nicht möglich, in denen das Ergebnis des Modulo -Betriebs das Zeichen der Dividende hat (einschließlich C), es sei denn, die Dividende ist von a ohne Vorzeichen Ganzzahltyp. Dies liegt daran, dass das Modulo negativ ist, wenn die Dividende negativ ist, während expression & (constant-1) wird immer positiv sein. Für diese Sprachen die Äquivalenz x% 2n == x <0? x | ~ (2n - 1): x & (2n - 1) muss stattdessen verwendet werden, mit bitweise oder nicht und operationen ausgedrückt werden.

Optimierungen für allgemeine Operationen mit konstantem Modulus existieren auch, indem die Teilung zunächst mit dem berechnet wird Optimierung mit Konstantivisoren.

Eigenschaften (Identitäten)

Einige Modulo -Operationen können ähnlich wie bei anderen mathematischen Operationen berücksichtigt oder erweitert werden. Dies kann nützlich sein in Kryptographie Beweise wie die Diffie -Hellman Key Exchange. Einige dieser Eigenschaften erfordern das $a$ und $n$ sind ganze Zahlen.

Identität:
- $(a Mod n) mod n = a Mod n$ .
- $n x Mod n = 0$ für alle positiven Ganzzahlwerte von $x$ .
- Wenn $p$ ist ein Primzahl Welches ist nicht a Divisor von $b$ , dann $ab p -1 Mod p = a Mod p$ , wegen Fermats kleiner Theorem.
Umgekehrt:
- $[( - a Mod n) + (a Mod n)] mod n = 0$ .
- $b -1 Mod n$ bezeichnet die Modulare multiplikative Inverse, was definiert ist dann und nur dann, wenn $b$ und $n$ sind relativ primär, was ist der Fall, wenn die linke Seite definiert ist: $[(b -1 Mod n) (b Mod n)] mod n = 1$ .
Verteilung:
- $(a + b) mod n = [((() a Mod n) + (b Mod n)] mod n$ .
- $ab Mod n = [((() a Mod n) (b Mod n)] mod n$ .
Abteilung (Definition): $.mw-parser-output .sfrac{white-space:nowrap}.mw-parser-output .sfrac.tion,.mw-parser-output .sfrac .tion{display:inline-block;vertical-align:-0.5em;font-size:85%;text-align:center}.mw-parser-output .sfrac .num,.mw-parser-output .sfrac .den{display:block;line-height:1em;margin:0 0.1em}.mw-parser-output .sfrac .den{border-top:1px solid}.mw-parser-output .sr-only{border:0;clip:rect(0,0,0,0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px} a/b Mod n = [((()a Mod n) (b–1 Mod n)] mod n$ , wenn die rechte Seite definiert ist (das ist dann $b$ und $n$ sind Coprime), und sonst undefiniert.
Inverse Multiplikation: $[(ab Mod n) (b -1 Mod n)] mod n = a Mod n$ .

In Programmiersprachen

Modulo -Operatoren in verschiedenen Programmiersprachen
Sprache	Operator	Ganze Zahl	Schwimmpunkt	Definition
Abap	`MOD`	Ja	Ja	Euklidisch
Aktionen	`%`	Ja	Nein	Gekürzt
Ada	`mod`	Ja	Nein	Bodend^[8]
Ada	`rem`	Ja	Nein	Gekürzt^[8]
Algol 68	`÷×`, `mod`	Ja	Nein	Euklidisch
Ampl	`mod`	Ja	Nein	Gekürzt
Apl	`\|`^[b]	Ja	Nein	Bodend
Apfelkript	`mod`	Ja	Nein	Gekürzt
Autolisp	`(rem d n)`	Ja	Nein	Gekürzt
Awk	`%`	Ja	Nein	Gekürzt
BASIC	`Mod`	Ja	Nein	Nicht definiert
BC	`%`	Ja	Nein	Gekürzt
C C ++	`%`, `div`	Ja	Nein	Gekürzt^[c]
	`fmod` (C) `std::fmod` (C ++)	Nein	Ja	Gekürzt^[11]
	`remainder` (C) `std::remainder` (C ++)	Nein	Ja	Gerundet
C#	`%`	Ja	Ja	Gekürzt
Clarion	`%`	Ja	Nein	Gekürzt
Sauber	`rem`	Ja	Nein	Gekürzt
Clojure	`mod`	Ja	Nein	Bodend^[12]
Clojure	`rem`	Ja	Nein	Gekürzt^[13]
Cobol	`FUNCTION MOD`	Ja	Nein	Bodend^[d]
CoffeeScript	`%`	Ja	Nein	Gekürzt
CoffeeScript	`%%`	Ja	Nein	Bodend^[14]
Coldfusion	`%`, `MOD`	Ja	Nein	Gekürzt
Common Lisp	`mod`	Ja	Ja	Bodend
Common Lisp	`rem`	Ja	Ja	Gekürzt
Kristall	`%`, `modulo`	Ja	Ja	Bodend
Kristall	`remainder`	Ja	Ja	Gekürzt
D	`%`	Ja	Ja	Gekürzt^[15]
Pfeil	`%`	Ja	Ja	Euklidisch^[16]
Pfeil	`remainder()`	Ja	Ja	Gekürzt^[17]
Eiffel	`\\`	Ja	Nein	Gekürzt
Elixier	`rem/2`	Ja	Nein	Gekürzt^[18]
Elixier	`Integer.mod/2`	Ja	Nein	Bodend^[19]
Ulme	`modBy`	Ja	Nein	Bodend^[20]
Ulme	`remainderBy`	Ja	Nein	Gekürzt^[21]
Erlang	`rem`	Ja	Nein	Gekürzt
Erlang	`math:fmod/2`	Nein	Ja	Verkürzt (gleich wie c)^[22]
Euphorie	`mod`	Ja	Nein	Bodend
Euphorie	`remainder`	Ja	Nein	Gekürzt
F#	`%`	Ja	Ja	Gekürzt
Faktor	`mod`	Ja	Nein	Gekürzt
FileMaker	`Mod`	Ja	Nein	Bodend
Weiter	`mod`	Ja	Nein	Implementierung definiert
	`fm/mod`	Ja	Nein	Bodend
	`sm/rem`	Ja	Nein	Gekürzt
Forran	`mod`	Ja	Ja	Gekürzt
Forran	`modulo`	Ja	Ja	Bodend
Frink	`mod`	Ja	Nein	Bodend
GLSL	`%`	Ja	Nein	Nicht definiert^[23]
GLSL	`mod`	Nein	Ja	Bodend^[24]
Gamemaker Studio (GML)	`mod`, `%`	Ja	Nein	Gekürzt
Gdscript (Godot)	`%`	Ja	Nein	Gekürzt
	`fmod`	Nein	Ja	Gekürzt
	`posmod`	Ja	Nein	Bodend
	`fposmod`	Nein	Ja	Bodend
gehen	`%`	Ja	Nein	Gekürzt^[25]
	`math.Mod`	Nein	Ja	Gekürzt^[26]
	`big.Int.Mod`	Ja	Nein	Euklidisch^[27]
Groovig	`%`	Ja	Nein	Gekürzt
Haskell	`mod`	Ja	Nein	Bodend^[28]
	`rem`	Ja	Nein	Gekürzt^[28]
	`Data.Fixed.mod'` (GHC))	Nein	Ja	Bodend
Haxe	`%`	Ja	Nein	Gekürzt
HLSL	`%`	Ja	Ja	Nicht definiert^[29]
J	`\|`^[b]	Ja	Nein	Bodend
Java	`%`	Ja	Ja	Gekürzt
Java	`Math.floorMod`	Ja	Nein	Bodend
JavaScript Typoskript	`%`	Ja	Ja	Gekürzt
Julia	`mod`	Ja	Ja	Bodend^[30]
Julia	`%`, `rem`	Ja	Ja	Gekürzt^[31]
Kotlin	`%`, `rem`	Ja	Ja	Gekürzt^[32]
Kotlin	`mod`	Ja	Ja	Bodend^[33]
ksh	`%`	Ja	Nein	Verkürzt (gleich wie POSIX SH)
ksh	`fmod`	Nein	Ja	Gekürzt
Labor	`mod`	Ja	Ja	Gekürzt
Libreoffice	`=MOD()`	Ja	Nein	Bodend
Logo	`MODULO`	Ja	Nein	Bodend
Logo	`REMAINDER`	Ja	Nein	Gekürzt
Lua 5	`%`	Ja	Ja	Bodend
Lua 4	`mod(x,y)`	Ja	Ja	Gekürzt
Liberty Basic	`MOD`	Ja	Nein	Gekürzt
Mathcad	`mod(x,y)`	Ja	Nein	Bodend
Ahorn	`e mod m` (standardmäßig), `modp(e, m)`	Ja	Nein	Euklidisch
	`mods(e, m)`	Ja	Nein	Gerundet
	`frem(e, m)`	Ja	Ja	Gerundet
Mathematica	`Mod[a, b]`	Ja	Nein	Bodend
Matlab	`mod`	Ja	Nein	Bodend
Matlab	`rem`	Ja	Nein	Gekürzt
Maxima	`mod`	Ja	Nein	Bodend
Maxima	`remainder`	Ja	Nein	Gekürzt
Maya eingebettete Sprache	`%`	Ja	Nein	Gekürzt
Microsoft Excel	`=MOD()`	Ja	Ja	Bodend
Minitab	`MOD`	Ja	Nein	Bodend
Modula-2	`MOD`	Ja	Nein	Bodend
Modula-2	`REM`	Ja	Nein	Gekürzt
MUMPS	`#`	Ja	Nein	Bodend
Netzweiter Assembler (Nasm, Nasmx))	`%`, `div` (ohne Vorzeichen)	Ja	Nein	-
Netzweiter Assembler (Nasm, Nasmx))	`%%` (unterzeichnet)	Ja	Nein	Implementierung definiert^[34]
Nim	`mod`	Ja	Nein	Gekürzt
Oberon	`MOD`	Ja	Nein	Bodenartig^[e]
Ziel c	`%`	Ja	Nein	Verkürzt (wie C99)
Objekt Pascal, Delphi	`mod`	Ja	Nein	Gekürzt
Ocaml	`mod`	Ja	Nein	Gekürzt^[35]
Ocaml	`mod_float`	Nein	Ja	Gekürzt^[36]
Occam	`\`	Ja	Nein	Gekürzt
Pascal (ISO -7185 und -10206)	`mod`	Ja	Nein	Euklidisch^[f]
Programmiercode erweitert (PCA))	`\`	Ja	Nein	Nicht definiert
Perl	`%`	Ja	Nein	Bodend^[g]
Perl	`POSIX::fmod`	Nein	Ja	Gekürzt
Phix	`mod`	Ja	Nein	Bodend
Phix	`remainder`	Ja	Nein	Gekürzt
Php	`%`	Ja	Nein	Gekürzt^[38]
Php	`fmod`	Nein	Ja	Gekürzt^[39]
Bild BASIC Profi	`\\`	Ja	Nein	Gekürzt
Pl/i	`mod`	Ja	Nein	Bodened (ansi pl/i)
Power Shell	`%`	Ja	Nein	Gekürzt
Programmiercode (PRC))	`MATH.OP - 'MOD; (\)'`	Ja	Nein	Nicht definiert
Fortschritt	`modulo`	Ja	Nein	Gekürzt
Prolog (ISO 1995))	`mod`	Ja	Nein	Bodend
Prolog (ISO 1995))	`rem`	Ja	Nein	Gekürzt
PureBasic	`%`, `Mod(x,y)`	Ja	Nein	Gekürzt
Pureskript	`mod`	Ja	Nein	Euklidisch^[40]
Reine Daten	`%`	Ja	Nein	Verkürzt (gleich wie c)
Reine Daten	`mod`	Ja	Nein	Bodend
Python	`%`	Ja	Ja	Bodend
Python	`math.fmod`	Nein	Ja	Gekürzt
Q#	`%`	Ja	Nein	Gekürzt^[41]
R	`%%`	Ja	Nein	Bodend
Schläger	`modulo`	Ja	Nein	Bodend
Schläger	`remainder`	Ja	Nein	Gekürzt
Raku	`%`	Nein	Ja	Bodend
Realbasic	`MOD`	Ja	Nein	Gekürzt
Grund	`mod`	Ja	Nein	Gekürzt
Rexx	`//`	Ja	Ja	Gekürzt
Rollenspiel	`%REM`	Ja	Nein	Gekürzt
Rubin	`%`, `modulo()`	Ja	Ja	Bodend
Rubin	`remainder()`	Ja	Ja	Gekürzt
Rost	`%`	Ja	Ja	Gekürzt
Rost	`rem_euclid()`	Ja	Ja	Euklidisch^[42]
SAS	`MOD`	Ja	Nein	Gekürzt
Scala	`%`	Ja	Nein	Gekürzt
Planen	`modulo`	Ja	Nein	Bodend
Planen	`remainder`	Ja	Nein	Gekürzt
Planen R⁶Rs	`mod`	Ja	Nein	Euklidisch^[43]
	`mod0`	Ja	Nein	Gerundet^[43]
	`flmod`	Nein	Ja	Euklidisch
	`flmod0`	Nein	Ja	Gerundet
Kratzen	`mod`	Ja	Ja	Bodend
Samen7	`mod`	Ja	Ja	Bodend
Samen7	`rem`	Ja	Ja	Gekürzt
Sensetalk	`modulo`	Ja	Nein	Bodend
Sensetalk	`rem`	Ja	Nein	Gekürzt
`sh` (Posix) (einschließlich verprügeln, Mksh, &c.)	`%`	Ja	Nein	Verkürzt (gleich wie c)^[44]
Smalltalk	`\\`	Ja	Nein	Bodend
Smalltalk	`rem:`	Ja	Nein	Gekürzt
Schnapp!	`mod`	Ja	Nein	Bodend
Drehen	`//`	Ja	Nein	Bodend
Solidität	`%`	Ja	Nein	Bodend
Sql (SQL: 1999))	`mod(x,y)`	Ja	Nein	Gekürzt
Sql (SQL: 2011))	`%`	Ja	Nein	Gekürzt
Standard ml	`mod`	Ja	Nein	Bodend
	`Int.rem`	Ja	Nein	Gekürzt
	`Real.rem`	Nein	Ja	Gekürzt
Stata	`mod(x,y)`	Ja	Nein	Euklidisch
Schnell	`%`	Ja	Nein	Gekürzt^[45]
	`remainder(dividingBy:)`	Nein	Ja	Gerundet^[46]
	`truncatingRemainder(dividingBy:)`	Nein	Ja	Gekürzt^[47]
Tcl	`%`	Ja	Nein	Bodend
Drehmoment	`%`	Ja	Nein	Gekürzt
Turing	`mod`	Ja	Nein	Bodend
Verilog (2001)	`%`	Ja	Nein	Gekürzt
VHDL	`mod`	Ja	Nein	Bodend
VHDL	`rem`	Ja	Nein	Gekürzt
Viml	`%`	Ja	Nein	Gekürzt
Visual Basic	`Mod`	Ja	Nein	Gekürzt
WebAssembly	`i32.rem_u`, `i64.rem_u` (ohne Vorzeichen)	Ja	Nein	—^[48]
WebAssembly	`i32.rem_s`, `i64.rem_s` (unterzeichnet)	Ja	Nein	Gekürzt^[49]
x86 Montage	`IDIV`	Ja	Nein	Gekürzt
Xbase ++	`%`	Ja	Ja	Gekürzt
Xbase ++	`Mod()`	Ja	Ja	Bodend
Z3 Theorem Prover	`div`, `mod`	Ja	Nein	Euklidisch

Darüber hinaus bieten viele Computersysteme a divmod Funktionalität, die gleichzeitig den Quotienten und den Rest erzeugt. Beispiele sind die x86 Architektur's IDIV Anweisungen, die C -Programmiersprache der von C. div() Funktion und Python's divmod() Funktion.

Verallgemeinerungen

Modulo mit Offset

Manchmal ist es nützlich für das Ergebnis von $a$ Modulo $n$ nicht zwischen 0 und nicht liegen $n - 1$ , aber zwischen einer Reihe $d$ und $d + n - 1$ . In diesem Fall, $d$ wird als ein genannt Offset. Es scheint keine Standardnotation für diesen Vorgang zu geben. Lassen Sie uns also vorläufig verwenden $a Mod d n$ . Wir haben also die folgende Definition:^[50] $x = a Mod d n$ Nur für den Fall $d \leq x \leq d + n - 1$ und $x Mod n = a Mod n$ . Offensichtlich entspricht der übliche Modulo -Betrieb null Offset: $a Mod n = a Mod 0 n$ . Der Betrieb von Modulo mit Offset hängt mit dem zusammen Bodenfunktion folgendermaßen:

oder

(Um dies zu sehen, lassen Sie es $oder$ . Wir zeigen das zuerst $x Mod n = a Mod n$ . Es ist im Allgemeinen wahr, dass $(a + bn) mod n = a Mod n$ Für alle Ganzzahlen $b$ ; Dies gilt daher auch in dem speziellen Fall, wenn $oder$ ; Aber das bedeutet das $oder BMOD {n}}}$ , was wir beweisen wollten. Es bleibt abzuweisen, dass $d \leq x \leq d + n - 1$ . Lassen $k$ und $r$ Seien Sie die Ganzzahlen, so dass $a - d = Kn + r$ mit $0 \leq r \leq n - 1$ (sehen Euklidische Division). Dann $oder$ , daher $oder$ . Jetzt nimm $0 \leq r \leq n - 1$ und hinzufügen $d$ zu beiden Seiten erhalten $d \leq d + r \leq d + n - 1$ . Aber das haben wir gesehen $x = d + r$ Also sind wir fertig. □)

Das Modulo mit Offset $a Mod d n$ wird in implementiert Mathematica wie Mod[a, n, d].^[50]

Implementierung anderer Modulo -Definitionen mithilfe von Kürzungen

Trotz der mathematischen Eleganz von Knuths Bodenabteilung und euklidischer Abteilung ist es im Allgemeinen viel häufiger, ein abgeschnittenes aufteilungsbasiertes Modulo in Programmiersprachen zu finden. Leijen liefert die folgenden Algorithmen zur Berechnung der beiden Abteilungen mit einer verkürzten Ganzzahlabteilung:^[5]

/ * Euklidische und bodend Divmod im Stil von Cs ldiv () */////// Typedef Struktur {   / * Diese Struktur ist Teil des C stdlib.h, wird aber hier aus Klarheit reproduziert */   lang int zitieren;   lang int Rem; } LDIV_T; / * Euklidische Division */ in der Reihe LDIV_T ldive(lang Numer, lang Denom) {   /* Die Sprachen von C99 und C ++ 11 definieren beide als abgeschnitten. */   lang q = Numer / Denom;   lang r = Numer % Denom;   wenn (r < 0) {   wenn (Denom > 0) {   q = q - 1;   r = r + Denom;   } anders {   q = q + 1;   r = r - Denom;   }   }   Rückkehr (LDIV_T) {.zitieren = q, .Rem = r}; } / * Bodendivision */ in der Reihe LDIV_T ldivf(lang Numer, lang Denom) {   lang q = Numer / Denom;   lang r = Numer % Denom;   wenn ((r > 0 && Denom < 0) || (r < 0 && Denom > 0)) {   q = q - 1;   r = r + Denom;   }   Rückkehr (LDIV_T) {.zitieren = q, .Rem = r}; }

In beiden Fällen kann der Rest unabhängig vom Quotienten berechnet werden, aber nicht umgekehrt. Die Vorgänge werden hier kombiniert, um den Bildschirmraum zu sparen, da die logischen Zweige gleich sind.

Siehe auch

Modulo (Disambiguierung) und Modulo (Jargon) - Viele Verwendungen des Wortes Modulo, alle wuchsen aus Carl F. Gauß's Einführung von Modulararithmetik im Jahr 1801.
Modulo (Mathematik), allgemeine Verwendung des Begriffs in Mathematik
Modulare Exponentiation
Drehung (Einheit)

Anmerkungen

^ Mathematisch sind diese beiden Auswahlmöglichkeiten nur zwei der unendlichen Anzahl von Auswahlmöglichkeiten für die Ungleichheit, die von einem Rest erfüllt ist.
^ ^a ^b Argumentreihenfolge kehrt sich um, d.h. α | ω berechnet ${\ displayStyle \ Omega {\ bmod {\ alpha}}}$ , der Rest beim Teilen ω durch α.
^ C99 und C ++ 11 das Verhalten von definieren % verkürzt werden.^[9] Die Standards zuvor lassen die Verhaltensimplementierung definiert.^[10]
^ Wie in Acucobol, Micro Focus COBOL und mögliche andere implementiert.
^ Der Divisor muss positiv sein, ansonsten undefiniert.
^ Wie von Boute diskutiert, ist Iso Pascals Definitionen von div und mod gehorchen nicht der Teilung Identität von $D = d \cdot (D / d) + D % d$ und sind also grundlegend gebrochen.
^ Perl verwendet normalerweise den arithmetischen Modulo-Operator, der maschinenunabhängig ist. Beispiele und Ausnahmen finden Sie in der Perl -Dokumentation zu multiplikativen Betreibern.^[37]

Verweise

^ Weisstein, Eric W. "Kongruenz". mathworld.wolfram.com. Abgerufen 2020-08-27.
^ Caldwell, Chris. "Rückstand". Prime Glossar. Abgerufen 27. August, 2020.
^ Knuth, Donald. E. (1972). Die Kunst der Computerprogrammierung. Addison-Wesley.
^ Boute, Raymond T. (April 1992). "Die euklidische Definition der Funktionen Div und Mod". ACM -Transaktionen zu Programmiersprachen und Systemen. ACM Press (New York, NY, USA). 14 (2): 127–144. doi:10.1145/128861.128862. HDL:1854/lU-314490. S2CID 8321674.
^ ^a ^b Leijen, Daan (3. Dezember 2001). "Teilung und Modul für Informatiker" (PDF). Abgerufen 2014-12-25. {{}}: Journal zitieren erfordert |journal= (Hilfe)
^ Peterson, Doktor (5. Juli 2001). "MOD -Funktion und negative Zahlen". Math Forum - Fragen Sie Dr. Math. Archiviert von das Original Am 2019-10-22. Abgerufen 22. Oktober 2019.
^ Horvath, Adam (5. Juli 2012). "Schnellere Abteilung und Modulo -Betrieb - die Leistung von zwei".
^ ^a ^b "ISO/IEC 8652: 2012 - Informationstechnologie - Programmiersprachen - ADA". ISO, IEC. 2012. Sec. 4.5.5 Multiplizieren von Betreibern. {{}}: Journal zitieren erfordert |journal= (Hilfe)
^ "C99 -Spezifikation (ISO/IEC 9899: TC2)" (PDF). 2005-05-06. Sek. 6.5.5 Multiplikationsbetreiber. Abgerufen 16. August 2018.
^ "ISO/IEC 14882: 2003: Programmiersprachen - C ++". Internationale Standardisierungsorganisation (ISO), Internationale Elektrotechnische Kommission (IEC). 2003. Sek. 5.6.4. Der binäre% -Preiber ergibt den Rest aus der Teilung des ersten Ausdrucks im zweiten. .... Wenn beide Operanden nicht negativ sind, ist der Rest nicht negativ; Wenn nicht, ist das Zeichen des Restes implementiert definiert {{}}: Journal zitieren erfordert |journal= (Hilfe)
^ "ISO/IEC 9899: 1990: Programmiersprachen - C". ISO, IEC. 1990. Sec. 7.5.6.4. Das $fmod$ Funktion gibt den Wert zurück $x - i * y$ für eine Ganzzahl $i$ so dass, wenn $y$ ist ungleich Null, das Ergebnis hat das gleiche Zeichen wie $x$ und Größe weniger als die Größe von $y$ . {{}}: Journal zitieren erfordert |journal= (Hilfe)
^ "Clojure.core - Clojure v1.10.3 API -Dokumentation". clojure.github.io. Abgerufen 2022-03-16.
^ "Clojure.core - Clojure v1.10.3 API -Dokumentation". clojure.github.io. Abgerufen 2022-03-16.
^ Coffeescript -Operatoren
^ "Ausdrücke - D Programmiersprache". dlang.org. Abgerufen 2021-06-01.
^ "Operator% Methode - Num Class - DART: Core Library - DART API". api.dart.dev. Abgerufen 2021-06-01.
^ "Restmethode - Num Class - Dart: Core Library - Dart -API". api.dart.dev. Abgerufen 2021-06-01.
^ "Kernel - Elixir v1.11.3". hexdocs.pm. Abgerufen 2021-01-28.
^ "Ganzzahl - Elixir v1.11.3". hexdocs.pm. Abgerufen 2021-01-28.
^ "Grundlagen - Core 1.0.5". package.elm-Lang.org. Abgerufen 2022-03-16.
^ "Grundlagen - Core 1.0.5". package.elm-Lang.org. Abgerufen 2022-03-16.
^ "Erlang - Mathematik". Erlang.org. Abgerufen 2021-06-01.
^ "GLSL -Sprachspezifikation, Version 4.50.7" (PDF). Abschnitt 5.9 Ausdrücke. Wenn beide Operanden nicht negativ sind, ist der Rest nicht negativ. Die Ergebnisse sind undefiniert, wenn einer oder beide Operanden negativ sind.
^ "GLSL -Sprachspezifikation, Version 4.50.7" (PDF). Abschnitt 8.3 Häufige Funktionen.
^ "Die GO -Programmiersprache Spezifikation - Die Go -Programmiersprache". Go.dev. Abgerufen 2022-02-28.
^ "Mathematikpaket - Math - pkg.go.dev". pkg.go.dev. Abgerufen 2022-02-28.
^ "Großes Paket - Math/Big - pkg.go.dev". pkg.go.dev. Abgerufen 2022-02-28.
^ ^a ^b "6 vordefinierte Typen und Klassen". www.haskell.org. Abgerufen 2022-05-22.
^ "Operatoren". Microsoft. Abgerufen 2021-07-19. Der% Operator ist nur in Fällen definiert, in denen beide Seiten positiv oder beide Seiten negativ sind. Im Gegensatz zu C arbeitet es auch mit Floating-Punkt-Datentypen sowie von Ganzzahlen.
^ "Mathematik · Die Julia -Sprache". docs.julialang.org. Abgerufen 2021-11-20.
^ "Mathematik · Die Julia -Sprache". docs.julialang.org. Abgerufen 2021-11-20.
^ "REM - Kotlin Programmiersprache". Kotlin. Abgerufen 2021-05-05.
^ "Mod - Kotlin Programmiersprache". Kotlin. Abgerufen 2021-05-05.
^ "Kapitel 3: Die Nasmsprache". Nasm - der netzweite Assembler Version 2.15.05.
^ "OCAML Library: Stdlib". ocaml.org. Abgerufen 2022-02-19.
^ "OCAML Library: Stdlib". ocaml.org. Abgerufen 2022-02-19.
^ Perl -Dokumentation
^ "PHP: Arithmetische Operatoren - Handbuch". www.php.net. Abgerufen 2021-11-20.
^ "PHP: FMOD - Handbuch". www.php.net. Abgerufen 2021-11-20.
^ "Euklidanring".
^ Quantenwriter. "Ausdrücke". docs.microsoft.com. Abgerufen 2018-07-11.
^ "F32 - Rost".
^ ^a ^b r6rs.org
^ "Shell -Befehlssprache". Pubs.opengroup.org. Abgerufen 2021-02-05.
^ "Apple Developer Dokumentation". Entwickler.apple.com. Abgerufen 2021-11-20.
^ "Apple Developer Dokumentation". Entwickler.apple.com. Abgerufen 2021-11-20.
^ "Apple Developer Dokumentation". Entwickler.apple.com. Abgerufen 2021-11-20.
^ "Numerics-WebAssembly 1.1 (Entwurf 2022-03-02)". WebAssembly.github.io. Abgerufen 2022-03-16.
^ "Numerics-WebAssembly 1.1 (Entwurf 2022-03-02)". WebAssembly.github.io. Abgerufen 2022-03-16.
^ ^a ^b "Mod". Wolfram Language & System Documentation Center. Wolfram -Forschung. 2020. Abgerufen 8. April, 2020.

Externe Links

Modulorama, Animation einer zyklischen Darstellung von Multiplikationstabellen (Erklärung auf Französisch)

[3] Mathematisch sind diese beiden Auswahlmöglichkeiten nur zwei der unendlichen Anzahl von Auswahlmöglichkeiten für die Ungleichheit, die von einem Rest erfüllt ist.

[rev-10] Argumentreihenfolge kehrt sich um, d.h. α | ω berechnet ${\ displayStyle \ Omega {\ bmod {\ alpha}}}$ , der Rest beim Teilen ω durch α.

[c-13] C99 und C ++ 11 das Verhalten von definieren % verkürzt werden.^[9] Die Standards zuvor lassen die Verhaltensimplementierung definiert.^[10]

[17] Wie in Acucobol, Micro Focus COBOL und mögliche andere implementiert.

[39] Der Divisor muss positiv sein, ansonsten undefiniert.

[42] Wie von Boute diskutiert, ist Iso Pascals Definitionen von div und mod gehorchen nicht der Teilung Identität von $D = d \cdot (D / d) + D % d$ und sind also grundlegend gebrochen.

[44] Perl verwendet normalerweise den arithmetischen Modulo-Operator, der maschinenunabhängig ist. Beispiele und Ausnahmen finden Sie in der Perl -Dokumentation zu multiplikativen Betreibern.^[37]

[1] Weisstein, Eric W. "Kongruenz". mathworld.wolfram.com. Abgerufen 2020-08-27.

[2] Caldwell, Chris. "Rückstand". Prime Glossar. Abgerufen 27. August, 2020.

[4] Knuth, Donald. E. (1972). Die Kunst der Computerprogrammierung. Addison-Wesley.

[5] Boute, Raymond T. (April 1992). "Die euklidische Definition der Funktionen Div und Mod". ACM -Transaktionen zu Programmiersprachen und Systemen. ACM Press (New York, NY, USA). 14 (2): 127–144. doi:10.1145/128861.128862. HDL:1854/lU-314490. S2CID 8321674.

[Leijen-6] Leijen, Daan (3. Dezember 2001). "Teilung und Modul für Informatiker" (PDF). Abgerufen 2014-12-25. {{}}: Journal zitieren erfordert |journal= (Hilfe)

[7] Peterson, Doktor (5. Juli 2001). "MOD -Funktion und negative Zahlen". Math Forum - Fragen Sie Dr. Math. Archiviert von das Original Am 2019-10-22. Abgerufen 22. Oktober 2019.

[8] Horvath, Adam (5. Juli 2012). "Schnellere Abteilung und Modulo -Betrieb - die Leistung von zwei".

[Ada-9] "ISO/IEC 8652: 2012 - Informationstechnologie - Programmiersprachen - ADA". ISO, IEC. 2012. Sec. 4.5.5 Multiplizieren von Betreibern. {{}}: Journal zitieren erfordert |journal= (Hilfe)

[C99-11] "C99 -Spezifikation (ISO/IEC 9899: TC2)" (PDF). 2005-05-06. Sek. 6.5.5 Multiplikationsbetreiber. Abgerufen 16. August 2018.

[12] "ISO/IEC 14882: 2003: Programmiersprachen - C ++". Internationale Standardisierungsorganisation (ISO), Internationale Elektrotechnische Kommission (IEC). 2003. Sek. 5.6.4. Der binäre% -Preiber ergibt den Rest aus der Teilung des ersten Ausdrucks im zweiten. .... Wenn beide Operanden nicht negativ sind, ist der Rest nicht negativ; Wenn nicht, ist das Zeichen des Restes implementiert definiert {{}}: Journal zitieren erfordert |journal= (Hilfe)

[14] "ISO/IEC 9899: 1990: Programmiersprachen - C". ISO, IEC. 1990. Sec. 7.5.6.4. Das $fmod$ Funktion gibt den Wert zurück $x - i * y$ für eine Ganzzahl $i$ so dass, wenn $y$ ist ungleich Null, das Ergebnis hat das gleiche Zeichen wie $x$ und Größe weniger als die Größe von $y$ . {{}}: Journal zitieren erfordert |journal= (Hilfe)

[15] "Clojure.core - Clojure v1.10.3 API -Dokumentation". clojure.github.io. Abgerufen 2022-03-16.

[16] "Clojure.core - Clojure v1.10.3 API -Dokumentation". clojure.github.io. Abgerufen 2022-03-16.

[CoffeeScript-18] Coffeescript -Operatoren

[19] "Ausdrücke - D Programmiersprache". dlang.org. Abgerufen 2021-06-01.

[20] "Operator% Methode - Num Class - DART: Core Library - DART API". api.dart.dev. Abgerufen 2021-06-01.

[21] "Restmethode - Num Class - Dart: Core Library - Dart -API". api.dart.dev. Abgerufen 2021-06-01.

[22] "Kernel - Elixir v1.11.3". hexdocs.pm. Abgerufen 2021-01-28.

[23] "Ganzzahl - Elixir v1.11.3". hexdocs.pm. Abgerufen 2021-01-28.

[24] "Grundlagen - Core 1.0.5". package.elm-Lang.org. Abgerufen 2022-03-16.

[25] "Grundlagen - Core 1.0.5". package.elm-Lang.org. Abgerufen 2022-03-16.

[26] "Erlang - Mathematik". Erlang.org. Abgerufen 2021-06-01.

[27] "GLSL -Sprachspezifikation, Version 4.50.7" (PDF). Abschnitt 5.9 Ausdrücke. Wenn beide Operanden nicht negativ sind, ist der Rest nicht negativ. Die Ergebnisse sind undefiniert, wenn einer oder beide Operanden negativ sind.

[28] "GLSL -Sprachspezifikation, Version 4.50.7" (PDF). Abschnitt 8.3 Häufige Funktionen.

[29] "Die GO -Programmiersprache Spezifikation - Die Go -Programmiersprache". Go.dev. Abgerufen 2022-02-28.

[30] "Mathematikpaket - Math - pkg.go.dev". pkg.go.dev. Abgerufen 2022-02-28.

[31] "Großes Paket - Math/Big - pkg.go.dev". pkg.go.dev. Abgerufen 2022-02-28.

[Haskell_2010-32] "6 vordefinierte Typen und Klassen". www.haskell.org. Abgerufen 2022-05-22.

[33] "Operatoren". Microsoft. Abgerufen 2021-07-19. Der% Operator ist nur in Fällen definiert, in denen beide Seiten positiv oder beide Seiten negativ sind. Im Gegensatz zu C arbeitet es auch mit Floating-Punkt-Datentypen sowie von Ganzzahlen.

[34] "Mathematik · Die Julia -Sprache". docs.julialang.org. Abgerufen 2021-11-20.

[35] "Mathematik · Die Julia -Sprache". docs.julialang.org. Abgerufen 2021-11-20.

[36] "REM - Kotlin Programmiersprache". Kotlin. Abgerufen 2021-05-05.

[37] "Mod - Kotlin Programmiersprache". Kotlin. Abgerufen 2021-05-05.

[38] "Kapitel 3: Die Nasmsprache". Nasm - der netzweite Assembler Version 2.15.05.

[40] "OCAML Library: Stdlib". ocaml.org. Abgerufen 2022-02-19.

[41] "OCAML Library: Stdlib". ocaml.org. Abgerufen 2022-02-19.

[43] Perl -Dokumentation

[45] "PHP: Arithmetische Operatoren - Handbuch". www.php.net. Abgerufen 2021-11-20.

[46] "PHP: FMOD - Handbuch". www.php.net. Abgerufen 2021-11-20.

[purescript_euclid-47] "Euklidanring".

[48] Quantenwriter. "Ausdrücke". docs.microsoft.com. Abgerufen 2018-07-11.

[rust_rem_euclid-49] "F32 - Rost".

[r6rs-50] r6rs.org

[51] "Shell -Befehlssprache". Pubs.opengroup.org. Abgerufen 2021-02-05.

[52] "Apple Developer Dokumentation". Entwickler.apple.com. Abgerufen 2021-11-20.

[53] "Apple Developer Dokumentation". Entwickler.apple.com. Abgerufen 2021-11-20.

[54] "Apple Developer Dokumentation". Entwickler.apple.com. Abgerufen 2021-11-20.

[55] "Numerics-WebAssembly 1.1 (Entwurf 2022-03-02)". WebAssembly.github.io. Abgerufen 2022-03-16.

[56] "Numerics-WebAssembly 1.1 (Entwurf 2022-03-02)". WebAssembly.github.io. Abgerufen 2022-03-16.

[Mathematica_Mod-57] "Mod". Wolfram Language & System Documentation Center. Wolfram -Forschung. 2020. Abgerufen 8. April, 2020.

[1]

[2]

[a]

[3]

[4]

[5]

[6]

[7]

[8]

[b]

[c]

[11]

[12]

[13]

[d]

[14]

[15]

[16]

[17]

[18]

[19]

[20]

[21]

[22]

[23]

[24]

[25]

[26]

[27]

[28]

[29]

[30]

[31]

[32]

[33]

[34]

[e]

[35]

[36]

[f]

[g]

[38]

[39]

[40]

[41]

[42]

[43]

[44]

[45]

[46]

[47]

[48]

[49]

[50]

[9]

[10]

[37]