my_notes();

Descarga Julia, puede que te sientas comodo con la versión portable.

Para Windows no olvides agregar y asociar a la variable de entorno la ubicación del ejecutable julia.exe:

Propiedades del sistema / Opciones avanzadas / Variables de entorno / Variables del sistema / Seleccionar Path / Editar / Nuevo / <ubicación>/<julia.exe>

Para verificar que todo sea correcto, abrir una Terminal e ingresar julia --version la salida debería indicar la versión de Julia instalada.

En otro caso, tal vez necesites: sudo apt install julia previo sudo apt-get update && sudo apt-get upgrade Leer más

Julia puede interoperar con código en lenguajes como Python, C, R e incluso MATLAB.

Para agregar Julia en Jupyter:

Inicia Jupyter (Anaconda)
New / Terminal
En el entorno de Julia ingresa: using Pkg
En el entorno de Julia ahora ingresa: Pkg.add("IJulia") (espera a que termine la instalación)
Regresa a Jupyter y da clic en New si Julia no aparece listado entonces refresca la página (F5)

Siempre antes de agregar un paquete en Julia (Pkg), debe indicar el uso de este using Pkg.
Ahora ya puede agregar paquetes Pkg.add("<nombre_paquete>").

También lo puede hacer desde la notebook.

REPL - Lectura, Evaluación e Impresión de Bucle. Julia proporciona un entorno interactivo donde puedes probar pequeños fragmentos de código.

Instalado el lenguaje ingrese a su entorno desde la terminal con julia

El prompt ha cambiado a julia> ingrese una suma, resta o multiplicación o bien print("Hola mundo") al finalizar [enter].

Para conocer un resultado anterior ingrese ans

Para soliciar ayuda dentro del entorno REPL, ingrese el caracter de interrogación ?

De manera automática el prompt cambia a help?> y el entorno espera que ingrese su consulta, por ejemplo Timer

Es posible interactuar con el shell del sistema sin salir del entorno REPL

Para ello ingrese el comando de shell ;

De manera automática el prompt cambia a shell> y el entorno espera que ingrese un comando, por ejemplo pwd

Para salir del entorno de REPL solo ingrese exit()

Para comentar una línea use el signo #
El carácter de signo de número (almohadilla, hash o pound) comienza comentarios de una sola línea

#= Cuando va seguido de un signo igual, comienza un comentario de varias líneas

=# Finalizar un comentario de varias líneas precediendo inmediatamente al signo numérico con un signo igual

¿Cómo definir funciones en Julia?

Para invocar la función solo escriba: nombre_fx()

Practicamente dentro de los parentesis se define el argumento seguido de :: y la definición del tipo de dato:

Las funciones en Julia siempre regresan el resultado de la última expresión por defecto.
Por lo que no sería necesario tecnicamente indicarlo expresamente con return

Las funciones pueden tener argumentos con un valor por defecto.
Entonces se puede invocar la función sin indicar el valor de un argumento por defecto.

Argumentos como keywords, al invocar la función deberá usar el keyword del argumento, sin importar, para este argumento el orden en el cual fue definido en la función.
Para definir el argumento como keyword debe ser precedido por un ;

Funciones inline o Anonymous Functions

Puede escribir funciones de la siguiente manera.

Funciones con un número no definido de argumentos

Es posible definir que la función puede recibir ninguno o n argumentos, para ello como argumento escriba args...

Antes de continuar algunas cosas que debes tomar en cuenta en Julia:

