Fundamentos de Julia

Es un lenguaje de programación Julia dinámica de alto nivel y alto rendimiento para computación científica. Proporciona un compilador sofisticado, ejecución paralela distribuida, precisión numérica y una extensa biblioteca de funciones matemáticas. Su rendimiento es superior en la mayoría de los casos que otros lenguajes de programación usados para el análisis de datos como Python, R o Matlab.

• Puedes consultar las pruebas de rendimiento

• Manual OFICIAL completo de Julia

• Think Julia: How to Think Like a Computer Scientist

• Data Science Tutorials in Julia

Julia fue lanzado originalmente en 2012 por Alan Edelman, Stefan Karpinski, Jeff Bezanson y Viral Shah. Es un lenguaje de programación de código abierto y gratuito. La elección de un lenguaje de programación siempre es subjetiva. Las siguientes características de Julia son decisivas:

• Julia se desarrolla como un lenguaje de programación de alto rendimiento.

• Julia utiliza el envío múltiple, lo que permite al programador elegir entre diferentes patrones de programación adaptados a la aplicación.

• Julia es un lenguaje escrito dinámicamente que se puede usar fácilmente de forma interactiva.

• Julia tiene una buena sintaxis de alto nivel que es fácil de aprender.

• Julia es un lenguaje de programación escrito opcionalmente cuyos tipos de datos (definidos por el usuario) hacen que el código sea más claro y robusto.

• Julia tiene una biblioteca estándar extendida y numerosos paquetes de terceros están disponibles.

Instalación

1. Instalar Anaconda con JupyterLab.

2. Descargar la correspondiente versión (current stable release) para su sistema operativo. Página de Descargas de Julia

3. Agregar a las variables de entorno la carpeta “Julia x.x.x:nbsphinx-math:bin” donde Julia ha sido Instalado, x.x.x es la versión que tenga instalada.

4. Abrir una terminal y escribir el comando julia. Esto inicia Juila y a continuación aparece la línea de comandos julia>

5. Para vincular Julia con Jupyter se requiere instalar el paquete IJulia, en la línea de comandos de Julia escribimos ], esto habilitará la línea de comandos para instalar paquetes pkg>. Entonces, en esta línea de comandos escribimos add IJulia y presionamos enter. (Este proceso que tarda entre 5 y 10 minutos, por favor sea paciente, el proceso ha finalizado cuando se muestra en consola Building IJulia y se presiona enter). Una vez finalizada la instalación, presionar ctrl+c para volver a la línea de comandos de Julia.

6. Para ejecutar un libro, ejecutar en la línea de comandos de Julia using IJulia la primera vez tarda al rededor de un minuto.

7. Finalmente, en la linea de comandos escriba jupyterlab() para ejecutar el cuaderno. La primera vez se pide install Jupyter via Conda, y/n? responder con y y presionar enter.

8. Una vez finalizada la instalación, se abre automáticamente el explorador con una ventana del JupyterLab. Dentro de este se pueden crear cuadernos directamente para Julia.

9. A cotinuación, seguiremos trabajando en Jupyter con Julia.

# verificamos la instalación
versioninfo()

Julia Version 1.5.3
Commit 788b2c77c1 (2020-11-09 13:37 UTC)
Platform Info:
  OS: Windows (x86_64-w64-mingw32)
  CPU: Intel(R) Core(TM) i5-8265U CPU @ 1.60GHz
  WORD_SIZE: 64
  LIBM: libopenlibm
  LLVM: libLLVM-9.0.1 (ORCJIT, skylake)

Tipos de Datos

Consultar Acá

Números Enteros y Reales

# Números Enteros
println(typeof(200000))

println("Número entero en notación Hexadecimal (Base 16) 0x22: $(0x22)")
println(typeof(0x22)) # de una vez se asigna el tipo 64 sin signo
println(typeof(34)) # de una vez se asigna el tipo 64

println("Número entero en notación Hexadecimal 0x222: $(0x222)")
println(typeof(0x222))
println(typeof(546))

aHex = string(2020, base = 16)
println("Número entero en notación Hexadecimal: $(aHex)")
suma = 0x7e4 + 1
println("Suma de Enteros: $(suma)")

#Recomendado https://www.binaryhexconverter.com/hex-to-decimal-converter

# Numeros reales o flotantes
println("Tipo Real")
println(typeof(3455.23))

Int64
Número entero en notación Hexadecimal (Base 16) 0x22: 34
UInt8
Int64
Número entero en notación Hexadecimal 0x222: 546
UInt16
Int64
Número entero en notación Hexadecimal: 7e4
Suma de Enteros: 2021
Tipo Real
Float64

Números Complejos y Racionales

complejo = 30 + 3im
println("Soy complejo $(complejo)")
complejo = complejo + 40 + 2im
println("Soy complejo $(complejo)")
println(typeof(complejo))

racional = 9//12
println("Soy racional $(racional)")
println(typeof(racional))

real = 9/12
println("Soy real $(real)")
println(typeof(real))

Soy complejo 30 + 3im
Soy complejo 70 + 5im
Complex{Int64}
Soy racional 3//4
Rational{Int64}
Soy real 0.75
Float64

Tipos de datos personalizados: Estructuras

Aquí para más info

struct Persona
    nombre
    direccion::String
    edad::Int
    imc::Float64
end

estudiante = Persona("Bartolomeo","Av. Siempre Viva 2343", 8, 20.1223)
println(estudiante)
println("Tipo de dato de la variable: " * string(typeof(estudiante)))
println("Tipo de dato de la variable: $(string(typeof(estudiante)))")
println("Direccion del estudiante: " * estudiante.direccion)
println("Atributos de la Persona: " * string(fieldnames(Persona)))
println("Atributos del estudiante: " * string(fieldnames(typeof(estudiante))))

Persona("Bartolomeo", "Av. Siempre Viva 2343", 8, 20.1223)
Tipo de dato de la variable: Persona
Tipo de dato de la variable: Persona
Direccion del estudiante: Av. Siempre Viva 2343
Atributos de la Persona: (:nombre, :direccion, :edad, :imc)
Atributos del estudiante: (:nombre, :direccion, :edad, :imc)

struct Paciente
    nombre::String
    remitido::Bool
    edad::Float64
    cantidadHijos::Int
end

function describir(p::Paciente)
    println("Nombre: ", p.nombre, " Es Remitido: ", p.remitido)
    println("Edad: ", p.edad, " Cantidad Hijos: ", p.cantidadHijos)
end


nata = Paciente("Natalia",0,26,0)

describir(nata)

Nombre: Natalia Es Remitido: false
Edad: 26.0 Cantidad Hijos: 0

Tipos de datos personalizados: Tipos Abstractos

abstract type Felino end

mutable struct Jaguar <: Felino
end

mutable struct Leon <: Felino end
mutable struct Pantera <: Felino end

mutable struct Gato <: Felino
    zona
end

subtypes(Felino)

4-element Array{Any,1}:
 Gato
 Jaguar
 Leon
 Pantera

tom = Gato("Dibujos Animados")
println(typeof(tom))
println(tom.zona)
println(supertype(Gato))
println(supertype(typeof(tom)))

Gato
Dibujos Animados
Felino
Felino

Enteros y Reales con Precisión Arbitraria

enteroGrande = BigInt(5052785737795758503064406447721934417290878968063369478337)
println(typeof(enteroGrande))

flotanteGrande = BigFloat(3.14159265358979323846264338327950288419716939937510582097)
println(typeof(flotanteGrande))

BigInt
BigFloat

Cálculos relativamente grandes

Consideraciones Básicas

Lectura recomendada las potencias de 2.

# Deseamos calcular 2 ^ 256
println("2 elevado a la 256 es: $(2 ^ 256)")

#Lo anterior nos entrega un resultado muy sospechoso
# veamos el tipo de datos de 2 y 256
println(typeof(2))
println(typeof(256))

#Son enteros de 64 bits, esto significa que solo permiten
# representar números hasta 2 ^ 64 bits
println("2 elevado a la 64 es: $(2 ^ 64)")

# La operación continúa dando como resultado 0, dado que
# el cero ocupa un bit y el signo otro bit,
# lo máximo es hasta 2 ^ (64 - 2)
println("2 elevado a la 62 es: $(2 ^ 62)")

#A partir de 64 bits se requiere usar el tipo de dato BigInt
println("2 elevado a la 64 es: $(BigInt(2) ^ 64)")

# Una precisión de 32bits permite tener números de 10 digitos
# Precisión de 10 Dígitos
println("La cantidad de dígitos que se obtienen con 32 bits es: $(length(string(2^32)))")

#A partir de 64 bits se requiere usar el tipo de dato BigInt
cantidadDigitos = length(string(BigInt(2)^64))
println("La cantidad de dígitos que se obtienen con 64 bits es: $(cantidadDigitos)")

cantidadDigitos = length(string(BigInt(2)^256))
println("La cantidad de dígitos que se obtienen con 256 bits es: $(cantidadDigitos)")

cantidadDigitos = length(string(BigInt(2)^1024))
println("La cantidad de dígitos que se obtienen con 1024 bits es: $(cantidadDigitos)")

2 elevado a la 256 es: 0
Int64
Int64
2 elevado a la 64 es: 0
2 elevado a la 62 es: 4611686018427387904
2 elevado a la 64 es: 18446744073709551616
La cantidad de dígitos que se obtienen con 32 bits es: 10
La cantidad de dígitos que se obtienen con 64 bits es: 20
La cantidad de dígitos que se obtienen con 256 bits es: 78
La cantidad de dígitos que se obtienen con 1024 bits es: 309

Cambiando la precisión

# π con una precisión de 256 bits
println("π con una precisión de 256 bits: $(BigFloat(0) + pi)")

# Pi con una precisión de 1024 bits, es decir, 309 cifras decimales
setprecision(BigFloat, 1024) do
    println("π con una precisión de 1024 bits: $(BigFloat(pi))")
end

π con una precisión de 256 bits: 3.141592653589793238462643383279502884197169399375105820974944592307816406286198
π con una precisión de 1024 bits: 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481117450284102701938521105559644622948954930381964428810975665933446128475648233786783165271201909145648566923460348610454326648213393607260249141273724586997