¿Cómo se implementan las estructuras matemáticas básicas como +, -, *, / en los lenguajes de programación?

[Vea la segunda parte de la respuesta para lo que probablemente quiso decir ..]

Busque el complemento de dos (y el sistema posicional [binario]) y la transferencia de ondas para ver cómo se realiza (por lo general) la suma / resta en el hardware. En realidad, es el mismo sistema que aprenden los niños, solo menos dígitos posibles, por lo tanto, números “más simples” pero más largos, por lo que en la práctica es más difícil / inhumano.

[Si su CPU tiene solo 1 bit (sí, ¡esos existen! Al menos uno …), entonces la “suma” es trivial para números de ese tamaño … por ejemplo, solo puertas lógicas. Los bits significan 0s y 1s, es decir, números binarios, siempre puede (para enteros …) convertir ay desde sus sistemas decimales habituales; se han utilizado otras formas, por ejemplo, computadora ternaria de Saturno soviético con tres dígitos posibles ..]

Podría construir n-bit a partir de 1-bit, si aún no lo ha hecho en hardware (en realidad puede incluso entonces … simplemente no es eficiente para realizar sus propias operaciones, que ya están en hardware) mediante el transporte de ondas …

Del mismo modo, puede desarrollar la multiplacción, mediante la adición repetida, o algoritmos más inteligentes (busque en la cabina). Mi primera computadora no tenía instrucciones MUL. Y mucho menos DIV o SQRT, etc.

También hay algoritmos de división. Mi segunda computadora no tenía instrucciones DIV, ahora las computadoras sí y MUL para enteros (las primeras computadoras implementadas solo para enteros, las instrucciones de soporte de punto flotante / “notación científica” se agregaron comúnmente más tarde, ahora están disponibles universalmente y punto flotante decimal en algunas CPU, simplemente no convencionales).

La raíz cuadrada, SQRT, ahora es común en las CPU, solo para coma flotante, ya que un entero solo no es demasiado útil. Para una raíz cuadrada de valor complejo, está construida a partir de un algoritmo, basado en tipos complejos, que tienen algunos idiomas, por ejemplo, Julia. El complejo se implementa mediante dos tipos de máquinas de punto flotante (de valor real), por ejemplo, no es un tipo nativo. Es un poco, solo en dos registros, pero no tiene instrucciones valiosas complejas. De hecho, estoy investigando cómo puedes hacer mejor las operaciones con coordenadas polares (parece raro hacerlo, debido a la adición, creo …).

Ahora veo, “interpretado por el compilador”, por lo que no estaba pensando cómo lo hace la CPU. Para ver cómo obtiene esas instrucciones, explicadas anteriormente, vea primero solo la ejecución (con los pasos ocultos) con los resultados, primero ejemplo a), para todos los pasos que se realizan detrás de escena, vea las macros que agregué para buscar en el compilador; todos los compiladores (o intérpretes) necesitan analizar , dándole b) la forma “bajada” (rara vez uso / miro eso), es decir, el árbol de sintaxis abstracta , sí, no es obvio que es un árbol como se muestra …, c) es generación de código para un CPU hipotético / virtual (aquí “LLVM”), d) código de ensamblaje (para x86, ya que estoy usando eso, por ejemplo ARM sería diferente, pero paso (s) antes del mismo, por qué a menudo use ese paso (a menudo también es más simple), pero el último paso es útil cuando estoy ajustando la velocidad máxima):

julia> 1 + 1

2

julia> @code_lowered 1 + 1

Plantilla LambdaInfo para + {T <: Unión {Int128, Int16, Int32, Int64, Int8, UInt128, UInt16, UInt32, UInt64, UInt8}} (x :: T, y :: T) en int.jl: 32

:(empezar

nada

return (Base.box) ($ (Expr (: static_parameter, 1)), (Base.add_int) ((Base.unbox) ($ (Expr (: static_parameter, 1)), x), (Base.unbox) ( $ (Expr (: parámetro_estático, 1)), y)))

fin)

julia> @code_llvm 1 + 1

defina i64 @ “jlsys _ + _ 44118” (i64, i64) # 0 {

parte superior:

% 2 = agregar i64% 1,% 0

ret i64% 2

}

julia> @code_native 1 + 1

.texto

Nombre de archivo: int.jl

pushq% rbp

movq% rsp,% rbp

Línea fuente: 32

leaq (% rdi,% rsi),% rax

popq% rbp

retq

nopw (% rax,% rax)

Tenga en cuenta lo que realmente está poniendo (en los registros de la CPU, los bits son solo para mostrarlo) y salir (sería la mitad de cadenas cortas si utilizo el lenguaje CPU / Julia de 32 bits):

julia> bits (1)

“0000000000000000000000000000000000000000000000000000000000000001”

julia> bits (2)

“0000000000000000000000000000000000000000000000000000000000000010”

En lenguajes como C que admiten estas operaciones solo en tipos de datos primitivos (como int / float), las operaciones se traducen directamente en instrucciones de la máquina. Por ejemplo, el conjunto de instrucciones x86 tiene una instrucción “agregar” entera que agrega dos enteros y almacena el resultado (consulte la Guía para el ensamblaje x86). También será similar con otras arquitecturas.

En el caso de lenguajes de nivel superior que admitan estas operaciones en tipos de datos no primitivos (por ejemplo, en Python, existe el tipo largo que tiene una precisión “ilimitada”, limitada solo por la memoria – 5. Tipos incorporados), el idioma El intérprete / compilador manejará las operaciones en números más grandes dividiéndolos según sea necesario y utilizando las capacidades limitadas de la CPU.

Editar: puede escribir un programa C simple con solo una declaración de suma y ver cómo se traduce en código de ensamblaje (algo que la CPU puede ejecutar directamente) como se muestra a continuación (test.c es su programa simple, el ensamblaje de salida estará en prueba. s)
$ gcc -S -o test.s test.c