El espacio en blanco y la sangría no son importantes como en Python, que usa para separar bloques funcionales entre sí
Los índices están basados en uno y no admite índices negativos
No hay equivalente a la palabra clave pass de Python en Julia.
Python usa esta palabra clave para denotar una declaración vacía, pero Julia no tiene nada parecido.
No hay sintaxis de continuación de línea en Julia como puede hacer con una barra invertida en Python. Puede forzar que una expresión continúe en la siguiente línea colocándola entre paréntesis
El operador de porcentaje en Julia es el operador restante, mientras que en Python es el operador de módulo. Y Julia tiene una función separada para Modulus.
El operador de módulo en Julia es una función llamada mod. No es el operador del doble porcentaje como en R
Las comillas simples encierran caracteres, no cadenas como en R.
Las cadenas también se pueden crear en Julia usando la notación de comillas triples.
Los operadores de flecha en R no funcionan como operadores de asignación en Julia.
Valores booleanos, verdaderos y falsos, Julia proporciona valores de palabras clave específicos.
No trata el cero y uno como booleano falso y verdadero de la forma en que lo hace R.
Las llamadas a funciones, Julia no copia los valores de los argumentos
Las matrices de Julia están indexadas con corchetes, no entre paréntesis.
Julia tampoco copia matrices cuando las asigna a otra variable
Para números imaginarios donde MATLAB usa I o j, Julia usa el designador IM
No puede agregarles campos en tiempo de ejecución
En Julia, cada módulo tiene su propio espacio de nombres global y alcance para su contenido

Dynamically typed language

No es necesario declarar el tipo de variable antes de usarla.
Es posible asignar un valor directamente a una variable y Julia inferirá qué tipo debería ser esa variable.

Julia tiene 5 tipos de datos básicos.

Caracteres individuales (char deben estar entre comillas simples. )
Cadenas de caracteres (strings deben estar entre comillas dobles. )
Booleanos
Enteros (Int8, Int16, Int32, UInt16, etc. )
Punto flotante

Para definir una constante definala con el uso de la palabra reservada const.
No puede redefinir una constante para que sea de un tipo diferente.

El tipo predeterminado para un literal entera depende de si el sistema de destino tiene una arquitectura de 32 bits o una arquitectura de 64 bits, puede verificar con typeof(1).

La variable interna de Julia Sys.WORD_SIZE indica si el sistema de destino es de 32 bits o de 64 bits.

La división de enteros tiene dos casos excepcionales:

Dividir por cero
Dividir el número negativo más bajo entre -1.

Ambos casos arrojan un DivideError.

Las funciones resto y módulo (rem y mod) arrojan un DivideError cuando su segundo argumento es cero.

c = 'a'
str = "a"
if(c == str)
	println("igual")
else
	println("diferente")
end
	
n = 10.24
println(n)
n = (2 + 2) / 4
println(n)
n = '$'
println(n)
n = "Hola mundo"
println(n)
n = false

if(n == 0)
	println("falso")
else
	println("verdadero")
end

const PI = 3.1416
println(PI)

s = "3"::String
println(typeof(s))
b = false::Bool
println(typeof(b))
ch = '3'::Char
println(typeof(ch))

n16 = Int16(127)
println("n16: ", typeof(n16))
n32 = Int32(32768)
println("n32: ", typeof(n32))
n64 = Int64(2147483648)
println("n64: ", typeof(n64))

nInferir = Int(12345678)
println("Julia infiere: ", typeof(nInferir))

u16 = UInt16(1)
println(typeof(u16))

f16 = Float16(127.9)
println("f16: ", typeof(f16))
f32 = Float32(32768.9)
println("f32: ", typeof(f32))
f64 = Float64(2147483648.9)
println("f64: ", typeof(f64))

for T in [Int8,Int16,Int32,Int64,Int128,UInt8,UInt16,UInt32,UInt64,UInt128]
	println("$(lpad(T,7)): [$(typemin(T)),$(typemax(T))]")
end

println("Arquitectura de este sistema es: ", Sys.WORD_SIZE)
println(typeof(1), " Bits")

println("1.0 / 1.0 = ", 1.0 / 1.0)
println("1.0 / Inf = ", 1.0 / Inf)
println("0.0 / 0.0 = ", 0.0 / 0.0)

try
	println("mod(10, 0) = ", mod(10, 0))
catch
	@warn "DivideError: integer division error"
end

Char, un solo caracter se define por comillas simples
String, un conjunto de caracteres se define por comillas dobles
Un string que ocupa varias líneas puede definirse con 3 comillas dobles

Para conocer la longitud de un string se una la función length(string)
El índice de un string inicia en 1
La última posición de un string la determina la palabra reservada end
Para concatenar strings se usa el símbolo *
Julia permite la interpolación de literales o expresiones en expresiones entre comillas. La interpolación se indica con un prefijo $.

Las cadenas pueden contener caracteres Unicode y otras letras no estándar, que ocupan más de un byte.

El método findnext() encuentra la siguiente aparición de patrón en el string comenzando en la posición de inicio.
El patrón puede ser una cadena o una expresión regular, en cuyo caso la cadena debe ser de tipo String.

La función occursin() determina si el primer argumento es una subcadena del segundo. Si needle > es una expresión regular, comprueba si haystack contiene una coincidencia.

La función lpad() Stringify s rellena la cadena resultante a la izquierda con p para que tenga n caracteres de longitud.
Si s ya tiene n caracteres, se devuelve una cadena igual. Rellenar con espacios por defecto.

La función join() une un Array de cadenas en una sola cadena, insertando el delimitador dado (si lo hay) entre cadenas adyacentes.
Si se da el último, se utilizará en lugar de delimitar entre las dos últimas cadenas.

Las funciones que se utilizan con frecuencia se denominan integradas, veamos algunos ejemplos:

También es posible solicitar al usuario ingresar un valor y leer esta entrada.

Así como usar estas funciones para validar valores.

Para trabajar un conjunto de datos lo podemos hacer a través de| una matriz, que es una lista de elementos de datos.

Para afectar el valor de todos los elementos a la vez contenidos en un arreglo se puede usar la vectorization operator u operador de punto .

Ejemplo, multiplicar por 2 todos los elementos del arreglo y multiplicar por 3 usando una función personalizada.

Casting es la capacidad de convertir un tipo de dato a otro.

Practicamente es hacer el cast del tipo de dato al valor a convertir.

parse() convierte un string como un número.

Son declaraciones que evalúan una expresión lógica y luego toman acciones basadas en el resultado

if - sino (condición simple)

Toma una condición y ejecuta algún código si la condición se evalúa como verdadera.

if - sino si (condición múltiple)

Operador ternario

Forma corta para condicionales: "si a, evalúa b de lo contrario evalúa c".
Tenga cuidado con los espacios entre ? y :

for

Un rango se define como el valor inicial seguido de dos puntos y el valor final

while

Ciclo que se ejecuta mientras una expresión lógica en particular se evalúa como verdadera.

enumerate(colección de datos)

continue

No ejecutar la iteración o saltar a la siguiente iteración, dado una condición en particular que se cumple.

break

Detener la ejecución del ciclo, después de que se cumpla una condición

Manejo de excepciones, es decir, responder de manera asertiva cuando el código podría generar un error y tal vez evitar que el programa colapse, en el mejor de los casos que continue.

Para ello el código que quiere controlar deberá estar contenido en un bloque try - catch

Dentro del conjunto de tipos de datos, tenemos una estructura para trabajar con colecciones conocida como Array.
Un Array es una colección ordenada de elementos.

Para crear una Array defina el nombre de este, seguido de un signo = y a continuación entre corchetes y separados por una coma , cada elemento.

La colección de valores contenidos en el Array deben ser de un mismo tipo, por lo que se podría indicar esto en la definición, sin embargo en caso de no describir el tipo, entonces Julia de manera dinámica o por inferencia podría determinar su tipo.

Los índices de los arreglos en Julia inician en cero.

Para conocer el número de elementos que contiene el arreglo use la función length()

Para acceder al valor de un elemento en el arreglo, escriba el nombre del arreglo seguido de corchetes y dentro de estos, el índice del elemento del cual quiere conocer su valor arreglo[índice]
Puede hacer uso de la palabra reservada end para conocer el último elemento de un arreglo.

Es posible que el contenido del Array tenga elementos de diferente tipo de datos, en este caso el tipo de datos del Array es Any

Al aplicar la función typeof() a un Array regresa Array{Any,1}, donde el segunto valor indica el número de dimensiones que tiene.

push!() esta función inserta uno o más elementos en la colección. Si la colección es un contenedor ordenado, los elementos se insertan al final (en el orden indicado).

Para poblar Arrays puede hacer uso de funciones como fill(), zeros(), ones().
Realmente estas funciones crean un Array>. En el caso de zeros() con el tipo de elemento T, de todos los ceros con el tamaño especificado por dims.

sort() función que devuelve una copia ordenada de v dejando v sin modificar.
Por defecto ordena de manera ascendente.
Es una variante de sort!()

La función join() une una Array de cadenas en una sola cadena, insertando el delimitador dado (si lo hay) entre cadenas adyacentes.

vChr = ['$', '#', '@']
println("Tipo de datos contenidos: ", typeof(vChr), " ¿Cuantos? ", length(vChr))
println("Primer elemento: ", vChr[1])
vNum = [0,10,200,3000]
println("Tipo de datos contenidos: ", typeof(vNum), " ¿Cuantos? ", length(vNum))
println("Último elemento: ", vNum[end])
vAny = ["El valor de PI", ':', 3.141592, 2020, false]
println("Tipo de datos contenidos: ", typeof(vAny), " ¿Cuantos? ", length(vAny))
vStr = String[]
println("Tipo de datos contenidos: ", typeof(vStr), " ¿Cuantos? ", length(vStr))
push!(vStr, "Donald", "John", "Trump", "Joseph", "Robinette", "Biden")
println("Tipo de datos contenidos: ", typeof(vStr), " ¿Cuantos? ", length(vStr))
println(vStr)
vZeros = zeros(3)
println(vZeros)
vOnes = ones(5)
println(vOnes)
valor = "*"
elementos = 5
v = fill(valor,elementos)
println(v)
v = sort(vStr)
println(v)
v = sort(vStr, rev = true) # orden desc
println(v)
sort!(v)
println(v)
j = join([10,20,30,40])
println(j)
j = join([10,20,30,40], "-")
println(j)
println(join(vStr, "."))

Julia tiene una estructura de datos incorporada llamada tupla que está estrechamente relacionada con los argumentos de la función y los valores de retorno.
Una tupla es un contenedor de longitud fija que puede contener cualquier valor, pero no se puede modificar (es inmutable).
Las tuplas se construyen con comas y paréntesis, y se puede acceder a ellas mediante la indexación como la sintaxis usada en los arreglos.
No se pueden cambiar una vez creados.
Las tuplas también inician con el índice cero
Es posible usar rangos para conocer los elementos de la tupla.
El operador o la función in() pueden ser utiles para determinar si un elemento está en la colección dada, en el sentido de que es igual (==) a uno de los valores generados al iterar sobre la colección, devolviendo un valor bool.

Las tuplas también pueden tener dimensiones.

Los elementos de las tuplas pueden ser asociados a nombres.

Colección de elementos que se pueden modificar, al igual que los Arrays.
Los valores de los elementos en la colección no se pueden repetir y no tienen orden.
Un Set no se puede acceder a mediante la indexación set[index].
Un Set es entonces un conjunto de los valores generados por el objeto iterable dado, o un conjunto vacío.
Para definir el tipo de dato de un Set este debe estar encerrado entre llaves {<dataType>}
Al traterse de conjuntos se pueden hacer con estos operaciones como intersección, unión y diferencia (intersect, union, setdiff).

const PI = 3.1416
c = '@'
s = "Hola mundo"
i = 2020
a = [5,"cadena", '#', true]
#
s = Set()
println(s)
push!(s, c,s,i,a)
println(s)
n = Set([1,2,3,1,2,3,1,2,3,4])
#No se pueden repetir valores en la colección
println(n)
try
	push!(n, c)
	println(n)        
catch
	@warn "ArgumentError: al inferir el tipo de dato de un conjunto no puede contener valores de otro tipo de dato distinto"
end
str = Set{String}()
push!(str, "Lorem", "ipsum", "dolor", "sit", "amet")
println(str) 
println("El conjunto tiene la palabra: dolor? ", "dolor" in str ? "si" : "no") 
try
	println(str[1]) 
catch
	@warn "MethodError: no se puede acceder a mediante la indexación"
end

pares  = Set([2,4,6,8,10])
primos = Set([1,3,5,7, 9])
otros  = Set([1,2,3,4, 5])

println("pares  y otros  tienen en común: ", intersect(pares,otros))
println("primos y otros  tienen en común: ", intersect(primos,otros))
println("pares  y primos tienen en común: ", intersect(pares,primos))
println("La diferencia entre pares  y primos es: ", setdiff(pares,primos))
println("La diferencia entre primos y pares  es: ", setdiff(primos,pares))
println("La unión de pares  y otros es: "  , union(pares, primos))

Dict{K, V}() construye una tabla hash con claves de tipo K y valores de tipo V (donde K es Key y V es Valor).
Un diccionario es una estructura de datos que asigna una clave única a un valor dado.
La siguiente sintaxis usa el constructor para crear un Dict.
Es similar a la asociación vista en las Tuplas, esta asociación se conoce como mapeo.

Otra manera de crear un diccionario, teniendo en cuenta que esta compuesto por los pares clave y valor, puede definir el tipo de dato correspondiente para cada uno.

Para acceder a los valores contenidos en el diccionario los puede hacer por clave, colocando entre corchetes el identificador de la clave [clave]

Para agregar un elemento al diccionario solamente debe definirlo

haskey() determina si una colección tiene una asignación para una clave determinada.

delete!() elimina la asignación para la clave dada en una colección, si la hubiera, y devuelva la colección.

keys() para un iterador o colección que tiene claves y valores (por ejemplo, matrices y diccionarios), devuelve un iterador sobre las claves.

values() para un iterador o colección que tiene claves y valores, devuelve un iterador sobre los valores.
Esta función simplemente devuelve su argumento por defecto, ya que los elementos de un iterador general normalmente se consideran sus "valores".

const PI = 3.1416
c = '@'
s = "Hola mundo"
i = 2020
a = [5,"cadena", '#', true]
nombre = "Albert Einstein"
profesion = "Físico"
origen = "Judío"
dia = 14
mes = "Marzo"
year = 1879
casado = true
#Constructor
d = Dict("name" => nombre, "day" => dia, "maritalStatus" => casado)
println(d)
#Clave numérica y valor de tipo string
dIS = Dict{Int,String}()
dIS[1] = nombre
dIS[2] = profesion
dIS[3] = s
dIS[4] = origen
dIS[5] = mes
println(dIS)
#Acceder mediante la Clave
println(dIS[1])
println(dIS[3])
println(dIS[5])
#Agregar un elemento al diccionario
dIS[100] = "cien"
println(dIS[100])
#¿La clave tiene un valor asignado?
println(haskey(dIS, 50) ? "Si" : "No")
println(haskey(dIS, 100) ? "Si" : "No")
#Eliminar el valor mapeado a la clave
delete!(dIS, 100)
println(haskey(dIS, 50) ? "Si" : "No")
println(haskey(dIS, 100) ? "Si" : "No")
println("Claves:  ", keys(dIS))
println("Valores: ", values(dIS))
#Iterar el diccionario
function mostrar(dic)
	for (k,v) in dic
		println("La clave: ", k, ", tiene asignado el valor: ", v)
	end
end
mostrar(dIS)
mostrar(d)

La generación de números aleatorios en Julia usa la biblioteca Mersenne Twister a través de objetos MersenneTwister.

Módulo Random.Random Soporte para generar números aleatorios.
Proporciona rand, randn, AbstractRNG, MersenneTwister y RandomDevice.

Para hacer uso de este módulo utilice la sentencia using.

La función random() elije un elemento aleatorio o un Array de elementos aleatorios del conjunto de valores especificado por S, donde S puede ser:

Una colección indexable ( por ejemplo, 1: 9 o ('x', "y",: z) )
Un objeto AbstractDict o AbstractSet
Una cadena (considerada como una colección de caracteres) o
Un tipo: el conjunto de valores para elegir es equivalente a typemin (S): typemax (S) para enteros (esto no es aplicable a BigInt), a [0, 1) [0,1) para números de coma flotante y a [0, 1) + i [0, 1) [0,1) + i [0,1) para números de coma flotante complejos;

S toma el valor predeterminado Float64. Cuando solo se pasa un argumento además del rng opcional y es una tupla, se interpreta como una colección de valores (S) y no como atenuaciones.

La función randstring() crea una cadena aleatoria de longitud len = 8, que consta de caracteres de chars, cuyo valor predeterminado es el conjunto de letras mayúsculas y minúsculas y los dígitos 0-9.
El argumento opcional rng especifica un generador de números aleatorios

La función shuffle!() permuta aleatoriamente v en el lugar, proporcionando opcionalmente el generador de números aleatorios rng.

La función seed!() reinicia el generador de números aleatorios: rng dará una secuencia reproducible de números si y solo si se proporciona una semilla.
Algunos RNG no aceptan una semilla, como RandomDevice.
Después de la llamada a seed!(), rng es equivalente a un objeto recién creado inicializado con la misma semilla.
Si no se especifica rng, el valor predeterminado es sembrar el estado del generador local de subprocesos compartido.

Funciones y características para trabajar con el sistema de archivos, puede crear y eliminar archivos, leer y escribir datos y trabajar con directorios.

La función pwd() obtiene el directorio de trabajo actual.

La función readdir() devuelve los nombres en el directorio dir> o el directorio de trabajo actual si no se dan.

La función open() abre un archivo en un modo especificado por cinco argumentos de palabras clave booleanas:

read lectura - !write
write escritura - truncate | append
create crear si no existe - !read & write | truncate | append
truncate truncar a tamaño cero - !read & write
append buscar al final - false

El valor predeterminado cuando no se pasan palabras clave es abrir archivos solo para lectura. Devuelve una secuencia para acceder al archivo abierto.
El argumento de la palabra clave lock controla si las operaciones se bloquearán para un acceso seguro de múltiples subprocesos.

La función close() Cierre un flujo de E / S. Primero realiza un flush.

La función write() escribe la representación binaria canónica de un valor en el stream o archivo de E/S dado. Devuelve el número de bytes escritos en la secuencia.

La función read() lee un valor único de tipo T de io, en representación binaria canónica.

La función mv() mueve el archivo, enlace o directorio de src (origen) a dst (destino). force = true primero eliminará un dst existente.
Regresa dst.

La función rm() elimina el archivo, enlace o directorio vacío en la ruta indicada.
Si se pasa force = true, una ruta no existente no se trata como error.
Si se pasa recursive = true y la ruta es un directorio, todos los contenidos se eliminan de forma recursiva.

using Random
println(pwd())      #Ubicación actual
println(readdir())  #Listar contenido del directorio
archivo = "lorem.txt"
#Escribir (nuevo):
permiso = "w"
stream = open(archivo, permiso)                #Abrir archivo para escritura
#Reemplaza todo el contenido del archivo por el nuevo contenido
#y si el archivo no existe lo crea:
write(stream, "Hola mundo\t" * string(rand()))   #Sobre escribe el archivo
close(stream)                                  #Cerrar archivo
#Leer:
permiso = "r"
stream = open(archivo, permiso)                #Abrir archivo para lectura
println("El archivo contiene:\n", read(stream, String))
close(stream)                                  #Cerrar archivo
#Agregar:
permiso = "a"
stream = open(archivo, permiso)                #Abrir archivo para agregar contenido
write(stream, "\nHello world\t" * string(rand()))  #Agrega contenido al final del archivo
close(stream)                                  #Cerrar archivo
#Leer:
permiso = "r"
stream = open(archivo, permiso)                #Abrir archivo para lectura
println("El archivo ahora contiene:\n", read(stream, String))
close(stream)                                  #Cerrar archivo
#Renombrar: 
nuevo = "nuevo.txt"
mv(archivo, nuevo, force=true)  #renombra el archivo
println("Se ha renombrado el archivo: ", archivo)
#Eliminar:
rm(nuevo)           #elimina el archivo
println("Se ha eliminado el archivo: ", nuevo)

El módulo Dates (using Dates) proporciona dos tipos para trabajar con fechas: Date y DateTime, que representan la precisión del día y milisegundos, respectivamente; ambos son subtipos del TimeType abstracto.

La motivación para los distintos tipos es simple: algunas operaciones son mucho más simples, tanto en términos de código como de razonamiento mental, cuando no es necesario abordar las complejidades de mayor precisión.

Por ejemplo, dado que el tipo de fecha solo se resuelve con la precisión de una sola fecha (es decir, sin horas, minutos o segundos), las consideraciones normales para las zonas horarias, el horario de verano/verano y los segundos intercalares son innecesarios y se evitan.

DateFormat Type construye un objeto de formato de fecha que pueda usarse para analizar cadenas de fecha o formatear un objeto de fecha como una cadena.
Los códigos de caracteres se pueden utilizar para construir la cadena de formato: y, Y, m, u, U, d, H, etc.

using Dates
a = 2020
mes = 6
dia = 28
d1 = Date(a, mes, dia)
dt = DateTime(a-1, mes-1, dia-1)
println("Date:\t\t", d1)
println("DateTime:\t", dt)
#Con formato
d2 = Date("01-03-2020", "d-m-y")
println("Date:\t\t", d2)
#Operaciones con fechas
println(d1, d1 < d1 ? " d1 es menor que d2 " : " d2 es mayor que d1 ", d2)
println("La diferencia entre la fecha menor y la mayor es de: ", d1 - d2)
println("La diferencia entre la fecha mayor y la menor es de: ", d2 - d1)
dt2 = DateTime(a+1, mes+1, dia+1)
println(dt2, dt2 > dt ? " dt2 es mayor que dt1 " : " dt2 es menor que dt ", dt)
println("La diferencia entre la fecha mayor y la menor es de: ", dt2 - dt)
#Funciones
ahora = now()
println("Ahora:\t",     ahora)
println("Segundo:",     Dates.second(ahora))
println("Minuto:\t",    Dates.minute(ahora))
println("Hora:\t",      Dates.hour(ahora))
println("Día:\t",       Dates.day(ahora))
println("Semana\t",     Dates.week(ahora))
println("Mes:\t",       Dates.month(ahora))
println("Año:\t",       Dates.year(ahora))
println("Año:\t",       Dates.isleapyear(ahora))#Bisiesto.
println("Día:\t",       Dates.dayname(ahora))
println("Día de la semana:",     Dates.dayofweek(ahora))
println("Primer día de la semana:",       Dates.firstdayofweek(ahora))
println("Último día del mes:\t",       Dates.lastdayofmonth(ahora))

Por defecto son inmutables, lo que significa que no puede cambiar el valor de los campos una vez que los haya asignado.

Especificada como un nombre y un conjunto de campos.
Como buena práctica el nombre de struct inicia con mayúscula.

Al definir la estructura también puede defirse su tipo de dato y ser accedidos mediante la notación de punto.

Para definir una struct como mutable, se debe anteponer la palabra reservada mutable

La función isa(x, type) determina si x es del tipo dado.

La función sort() es una variante de sort! que devuelve una copia ordenada de V dejando V sin modificar.

La función issorted() prueba si un vector está ordenado.

Index

Julia

References