Capítulo

4

Introdução à linguagem de programação Julia: A ambiciosa linguagem de programação que quer substituir Python, R e Matlab.

João Marcello Pereira

Abstract

Scientific computation, also known as computational science, is the field of knowledge for the construction of mathematical models and techniques of numerical solutions using software and hardware to analyze and solve scientific problems. The Julia programming language is an opensource alternative to MATLAB®, Maple®, Fortran, R and Python, focused on teaching numerical and symbolic programming, and scientific research. Based on several other languages, Julia has JIT compilation (just in time) is designed for parallel and distributed computing, is IDE free choice, has integration with C, Fortran and Python, as well as practical package development and management by GIT.

Resumo

A computação científica, também conhecida como ciência computacional, é o campo do saber destinado à construção de modelos matemáticos e técnicas de soluções numéricas utilizando softwares e hardwares para analisar e resolver problemas científicos. A linguagem de programação Julia é uma alternativa opensource ao MATLAB®, Maple®,

Fortran, R e Python, focado no ensino de programação numérica e simbólica, e pesquisa científica. Baseada em várias outras linguagens, Julia apresenta compilação JIT (just in time) é projetado para computação paralela e distribuída, é de livre escolha de IDE, possui integração com C, Fortran e Python, além de desenvolvimento de pacotes de forma prática e gerenciamento via GIT.

III Escola Regional de Informática do Piauí. Livro Anais - Artigos e Minicursos, v. 1, n. 1, p. 315-335, jun, 2017.www.eripi.com.br/2017 - ISBN: 978-85-7669-395-6

4.1. Introdução

A análise numérica permite que inúmeros problemas matemáticos, cujas soluções algébricas são difíceis, ou até mesmo impossíveis de se encontrar, possam ser resolvidos por meio de métodos numéricos apropriados [Sperandio; Mendes; Silva, 2003]. Dessa forma, diversos softwares e linguagens de programação foram desenvolvidos com o intuito de resolver problemas numéricos, sendo aplicados, principalmente, em pesquisas e no ensino das disciplinas de cálculo e métodos numéricos. Entre esses, o MATLAB® é a mais expressiva plataforma (linguagem e ambiente de programação) de programação numérica e simbólica utilizada nas instituições de ensino e nas indústrias. Embora seja muito popular no ambiente acadêmico, o MATLAB® é uma plataforma fechada de alto custo de aquisição, além de exigir computadores acima do padrão básico do mercado brasileiro. Neste ponto, há diversas alternativas de código aberto como Python, R, Fortran. Julia surgiu nesse cenário com a proposta ousada de substituir várias linguagens voltadas para computação científica. Conforme as palavras dos criadores, Bezanson et al. (2015):

“Queremos uma linguagem de código aberto, com uma licença liberal. Queremos a velocidade de C com o dinamismo de Ruby. Queremos uma linguagem que seja homoicônica, com macros verdadeiros como Lisp, mas com notação matemática óbvia e familiar como Matlab. Queremos algo tão útil para programação geral como Python, tão fácil para estatísticas como R, como natural para processamento de strings como Perl, tão poderoso para álgebra linear como Matlab, tão bom e adaptável como programas juntos em shell. Algo simples de aprender, mas que ainda satisfaça os hackers mais sérios. Queremos que ele interativo e queremos compilado.

(Será que mencionamos que deve ser tão rápido quanto C?)”

Os esforços dos desenvolvedores em projetar uma linguagem de alto desempenho podem ser observados nos resultados de um benchmark entre várias linguagens disponível no site oficial da linguagem Julia. O benchmark consiste na execução de vários códigos em um único núcleo (execução serial) de um processador Intel® Xeon® CPU E7-8850 2.00GHz com 1TB de memória RAM DDR3 de 1067MHz e sistema operacional Linux.

Tabela 4.1. Tempo de processamento relativo ao temp o de C (Quanto menor, melhor. Performance de C = 1)

Conforme dos dados apresentados, Julia apresenta um potencial significativo, principalmente em função de uma linguagem que ainda não chegou à sua versão 1.0.

Algoritmos Fortran

(gcc 5.4.1)

Julia

(0.4.0)

Python

(3.4.3)

R

(3.2.2)

Matlab

(R2015b)

Octave

(4.0.0)

Mathematica

(10.2.0)

JavaScript

(V8 3.28.74.19)

Go

(go4.5)

LuaJIT

(gsl-shell 2.3.1)

Java

(4.8.0_45)

fibonacci 0.70 2.11 77.76 533.52 26.89 9324.35 118.53 3.36 4.86 4.71 4.21

parse_int 5.05 4.45 17.02 45.73 802.52 9584.44 15.02 6.06 4.20 5.77 3.35

quicksort 4.31 4.15 32.89 264.54 4.92 1866.01 43.23 2.70 4.29 2.03 2.60

mandel 0.81 0.79 15.32 53.16 7.58 454.81 5.13 0.66 4.11 0.67 4.35

pi_sum 4.00 4.00 24.99 9.56 4.00 299.31 4.69 4.01 4.00 4.00 4.00

rand_mat_stat 4.45 4.66 17.93 14.56 14.52 30.93 5.95 2.30 2.96 3.27 3.92

rand_mat_mul 3.48 4.02 4.14 4.57 4.12 4.12 4.30 15.07 4.42 4.16 2.36

4.2. Linguagem de programação Julia

Julia é uma linguagem de programação compilada (JIT – Just In Time) open source de alto nível, projetada com foco na computação científica e numérica de alto desempenho [Bezanson et al. 2015]. É relativamente jovem, posto que teve início no MIT em agosto de 2009 e, em fevereiro de 2012, tornou-se open source. É fruto do trabalho de quatro pesquisadores: Stefan Karpinski, Jeff Bezanson, Alan Edelman e Viral Shah [Bezanson et al. 2015]. A linguagem Julia foi pensada como uma linguagem para computação científica suficientemente rápida, tal como as linguagens C e Fortran, mas igualmente fácil de aprender como o MATLAB® e o Mathematica®, com o objetivo de facilitar a modelagem computacional. É escrito em C, C++ e Scheme, e a biblioteca padrão é escrita utilizando a própria linguagem. Possui forte inspiração em MATLAB®, Lisp, C, Fortran, Mathematica®, Python, Perl, R, Ruby, Lua, além de compartilhar muitas características de Dylan e Fortress. A versão estável atual de Julia é v0.5.2 lançada em 10 de maio de 2017. O site oficial (http://julialang.org), lista abaixo como os recursos principais da linguagem:

• Sintaxe intuitiva e semelhante ao MATLAB®

• Despacho múltiplo: permite definir diferentes comportamentos para uma mesma função a partir de diferentes combinações dos tipos de seus argumentos;

• Sistema de tipos dinâmico: tipos para documentação, otimização e despacho;

• Bom desempenho, aproximando-se de linguagens compiladas estaticamente como C;

• Gerenciador de pacotes embutido;

• Macros similares a Lisp e outras funcionalidades de metaprogramação;

• Chamadas para funções de bibliotecas Python por meio do pacote PyCall.jl;

• Chamadas para funções de bibliotecas C diretamente sem necessidade de wrappers ou APIs especiais;

• Projetado para paralelismo e computação distribuída;

• Tipos definidos pelo usuário são tão rápidos e compactos quanto os tipos nativos da linguagem;

• Geração automática de código especializado e eficiente para diferentes tipos de argumentos;

• Conversões e promoções elegantes e extensíveis para tipos numéricos e demais tipos;

• Suporte eficiente para Unicode;

• Licença MIT.

A compilação just-in-time (JIT) baseado em LLVM de Julia, combinado com seu design, permite que a linguagem se equipare à performance da linguagem C em vários cenários. Neste ponto, a compilação Just-in-Time é descrito por Sengupta (2015) como:

A compilação Just-in-Time é uma técnica na qual o código escrito em uma linguagem de alto nível é convertido em código de máquina para execução na CPU em tempo de execução. Isso contrasta com as linguagens interpretadas, que executam o código diretamente em tempo de execução. Isso geralmente tem uma sobrecarga significativamente maior.

O processo de compilação na linguagem Julia é descrito por Balbaert (2015) da seguinte forma:

Na primeira vez em que é executada uma função na linguagem Julia, ela é analisada e os tipos são inferidos. Em seguida, o código LLVM é gerado pelo compilador JIT, que é otimizado e compilado para código nativo. Na segunda vez em que é executada novamente a mesma função Julia, o código nativo, já gerado, é chamado. Esta é a razão pela qual, na segunda vez em que é chamada uma função com argumentos de um tipo específico, o tempo de execução é bem menor que na primeira vez.

Feito as considerações iniciais sobre a linguagem, os tópicos seguintes são referentes aos comandos básicos, interface, instalação, tipos de dados, cotrole de fluxo, escopo, gerenciamento de pacotes, matemática simbólica, gráficos e dataframes.

4.3. Começando com o Julia

A maneira mais fácil de "testar" a linguagem de programação Julia é através do JuliaBox (juliabox.com). JuliaBox é um ambiente de programação com interface web Jupyter hospedado na nuvem do Google para codificação em linguagem Julia sem a necessidade de instalar qualquer software na máquina local. O Jupyter é uma aplicação web derivado do IPython que é um interpretador de comandos interativo para várias linguagens de programação. A interface Jupyter oferece type introspection, rich media, sintax shell, suporte para mais de 40 linguagens de programação, incluindo as mais populares em computação científica como Python, R, Julia e Scala. Além disto, permite realizar o download do código em outros formatos (.pdf, .md, .rst, .html e .tex), gerar apresentação de slides, permite escrita de texto científicos em latex e markdown, importação/exportação de projetos para o github e muitas outras funcionalidades. JuliaBox disponibiliza algumas recursos interessantes para cada usuário:

• Permite executar um terminal bash Linux que pode ser usado para executar o Julia REPL;

• Transferência de arquivos para o contêiner de uma sessão;

• Sincronização de arquivos com o Google Drive e Github;

• Extensível com plugins;

• 500 MB de espaço em disco;

• 6 GB de memória RAM;

• 4 CPUs (16 cores) Xeon(R) CPU 2.60GHz;

• Ubuntu 14.04.5 LTS;

• Interface web Jupyter;

• E muito mais.

O JuliaBox não é um ambiente ideal para simulações e benchmark, a proposta é dos desenvolvedores é fornecer um ambiente de codificação prática e portável. São

permitas apenas 3h de uso contínuo, após isto, ocorrerá lougout e um novo login será necessário.

Figura 4.1. Interface inicial do JuliaBox.

Figure 4.2. Pastas e arquivos no formato “ipynb”.

Figura 4.3. Interface Jupyter do JuliaBox

Outra forma de utilizar Julia é instalando na máquina local de acordo com o sistema operacional:

• Windows

Baixe o executável de acordo do com a arquitetura do computador no endereço https://julialang.org/downloads/ e execute o processo de instalação clicando no executável e seguindo as informações do instalador.

• Linux

Ubuntu e derivados (Mint/Kubuntu)

#ferramentas de compilação

:~$ sudo apt-get update

:~$ sudo apt-get install build-essential

#Instalação Julia

:~$ sudo add-apt-repository ppa:staticfloat/juliareleases

:~$ sudo add-apt-repository ppa:staticfloat/julia-deps

:~$ sudo apt-get update && sudo apt-get install julia

Artch e derivados (Manjaro/Artegos)

#ferramentas de compilação

:~$ sudo pacman -Sy base-devel && sudo pacman -Syu

#Instalação Julia

:~$ sudo pacman –S Julia

RedHat e derivados (Fedora/Scientific/CentOS)

#ferramentas de compilação

:~$ sudo dnf groupinstall "Development Tools and Libraries" ou "Ferramentas de Desenvolvimento C e Bibliotecas"

#Instalação Julia

:~$ sudo dnf copr enable nalimilan/julia

:~$ sudo yum install julia

Binários

Basta baixar os binários do site (https://julialang.org/downloads/), extrair para um diretório e executar o binário “Julia” dentro da pasta “bin” na forma:

:~$ ./Julia

4.4. Comandos Básicos

Os comandos em Julia apresentam sintaxe muito semelhante à sintaxe dos comandos em MATLAB ®. Vejamos alguns pontos interessantes:

• Ponto e vírgula ao final do comando oculta o resultado;

• Comentários são na forma de #;

• O ponto antes de um operador matemático indica operação elemento-elemento em um array (ex: ./, .^);

• 4.0 (float) e 1 (inteiro) são diferentes;

• Informação do tipo: variable::Bool significa que a variável é do tipo booleano;

• Todos os pacotes são escritos usando a primeira letra maiúscula entre aspas duplas;

• Julia é Case-Sensitive F e f são diferentes;

• Funções e comandos de controle de fluxo (if, for, while...) necessita de "end" para terminar o bloco;

• Macros são iniciados por "@";

• O comando de ajuda é ? comando/função;

Alguns comandos básicos:

4.5. Tipos Básicos

Em Julia existem basicamente dois tipos: tipos abstratos e tipos concretos. Um tipo abstrato é caracterizado por não ser instanciado, servindo apenas para a construção de outros tipos. Já os tipos concretos podem ser instanciados, mas não podem ter subtipos. A árvore de tipo (Figura 4.4) em Julia possui mais de 500 tipos! Apesar de enorme é útil, pois permite a construção de código generalizado, em vez de restringi-lo a um único tipo.

Figura 4.4. Interface Jupyter do JuliaBox [Larsson, 2017]

Exemplo de algumas estruturas com tipos básicos:

4.6. Gerenciamento de pacotes

A Julia tem um gerenciador de pacotes embutido escrito na própria linguagem assim como também grande parte da sua biblioteca padrão. Os pacotes adicionais (registrados ou mantido por usuários) são disponibilizados no GitHub (github.com) e a lista oficial (1385 pacotes registrados) está disponível em http://pkg.julialang.org.

Os pacotes desenvolvidos para a linguagem Julia estão sempre sendo atualizados, logo, é importante atualizar a base de pacotes instalados. O processo de instalação (do repositório oficial) e remoção de pacotes utiliza somente dois comandos: Pkg.add(“NomePacote”) e Pkg.rm(“NomePacote”).

4.7. Controle de fluxo

Nas linguagens de programação, uma estrutura de controle (ou fluxo de controle) possui relação com a ordem em que estruturas lógicas são executadas ou avaliadas em um código computacional. Em Julia, assim com outras linguagens, temos as estruturas condicionais e estruturas de repetição.

• Estrutura Condicional

A avaliação condicional na linguagem Julia permite que partes de código sejam avaliados ou não dependendo do valor de uma expressão booleana. Dessa forma uma estrutura condicional é útil para implementar situações no qual requer a execução de ações alternativas que dependem de certas condições quando avaliadas. Código:

Não existe implementada uma estrutura “Case” em Julia, a saída é utilizar o pacote Match.jl como alternativa.

• Estruturas de Repetição

Estruturas de repetição, que permitem executar mais de uma vez um mesmo trecho de código. Julia possui as seguintes estruturas de repetição: loop while, for e do.

4.8. Funções

Na linguagem Julia, uma função é um objeto que mapeia uma tupla de valores de argumentos de entrada e produz um ou vários valores de retorno. De acordo com o manual oficial (versão 0.5), as funções de Julia não são funções matemáticas puras, no sentido de que as funções podem alterar e ser afetadas pelo estado global do programa. No entanto podemos utilizar (principalmente a forma reduzida da função genérica) as funções em Julia de forma bem próximas do conceito matemático de acordo com as duas formas: função genérica e função anônima. Cada uma possui vantagens e desvantagens quanto ao desempenho e sintaxe. Em geral a mais utilizada é a função genérica. Qualquer função pode ser aplicada elemento-elemento a qualquer array (ou outra coleção) com a sintaxe função.(Array).

O multiple dispatch ou Despacho múltiplo é uma das características mais importantes de Julia e um grande diferencial em relação a outras linguagens para computação científica. As funções em Julia podem ter vários métodos definidos e o comportamento da execução depende dos argumentos que são passados. Quando uma função é chamada, Julia fará uma pesquisa na sua vtable (tabela de métodos virtual) em tempo de execução para descobrir qual método correto deve ser chamado com base nos tipos de todos os seus argumentos; Este é o mecanismo de Julia de despacho múltiplo, que nem Python, nem C++ ou Fortran implementam [Balbaert, 2015].

• Função Genérica

As funções genéricas possuem este nome porque estão prontas para trabalhar com diferentes tipos de dados. A construção de funções é feita na forma de blocos ou reduzida (estrutura semelhante a uma definição matemática).

Para realizar o cálculo com arrays, basta usar o “.” entre o nome da função e array:

As funções podem ser escritas em um arquivo “.jl” e importadas para o ambiente de programação. No exemplo abaixo, a função fibonacci recursiva foi salva no arquivo “ fiboR.jl” e importada pelo comando include(). Outra possibilidade é gravar várias funções em um único arquivo e importa-las com o mesmo comando.

Exemplo de Despacho múltiplo

• Função Anônima

Funções anônimas não têm um nome para serem invocadas diretamente, mas são muito usadas como parâmetros para outras funções, ou são atribuídas a uma variável, que acaba funcionando como um nome [Balduino, 2012]. Um exemplo clássico de uso de uma função anônima ocorre combinado com a função map(), no qual esta aplica cada valor de um array a uma função anônima e retorna um novo array contendo os valores resultantes. Outra aplicação é quando uma função precisa ser redefinida várias vezes. Ao definir uma função anônima em Julia, devemos observar que o resultado é uma função genérica, mas com um nome gerado pelo compilador na forma (::#a)(generic function with b method). Os caracteres #a representam o número gerado pelo compilador baseado em numeração consecutiva e b o número de métodos.

Para realizar o cálculo com arrays, basta usar o “.” entre a função e array:

4.9. Escopo

O escopo de uma variável é a região dentro do código no qual uma variável está visível. O objetivo do escopo de variáveis em linguagens de programação é bem claro: evitar conflitos de nomeação de variáveis. Na linguagem Julia existem dois tipos principais de escopos denominados escopo global e escopo local (Soft ou Hard), sendo que este último pode ser aninhado.

• Global

Em Julia as variáveis globais que são acessíveis de qualquer lugar do programa e uma variável global declarada como const pode alterar seu valor (um aviso é informado na tela) conforme a conveniência. Código:

• Soft Local

Um escopo local geralmente herda todas as variáveis de seu escopo principal, tanto para leitura e escrita. Em um escopo soft local, todas as variáveis são herdadas de seu escopo principal, a menos que uma variável seja especificamente marcada com a palavra chave local.

• Hard Local

Escopo hard local é determinado principalmente por funções (em todas as suas formas) e macro. Em um escopo hard local, todas as variáveis são herdadas de seu escopo principal.

4.10. Matemática simbólica

A abordagem simbólica é de domínio dos sistemas de álgebra computacional (CAS), trabalhado através de programas muito abrangentes como o Mathematica®, o Maple® e o Maxima. Julia usa o pacote SymPy do Python via pacote Pycall.jl para realizar cálculos de matemática simbólica. Dessa forma, é possível integrar e diferenciar funções simbolicamente, resolver grande parte das EDOs lineares de segunda ordem, realizar simplificação de expressões, além de muitas outras manipulações simbólicas.

4.11. Gráficos

É possível utilizar diversos pacotes gráficos com Julia. Alguns pacotes disponíveis no repositório oficial: PyPlot.jl, PlotlyJS.jl, GR.jl e GadFly.jl. PyPlot.jl permite plotar diferentes tipos de gráficos 2D e 3D. Utiliza o pacote

PyCall.jl para chamar o matplotlib do Python diretamente do código em Julia. Uma das

vantagens do pacote PyPlot.jl é a quantidade de opções de gráficos e configuração de

visualização.

GR.jl é um pacote que fornece uma interface de Julia para GR no qual oferece

aos desenvolvedores uma compacta e consistente biblioteca gráfica 2D e 3D para seus

programas baseado em OpenGL.

GadFly.jl é um pacote para plotar e visualizar somente gráficos 2D totalmente

escrito em Julia. Baseia-se em grande parte nos trabalhos de Hadley Wickhams e Leland

Wilkinson. Foi criado por Daniel C. Jones e atualmente é mantida pela comunidade.

GadFly.jl gera gráficos muito bonitos e apresenta várias opções de visualização,

incluindo uma prática barra de zoom.

PlotlyJS.jl é uma interface para a biblioteca desenvolvida em javascript Plotly.js

que permite criar gráficos interativos de alta qualidade visual.

Plots.jl é um conjunto de ferramentas para construção e visualização de gráficos

2D e 3D. Diferente dos outros pacotes gráficos, Plots cria uma interface para um

backends gráfico, ou seja, para um pacote (PyPlot, GR, PlotlyJS e outros) responsável

por gerar o gráfico. Uma grande vantagem do pacote Plots.jl é que um mesmo conjunto

de comandos pode ser utilizado para vários backends, eliminando assim a necessidade e

aprender vários comandos diferentes para cada pacote gráfico.

4.12. DataFrames

Data frames são objetos usados para guardar dados na forma de tabelas. Um data frame possui colunas nomeadas, sendo que todas as colunas possuem a mesma quantidade de linhas. É uma ótima forma de visualizar informações, pois além de manter uma boa formatação dos dados, ainda permite que sejam gravados em arquivos do tipo CSV ou XLS, que podem ser abertos e manipulados em softwares de planilha como o excel (Microsoft®) ou calc (LibreOffice). DataFrames.jl é um dos pacotes disponíveis para trabalhar com dados tabulares na linguagem Julia.

Referências

Balbaert, Ivo et al (2015). “Getting Started With Julia Programming”. Birmingham, Packt Publishing.,p.30-35

Baldoino, Plínio. (2012)“Dominando JavaScript com jQuery”, São Paulo, Casa do Código., p.31-32

Larsson, Olle et al (2017). “A brief overview of Julia the programming language”. https://www8.cs.umu.se/kurser/5DV086/VT17/. Maio.

Sengupta, Avik (2016).“Julia High Performanc”. Birmingham, Packt Publishing., p.1-5.

Sherrington, Malcolm (2015). “Mastering Julia”. Birmingham, Packt Publishing., p.120-122

Sperandio, D.; Mendes, J. T; Silva, L. H (2003). “Cálculo numérico – Características matemáticas e computacionais dos métodos numéricos”. São Paulo, Pearson., p.15