En computación , la operación de módulo devuelve el resto o el resto con signo de una división , después de que un número se divide por otro (llamado módulo de la operación).
Dados dos números positivos a y n , un modulo n (abreviado como un mod n ) es el resto de la división euclidiana de un por n , donde una es el dividendo y n es el divisor . [1] La operación de módulo debe distinguirse del símbolo mod , que se refiere al módulo [2] (o divisor) desde el que se está operando.
Por ejemplo, la expresión "5 mod 2" evaluaría a 1, porque 5 dividido por 2 tiene un cociente de 2 y un resto de 1, mientras que "9 mod 3" evaluaría a 0, porque la división de 9 por 3 tiene un cociente de 3 y un resto de 0; no hay nada que restar de 9 después de multiplicar 3 por 3.
(Aquí, observe que hacer una división con una calculadora no mostrará el resultado de la operación de módulo y que el cociente se expresará como una fracción decimal si se trata de un resto distinto de cero).
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 números para un módulo entero de n es de 0 a n - 1 inclusive ( un mod 1 es siempre 0; un mod 0 no está definido, lo que posiblemente resulte en una división por error cero en algunos lenguajes de programación). Consulte la aritmética modular para conocer una convención anterior y relacionada aplicada en la teoría de números .
Cuando exactamente uno de a o n es negativo, la definición ingenua se rompe y los lenguajes de programación difieren en cómo 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 elegirse como representante; sin embargo, el representante habitual es el residuo menos positivo , el número entero no negativo más pequeño que pertenece a esa clase (es decir, el resto de la división euclidiana ). [3] Sin embargo, son posibles otras convenciones. Las computadoras y las calculadoras tienen varias formas de almacenar y representar números; por tanto, su definición de la operación de 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:
( 1 )
Sin embargo, 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, y ocurren dos opciones posibles para el cociente. En teoría de números, siempre se elige el resto positivo, pero en informática, los lenguajes de programación eligen según el lenguaje y 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 (ver el 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 a .
- Muchas implementaciones usan división truncada , donde el cociente se define por truncamiento y así, según la ecuación ( 1 ), el resto tendría el mismo signo que el dividendo . El cociente se redondea hacia cero: igual al primer número entero en la dirección de cero del cociente racional exacto.
- Donald Knuth [4] describió la división en suelo donde el cociente está definido por la función del suelo y así, según la ecuación ( 1 ), el resto tendría el mismo signo que el divisor . Debido a la función de piso, el cociente siempre se redondea hacia abajo, incluso si ya es negativo.
- Raymond T. Boute [5] describe la definición euclidiana en la que el resto es siempre no negativo, 0 ≤ r , y por lo tanto es consistente con el algoritmo de división euclidiana . En este caso,
o equivalente
donde sgn es la función de signo , y por lo tanto
- Una división redonda es donde el cociente es , es decir, redondeado al número entero más cercano. Se encuentra en Common Lisp e IEEE 754 (consulte la convención de redondeo a la más cercana en IEEE-754). Por lo tanto, se elige el signo del resto para que sea más cercano a cero .
- Common Lisp también define la división de techo (signo diferente del resto del divisor) donde el cociente está dado por . Por lo tanto, se elige el signo del resto para que sea diferente al del divisor .
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 en el suelo, promovida por Knuth, también es una buena definición. A pesar de su uso generalizado, la división truncada se muestra inferior a las otras definiciones.
- Daan Leijen, División y módulo para informáticos [6]
Sin embargo, la división truncada satisface la identidad . [7]
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 usan "%", "mod" o "Mod" como operador de módulo o resto , como a % n
o 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 llevar a errores sorprendentes.
Por ejemplo, para probar si un número entero es impar, uno podría inclinarse a probar si el resto por 2 es igual a 1:
bool is_odd ( int n ) { return n % 2 == 1 ; }
Pero en un lenguaje donde 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 ) { return 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 ) { return n % 2 == 1 || n % 2 == -1 ; }
Problemas de desempeño
Las operaciones de módulo pueden implementarse de manera que se calcule una división con un resto cada vez. Para casos especiales, en algunos hardware, existen alternativas más rápidas. Por ejemplo, el módulo de potencias de 2 puede expresarse alternativamente como una operación AND bit a bit (asumiendo que x es un número entero positivo, o usando una definición no truncada):
x % 2n == x & (2n - 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. [8]
Las optimizaciones del compilador pueden reconocer expresiones de la forma expression % constant
donde constant
hay 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 simple optimización no es posible para idiomas 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 un tipo entero sin signo. Esto se debe a que, si el dividendo es negativo, el módulo será negativo, mientras expression & (constant-1)
que siempre será positivo. Para estos lenguajes, la equivalencia debe usarse en su lugar, expresada usando operaciones bit a bit OR, NOT y AND.x % 2n == x < 0 ? x | ~(2n - 1) : x & (2n - 1)
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 .
- Identidad:
- ( un modelo n ) modelo n = un modelo 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 modelo n ) + ( un modelo n )] modelo 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 n = 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): a/Bmod n = [( un mod n ) ( b -1 mod n )] mod n , cuando se define el lado derecho (que es cuando b y n son primos entre sí ). Indefinido de lo contrario.
- Multiplicación inversa: [( ab mod n ) ( b −1 mod n )] mod n = a mod n .
En lenguajes de programación
Idioma | Operador | Entero | Punto flotante | Definición |
---|---|---|---|---|
ABAP | MOD | sí | sí | Euclidiana |
ActionScript | % | sí | No | Truncado |
Ada | mod | sí | No | Piso |
rem | sí | No | Truncado | |
ALGOL 68 | ÷× , mod | sí | No | Euclidiana |
AMPL | mod | sí | No | Truncado |
APL | | [B] | sí | No | Piso |
AppleScript | mod | sí | No | Truncado |
AutoLISP | (rem d n) | sí | No | Truncado |
AWK | % | sí | No | Truncado |
BÁSICO | Mod | sí | No | Indefinido |
antes de Cristo | % | sí | No | Truncado |
C C ++ | % , div | sí | No | Truncado [c] |
fmod (C) std::fmod (C ++) | No | sí | Truncado [11] | |
remainder (C) std::remainder (C ++) | No | sí | Redondeado | |
C# | % | sí | sí | Truncado |
Clarín | % | sí | No | Truncado |
Limpio | rem | sí | No | Truncado |
Clojure | mod | sí | No | Piso |
rem | sí | No | Truncado | |
COBOL | FUNCTION MOD | sí | No | Suelo [d] |
CoffeeScript | % | sí | No | Truncado |
%% | sí | No | Suelo [12] | |
Fusión fría | % , MOD | sí | No | Truncado |
Lisp común | mod | sí | sí | Piso |
rem | sí | sí | Truncado | |
Cristal | % | sí | No | Truncado |
D | % | sí | sí | Truncado [13] |
Dardo | % | sí | sí | Euclidiana |
remainder() | sí | sí | Truncado | |
Eiffel | \\ | sí | No | Truncado |
Elixir | rem/2 | sí | No | Truncado [14] |
Integer.mod/2 | sí | No | Suelo [15] | |
Olmo | modBy | sí | No | Piso |
remainderBy | sí | No | Truncado | |
Erlang | rem | sí | No | Truncado |
Euforia | mod | sí | No | Piso |
remainder | sí | No | Truncado | |
F# | % | sí | sí | Truncado |
Factor | mod | sí | No | Truncado |
FileMaker | Mod | sí | No | Piso |
Adelante | mod | sí | No | Implementación definida |
fm/mod | sí | No | Piso | |
sm/rem | sí | No | Truncado | |
Fortran | mod | sí | sí | Truncado |
modulo | sí | sí | Piso | |
Frink | mod | sí | No | Piso |
GameMaker Studio (GML) | mod , % | sí | No | Truncado |
GDScript (Godot) | % | sí | No | Truncado |
fmod | No | sí | Truncado | |
posmod | sí | No | Piso | |
fposmod | No | sí | Piso | |
Ir | % | sí | No | Truncado |
math.Mod | No | sí | Truncado | |
Groovy | % | sí | No | Truncado |
Haskell | mod | sí | No | Piso |
rem | sí | No | Truncado | |
Data.Fixed.mod' ( GHC ) | No | sí | Piso | |
Haxe | % | sí | No | Truncado |
J | | [B] | sí | No | Piso |
Java | % | sí | sí | Truncado |
Math.floorMod | sí | No | Piso | |
JavaScript TypeScript | % | sí | sí | Truncado |
Julia | mod | sí | No | Piso |
% , rem | sí | No | Truncado | |
Kotlin | % , rem | sí | sí | Truncado [16] |
mod | sí | sí | Suelo [17] | |
ksh | % | sí | No | Truncado (igual que POSIX sh) |
fmod | No | sí | Truncado | |
LabVIEW | mod | sí | sí | Truncado |
LibreOffice | =MOD() | sí | No | Piso |
Logo | MODULO | sí | No | Piso |
REMAINDER | sí | No | Truncado | |
Lua 5 | % | sí | No | Piso |
Lua 4 | mod(x,y) | sí | No | Piso |
Libertad BASIC | MOD | sí | No | Truncado |
Mathcad | mod(x,y) | sí | No | Piso |
Arce | e mod m | sí | No | Euclidiana |
Mathematica | Mod[a, b] | sí | No | Piso |
MATLAB | mod | sí | No | Piso |
rem | sí | No | Truncado | |
Maxima | mod | sí | No | Piso |
remainder | sí | No | Truncado | |
Lenguaje incrustado maya | % | sí | No | Truncado |
Microsoft Excel | =MOD() | sí | sí | Piso |
Minitab | MOD | sí | No | Piso |
Modula-2 | MOD | sí | No | Piso |
REM | sí | No | Truncado | |
PAPERAS | # | sí | No | Piso |
Ensamblador de red ( NASM , NASMX ) | % , div (sin firmar) | sí | No | N / A |
%% (firmado) | sí | No | Definición de implementación [18] | |
Nim | mod | sí | No | Truncado |
Oberon | MOD | sí | No | Parecido al suelo [e] |
C objetivo | % | sí | No | Truncado (igual que C99) |
Objeto Pascal , Delphi | mod | sí | No | Truncado |
OCaml | mod | sí | No | Truncado |
mod_float | No | sí | Truncado | |
Occam | \ | sí | No | Truncado |
Pascal (ISO-7185 y -10206) | mod | sí | No | Euclidiana [f] |
Código de programación avanzado ( PCA ) | \ | sí | No | Indefinido |
Perl | % | sí | No | Suelo [g] |
POSIX::fmod | No | sí | Truncado | |
Phix | mod | sí | No | Piso |
remainder | sí | No | Truncado | |
PHP | % | sí | No | Truncado |
fmod | No | sí | Truncado | |
PIC BÁSICO Pro | \\ | sí | No | Truncado |
PL / I | mod | sí | No | Suelo (ANSI PL / I) |
Potencia Shell | % | sí | No | Truncado |
Código de programación ( PRC ) | MATH.OP - 'MOD; (\)' | sí | No | Indefinido |
Progreso | modulo | sí | No | Truncado |
Prólogo ( ISO 1995 ) | mod | sí | No | Piso |
rem | sí | No | Truncado | |
PureBasic | % , Mod(x,y) | sí | No | Truncado |
PureScript | `mod` | sí | No | Piso |
Pitón | % | sí | sí | Piso |
math.fmod | No | sí | Truncado | |
Q # | % | sí | No | Truncado [20] |
R | %% | sí | No | Piso |
Raqueta | modulo | sí | No | Piso |
remainder | sí | No | Truncado | |
Raku | % | No | sí | Piso |
RealBasic | MOD | sí | No | Truncado |
Razón | mod | sí | No | Truncado |
Rexx | // | sí | sí | Truncado |
Juego de rol | %REM | sí | No | Truncado |
Rubí | % , modulo() | sí | sí | Piso |
remainder() | sí | sí | Truncado | |
Oxido | % | sí | sí | Truncado |
rem_euclid() | sí | sí | Euclidiana [21] | |
SAS | MOD | sí | No | Truncado |
Scala | % | sí | No | Truncado |
Esquema | modulo | sí | No | Piso |
remainder | sí | No | Truncado | |
Esquema R 6 RS | mod | sí | No | Euclidiana [22] |
mod0 | sí | No | Redondeado [22] | |
flmod | No | sí | Euclidiana | |
flmod0 | No | sí | Redondeado | |
Rasga | mod | sí | No | Piso |
mod | No | sí | Truncado | |
Semilla7 | mod | sí | sí | Piso |
rem | sí | sí | Truncado | |
SenseTalk | modulo | sí | No | Piso |
rem | sí | No | Truncado | |
sh(POSIX) (incluye bash , mksh y c.) | % | sí | No | Truncado (igual que C) [23] |
Charla | \\ | sí | No | Piso |
rem: | sí | No | Truncado | |
¡Quebrar! | mod | sí | No | Piso |
Girar | // | sí | No | Piso |
Solidez | % | sí | No | Piso |
SQL ( SQL: 1999 ) | mod(x,y) | sí | No | Truncado |
SQL ( SQL: 2011 ) | % | sí | No | Truncado |
ML estándar | mod | sí | No | Piso |
Int.rem | sí | No | Truncado | |
Real.rem | No | sí | Truncado | |
Stata | mod(x,y) | sí | No | Euclidiana |
Rápido | % | sí | No | Truncado |
truncatingRemainder(dividingBy:) | No | sí | Truncado | |
Tcl | % | sí | No | Piso |
Esfuerzo de torsión | % | sí | No | Truncado |
Turing | mod | sí | No | Piso |
Verilog (2001) | % | sí | No | Truncado |
VHDL | mod | sí | No | Piso |
rem | sí | No | Truncado | |
VimL | % | sí | No | Truncado |
Visual Basic | Mod | sí | No | Truncado |
WebAssembly | i32.rem_s , i64.rem_s | sí | No | Truncado |
montaje x86 | IDIV | sí | No | Truncado |
XBase ++ | % | sí | sí | Truncado |
Mod() | sí | sí | Piso | |
Demostrador del teorema Z3 | div , mod | sí | No | Euclidiana |
Además, muchos sistemas informáticos proporcionan una divmod
funcionalidad que produce el cociente y el resto al mismo tiempo. Los ejemplos incluyen la arquitectura x86 's IDIV
instrucción, del lenguaje de programación C div()
función, y de Python divmod()
función.
Generalizaciones
Módulo con desplazamiento
A veces es útil para el resultado de un módulo n mienta no entre 0 y n -1 , pero entre un número d y d + n -1 . En ese caso, d se denomina desplazamiento. No parece haber una notación estándar para esta operación, así que usemos tentativamente un mod d n . Por lo tanto, tenemos la siguiente definición: [24] x = a mod d n solo en el caso de d ≤ x ≤ 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 de módulo con offset está relacionada con la función de piso de la siguiente manera:
- .
(Esto es fácil de ver. Deje . Primero mostramos que x mod n = a mod n . En general, es cierto que ( a + bn ) mod n = a mod n para todos los enteros b ; por lo tanto, esto es cierto también en el caso particular cuando; pero eso significa que, que es lo que queríamos demostrar. Queda por demostrar que d ≤ x ≤ d + n −1 . Deje k y r sean los números enteros tales que un - d = kn + r con 0 ≤ r ≤ n -1 (ver división euclidiana ). Luego, por lo tanto . Ahora tome 0 ≤ r ≤ n −1 y agregue d a ambos lados, obteniendo d ≤ d + r ≤ d + n −1 . Pero hemos visto que x = d + r , así que hemos terminado. □)
El módulo con desplazamiento a mod d n se implementa en Mathematica como [24] Mod[a, n, d]
.
Implementar otras definiciones de módulo mediante truncamiento
A pesar de la elegancia matemática de la división de piso de Kunth y la división euclidiana, generalmente es mucho más común encontrar un módulo basado en división truncado en los lenguajes de programación. Leijen proporciona los siguientes algoritmos para calcular las dos divisiones dada una división entera truncada: [6]
/ * Divmod Euclidiano y Floored, al estilo de ldiv () * / 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 ( largo numer , largo denom ) { / * El C99 y C ++ 11 idiomas definir tanto de éstos como truncar. * / Largo q = numer / denom ; largo r = numer % denom ; if ( r < 0 ) { if ( denom > 0 ) { q = q - 1 ; r = r + denom ; } más { q = q + 1 ; r = r - denom ; } } return ( ldiv_t ) {. quot = q , . rem = r }; }/ * División Floored * / inline ldiv_t ldivF ( largo numer , largo denom ) { largo q = numer / denom ; largo r = numer % denom ; si (( r > 0 && denom < 0 ) || ( r < 0 && denom > 0 )) { q = q - 1 ; r = r + denom ; } return ( ldiv_t ) {. quot = q , . rem = r }; }
Tenga en cuenta que para 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) y módulo (jerga) : muchos usos de la palabra módulo , todos los cuales surgieron de la introducción de Carl F. Gauss de la aritmética modular en 1801.
- Módulo (matemáticas) , uso general del término en matemáticas
- Exponenciación modular
- Girar (unidad)
Notas
- ^ Matemáticamente, estas dos opciones son solo dos del número infinito de opciones disponibles para la desigualdad satisfecha por un resto .
- ^ a b El orden del argumento se invierte, es decir,
α|ω
calcula, el resto al dividirω
entreα
. - ^ C99 y C ++ 11 definen el comportamiento de
%
ser truncado. [9] Los estándares anteriores dejan definida la implementación del comportamiento. [10] - ^ Tal como se implementó en ACUCOBOL, Micro Focus COBOL y posibles otros.
- ^ El divisor debe ser positivo, de lo contrario indefinido.
- ^ Como lo discutió Boute, las definiciones de ISO Pascal de
div
ymod
no obedecen a la identidad de división de D = d · ( 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 obtener ejemplos y excepciones, consulte la documentación de Perl sobre operadores multiplicativos. [19]
Referencias
- ^ "El glosario definitivo de jerga matemática superior: módulo" . Bóveda de matemáticas . 2019-08-01 . Consultado el 27 de agosto de 2020 .
- ^ Weisstein, Eric W. "Congruencia" . mathworld.wolfram.com . Consultado el 27 de agosto de 2020 .
- ^ Caldwell, Chris. "residuo" . Prime 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 .
- ^ a b Leijen, Daan (3 de diciembre de 2001). "División y módulo para informáticos" (PDF) . Consultado el 25 de diciembre de 2014 . Cite journal requiere
|journal=
( ayuda ) - ^ 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). "División más rápida y operación de módulo - el poder de dos" .
- ^ "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. sec. 5.6.4.
el operador binario% produce el resto de la división de la primera expresión por la segunda. .... Si ambos operandos son no negativos, el resto no es negativo; si no, el signo del resto está definido por la implementación
Cite journal requiere|journal=
( ayuda ) - ^ "ISO / IEC 9899: 1990: Lenguajes de programación - C". ISO , IEC . 1990. sec. 7.5.6.4.
La
marcador de franja de resaltado de sintaxis en lafmod
función devuelve el valorx - i * y
, para algún número enteroi
tal que, siy
es distinto de cero, el resultado tiene el mismo signox
y una magnitud menor que la magnitud dey
.|quote=
posición 5 ( ayuda );Cite journal requiere|journal=
( ayuda ) - ^ Operadores CoffeeScript
- ^ "Expresiones" . D Lenguaje de programación 2.0 . Marte digital . Consultado el 29 de julio de 2010 .
- ^ "Kernel - 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 .
- ^ "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 - The Netwide Assembler versión 2.15.05 .
- ^ Documentación de Perl
- ^ QuantumWriter. "Expresiones" . docs.microsoft.com . Consultado el 11 de julio de 2018 .
- ^ "F32 - Óxido" .
- ^ a b r6rs.org
- ^ "Lenguaje de comandos de Shell" . pubs.opengroup.org . Consultado el 5 de febrero de 2021 .
- ^ a b "Mod" . Centro de documentación de Wolfram Language & System . Wolfram Research . 2020 . Consultado el 8 de abril de 2020 .
enlaces externos
- Modulorama , animación de una representación cíclica de tablas de multiplicar (explicación en francés)