módulo

En informática , la operación de módulo devuelve el resto o resto con signo de una división , después de dividir un número por otro (llamado módulo de la operación).

Dados dos números positivos $a$ y $n$ , $un$ módulo $n$ (a menudo abreviado como $mod n$ ) es el resto de la división euclidiana de $a$ por $n$ , donde $a$ es el dividendo y $n$ $es$ el divisor . ^[1]

Por ejemplo, la expresión "5 mod 2" se evalúa como 1, porque 5 dividido por 2 tiene un cociente de 2 y un resto de 1, mientras que "9 mod 3" se evaluaría como 0, porque 9 dividido por 3 tiene un cociente de 3 y un resto de 0.

Aunque normalmente se realiza con $a$ y $n$ como números enteros , muchos sistemas informáticos ahora permiten otros tipos de operandos numéricos. El rango de valores para una operación de módulo entero de $n$ es de 0 a $n - 1$ ( $un$ mod 1 es siempre 0; $un mod 0$ no está definido, ya que es una división por cero ).

Cuando exactamente uno de $a$ o $n$ es negativo, la definición básica se rompe y los lenguajes de programación difieren en la forma en que se definen estos valores.

Variantes de la definición.

En matemáticas , el resultado de la operación de módulo es una clase de equivalencia , y cualquier miembro de la clase puede ser elegido como representante ; sin embargo, el representante habitual es el residuo menos positivo , el entero no negativo más pequeño que pertenece a esa clase (es decir, el resto de la división euclidiana ). ^[2] Sin embargo, son posibles otras convenciones. Las computadoras y calculadoras tienen varias formas de almacenar y representar números; por lo tanto, su definición de la operación del módulo depende del lenguaje de programación o del hardware subyacente .

En casi todos los sistemas informáticos, el cociente $q$ y el resto $r$ de $a$ dividido por $n$ satisfacen las siguientes condiciones:

Esto todavía deja un signo de ambigüedad si el resto es distinto de cero: ocurren dos opciones posibles para el resto, una negativa y otra positiva, esa elección determina cuál de los dos cocientes consecutivos debe usarse para satisfacer las ecuaciones (1). En teoría de números siempre se elige el resto positivo, pero en informática los lenguajes de programación eligen dependiendo del lenguaje y de los signos de $a$ o $n$ . ^[a]Pascal estándar y ALGOL 68 , por ejemplo, dan un resto positivo (o 0) incluso para divisores negativos, y algunos lenguajes de programación, como C90, lo dejan a la implementación cuando cualquiera de $n$ o $a$ es negativo (consulte la tabla en § En lenguajes de programación para más detalles). $un$ módulo 0 no está definido en la mayoría de los sistemas, aunque algunos lo definen $como$ .

Cociente ( $q$ ) y resto ( $r$ ) como funciones del dividendo ( $a$ ), usando división truncada
Muchas implementaciones utilizan división truncada , para la cual el cociente se define por
$q=\operatorname {trunc} \left({\frac {a}{n}}\right)$
donde es la función de parte integral ( redondeo hacia cero ), es decir, el truncamiento a cero de dígitos significativos. Así, según la ecuación ( 1 ), el resto tiene el mismo signo que el dividendo a , por lo que puede tomar $2|$ $norte$ $|$ $- 1$ valores: $\operatorname {trunc}$
$r=an\operatorname {trunc} \left({\frac {a}{n}}\right)$
Cociente y resto mediante división por suelo
Donald Knuth ^[3] promueve la división piso , para la cual el cociente se define por
$q=\left\lfloor {\frac {a}{n}}\right\rfloor$
donde ⌊⌋ es la función suelo ( redondeando hacia abajo ). Así, según la ecuación ( 1 ), el resto tiene el mismo signo que el divisor n :
$r=an\left\lfloor {\frac {a}{n}}\right\rfloor$
Cociente y resto usando división euclidiana
Raymond T. Boute ^[4] promueve la división euclidiana , para la cual el cociente se define por
$q=\operatorname {sgn}(n)\left\lfloor {\frac {a}{\left|n\right|}}\right\rfloor ={\begin{casos}\left\lfloor {\ frac {a}{n}}\right\rfloor &{\text{if }}n>0\\\left\lceil {\frac {a}{n}}\right\rceil &{\text{if } }n<0\\\end{casos}}$
donde $sgn$ es la función de signo , ⌊⌋ es la función de piso ( redondeando hacia abajo ) y ⌈⌉ es la función de techo ( redondeando hacia arriba ). Así, según la ecuación ( 1 ), el resto no es negativo :
$r=a-|n|\left\lfloor {\frac {a}{\left|n\right|}}\right\rfloor$
Cociente y resto usando división redondeada
Common Lisp e IEEE 754 utilizan división redondeada , para la cual el cociente se define por
$q=\operatorname {ronda} \left({\frac {a}{n}}\right)$
donde $ronda$ es la función redonda ( redondear la mitad a par ). Por lo tanto, según la ecuación ( 1 ), el resto se encuentra entre y y su signo depende de en qué lado de cero se encuentra dentro de estos límites: $-{\frac {n}{2}}$ ${\frac {n}{2}}$
$r=un\operatorname {ronda} \left({\frac {a}{n}}\right)$
Cociente y resto mediante división de techo
Common Lisp también utiliza la división de techo , para la cual el cociente se define por
$q=\left\lceil {\frac {a}{n}}\right\rceil$
donde ⌈⌉ es la función techo ( redondeando hacia arriba ). Así, según la ecuación ( 1 ), el resto tiene el signo opuesto al del divisor :
$r=an\left\lceil {\frac {a}{n}}\right\rceil$

Si tanto el dividendo como el divisor son positivos, entonces las definiciones truncada, mínima y euclidiana concuerdan. Si el dividendo es positivo y el divisor es negativo, entonces las definiciones truncada y euclidiana concuerdan. Si el dividendo es negativo y el divisor es positivo, entonces las definiciones piso y euclidiana concuerdan. Si tanto el dividendo como el divisor son negativos, entonces las definiciones truncada y mínima concuerdan.

Como lo describe Leijen,

Boute sostiene que la división euclidiana es superior a las demás en términos de regularidad y propiedades matemáticas útiles, aunque la división suelo, promovida por Knuth, también es una buena definición. A pesar de su uso generalizado, la división truncada resulta ser inferior a las otras definiciones.
— Daan Leijen, División y módulo para informáticos ^[5]

Sin embargo, la división truncada satisface la identidad . ^[6] $({-a})/b={-(a/b)}=a/({-b})$

Notación

Algunas calculadoras tienen un botón de función $mod()$ y muchos lenguajes de programación tienen una función similar, expresada como $mod(a, n)$ , por ejemplo. Algunos también admiten expresiones que utilizan "%", "mod" o "Mod" como operador de módulo o resto , como a % no a mod n.

Para entornos que carecen de una función similar, se puede utilizar cualquiera de las tres definiciones anteriores.

Errores comunes

Cuando el resultado de una operación de módulo tiene el signo del dividendo (definición truncada), puede dar lugar a errores sorprendentes.

Por ejemplo, para probar si un número entero es impar , uno podría inclinarse por probar si el resto entre 2 es igual a 1:

bool is_odd ( int n ) { retorno n % 2 == 1 ; }

Pero en un lenguaje donde el módulo tiene el signo del dividendo, eso es incorrecto, porque cuando $n$ (el dividendo) es negativo e impar, $n$ mod 2 devuelve −1 y la función devuelve falso.

Una alternativa correcta es probar que el resto no es 0 (porque el resto 0 es el mismo independientemente de los signos):

bool is_odd ( int n ) { retorno n % 2 != 0 ; }

Otra alternativa es utilizar el hecho de que para cualquier número impar, el resto puede ser 1 o −1:

bool is_odd ( int n ) { retorno n % 2 == 1 || norte % 2 == -1 ; }

Una alternativa más sencilla es tratar el resultado de n % 2 como si fuera un valor booleano, donde cualquier valor distinto de cero es verdadero:

bool is_odd ( int n ) { retorno n % 2 ; }

Problemas de desempeño

Las operaciones de módulo podrían implementarse de manera que cada vez se calcule una división con un resto. Para casos especiales, en algunos hardware, existen alternativas más rápidas. Por ejemplo, el módulo de potencias de 2 se puede expresar alternativamente como una operación AND bit a bit (asumiendo que $x$ es un entero positivo o usando una definición que no se trunca):

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

Ejemplos:

x % 2 == x & 1

x % 4 == x & 3

x % 8 == x & 7

En dispositivos y software que implementan operaciones bit a bit de manera más eficiente que el módulo, estas formas alternativas pueden resultar en cálculos más rápidos. ^[7]

Las optimizaciones del compilador pueden reconocer expresiones de la forma expression % constantdonde constantes una potencia de dos e implementarlas automáticamente como expression & (constant-1), lo que permite al programador escribir código más claro sin comprometer el rendimiento. Esta optimización simple no es posible para lenguajes en los que el resultado de la operación de módulo tiene el signo del dividendo (incluido C ), a menos que el dividendo sea de tipo entero sin signo . Esto se debe a que, si el dividendo es negativo, el módulo será negativo, mientras que expression & (constant-1)siempre será positivo. Para estos lenguajes, se debe utilizar la equivalencia , expresada mediante operaciones bit a bit OR, NOT y AND.x % 2ⁿ == x < 0 ? x | ~(2ⁿ - 1) : x & (2ⁿ - 1)

También existen optimizaciones para operaciones generales de módulo constante calculando primero la división utilizando la optimización del divisor constante .

Propiedades (identidades)

Algunas operaciones de módulo se pueden factorizar o expandir de manera similar a otras operaciones matemáticas. Esto puede resultar útil en pruebas de criptografía , como el intercambio de claves Diffie-Hellman . Algunas de estas propiedades ^{[ ¿cuáles? ]} requieren que $a$ y $n$ sean números enteros.

Identidad:
- $(un mod n) mod n = un mod n$ .
- $n x mod n = 0$ para todos los valores enteros positivos de $x$ .
- Si $p$ es un número primo que no es divisor de $b$ , entonces $ab p -1 mod p = a mod p$ , debido al pequeño teorema de Fermat .
Inverso:
- $[(- un mod n) + (un mod n)] mod n = 0$ .
- $b -1 mod n$ denota el inverso multiplicativo modular , que se define si y solo si $b$ y $n$ son primos relativos , que es el caso cuando se define el lado izquierdo: $[(b -1 mod n)(b mod n) ] mod norte = 1$ .
Distributivo:
- $(a + b) mod n = [(a mod n) + (b mod n)] mod n$ .
- $ab mod n = [(a mod n)(b mod n)] mod n$ .
División (definición): $.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{display:block;line-height:1em;margin:0.0em 0.1em;border-bottom:1px solid}.mw-parser-output .sfrac .den{display:block;line-height:1em;margin:0.1em 0.1em}.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/bmod n = [( a mod n )( b −1 mod n )] mod n$ , cuando el lado derecho está definido (es decir, $b$ y $n$ son coprimos ), y no definido en caso contrario.
Multiplicación inversa: $[(ab mod n)(b -1 mod n)] mod n = a mod n$ .

En lenguajes de programación

Además, muchos sistemas informáticos ofrecen una divmodfuncionalidad que genera el cociente y el resto al mismo tiempo. Los ejemplos incluyen las instrucciones de la arquitectura x86IDIV , la div()función del lenguaje de programación C y la función de Pythondivmod() .

Generalizaciones

Módulo con compensación

A veces es útil que el resultado de $un$ módulo $n$ no se encuentre entre 0 y $n - 1$ , sino entre algún número $d$ y $d + n - 1$ . En ese caso, $d$ se llama desplazamiento y $d = 1$ es particularmente común.

No parece haber una notación estándar para esta operación, así que usemos tentativamente $un mod d n$ . Tenemos así la siguiente definición: ^[56] $x = a mod d n$ en el caso de que $d \leq x \leq d + n - 1$ y $x mod n = a mod n$ . Claramente, la operación de módulo habitual corresponde al desplazamiento cero: $a mod n = a mod 0 n$ .

La operación del módulo con compensación está relacionada con la función de piso de la siguiente manera:

a\operatorname {mod} _ {d}n=an\left\lfloor {\frac {ad}{n}}\right\rfloor .

Para ver esto, vamos . Primero demostramos que $x$ $mod$ $n$ $=$ $a$ $mod$ $n$ . En general, es cierto que $($ $a$ $+$ $bn$ $) mod$ $n$ $=$ $a$ $mod$ $n$ para todos los números enteros $b$ ; por tanto, esto es cierto también en el caso particular cuando ; pero eso significa eso , que es lo que queríamos demostrar. Queda por demostrar que $d$ $\leq$ $x$ $\leq$ $d$ $+$ $n$ $- 1$ . Sean $k$ y $r$ los números enteros tales que $a$ $-$ $d$ $=$ $kn$ $+$ $r$ con $0 \leq$ $r$ $\leq$ $n$ $- 1$ (ver división euclidiana ). Entonces , así . Ahora tomamos $0 \leq$ $r$ $\leq$ $n$ $- 1$ y sumamos $d$ a ambos lados, obteniendo $d$ $\leq$ $d$ $+$ $r$ $\leq$ $d$ $+$ $n$ $- 1$ . Pero hemos visto que $x$ $=$ $d$ $+$ $r$ , así que hemos terminado. ${\textstyle x=an\left\lfloor {\frac {anuncio}{n}}\right\rfloor }$ ${\textstyle b=-\!\left\lfloor {\frac {ad}{n}}\right\rfloor }$ ${\textstyle x{\bmod {n}}=\left(an\left\lfloor {\frac {ad}{n}}\right\rfloor \right)\!{\bmod {n}}=a{\ mod {n}}}$ ${\textstyle \left\lfloor {\frac {anuncio}{n}}\right\rfloor =k}$ ${\textstyle x=an\left\lfloor {\frac {anuncio}{n}}\right\rfloor =a-nk=d+r}$

El módulo con desplazamiento $a mod d n$ se implementa en Mathematica como Mod[a, n, d] . ^[56]

Implementación de otras definiciones de módulo mediante truncamiento

A pesar de la elegancia matemática de la división piso de Knuth y la división euclidiana, generalmente es mucho más común encontrar un módulo truncado basado en división en los lenguajes de programación. Leijen proporciona los siguientes algoritmos para calcular las dos divisiones dada una división entera truncada: ^[5]

/* divmod euclidiano y de suelo, al estilo de ldiv() de C */ typedef struct { /* Esta estructura es parte de C stdlib.h, pero se reproduce aquí para mayor claridad */ long int quot ; largo int rem ; } ldiv_t ;          /* División euclidiana */ inline ldiv_t ldivE ( long numer , long denom ) { /* Los lenguajes C99 y C++11 definen ambos como truncados. */ long q = número / denominación ; long r = numer % denominación ; si ( r < 0 ) { si ( denom > 0 ) { q = q - 1 ; r = r + denominación ; } más { q = q + 1 ; r = r - denominación ; } } devolver ( ldiv_t ){. quot = q , . rem = r }; }                                                             /* División con piso */ inline ldiv_t ldivF ( número largo , denominación larga ) { long q = numer / denom ; long r = numer % denominación ; if (( r > 0 && denom < 0 ) || ( r < 0 && denom > 0 )) { q = q - 1 ; r = r + denominación ; } devolver ( ldiv_t ){. quot = q , . rem = r }; }

En ambos casos, el resto se puede calcular independientemente del cociente, pero no al revés. Las operaciones se combinan aquí para ahorrar espacio en la pantalla, ya que las ramas lógicas son las mismas.

Ver también

Módulo (desambiguación) : muchos usos de la palabra módulo , todos los cuales surgieron de la introducción de la aritmética modular por parte de Carl F. Gauss en 1801.
Módulo (matemáticas) , uso general del término en matemáticas
exponenciación modular
Girar (ángulo)

Notas

^ Matemáticamente, estas dos opciones son solo dos del infinito número de opciones disponibles para la desigualdad satisfecha por un resto .
^ ab El orden de los argumentos se invierte, es decir, α|ωcalcula el resto al dividir por . $\omega {\bmod {\alpha }}$ ωα
^ C99 y C++11 definen el comportamiento de %truncamiento. ^[9] Los estándares anteriores dejan el comportamiento definido por la implementación. ^[10]
^ El divisor debe ser positivo; de lo contrario, no está definido.
^ Como lo analizó Boute, las definiciones de ISO Pascal divy modno obedecen a la identidad de división de $D = d \cdot (D / d) + D % d$ y, por lo tanto, están fundamentalmente rotas.
^ Perl suele utilizar un operador de módulo aritmético que es independiente de la máquina. Para ejemplos y excepciones, consulte la documentación de Perl sobre operadores multiplicativos. ^[42]

Referencias

^ Weisstein, Eric W. "Congruencia". mathworld.wolfram.com . Consultado el 27 de agosto de 2020 .
^ Caldwell, Chris. "residuo". Primer glosario . Consultado el 27 de agosto de 2020 .
^ Knuth, Donald. E. (1972). El arte de la programación informática . Addison-Wesley.
^ Boute, Raymond T. (abril de 1992). "La definición euclidiana de las funciones div y mod". Transacciones ACM sobre lenguajes y sistemas de programación . ACM Press (Nueva York, NY, EE. UU.). 14 (2): 127-144. doi :10.1145/128861.128862. hdl : 1854/LU-314490 . S2CID 8321674.
^ ab Leijen, Daan (3 de diciembre de 2001). «División y Módulo para Informáticos» (PDF) . Consultado el 25 de diciembre de 2014 .
^ Peterson, Doctor (5 de julio de 2001). "Función Mod y números negativos". Foro de matemáticas: pregúntele al Dr. Math . Archivado desde el original el 22 de octubre de 2019 . Consultado el 22 de octubre de 2019 .
^ Horvath, Adam (5 de julio de 2012). "Operación de módulo y división más rápida: la potencia de dos".
^ ab "ISO/IEC 8652:2012 - Tecnología de la información - Lenguajes de programación - Ada". ISO , CEI . 2012. seg. 4.5.5 Operadores multiplicadores. {{cite journal}}: Citar diario requiere |journal=( ayuda )
^ "Especificación C99 (ISO/IEC 9899:TC2)" (PDF) . 2005-05-06. segundo. 6.5.5 Operadores multiplicativos . Consultado el 16 de agosto de 2018 .
^ "ISO/IEC 14882:2003: Lenguajes de programación - C++". Organización Internacional de Normalización (ISO), Comisión Electrotécnica Internacional (IEC). 2003, seg. 5.6.4. el operador binario % produce el resto de la división de la primera expresión por la segunda. .... Si ambos operandos no son negativos, entonces el resto no es negativo; si no, el signo del resto está definido por la implementación {{cite journal}}: Citar diario requiere |journal=( ayuda )
^ "ISO/IEC 9899:1990: Lenguajes de programación - C". ISO , CEI . 1990. seg. 7.5.6.4. La función $fmod$ devuelve el valor $x - i * y$ , para algún número entero $i$ tal que, si $y$ es distinto de cero, el resultado tiene el mismo signo que $x$ y magnitud menor que la magnitud de $y$ . {{cite journal}}: Citar diario requiere |journal=( ayuda )
^ ab dotnet-bot. "Método (Sistema) Math.IEEERemainder (Doble, Doble)". aprender.microsoft.com . Consultado el 4 de octubre de 2022 .
^ "clojure.core - Documentación de la API de Clojure v1.10.3". clojure.github.io . Consultado el 16 de marzo de 2022 .
^ "clojure.core - Documentación de la API de Clojure v1.10.3". clojure.github.io . Consultado el 16 de marzo de 2022 .
^ ab ISO/IEC JTC 1/SC 22/WG 4 (enero de 2023). ISO/IEC 1989:2023 – Lenguaje de programación COBOL . YO ASI .{{cite book}}: Mantenimiento CS1: nombres numéricos: lista de autores ( enlace )
^ Operadores de CoffeeScript
^ ISO/IEC JTC 1/SC 22 (febrero de 2012). ISO/IEC 23271:2012 — Tecnología de la información — Infraestructura de lenguaje común (CLI). YO ASI . §§ III.3.55–56.{{cite book}}: Mantenimiento CS1: nombres numéricos: lista de autores ( enlace )
^ "Expresiones - Lenguaje de programación D". dlang.org . Consultado el 1 de junio de 2021 .
^ "Método operador % - clase num - biblioteca dart:core - API Dart". api.dart.dev . Consultado el 1 de junio de 2021 .
^ "método restante - clase num - biblioteca dart:core - API de Dart". api.dart.dev . Consultado el 1 de junio de 2021 .
^ "Núcleo - Elixir v1.11.3". hexdocs.pm . Consultado el 28 de enero de 2021 .
^ "Entero - Elixir v1.11.3". hexdocs.pm . Consultado el 28 de enero de 2021 .
^ "Conceptos básicos: núcleo 1.0.5". paquete.elm-lang.org . Consultado el 16 de marzo de 2022 .
^ "Conceptos básicos: núcleo 1.0.5". paquete.elm-lang.org . Consultado el 16 de marzo de 2022 .
^ "Erlang - matemáticas". erlang.org . Consultado el 1 de junio de 2021 .
^ ANSI (28 de enero de 1987). Lenguajes de programación: BÁSICO completo. Nueva York: Instituto Nacional Estadounidense de Estándares. § 5.4.4. X módulo Y, es decir, XY*INT(X/Y).
^ ANSI (28 de enero de 1987). Lenguajes de programación: BÁSICO completo. Nueva York: Instituto Nacional Estadounidense de Estándares. § 5.4.4. La función restante, es decir, XY*IP(X/Y).
^ "Especificación del lenguaje GLSL, versión 4.50.7" (PDF) . sección 5.9 Expresiones. Si ambos operandos no son negativos, el resto no es negativo. Los resultados no están definidos si uno o ambos operandos son negativos.
^ "Especificación del lenguaje GLSL, versión 4.50.7" (PDF) . sección 8.3 Funciones comunes.
^ "La especificación del lenguaje de programación Go: el lenguaje de programación Go". ir.dev . Consultado el 28 de febrero de 2022 .
^ "paquete de matemáticas - matemáticas - pkg.go.dev". pkg.go.dev . Consultado el 28 de febrero de 2022 .
^ "paquete grande - math/big - pkg.go.dev". pkg.go.dev . Consultado el 28 de febrero de 2022 .
^ ab "6 tipos y clases predefinidos". www.haskell.org . Consultado el 22 de mayo de 2022 .
^ "Operadores". Microsoft . Consultado el 19 de julio de 2021 . El operador % se define solo en los casos en los que ambos lados son positivos o ambos lados son negativos. A diferencia de C, también opera con tipos de datos de punto flotante, así como con números enteros.
^ "Matemáticas · El lenguaje Julia". docs.julialang.org . Consultado el 20 de noviembre de 2021 .
^ "Matemáticas · El lenguaje Julia". docs.julialang.org . Consultado el 20 de noviembre de 2021 .
^ "rem - Lenguaje de programación Kotlin". Kotlin . Consultado el 5 de mayo de 2021 .
^ "mod - Lenguaje de programación Kotlin". Kotlin . Consultado el 5 de mayo de 2021 .
^ "Capítulo 3: El lenguaje NASM". NASM: la versión 2.15.05 del ensamblador de red .
^ "Biblioteca OCaml: Stdlib". ocaml.org . Consultado el 19 de febrero de 2022 .
^ "Biblioteca OCaml: Stdlib". ocaml.org . Consultado el 19 de febrero de 2022 .
^ Documentación Perl
^ "PHP: Operadores aritméticos - Manual". www.php.net . Consultado el 20 de noviembre de 2021 .
^ "PHP: fmod-Manual". www.php.net . Consultado el 20 de noviembre de 2021 .
^ "Anillo euclidiano".
^ Escritor cuántico. "Expresiones". docs.microsoft.com . Consultado el 11 de julio de 2018 .
^ "R: operadores aritméticos". search.r-project.org . Consultado el 24 de diciembre de 2022 .
^ "F32 - Óxido".
^ ab r6rs.org
^ "Lenguaje de comando de Shell". pubs.opengroup.org . Consultado el 5 de febrero de 2021 .
^ "Documentación para desarrolladores de Apple". desarrollador.apple.com . Consultado el 20 de noviembre de 2021 .
^ "Documentación para desarrolladores de Apple". desarrollador.apple.com . Consultado el 20 de noviembre de 2021 .
^ "Documentación para desarrolladores de Apple". desarrollador.apple.com . Consultado el 20 de noviembre de 2021 .
^ ab Rossberg, Andreas, ed. (19 de abril de 2022). "Especificación principal de WebAssembly: versión 2.0". Consorcio Mundial de la red . § 4.3.2 Operaciones con números enteros.
^ "Documentación en Zig". Lenguaje de programación Zig . Consultado el 18 de diciembre de 2022 .
^ ab "Modificación". Centro de documentación de sistemas y lenguaje Wolfram . Investigación Wolfram . 2020 . Consultado el 8 de abril de 2020 .

enlaces externos

Diferentes tipos de división de números enteros
Modulorama, animación de una representación cíclica de las tablas de multiplicar (explicación en francés)