Julia -> python -> Julia -> python...

run(`curl https://www.gutenberg.org/cache/epub/2265/pg2265.txt` |> 
    `tr -s "[:upper:]" "[:lower:]"`                             |> 
    `grep -oE "\w+"`                                            |>
    `grep -v "[0-9]"`                                           |> 
    `sort`                                                      |> 
    `uniq -c`                                                   |> 
    `sort -rn`                                                  |> 
    `head -10`)

10 palabras más frecuentes en Hamlet

Añadir paquetes

Sintáxis 

julia> x = reshape(1:16, 4, 4)
4x4 Array{Int64,2}:
 1  5   9  13
 2  6  10  14
 3  7  11  15
 4  8  12  16

julia> x[2:3, 2:end-1]
2x2 Array{Int64,2}:
 6  10
 7  11

# Investigación de operaciones.
# Luis Manuel Román García
# 000117077
# En este código se verifica que la gráfica este conectada.
using Distributions
#using Gadfly

function genGraph(net_length)
#Genera de manera aleatoria una gráfica.
#IN
#net_length = el tamaño de la red.
#OUT
#matriz de vértices.
    edgeMatrix   = reshape(rand(DiscreteUniform(1,net_length), net_length*2),net_length,2)
    vcat(edgeMatrix,edgeMatrix[:,[2,1]])
end


function adjacency(graph, node)
#Encuentra los nodos adjacentes a un nodo dado.
#IN
#node = el nodo del cual se quieren encontrar los nodos adjacentes
#graph = la gráfica sobre la cuál se hará la búsqueda
#OUT
#adj  = el conjunto de nodos adjacentes al nodo dado.
    g_length = length(graph[:, 1])
    adj          = Int64[]
    for i = 1:g_length
        if graph[i, 1] == node
            push!(adj, graph[i, 2])
        end
    end
    return unique(adj)
end


 function recorrido(graph, node,  check)
 # Recorre la gráfica a partir de un nodo y verifica si esta está conectada.
 # IN
 # graph: la gráfica sobre la que se quiere hacer el recorrido.
 # node: el nodo a partir del cual se inicia la búsqueda (default 1).
 # check: los nodos que han sido verificados hasta el momento (default 0).
 # cycle: determina si la gráfica tiene ciclos, default false
 # tree: un árbol asociado a la gráfica (default la)
 # OUT
 # variable lógica que determina si la gráfica está conectada.
     check[node] = 1                                                                 #Marcar el nodo como verificado.
     adj                = adjacency(graph, node)                               #Obtener los nodos adjacentes al nodo i.
         for j in adj
             if  check[j] == 0 && sum(check[adj]) != length(adj)   #Verifica si el nodo está marcado y si tiene vecinos no marcados.
                 recorrido(graph, j,  check)
             elseif sum(check[adj]) == length(adj)                         # Si todos sus vecinos están marcados lo marcamos
                 check[j] = 1
             end
         end
         if      sum(check) == length(unique(graph[:, 1]))
             return true
         else
             return false
         end
 end


function spanningTree(graph)
 # Recorre la gráfica a partir de un nodo y construye un árbol de expansión.
 # IN
 # graph: la gráfica sobre la que se quiere hacer el árbol.
 # OUT
 # Un árbol de expansión en caso de que la gráfica este conectada,
 # de lo contrario un mensaje.
    check = zeros(length(unique(graph[:,1])),1)
    node  = 1
    if recorrido(graph, node, check) == true
        print("gráfica conectada")
        tree = zeros(1,2)
        bag  = []
        for i in unique(graph[:,1])
            bag = vcat(bag,i)
            for j in adjacency(graph, i)
                if !(j in bag)
                    bag = vcat(bag,j)
                    tree = vcat(tree,[i j])
                end
            end
        end
        return tree[2:end,[1, 2]]
    else
        return "gráfica no conectada"
    end
end


function input(prompt::String="")
# Leer inputs del usuario.
     print(prompt)
     chomp(readline())
end

#######
#Run
#######
#graph = input("Gráfica:")
#println(spanningTree(graph))

functions.jl

# En este script se pone a prueba el algoritmo spanningTree
graph1 = [1 2; 2 3; 3 4; 2 1; 3 2; 4 3]
graph2 = [1 2; 1 4; 2 3; 3 4; 4 1;  2 1; 4 1;  3 2; 4 3; 1 4]
graph3 = [1 2;  3 4; 2 1; 4 3]
graph4 = [1 2; 1 3; 2 3; 2 5; 3 4; 3 5; 4 5; 2 1; 3 1; 3 2; 5 2; 4 3; 5 3; 5 4]

spanningTree(graph1)
spanningTree(graph2)
spanningTree(graph3)
spanningTree(graph4)

Main.jl

Números aleatorios (paralelo)

Números aleatorios (normal)

tic()
a = zeros(100000)
@parallel for i=1:100000
  a[i] = i
end
toc()

elapsed time: 0.585655953 seconds

tic()
a = zeros(100000)
 for i=1:100000
  a[i] = i
end
toc()

elapsed time: 1.710980293 seconds

Más de 3 veces más rápido