PRIMEROS PASOS.¶

Introducción¶

Como aspecto para poder mostrar los resultados en el notebook se va a empezar explicando la forma de mostrar mensajes en pantalla con el comando println()

In [ ]:

println("Hello Julia!")

Los comentarios de una sola linea empiezan con #, mientras que los multilinea empiezan con #= y terminan con =#

In [31]:

println("Este si")
# println("Este no")
#=
println("Mucho menos")
println("estos dos")
=#

Este si

1. Variables¶

Como tal las variables se refieren a un nombre asociado a un valor¶

No deben ser tipadas por lo que no deben ser asignadas antes de asignarlas

In [1]:

some_var = 5
x = "Hello Julia"
X = 4.914
esta!esUna_cadena = "En realidad si lo es"
println(some_var)
println(x)
println(X)
println(esta!esUna_cadena)

5
Hello Julia
4.914
En realidad si lo es

Sin embargo intentar acceder a una variable que aun no ha sido creada, genera error.¶

In [2]:

try
    som_other_var
catch e
    println(e)
end

UndefVarError(:som_other_var)

Además Julia permite asignar nombres "unicode" a las variables y sobreescribir el valores de las constantes y de funciones.¶

Para poder asignar nombres de esta manera es necesario escrbir el simbolo de LaTeX seguido de la tecla tab.

In [3]:

δ = 4.5
println(δ) 
println(pi)
pi = "Ya no es un numero"
println(pi)

4.5
π = 3.1415926535897...
Ya no es un numero

WARNING: imported binding for pi overwritten in module Main

2. Tipos numéricos¶

Enteros¶

In [4]:

WORD_SIZE

Out[4]:

Float¶

In [5]:

g = 1.0
m = 4.
e = .5
G = 1e10
M = 2.5e-4
E = -.4e-10
println(g)
println(m)
println(e)
println(G)
println(M)
println(E)

1.0
4.0
0.5
1.0e10
0.00025
-4.0e-11

In [6]:

println(typeof(WORD_SIZE))
println(typeof(g))
println(typeof(E))

Int64
Float64
Float64

In [7]:

println(1/Inf)
println(1/0)
println(0/0)

0.0
Inf
NaN

Complejos¶

In [9]:

println(sqrt(complex(-4)))
println((1+2im)*(-3+2im))

0.0 + 2.0im
-7 - 4im

Racionales¶

In [10]:

println(2//3)
println(6//9)
println(-4//8)
println(-4//-12)
println(den(2//3))
println(num(2//3))

2//3
2//3
-1//2
1//3
3
2

3.Operadores¶

Operadores Aritméticos¶

In [11]:

println(1+2+3)
println(1-2)
println(3*2/12)

6
-1
0.5

Operadores bit a bit¶

In [12]:

println(~123)
println(123&234)
println(123|234)

-124
106
251

Operadores de actualización¶

In [13]:

x = 1
x += 3
println(x)

Comparaciones numéricas¶

In [16]:

println(1==1)
println(1==2)
println(1!=1)
println(1==1.0)

true
false
false
true

Conversiones numéricas¶

In [17]:

println(Int8(127))
println(Int8(128))
println(Int8(127.0))
println(Int8(3.14165))

LoadError: InexactError()
while loading In[17], in expression starting on line 2

 in call at essentials.jl:56

Funciones elementales¶

In [28]:

println("---Redondeo")
println(round(3.14165))
println(ceil(3.14165))
println(floor(3.14165))
println("---Divisiones")
println(fld(3,4))
println(cld(3,4))
println("---Valor absoluto")
println(abs(-3.14165))
println(abs2(-3.14165))
println("---Funciones matemáticas")
println(123456789^2)
println(sqrt(15241578750190521))
println(log2(1024))

---Redondeo
3.0
4.0
3.0
---Divisiones
0
1
---Valor absoluto
3.14165
9.869964722499999
---Funciones matemáticas
15241578750190521
1.23456789e8
10.0

4. Colecciones¶

Listas¶

Sobre las listas es necesario tener en cuenta que el indice va desde 1 hasta n¶

In [32]:

a = Int64[]  # arreglo vacio
push!(a,1)   # => [1]
push!(a,2)   # => [1,2]
a[1]

Out[32]:

La instanciación puede indicar el tipo o dejarlo de manera automática¶

In [33]:

b = [4, 5, 6]     # => Int64 [4, 5, 6]
b = [4; 5; 6]     # => Int64 [4, 5, 6]
b = Int8[4, 5, 6] # => Int8  [4, 5, 6]
println(b[1])   # => 4
println(b[end]) # => 6

4
6

El signo de exclamación ! al final de una función indica que esta modifica el estado de los parámetros¶

In [37]:

arr = [5,4,6]
arr1 = [4,5,6]
println(sort(arr))
println(sort!(arr1))

[4,5,6]
[4,5,6]

Los arreglos pueden ser creados a partir de rangos, y para acceder a estos puede igual hacerse por rangos (slice)¶

In [40]:

a = [1:5;] # => Int64 [1,2,3,4,5]
println(a)
println(a[1:3])
println(a[2:end])

[1,2,3,4,5]
[1,2,3]
[2,3,4,5]

Los métodos más comunes para listas son:¶

push!(arr, elm): agrega el elemento elm al final del arreglo arr
pop!(arr): elimina y retorna el elemento final del arreglo arr
shift!(arr): elimina y retorna el primer elemento del arreglo arr
unshift!(arr, elm): agrega el elemento elm al principio del arreglo arr
sort!(arr): ordena de forma ascendente el arreglo arr
splice!(arr, pos): elimina y retorna el elemento del arreglo arr en la posición pos
append!(arr1, arr2): concatena los arreglos arr1 y arr2
in(elm, arr): revisa si el elemento elm pertence al arreglo arr
lenght(arr): devuelve la cantidad de elementos en el arreglo arr

Tuplas¶

Las tuplas se comportan de manera similar a las listas, con la excepción de que son inmutables.¶

In [42]:

tupla = (1, 2, 3)
otra_tupla = 1, 2, 3

Out[42]:

(1,2,3)

Diccionarios¶

Para el uso de diccionarios, su instanciación puede ser vacía o con objetos¶

In [43]:

empty_dict = Dict() # instanciación vacía
filled_dict = Dict("one"=> 1, "two"=> 2, "three"=> 3) # instanciación con elementos

Out[43]:

Dict{ASCIIString,Int64} with 3 entries:
  "two"   => 2
  "one"   => 1
  "three" => 3

Para acceder a las llaves y valores como listas de un diccionario¶

In [45]:

println(keys(filled_dict))
println(values(filled_dict))

ASCIIString["two","one","three"]
[2,1,3]

Se puede saber si una llave o una llave-valor hacen parte del diccionario¶

In [49]:

println(in(("one" => 1), filled_dict)) # => true
println(in(("two" => 3), filled_dict)) # => false
println(haskey(filled_dict, "one")) # => true
println(haskey(filled_dict, 1)) # => false

true
false
true
false

Conjuntos (Set)¶

Se pueden hacer listas desordenadas sin elementos repetidos de la siguiente forma¶

In [50]:

empty_set = Set() # => Set{Any}()
filled_set = Set([1,2,2,3,4]) # => Set{Int64}(1,2,3,4)

Out[50]:

Set([4,2,3,1])

5. Funciones¶

En Julia, una función es un objeto que mapea una tupla de valores (argumentos) a un valor de retorno.¶

Las funciones en Julia no son funciones matemáticas puramente, en este sentido las funciones pueden alterar y ser afectadas por el estado global del programa.

Sintaxis¶

In [60]:

function f(x,y)
    x + y
end

f_prod(x,y) = x * y # => "f_prod (generic function with 1 method)"

5
6

Llamado de una Función¶

In [61]:

println(f(2,3))

In [62]:

println(f_prod(2,3))

In [63]:

g = f;
println(g(2,3))

Return¶

En Principio las funciones retoRnan el valor de la última expresión evaluada, sin embargo si hay un return, se va a retornar este valor

In [65]:

function prod(x,y)
  return x * y
  x + y
end

Out[65]:

prod (generic function with 1 method)

In [66]:

prod(3,5)

Out[66]:

In [67]:

function hypot(x,y)
  x = abs(x)
  y = abs(y)
  if x > y
    r = y/x
    return x*sqrt(1+r*r)
  end
  if y == 0
    return zero(x)
  end
  r = x/y
  return y*sqrt(1+r*r)
end

Out[67]:

hypot (generic function with 1 method)

In [68]:

hypot(3,4)

Out[68]:

5.0

In [69]:

hypot(5,2)

Out[69]:

5.385164807134505

In [70]:

hypot(3,0)

Out[70]:

3.0

Operadores como Funciones¶

In [73]:

1 + 2 + 3 + 4 + 5 + 6

Out[73]:

In [72]:

+(1,2,3,4,5,6)

Out[72]:

Para devolver varios valores se pueden usar tuplas¶

In [74]:

f_aritmeticas(x, y) = x + y, x - y, x * y, x / y
f_aritmeticas(3, 4) # => (7, -1)

Out[74]:

(7,-1,12,0.75)

Para tener una cantidad indefinida de valores se puede usar el operador splat¶

In [75]:

function varargs(args...)
    println(args)
end

varargs(1,2)
varargs(1,2,3,4)

(1,2)
(1,2,3,4)

Para los valores por defecto como argumentos como para la elección del parámetro¶

In [76]:

function defaults(a,b,x=5,y=6)
    return "$a $b and $x $y"
end
defaults(1,2)
defaults(1,2,3)


function keyword_args(;k1=4,name2="hello") # importante el ;
    return Dict("k1"=>k1,"name2"=>name2)
end
keyword_args(name2="ness") # => ["name2"=>"ness","k1"=>4]

Out[76]:

Dict{ASCIIString,Any} with 2 entries:
  "name2" => "ness"
  "k1"    => 4

6.Estructuras de control¶

Condicionales¶

In [82]:

function test(x,y)
     if x < y
       relation = "less than"
     elseif x == y
       relation = "equal to"
     else
       relation = "greater than"
     end
     println("x is ", relation, " y.")
   end
end

LoadError: syntax: unexpected end
while loading In[82], in expression starting on line 11

In [83]:

test(1,2)

x is less than y.

In [84]:

test(2979,2514)

x is greater than y.

In [85]:

test(32.0,32)

x is equal to y.

Operador "?"¶

In [86]:

f_otro_test(x,y) = println(x < y ? "less than" : "not less than")

Out[86]:

f_otro_test (generic function with 1 method)

In [87]:

f_otro_test(1,2)

less than

In [90]:

f_otro_test(3,1)

not less than

Ciclos¶

In [92]:

i = 1;

while i <= 5
     println(i)
     i += 1
end

In [93]:

for i = 1:5
    println(i)
end

In [94]:

for s in ["foo","bar","baz"]
    println(s)
end

foo
bar
baz

Manejo de errores¶

In [95]:

try
    some_other_var # => ERROR: some_other_var no definida
catch e
    println(e)
end

UndefVarError(:some_other_var)

Tasks (aka Coroutines)¶

In [97]:

function producer()
    produce("start")
    for n=1:4
        produce(2n)
    end
    produce("stop")
end;

In [ ]:

p = Task(producer);

In [ ]:

consume(p)

In [ ]:

consume(p)

In [ ]:

consume(p)

In [ ]: