Número y sus tipos en Julia

Julia es un lenguaje de programación de propósito general, dinámico y de alto nivel que se puede usar para escribir aplicaciones de software y es muy adecuado para el análisis de datos y la ciencia computacional. Los números son importantes en cualquier lenguaje de programación. Los números en Julia se clasifican en dos tipos: números enteros y números de coma flotante. Julia proporciona una amplia gama de tipos numéricos primitivos. Estos tipos de datos numéricos incorporados ayudan a Julia a aprovechar al máximo los recursos informáticos. Julia también proporciona soporte de software para aritmética de precisión arbitraria, que puede manejar operaciones numéricas que son difíciles de representar en representaciones de hardware nativas. Sin embargo, la compatibilidad con la aritmética de precisión arbitraria tiene el costo de un rendimiento más lento. Los números complejos y racionales se definen sobre tipos numéricos primitivos.

Los siguientes son tipos numéricos primitivos de Julia:

1. Entero
   

   Escribe	firmado	Número de bits	Rango
   Int8	Sí	8	-2^7 a 2^7 – 1
   UInt8	No	8	0 a 2^8-1
   int16	Sí	dieciséis	-2^15 a 2^15-1
   UInt16	No	dieciséis	0 a 2^16 – 1
   Int32	Sí	32	-2^31 a 2^31-1
   UInt32	No	32	0 a 2^32-1
   Int64	Sí	64	-2^63 a 2^63-1
   UInt64	No	64	0 a 2^64 – 1
   Int128	Sí	128	-2^127 a 2^127 – 1
   UInt128	No	128	0 a 2^128 – 1
   bool	N / A	8	falso (0) y verdadero (1)

2. Números de punto flotante
   

   Escribe	Precisión	Número de bits
   Flotador16	mitad	dieciséis
   Flotador32	único	32
   flotar64	doble	64

enteros

El tipo predeterminado para un literal entero depende de si el sistema es de 32 bits o de 64 bits. La variable Sys.WORD_SIZE indica si el sistema es de 32 bits o de 64 bits:

println(Sys.WORD_SIZE)
println(typeof(123))

Producción:

Sin embargo, los literales enteros más grandes que no se pueden representar con 32 bits se representan con 64 bits, independientemente del tipo de sistema.
Los enteros sin signo se representan con el prefijo 0x y los dígitos hexadecimales 0-9a-f o 0-9A-F. El tamaño del entero sin signo está determinado por el número de dígitos hexadecimales utilizados.

println(typeof(0x12))
println(typeof(0x123))
println(typeof(0x1234567))
println(typeof(0x123456789abcd))
println(typeof(0x1112223333444555566677788))

Producción:

Los literales binarios y octales también son compatibles con Julia.

println(typeof(0b10))
println(typeof(0o10))
println(0b10)
println(0o10)

Producción:

Valores mínimos y máximos de números enteros

println(typemin(Int8), ' ', typemax(Int8))
println(typemin(Int16), ' ', typemax(Int16))
println(typemin(Int32), ' ', typemax(Int32))
println(typemin(Int64), ' ', typemax(Int64))
println(typemin(Int128), ' ', typemax(Int128))

Producción:

Números de punto flotante

Los números de coma flotante se representan en un formato estándar. No existe un formato literal para Float32, pero podemos convertir valores a Float32 escribiendo una ‘f’ o un encasillado explícito.

println(typeof(1.0))
println(typeof(.5))
println(typeof(-1.23))
println(typeof(0.5f0))
println(2.5f-4)
println(typeof(2.5f-4))
println(typeof(Float32(-1.5)))

Producción:

punto flotante cero

Los números de coma flotante tienen un cero positivo y un cero negativo que son iguales entre sí pero tienen representaciones binarias diferentes.

julia> 0.0 == -0.0
true

julia> bitstring(0.0)
"0000000000000000000000000000000000000000000000000000000000000000"

julia> bitstring(-0.0)
"1000000000000000000000000000000000000000000000000000000000000000"

Valores especiales de punto flotante

Número complejo

La constante global ‘im’ se usa para representar el número complejo i donde i es la raíz cuadrada de -1.

println(typeof(1+2im))
  
# performing mathematical operations
  
println()
println((1 + 2im) + (2 + 3im))
println((5 + 5im) - (3 + 2im))
println((5 + 2im) * (3 + 2im))
println((1 + 2im) / (1 - 2im))
println(3(2 - 5im)^2)

Producción:

Número racional

Julia tiene números racionales para representar proporciones exactas de números enteros. Los números racionales se construyen usando el operador //.

println(typeof(6//9))
println(6//9)
println(-6//9)
println(-6//-9)
println(5//8 + 3//12)
println(6//5 - 10//13)
println(5//8 * 3//12)
println(6//5 / 10//3)

Producción: