http://fiscomp.if.ufrgs.br/api.php?action=feedcontributions&feedformat=atom&user=RaquelmFísica Computacional - Contribuições do usuário [pt-br]2026-06-12T20:52:53ZContribuições do usuárioMediaWiki 1.43.0http://fiscomp.if.ufrgs.br/index.php?title=Julia&diff=2518Julia2020-01-07T15:07:17Z<p>Raquelm: /* Aprendendo Julia */</p>
<hr />
<div>Julia é uma linguagem relativamente nova de programação que começou a ser desenvolvida em 2009 por Jeff Bezanson, Stefan Karpinski, Viral B. Shah, e Alan Edelman, um grupo do MIT. Ela foi oficialmente lançada para o mundo em 2012.<br />
<br />
Em uma entrevista, quando perguntaram a Alan o por quê do nome Julia, ele disse que numa conversa anos atrás alguém sugeriu que Julia seria um bom nome para uma linguagem de programação.<br />
<br />
Julia pode ser usada para propósitos gerais de programação, assim como Python, mas em sua criação foi visada a utilização de Julia para Cálculo Numérico.<br />
<br />
== Aspectos Gerais ==<br />
<br />
Julia é uma linguagem de alto nível, isso significa, de maneira sucinta, que ela não é executada utilizando somente o processador, assim como acontece com linguagens de baixo nível, como Assembly, por exemplo.<br />
<br />
É escrita em C, C++, e Scheme, usando a estrutura do compilador LLVM (para melhor entendimento, o compilador de C é o GCC, por exemplo), enquanto a maior parte da biblioteca padrão de Julia é implementada na própria Julia.<br />
<br />
Um fato importante sobre Julia para os programadores de Python é que todas as bibliotecas de Python são usáveis através de um comando simples: PyCall.<br />
<br />
Um fato importante sobre Julia para os programadores de C é que Julia possui APIs (Interfaces de Programação de Aplicativos) especiais para chamada de funções em C diretamente.<br />
<br />
== Velocidade ==<br />
<br />
De acordo com testes feitos pelos próprios criadores de Julia, sua velocidade é similar com a de C.<br />
<br />
<br />
<center>[[Arquivo:juliasvelocity.png|border]]<br />
Fonte: [https://julialang.org/benchmarks/]<br />
</center><br />
<br />
<br />
== Testes de Velocidade ==<br />
<br />
A fim de pessoalmente testar a velocidade da linguagem de programação, foi escrito um programa em Julia de maneira similar ao programa de Python para o FTCS aplicado na Equação de Difusão (também conhecida como Equação do Calor). <br />
<br />
A Equação da Difusão em uma dimensão pode ser escrita da forma:<br />
<br />
<center><math>\frac{df}{dt}=\frac{d^{2}f}{dx^{2}}</math></center><br />
<br />
No método de FTCS (Forward-Time Central-Space) definimos a derivada em t na forma não simetrizada (forward) e as derivadas em x na forma simetrizada:<br />
<br />
<br />
<center><math>\frac{df}{dt} = \frac{f(x, t+dt) - f(x,t)}{dt}</math></center><br />
<br />
<p><br />
<br />
<center><math>\frac{d^{2}f}{dx^{2}} = \frac{f(x+dx, t) + f(x-dx, t) - 2f(x,t)}{dx^{2}}</math></center><br />
<br />
E substuindo na equação da difusão, em notação discreta temos:<br />
<br />
<center><math>f_{j}^{n+1} = f_{j}^{n} + D\frac{dt}{(dx)^{2}}[f_{j+1}^{n} + f_{j-1}^{n} - 2 f_{j}^{n}]</math></center><br />
<br />
'''Observação:''' esse procedimento funciona bem se <math>k=D\frac{dt}{(dx)^{2}} <= 1/2</math>, segundo análise de estabilidade do método.<br />
<br />
<br />
Dessa forma, foi escrito um programa para integrar a Equação de Difusão através do método de FTCS nas linguagens Python e Julia.<br />
<br />
Para '''Python''':<br />
<pre><br />
# FTCS aplicado na equacao da difusao. Linguagem: PYTHON<br />
<br />
import copy<br />
import numpy as np<br />
import matplotlib.pyplot as plt<br />
<br />
def init():<br />
L=50;D=1.;dt=0.05;dx=1.;t=0;tmax=100.<br />
k=D*dt/(dx*dx) <br />
return L,k,dt,t,tmax<br />
<br />
L,k,dt,t,tmax = init()<br />
<br />
x = np.arange(0,L,1) <br />
f = np.zeros(x.shape)<br />
<br />
a = int(L/3)<br />
b = int(2*L/3)<br />
f[a:b]=1.<br />
f1 = copy.deepcopy(f) <br />
f2 = copy.deepcopy(f)<br />
<br />
while t<tmax:<br />
t+=dt<br />
f1[1:L-1]=f[1:L-1]+k*(f[0:L-2]+f[2:L]-2*f[1:L-1])<br />
f1[L-1]=f[L-1]+k*(f[L-2]+f[0]-2*f[L-1]) <br />
f1[0]=f[0]+k*(f[1]+f[L-1]-2*f[0]) <br />
f=copy.deepcopy(f1) <br />
<br />
sum0=sum(f1)<br />
sum1=sum(f2) <br />
<br />
print("Integral em t=0: %7.4f" % sum0)<br />
print("Integral em tmax: %7.4f" % sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
Em '''Julia''':<br />
<pre><br />
# FTCS aplicado na equacao da difusao. Linguagem: JULIA<br />
<br />
using PyPlot<br />
<br />
L=50<br />
D=1.<br />
dt=0.05<br />
dx=1.<br />
t=0<br />
tmax=100.<br />
k=D*dt/(dx*dx) <br />
<br />
x = collect(0:1:L-1)<br />
f = zeros(L)<br />
f1 = zeros(L)<br />
<br />
a = trunc(Int, L/3) <br />
b = trunc(Int, 2*L/3)<br />
<br />
f[a+1:b] .= 1.<br />
f2 = deepcopy(f)<br />
<br />
while t<tmax<br />
global t+=dt <br />
f1[2:L-1] = f[2:L-1] + k*(f[1:L-2] + f[3:L] - 2*f[2:L-1]) <br />
f1[L] = f[L] + k*(f[L-1] + f[1] - 2*f[L])<br />
f1[1] = f[1] + k*(f[2] + f[L] - 2*f[1]) <br />
global f = deepcopy(f1) <br />
end<br />
<br />
sum0 = sum(f1)<br />
sum1 = sum(f2)<br />
<br />
println("Integral em t=0: ", sum0)<br />
println("Integral em tmax: ", sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
<br />
Foi testado o tempo de execução da parte principal dos dois programas (isto é, sem fazer o gráfico dos resultados), através do timer do terminal, como mostra na próxima figura:<br />
<br />
<center>[[Arquivo:Ftcs_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o método de FTCS aplicado à Equação de Difusão<br />
</center><br />
<br />
É possível perceber, através da figura acima, que o tempo de execução de Python para o FTCS aplicado à Equação de Difusão é menor do que o de Julia. Em razão disso, foi testado um programa simples, como mostra abaixo, que incrementa uma variável 10 vezes, sendo o seu valor inicial 0.<br />
<br />
<br />
<center>[[Arquivo:For.png|border]]<br />
'''Legenda:''' Programa para incrementar o valor de uma variável, nesse caso ''i'', 10 vezes, escrito em Julia e em Python<br />
</center><br />
<br />
E posteriormente, novamente, foi testado o tempo de execução da parte principal dos programas através do terminal:<br />
<br />
<center>[[Arquivo:For_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o programa que incrementa o valor da variável 10 vezes<br />
</center><br />
<br />
É possível perceber que para esse simples programa de incrementação, Python ainda obtém melhor performance do que Julia.<br />
<br />
== Performance de Julia ==<br />
<br />
Tentando entender o que traria tal performance em Cálculo Numérico para Julia, foi chegado à conclusão de que ser uma linguagem que se utilizada de ''variáveis dinâmicas'' e ''multi-métodos'' seria uma das grandes contribuições da linguagem.<br />
<br />
'''Variáveis dinâmicas:'''<br />
<br />
Em Python as variáveis são interpretadas em runtime, ou seja, '''tempo de execução''' => o programa checa toda hora se a variável mudou e isso torna ele mais lento<br />
<br />
'''Variáveis estáticas:'''<br />
<br />
Em C as variáveis são fixas, e isso é visto é em '''tempo de compilação''' => precisa pensar nas variáveis e isso torna o tempo de programação mais lento<br />
<br />
Em Julia isso é basicamente opcional, não é preciso definir as variáveis, mas é possível, e elas podem mudar dinamicamente, em tempo de execução. E ainda, Julia se utiliza de multi-métodos para não ter que lidar com a constante checagem dos tipos das variáveis, como Python faz!<br />
<br />
'''Métodos Únicos'''<br />
<br />
Python => Métodos Únicos (single dispatch)<br />
- Não tenho sobrecarga de funções, eu simplesmente chamo uma função que já está escrita<br />
<br />
'''Multi-métodos'''<br />
<br />
Sobrecarga de funções (C++) => Multi-métodos (multiple dispatch)<br />
- Tenho uma função e dependendo dos parâmetros que eu coloco ao chamá-la, eu chamo uma função ou outra<br />
<br />
'''Exemplo de sobrecarga de funções em Julia:'''<br />
<br />
<pre> <br />
# Dependendo do tipo da minha variável x na chamada da função, será chamada uma função ou outra, mesmo que tenham o mesmo nome<br />
<br />
function printx(x::Float64)<br />
println(x)<br />
end<br />
<br />
function printx(x::String)<br />
println(x)<br />
end<br />
<br />
x="Oi"<br />
<br />
printx(x)<br />
</pre><br />
<br />
== Performance de Julia: na prática ==<br />
Para resumir, temos: <br />
<br />
Python => dynamic (variáveis dinâmicas) single dispatch (métodos únicos)<br />
<br />
C++ => static (variáveis estáticas) multiple dispatch (multi-métodos)<br />
<br />
Julia => dynamic multiple dispatch (''o melhor dos dois mundos!'')<br />
<br />
Na prática, é mostrado abaixo um exemplo da performance de Julia como linguagem de programação em dynamic multiple dispatch. <br />
<br />
O mesmo programa foi escrito em Julia e em C++. <br />
<br />
Em '''Julia''':<br />
<br />
<pre><br />
abstract type Animal end<br />
<br />
struct Cachorro <: Animal<br />
nome::String<br />
end<br />
<br />
struct Gato <: Animal<br />
nome::String<br />
end<br />
<br />
# Função de encontro que recebe tipo genérico de animal<br />
function encontroDeAnimais(a::Animal, b::Animal)<br />
acao = encontro(a,b)<br />
println("$(a.nome) encontra $(b.nome) e $acao")<br />
end<br />
<br />
# Funções de expressão única que recebem diferentes tipos de animais<br />
encontro(a::Cachorro, b::Cachorro) = "cheira" <br />
encontro(a::Cachorro, b::Gato) = "persegue"<br />
encontro(a::Gato, b::Gato) = "lambe"<br />
encontro(a::Gato, b::Cachorro) = "ignora" <br />
<br />
# Instanciando os bichinhos<br />
gato1 = Gato("Luciene Maria")<br />
gato2 = Gato("Mel")<br />
cachorro1 = Cachorro("Batata")<br />
cachorro2 = Cachorro("Snoopy")<br />
<br />
# Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2)<br />
encontroDeAnimais(gato1, cachorro2)<br />
encontroDeAnimais(cachorro1, cachorro2)<br />
</pre><br />
<br />
<br />
Em '''C++''':<br />
<br />
<pre><br />
#include <iostream><br />
using namespace std;<br />
<br />
class Animal { <br />
public:<br />
string nome;<br />
};<br />
<br />
string encontro(Animal a, Animal b) {}<br />
<br />
// Função de encontro que recebe tipo genérico de animal<br />
void encontroDeAnimais(Animal a, Animal b) {<br />
string acao = encontro(a,b);<br />
cout << a.nome << " encontra " << b.nome << " e " << acao << endl;<br />
}<br />
<br />
class Cachorro:public Animal {};<br />
class Gato:public Animal {};<br />
<br />
// Funções de expressão única que recebem diferentes tipos de animais<br />
string encontro(Cachorro a, Cachorro b) { return "cheira"; }<br />
string encontro(Cachorro a, Gato b) { return "persegue"; }<br />
string encontro(Gato a, Gato b) { return "lambe"; }<br />
string encontro(Gato a, Cachorro b) { return "ignora"; }<br />
<br />
int main() {<br />
// Instanciando os bichinhos<br />
Gato gato1; gato1.nome = "Luciene Maria";<br />
Gato gato2; gato2.nome = "Mel";<br />
Cachorro cachorro1; cachorro1.nome = "Batata";<br />
Cachorro cachorro2; cachorro2.nome = "Snoopy";<br />
<br />
// Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2);<br />
encontroDeAnimais(gato1, cachorro2);<br />
encontroDeAnimais(cachorro1, cachorro2);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Para '''Julia''' nós obtemos o seguinte '''resultado''':<br />
<br />
<pre><br />
Luciene Maria encontra Mel e lambe<br />
Luciene Maria encontra Snoopy e ignora<br />
Batata encontra Snoopy e cheira<br />
</pre><br />
<br />
Para '''C++''' o '''resultado''' é:<br />
<br />
<pre><br />
Luciene Maria encontra Mel e<br />
Falha de Segmentação<br />
</pre><br />
<br />
Isso acontece porque C++ não aceita que uma função utilize-se de uma variável sem antes saber qual o tipo dessa variável! Por isso, poder utilizar-se de variáveis dinâmicas quando há multi-métodos é um diferencial que acaba por incrementar a performance de Julia como linguagem de programação visada para o Cálculo Numérico.<br />
<br />
'''Observação:''' é importante ressaltar que os testes feitos não são conclusivos para debater a performance de Julia, em termos estatísticos, e além disso, ser uma linguagem de programação que utiliza de variáveis dinâmicas e multi-métodos não é o único motivo pelo qual Julia poderia trazer tal performance em Cálculo Numérico. Podemos ainda contar com a sua capacidade de '''metaprogramação''', ou seja, Julia pode usar macros e eles são aplicados em tempo de interpretação. Há ainda outros fatores da construção da linguagem que contribuem para sua performance que aqui não foram citados.<br />
<br />
== Aprendendo Julia ==<br />
<br />
'''Ambiente de programação'''<br />
<br />
Após feita a instalação de Julia, para abri-la no seu terminal de comando é preciso apenas digitar: <pre>$julia</pre> para entrar em seu ambiente de programação.<br />
<br />
É possível, também, programar em um arquivo de texto (salvo como .jl) e executar o programa pelo terminal, fazendo simplesmente:<br />
<br />
<pre><br />
$julia programa.jl <br />
</pre><br />
<br />
'''Impressão na tela'''<br />
<pre><br />
println("Hello World")<br />
<br />
Saída:<br />
Hello World<br />
</pre><br />
<br />
'''Variáveis'''<br />
<br />
Variáveis são atribuídas dinamicamente e podem mudar.<br />
<pre><br />
s = 1<br />
s = "Oi"<br />
println(s)<br />
println(typeof(s))<br />
<br />
Saída:<br />
Oi<br />
String<br />
</pre><br />
<br />
<pre><br />
s::String<br />
s = 1<br />
println(s)<br />
<br />
Saída:<br />
TypeError: in typeassert, expected String, got Int32<br />
</pre><br />
<br />
'''Condicionais'''<br />
<pre><br />
cats = 12<br />
if cats < 1<br />
println("You should adopt a cat.")<br />
elseif cats >= 1 && cats <=6<br />
println("Not enough cats.")<br />
elseif cats >= 7 && cats <= 12<br />
println("Still not enough cats.")<br />
else<br />
println("Gato have more cats.")<br />
end<br />
<br />
Saída:<br />
Still not enough cats.<br />
</pre><br />
<br />
<pre><br />
i = 0<br />
while (i < 10)<br />
global i += 1<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
</pre><br />
<br />
<pre><br />
for i = 1:10<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
</pre><br />
<br />
<pre><br />
for i in [1,2,3]<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
</pre><br />
<br />
'''Arrays'''<br />
<pre><br />
# Criando um array de zeros<br />
a1 = zeros()<br />
println(a1)<br />
# Posso definir o tipo e o tamanho do Array (linhas, colunas) também<br />
a1 = zeros(Int32, 1, 4)<br />
println(a1)<br />
<br />
Saída:<br />
0.0<br />
[0 0 0 0]<br />
</pre><br />
<br />
<pre><br />
# Criando um array do tipo inteiro<br />
a2 = Array{Int32}<br />
println(a2)<br />
# Criando um array (de outra maneira) do tipo float<br />
a3 = Float64[]<br />
println(a3)<br />
<br />
Saída:<br />
Array{Int32,N} where N [...]<br />
Float64[]<br />
</pre><br />
<br />
<pre><br />
# Criando um array e definindo valores<br />
a4 = [1,2,3]<br />
#Imprimindo a4<br />
println("Array: ", a4)<br />
<br />
Saída:<br />
Array: [1, 2, 3]<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Imprimindo valor de um indíce específico<br />
println("Imprimindo primeiro elemento: ", a4[1])<br />
# Imprimindo último valor do array<br />
println("Imprimindo último elemento: ",a4[end])<br />
<br />
Saída:<br />
Imprimindo primeiro elemento: 1<br />
Imprimindo último elemento: 3<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
println(a4[2])<br />
# Valores podem mudar (diferente de Tuplas, que veremos adiante)<br />
a4[2] = 4<br />
println(a4[2])<br />
<br />
Saída:<br />
2<br />
4<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
println(a4)<br />
# Número de elementos<br />
println("Imprimindo número de elementos: ",length(a4))<br />
<br />
Saída:<br />
[1, 2, 3]<br />
Imprimindo número de elementos: 3<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Soma os valores do array<br />
println("Imprimindo soma dos elementos: ",sum(a4))<br />
# Põe os valores começando no índice 2<br />
splice!(a4, 2:1, [8,9])<br />
println("Imprimindo Array tendo feito splice!(a4, 2:1, [8,9]): ",a4)<br />
# Remove os itens do índice 2 ao 3<br />
4splice!(a4, 2:3)<br />
println("Imprimindo Array tendo feito splice!(a4, 2:3): ",a4)<br />
<br />
Saída:<br />
Imprimindo soma dos elementos: 6<br />
Imprimindo Array tendo feito splice!(a4, 2:1, [8,9]): [1, 8, 9, 2, 3]<br />
Imprimindo Array tendo feito splice!(a4, 2:3): [1, 2, 3]<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Pegar valor máximo e valor mínimo<br />
println("Imprimindo valor máximo: ",maximum(a4))<br />
println("Imprimindo Array valor mínimo: ",minimum(a4))<br />
# Multiplicando todos os elementos do array por outro número sem precisar de um for<br />
println("Imprimindo multiplicação dos elementos por 2: ",a4 * 2)<br />
<br />
Saída:<br />
Imprimindo valor máximo: 3<br />
Imprimindo Array valor mínimo: 1<br />
Imprimindo multiplicação dos elementos por 2: [2, 4, 6]<br />
</pre><br />
<br />
<pre><br />
# Arrays podem conter funções<br />
a5 = [sin, cos, tan]<br />
for n in a5<br />
println(n(0))<br />
end<br />
<br />
Saída:<br />
0.0<br />
1.0<br />
0.0<br />
</pre><br />
<br />
<pre><br />
# Para os acostumados com range<br />
a6 = collect(1:5)<br />
println(a6)<br />
<br />
Saída:<br />
[1, 2, 3, 4, 5]<br />
</pre><br />
<br />
'''Tuplas'''<br />
<br />
A maioria das funções de array funciona com tuplas.<br />
<pre><br />
# Valores não podem mudar<br />
t1 = (1,2,3,4)<br />
println(t1[2])<br />
t1[2] = 5<br />
println(t1[2])<br />
<br />
Saída:<br />
2<br />
MethodError: no method matching setindex!(::NTuple{4,Int32}, ::Int32, ::Int32)<br />
</pre><br />
<br />
<pre><br />
# Imprimindo a tupla inteira<br />
println(t1)<br />
# Imprimindo a tupla inteira<br />
for i in t1<br />
println(i)<br />
end<br />
<br />
Saída:<br />
(1, 2, 3, 4)<br />
1<br />
2<br />
3<br />
4<br />
</pre><br />
<br />
'''Dicionários'''<br />
<br />
A palavra-chave deve ser única.<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Imprimir um valor<br />
println(d1["pi"])<br />
<br />
Saída:<br />
3.14<br />
</pre><br />
<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Imprimindo todas as palavras-chaves<br />
println(keys(d1))<br />
# Imprimindo todos os valores<br />
println(values(d1))<br />
# Adicionar uma palavra-chave<br />
d1["golden"] = 1.618<br />
# Deleter uma palavra-chave<br />
delete!(d1, "pi")<br />
# Imprimindo todas as palavras-chaves<br />
println(keys(d1))<br />
# Imprimindo todos os valores<br />
println(values(d1))<br />
<br />
Saída:<br />
["pi", "e"]<br />
[3.14, 2.718]<br />
["e", "golden"]<br />
[2.718, 1.618]<br />
</pre><br />
<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Ver se a palavra-chave existe<br />
println(haskey(d1, "pi"))<br />
# Imprimindo palavras-chaves E valores<br />
for kv in d1<br />
println(kv)<br />
end<br />
<br />
Saída:<br />
true<br />
"pi" => 3.14<br />
"e" => 2.718<br />
</pre><br />
<br />
'''Sets'''<br />
<br />
Sets são arrays com elementos únicos.<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
# Ele não pega os elementos repetidos<br />
println(st1)<br />
<br />
Saída:<br />
Set(["Pam", "Jim"])<br />
</pre><br />
<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
# Adicionando um elemento<br />
push!(st1, "Michael")<br />
println(st1)<br />
# Ver se um elemento está no Set<br />
println(in("Dwight", st1))<br />
<br />
Saída:<br />
Set(["Pam", "Michael", "Jim"])<br />
false<br />
</pre><br />
<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
st2 = Set(["Stanley", "Meredith"])<br />
# Combinando Sets<br />
println(union(st1, st2))<br />
# Imprimindo todo o elemento que os dois Sets tem em comum<br />
println(intersect(st1, st2))<br />
# Imprimindo elementos que estão no primeiro Set, mas não no segundo<br />
println(setdiff(st1, st2))<br />
<br />
Saída:<br />
Set(["Jim", "Meredith", "Stanley", "Pam"])<br />
Set(String[])<br />
Set(["Pam", "Jim"])<br />
</pre><br />
<br />
'''Funções'''<br />
<pre><br />
using Printf<br />
# Função de expressão única<br />
soma(x,y) = x + y<br />
x, y = 1, 2<br />
@printf("%d + %d = %d\n", x, y, x+y)<br />
<br />
Saída:<br />
1 + 2 = 3<br />
</pre><br />
<br />
<pre><br />
# Função de múltiplas expressões<br />
function adoptACat(cats)<br />
if cats <= 1<br />
println("You should adopt a cat.")<br />
else<br />
println("You should adopt a cat. They're cute.")<br />
end<br />
end<br />
adoptACat(2)<br />
<br />
Saída:<br />
You should adopt a cat. They're cute.<br />
</pre><br />
<br />
<pre><br />
v1 = 5<br />
function changeV1(v1)<br />
v1 = 10<br />
end<br />
changeV1(v1)<br />
println(v1)<br />
<br />
Saída:<br />
5<br />
</pre><br />
<br />
<pre><br />
v1 = 5<br />
function changeV1(v1)<br />
v1 = 10<br />
return v1<br />
end<br />
changeV1(v1)<br />
println(v1)<br />
v2 = changeV1(v1)<br />
println(v2)<br />
<br />
Saída:<br />
5<br />
10<br />
</pre><br />
<br />
<pre><br />
# Usando variáveis globais dentro da função<br />
v1 = 5<br />
function changeV12()<br />
global v1 = 10<br />
end<br />
changeV12()<br />
println(v1)<br />
<br />
Saída:<br />
10<br />
</pre><br />
<br />
<pre><br />
# Quando não sei quantos argumentos vou passar<br />
function soma(args...)<br />
sum = 0<br />
for i in args<br />
sum += i<br />
end<br />
println(sum)<br />
end<br />
soma(1,2,3)<br />
<br />
Saída:<br />
6<br />
</pre><br />
<br />
<pre><br />
# Retornando mais de um valor<br />
function retorna2(valor)<br />
return (valor + 1, valor + 2)<br />
end<br />
println(retorna2(4))<br />
<br />
Saída:<br />
(5, 6)<br />
</pre><br />
<br />
<pre><br />
# Map é uma função anônima que aplica uma função para cada elemento<br />
v = map(x -> x * x, [1,2,3])<br />
println(v)<br />
<br />
Saída:<br />
[1, 4, 9]<br />
</pre><br />
<br />
'''Structs'''<br />
<pre><br />
struct Estudante<br />
name::String<br />
saldoTRI::Float32<br />
cartaoUFRGS::Int<br />
end<br />
# Criando um objeto<br />
estudante1 = Estudante("Raquel", 10.50, 244449)<br />
println(estudante1.name, "\n", estudante1.saldoTRI, "\n", estudante1.cartaoUFRGS)<br />
<br />
Saída:<br />
Raquel<br />
10.5<br />
244449<br />
</pre><br />
<br />
'''Tipos Abstratos'''<br />
<br />
Tipos abstratos não podem ser instanciados como as Structs (instanciar => fazer estudante1 =<br />
Estudante(“Raquel”, 10.50, 244449) => criar um objeto) MAS podem ter subTipos e isso é muito<br />
útil!<br />
<br />
<pre><br />
abstract type animal end<br />
struct cachorro <: animal<br />
nome::String<br />
latido::String<br />
end<br />
struct gato <: animal<br />
nome::String<br />
miado::String<br />
end<br />
cachorro1 = cachorro("Urso", "Au Au")<br />
gato1 = gato("Lucia Irene", "Miau")<br />
# Criando funções pros subTipos<br />
function fazerSom(animal::cachorro)<br />
println("$(animal.nome) diz $(animal.latido)")<br />
end<br />
function fazerSom(animal::gato)<br />
println("$(animal.nome) diz $(animal.miado)")<br />
end<br />
fazerSom(cachorro1)<br />
fazerSom(gato1)<br />
<br />
Saída: <br />
Urso diz Au Au<br />
Lucia Irene diz Miau<br />
</pre></div>Raquelmhttp://fiscomp.if.ufrgs.br/index.php?title=Julia&diff=2517Julia2020-01-07T15:06:33Z<p>Raquelm: /* Aprendendo Julia */</p>
<hr />
<div>Julia é uma linguagem relativamente nova de programação que começou a ser desenvolvida em 2009 por Jeff Bezanson, Stefan Karpinski, Viral B. Shah, e Alan Edelman, um grupo do MIT. Ela foi oficialmente lançada para o mundo em 2012.<br />
<br />
Em uma entrevista, quando perguntaram a Alan o por quê do nome Julia, ele disse que numa conversa anos atrás alguém sugeriu que Julia seria um bom nome para uma linguagem de programação.<br />
<br />
Julia pode ser usada para propósitos gerais de programação, assim como Python, mas em sua criação foi visada a utilização de Julia para Cálculo Numérico.<br />
<br />
== Aspectos Gerais ==<br />
<br />
Julia é uma linguagem de alto nível, isso significa, de maneira sucinta, que ela não é executada utilizando somente o processador, assim como acontece com linguagens de baixo nível, como Assembly, por exemplo.<br />
<br />
É escrita em C, C++, e Scheme, usando a estrutura do compilador LLVM (para melhor entendimento, o compilador de C é o GCC, por exemplo), enquanto a maior parte da biblioteca padrão de Julia é implementada na própria Julia.<br />
<br />
Um fato importante sobre Julia para os programadores de Python é que todas as bibliotecas de Python são usáveis através de um comando simples: PyCall.<br />
<br />
Um fato importante sobre Julia para os programadores de C é que Julia possui APIs (Interfaces de Programação de Aplicativos) especiais para chamada de funções em C diretamente.<br />
<br />
== Velocidade ==<br />
<br />
De acordo com testes feitos pelos próprios criadores de Julia, sua velocidade é similar com a de C.<br />
<br />
<br />
<center>[[Arquivo:juliasvelocity.png|border]]<br />
Fonte: [https://julialang.org/benchmarks/]<br />
</center><br />
<br />
<br />
== Testes de Velocidade ==<br />
<br />
A fim de pessoalmente testar a velocidade da linguagem de programação, foi escrito um programa em Julia de maneira similar ao programa de Python para o FTCS aplicado na Equação de Difusão (também conhecida como Equação do Calor). <br />
<br />
A Equação da Difusão em uma dimensão pode ser escrita da forma:<br />
<br />
<center><math>\frac{df}{dt}=\frac{d^{2}f}{dx^{2}}</math></center><br />
<br />
No método de FTCS (Forward-Time Central-Space) definimos a derivada em t na forma não simetrizada (forward) e as derivadas em x na forma simetrizada:<br />
<br />
<br />
<center><math>\frac{df}{dt} = \frac{f(x, t+dt) - f(x,t)}{dt}</math></center><br />
<br />
<p><br />
<br />
<center><math>\frac{d^{2}f}{dx^{2}} = \frac{f(x+dx, t) + f(x-dx, t) - 2f(x,t)}{dx^{2}}</math></center><br />
<br />
E substuindo na equação da difusão, em notação discreta temos:<br />
<br />
<center><math>f_{j}^{n+1} = f_{j}^{n} + D\frac{dt}{(dx)^{2}}[f_{j+1}^{n} + f_{j-1}^{n} - 2 f_{j}^{n}]</math></center><br />
<br />
'''Observação:''' esse procedimento funciona bem se <math>k=D\frac{dt}{(dx)^{2}} <= 1/2</math>, segundo análise de estabilidade do método.<br />
<br />
<br />
Dessa forma, foi escrito um programa para integrar a Equação de Difusão através do método de FTCS nas linguagens Python e Julia.<br />
<br />
Para '''Python''':<br />
<pre><br />
# FTCS aplicado na equacao da difusao. Linguagem: PYTHON<br />
<br />
import copy<br />
import numpy as np<br />
import matplotlib.pyplot as plt<br />
<br />
def init():<br />
L=50;D=1.;dt=0.05;dx=1.;t=0;tmax=100.<br />
k=D*dt/(dx*dx) <br />
return L,k,dt,t,tmax<br />
<br />
L,k,dt,t,tmax = init()<br />
<br />
x = np.arange(0,L,1) <br />
f = np.zeros(x.shape)<br />
<br />
a = int(L/3)<br />
b = int(2*L/3)<br />
f[a:b]=1.<br />
f1 = copy.deepcopy(f) <br />
f2 = copy.deepcopy(f)<br />
<br />
while t<tmax:<br />
t+=dt<br />
f1[1:L-1]=f[1:L-1]+k*(f[0:L-2]+f[2:L]-2*f[1:L-1])<br />
f1[L-1]=f[L-1]+k*(f[L-2]+f[0]-2*f[L-1]) <br />
f1[0]=f[0]+k*(f[1]+f[L-1]-2*f[0]) <br />
f=copy.deepcopy(f1) <br />
<br />
sum0=sum(f1)<br />
sum1=sum(f2) <br />
<br />
print("Integral em t=0: %7.4f" % sum0)<br />
print("Integral em tmax: %7.4f" % sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
Em '''Julia''':<br />
<pre><br />
# FTCS aplicado na equacao da difusao. Linguagem: JULIA<br />
<br />
using PyPlot<br />
<br />
L=50<br />
D=1.<br />
dt=0.05<br />
dx=1.<br />
t=0<br />
tmax=100.<br />
k=D*dt/(dx*dx) <br />
<br />
x = collect(0:1:L-1)<br />
f = zeros(L)<br />
f1 = zeros(L)<br />
<br />
a = trunc(Int, L/3) <br />
b = trunc(Int, 2*L/3)<br />
<br />
f[a+1:b] .= 1.<br />
f2 = deepcopy(f)<br />
<br />
while t<tmax<br />
global t+=dt <br />
f1[2:L-1] = f[2:L-1] + k*(f[1:L-2] + f[3:L] - 2*f[2:L-1]) <br />
f1[L] = f[L] + k*(f[L-1] + f[1] - 2*f[L])<br />
f1[1] = f[1] + k*(f[2] + f[L] - 2*f[1]) <br />
global f = deepcopy(f1) <br />
end<br />
<br />
sum0 = sum(f1)<br />
sum1 = sum(f2)<br />
<br />
println("Integral em t=0: ", sum0)<br />
println("Integral em tmax: ", sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
<br />
Foi testado o tempo de execução da parte principal dos dois programas (isto é, sem fazer o gráfico dos resultados), através do timer do terminal, como mostra na próxima figura:<br />
<br />
<center>[[Arquivo:Ftcs_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o método de FTCS aplicado à Equação de Difusão<br />
</center><br />
<br />
É possível perceber, através da figura acima, que o tempo de execução de Python para o FTCS aplicado à Equação de Difusão é menor do que o de Julia. Em razão disso, foi testado um programa simples, como mostra abaixo, que incrementa uma variável 10 vezes, sendo o seu valor inicial 0.<br />
<br />
<br />
<center>[[Arquivo:For.png|border]]<br />
'''Legenda:''' Programa para incrementar o valor de uma variável, nesse caso ''i'', 10 vezes, escrito em Julia e em Python<br />
</center><br />
<br />
E posteriormente, novamente, foi testado o tempo de execução da parte principal dos programas através do terminal:<br />
<br />
<center>[[Arquivo:For_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o programa que incrementa o valor da variável 10 vezes<br />
</center><br />
<br />
É possível perceber que para esse simples programa de incrementação, Python ainda obtém melhor performance do que Julia.<br />
<br />
== Performance de Julia ==<br />
<br />
Tentando entender o que traria tal performance em Cálculo Numérico para Julia, foi chegado à conclusão de que ser uma linguagem que se utilizada de ''variáveis dinâmicas'' e ''multi-métodos'' seria uma das grandes contribuições da linguagem.<br />
<br />
'''Variáveis dinâmicas:'''<br />
<br />
Em Python as variáveis são interpretadas em runtime, ou seja, '''tempo de execução''' => o programa checa toda hora se a variável mudou e isso torna ele mais lento<br />
<br />
'''Variáveis estáticas:'''<br />
<br />
Em C as variáveis são fixas, e isso é visto é em '''tempo de compilação''' => precisa pensar nas variáveis e isso torna o tempo de programação mais lento<br />
<br />
Em Julia isso é basicamente opcional, não é preciso definir as variáveis, mas é possível, e elas podem mudar dinamicamente, em tempo de execução. E ainda, Julia se utiliza de multi-métodos para não ter que lidar com a constante checagem dos tipos das variáveis, como Python faz!<br />
<br />
'''Métodos Únicos'''<br />
<br />
Python => Métodos Únicos (single dispatch)<br />
- Não tenho sobrecarga de funções, eu simplesmente chamo uma função que já está escrita<br />
<br />
'''Multi-métodos'''<br />
<br />
Sobrecarga de funções (C++) => Multi-métodos (multiple dispatch)<br />
- Tenho uma função e dependendo dos parâmetros que eu coloco ao chamá-la, eu chamo uma função ou outra<br />
<br />
'''Exemplo de sobrecarga de funções em Julia:'''<br />
<br />
<pre> <br />
# Dependendo do tipo da minha variável x na chamada da função, será chamada uma função ou outra, mesmo que tenham o mesmo nome<br />
<br />
function printx(x::Float64)<br />
println(x)<br />
end<br />
<br />
function printx(x::String)<br />
println(x)<br />
end<br />
<br />
x="Oi"<br />
<br />
printx(x)<br />
</pre><br />
<br />
== Performance de Julia: na prática ==<br />
Para resumir, temos: <br />
<br />
Python => dynamic (variáveis dinâmicas) single dispatch (métodos únicos)<br />
<br />
C++ => static (variáveis estáticas) multiple dispatch (multi-métodos)<br />
<br />
Julia => dynamic multiple dispatch (''o melhor dos dois mundos!'')<br />
<br />
Na prática, é mostrado abaixo um exemplo da performance de Julia como linguagem de programação em dynamic multiple dispatch. <br />
<br />
O mesmo programa foi escrito em Julia e em C++. <br />
<br />
Em '''Julia''':<br />
<br />
<pre><br />
abstract type Animal end<br />
<br />
struct Cachorro <: Animal<br />
nome::String<br />
end<br />
<br />
struct Gato <: Animal<br />
nome::String<br />
end<br />
<br />
# Função de encontro que recebe tipo genérico de animal<br />
function encontroDeAnimais(a::Animal, b::Animal)<br />
acao = encontro(a,b)<br />
println("$(a.nome) encontra $(b.nome) e $acao")<br />
end<br />
<br />
# Funções de expressão única que recebem diferentes tipos de animais<br />
encontro(a::Cachorro, b::Cachorro) = "cheira" <br />
encontro(a::Cachorro, b::Gato) = "persegue"<br />
encontro(a::Gato, b::Gato) = "lambe"<br />
encontro(a::Gato, b::Cachorro) = "ignora" <br />
<br />
# Instanciando os bichinhos<br />
gato1 = Gato("Luciene Maria")<br />
gato2 = Gato("Mel")<br />
cachorro1 = Cachorro("Batata")<br />
cachorro2 = Cachorro("Snoopy")<br />
<br />
# Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2)<br />
encontroDeAnimais(gato1, cachorro2)<br />
encontroDeAnimais(cachorro1, cachorro2)<br />
</pre><br />
<br />
<br />
Em '''C++''':<br />
<br />
<pre><br />
#include <iostream><br />
using namespace std;<br />
<br />
class Animal { <br />
public:<br />
string nome;<br />
};<br />
<br />
string encontro(Animal a, Animal b) {}<br />
<br />
// Função de encontro que recebe tipo genérico de animal<br />
void encontroDeAnimais(Animal a, Animal b) {<br />
string acao = encontro(a,b);<br />
cout << a.nome << " encontra " << b.nome << " e " << acao << endl;<br />
}<br />
<br />
class Cachorro:public Animal {};<br />
class Gato:public Animal {};<br />
<br />
// Funções de expressão única que recebem diferentes tipos de animais<br />
string encontro(Cachorro a, Cachorro b) { return "cheira"; }<br />
string encontro(Cachorro a, Gato b) { return "persegue"; }<br />
string encontro(Gato a, Gato b) { return "lambe"; }<br />
string encontro(Gato a, Cachorro b) { return "ignora"; }<br />
<br />
int main() {<br />
// Instanciando os bichinhos<br />
Gato gato1; gato1.nome = "Luciene Maria";<br />
Gato gato2; gato2.nome = "Mel";<br />
Cachorro cachorro1; cachorro1.nome = "Batata";<br />
Cachorro cachorro2; cachorro2.nome = "Snoopy";<br />
<br />
// Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2);<br />
encontroDeAnimais(gato1, cachorro2);<br />
encontroDeAnimais(cachorro1, cachorro2);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Para '''Julia''' nós obtemos o seguinte '''resultado''':<br />
<br />
<pre><br />
Luciene Maria encontra Mel e lambe<br />
Luciene Maria encontra Snoopy e ignora<br />
Batata encontra Snoopy e cheira<br />
</pre><br />
<br />
Para '''C++''' o '''resultado''' é:<br />
<br />
<pre><br />
Luciene Maria encontra Mel e<br />
Falha de Segmentação<br />
</pre><br />
<br />
Isso acontece porque C++ não aceita que uma função utilize-se de uma variável sem antes saber qual o tipo dessa variável! Por isso, poder utilizar-se de variáveis dinâmicas quando há multi-métodos é um diferencial que acaba por incrementar a performance de Julia como linguagem de programação visada para o Cálculo Numérico.<br />
<br />
'''Observação:''' é importante ressaltar que os testes feitos não são conclusivos para debater a performance de Julia, em termos estatísticos, e além disso, ser uma linguagem de programação que utiliza de variáveis dinâmicas e multi-métodos não é o único motivo pelo qual Julia poderia trazer tal performance em Cálculo Numérico. Podemos ainda contar com a sua capacidade de '''metaprogramação''', ou seja, Julia pode usar macros e eles são aplicados em tempo de interpretação. Há ainda outros fatores da construção da linguagem que contribuem para sua performance que aqui não foram citados.<br />
<br />
== Aprendendo Julia ==<br />
<br />
'''Ambiente de programação'''<br />
<br />
Após feita a instalação de Julia, para abri-la no seu terminal de comando é preciso apenas digitar: <pre>$julia</pre> para entrar em seu ambiente de programação.<br />
<br />
É possível, também, programar em um arquivo de texto (salvo como .jl) e executar o programa pelo terminal, fazendo simplesmente:<br />
<br />
<pre><br />
$julia programa.jl <br />
</pre><br />
<br />
'''Impressão na tela'''<br />
<pre><br />
println("Hello World")<br />
<br />
Saída:<br />
Hello World<br />
</pre><br />
<br />
'''Variáveis'''<br />
<br />
Variáveis são atribuídas dinamicamente e podem mudar.<br />
<pre><br />
s = 1<br />
s = "Oi"<br />
println(s)<br />
println(typeof(s))<br />
<br />
Saída:<br />
Oi<br />
String<br />
</pre><br />
<br />
<pre><br />
s::String<br />
s = 1<br />
println(s)<br />
<br />
Saída:<br />
TypeError: in typeassert, expected String, got Int32<br />
</pre><br />
<br />
'''Condicionais'''<br />
<pre><br />
cats = 12<br />
if cats < 1<br />
println("You should adopt a cat.")<br />
elseif cats >= 1 && cats <=6<br />
println("Not enough cats.")<br />
elseif cats >= 7 && cats <= 12<br />
println("Still not enough cats.")<br />
else<br />
println("Gato have more cats.")<br />
end<br />
<br />
Saída:<br />
Still not enough cats.<br />
</pre><br />
<br />
<pre><br />
i = 0<br />
while (i < 10)<br />
global i += 1<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
</pre><br />
<br />
<pre><br />
for i = 1:10<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
</pre><br />
<br />
<pre><br />
for i in [1,2,3]<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
</pre><br />
<br />
'''Arrays'''<br />
<pre><br />
# Criando um array de zeros<br />
a1 = zeros()<br />
println(a1)<br />
# Posso definir o tipo e o tamanho do Array (linhas, colunas) também<br />
a1 = zeros(Int32, 1, 4)<br />
println(a1)<br />
<br />
Saída:<br />
0.0<br />
[0 0 0 0]<br />
</pre><br />
<br />
<pre><br />
# Criando um array do tipo inteiro<br />
a2 = Array{Int32}<br />
println(a2)<br />
# Criando um array (de outra maneira) do tipo float<br />
a3 = Float64[]<br />
println(a3)<br />
<br />
Saída:<br />
Array{Int32,N} where N [...]<br />
Float64[]<br />
</pre><br />
<br />
<pre><br />
# Criando um array e definindo valores<br />
a4 = [1,2,3]<br />
#Imprimindo a4<br />
println("Array: ", a4)<br />
<br />
Saída:<br />
Array: [1, 2, 3]<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Imprimindo valor de um indíce específico<br />
println("Imprimindo primeiro elemento: ", a4[1])<br />
# Imprimindo último valor do array<br />
println("Imprimindo último elemento: ",a4[end])<br />
<br />
Saída:<br />
Imprimindo primeiro elemento: 1<br />
Imprimindo último elemento: 3<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
println(a4[2])<br />
# Valores podem mudar (diferente de Tuplas, que veremos adiante)<br />
a4[2] = 4<br />
println(a4[2])<br />
<br />
Saída:<br />
2<br />
4<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
println(a4)<br />
# Número de elementos<br />
println("Imprimindo número de elementos: ",length(a4))<br />
<br />
Saída:<br />
[1, 2, 3]<br />
Imprimindo número de elementos: 3<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Soma os valores do array<br />
println("Imprimindo soma dos elementos: ",sum(a4))<br />
# Põe os valores começando no índice 2<br />
splice!(a4, 2:1, [8,9])<br />
println("Imprimindo Array tendo feito splice!(a4, 2:1, [8,9]): ",a4)<br />
# Remove os itens do índice 2 ao 3<br />
4splice!(a4, 2:3)<br />
println("Imprimindo Array tendo feito splice!(a4, 2:3): ",a4)<br />
<br />
Saída:<br />
Imprimindo soma dos elementos: 6<br />
Imprimindo Array tendo feito splice!(a4, 2:1, [8,9]): [1, 8, 9, 2, 3]<br />
Imprimindo Array tendo feito splice!(a4, 2:3): [1, 2, 3]<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Pegar valor máximo e valor mínimo<br />
println("Imprimindo valor máximo: ",maximum(a4))<br />
println("Imprimindo Array valor mínimo: ",minimum(a4))<br />
# Multiplicando todos os elementos do array por outro número sem precisar de um for<br />
println("Imprimindo multiplicação dos elementos por 2: ",a4 * 2)<br />
<br />
Saída:<br />
Imprimindo valor máximo: 3<br />
Imprimindo Array valor mínimo: 1<br />
Imprimindo multiplicação dos elementos por 2: [2, 4, 6]<br />
</pre><br />
<br />
<pre><br />
# Arrays podem conter funções<br />
a5 = [sin, cos, tan]<br />
for n in a5<br />
println(n(0))<br />
end<br />
<br />
Saída:<br />
0.0<br />
1.0<br />
0.0<br />
</pre><br />
<br />
<pre><br />
# Para os acostumados com range<br />
a6 = collect(1:5)<br />
println(a6)<br />
<br />
Saída:<br />
[1, 2, 3, 4, 5]<br />
</pre><br />
<br />
'''Tuplas'''<br />
<br />
A maioria das funções de array funciona com tuplas.<br />
<pre><br />
# Valores não podem mudar<br />
t1 = (1,2,3,4)<br />
println(t1[2])<br />
t1[2] = 5<br />
println(t1[2])<br />
<br />
Saída:<br />
2<br />
MethodError: no method matching setindex!(::NTuple{4,Int32}, ::Int32, ::Int32)<br />
</pre><br />
<br />
<pre><br />
# Imprimindo a tupla inteira<br />
println(t1)<br />
# Imprimindo a tupla inteira<br />
for i in t1<br />
println(i)<br />
end<br />
<br />
Saída:<br />
(1, 2, 3, 4)<br />
1<br />
2<br />
3<br />
4<br />
</pre><br />
<br />
'''Dicionários'''<br />
<br />
A palavra-chave deve ser única.<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Imprimir um valor<br />
println(d1["pi"])<br />
<br />
Saída:<br />
3.14<br />
</pre><br />
<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Imprimindo todas as palavras-chaves<br />
println(keys(d1))<br />
# Imprimindo todos os valores<br />
println(values(d1))<br />
# Adicionar uma palavra-chave<br />
d1["golden"] = 1.618<br />
# Deleter uma palavra-chave<br />
delete!(d1, "pi")<br />
# Imprimindo todas as palavras-chaves<br />
println(keys(d1))<br />
# Imprimindo todos os valores<br />
println(values(d1))<br />
<br />
Saída:<br />
["pi", "e"]<br />
[3.14, 2.718]<br />
["e", "golden"]<br />
[2.718, 1.618]<br />
</pre><br />
<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Ver se a palavra-chave existe<br />
println(haskey(d1, "pi"))<br />
# Imprimindo palavras-chaves E valores<br />
for kv in d1<br />
println(kv)<br />
end<br />
<br />
Saída:<br />
true<br />
"pi" => 3.14<br />
"e" => 2.718<br />
</pre><br />
<br />
'''Sets'''<br />
<br />
Sets são arrays com elementos únicos.<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
# Ele não pega os elementos repetidos<br />
println(st1)<br />
<br />
Saída:<br />
Set(["Pam", "Jim"])<br />
</pre><br />
<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
# Adicionando um elemento<br />
push!(st1, "Michael")<br />
println(st1)<br />
# Ver se um elemento está no Set<br />
println(in("Dwight", st1))<br />
<br />
Saída:<br />
Set(["Pam", "Michael", "Jim"])<br />
false<br />
</pre><br />
<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
st2 = Set(["Stanley", "Meredith"])<br />
# Combinando Sets<br />
println(union(st1, st2))<br />
# Imprimindo todo o elemento que os dois Sets tem em comum<br />
println(intersect(st1, st2))<br />
# Imprimindo elementos que estão no primeiro Set, mas não no segundo<br />
println(setdiff(st1, st2))<br />
<br />
Saída:<br />
Set(["Jim", "Meredith", "Stanley", "Pam"])<br />
Set(String[])<br />
Set(["Pam", "Jim"])<br />
</pre><br />
<br />
'''Funções'''<br />
<pre><br />
using Printf<br />
# Função de expressão única<br />
soma(x,y) = x + y<br />
x, y = 1, 2<br />
@printf("%d + %d = %d\n", x, y, x+y)<br />
<br />
Saída:<br />
1 + 2 = 3<br />
</pre><br />
<br />
<pre><br />
# Função de múltiplas expressões<br />
function adoptACat(cats)<br />
if cats <= 1<br />
println("You should adopt a cat.")<br />
else<br />
println("You should adopt a cat. They're cute.")<br />
end<br />
end<br />
adoptACat(2)<br />
<br />
Saída:<br />
You should adopt a cat. They're cute.<br />
</pre><br />
<br />
<pre><br />
v1 = 5<br />
function changeV1(v1)<br />
v1 = 10<br />
end<br />
changeV1(v1)<br />
println(v1)<br />
<br />
Saída:<br />
5<br />
</pre><br />
<br />
<pre><br />
v1 = 5<br />
function changeV1(v1)<br />
v1 = 10<br />
return v1<br />
end<br />
changeV1(v1)<br />
println(v1)<br />
v2 = changeV1(v1)<br />
println(v2)<br />
<br />
Saída:<br />
5<br />
10<br />
</pre><br />
<br />
<pre><br />
# Usando variáveis globais dentro da função<br />
v1 = 5<br />
function changeV12()<br />
global v1 = 10<br />
end<br />
changeV12()<br />
println(v1)<br />
<br />
Saída:<br />
10<br />
</pre><br />
<br />
<pre><br />
# Quando não sei quantos argumentos vou passar<br />
function soma(args...)<br />
sum = 0<br />
for i in args<br />
sum += i<br />
end<br />
println(sum)<br />
end<br />
soma(1,2,3)<br />
<br />
Saída:<br />
6<br />
</pre><br />
<br />
<pre><br />
# Retornando mais de um valor<br />
function retorna2(valor)<br />
return (valor + 1, valor + 2)<br />
end<br />
println(retorna2(4))<br />
<br />
Saída:<br />
(5, 6)<br />
</pre><br />
<br />
<pre><br />
# Map é uma função anônima que aplica uma função para cada elemento<br />
v = map(x -> x * x, [1,2,3])<br />
println(v)<br />
<br />
Saída:<br />
[1, 4, 9]<br />
</pre><br />
<br />
'''Structs'''<br />
<pre><br />
struct Estudante<br />
name::String<br />
saldoTRI::Float32<br />
cartaoUFRGS::Int<br />
end<br />
# Criando um objeto<br />
estudante1 = Estudante("Raquel", 10.50, 244449)<br />
println(estudante1.name, "\n", estudante1.saldoTRI, "\n", estudante1.cartaoUFRGS)<br />
<br />
Saída:<br />
Raquel<br />
10.5<br />
244449<br />
9<br />
</pre><br />
<br />
'''Tipos Abstratos'''<br />
<br />
Tipos abstratos não podem ser instanciados como as Structs (instanciar => fazer estudante1 =<br />
Estudante(“Raquel”, 10.50, 244449) => criar um objeto) MAS podem ter subTipos e isso é muito<br />
útil!<br />
<br />
<pre><br />
abstract type animal end<br />
struct cachorro <: animal<br />
nome::String<br />
latido::String<br />
end<br />
struct gato <: animal<br />
nome::String<br />
miado::String<br />
end<br />
cachorro1 = cachorro("Urso", "Au Au")<br />
gato1 = gato("Lucia Irene", "Miau")<br />
# Criando funções pros subTipos<br />
function fazerSom(animal::cachorro)<br />
println("$(animal.nome) diz $(animal.latido)")<br />
end<br />
function fazerSom(animal::gato)<br />
println("$(animal.nome) diz $(animal.miado)")<br />
end<br />
fazerSom(cachorro1)<br />
fazerSom(gato1)<br />
<br />
Saída: <br />
Urso diz Au Au<br />
Lucia Irene diz Miau<br />
</pre></div>Raquelmhttp://fiscomp.if.ufrgs.br/index.php?title=Julia&diff=2516Julia2020-01-07T15:03:33Z<p>Raquelm: /* Aprendendo Julia */</p>
<hr />
<div>Julia é uma linguagem relativamente nova de programação que começou a ser desenvolvida em 2009 por Jeff Bezanson, Stefan Karpinski, Viral B. Shah, e Alan Edelman, um grupo do MIT. Ela foi oficialmente lançada para o mundo em 2012.<br />
<br />
Em uma entrevista, quando perguntaram a Alan o por quê do nome Julia, ele disse que numa conversa anos atrás alguém sugeriu que Julia seria um bom nome para uma linguagem de programação.<br />
<br />
Julia pode ser usada para propósitos gerais de programação, assim como Python, mas em sua criação foi visada a utilização de Julia para Cálculo Numérico.<br />
<br />
== Aspectos Gerais ==<br />
<br />
Julia é uma linguagem de alto nível, isso significa, de maneira sucinta, que ela não é executada utilizando somente o processador, assim como acontece com linguagens de baixo nível, como Assembly, por exemplo.<br />
<br />
É escrita em C, C++, e Scheme, usando a estrutura do compilador LLVM (para melhor entendimento, o compilador de C é o GCC, por exemplo), enquanto a maior parte da biblioteca padrão de Julia é implementada na própria Julia.<br />
<br />
Um fato importante sobre Julia para os programadores de Python é que todas as bibliotecas de Python são usáveis através de um comando simples: PyCall.<br />
<br />
Um fato importante sobre Julia para os programadores de C é que Julia possui APIs (Interfaces de Programação de Aplicativos) especiais para chamada de funções em C diretamente.<br />
<br />
== Velocidade ==<br />
<br />
De acordo com testes feitos pelos próprios criadores de Julia, sua velocidade é similar com a de C.<br />
<br />
<br />
<center>[[Arquivo:juliasvelocity.png|border]]<br />
Fonte: [https://julialang.org/benchmarks/]<br />
</center><br />
<br />
<br />
== Testes de Velocidade ==<br />
<br />
A fim de pessoalmente testar a velocidade da linguagem de programação, foi escrito um programa em Julia de maneira similar ao programa de Python para o FTCS aplicado na Equação de Difusão (também conhecida como Equação do Calor). <br />
<br />
A Equação da Difusão em uma dimensão pode ser escrita da forma:<br />
<br />
<center><math>\frac{df}{dt}=\frac{d^{2}f}{dx^{2}}</math></center><br />
<br />
No método de FTCS (Forward-Time Central-Space) definimos a derivada em t na forma não simetrizada (forward) e as derivadas em x na forma simetrizada:<br />
<br />
<br />
<center><math>\frac{df}{dt} = \frac{f(x, t+dt) - f(x,t)}{dt}</math></center><br />
<br />
<p><br />
<br />
<center><math>\frac{d^{2}f}{dx^{2}} = \frac{f(x+dx, t) + f(x-dx, t) - 2f(x,t)}{dx^{2}}</math></center><br />
<br />
E substuindo na equação da difusão, em notação discreta temos:<br />
<br />
<center><math>f_{j}^{n+1} = f_{j}^{n} + D\frac{dt}{(dx)^{2}}[f_{j+1}^{n} + f_{j-1}^{n} - 2 f_{j}^{n}]</math></center><br />
<br />
'''Observação:''' esse procedimento funciona bem se <math>k=D\frac{dt}{(dx)^{2}} <= 1/2</math>, segundo análise de estabilidade do método.<br />
<br />
<br />
Dessa forma, foi escrito um programa para integrar a Equação de Difusão através do método de FTCS nas linguagens Python e Julia.<br />
<br />
Para '''Python''':<br />
<pre><br />
# FTCS aplicado na equacao da difusao. Linguagem: PYTHON<br />
<br />
import copy<br />
import numpy as np<br />
import matplotlib.pyplot as plt<br />
<br />
def init():<br />
L=50;D=1.;dt=0.05;dx=1.;t=0;tmax=100.<br />
k=D*dt/(dx*dx) <br />
return L,k,dt,t,tmax<br />
<br />
L,k,dt,t,tmax = init()<br />
<br />
x = np.arange(0,L,1) <br />
f = np.zeros(x.shape)<br />
<br />
a = int(L/3)<br />
b = int(2*L/3)<br />
f[a:b]=1.<br />
f1 = copy.deepcopy(f) <br />
f2 = copy.deepcopy(f)<br />
<br />
while t<tmax:<br />
t+=dt<br />
f1[1:L-1]=f[1:L-1]+k*(f[0:L-2]+f[2:L]-2*f[1:L-1])<br />
f1[L-1]=f[L-1]+k*(f[L-2]+f[0]-2*f[L-1]) <br />
f1[0]=f[0]+k*(f[1]+f[L-1]-2*f[0]) <br />
f=copy.deepcopy(f1) <br />
<br />
sum0=sum(f1)<br />
sum1=sum(f2) <br />
<br />
print("Integral em t=0: %7.4f" % sum0)<br />
print("Integral em tmax: %7.4f" % sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
Em '''Julia''':<br />
<pre><br />
# FTCS aplicado na equacao da difusao. Linguagem: JULIA<br />
<br />
using PyPlot<br />
<br />
L=50<br />
D=1.<br />
dt=0.05<br />
dx=1.<br />
t=0<br />
tmax=100.<br />
k=D*dt/(dx*dx) <br />
<br />
x = collect(0:1:L-1)<br />
f = zeros(L)<br />
f1 = zeros(L)<br />
<br />
a = trunc(Int, L/3) <br />
b = trunc(Int, 2*L/3)<br />
<br />
f[a+1:b] .= 1.<br />
f2 = deepcopy(f)<br />
<br />
while t<tmax<br />
global t+=dt <br />
f1[2:L-1] = f[2:L-1] + k*(f[1:L-2] + f[3:L] - 2*f[2:L-1]) <br />
f1[L] = f[L] + k*(f[L-1] + f[1] - 2*f[L])<br />
f1[1] = f[1] + k*(f[2] + f[L] - 2*f[1]) <br />
global f = deepcopy(f1) <br />
end<br />
<br />
sum0 = sum(f1)<br />
sum1 = sum(f2)<br />
<br />
println("Integral em t=0: ", sum0)<br />
println("Integral em tmax: ", sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
<br />
Foi testado o tempo de execução da parte principal dos dois programas (isto é, sem fazer o gráfico dos resultados), através do timer do terminal, como mostra na próxima figura:<br />
<br />
<center>[[Arquivo:Ftcs_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o método de FTCS aplicado à Equação de Difusão<br />
</center><br />
<br />
É possível perceber, através da figura acima, que o tempo de execução de Python para o FTCS aplicado à Equação de Difusão é menor do que o de Julia. Em razão disso, foi testado um programa simples, como mostra abaixo, que incrementa uma variável 10 vezes, sendo o seu valor inicial 0.<br />
<br />
<br />
<center>[[Arquivo:For.png|border]]<br />
'''Legenda:''' Programa para incrementar o valor de uma variável, nesse caso ''i'', 10 vezes, escrito em Julia e em Python<br />
</center><br />
<br />
E posteriormente, novamente, foi testado o tempo de execução da parte principal dos programas através do terminal:<br />
<br />
<center>[[Arquivo:For_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o programa que incrementa o valor da variável 10 vezes<br />
</center><br />
<br />
É possível perceber que para esse simples programa de incrementação, Python ainda obtém melhor performance do que Julia.<br />
<br />
== Performance de Julia ==<br />
<br />
Tentando entender o que traria tal performance em Cálculo Numérico para Julia, foi chegado à conclusão de que ser uma linguagem que se utilizada de ''variáveis dinâmicas'' e ''multi-métodos'' seria uma das grandes contribuições da linguagem.<br />
<br />
'''Variáveis dinâmicas:'''<br />
<br />
Em Python as variáveis são interpretadas em runtime, ou seja, '''tempo de execução''' => o programa checa toda hora se a variável mudou e isso torna ele mais lento<br />
<br />
'''Variáveis estáticas:'''<br />
<br />
Em C as variáveis são fixas, e isso é visto é em '''tempo de compilação''' => precisa pensar nas variáveis e isso torna o tempo de programação mais lento<br />
<br />
Em Julia isso é basicamente opcional, não é preciso definir as variáveis, mas é possível, e elas podem mudar dinamicamente, em tempo de execução. E ainda, Julia se utiliza de multi-métodos para não ter que lidar com a constante checagem dos tipos das variáveis, como Python faz!<br />
<br />
'''Métodos Únicos'''<br />
<br />
Python => Métodos Únicos (single dispatch)<br />
- Não tenho sobrecarga de funções, eu simplesmente chamo uma função que já está escrita<br />
<br />
'''Multi-métodos'''<br />
<br />
Sobrecarga de funções (C++) => Multi-métodos (multiple dispatch)<br />
- Tenho uma função e dependendo dos parâmetros que eu coloco ao chamá-la, eu chamo uma função ou outra<br />
<br />
'''Exemplo de sobrecarga de funções em Julia:'''<br />
<br />
<pre> <br />
# Dependendo do tipo da minha variável x na chamada da função, será chamada uma função ou outra, mesmo que tenham o mesmo nome<br />
<br />
function printx(x::Float64)<br />
println(x)<br />
end<br />
<br />
function printx(x::String)<br />
println(x)<br />
end<br />
<br />
x="Oi"<br />
<br />
printx(x)<br />
</pre><br />
<br />
== Performance de Julia: na prática ==<br />
Para resumir, temos: <br />
<br />
Python => dynamic (variáveis dinâmicas) single dispatch (métodos únicos)<br />
<br />
C++ => static (variáveis estáticas) multiple dispatch (multi-métodos)<br />
<br />
Julia => dynamic multiple dispatch (''o melhor dos dois mundos!'')<br />
<br />
Na prática, é mostrado abaixo um exemplo da performance de Julia como linguagem de programação em dynamic multiple dispatch. <br />
<br />
O mesmo programa foi escrito em Julia e em C++. <br />
<br />
Em '''Julia''':<br />
<br />
<pre><br />
abstract type Animal end<br />
<br />
struct Cachorro <: Animal<br />
nome::String<br />
end<br />
<br />
struct Gato <: Animal<br />
nome::String<br />
end<br />
<br />
# Função de encontro que recebe tipo genérico de animal<br />
function encontroDeAnimais(a::Animal, b::Animal)<br />
acao = encontro(a,b)<br />
println("$(a.nome) encontra $(b.nome) e $acao")<br />
end<br />
<br />
# Funções de expressão única que recebem diferentes tipos de animais<br />
encontro(a::Cachorro, b::Cachorro) = "cheira" <br />
encontro(a::Cachorro, b::Gato) = "persegue"<br />
encontro(a::Gato, b::Gato) = "lambe"<br />
encontro(a::Gato, b::Cachorro) = "ignora" <br />
<br />
# Instanciando os bichinhos<br />
gato1 = Gato("Luciene Maria")<br />
gato2 = Gato("Mel")<br />
cachorro1 = Cachorro("Batata")<br />
cachorro2 = Cachorro("Snoopy")<br />
<br />
# Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2)<br />
encontroDeAnimais(gato1, cachorro2)<br />
encontroDeAnimais(cachorro1, cachorro2)<br />
</pre><br />
<br />
<br />
Em '''C++''':<br />
<br />
<pre><br />
#include <iostream><br />
using namespace std;<br />
<br />
class Animal { <br />
public:<br />
string nome;<br />
};<br />
<br />
string encontro(Animal a, Animal b) {}<br />
<br />
// Função de encontro que recebe tipo genérico de animal<br />
void encontroDeAnimais(Animal a, Animal b) {<br />
string acao = encontro(a,b);<br />
cout << a.nome << " encontra " << b.nome << " e " << acao << endl;<br />
}<br />
<br />
class Cachorro:public Animal {};<br />
class Gato:public Animal {};<br />
<br />
// Funções de expressão única que recebem diferentes tipos de animais<br />
string encontro(Cachorro a, Cachorro b) { return "cheira"; }<br />
string encontro(Cachorro a, Gato b) { return "persegue"; }<br />
string encontro(Gato a, Gato b) { return "lambe"; }<br />
string encontro(Gato a, Cachorro b) { return "ignora"; }<br />
<br />
int main() {<br />
// Instanciando os bichinhos<br />
Gato gato1; gato1.nome = "Luciene Maria";<br />
Gato gato2; gato2.nome = "Mel";<br />
Cachorro cachorro1; cachorro1.nome = "Batata";<br />
Cachorro cachorro2; cachorro2.nome = "Snoopy";<br />
<br />
// Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2);<br />
encontroDeAnimais(gato1, cachorro2);<br />
encontroDeAnimais(cachorro1, cachorro2);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Para '''Julia''' nós obtemos o seguinte '''resultado''':<br />
<br />
<pre><br />
Luciene Maria encontra Mel e lambe<br />
Luciene Maria encontra Snoopy e ignora<br />
Batata encontra Snoopy e cheira<br />
</pre><br />
<br />
Para '''C++''' o '''resultado''' é:<br />
<br />
<pre><br />
Luciene Maria encontra Mel e<br />
Falha de Segmentação<br />
</pre><br />
<br />
Isso acontece porque C++ não aceita que uma função utilize-se de uma variável sem antes saber qual o tipo dessa variável! Por isso, poder utilizar-se de variáveis dinâmicas quando há multi-métodos é um diferencial que acaba por incrementar a performance de Julia como linguagem de programação visada para o Cálculo Numérico.<br />
<br />
'''Observação:''' é importante ressaltar que os testes feitos não são conclusivos para debater a performance de Julia, em termos estatísticos, e além disso, ser uma linguagem de programação que utiliza de variáveis dinâmicas e multi-métodos não é o único motivo pelo qual Julia poderia trazer tal performance em Cálculo Numérico. Podemos ainda contar com a sua capacidade de '''metaprogramação''', ou seja, Julia pode usar macros e eles são aplicados em tempo de interpretação. Há ainda outros fatores da construção da linguagem que contribuem para sua performance que aqui não foram citados.<br />
<br />
== Aprendendo Julia ==<br />
<br />
'''Ambiente de programação'''<br />
<br />
Após feita a instalação de Julia, para abri-la no seu terminal de comando é preciso apenas digitar: <pre>$julia</pre> para entrar em seu ambiente de programação.<br />
<br />
É possível, também, programar em um arquivo de texto (salvo como .jl) e executar o programa pelo terminal, fazendo simplesmente:<br />
<br />
<pre><br />
$julia programa.jl <br />
</pre><br />
<br />
'''Impressão na tela'''<br />
<pre><br />
println("Hello World")<br />
<br />
Saída:<br />
Hello World<br />
</pre><br />
<br />
'''Variáveis'''<br />
<br />
Variáveis são atribuídas dinamicamente e podem mudar.<br />
<pre><br />
s = 1<br />
s = "Oi"<br />
println(s)<br />
println(typeof(s))<br />
<br />
Saída:<br />
Oi<br />
String<br />
</pre><br />
<br />
<pre><br />
s::String<br />
s = 1<br />
println(s)<br />
<br />
Saída:<br />
TypeError: in typeassert, expected String, got Int32<br />
</pre><br />
<br />
'''Condicionais'''<br />
<pre><br />
cats = 12<br />
if cats < 1<br />
println("You should adopt a cat.")<br />
elseif cats >= 1 && cats <=6<br />
println("Not enough cats.")<br />
elseif cats >= 7 && cats <= 12<br />
println("Still not enough cats.")<br />
else<br />
println("Gato have more cats.")<br />
end<br />
<br />
Saída:<br />
Still not enough cats.<br />
</pre><br />
<br />
<pre><br />
i = 0<br />
while (i < 10)<br />
global i += 1<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
</pre><br />
<br />
<pre><br />
for i = 1:10<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
</pre><br />
<br />
<pre><br />
for i in [1,2,3]<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
</pre><br />
<br />
'''Arrays'''<br />
<pre><br />
# Criando um array de zeros<br />
a1 = zeros()<br />
println(a1)<br />
# Posso definir o tipo e o tamanho do Array (linhas, colunas) também<br />
a1 = zeros(Int32, 1, 4)<br />
println(a1)<br />
<br />
Saída:<br />
0.0<br />
[0 0 0 0]<br />
</pre><br />
<br />
<pre><br />
# Criando um array do tipo inteiro<br />
a2 = Array{Int32}<br />
println(a2)<br />
# Criando um array (de outra maneira) do tipo float<br />
a3 = Float64[]<br />
println(a3)<br />
<br />
Saída:<br />
Array{Int32,N} where N [...]<br />
Float64[]<br />
</pre><br />
<br />
<pre><br />
# Criando um array e definindo valores<br />
a4 = [1,2,3]<br />
#Imprimindo a4<br />
println("Array: ", a4)<br />
<br />
Saída:<br />
Array: [1, 2, 3]<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Imprimindo valor de um indíce específico<br />
println("Imprimindo primeiro elemento: ", a4[1])<br />
# Imprimindo último valor do array<br />
println("Imprimindo último elemento: ",a4[end])<br />
<br />
Saída:<br />
Imprimindo primeiro elemento: 1<br />
Imprimindo último elemento: 3<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
println(a4[2])<br />
# Valores podem mudar (diferente de Tuplas, que veremos adiante)<br />
a4[2] = 4<br />
println(a4[2])<br />
<br />
Saída:<br />
2<br />
4<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
println(a4)<br />
# Número de elementos<br />
println("Imprimindo número de elementos: ",length(a4))<br />
<br />
Saída:<br />
[1, 2, 3]<br />
Imprimindo número de elementos: 3<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Soma os valores do array<br />
println("Imprimindo soma dos elementos: ",sum(a4))<br />
# Põe os valores começando no índice 2<br />
splice!(a4, 2:1, [8,9])<br />
println("Imprimindo Array tendo feito splice!(a4, 2:1, [8,9]): ",a4)<br />
# Remove os itens do índice 2 ao 3<br />
4splice!(a4, 2:3)<br />
println("Imprimindo Array tendo feito splice!(a4, 2:3): ",a4)<br />
<br />
Saída:<br />
Imprimindo soma dos elementos: 6<br />
Imprimindo Array tendo feito splice!(a4, 2:1, [8,9]): [1, 8, 9, 2, 3]<br />
Imprimindo Array tendo feito splice!(a4, 2:3): [1, 2, 3]<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Pegar valor máximo e valor mínimo<br />
println("Imprimindo valor máximo: ",maximum(a4))<br />
println("Imprimindo Array valor mínimo: ",minimum(a4))<br />
# Multiplicando todos os elementos do array por outro número sem precisar de um for<br />
println("Imprimindo multiplicação dos elementos por 2: ",a4 * 2)<br />
<br />
Saída:<br />
Imprimindo valor máximo: 3<br />
Imprimindo Array valor mínimo: 1<br />
Imprimindo multiplicação dos elementos por 2: [2, 4, 6]<br />
</pre><br />
<br />
<pre><br />
# Arrays podem conter funções<br />
a5 = [sin, cos, tan]<br />
for n in a5<br />
println(n(0))<br />
end<br />
<br />
Saída:<br />
0.0<br />
1.0<br />
0.0<br />
</pre><br />
<br />
<pre><br />
# Para os acostumados com range<br />
a6 = collect(1:5)<br />
println(a6)<br />
<br />
Saída:<br />
[1, 2, 3, 4, 5]<br />
</pre><br />
<br />
'''Tuplas'''<br />
<br />
A maioria das funções de array funciona com tuplas.<br />
<pre><br />
# Valores não podem mudar<br />
t1 = (1,2,3,4)<br />
println(t1[2])<br />
t1[2] = 5<br />
println(t1[2])<br />
<br />
Saída:<br />
2<br />
MethodError: no method matching setindex!(::NTuple{4,Int32}, ::Int32, ::Int32)<br />
</pre><br />
<br />
<pre><br />
# Imprimindo a tupla inteira<br />
println(t1)<br />
# Imprimindo a tupla inteira<br />
for i in t1<br />
println(i)<br />
end<br />
<br />
Saída:<br />
(1, 2, 3, 4)<br />
1<br />
2<br />
3<br />
4<br />
</pre><br />
<br />
'''Dicionários'''<br />
<br />
A palavra-chave deve ser única.<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Imprimir um valor<br />
println(d1["pi"])<br />
<br />
Saída:<br />
3.14<br />
</pre><br />
<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Imprimindo todas as palavras-chaves<br />
println(keys(d1))<br />
# Imprimindo todos os valores<br />
println(values(d1))<br />
# Adicionar uma palavra-chave<br />
d1["golden"] = 1.618<br />
# Deleter uma palavra-chave<br />
delete!(d1, "pi")<br />
# Imprimindo todas as palavras-chaves<br />
println(keys(d1))<br />
# Imprimindo todos os valores<br />
println(values(d1))<br />
<br />
Saída:<br />
["pi", "e"]<br />
[3.14, 2.718]<br />
["e", "golden"]<br />
[2.718, 1.618]<br />
</pre><br />
<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Ver se a palavra-chave existe<br />
println(haskey(d1, "pi"))<br />
# Imprimindo palavras-chaves E valores<br />
for kv in d1<br />
println(kv)<br />
end<br />
<br />
Saída:<br />
true<br />
"pi" => 3.14<br />
"e" => 2.718<br />
</pre><br />
<br />
'''Sets'''<br />
<br />
Sets são arrays com elementos únicos.<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
# Ele não pega os elementos repetidos<br />
println(st1)<br />
<br />
Saída:<br />
Set(["Pam", "Jim"])<br />
</pre><br />
<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
# Adicionando um elemento<br />
push!(st1, "Michael")<br />
println(st1)<br />
# Ver se um elemento está no Set<br />
println(in("Dwight", st1))<br />
<br />
Saída:<br />
Set(["Pam", "Michael", "Jim"])<br />
false<br />
</pre><br />
<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
st2 = Set(["Stanley", "Meredith"])<br />
# Combinando Sets<br />
println(union(st1, st2))<br />
# Imprimindo todo o elemento que os dois Sets tem em comum<br />
println(intersect(st1, st2))<br />
# Imprimindo elementos que estão no primeiro Set, mas não no segundo<br />
println(setdiff(st1, st2))<br />
<br />
Saída:<br />
Set(["Jim", "Meredith", "Stanley", "Pam"])<br />
Set(String[])<br />
Set(["Pam", "Jim"])<br />
</pre><br />
<br />
'''Funções'''<br />
<pre><br />
using Printf<br />
# Função de expressão única<br />
soma(x,y) = x + y<br />
x, y = 1, 2<br />
@printf("%d + %d = %d\n", x, y, x+y)<br />
<br />
Saída:<br />
1 + 2 = 3<br />
</pre><br />
<br />
<pre><br />
# Função de múltiplas expressões<br />
function adoptACat(cats)<br />
if cats <= 1<br />
println("You should adopt a cat.")<br />
else<br />
println("You should adopt a cat. They're cute.")<br />
end<br />
end<br />
adoptACat(2)<br />
<br />
Saída:<br />
You should adopt a cat. They're cute.<br />
</pre><br />
<br />
<pre><br />
v1 = 5<br />
function changeV1(v1)<br />
v1 = 10<br />
end<br />
changeV1(v1)<br />
println(v1)<br />
<br />
Saída:<br />
5<br />
</pre><br />
<br />
<pre><br />
v1 = 5<br />
function changeV1(v1)<br />
v1 = 10<br />
return v1<br />
end<br />
changeV1(v1)<br />
println(v1)<br />
v2 = changeV1(v1)<br />
println(v2)<br />
<br />
Saída:<br />
5<br />
10<br />
</pre><br />
<br />
<pre><br />
# Usando variáveis globais dentro da função<br />
v1 = 5<br />
function changeV12()<br />
global v1 = 10<br />
end<br />
changeV12()<br />
println(v1)<br />
<br />
Saída:<br />
10<br />
</pre><br />
<br />
<pre><br />
# Quando não sei quantos argumentos vou passar<br />
function soma(args...)<br />
sum = 0<br />
for i in args<br />
sum += i<br />
end<br />
println(sum)<br />
end<br />
soma(1,2,3)<br />
<br />
Saída:<br />
6<br />
</pre><br />
<br />
<pre><br />
# Retornando mais de um valor<br />
function retorna2(valor)<br />
return (valor + 1, valor + 2)<br />
end<br />
println(retorna2(4))<br />
<br />
Saída:<br />
(5, 6)<br />
</pre><br />
<br />
<pre><br />
# Map é uma função anônima que aplica uma função para cada elemento<br />
v = map(x -> x * x, [1,2,3])<br />
println(v)<br />
<br />
Saída:<br />
[1, 4, 9]<br />
<br />
'''Structs'''<br />
<pre><br />
struct Estudante<br />
name::String<br />
saldoTRI::Float32<br />
cartaoUFRGS::Int<br />
end<br />
# Criando um objeto<br />
estudante1 = Estudante("Raquel", 10.50, 244449)<br />
println(estudante1.name, "\n", estudante1.saldoTRI, "\n", estudante1.cartaoUFRGS)<br />
<br />
Saída:<br />
Raquel<br />
10.5<br />
244449<br />
9<br />
</pre><br />
<br />
'''Tipos Abstratos'''<br />
<br />
Tipos abstratos não podem ser instanciados como as Structs (instanciar => fazer estudante1 =<br />
Estudante(“Raquel”, 10.50, 244449) => criar um objeto) MAS podem ter subTipos e isso é muito<br />
útil!<br />
<br />
<pre><br />
abstract type animal end<br />
struct cachorro <: animal<br />
nome::String<br />
latido::String<br />
end<br />
struct gato <: animal<br />
nome::String<br />
miado::String<br />
end<br />
cachorro1 = cachorro("Urso", "Au Au")<br />
gato1 = gato("Lucia Irene", "Miau")<br />
# Criando funções pros subTipos<br />
function fazerSom(animal::cachorro)<br />
println("$(animal.nome) diz $(animal.latido)")<br />
end<br />
function fazerSom(animal::gato)<br />
println("$(animal.nome) diz $(animal.miado)")<br />
end<br />
fazerSom(cachorro1)<br />
fazerSom(gato1)<br />
<br />
Saída: <br />
Urso diz Au Au<br />
Lucia Irene diz Miau<br />
</pre></div>Raquelmhttp://fiscomp.if.ufrgs.br/index.php?title=Julia&diff=2515Julia2020-01-07T15:00:56Z<p>Raquelm: /* Aprendendo Julia */</p>
<hr />
<div>Julia é uma linguagem relativamente nova de programação que começou a ser desenvolvida em 2009 por Jeff Bezanson, Stefan Karpinski, Viral B. Shah, e Alan Edelman, um grupo do MIT. Ela foi oficialmente lançada para o mundo em 2012.<br />
<br />
Em uma entrevista, quando perguntaram a Alan o por quê do nome Julia, ele disse que numa conversa anos atrás alguém sugeriu que Julia seria um bom nome para uma linguagem de programação.<br />
<br />
Julia pode ser usada para propósitos gerais de programação, assim como Python, mas em sua criação foi visada a utilização de Julia para Cálculo Numérico.<br />
<br />
== Aspectos Gerais ==<br />
<br />
Julia é uma linguagem de alto nível, isso significa, de maneira sucinta, que ela não é executada utilizando somente o processador, assim como acontece com linguagens de baixo nível, como Assembly, por exemplo.<br />
<br />
É escrita em C, C++, e Scheme, usando a estrutura do compilador LLVM (para melhor entendimento, o compilador de C é o GCC, por exemplo), enquanto a maior parte da biblioteca padrão de Julia é implementada na própria Julia.<br />
<br />
Um fato importante sobre Julia para os programadores de Python é que todas as bibliotecas de Python são usáveis através de um comando simples: PyCall.<br />
<br />
Um fato importante sobre Julia para os programadores de C é que Julia possui APIs (Interfaces de Programação de Aplicativos) especiais para chamada de funções em C diretamente.<br />
<br />
== Velocidade ==<br />
<br />
De acordo com testes feitos pelos próprios criadores de Julia, sua velocidade é similar com a de C.<br />
<br />
<br />
<center>[[Arquivo:juliasvelocity.png|border]]<br />
Fonte: [https://julialang.org/benchmarks/]<br />
</center><br />
<br />
<br />
== Testes de Velocidade ==<br />
<br />
A fim de pessoalmente testar a velocidade da linguagem de programação, foi escrito um programa em Julia de maneira similar ao programa de Python para o FTCS aplicado na Equação de Difusão (também conhecida como Equação do Calor). <br />
<br />
A Equação da Difusão em uma dimensão pode ser escrita da forma:<br />
<br />
<center><math>\frac{df}{dt}=\frac{d^{2}f}{dx^{2}}</math></center><br />
<br />
No método de FTCS (Forward-Time Central-Space) definimos a derivada em t na forma não simetrizada (forward) e as derivadas em x na forma simetrizada:<br />
<br />
<br />
<center><math>\frac{df}{dt} = \frac{f(x, t+dt) - f(x,t)}{dt}</math></center><br />
<br />
<p><br />
<br />
<center><math>\frac{d^{2}f}{dx^{2}} = \frac{f(x+dx, t) + f(x-dx, t) - 2f(x,t)}{dx^{2}}</math></center><br />
<br />
E substuindo na equação da difusão, em notação discreta temos:<br />
<br />
<center><math>f_{j}^{n+1} = f_{j}^{n} + D\frac{dt}{(dx)^{2}}[f_{j+1}^{n} + f_{j-1}^{n} - 2 f_{j}^{n}]</math></center><br />
<br />
'''Observação:''' esse procedimento funciona bem se <math>k=D\frac{dt}{(dx)^{2}} <= 1/2</math>, segundo análise de estabilidade do método.<br />
<br />
<br />
Dessa forma, foi escrito um programa para integrar a Equação de Difusão através do método de FTCS nas linguagens Python e Julia.<br />
<br />
Para '''Python''':<br />
<pre><br />
# FTCS aplicado na equacao da difusao. Linguagem: PYTHON<br />
<br />
import copy<br />
import numpy as np<br />
import matplotlib.pyplot as plt<br />
<br />
def init():<br />
L=50;D=1.;dt=0.05;dx=1.;t=0;tmax=100.<br />
k=D*dt/(dx*dx) <br />
return L,k,dt,t,tmax<br />
<br />
L,k,dt,t,tmax = init()<br />
<br />
x = np.arange(0,L,1) <br />
f = np.zeros(x.shape)<br />
<br />
a = int(L/3)<br />
b = int(2*L/3)<br />
f[a:b]=1.<br />
f1 = copy.deepcopy(f) <br />
f2 = copy.deepcopy(f)<br />
<br />
while t<tmax:<br />
t+=dt<br />
f1[1:L-1]=f[1:L-1]+k*(f[0:L-2]+f[2:L]-2*f[1:L-1])<br />
f1[L-1]=f[L-1]+k*(f[L-2]+f[0]-2*f[L-1]) <br />
f1[0]=f[0]+k*(f[1]+f[L-1]-2*f[0]) <br />
f=copy.deepcopy(f1) <br />
<br />
sum0=sum(f1)<br />
sum1=sum(f2) <br />
<br />
print("Integral em t=0: %7.4f" % sum0)<br />
print("Integral em tmax: %7.4f" % sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
Em '''Julia''':<br />
<pre><br />
# FTCS aplicado na equacao da difusao. Linguagem: JULIA<br />
<br />
using PyPlot<br />
<br />
L=50<br />
D=1.<br />
dt=0.05<br />
dx=1.<br />
t=0<br />
tmax=100.<br />
k=D*dt/(dx*dx) <br />
<br />
x = collect(0:1:L-1)<br />
f = zeros(L)<br />
f1 = zeros(L)<br />
<br />
a = trunc(Int, L/3) <br />
b = trunc(Int, 2*L/3)<br />
<br />
f[a+1:b] .= 1.<br />
f2 = deepcopy(f)<br />
<br />
while t<tmax<br />
global t+=dt <br />
f1[2:L-1] = f[2:L-1] + k*(f[1:L-2] + f[3:L] - 2*f[2:L-1]) <br />
f1[L] = f[L] + k*(f[L-1] + f[1] - 2*f[L])<br />
f1[1] = f[1] + k*(f[2] + f[L] - 2*f[1]) <br />
global f = deepcopy(f1) <br />
end<br />
<br />
sum0 = sum(f1)<br />
sum1 = sum(f2)<br />
<br />
println("Integral em t=0: ", sum0)<br />
println("Integral em tmax: ", sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
<br />
Foi testado o tempo de execução da parte principal dos dois programas (isto é, sem fazer o gráfico dos resultados), através do timer do terminal, como mostra na próxima figura:<br />
<br />
<center>[[Arquivo:Ftcs_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o método de FTCS aplicado à Equação de Difusão<br />
</center><br />
<br />
É possível perceber, através da figura acima, que o tempo de execução de Python para o FTCS aplicado à Equação de Difusão é menor do que o de Julia. Em razão disso, foi testado um programa simples, como mostra abaixo, que incrementa uma variável 10 vezes, sendo o seu valor inicial 0.<br />
<br />
<br />
<center>[[Arquivo:For.png|border]]<br />
'''Legenda:''' Programa para incrementar o valor de uma variável, nesse caso ''i'', 10 vezes, escrito em Julia e em Python<br />
</center><br />
<br />
E posteriormente, novamente, foi testado o tempo de execução da parte principal dos programas através do terminal:<br />
<br />
<center>[[Arquivo:For_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o programa que incrementa o valor da variável 10 vezes<br />
</center><br />
<br />
É possível perceber que para esse simples programa de incrementação, Python ainda obtém melhor performance do que Julia.<br />
<br />
== Performance de Julia ==<br />
<br />
Tentando entender o que traria tal performance em Cálculo Numérico para Julia, foi chegado à conclusão de que ser uma linguagem que se utilizada de ''variáveis dinâmicas'' e ''multi-métodos'' seria uma das grandes contribuições da linguagem.<br />
<br />
'''Variáveis dinâmicas:'''<br />
<br />
Em Python as variáveis são interpretadas em runtime, ou seja, '''tempo de execução''' => o programa checa toda hora se a variável mudou e isso torna ele mais lento<br />
<br />
'''Variáveis estáticas:'''<br />
<br />
Em C as variáveis são fixas, e isso é visto é em '''tempo de compilação''' => precisa pensar nas variáveis e isso torna o tempo de programação mais lento<br />
<br />
Em Julia isso é basicamente opcional, não é preciso definir as variáveis, mas é possível, e elas podem mudar dinamicamente, em tempo de execução. E ainda, Julia se utiliza de multi-métodos para não ter que lidar com a constante checagem dos tipos das variáveis, como Python faz!<br />
<br />
'''Métodos Únicos'''<br />
<br />
Python => Métodos Únicos (single dispatch)<br />
- Não tenho sobrecarga de funções, eu simplesmente chamo uma função que já está escrita<br />
<br />
'''Multi-métodos'''<br />
<br />
Sobrecarga de funções (C++) => Multi-métodos (multiple dispatch)<br />
- Tenho uma função e dependendo dos parâmetros que eu coloco ao chamá-la, eu chamo uma função ou outra<br />
<br />
'''Exemplo de sobrecarga de funções em Julia:'''<br />
<br />
<pre> <br />
# Dependendo do tipo da minha variável x na chamada da função, será chamada uma função ou outra, mesmo que tenham o mesmo nome<br />
<br />
function printx(x::Float64)<br />
println(x)<br />
end<br />
<br />
function printx(x::String)<br />
println(x)<br />
end<br />
<br />
x="Oi"<br />
<br />
printx(x)<br />
</pre><br />
<br />
== Performance de Julia: na prática ==<br />
Para resumir, temos: <br />
<br />
Python => dynamic (variáveis dinâmicas) single dispatch (métodos únicos)<br />
<br />
C++ => static (variáveis estáticas) multiple dispatch (multi-métodos)<br />
<br />
Julia => dynamic multiple dispatch (''o melhor dos dois mundos!'')<br />
<br />
Na prática, é mostrado abaixo um exemplo da performance de Julia como linguagem de programação em dynamic multiple dispatch. <br />
<br />
O mesmo programa foi escrito em Julia e em C++. <br />
<br />
Em '''Julia''':<br />
<br />
<pre><br />
abstract type Animal end<br />
<br />
struct Cachorro <: Animal<br />
nome::String<br />
end<br />
<br />
struct Gato <: Animal<br />
nome::String<br />
end<br />
<br />
# Função de encontro que recebe tipo genérico de animal<br />
function encontroDeAnimais(a::Animal, b::Animal)<br />
acao = encontro(a,b)<br />
println("$(a.nome) encontra $(b.nome) e $acao")<br />
end<br />
<br />
# Funções de expressão única que recebem diferentes tipos de animais<br />
encontro(a::Cachorro, b::Cachorro) = "cheira" <br />
encontro(a::Cachorro, b::Gato) = "persegue"<br />
encontro(a::Gato, b::Gato) = "lambe"<br />
encontro(a::Gato, b::Cachorro) = "ignora" <br />
<br />
# Instanciando os bichinhos<br />
gato1 = Gato("Luciene Maria")<br />
gato2 = Gato("Mel")<br />
cachorro1 = Cachorro("Batata")<br />
cachorro2 = Cachorro("Snoopy")<br />
<br />
# Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2)<br />
encontroDeAnimais(gato1, cachorro2)<br />
encontroDeAnimais(cachorro1, cachorro2)<br />
</pre><br />
<br />
<br />
Em '''C++''':<br />
<br />
<pre><br />
#include <iostream><br />
using namespace std;<br />
<br />
class Animal { <br />
public:<br />
string nome;<br />
};<br />
<br />
string encontro(Animal a, Animal b) {}<br />
<br />
// Função de encontro que recebe tipo genérico de animal<br />
void encontroDeAnimais(Animal a, Animal b) {<br />
string acao = encontro(a,b);<br />
cout << a.nome << " encontra " << b.nome << " e " << acao << endl;<br />
}<br />
<br />
class Cachorro:public Animal {};<br />
class Gato:public Animal {};<br />
<br />
// Funções de expressão única que recebem diferentes tipos de animais<br />
string encontro(Cachorro a, Cachorro b) { return "cheira"; }<br />
string encontro(Cachorro a, Gato b) { return "persegue"; }<br />
string encontro(Gato a, Gato b) { return "lambe"; }<br />
string encontro(Gato a, Cachorro b) { return "ignora"; }<br />
<br />
int main() {<br />
// Instanciando os bichinhos<br />
Gato gato1; gato1.nome = "Luciene Maria";<br />
Gato gato2; gato2.nome = "Mel";<br />
Cachorro cachorro1; cachorro1.nome = "Batata";<br />
Cachorro cachorro2; cachorro2.nome = "Snoopy";<br />
<br />
// Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2);<br />
encontroDeAnimais(gato1, cachorro2);<br />
encontroDeAnimais(cachorro1, cachorro2);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Para '''Julia''' nós obtemos o seguinte '''resultado''':<br />
<br />
<pre><br />
Luciene Maria encontra Mel e lambe<br />
Luciene Maria encontra Snoopy e ignora<br />
Batata encontra Snoopy e cheira<br />
</pre><br />
<br />
Para '''C++''' o '''resultado''' é:<br />
<br />
<pre><br />
Luciene Maria encontra Mel e<br />
Falha de Segmentação<br />
</pre><br />
<br />
Isso acontece porque C++ não aceita que uma função utilize-se de uma variável sem antes saber qual o tipo dessa variável! Por isso, poder utilizar-se de variáveis dinâmicas quando há multi-métodos é um diferencial que acaba por incrementar a performance de Julia como linguagem de programação visada para o Cálculo Numérico.<br />
<br />
'''Observação:''' é importante ressaltar que os testes feitos não são conclusivos para debater a performance de Julia, em termos estatísticos, e além disso, ser uma linguagem de programação que utiliza de variáveis dinâmicas e multi-métodos não é o único motivo pelo qual Julia poderia trazer tal performance em Cálculo Numérico. Podemos ainda contar com a sua capacidade de '''metaprogramação''', ou seja, Julia pode usar macros e eles são aplicados em tempo de interpretação. Há ainda outros fatores da construção da linguagem que contribuem para sua performance que aqui não foram citados.<br />
<br />
== Aprendendo Julia ==<br />
<br />
'''Ambiente de programação'''<br />
<br />
Após feita a instalação de Julia, para abri-la no seu terminal de comando é preciso apenas digitar: <pre>$julia</pre> para entrar em seu ambiente de programação.<br />
<br />
É possível, também, programar em um arquivo de texto (salvo como .jl) e executar o programa pelo terminal, fazendo simplesmente:<br />
<br />
<pre><br />
$julia programa.jl <br />
</pre><br />
<br />
'''Impressão na tela'''<br />
<pre><br />
println("Hello World")<br />
<br />
Saída:<br />
Hello World<br />
</pre><br />
<br />
'''Variáveis'''<br />
<br />
Variáveis são atribuídas dinamicamente e podem mudar.<br />
<pre><br />
s = 1<br />
s = "Oi"<br />
println(s)<br />
println(typeof(s))<br />
<br />
Saída:<br />
Oi<br />
String<br />
</pre><br />
<br />
<pre><br />
s::String<br />
s = 1<br />
println(s)<br />
<br />
Saída:<br />
TypeError: in typeassert, expected String, got Int32<br />
</pre><br />
<br />
'''Condicionais'''<br />
<pre><br />
cats = 12<br />
if cats < 1<br />
println("You should adopt a cat.")<br />
elseif cats >= 1 && cats <=6<br />
println("Not enough cats.")<br />
elseif cats >= 7 && cats <= 12<br />
println("Still not enough cats.")<br />
else<br />
println("Gato have more cats.")<br />
end<br />
<br />
Saída:<br />
Still not enough cats.<br />
</pre><br />
<br />
<pre><br />
i = 0<br />
while (i < 10)<br />
global i += 1<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
</pre><br />
<br />
<pre><br />
for i = 1:10<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
</pre><br />
<br />
<pre><br />
for i in [1,2,3]<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
</pre><br />
<br />
'''Arrays'''<br />
<pre><br />
# Criando um array de zeros<br />
a1 = zeros()<br />
println(a1)<br />
# Posso definir o tipo e o tamanho do Array (linhas, colunas) também<br />
a1 = zeros(Int32, 1, 4)<br />
println(a1)<br />
<br />
Saída:<br />
0.0<br />
[0 0 0 0]<br />
</pre><br />
<br />
<pre><br />
# Criando um array do tipo inteiro<br />
a2 = Array{Int32}<br />
println(a2)<br />
# Criando um array (de outra maneira) do tipo float<br />
a3 = Float64[]<br />
println(a3)<br />
<br />
Saída:<br />
Array{Int32,N} where N<br />
Float64[]<br />
</pre><br />
<br />
<pre><br />
# Criando um array e definindo valores<br />
a4 = [1,2,3]<br />
#Imprimindo a4<br />
println("Array: ", a4)<br />
<br />
Saída:<br />
Array: [1, 2, 3]<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Imprimindo valor de um indíce específico<br />
println("Imprimindo primeiro elemento: ", a4[1])<br />
# Imprimindo último valor do array<br />
println("Imprimindo último elemento: ",a4[end])<br />
<br />
Saída:<br />
Imprimindo primeiro elemento: 1<br />
Imprimindo último elemento: 3<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
println(a4[2])<br />
# Valores podem mudar (diferente de Tuplas, que veremos adiante)<br />
a4[2] = 4<br />
println(a4[2])<br />
<br />
Saída:<br />
2<br />
4<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
println(a4)<br />
# Número de elementos<br />
println("Imprimindo número de elementos: ",length(a4))<br />
<br />
Saída:<br />
[1, 2, 3]<br />
Imprimindo número de elementos: 3<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Soma os valores do array<br />
println("Imprimindo soma dos elementos: ",sum(a4))<br />
# Põe os valores começando no índice 2<br />
splice!(a4, 2:1, [8,9])<br />
println("Imprimindo Array tendo feito splice!(a4, 2:1, [8,9]): ",a4)<br />
# Remove os itens do índice 2 ao 3<br />
4splice!(a4, 2:3)<br />
println("Imprimindo Array tendo feito splice!(a4, 2:3): ",a4)<br />
<br />
Saída:<br />
Imprimindo soma dos elementos: 6<br />
Imprimindo Array tendo feito splice!(a4, 2:1, [8,9]): [1, 8, 9, 2, 3]<br />
Imprimindo Array tendo feito splice!(a4, 2:3): [1, 2, 3]<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Pegar valor máximo e valor mínimo<br />
println("Imprimindo valor máximo: ",maximum(a4))<br />
println("Imprimindo Array valor mínimo: ",minimum(a4))<br />
# Multiplicando todos os elementos do array por outro número sem precisar de um␣<br />
println("Imprimindo multiplicação dos elementos por 2: ",a4 * 2)<br />
<br />
Saída:<br />
Imprimindo valor máximo: 3<br />
Imprimindo Array valor mínimo: 1<br />
Imprimindo multiplicação dos elementos por 2: [2, 4, 6]<br />
</pre><br />
<br />
<pre><br />
# Arrays podem conter funções<br />
a5 = [sin, cos, tan]<br />
for n in a5<br />
println(n(0))<br />
end<br />
<br />
Saída:<br />
0.0<br />
1.0<br />
0.0<br />
</pre><br />
<br />
<pre><br />
# Para os acostumados com range<br />
a6 = collect(1:5)<br />
println(a6)<br />
<br />
Saída:<br />
[1, 2, 3, 4, 5]<br />
</pre><br />
<br />
'''Tuplas'''<br />
<br />
A maioria das funções de array funciona com tuplas.<br />
<pre><br />
# Valores não podem mudar<br />
t1 = (1,2,3,4)<br />
println(t1[2])<br />
t1[2] = 5<br />
println(t1[2])<br />
<br />
Saída:<br />
2<br />
MethodError: no method matching setindex!(::NTuple{4,Int32}, ::Int32, ::Int32)<br />
</pre><br />
<br />
<pre><br />
# Imprimindo a tupla inteira<br />
println(t1)<br />
# Imprimindo a tupla inteira<br />
for i in t1<br />
println(i)<br />
end<br />
<br />
Saída:<br />
(1, 2, 3, 4)<br />
1<br />
2<br />
3<br />
4<br />
</pre><br />
<br />
'''Dicionários'''<br />
<br />
A palavra-chave deve ser única.<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Imprimir um valor<br />
println(d1["pi"])<br />
<br />
Saída:<br />
3.14<br />
</pre><br />
<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Imprimindo todas as palavras-chaves<br />
println(keys(d1))<br />
# Imprimindo todos os valores<br />
println(values(d1))<br />
# Adicionar uma palavra-chave<br />
d1["golden"] = 1.618<br />
# Deleter uma palavra-chave<br />
delete!(d1, "pi")<br />
# Imprimindo todas as palavras-chaves<br />
println(keys(d1))<br />
# Imprimindo todos os valores<br />
println(values(d1))<br />
<br />
Saída:<br />
["pi", "e"]<br />
[3.14, 2.718]<br />
["e", "golden"]<br />
[2.718, 1.618]<br />
</pre><br />
<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Ver se a palavra-chave existe<br />
println(haskey(d1, "pi"))<br />
# Imprimindo palavras-chaves E valores<br />
for kv in d1<br />
println(kv)<br />
end<br />
<br />
Saída:<br />
true<br />
"pi" => 3.14<br />
"e" => 2.718<br />
</pre><br />
<br />
'''Sets'''<br />
<br />
Sets são arrays com elementos únicos.<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
# Ele não pega os elementos repetidos<br />
println(st1)<br />
<br />
Saída:<br />
Set(["Pam", "Jim"])<br />
</pre><br />
<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
# Adicionando um elemento<br />
push!(st1, "Michael")<br />
println(st1)<br />
# Ver se um elemento está no Set<br />
println(in("Dwight", st1))<br />
<br />
Saída:<br />
Set(["Pam", "Michael", "Jim"])<br />
false<br />
</pre><br />
<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
st2 = Set(["Stanley", "Meredith"])<br />
# Combinando Sets<br />
println(union(st1, st2))<br />
# Imprimindo todo o elemento que os dois Sets tem em comum<br />
println(intersect(st1, st2))<br />
# Imprimindo elementos que estão no primeiro Set, mas não no segundo<br />
println(setdiff(st1, st2))<br />
<br />
Saída:<br />
Set(["Jim", "Meredith", "Stanley", "Pam"])<br />
Set(String[])<br />
Set(["Pam", "Jim"])<br />
</pre><br />
<br />
'''Funções'''<br />
<pre><br />
using Printf<br />
# Função de expressão única<br />
soma(x,y) = x + y<br />
x, y = 1, 2<br />
@printf("%d + %d = %d\n", x, y, x+y)<br />
<br />
Saída:<br />
1 + 2 = 3<br />
</pre><br />
<br />
<pre><br />
# Função de múltiplas expressões<br />
function adoptACat(cats)<br />
if cats <= 1<br />
println("You should adopt a cat.")<br />
else<br />
println("You should adopt a cat. They're cute.")<br />
end<br />
end<br />
adoptACat(2)<br />
<br />
Saída:<br />
You should adopt a cat. They're cute.<br />
</pre><br />
<br />
<pre><br />
v1 = 5<br />
function changeV1(v1)<br />
v1 = 10<br />
end<br />
changeV1(v1)<br />
println(v1)<br />
<br />
Saída:<br />
5<br />
</pre><br />
<br />
<pre><br />
v1 = 5<br />
function changeV1(v1)<br />
v1 = 10<br />
return v1<br />
end<br />
changeV1(v1)<br />
println(v1)<br />
v2 = changeV1(v1)<br />
println(v2)<br />
<br />
Saída:<br />
5<br />
10<br />
</pre><br />
<br />
<pre><br />
# Usando variáveis globais dentro da função<br />
v1 = 5<br />
function changeV12()<br />
global v1 = 10<br />
end<br />
changeV12()<br />
println(v1)<br />
<br />
Saída:<br />
10<br />
</pre><br />
<br />
<pre><br />
# Quando não sei quantos argumentos vou passar<br />
function soma(args...)<br />
sum = 0<br />
for i in args<br />
sum += i<br />
end<br />
println(sum)<br />
end<br />
soma(1,2,3)<br />
<br />
Saída:<br />
6<br />
</pre><br />
<br />
<pre><br />
# Retornando mais de um valor<br />
function retorna2(valor)<br />
return (valor + 1, valor + 2)<br />
end<br />
println(retorna2(4))<br />
<br />
Saída:<br />
(5, 6)<br />
</pre><br />
<br />
<pre><br />
# Map é uma função anônima que aplica uma função para cada elemento<br />
v = map(x -> x * x, [1,2,3])<br />
println(v)<br />
<br />
Saída:<br />
[1, 4, 9]<br />
<br />
'''Structs'''<br />
<pre><br />
struct Estudante<br />
name::String<br />
saldoTRI::Float32<br />
cartaoUFRGS::Int<br />
end<br />
# Criando um objeto<br />
estudante1 = Estudante("Raquel", 10.50, 244449)<br />
println(estudante1.name, "\n", estudante1.saldoTRI, "\n", estudante1.cartaoUFRGS)<br />
<br />
Saída:<br />
Raquel<br />
10.5<br />
244449<br />
9<br />
</pre><br />
<br />
'''Tipos Abstratos'''<br />
<br />
Tipos abstratos não podem ser instanciados como as Structs (instanciar => fazer estudante1 =<br />
Estudante(“Raquel”, 10.50, 244449) => criar um objeto) MAS podem ter subTipos e isso é muito<br />
útil!<br />
<br />
<pre><br />
abstract type animal end<br />
struct cachorro <: animal<br />
nome::String<br />
latido::String<br />
end<br />
struct gato <: animal<br />
nome::String<br />
miado::String<br />
end<br />
cachorro1 = cachorro("Urso", "Au Au")<br />
gato1 = gato("Lucia Irene", "Miau")<br />
# Criando funções pros subTipos<br />
function fazerSom(animal::cachorro)<br />
println("$(animal.nome) diz $(animal.latido)")<br />
end<br />
function fazerSom(animal::gato)<br />
println("$(animal.nome) diz $(animal.miado)")<br />
end<br />
fazerSom(cachorro1)<br />
fazerSom(gato1)<br />
<br />
Saída: <br />
Urso diz Au Au<br />
Lucia Irene diz Miau<br />
</pre></div>Raquelmhttp://fiscomp.if.ufrgs.br/index.php?title=Julia&diff=2514Julia2020-01-07T14:59:23Z<p>Raquelm: /* Aprendendo Julia */</p>
<hr />
<div>Julia é uma linguagem relativamente nova de programação que começou a ser desenvolvida em 2009 por Jeff Bezanson, Stefan Karpinski, Viral B. Shah, e Alan Edelman, um grupo do MIT. Ela foi oficialmente lançada para o mundo em 2012.<br />
<br />
Em uma entrevista, quando perguntaram a Alan o por quê do nome Julia, ele disse que numa conversa anos atrás alguém sugeriu que Julia seria um bom nome para uma linguagem de programação.<br />
<br />
Julia pode ser usada para propósitos gerais de programação, assim como Python, mas em sua criação foi visada a utilização de Julia para Cálculo Numérico.<br />
<br />
== Aspectos Gerais ==<br />
<br />
Julia é uma linguagem de alto nível, isso significa, de maneira sucinta, que ela não é executada utilizando somente o processador, assim como acontece com linguagens de baixo nível, como Assembly, por exemplo.<br />
<br />
É escrita em C, C++, e Scheme, usando a estrutura do compilador LLVM (para melhor entendimento, o compilador de C é o GCC, por exemplo), enquanto a maior parte da biblioteca padrão de Julia é implementada na própria Julia.<br />
<br />
Um fato importante sobre Julia para os programadores de Python é que todas as bibliotecas de Python são usáveis através de um comando simples: PyCall.<br />
<br />
Um fato importante sobre Julia para os programadores de C é que Julia possui APIs (Interfaces de Programação de Aplicativos) especiais para chamada de funções em C diretamente.<br />
<br />
== Velocidade ==<br />
<br />
De acordo com testes feitos pelos próprios criadores de Julia, sua velocidade é similar com a de C.<br />
<br />
<br />
<center>[[Arquivo:juliasvelocity.png|border]]<br />
Fonte: [https://julialang.org/benchmarks/]<br />
</center><br />
<br />
<br />
== Testes de Velocidade ==<br />
<br />
A fim de pessoalmente testar a velocidade da linguagem de programação, foi escrito um programa em Julia de maneira similar ao programa de Python para o FTCS aplicado na Equação de Difusão (também conhecida como Equação do Calor). <br />
<br />
A Equação da Difusão em uma dimensão pode ser escrita da forma:<br />
<br />
<center><math>\frac{df}{dt}=\frac{d^{2}f}{dx^{2}}</math></center><br />
<br />
No método de FTCS (Forward-Time Central-Space) definimos a derivada em t na forma não simetrizada (forward) e as derivadas em x na forma simetrizada:<br />
<br />
<br />
<center><math>\frac{df}{dt} = \frac{f(x, t+dt) - f(x,t)}{dt}</math></center><br />
<br />
<p><br />
<br />
<center><math>\frac{d^{2}f}{dx^{2}} = \frac{f(x+dx, t) + f(x-dx, t) - 2f(x,t)}{dx^{2}}</math></center><br />
<br />
E substuindo na equação da difusão, em notação discreta temos:<br />
<br />
<center><math>f_{j}^{n+1} = f_{j}^{n} + D\frac{dt}{(dx)^{2}}[f_{j+1}^{n} + f_{j-1}^{n} - 2 f_{j}^{n}]</math></center><br />
<br />
'''Observação:''' esse procedimento funciona bem se <math>k=D\frac{dt}{(dx)^{2}} <= 1/2</math>, segundo análise de estabilidade do método.<br />
<br />
<br />
Dessa forma, foi escrito um programa para integrar a Equação de Difusão através do método de FTCS nas linguagens Python e Julia.<br />
<br />
Para '''Python''':<br />
<pre><br />
# FTCS aplicado na equacao da difusao. Linguagem: PYTHON<br />
<br />
import copy<br />
import numpy as np<br />
import matplotlib.pyplot as plt<br />
<br />
def init():<br />
L=50;D=1.;dt=0.05;dx=1.;t=0;tmax=100.<br />
k=D*dt/(dx*dx) <br />
return L,k,dt,t,tmax<br />
<br />
L,k,dt,t,tmax = init()<br />
<br />
x = np.arange(0,L,1) <br />
f = np.zeros(x.shape)<br />
<br />
a = int(L/3)<br />
b = int(2*L/3)<br />
f[a:b]=1.<br />
f1 = copy.deepcopy(f) <br />
f2 = copy.deepcopy(f)<br />
<br />
while t<tmax:<br />
t+=dt<br />
f1[1:L-1]=f[1:L-1]+k*(f[0:L-2]+f[2:L]-2*f[1:L-1])<br />
f1[L-1]=f[L-1]+k*(f[L-2]+f[0]-2*f[L-1]) <br />
f1[0]=f[0]+k*(f[1]+f[L-1]-2*f[0]) <br />
f=copy.deepcopy(f1) <br />
<br />
sum0=sum(f1)<br />
sum1=sum(f2) <br />
<br />
print("Integral em t=0: %7.4f" % sum0)<br />
print("Integral em tmax: %7.4f" % sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
Em '''Julia''':<br />
<pre><br />
# FTCS aplicado na equacao da difusao. Linguagem: JULIA<br />
<br />
using PyPlot<br />
<br />
L=50<br />
D=1.<br />
dt=0.05<br />
dx=1.<br />
t=0<br />
tmax=100.<br />
k=D*dt/(dx*dx) <br />
<br />
x = collect(0:1:L-1)<br />
f = zeros(L)<br />
f1 = zeros(L)<br />
<br />
a = trunc(Int, L/3) <br />
b = trunc(Int, 2*L/3)<br />
<br />
f[a+1:b] .= 1.<br />
f2 = deepcopy(f)<br />
<br />
while t<tmax<br />
global t+=dt <br />
f1[2:L-1] = f[2:L-1] + k*(f[1:L-2] + f[3:L] - 2*f[2:L-1]) <br />
f1[L] = f[L] + k*(f[L-1] + f[1] - 2*f[L])<br />
f1[1] = f[1] + k*(f[2] + f[L] - 2*f[1]) <br />
global f = deepcopy(f1) <br />
end<br />
<br />
sum0 = sum(f1)<br />
sum1 = sum(f2)<br />
<br />
println("Integral em t=0: ", sum0)<br />
println("Integral em tmax: ", sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
<br />
Foi testado o tempo de execução da parte principal dos dois programas (isto é, sem fazer o gráfico dos resultados), através do timer do terminal, como mostra na próxima figura:<br />
<br />
<center>[[Arquivo:Ftcs_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o método de FTCS aplicado à Equação de Difusão<br />
</center><br />
<br />
É possível perceber, através da figura acima, que o tempo de execução de Python para o FTCS aplicado à Equação de Difusão é menor do que o de Julia. Em razão disso, foi testado um programa simples, como mostra abaixo, que incrementa uma variável 10 vezes, sendo o seu valor inicial 0.<br />
<br />
<br />
<center>[[Arquivo:For.png|border]]<br />
'''Legenda:''' Programa para incrementar o valor de uma variável, nesse caso ''i'', 10 vezes, escrito em Julia e em Python<br />
</center><br />
<br />
E posteriormente, novamente, foi testado o tempo de execução da parte principal dos programas através do terminal:<br />
<br />
<center>[[Arquivo:For_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o programa que incrementa o valor da variável 10 vezes<br />
</center><br />
<br />
É possível perceber que para esse simples programa de incrementação, Python ainda obtém melhor performance do que Julia.<br />
<br />
== Performance de Julia ==<br />
<br />
Tentando entender o que traria tal performance em Cálculo Numérico para Julia, foi chegado à conclusão de que ser uma linguagem que se utilizada de ''variáveis dinâmicas'' e ''multi-métodos'' seria uma das grandes contribuições da linguagem.<br />
<br />
'''Variáveis dinâmicas:'''<br />
<br />
Em Python as variáveis são interpretadas em runtime, ou seja, '''tempo de execução''' => o programa checa toda hora se a variável mudou e isso torna ele mais lento<br />
<br />
'''Variáveis estáticas:'''<br />
<br />
Em C as variáveis são fixas, e isso é visto é em '''tempo de compilação''' => precisa pensar nas variáveis e isso torna o tempo de programação mais lento<br />
<br />
Em Julia isso é basicamente opcional, não é preciso definir as variáveis, mas é possível, e elas podem mudar dinamicamente, em tempo de execução. E ainda, Julia se utiliza de multi-métodos para não ter que lidar com a constante checagem dos tipos das variáveis, como Python faz!<br />
<br />
'''Métodos Únicos'''<br />
<br />
Python => Métodos Únicos (single dispatch)<br />
- Não tenho sobrecarga de funções, eu simplesmente chamo uma função que já está escrita<br />
<br />
'''Multi-métodos'''<br />
<br />
Sobrecarga de funções (C++) => Multi-métodos (multiple dispatch)<br />
- Tenho uma função e dependendo dos parâmetros que eu coloco ao chamá-la, eu chamo uma função ou outra<br />
<br />
'''Exemplo de sobrecarga de funções em Julia:'''<br />
<br />
<pre> <br />
# Dependendo do tipo da minha variável x na chamada da função, será chamada uma função ou outra, mesmo que tenham o mesmo nome<br />
<br />
function printx(x::Float64)<br />
println(x)<br />
end<br />
<br />
function printx(x::String)<br />
println(x)<br />
end<br />
<br />
x="Oi"<br />
<br />
printx(x)<br />
</pre><br />
<br />
== Performance de Julia: na prática ==<br />
Para resumir, temos: <br />
<br />
Python => dynamic (variáveis dinâmicas) single dispatch (métodos únicos)<br />
<br />
C++ => static (variáveis estáticas) multiple dispatch (multi-métodos)<br />
<br />
Julia => dynamic multiple dispatch (''o melhor dos dois mundos!'')<br />
<br />
Na prática, é mostrado abaixo um exemplo da performance de Julia como linguagem de programação em dynamic multiple dispatch. <br />
<br />
O mesmo programa foi escrito em Julia e em C++. <br />
<br />
Em '''Julia''':<br />
<br />
<pre><br />
abstract type Animal end<br />
<br />
struct Cachorro <: Animal<br />
nome::String<br />
end<br />
<br />
struct Gato <: Animal<br />
nome::String<br />
end<br />
<br />
# Função de encontro que recebe tipo genérico de animal<br />
function encontroDeAnimais(a::Animal, b::Animal)<br />
acao = encontro(a,b)<br />
println("$(a.nome) encontra $(b.nome) e $acao")<br />
end<br />
<br />
# Funções de expressão única que recebem diferentes tipos de animais<br />
encontro(a::Cachorro, b::Cachorro) = "cheira" <br />
encontro(a::Cachorro, b::Gato) = "persegue"<br />
encontro(a::Gato, b::Gato) = "lambe"<br />
encontro(a::Gato, b::Cachorro) = "ignora" <br />
<br />
# Instanciando os bichinhos<br />
gato1 = Gato("Luciene Maria")<br />
gato2 = Gato("Mel")<br />
cachorro1 = Cachorro("Batata")<br />
cachorro2 = Cachorro("Snoopy")<br />
<br />
# Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2)<br />
encontroDeAnimais(gato1, cachorro2)<br />
encontroDeAnimais(cachorro1, cachorro2)<br />
</pre><br />
<br />
<br />
Em '''C++''':<br />
<br />
<pre><br />
#include <iostream><br />
using namespace std;<br />
<br />
class Animal { <br />
public:<br />
string nome;<br />
};<br />
<br />
string encontro(Animal a, Animal b) {}<br />
<br />
// Função de encontro que recebe tipo genérico de animal<br />
void encontroDeAnimais(Animal a, Animal b) {<br />
string acao = encontro(a,b);<br />
cout << a.nome << " encontra " << b.nome << " e " << acao << endl;<br />
}<br />
<br />
class Cachorro:public Animal {};<br />
class Gato:public Animal {};<br />
<br />
// Funções de expressão única que recebem diferentes tipos de animais<br />
string encontro(Cachorro a, Cachorro b) { return "cheira"; }<br />
string encontro(Cachorro a, Gato b) { return "persegue"; }<br />
string encontro(Gato a, Gato b) { return "lambe"; }<br />
string encontro(Gato a, Cachorro b) { return "ignora"; }<br />
<br />
int main() {<br />
// Instanciando os bichinhos<br />
Gato gato1; gato1.nome = "Luciene Maria";<br />
Gato gato2; gato2.nome = "Mel";<br />
Cachorro cachorro1; cachorro1.nome = "Batata";<br />
Cachorro cachorro2; cachorro2.nome = "Snoopy";<br />
<br />
// Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2);<br />
encontroDeAnimais(gato1, cachorro2);<br />
encontroDeAnimais(cachorro1, cachorro2);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Para '''Julia''' nós obtemos o seguinte '''resultado''':<br />
<br />
<pre><br />
Luciene Maria encontra Mel e lambe<br />
Luciene Maria encontra Snoopy e ignora<br />
Batata encontra Snoopy e cheira<br />
</pre><br />
<br />
Para '''C++''' o '''resultado''' é:<br />
<br />
<pre><br />
Luciene Maria encontra Mel e<br />
Falha de Segmentação<br />
</pre><br />
<br />
Isso acontece porque C++ não aceita que uma função utilize-se de uma variável sem antes saber qual o tipo dessa variável! Por isso, poder utilizar-se de variáveis dinâmicas quando há multi-métodos é um diferencial que acaba por incrementar a performance de Julia como linguagem de programação visada para o Cálculo Numérico.<br />
<br />
'''Observação:''' é importante ressaltar que os testes feitos não são conclusivos para debater a performance de Julia, em termos estatísticos, e além disso, ser uma linguagem de programação que utiliza de variáveis dinâmicas e multi-métodos não é o único motivo pelo qual Julia poderia trazer tal performance em Cálculo Numérico. Podemos ainda contar com a sua capacidade de '''metaprogramação''', ou seja, Julia pode usar macros e eles são aplicados em tempo de interpretação. Há ainda outros fatores da construção da linguagem que contribuem para sua performance que aqui não foram citados.<br />
<br />
== Aprendendo Julia ==<br />
<br />
'''Ambiente de programação'''<br />
<br />
Após feita a instalação de Julia, para abri-la no seu terminal de comando é preciso apenas digitar: <pre>$julia</pre> para entrar em seu ambiente de programação.<br />
<br />
É possível, também, programar em um arquivo de texto (salvo como .jl) e executar o programa pelo terminal, fazendo simplesmente:<br />
<br />
<pre><br />
$julia programa.jl <br />
</pre><br />
<br />
'''Impressão na tela'''<br />
<pre><br />
println("Hello World")<br />
<br />
Saída:<br />
Hello World<br />
</pre><br />
<br />
'''Variáveis'''<br />
<br />
Variáveis são atribuídas dinamicamente e podem mudar.<br />
<pre><br />
s = 1<br />
s = "Oi"<br />
println(s)<br />
println(typeof(s))<br />
<br />
Saída:<br />
Oi<br />
String<br />
</pre><br />
<br />
<pre><br />
s::String<br />
s = 1<br />
println(s)<br />
<br />
Saída:<br />
TypeError: in typeassert, expected String, got Int32<br />
</pre><br />
<br />
'''Condicionais'''<br />
<pre><br />
cats = 12<br />
if cats < 1<br />
println("You should adopt a cat.")<br />
elseif cats >= 1 && cats <=6<br />
println("Not enough cats.")<br />
elseif cats >= 7 && cats <= 12<br />
println("Still not enough cats.")<br />
else<br />
println("Gato have more cats.")<br />
end<br />
<br />
Saída:<br />
Still not enough cats.<br />
</pre><br />
<br />
<pre><br />
i = 0<br />
while (i < 10)<br />
global i += 1<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
</pre><br />
<br />
<pre><br />
for i = 1:10<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
</pre><br />
<br />
<pre><br />
for i in [1,2,3]<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
3<br />
</pre><br />
<br />
'''Arrays'''<br />
<pre><br />
# Criando um array de zeros<br />
a1 = zeros()<br />
println(a1)<br />
# Posso definir o tipo e o tamanho do Array (linhas, colunas) também<br />
a1 = zeros(Int32, 1, 4)<br />
println(a1)<br />
<br />
Saída:<br />
0.0<br />
[0 0 0 0]<br />
</pre><br />
<br />
<pre><br />
# Criando um array do tipo inteiro<br />
a2 = Array{Int32}<br />
println(a2)<br />
# Criando um array (de outra maneira) do tipo float<br />
a3 = Float64[]<br />
println(a3)<br />
<br />
Saída:<br />
Array{Int32,N} where N<br />
Float64[]<br />
</pre><br />
<br />
<pre><br />
# Criando um array e definindo valores<br />
a4 = [1,2,3]<br />
#Imprimindo a4<br />
println("Array: ", a4)<br />
<br />
Saída:<br />
Array: [1, 2, 3]<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Imprimindo valor de um indíce específico<br />
println("Imprimindo primeiro elemento: ", a4[1])<br />
# Imprimindo último valor do array<br />
println("Imprimindo último elemento: ",a4[end])<br />
<br />
Saída:<br />
Imprimindo primeiro elemento: 1<br />
Imprimindo último elemento: 3<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
println(a4[2])<br />
# Valores podem mudar (diferente de Tuplas, que veremos adiante)<br />
a4[2] = 4<br />
println(a4[2])<br />
<br />
Saída:<br />
2<br />
4<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
println(a4)<br />
# Número de elementos<br />
println("Imprimindo número de elementos: ",length(a4))<br />
<br />
Saída:<br />
[1, 2, 3]<br />
Imprimindo número de elementos: 3<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Soma os valores do array<br />
println("Imprimindo soma dos elementos: ",sum(a4))<br />
# Põe os valores começando no índice 2<br />
splice!(a4, 2:1, [8,9])<br />
println("Imprimindo Array tendo feito splice!(a4, 2:1, [8,9]): ",a4)<br />
# Remove os itens do índice 2 ao 3<br />
4splice!(a4, 2:3)<br />
println("Imprimindo Array tendo feito splice!(a4, 2:3): ",a4)<br />
<br />
Saída:<br />
Imprimindo soma dos elementos: 6<br />
Imprimindo Array tendo feito splice!(a4, 2:1, [8,9]): [1, 8, 9, 2, 3]<br />
Imprimindo Array tendo feito splice!(a4, 2:3): [1, 2, 3]<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Pegar valor máximo e valor mínimo<br />
println("Imprimindo valor máximo: ",maximum(a4))<br />
println("Imprimindo Array valor mínimo: ",minimum(a4))<br />
# Multiplicando todos os elementos do array por outro número sem precisar de um␣<br />
println("Imprimindo multiplicação dos elementos por 2: ",a4 * 2)<br />
<br />
Saída:<br />
Imprimindo valor máximo: 3<br />
Imprimindo Array valor mínimo: 1<br />
Imprimindo multiplicação dos elementos por 2: [2, 4, 6]<br />
</pre><br />
<br />
<pre><br />
# Arrays podem conter funções<br />
a5 = [sin, cos, tan]<br />
for n in a5<br />
println(n(0))<br />
end<br />
<br />
Saída:<br />
0.0<br />
1.0<br />
0.0<br />
</pre><br />
<br />
<pre><br />
# Para os acostumados com range<br />
a6 = collect(1:5)<br />
println(a6)<br />
<br />
Saída:<br />
[1, 2, 3, 4, 5]<br />
</pre><br />
<br />
'''Tuplas'''<br />
<br />
A maioria das funções de array funciona com tuplas.<br />
<pre><br />
# Valores não podem mudar<br />
t1 = (1,2,3,4)<br />
println(t1[2])<br />
t1[2] = 5<br />
println(t1[2])<br />
<br />
Saída:<br />
2<br />
MethodError: no method matching setindex!(::NTuple{4,Int32}, ::Int32, ::Int32)<br />
</pre><br />
<br />
<pre><br />
# Imprimindo a tupla inteira<br />
println(t1)<br />
# Imprimindo a tupla inteira<br />
for i in t1<br />
println(i)<br />
end<br />
<br />
Saída:<br />
(1, 2, 3, 4)<br />
1<br />
2<br />
3<br />
4<br />
</pre><br />
<br />
'''Dicionários'''<br />
<br />
A palavra-chave deve ser única.<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Imprimir um valor<br />
println(d1["pi"])<br />
<br />
Saída:<br />
3.14<br />
</pre><br />
<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Imprimindo todas as palavras-chaves<br />
println(keys(d1))<br />
# Imprimindo todos os valores<br />
println(values(d1))<br />
# Adicionar uma palavra-chave<br />
d1["golden"] = 1.618<br />
# Deleter uma palavra-chave<br />
delete!(d1, "pi")<br />
# Imprimindo todas as palavras-chaves<br />
println(keys(d1))<br />
# Imprimindo todos os valores<br />
println(values(d1))<br />
<br />
Saída:<br />
["pi", "e"]<br />
[3.14, 2.718]<br />
["e", "golden"]<br />
[2.718, 1.618]<br />
</pre><br />
<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Ver se a palavra-chave existe<br />
println(haskey(d1, "pi"))<br />
# Imprimindo palavras-chaves E valores<br />
for kv in d1<br />
println(kv)<br />
end<br />
<br />
Saída:<br />
true<br />
"pi" => 3.14<br />
"e" => 2.718<br />
</pre><br />
<br />
'''Sets'''<br />
<br />
Sets são arrays com elementos únicos.<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
# Ele não pega os elementos repetidos<br />
println(st1)<br />
<br />
Saída:<br />
Set(["Pam", "Jim"])<br />
</pre><br />
<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
# Adicionando um elemento<br />
push!(st1, "Michael")<br />
println(st1)<br />
# Ver se um elemento está no Set<br />
println(in("Dwight", st1))<br />
<br />
Saída:<br />
Set(["Pam", "Michael", "Jim"])<br />
false<br />
</pre><br />
<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
st2 = Set(["Stanley", "Meredith"])<br />
# Combinando Sets<br />
println(union(st1, st2))<br />
# Imprimindo todo o elemento que os dois Sets tem em comum<br />
println(intersect(st1, st2))<br />
# Imprimindo elementos que estão no primeiro Set, mas não no segundo<br />
println(setdiff(st1, st2))<br />
<br />
Saída:<br />
Set(["Jim", "Meredith", "Stanley", "Pam"])<br />
Set(String[])<br />
Set(["Pam", "Jim"])<br />
</pre><br />
<br />
'''Funções'''<br />
<pre><br />
using Printf<br />
# Função de expressão única<br />
soma(x,y) = x + y<br />
x, y = 1, 2<br />
@printf("%d + %d = %d\n", x, y, x+y)<br />
<br />
Saída:<br />
1 + 2 = 3<br />
</pre><br />
<br />
<pre><br />
# Função de múltiplas expressões<br />
function adoptACat(cats)<br />
if cats <= 1<br />
println("You should adopt a cat.")<br />
else<br />
println("You should adopt a cat. They're cute.")<br />
end<br />
end<br />
adoptACat(2)<br />
<br />
Saída:<br />
You should adopt a cat. They're cute.<br />
</pre><br />
<br />
<pre><br />
v1 = 5<br />
function changeV1(v1)<br />
v1 = 10<br />
end<br />
changeV1(v1)<br />
println(v1)<br />
<br />
Saída:<br />
5<br />
</pre><br />
<br />
<pre><br />
v1 = 5<br />
function changeV1(v1)<br />
v1 = 10<br />
return v1<br />
end<br />
changeV1(v1)<br />
println(v1)<br />
v2 = changeV1(v1)<br />
println(v2)<br />
<br />
Saída:<br />
5<br />
10<br />
</pre><br />
<br />
<pre><br />
# Usando variáveis globais dentro da função<br />
v1 = 5<br />
function changeV12()<br />
global v1 = 10<br />
end<br />
changeV12()<br />
println(v1)<br />
<br />
Saída:<br />
10<br />
</pre><br />
<br />
<pre><br />
# Quando não sei quantos argumentos vou passar<br />
function soma(args...)<br />
sum = 0<br />
for i in args<br />
sum += i<br />
end<br />
println(sum)<br />
end<br />
soma(1,2,3)<br />
<br />
Saída:<br />
6<br />
</pre><br />
<br />
<pre><br />
# Retornando mais de um valor<br />
function retorna2(valor)<br />
return (valor + 1, valor + 2)<br />
end<br />
println(retorna2(4))<br />
<br />
Saída:<br />
(5, 6)<br />
</pre><br />
<br />
<pre><br />
# Map é uma função anônima que aplica uma função para cada elemento<br />
v = map(x -> x * x, [1,2,3])<br />
println(v)<br />
<br />
Saída:<br />
[1, 4, 9]<br />
<br />
'''Structs'''<br />
<pre><br />
struct Estudante<br />
name::String<br />
saldoTRI::Float32<br />
cartaoUFRGS::Int<br />
end<br />
# Criando um objeto<br />
estudante1 = Estudante("Raquel", 10.50, 244449)<br />
println(estudante1.name, "\n", estudante1.saldoTRI, "\n", estudante1.cartaoUFRGS)<br />
<br />
Saída:<br />
Raquel<br />
10.5<br />
244449<br />
9<br />
</pre><br />
<br />
'''Tipos Abstratos'''<br />
<br />
Tipos abstratos não podem ser instanciados como as Structs (instanciar => fazer estudante1 =<br />
Estudante(“Raquel”, 10.50, 244449) => criar um objeto) MAS podem ter subTipos e isso é muito<br />
útil!<br />
<br />
<pre><br />
abstract type animal end<br />
struct cachorro <: animal<br />
nome::String<br />
latido::String<br />
end<br />
struct gato <: animal<br />
nome::String<br />
miado::String<br />
end<br />
cachorro1 = cachorro("Urso", "Au Au")<br />
gato1 = gato("Lucia Irene", "Miau")<br />
# Criando funções pros subTipos<br />
function fazerSom(animal::cachorro)<br />
println("$(animal.nome) diz $(animal.latido)")<br />
end<br />
function fazerSom(animal::gato)<br />
println("$(animal.nome) diz $(animal.miado)")<br />
end<br />
fazerSom(cachorro1)<br />
fazerSom(gato1)<br />
<br />
Saída: <br />
Urso diz Au Au<br />
Lucia Irene diz Miau<br />
</pre></div>Raquelmhttp://fiscomp.if.ufrgs.br/index.php?title=Julia&diff=2513Julia2020-01-07T14:58:34Z<p>Raquelm: /* Aprendendo Julia */</p>
<hr />
<div>Julia é uma linguagem relativamente nova de programação que começou a ser desenvolvida em 2009 por Jeff Bezanson, Stefan Karpinski, Viral B. Shah, e Alan Edelman, um grupo do MIT. Ela foi oficialmente lançada para o mundo em 2012.<br />
<br />
Em uma entrevista, quando perguntaram a Alan o por quê do nome Julia, ele disse que numa conversa anos atrás alguém sugeriu que Julia seria um bom nome para uma linguagem de programação.<br />
<br />
Julia pode ser usada para propósitos gerais de programação, assim como Python, mas em sua criação foi visada a utilização de Julia para Cálculo Numérico.<br />
<br />
== Aspectos Gerais ==<br />
<br />
Julia é uma linguagem de alto nível, isso significa, de maneira sucinta, que ela não é executada utilizando somente o processador, assim como acontece com linguagens de baixo nível, como Assembly, por exemplo.<br />
<br />
É escrita em C, C++, e Scheme, usando a estrutura do compilador LLVM (para melhor entendimento, o compilador de C é o GCC, por exemplo), enquanto a maior parte da biblioteca padrão de Julia é implementada na própria Julia.<br />
<br />
Um fato importante sobre Julia para os programadores de Python é que todas as bibliotecas de Python são usáveis através de um comando simples: PyCall.<br />
<br />
Um fato importante sobre Julia para os programadores de C é que Julia possui APIs (Interfaces de Programação de Aplicativos) especiais para chamada de funções em C diretamente.<br />
<br />
== Velocidade ==<br />
<br />
De acordo com testes feitos pelos próprios criadores de Julia, sua velocidade é similar com a de C.<br />
<br />
<br />
<center>[[Arquivo:juliasvelocity.png|border]]<br />
Fonte: [https://julialang.org/benchmarks/]<br />
</center><br />
<br />
<br />
== Testes de Velocidade ==<br />
<br />
A fim de pessoalmente testar a velocidade da linguagem de programação, foi escrito um programa em Julia de maneira similar ao programa de Python para o FTCS aplicado na Equação de Difusão (também conhecida como Equação do Calor). <br />
<br />
A Equação da Difusão em uma dimensão pode ser escrita da forma:<br />
<br />
<center><math>\frac{df}{dt}=\frac{d^{2}f}{dx^{2}}</math></center><br />
<br />
No método de FTCS (Forward-Time Central-Space) definimos a derivada em t na forma não simetrizada (forward) e as derivadas em x na forma simetrizada:<br />
<br />
<br />
<center><math>\frac{df}{dt} = \frac{f(x, t+dt) - f(x,t)}{dt}</math></center><br />
<br />
<p><br />
<br />
<center><math>\frac{d^{2}f}{dx^{2}} = \frac{f(x+dx, t) + f(x-dx, t) - 2f(x,t)}{dx^{2}}</math></center><br />
<br />
E substuindo na equação da difusão, em notação discreta temos:<br />
<br />
<center><math>f_{j}^{n+1} = f_{j}^{n} + D\frac{dt}{(dx)^{2}}[f_{j+1}^{n} + f_{j-1}^{n} - 2 f_{j}^{n}]</math></center><br />
<br />
'''Observação:''' esse procedimento funciona bem se <math>k=D\frac{dt}{(dx)^{2}} <= 1/2</math>, segundo análise de estabilidade do método.<br />
<br />
<br />
Dessa forma, foi escrito um programa para integrar a Equação de Difusão através do método de FTCS nas linguagens Python e Julia.<br />
<br />
Para '''Python''':<br />
<pre><br />
# FTCS aplicado na equacao da difusao. Linguagem: PYTHON<br />
<br />
import copy<br />
import numpy as np<br />
import matplotlib.pyplot as plt<br />
<br />
def init():<br />
L=50;D=1.;dt=0.05;dx=1.;t=0;tmax=100.<br />
k=D*dt/(dx*dx) <br />
return L,k,dt,t,tmax<br />
<br />
L,k,dt,t,tmax = init()<br />
<br />
x = np.arange(0,L,1) <br />
f = np.zeros(x.shape)<br />
<br />
a = int(L/3)<br />
b = int(2*L/3)<br />
f[a:b]=1.<br />
f1 = copy.deepcopy(f) <br />
f2 = copy.deepcopy(f)<br />
<br />
while t<tmax:<br />
t+=dt<br />
f1[1:L-1]=f[1:L-1]+k*(f[0:L-2]+f[2:L]-2*f[1:L-1])<br />
f1[L-1]=f[L-1]+k*(f[L-2]+f[0]-2*f[L-1]) <br />
f1[0]=f[0]+k*(f[1]+f[L-1]-2*f[0]) <br />
f=copy.deepcopy(f1) <br />
<br />
sum0=sum(f1)<br />
sum1=sum(f2) <br />
<br />
print("Integral em t=0: %7.4f" % sum0)<br />
print("Integral em tmax: %7.4f" % sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
Em '''Julia''':<br />
<pre><br />
# FTCS aplicado na equacao da difusao. Linguagem: JULIA<br />
<br />
using PyPlot<br />
<br />
L=50<br />
D=1.<br />
dt=0.05<br />
dx=1.<br />
t=0<br />
tmax=100.<br />
k=D*dt/(dx*dx) <br />
<br />
x = collect(0:1:L-1)<br />
f = zeros(L)<br />
f1 = zeros(L)<br />
<br />
a = trunc(Int, L/3) <br />
b = trunc(Int, 2*L/3)<br />
<br />
f[a+1:b] .= 1.<br />
f2 = deepcopy(f)<br />
<br />
while t<tmax<br />
global t+=dt <br />
f1[2:L-1] = f[2:L-1] + k*(f[1:L-2] + f[3:L] - 2*f[2:L-1]) <br />
f1[L] = f[L] + k*(f[L-1] + f[1] - 2*f[L])<br />
f1[1] = f[1] + k*(f[2] + f[L] - 2*f[1]) <br />
global f = deepcopy(f1) <br />
end<br />
<br />
sum0 = sum(f1)<br />
sum1 = sum(f2)<br />
<br />
println("Integral em t=0: ", sum0)<br />
println("Integral em tmax: ", sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
<br />
Foi testado o tempo de execução da parte principal dos dois programas (isto é, sem fazer o gráfico dos resultados), através do timer do terminal, como mostra na próxima figura:<br />
<br />
<center>[[Arquivo:Ftcs_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o método de FTCS aplicado à Equação de Difusão<br />
</center><br />
<br />
É possível perceber, através da figura acima, que o tempo de execução de Python para o FTCS aplicado à Equação de Difusão é menor do que o de Julia. Em razão disso, foi testado um programa simples, como mostra abaixo, que incrementa uma variável 10 vezes, sendo o seu valor inicial 0.<br />
<br />
<br />
<center>[[Arquivo:For.png|border]]<br />
'''Legenda:''' Programa para incrementar o valor de uma variável, nesse caso ''i'', 10 vezes, escrito em Julia e em Python<br />
</center><br />
<br />
E posteriormente, novamente, foi testado o tempo de execução da parte principal dos programas através do terminal:<br />
<br />
<center>[[Arquivo:For_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o programa que incrementa o valor da variável 10 vezes<br />
</center><br />
<br />
É possível perceber que para esse simples programa de incrementação, Python ainda obtém melhor performance do que Julia.<br />
<br />
== Performance de Julia ==<br />
<br />
Tentando entender o que traria tal performance em Cálculo Numérico para Julia, foi chegado à conclusão de que ser uma linguagem que se utilizada de ''variáveis dinâmicas'' e ''multi-métodos'' seria uma das grandes contribuições da linguagem.<br />
<br />
'''Variáveis dinâmicas:'''<br />
<br />
Em Python as variáveis são interpretadas em runtime, ou seja, '''tempo de execução''' => o programa checa toda hora se a variável mudou e isso torna ele mais lento<br />
<br />
'''Variáveis estáticas:'''<br />
<br />
Em C as variáveis são fixas, e isso é visto é em '''tempo de compilação''' => precisa pensar nas variáveis e isso torna o tempo de programação mais lento<br />
<br />
Em Julia isso é basicamente opcional, não é preciso definir as variáveis, mas é possível, e elas podem mudar dinamicamente, em tempo de execução. E ainda, Julia se utiliza de multi-métodos para não ter que lidar com a constante checagem dos tipos das variáveis, como Python faz!<br />
<br />
'''Métodos Únicos'''<br />
<br />
Python => Métodos Únicos (single dispatch)<br />
- Não tenho sobrecarga de funções, eu simplesmente chamo uma função que já está escrita<br />
<br />
'''Multi-métodos'''<br />
<br />
Sobrecarga de funções (C++) => Multi-métodos (multiple dispatch)<br />
- Tenho uma função e dependendo dos parâmetros que eu coloco ao chamá-la, eu chamo uma função ou outra<br />
<br />
'''Exemplo de sobrecarga de funções em Julia:'''<br />
<br />
<pre> <br />
# Dependendo do tipo da minha variável x na chamada da função, será chamada uma função ou outra, mesmo que tenham o mesmo nome<br />
<br />
function printx(x::Float64)<br />
println(x)<br />
end<br />
<br />
function printx(x::String)<br />
println(x)<br />
end<br />
<br />
x="Oi"<br />
<br />
printx(x)<br />
</pre><br />
<br />
== Performance de Julia: na prática ==<br />
Para resumir, temos: <br />
<br />
Python => dynamic (variáveis dinâmicas) single dispatch (métodos únicos)<br />
<br />
C++ => static (variáveis estáticas) multiple dispatch (multi-métodos)<br />
<br />
Julia => dynamic multiple dispatch (''o melhor dos dois mundos!'')<br />
<br />
Na prática, é mostrado abaixo um exemplo da performance de Julia como linguagem de programação em dynamic multiple dispatch. <br />
<br />
O mesmo programa foi escrito em Julia e em C++. <br />
<br />
Em '''Julia''':<br />
<br />
<pre><br />
abstract type Animal end<br />
<br />
struct Cachorro <: Animal<br />
nome::String<br />
end<br />
<br />
struct Gato <: Animal<br />
nome::String<br />
end<br />
<br />
# Função de encontro que recebe tipo genérico de animal<br />
function encontroDeAnimais(a::Animal, b::Animal)<br />
acao = encontro(a,b)<br />
println("$(a.nome) encontra $(b.nome) e $acao")<br />
end<br />
<br />
# Funções de expressão única que recebem diferentes tipos de animais<br />
encontro(a::Cachorro, b::Cachorro) = "cheira" <br />
encontro(a::Cachorro, b::Gato) = "persegue"<br />
encontro(a::Gato, b::Gato) = "lambe"<br />
encontro(a::Gato, b::Cachorro) = "ignora" <br />
<br />
# Instanciando os bichinhos<br />
gato1 = Gato("Luciene Maria")<br />
gato2 = Gato("Mel")<br />
cachorro1 = Cachorro("Batata")<br />
cachorro2 = Cachorro("Snoopy")<br />
<br />
# Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2)<br />
encontroDeAnimais(gato1, cachorro2)<br />
encontroDeAnimais(cachorro1, cachorro2)<br />
</pre><br />
<br />
<br />
Em '''C++''':<br />
<br />
<pre><br />
#include <iostream><br />
using namespace std;<br />
<br />
class Animal { <br />
public:<br />
string nome;<br />
};<br />
<br />
string encontro(Animal a, Animal b) {}<br />
<br />
// Função de encontro que recebe tipo genérico de animal<br />
void encontroDeAnimais(Animal a, Animal b) {<br />
string acao = encontro(a,b);<br />
cout << a.nome << " encontra " << b.nome << " e " << acao << endl;<br />
}<br />
<br />
class Cachorro:public Animal {};<br />
class Gato:public Animal {};<br />
<br />
// Funções de expressão única que recebem diferentes tipos de animais<br />
string encontro(Cachorro a, Cachorro b) { return "cheira"; }<br />
string encontro(Cachorro a, Gato b) { return "persegue"; }<br />
string encontro(Gato a, Gato b) { return "lambe"; }<br />
string encontro(Gato a, Cachorro b) { return "ignora"; }<br />
<br />
int main() {<br />
// Instanciando os bichinhos<br />
Gato gato1; gato1.nome = "Luciene Maria";<br />
Gato gato2; gato2.nome = "Mel";<br />
Cachorro cachorro1; cachorro1.nome = "Batata";<br />
Cachorro cachorro2; cachorro2.nome = "Snoopy";<br />
<br />
// Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2);<br />
encontroDeAnimais(gato1, cachorro2);<br />
encontroDeAnimais(cachorro1, cachorro2);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Para '''Julia''' nós obtemos o seguinte '''resultado''':<br />
<br />
<pre><br />
Luciene Maria encontra Mel e lambe<br />
Luciene Maria encontra Snoopy e ignora<br />
Batata encontra Snoopy e cheira<br />
</pre><br />
<br />
Para '''C++''' o '''resultado''' é:<br />
<br />
<pre><br />
Luciene Maria encontra Mel e<br />
Falha de Segmentação<br />
</pre><br />
<br />
Isso acontece porque C++ não aceita que uma função utilize-se de uma variável sem antes saber qual o tipo dessa variável! Por isso, poder utilizar-se de variáveis dinâmicas quando há multi-métodos é um diferencial que acaba por incrementar a performance de Julia como linguagem de programação visada para o Cálculo Numérico.<br />
<br />
'''Observação:''' é importante ressaltar que os testes feitos não são conclusivos para debater a performance de Julia, em termos estatísticos, e além disso, ser uma linguagem de programação que utiliza de variáveis dinâmicas e multi-métodos não é o único motivo pelo qual Julia poderia trazer tal performance em Cálculo Numérico. Podemos ainda contar com a sua capacidade de '''metaprogramação''', ou seja, Julia pode usar macros e eles são aplicados em tempo de interpretação. Há ainda outros fatores da construção da linguagem que contribuem para sua performance que aqui não foram citados.<br />
<br />
== Aprendendo Julia ==<br />
<br />
Após feita a instalação de Julia, para abri-la no seu terminal de comando é preciso apenas digitar: <pre>$julia</pre> para entrar em seu ambiente de programação.<br />
<br />
É possível, também, programar em um arquivo de texto (salvo como .jl) e executar o programa pelo terminal, fazendo simplesmente:<br />
<br />
<pre><br />
$julia programa.jl <br />
</pre><br />
<br />
'''Impressão na tela'''<br />
<pre><br />
println("Hello World")<br />
<br />
Saída:<br />
Hello World<br />
</pre><br />
<br />
'''Variáveis'''<br />
<br />
Variáveis são atribuídas dinamicamente e podem mudar.<br />
<pre><br />
s = 1<br />
s = "Oi"<br />
println(s)<br />
println(typeof(s))<br />
<br />
Saída:<br />
Oi<br />
String<br />
</pre><br />
<br />
<pre><br />
s::String<br />
s = 1<br />
println(s)<br />
<br />
Saída:<br />
TypeError: in typeassert, expected String, got Int32<br />
</pre><br />
<br />
'''Condicionais'''<br />
<pre><br />
cats = 12<br />
if cats < 1<br />
println("You should adopt a cat.")<br />
elseif cats >= 1 && cats <=6<br />
println("Not enough cats.")<br />
elseif cats >= 7 && cats <= 12<br />
println("Still not enough cats.")<br />
else<br />
println("Gato have more cats.")<br />
end<br />
<br />
Saída:<br />
Still not enough cats.<br />
</pre><br />
<br />
<pre><br />
i = 0<br />
while (i < 10)<br />
global i += 1<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
</pre><br />
<br />
<pre><br />
for i = 1:10<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
</pre><br />
<br />
<pre><br />
for i in [1,2,3]<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
3<br />
</pre><br />
<br />
'''Arrays'''<br />
<pre><br />
# Criando um array de zeros<br />
a1 = zeros()<br />
println(a1)<br />
# Posso definir o tipo e o tamanho do Array (linhas, colunas) também<br />
a1 = zeros(Int32, 1, 4)<br />
println(a1)<br />
<br />
Saída:<br />
0.0<br />
[0 0 0 0]<br />
</pre><br />
<br />
<pre><br />
# Criando um array do tipo inteiro<br />
a2 = Array{Int32}<br />
println(a2)<br />
# Criando um array (de outra maneira) do tipo float<br />
a3 = Float64[]<br />
println(a3)<br />
<br />
Saída:<br />
Array{Int32,N} where N<br />
Float64[]<br />
</pre><br />
<br />
<pre><br />
# Criando um array e definindo valores<br />
a4 = [1,2,3]<br />
#Imprimindo a4<br />
println("Array: ", a4)<br />
<br />
Saída:<br />
Array: [1, 2, 3]<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Imprimindo valor de um indíce específico<br />
println("Imprimindo primeiro elemento: ", a4[1])<br />
# Imprimindo último valor do array<br />
println("Imprimindo último elemento: ",a4[end])<br />
<br />
Saída:<br />
Imprimindo primeiro elemento: 1<br />
Imprimindo último elemento: 3<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
println(a4[2])<br />
# Valores podem mudar (diferente de Tuplas, que veremos adiante)<br />
a4[2] = 4<br />
println(a4[2])<br />
<br />
Saída:<br />
2<br />
4<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
println(a4)<br />
# Número de elementos<br />
println("Imprimindo número de elementos: ",length(a4))<br />
<br />
Saída:<br />
[1, 2, 3]<br />
Imprimindo número de elementos: 3<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Soma os valores do array<br />
println("Imprimindo soma dos elementos: ",sum(a4))<br />
# Põe os valores começando no índice 2<br />
splice!(a4, 2:1, [8,9])<br />
println("Imprimindo Array tendo feito splice!(a4, 2:1, [8,9]): ",a4)<br />
# Remove os itens do índice 2 ao 3<br />
4splice!(a4, 2:3)<br />
println("Imprimindo Array tendo feito splice!(a4, 2:3): ",a4)<br />
<br />
Saída:<br />
Imprimindo soma dos elementos: 6<br />
Imprimindo Array tendo feito splice!(a4, 2:1, [8,9]): [1, 8, 9, 2, 3]<br />
Imprimindo Array tendo feito splice!(a4, 2:3): [1, 2, 3]<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Pegar valor máximo e valor mínimo<br />
println("Imprimindo valor máximo: ",maximum(a4))<br />
println("Imprimindo Array valor mínimo: ",minimum(a4))<br />
# Multiplicando todos os elementos do array por outro número sem precisar de um␣<br />
println("Imprimindo multiplicação dos elementos por 2: ",a4 * 2)<br />
<br />
Saída:<br />
Imprimindo valor máximo: 3<br />
Imprimindo Array valor mínimo: 1<br />
Imprimindo multiplicação dos elementos por 2: [2, 4, 6]<br />
</pre><br />
<br />
<pre><br />
# Arrays podem conter funções<br />
a5 = [sin, cos, tan]<br />
for n in a5<br />
println(n(0))<br />
end<br />
<br />
Saída:<br />
0.0<br />
1.0<br />
0.0<br />
</pre><br />
<br />
<pre><br />
# Para os acostumados com range<br />
a6 = collect(1:5)<br />
println(a6)<br />
<br />
Saída:<br />
[1, 2, 3, 4, 5]<br />
</pre><br />
<br />
'''Tuplas'''<br />
<br />
A maioria das funções de array funciona com tuplas.<br />
<pre><br />
# Valores não podem mudar<br />
t1 = (1,2,3,4)<br />
println(t1[2])<br />
t1[2] = 5<br />
println(t1[2])<br />
<br />
Saída:<br />
2<br />
MethodError: no method matching setindex!(::NTuple{4,Int32}, ::Int32, ::Int32)<br />
</pre><br />
<br />
<pre><br />
# Imprimindo a tupla inteira<br />
println(t1)<br />
# Imprimindo a tupla inteira<br />
for i in t1<br />
println(i)<br />
end<br />
<br />
Saída:<br />
(1, 2, 3, 4)<br />
1<br />
2<br />
3<br />
4<br />
</pre><br />
<br />
'''Dicionários'''<br />
<br />
A palavra-chave deve ser única.<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Imprimir um valor<br />
println(d1["pi"])<br />
<br />
Saída:<br />
3.14<br />
</pre><br />
<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Imprimindo todas as palavras-chaves<br />
println(keys(d1))<br />
# Imprimindo todos os valores<br />
println(values(d1))<br />
# Adicionar uma palavra-chave<br />
d1["golden"] = 1.618<br />
# Deleter uma palavra-chave<br />
delete!(d1, "pi")<br />
# Imprimindo todas as palavras-chaves<br />
println(keys(d1))<br />
# Imprimindo todos os valores<br />
println(values(d1))<br />
<br />
Saída:<br />
["pi", "e"]<br />
[3.14, 2.718]<br />
["e", "golden"]<br />
[2.718, 1.618]<br />
</pre><br />
<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Ver se a palavra-chave existe<br />
println(haskey(d1, "pi"))<br />
# Imprimindo palavras-chaves E valores<br />
for kv in d1<br />
println(kv)<br />
end<br />
<br />
Saída:<br />
true<br />
"pi" => 3.14<br />
"e" => 2.718<br />
</pre><br />
<br />
'''Sets'''<br />
<br />
Sets são arrays com elementos únicos.<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
# Ele não pega os elementos repetidos<br />
println(st1)<br />
<br />
Saída:<br />
Set(["Pam", "Jim"])<br />
</pre><br />
<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
# Adicionando um elemento<br />
push!(st1, "Michael")<br />
println(st1)<br />
# Ver se um elemento está no Set<br />
println(in("Dwight", st1))<br />
<br />
Saída:<br />
Set(["Pam", "Michael", "Jim"])<br />
false<br />
</pre><br />
<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
st2 = Set(["Stanley", "Meredith"])<br />
# Combinando Sets<br />
println(union(st1, st2))<br />
# Imprimindo todo o elemento que os dois Sets tem em comum<br />
println(intersect(st1, st2))<br />
# Imprimindo elementos que estão no primeiro Set, mas não no segundo<br />
println(setdiff(st1, st2))<br />
<br />
Saída:<br />
Set(["Jim", "Meredith", "Stanley", "Pam"])<br />
Set(String[])<br />
Set(["Pam", "Jim"])<br />
</pre><br />
<br />
'''Funções'''<br />
<pre><br />
using Printf<br />
# Função de expressão única<br />
soma(x,y) = x + y<br />
x, y = 1, 2<br />
@printf("%d + %d = %d\n", x, y, x+y)<br />
<br />
Saída:<br />
1 + 2 = 3<br />
</pre><br />
<br />
<pre><br />
# Função de múltiplas expressões<br />
function adoptACat(cats)<br />
if cats <= 1<br />
println("You should adopt a cat.")<br />
else<br />
println("You should adopt a cat. They're cute.")<br />
end<br />
end<br />
adoptACat(2)<br />
<br />
Saída:<br />
You should adopt a cat. They're cute.<br />
</pre><br />
<br />
<pre><br />
v1 = 5<br />
function changeV1(v1)<br />
v1 = 10<br />
end<br />
changeV1(v1)<br />
println(v1)<br />
<br />
Saída:<br />
5<br />
</pre><br />
<br />
<pre><br />
v1 = 5<br />
function changeV1(v1)<br />
v1 = 10<br />
return v1<br />
end<br />
changeV1(v1)<br />
println(v1)<br />
v2 = changeV1(v1)<br />
println(v2)<br />
<br />
Saída:<br />
5<br />
10<br />
</pre><br />
<br />
<pre><br />
# Usando variáveis globais dentro da função<br />
v1 = 5<br />
function changeV12()<br />
global v1 = 10<br />
end<br />
changeV12()<br />
println(v1)<br />
<br />
Saída:<br />
10<br />
</pre><br />
<br />
<pre><br />
# Quando não sei quantos argumentos vou passar<br />
function soma(args...)<br />
sum = 0<br />
for i in args<br />
sum += i<br />
end<br />
println(sum)<br />
end<br />
soma(1,2,3)<br />
<br />
Saída:<br />
6<br />
</pre><br />
<br />
<pre><br />
# Retornando mais de um valor<br />
function retorna2(valor)<br />
return (valor + 1, valor + 2)<br />
end<br />
println(retorna2(4))<br />
<br />
Saída:<br />
(5, 6)<br />
</pre><br />
<br />
<pre><br />
# Map é uma função anônima que aplica uma função para cada elemento<br />
v = map(x -> x * x, [1,2,3])<br />
println(v)<br />
<br />
Saída:<br />
[1, 4, 9]<br />
<br />
'''Structs'''<br />
<pre><br />
struct Estudante<br />
name::String<br />
saldoTRI::Float32<br />
cartaoUFRGS::Int<br />
end<br />
# Criando um objeto<br />
estudante1 = Estudante("Raquel", 10.50, 244449)<br />
println(estudante1.name, "\n", estudante1.saldoTRI, "\n", estudante1.cartaoUFRGS)<br />
<br />
Saída:<br />
Raquel<br />
10.5<br />
244449<br />
9<br />
</pre><br />
<br />
'''Tipos Abstratos'''<br />
<br />
Tipos abstratos não podem ser instanciados como as Structs (instanciar => fazer estudante1 =<br />
Estudante(“Raquel”, 10.50, 244449) => criar um objeto) MAS podem ter subTipos e isso é muito<br />
útil!<br />
<br />
<pre><br />
abstract type animal end<br />
struct cachorro <: animal<br />
nome::String<br />
latido::String<br />
end<br />
struct gato <: animal<br />
nome::String<br />
miado::String<br />
end<br />
cachorro1 = cachorro("Urso", "Au Au")<br />
gato1 = gato("Lucia Irene", "Miau")<br />
# Criando funções pros subTipos<br />
function fazerSom(animal::cachorro)<br />
println("$(animal.nome) diz $(animal.latido)")<br />
end<br />
function fazerSom(animal::gato)<br />
println("$(animal.nome) diz $(animal.miado)")<br />
end<br />
fazerSom(cachorro1)<br />
fazerSom(gato1)<br />
<br />
Saída: <br />
Urso diz Au Au<br />
Lucia Irene diz Miau<br />
</pre></div>Raquelmhttp://fiscomp.if.ufrgs.br/index.php?title=Julia&diff=2512Julia2020-01-07T14:42:28Z<p>Raquelm: /* Aprendendo Julia */</p>
<hr />
<div>Julia é uma linguagem relativamente nova de programação que começou a ser desenvolvida em 2009 por Jeff Bezanson, Stefan Karpinski, Viral B. Shah, e Alan Edelman, um grupo do MIT. Ela foi oficialmente lançada para o mundo em 2012.<br />
<br />
Em uma entrevista, quando perguntaram a Alan o por quê do nome Julia, ele disse que numa conversa anos atrás alguém sugeriu que Julia seria um bom nome para uma linguagem de programação.<br />
<br />
Julia pode ser usada para propósitos gerais de programação, assim como Python, mas em sua criação foi visada a utilização de Julia para Cálculo Numérico.<br />
<br />
== Aspectos Gerais ==<br />
<br />
Julia é uma linguagem de alto nível, isso significa, de maneira sucinta, que ela não é executada utilizando somente o processador, assim como acontece com linguagens de baixo nível, como Assembly, por exemplo.<br />
<br />
É escrita em C, C++, e Scheme, usando a estrutura do compilador LLVM (para melhor entendimento, o compilador de C é o GCC, por exemplo), enquanto a maior parte da biblioteca padrão de Julia é implementada na própria Julia.<br />
<br />
Um fato importante sobre Julia para os programadores de Python é que todas as bibliotecas de Python são usáveis através de um comando simples: PyCall.<br />
<br />
Um fato importante sobre Julia para os programadores de C é que Julia possui APIs (Interfaces de Programação de Aplicativos) especiais para chamada de funções em C diretamente.<br />
<br />
== Velocidade ==<br />
<br />
De acordo com testes feitos pelos próprios criadores de Julia, sua velocidade é similar com a de C.<br />
<br />
<br />
<center>[[Arquivo:juliasvelocity.png|border]]<br />
Fonte: [https://julialang.org/benchmarks/]<br />
</center><br />
<br />
<br />
== Testes de Velocidade ==<br />
<br />
A fim de pessoalmente testar a velocidade da linguagem de programação, foi escrito um programa em Julia de maneira similar ao programa de Python para o FTCS aplicado na Equação de Difusão (também conhecida como Equação do Calor). <br />
<br />
A Equação da Difusão em uma dimensão pode ser escrita da forma:<br />
<br />
<center><math>\frac{df}{dt}=\frac{d^{2}f}{dx^{2}}</math></center><br />
<br />
No método de FTCS (Forward-Time Central-Space) definimos a derivada em t na forma não simetrizada (forward) e as derivadas em x na forma simetrizada:<br />
<br />
<br />
<center><math>\frac{df}{dt} = \frac{f(x, t+dt) - f(x,t)}{dt}</math></center><br />
<br />
<p><br />
<br />
<center><math>\frac{d^{2}f}{dx^{2}} = \frac{f(x+dx, t) + f(x-dx, t) - 2f(x,t)}{dx^{2}}</math></center><br />
<br />
E substuindo na equação da difusão, em notação discreta temos:<br />
<br />
<center><math>f_{j}^{n+1} = f_{j}^{n} + D\frac{dt}{(dx)^{2}}[f_{j+1}^{n} + f_{j-1}^{n} - 2 f_{j}^{n}]</math></center><br />
<br />
'''Observação:''' esse procedimento funciona bem se <math>k=D\frac{dt}{(dx)^{2}} <= 1/2</math>, segundo análise de estabilidade do método.<br />
<br />
<br />
Dessa forma, foi escrito um programa para integrar a Equação de Difusão através do método de FTCS nas linguagens Python e Julia.<br />
<br />
Para '''Python''':<br />
<pre><br />
# FTCS aplicado na equacao da difusao. Linguagem: PYTHON<br />
<br />
import copy<br />
import numpy as np<br />
import matplotlib.pyplot as plt<br />
<br />
def init():<br />
L=50;D=1.;dt=0.05;dx=1.;t=0;tmax=100.<br />
k=D*dt/(dx*dx) <br />
return L,k,dt,t,tmax<br />
<br />
L,k,dt,t,tmax = init()<br />
<br />
x = np.arange(0,L,1) <br />
f = np.zeros(x.shape)<br />
<br />
a = int(L/3)<br />
b = int(2*L/3)<br />
f[a:b]=1.<br />
f1 = copy.deepcopy(f) <br />
f2 = copy.deepcopy(f)<br />
<br />
while t<tmax:<br />
t+=dt<br />
f1[1:L-1]=f[1:L-1]+k*(f[0:L-2]+f[2:L]-2*f[1:L-1])<br />
f1[L-1]=f[L-1]+k*(f[L-2]+f[0]-2*f[L-1]) <br />
f1[0]=f[0]+k*(f[1]+f[L-1]-2*f[0]) <br />
f=copy.deepcopy(f1) <br />
<br />
sum0=sum(f1)<br />
sum1=sum(f2) <br />
<br />
print("Integral em t=0: %7.4f" % sum0)<br />
print("Integral em tmax: %7.4f" % sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
Em '''Julia''':<br />
<pre><br />
# FTCS aplicado na equacao da difusao. Linguagem: JULIA<br />
<br />
using PyPlot<br />
<br />
L=50<br />
D=1.<br />
dt=0.05<br />
dx=1.<br />
t=0<br />
tmax=100.<br />
k=D*dt/(dx*dx) <br />
<br />
x = collect(0:1:L-1)<br />
f = zeros(L)<br />
f1 = zeros(L)<br />
<br />
a = trunc(Int, L/3) <br />
b = trunc(Int, 2*L/3)<br />
<br />
f[a+1:b] .= 1.<br />
f2 = deepcopy(f)<br />
<br />
while t<tmax<br />
global t+=dt <br />
f1[2:L-1] = f[2:L-1] + k*(f[1:L-2] + f[3:L] - 2*f[2:L-1]) <br />
f1[L] = f[L] + k*(f[L-1] + f[1] - 2*f[L])<br />
f1[1] = f[1] + k*(f[2] + f[L] - 2*f[1]) <br />
global f = deepcopy(f1) <br />
end<br />
<br />
sum0 = sum(f1)<br />
sum1 = sum(f2)<br />
<br />
println("Integral em t=0: ", sum0)<br />
println("Integral em tmax: ", sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
<br />
Foi testado o tempo de execução da parte principal dos dois programas (isto é, sem fazer o gráfico dos resultados), através do timer do terminal, como mostra na próxima figura:<br />
<br />
<center>[[Arquivo:Ftcs_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o método de FTCS aplicado à Equação de Difusão<br />
</center><br />
<br />
É possível perceber, através da figura acima, que o tempo de execução de Python para o FTCS aplicado à Equação de Difusão é menor do que o de Julia. Em razão disso, foi testado um programa simples, como mostra abaixo, que incrementa uma variável 10 vezes, sendo o seu valor inicial 0.<br />
<br />
<br />
<center>[[Arquivo:For.png|border]]<br />
'''Legenda:''' Programa para incrementar o valor de uma variável, nesse caso ''i'', 10 vezes, escrito em Julia e em Python<br />
</center><br />
<br />
E posteriormente, novamente, foi testado o tempo de execução da parte principal dos programas através do terminal:<br />
<br />
<center>[[Arquivo:For_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o programa que incrementa o valor da variável 10 vezes<br />
</center><br />
<br />
É possível perceber que para esse simples programa de incrementação, Python ainda obtém melhor performance do que Julia.<br />
<br />
== Performance de Julia ==<br />
<br />
Tentando entender o que traria tal performance em Cálculo Numérico para Julia, foi chegado à conclusão de que ser uma linguagem que se utilizada de ''variáveis dinâmicas'' e ''multi-métodos'' seria uma das grandes contribuições da linguagem.<br />
<br />
'''Variáveis dinâmicas:'''<br />
<br />
Em Python as variáveis são interpretadas em runtime, ou seja, '''tempo de execução''' => o programa checa toda hora se a variável mudou e isso torna ele mais lento<br />
<br />
'''Variáveis estáticas:'''<br />
<br />
Em C as variáveis são fixas, e isso é visto é em '''tempo de compilação''' => precisa pensar nas variáveis e isso torna o tempo de programação mais lento<br />
<br />
Em Julia isso é basicamente opcional, não é preciso definir as variáveis, mas é possível, e elas podem mudar dinamicamente, em tempo de execução. E ainda, Julia se utiliza de multi-métodos para não ter que lidar com a constante checagem dos tipos das variáveis, como Python faz!<br />
<br />
'''Métodos Únicos'''<br />
<br />
Python => Métodos Únicos (single dispatch)<br />
- Não tenho sobrecarga de funções, eu simplesmente chamo uma função que já está escrita<br />
<br />
'''Multi-métodos'''<br />
<br />
Sobrecarga de funções (C++) => Multi-métodos (multiple dispatch)<br />
- Tenho uma função e dependendo dos parâmetros que eu coloco ao chamá-la, eu chamo uma função ou outra<br />
<br />
'''Exemplo de sobrecarga de funções em Julia:'''<br />
<br />
<pre> <br />
# Dependendo do tipo da minha variável x na chamada da função, será chamada uma função ou outra, mesmo que tenham o mesmo nome<br />
<br />
function printx(x::Float64)<br />
println(x)<br />
end<br />
<br />
function printx(x::String)<br />
println(x)<br />
end<br />
<br />
x="Oi"<br />
<br />
printx(x)<br />
</pre><br />
<br />
== Performance de Julia: na prática ==<br />
Para resumir, temos: <br />
<br />
Python => dynamic (variáveis dinâmicas) single dispatch (métodos únicos)<br />
<br />
C++ => static (variáveis estáticas) multiple dispatch (multi-métodos)<br />
<br />
Julia => dynamic multiple dispatch (''o melhor dos dois mundos!'')<br />
<br />
Na prática, é mostrado abaixo um exemplo da performance de Julia como linguagem de programação em dynamic multiple dispatch. <br />
<br />
O mesmo programa foi escrito em Julia e em C++. <br />
<br />
Em '''Julia''':<br />
<br />
<pre><br />
abstract type Animal end<br />
<br />
struct Cachorro <: Animal<br />
nome::String<br />
end<br />
<br />
struct Gato <: Animal<br />
nome::String<br />
end<br />
<br />
# Função de encontro que recebe tipo genérico de animal<br />
function encontroDeAnimais(a::Animal, b::Animal)<br />
acao = encontro(a,b)<br />
println("$(a.nome) encontra $(b.nome) e $acao")<br />
end<br />
<br />
# Funções de expressão única que recebem diferentes tipos de animais<br />
encontro(a::Cachorro, b::Cachorro) = "cheira" <br />
encontro(a::Cachorro, b::Gato) = "persegue"<br />
encontro(a::Gato, b::Gato) = "lambe"<br />
encontro(a::Gato, b::Cachorro) = "ignora" <br />
<br />
# Instanciando os bichinhos<br />
gato1 = Gato("Luciene Maria")<br />
gato2 = Gato("Mel")<br />
cachorro1 = Cachorro("Batata")<br />
cachorro2 = Cachorro("Snoopy")<br />
<br />
# Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2)<br />
encontroDeAnimais(gato1, cachorro2)<br />
encontroDeAnimais(cachorro1, cachorro2)<br />
</pre><br />
<br />
<br />
Em '''C++''':<br />
<br />
<pre><br />
#include <iostream><br />
using namespace std;<br />
<br />
class Animal { <br />
public:<br />
string nome;<br />
};<br />
<br />
string encontro(Animal a, Animal b) {}<br />
<br />
// Função de encontro que recebe tipo genérico de animal<br />
void encontroDeAnimais(Animal a, Animal b) {<br />
string acao = encontro(a,b);<br />
cout << a.nome << " encontra " << b.nome << " e " << acao << endl;<br />
}<br />
<br />
class Cachorro:public Animal {};<br />
class Gato:public Animal {};<br />
<br />
// Funções de expressão única que recebem diferentes tipos de animais<br />
string encontro(Cachorro a, Cachorro b) { return "cheira"; }<br />
string encontro(Cachorro a, Gato b) { return "persegue"; }<br />
string encontro(Gato a, Gato b) { return "lambe"; }<br />
string encontro(Gato a, Cachorro b) { return "ignora"; }<br />
<br />
int main() {<br />
// Instanciando os bichinhos<br />
Gato gato1; gato1.nome = "Luciene Maria";<br />
Gato gato2; gato2.nome = "Mel";<br />
Cachorro cachorro1; cachorro1.nome = "Batata";<br />
Cachorro cachorro2; cachorro2.nome = "Snoopy";<br />
<br />
// Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2);<br />
encontroDeAnimais(gato1, cachorro2);<br />
encontroDeAnimais(cachorro1, cachorro2);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Para '''Julia''' nós obtemos o seguinte '''resultado''':<br />
<br />
<pre><br />
Luciene Maria encontra Mel e lambe<br />
Luciene Maria encontra Snoopy e ignora<br />
Batata encontra Snoopy e cheira<br />
</pre><br />
<br />
Para '''C++''' o '''resultado''' é:<br />
<br />
<pre><br />
Luciene Maria encontra Mel e<br />
Falha de Segmentação<br />
</pre><br />
<br />
Isso acontece porque C++ não aceita que uma função utilize-se de uma variável sem antes saber qual o tipo dessa variável! Por isso, poder utilizar-se de variáveis dinâmicas quando há multi-métodos é um diferencial que acaba por incrementar a performance de Julia como linguagem de programação visada para o Cálculo Numérico.<br />
<br />
'''Observação:''' é importante ressaltar que os testes feitos não são conclusivos para debater a performance de Julia, em termos estatísticos, e além disso, ser uma linguagem de programação que utiliza de variáveis dinâmicas e multi-métodos não é o único motivo pelo qual Julia poderia trazer tal performance em Cálculo Numérico. Podemos ainda contar com a sua capacidade de '''metaprogramação''', ou seja, Julia pode usar macros e eles são aplicados em tempo de interpretação. Há ainda outros fatores da construção da linguagem que contribuem para sua performance que aqui não foram citados.<br />
<br />
== Aprendendo Julia ==<br />
<br />
Após feita a instalação de Julia, para abri-la no seu terminal de comando é preciso apenas digitar: <pre>$julia</pre> para entrar em seu ambiente de programação.<br />
<br />
É possível, também, programar em um arquivo de texto e executar o programa pelo terminal, fazendo simplesmente:<br />
<br />
<pre><br />
$julia programa.jl <br />
</pre><br />
<br />
'''Impressão na tela'''<br />
<pre><br />
println("Hello World")<br />
<br />
Saída:<br />
Hello World<br />
</pre><br />
<br />
'''Variáveis'''<br />
<br />
Variáveis são atribuídas dinamicamente e podem mudar.<br />
<pre><br />
s = 1<br />
s = "Oi"<br />
println(s)<br />
println(typeof(s))<br />
<br />
Saída:<br />
Oi<br />
String<br />
</pre><br />
<br />
<pre><br />
s::String<br />
s = 1<br />
println(s)<br />
<br />
Saída:<br />
TypeError: in typeassert, expected String, got Int32<br />
</pre><br />
<br />
'''Condicionais'''<br />
<pre><br />
cats = 12<br />
if cats < 1<br />
println("You should adopt a cat.")<br />
elseif cats >= 1 && cats <=6<br />
println("Not enough cats.")<br />
elseif cats >= 7 && cats <= 12<br />
println("Still not enough cats.")<br />
else<br />
println("Gato have more cats.")<br />
end<br />
<br />
Saída:<br />
Still not enough cats.<br />
</pre><br />
<br />
<pre><br />
i = 0<br />
while (i < 10)<br />
global i += 1<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
</pre><br />
<br />
<pre><br />
for i = 1:10<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
</pre><br />
<br />
<pre><br />
for i in [1,2,3]<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
3<br />
</pre><br />
<br />
'''Arrays'''<br />
<pre><br />
# Criando um array de zeros<br />
a1 = zeros()<br />
println(a1)<br />
# Posso definir o tipo e o tamanho do Array (linhas, colunas) também<br />
a1 = zeros(Int32, 1, 4)<br />
println(a1)<br />
<br />
Saída:<br />
0.0<br />
[0 0 0 0]<br />
</pre><br />
<br />
<pre><br />
# Criando um array do tipo inteiro<br />
a2 = Array{Int32}<br />
println(a2)<br />
# Criando um array (de outra maneira) do tipo float<br />
a3 = Float64[]<br />
println(a3)<br />
<br />
Saída:<br />
Array{Int32,N} where N<br />
Float64[]<br />
</pre><br />
<br />
<pre><br />
# Criando um array e definindo valores<br />
a4 = [1,2,3]<br />
#Imprimindo a4<br />
println("Array: ", a4)<br />
<br />
Saída:<br />
Array: [1, 2, 3]<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Imprimindo valor de um indíce específico<br />
println("Imprimindo primeiro elemento: ", a4[1])<br />
# Imprimindo último valor do array<br />
println("Imprimindo último elemento: ",a4[end])<br />
<br />
Saída:<br />
Imprimindo primeiro elemento: 1<br />
Imprimindo último elemento: 3<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
println(a4[2])<br />
# Valores podem mudar (diferente de Tuplas, que veremos adiante)<br />
a4[2] = 4<br />
println(a4[2])<br />
<br />
Saída:<br />
2<br />
4<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
println(a4)<br />
# Número de elementos<br />
println("Imprimindo número de elementos: ",length(a4))<br />
<br />
Saída:<br />
[1, 2, 3]<br />
Imprimindo número de elementos: 3<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Soma os valores do array<br />
println("Imprimindo soma dos elementos: ",sum(a4))<br />
# Põe os valores começando no índice 2<br />
splice!(a4, 2:1, [8,9])<br />
println("Imprimindo Array tendo feito splice!(a4, 2:1, [8,9]): ",a4)<br />
# Remove os itens do índice 2 ao 3<br />
4splice!(a4, 2:3)<br />
println("Imprimindo Array tendo feito splice!(a4, 2:3): ",a4)<br />
<br />
Saída:<br />
Imprimindo soma dos elementos: 6<br />
Imprimindo Array tendo feito splice!(a4, 2:1, [8,9]): [1, 8, 9, 2, 3]<br />
Imprimindo Array tendo feito splice!(a4, 2:3): [1, 2, 3]<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Pegar valor máximo e valor mínimo<br />
println("Imprimindo valor máximo: ",maximum(a4))<br />
println("Imprimindo Array valor mínimo: ",minimum(a4))<br />
# Multiplicando todos os elementos do array por outro número sem precisar de um␣<br />
println("Imprimindo multiplicação dos elementos por 2: ",a4 * 2)<br />
<br />
Saída:<br />
Imprimindo valor máximo: 3<br />
Imprimindo Array valor mínimo: 1<br />
Imprimindo multiplicação dos elementos por 2: [2, 4, 6]<br />
</pre><br />
<br />
<pre><br />
# Arrays podem conter funções<br />
a5 = [sin, cos, tan]<br />
for n in a5<br />
println(n(0))<br />
end<br />
<br />
Saída:<br />
0.0<br />
1.0<br />
0.0<br />
</pre><br />
<br />
<pre><br />
# Para os acostumados com range<br />
a6 = collect(1:5)<br />
println(a6)<br />
<br />
Saída:<br />
[1, 2, 3, 4, 5]<br />
</pre><br />
<br />
'''Tuplas'''<br />
<br />
A maioria das funções de array funciona com tuplas.<br />
<pre><br />
# Valores não podem mudar<br />
t1 = (1,2,3,4)<br />
println(t1[2])<br />
t1[2] = 5<br />
println(t1[2])<br />
<br />
Saída:<br />
2<br />
MethodError: no method matching setindex!(::NTuple{4,Int32}, ::Int32, ::Int32)<br />
</pre><br />
<br />
<pre><br />
# Imprimindo a tupla inteira<br />
println(t1)<br />
# Imprimindo a tupla inteira<br />
for i in t1<br />
println(i)<br />
end<br />
<br />
Saída:<br />
(1, 2, 3, 4)<br />
1<br />
2<br />
3<br />
4<br />
</pre><br />
<br />
'''Dicionários'''<br />
<br />
A palavra-chave deve ser única.<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Imprimir um valor<br />
println(d1["pi"])<br />
<br />
Saída:<br />
3.14<br />
</pre><br />
<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Imprimindo todas as palavras-chaves<br />
println(keys(d1))<br />
# Imprimindo todos os valores<br />
println(values(d1))<br />
# Adicionar uma palavra-chave<br />
d1["golden"] = 1.618<br />
# Deleter uma palavra-chave<br />
delete!(d1, "pi")<br />
# Imprimindo todas as palavras-chaves<br />
println(keys(d1))<br />
# Imprimindo todos os valores<br />
println(values(d1))<br />
<br />
Saída:<br />
["pi", "e"]<br />
[3.14, 2.718]<br />
["e", "golden"]<br />
[2.718, 1.618]<br />
</pre><br />
<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Ver se a palavra-chave existe<br />
println(haskey(d1, "pi"))<br />
# Imprimindo palavras-chaves E valores<br />
for kv in d1<br />
println(kv)<br />
end<br />
<br />
Saída:<br />
true<br />
"pi" => 3.14<br />
"e" => 2.718<br />
</pre><br />
<br />
'''Sets'''<br />
<br />
Sets são arrays com elementos únicos.<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
# Ele não pega os elementos repetidos<br />
println(st1)<br />
<br />
Saída:<br />
Set(["Pam", "Jim"])<br />
</pre><br />
<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
# Adicionando um elemento<br />
push!(st1, "Michael")<br />
println(st1)<br />
# Ver se um elemento está no Set<br />
println(in("Dwight", st1))<br />
<br />
Saída:<br />
Set(["Pam", "Michael", "Jim"])<br />
false<br />
</pre><br />
<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
st2 = Set(["Stanley", "Meredith"])<br />
# Combinando Sets<br />
println(union(st1, st2))<br />
# Imprimindo todo o elemento que os dois Sets tem em comum<br />
println(intersect(st1, st2))<br />
# Imprimindo elementos que estão no primeiro Set, mas não no segundo<br />
println(setdiff(st1, st2))<br />
<br />
Saída:<br />
Set(["Jim", "Meredith", "Stanley", "Pam"])<br />
Set(String[])<br />
Set(["Pam", "Jim"])<br />
</pre><br />
<br />
'''Funções'''<br />
<pre><br />
using Printf<br />
# Função de expressão única<br />
soma(x,y) = x + y<br />
x, y = 1, 2<br />
@printf("%d + %d = %d\n", x, y, x+y)<br />
<br />
Saída:<br />
1 + 2 = 3<br />
</pre><br />
<br />
<pre><br />
# Função de múltiplas expressões<br />
function adoptACat(cats)<br />
if cats <= 1<br />
println("You should adopt a cat.")<br />
else<br />
println("You should adopt a cat. They're cute.")<br />
end<br />
end<br />
adoptACat(2)<br />
<br />
Saída:<br />
You should adopt a cat. They're cute.<br />
</pre><br />
<br />
<pre><br />
v1 = 5<br />
function changeV1(v1)<br />
v1 = 10<br />
end<br />
changeV1(v1)<br />
println(v1)<br />
<br />
Saída:<br />
5<br />
</pre><br />
<br />
<pre><br />
v1 = 5<br />
function changeV1(v1)<br />
v1 = 10<br />
return v1<br />
end<br />
changeV1(v1)<br />
println(v1)<br />
v2 = changeV1(v1)<br />
println(v2)<br />
<br />
Saída:<br />
5<br />
10<br />
</pre><br />
<br />
<pre><br />
# Usando variáveis globais dentro da função<br />
v1 = 5<br />
function changeV12()<br />
global v1 = 10<br />
end<br />
changeV12()<br />
println(v1)<br />
<br />
Saída:<br />
10<br />
</pre><br />
<br />
<pre><br />
# Quando não sei quantos argumentos vou passar<br />
function soma(args...)<br />
sum = 0<br />
for i in args<br />
sum += i<br />
end<br />
println(sum)<br />
end<br />
soma(1,2,3)<br />
<br />
Saída:<br />
6<br />
</pre><br />
<br />
<pre><br />
# Retornando mais de um valor<br />
function retorna2(valor)<br />
return (valor + 1, valor + 2)<br />
end<br />
println(retorna2(4))<br />
<br />
Saída:<br />
(5, 6)<br />
</pre><br />
<br />
<pre><br />
# Map é uma função anônima que aplica uma função para cada elemento<br />
v = map(x -> x * x, [1,2,3])<br />
println(v)<br />
<br />
Saída:<br />
[1, 4, 9]<br />
<br />
'''Structs'''<br />
<pre><br />
struct Estudante<br />
name::String<br />
saldoTRI::Float32<br />
cartaoUFRGS::Int<br />
end<br />
# Criando um objeto<br />
estudante1 = Estudante("Raquel", 10.50, 244449)<br />
println(estudante1.name, "\n", estudante1.saldoTRI, "\n", estudante1.cartaoUFRGS)<br />
<br />
Saída:<br />
Raquel<br />
10.5<br />
244449<br />
9<br />
</pre><br />
<br />
'''Tipos Abstratos'''<br />
<br />
Tipos abstratos não podem ser instanciados como as Structs (instanciar => fazer estudante1 =<br />
Estudante(“Raquel”, 10.50, 244449) => criar um objeto) MAS podem ter subTipos e isso é muito<br />
útil!<br />
<br />
<pre><br />
abstract type animal end<br />
struct cachorro <: animal<br />
nome::String<br />
latido::String<br />
end<br />
struct gato <: animal<br />
nome::String<br />
miado::String<br />
end<br />
cachorro1 = cachorro("Urso", "Au Au")<br />
gato1 = gato("Lucia Irene", "Miau")<br />
# Criando funções pros subTipos<br />
function fazerSom(animal::cachorro)<br />
println("$(animal.nome) diz $(animal.latido)")<br />
end<br />
function fazerSom(animal::gato)<br />
println("$(animal.nome) diz $(animal.miado)")<br />
end<br />
fazerSom(cachorro1)<br />
fazerSom(gato1)<br />
<br />
Saída: <br />
Urso diz Au Au<br />
Lucia Irene diz Miau<br />
</pre></div>Raquelmhttp://fiscomp.if.ufrgs.br/index.php?title=Julia&diff=2511Julia2020-01-07T14:42:09Z<p>Raquelm: /* Aprendendo Julia */</p>
<hr />
<div>Julia é uma linguagem relativamente nova de programação que começou a ser desenvolvida em 2009 por Jeff Bezanson, Stefan Karpinski, Viral B. Shah, e Alan Edelman, um grupo do MIT. Ela foi oficialmente lançada para o mundo em 2012.<br />
<br />
Em uma entrevista, quando perguntaram a Alan o por quê do nome Julia, ele disse que numa conversa anos atrás alguém sugeriu que Julia seria um bom nome para uma linguagem de programação.<br />
<br />
Julia pode ser usada para propósitos gerais de programação, assim como Python, mas em sua criação foi visada a utilização de Julia para Cálculo Numérico.<br />
<br />
== Aspectos Gerais ==<br />
<br />
Julia é uma linguagem de alto nível, isso significa, de maneira sucinta, que ela não é executada utilizando somente o processador, assim como acontece com linguagens de baixo nível, como Assembly, por exemplo.<br />
<br />
É escrita em C, C++, e Scheme, usando a estrutura do compilador LLVM (para melhor entendimento, o compilador de C é o GCC, por exemplo), enquanto a maior parte da biblioteca padrão de Julia é implementada na própria Julia.<br />
<br />
Um fato importante sobre Julia para os programadores de Python é que todas as bibliotecas de Python são usáveis através de um comando simples: PyCall.<br />
<br />
Um fato importante sobre Julia para os programadores de C é que Julia possui APIs (Interfaces de Programação de Aplicativos) especiais para chamada de funções em C diretamente.<br />
<br />
== Velocidade ==<br />
<br />
De acordo com testes feitos pelos próprios criadores de Julia, sua velocidade é similar com a de C.<br />
<br />
<br />
<center>[[Arquivo:juliasvelocity.png|border]]<br />
Fonte: [https://julialang.org/benchmarks/]<br />
</center><br />
<br />
<br />
== Testes de Velocidade ==<br />
<br />
A fim de pessoalmente testar a velocidade da linguagem de programação, foi escrito um programa em Julia de maneira similar ao programa de Python para o FTCS aplicado na Equação de Difusão (também conhecida como Equação do Calor). <br />
<br />
A Equação da Difusão em uma dimensão pode ser escrita da forma:<br />
<br />
<center><math>\frac{df}{dt}=\frac{d^{2}f}{dx^{2}}</math></center><br />
<br />
No método de FTCS (Forward-Time Central-Space) definimos a derivada em t na forma não simetrizada (forward) e as derivadas em x na forma simetrizada:<br />
<br />
<br />
<center><math>\frac{df}{dt} = \frac{f(x, t+dt) - f(x,t)}{dt}</math></center><br />
<br />
<p><br />
<br />
<center><math>\frac{d^{2}f}{dx^{2}} = \frac{f(x+dx, t) + f(x-dx, t) - 2f(x,t)}{dx^{2}}</math></center><br />
<br />
E substuindo na equação da difusão, em notação discreta temos:<br />
<br />
<center><math>f_{j}^{n+1} = f_{j}^{n} + D\frac{dt}{(dx)^{2}}[f_{j+1}^{n} + f_{j-1}^{n} - 2 f_{j}^{n}]</math></center><br />
<br />
'''Observação:''' esse procedimento funciona bem se <math>k=D\frac{dt}{(dx)^{2}} <= 1/2</math>, segundo análise de estabilidade do método.<br />
<br />
<br />
Dessa forma, foi escrito um programa para integrar a Equação de Difusão através do método de FTCS nas linguagens Python e Julia.<br />
<br />
Para '''Python''':<br />
<pre><br />
# FTCS aplicado na equacao da difusao. Linguagem: PYTHON<br />
<br />
import copy<br />
import numpy as np<br />
import matplotlib.pyplot as plt<br />
<br />
def init():<br />
L=50;D=1.;dt=0.05;dx=1.;t=0;tmax=100.<br />
k=D*dt/(dx*dx) <br />
return L,k,dt,t,tmax<br />
<br />
L,k,dt,t,tmax = init()<br />
<br />
x = np.arange(0,L,1) <br />
f = np.zeros(x.shape)<br />
<br />
a = int(L/3)<br />
b = int(2*L/3)<br />
f[a:b]=1.<br />
f1 = copy.deepcopy(f) <br />
f2 = copy.deepcopy(f)<br />
<br />
while t<tmax:<br />
t+=dt<br />
f1[1:L-1]=f[1:L-1]+k*(f[0:L-2]+f[2:L]-2*f[1:L-1])<br />
f1[L-1]=f[L-1]+k*(f[L-2]+f[0]-2*f[L-1]) <br />
f1[0]=f[0]+k*(f[1]+f[L-1]-2*f[0]) <br />
f=copy.deepcopy(f1) <br />
<br />
sum0=sum(f1)<br />
sum1=sum(f2) <br />
<br />
print("Integral em t=0: %7.4f" % sum0)<br />
print("Integral em tmax: %7.4f" % sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
Em '''Julia''':<br />
<pre><br />
# FTCS aplicado na equacao da difusao. Linguagem: JULIA<br />
<br />
using PyPlot<br />
<br />
L=50<br />
D=1.<br />
dt=0.05<br />
dx=1.<br />
t=0<br />
tmax=100.<br />
k=D*dt/(dx*dx) <br />
<br />
x = collect(0:1:L-1)<br />
f = zeros(L)<br />
f1 = zeros(L)<br />
<br />
a = trunc(Int, L/3) <br />
b = trunc(Int, 2*L/3)<br />
<br />
f[a+1:b] .= 1.<br />
f2 = deepcopy(f)<br />
<br />
while t<tmax<br />
global t+=dt <br />
f1[2:L-1] = f[2:L-1] + k*(f[1:L-2] + f[3:L] - 2*f[2:L-1]) <br />
f1[L] = f[L] + k*(f[L-1] + f[1] - 2*f[L])<br />
f1[1] = f[1] + k*(f[2] + f[L] - 2*f[1]) <br />
global f = deepcopy(f1) <br />
end<br />
<br />
sum0 = sum(f1)<br />
sum1 = sum(f2)<br />
<br />
println("Integral em t=0: ", sum0)<br />
println("Integral em tmax: ", sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
<br />
Foi testado o tempo de execução da parte principal dos dois programas (isto é, sem fazer o gráfico dos resultados), através do timer do terminal, como mostra na próxima figura:<br />
<br />
<center>[[Arquivo:Ftcs_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o método de FTCS aplicado à Equação de Difusão<br />
</center><br />
<br />
É possível perceber, através da figura acima, que o tempo de execução de Python para o FTCS aplicado à Equação de Difusão é menor do que o de Julia. Em razão disso, foi testado um programa simples, como mostra abaixo, que incrementa uma variável 10 vezes, sendo o seu valor inicial 0.<br />
<br />
<br />
<center>[[Arquivo:For.png|border]]<br />
'''Legenda:''' Programa para incrementar o valor de uma variável, nesse caso ''i'', 10 vezes, escrito em Julia e em Python<br />
</center><br />
<br />
E posteriormente, novamente, foi testado o tempo de execução da parte principal dos programas através do terminal:<br />
<br />
<center>[[Arquivo:For_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o programa que incrementa o valor da variável 10 vezes<br />
</center><br />
<br />
É possível perceber que para esse simples programa de incrementação, Python ainda obtém melhor performance do que Julia.<br />
<br />
== Performance de Julia ==<br />
<br />
Tentando entender o que traria tal performance em Cálculo Numérico para Julia, foi chegado à conclusão de que ser uma linguagem que se utilizada de ''variáveis dinâmicas'' e ''multi-métodos'' seria uma das grandes contribuições da linguagem.<br />
<br />
'''Variáveis dinâmicas:'''<br />
<br />
Em Python as variáveis são interpretadas em runtime, ou seja, '''tempo de execução''' => o programa checa toda hora se a variável mudou e isso torna ele mais lento<br />
<br />
'''Variáveis estáticas:'''<br />
<br />
Em C as variáveis são fixas, e isso é visto é em '''tempo de compilação''' => precisa pensar nas variáveis e isso torna o tempo de programação mais lento<br />
<br />
Em Julia isso é basicamente opcional, não é preciso definir as variáveis, mas é possível, e elas podem mudar dinamicamente, em tempo de execução. E ainda, Julia se utiliza de multi-métodos para não ter que lidar com a constante checagem dos tipos das variáveis, como Python faz!<br />
<br />
'''Métodos Únicos'''<br />
<br />
Python => Métodos Únicos (single dispatch)<br />
- Não tenho sobrecarga de funções, eu simplesmente chamo uma função que já está escrita<br />
<br />
'''Multi-métodos'''<br />
<br />
Sobrecarga de funções (C++) => Multi-métodos (multiple dispatch)<br />
- Tenho uma função e dependendo dos parâmetros que eu coloco ao chamá-la, eu chamo uma função ou outra<br />
<br />
'''Exemplo de sobrecarga de funções em Julia:'''<br />
<br />
<pre> <br />
# Dependendo do tipo da minha variável x na chamada da função, será chamada uma função ou outra, mesmo que tenham o mesmo nome<br />
<br />
function printx(x::Float64)<br />
println(x)<br />
end<br />
<br />
function printx(x::String)<br />
println(x)<br />
end<br />
<br />
x="Oi"<br />
<br />
printx(x)<br />
</pre><br />
<br />
== Performance de Julia: na prática ==<br />
Para resumir, temos: <br />
<br />
Python => dynamic (variáveis dinâmicas) single dispatch (métodos únicos)<br />
<br />
C++ => static (variáveis estáticas) multiple dispatch (multi-métodos)<br />
<br />
Julia => dynamic multiple dispatch (''o melhor dos dois mundos!'')<br />
<br />
Na prática, é mostrado abaixo um exemplo da performance de Julia como linguagem de programação em dynamic multiple dispatch. <br />
<br />
O mesmo programa foi escrito em Julia e em C++. <br />
<br />
Em '''Julia''':<br />
<br />
<pre><br />
abstract type Animal end<br />
<br />
struct Cachorro <: Animal<br />
nome::String<br />
end<br />
<br />
struct Gato <: Animal<br />
nome::String<br />
end<br />
<br />
# Função de encontro que recebe tipo genérico de animal<br />
function encontroDeAnimais(a::Animal, b::Animal)<br />
acao = encontro(a,b)<br />
println("$(a.nome) encontra $(b.nome) e $acao")<br />
end<br />
<br />
# Funções de expressão única que recebem diferentes tipos de animais<br />
encontro(a::Cachorro, b::Cachorro) = "cheira" <br />
encontro(a::Cachorro, b::Gato) = "persegue"<br />
encontro(a::Gato, b::Gato) = "lambe"<br />
encontro(a::Gato, b::Cachorro) = "ignora" <br />
<br />
# Instanciando os bichinhos<br />
gato1 = Gato("Luciene Maria")<br />
gato2 = Gato("Mel")<br />
cachorro1 = Cachorro("Batata")<br />
cachorro2 = Cachorro("Snoopy")<br />
<br />
# Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2)<br />
encontroDeAnimais(gato1, cachorro2)<br />
encontroDeAnimais(cachorro1, cachorro2)<br />
</pre><br />
<br />
<br />
Em '''C++''':<br />
<br />
<pre><br />
#include <iostream><br />
using namespace std;<br />
<br />
class Animal { <br />
public:<br />
string nome;<br />
};<br />
<br />
string encontro(Animal a, Animal b) {}<br />
<br />
// Função de encontro que recebe tipo genérico de animal<br />
void encontroDeAnimais(Animal a, Animal b) {<br />
string acao = encontro(a,b);<br />
cout << a.nome << " encontra " << b.nome << " e " << acao << endl;<br />
}<br />
<br />
class Cachorro:public Animal {};<br />
class Gato:public Animal {};<br />
<br />
// Funções de expressão única que recebem diferentes tipos de animais<br />
string encontro(Cachorro a, Cachorro b) { return "cheira"; }<br />
string encontro(Cachorro a, Gato b) { return "persegue"; }<br />
string encontro(Gato a, Gato b) { return "lambe"; }<br />
string encontro(Gato a, Cachorro b) { return "ignora"; }<br />
<br />
int main() {<br />
// Instanciando os bichinhos<br />
Gato gato1; gato1.nome = "Luciene Maria";<br />
Gato gato2; gato2.nome = "Mel";<br />
Cachorro cachorro1; cachorro1.nome = "Batata";<br />
Cachorro cachorro2; cachorro2.nome = "Snoopy";<br />
<br />
// Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2);<br />
encontroDeAnimais(gato1, cachorro2);<br />
encontroDeAnimais(cachorro1, cachorro2);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Para '''Julia''' nós obtemos o seguinte '''resultado''':<br />
<br />
<pre><br />
Luciene Maria encontra Mel e lambe<br />
Luciene Maria encontra Snoopy e ignora<br />
Batata encontra Snoopy e cheira<br />
</pre><br />
<br />
Para '''C++''' o '''resultado''' é:<br />
<br />
<pre><br />
Luciene Maria encontra Mel e<br />
Falha de Segmentação<br />
</pre><br />
<br />
Isso acontece porque C++ não aceita que uma função utilize-se de uma variável sem antes saber qual o tipo dessa variável! Por isso, poder utilizar-se de variáveis dinâmicas quando há multi-métodos é um diferencial que acaba por incrementar a performance de Julia como linguagem de programação visada para o Cálculo Numérico.<br />
<br />
'''Observação:''' é importante ressaltar que os testes feitos não são conclusivos para debater a performance de Julia, em termos estatísticos, e além disso, ser uma linguagem de programação que utiliza de variáveis dinâmicas e multi-métodos não é o único motivo pelo qual Julia poderia trazer tal performance em Cálculo Numérico. Podemos ainda contar com a sua capacidade de '''metaprogramação''', ou seja, Julia pode usar macros e eles são aplicados em tempo de interpretação. Há ainda outros fatores da construção da linguagem que contribuem para sua performance que aqui não foram citados.<br />
<br />
== Aprendendo Julia ==<br />
<br />
Após feita a instalação de Julia, para abri-la no seu terminal de comando é preciso apenas digitar <pre>$julia</pre> para entrar em seu ambiente de programação.<br />
<br />
É possível, também, programar em um arquivo de texto e executar o programa pelo terminal, fazendo simplesmente:<br />
<br />
<pre><br />
$julia programa.jl <br />
</pre><br />
<br />
'''Impressão na tela'''<br />
<pre><br />
println("Hello World")<br />
<br />
Saída:<br />
Hello World<br />
</pre><br />
<br />
'''Variáveis'''<br />
<br />
Variáveis são atribuídas dinamicamente e podem mudar.<br />
<pre><br />
s = 1<br />
s = "Oi"<br />
println(s)<br />
println(typeof(s))<br />
<br />
Saída:<br />
Oi<br />
String<br />
</pre><br />
<br />
<pre><br />
s::String<br />
s = 1<br />
println(s)<br />
<br />
Saída:<br />
TypeError: in typeassert, expected String, got Int32<br />
</pre><br />
<br />
'''Condicionais'''<br />
<pre><br />
cats = 12<br />
if cats < 1<br />
println("You should adopt a cat.")<br />
elseif cats >= 1 && cats <=6<br />
println("Not enough cats.")<br />
elseif cats >= 7 && cats <= 12<br />
println("Still not enough cats.")<br />
else<br />
println("Gato have more cats.")<br />
end<br />
<br />
Saída:<br />
Still not enough cats.<br />
</pre><br />
<br />
<pre><br />
i = 0<br />
while (i < 10)<br />
global i += 1<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
</pre><br />
<br />
<pre><br />
for i = 1:10<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
</pre><br />
<br />
<pre><br />
for i in [1,2,3]<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
3<br />
</pre><br />
<br />
'''Arrays'''<br />
<pre><br />
# Criando um array de zeros<br />
a1 = zeros()<br />
println(a1)<br />
# Posso definir o tipo e o tamanho do Array (linhas, colunas) também<br />
a1 = zeros(Int32, 1, 4)<br />
println(a1)<br />
<br />
Saída:<br />
0.0<br />
[0 0 0 0]<br />
</pre><br />
<br />
<pre><br />
# Criando um array do tipo inteiro<br />
a2 = Array{Int32}<br />
println(a2)<br />
# Criando um array (de outra maneira) do tipo float<br />
a3 = Float64[]<br />
println(a3)<br />
<br />
Saída:<br />
Array{Int32,N} where N<br />
Float64[]<br />
</pre><br />
<br />
<pre><br />
# Criando um array e definindo valores<br />
a4 = [1,2,3]<br />
#Imprimindo a4<br />
println("Array: ", a4)<br />
<br />
Saída:<br />
Array: [1, 2, 3]<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Imprimindo valor de um indíce específico<br />
println("Imprimindo primeiro elemento: ", a4[1])<br />
# Imprimindo último valor do array<br />
println("Imprimindo último elemento: ",a4[end])<br />
<br />
Saída:<br />
Imprimindo primeiro elemento: 1<br />
Imprimindo último elemento: 3<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
println(a4[2])<br />
# Valores podem mudar (diferente de Tuplas, que veremos adiante)<br />
a4[2] = 4<br />
println(a4[2])<br />
<br />
Saída:<br />
2<br />
4<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
println(a4)<br />
# Número de elementos<br />
println("Imprimindo número de elementos: ",length(a4))<br />
<br />
Saída:<br />
[1, 2, 3]<br />
Imprimindo número de elementos: 3<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Soma os valores do array<br />
println("Imprimindo soma dos elementos: ",sum(a4))<br />
# Põe os valores começando no índice 2<br />
splice!(a4, 2:1, [8,9])<br />
println("Imprimindo Array tendo feito splice!(a4, 2:1, [8,9]): ",a4)<br />
# Remove os itens do índice 2 ao 3<br />
4splice!(a4, 2:3)<br />
println("Imprimindo Array tendo feito splice!(a4, 2:3): ",a4)<br />
<br />
Saída:<br />
Imprimindo soma dos elementos: 6<br />
Imprimindo Array tendo feito splice!(a4, 2:1, [8,9]): [1, 8, 9, 2, 3]<br />
Imprimindo Array tendo feito splice!(a4, 2:3): [1, 2, 3]<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Pegar valor máximo e valor mínimo<br />
println("Imprimindo valor máximo: ",maximum(a4))<br />
println("Imprimindo Array valor mínimo: ",minimum(a4))<br />
# Multiplicando todos os elementos do array por outro número sem precisar de um␣<br />
println("Imprimindo multiplicação dos elementos por 2: ",a4 * 2)<br />
<br />
Saída:<br />
Imprimindo valor máximo: 3<br />
Imprimindo Array valor mínimo: 1<br />
Imprimindo multiplicação dos elementos por 2: [2, 4, 6]<br />
</pre><br />
<br />
<pre><br />
# Arrays podem conter funções<br />
a5 = [sin, cos, tan]<br />
for n in a5<br />
println(n(0))<br />
end<br />
<br />
Saída:<br />
0.0<br />
1.0<br />
0.0<br />
</pre><br />
<br />
<pre><br />
# Para os acostumados com range<br />
a6 = collect(1:5)<br />
println(a6)<br />
<br />
Saída:<br />
[1, 2, 3, 4, 5]<br />
</pre><br />
<br />
'''Tuplas'''<br />
<br />
A maioria das funções de array funciona com tuplas.<br />
<pre><br />
# Valores não podem mudar<br />
t1 = (1,2,3,4)<br />
println(t1[2])<br />
t1[2] = 5<br />
println(t1[2])<br />
<br />
Saída:<br />
2<br />
MethodError: no method matching setindex!(::NTuple{4,Int32}, ::Int32, ::Int32)<br />
</pre><br />
<br />
<pre><br />
# Imprimindo a tupla inteira<br />
println(t1)<br />
# Imprimindo a tupla inteira<br />
for i in t1<br />
println(i)<br />
end<br />
<br />
Saída:<br />
(1, 2, 3, 4)<br />
1<br />
2<br />
3<br />
4<br />
</pre><br />
<br />
'''Dicionários'''<br />
<br />
A palavra-chave deve ser única.<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Imprimir um valor<br />
println(d1["pi"])<br />
<br />
Saída:<br />
3.14<br />
</pre><br />
<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Imprimindo todas as palavras-chaves<br />
println(keys(d1))<br />
# Imprimindo todos os valores<br />
println(values(d1))<br />
# Adicionar uma palavra-chave<br />
d1["golden"] = 1.618<br />
# Deleter uma palavra-chave<br />
delete!(d1, "pi")<br />
# Imprimindo todas as palavras-chaves<br />
println(keys(d1))<br />
# Imprimindo todos os valores<br />
println(values(d1))<br />
<br />
Saída:<br />
["pi", "e"]<br />
[3.14, 2.718]<br />
["e", "golden"]<br />
[2.718, 1.618]<br />
</pre><br />
<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Ver se a palavra-chave existe<br />
println(haskey(d1, "pi"))<br />
# Imprimindo palavras-chaves E valores<br />
for kv in d1<br />
println(kv)<br />
end<br />
<br />
Saída:<br />
true<br />
"pi" => 3.14<br />
"e" => 2.718<br />
</pre><br />
<br />
'''Sets'''<br />
<br />
Sets são arrays com elementos únicos.<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
# Ele não pega os elementos repetidos<br />
println(st1)<br />
<br />
Saída:<br />
Set(["Pam", "Jim"])<br />
</pre><br />
<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
# Adicionando um elemento<br />
push!(st1, "Michael")<br />
println(st1)<br />
# Ver se um elemento está no Set<br />
println(in("Dwight", st1))<br />
<br />
Saída:<br />
Set(["Pam", "Michael", "Jim"])<br />
false<br />
</pre><br />
<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
st2 = Set(["Stanley", "Meredith"])<br />
# Combinando Sets<br />
println(union(st1, st2))<br />
# Imprimindo todo o elemento que os dois Sets tem em comum<br />
println(intersect(st1, st2))<br />
# Imprimindo elementos que estão no primeiro Set, mas não no segundo<br />
println(setdiff(st1, st2))<br />
<br />
Saída:<br />
Set(["Jim", "Meredith", "Stanley", "Pam"])<br />
Set(String[])<br />
Set(["Pam", "Jim"])<br />
</pre><br />
<br />
'''Funções'''<br />
<pre><br />
using Printf<br />
# Função de expressão única<br />
soma(x,y) = x + y<br />
x, y = 1, 2<br />
@printf("%d + %d = %d\n", x, y, x+y)<br />
<br />
Saída:<br />
1 + 2 = 3<br />
</pre><br />
<br />
<pre><br />
# Função de múltiplas expressões<br />
function adoptACat(cats)<br />
if cats <= 1<br />
println("You should adopt a cat.")<br />
else<br />
println("You should adopt a cat. They're cute.")<br />
end<br />
end<br />
adoptACat(2)<br />
<br />
Saída:<br />
You should adopt a cat. They're cute.<br />
</pre><br />
<br />
<pre><br />
v1 = 5<br />
function changeV1(v1)<br />
v1 = 10<br />
end<br />
changeV1(v1)<br />
println(v1)<br />
<br />
Saída:<br />
5<br />
</pre><br />
<br />
<pre><br />
v1 = 5<br />
function changeV1(v1)<br />
v1 = 10<br />
return v1<br />
end<br />
changeV1(v1)<br />
println(v1)<br />
v2 = changeV1(v1)<br />
println(v2)<br />
<br />
Saída:<br />
5<br />
10<br />
</pre><br />
<br />
<pre><br />
# Usando variáveis globais dentro da função<br />
v1 = 5<br />
function changeV12()<br />
global v1 = 10<br />
end<br />
changeV12()<br />
println(v1)<br />
<br />
Saída:<br />
10<br />
</pre><br />
<br />
<pre><br />
# Quando não sei quantos argumentos vou passar<br />
function soma(args...)<br />
sum = 0<br />
for i in args<br />
sum += i<br />
end<br />
println(sum)<br />
end<br />
soma(1,2,3)<br />
<br />
Saída:<br />
6<br />
</pre><br />
<br />
<pre><br />
# Retornando mais de um valor<br />
function retorna2(valor)<br />
return (valor + 1, valor + 2)<br />
end<br />
println(retorna2(4))<br />
<br />
Saída:<br />
(5, 6)<br />
</pre><br />
<br />
<pre><br />
# Map é uma função anônima que aplica uma função para cada elemento<br />
v = map(x -> x * x, [1,2,3])<br />
println(v)<br />
<br />
Saída:<br />
[1, 4, 9]<br />
<br />
'''Structs'''<br />
<pre><br />
struct Estudante<br />
name::String<br />
saldoTRI::Float32<br />
cartaoUFRGS::Int<br />
end<br />
# Criando um objeto<br />
estudante1 = Estudante("Raquel", 10.50, 244449)<br />
println(estudante1.name, "\n", estudante1.saldoTRI, "\n", estudante1.cartaoUFRGS)<br />
<br />
Saída:<br />
Raquel<br />
10.5<br />
244449<br />
9<br />
</pre><br />
<br />
'''Tipos Abstratos'''<br />
<br />
Tipos abstratos não podem ser instanciados como as Structs (instanciar => fazer estudante1 =<br />
Estudante(“Raquel”, 10.50, 244449) => criar um objeto) MAS podem ter subTipos e isso é muito<br />
útil!<br />
<br />
<pre><br />
abstract type animal end<br />
struct cachorro <: animal<br />
nome::String<br />
latido::String<br />
end<br />
struct gato <: animal<br />
nome::String<br />
miado::String<br />
end<br />
cachorro1 = cachorro("Urso", "Au Au")<br />
gato1 = gato("Lucia Irene", "Miau")<br />
# Criando funções pros subTipos<br />
function fazerSom(animal::cachorro)<br />
println("$(animal.nome) diz $(animal.latido)")<br />
end<br />
function fazerSom(animal::gato)<br />
println("$(animal.nome) diz $(animal.miado)")<br />
end<br />
fazerSom(cachorro1)<br />
fazerSom(gato1)<br />
<br />
Saída: <br />
Urso diz Au Au<br />
Lucia Irene diz Miau<br />
</pre></div>Raquelmhttp://fiscomp.if.ufrgs.br/index.php?title=Julia&diff=2510Julia2020-01-07T14:39:56Z<p>Raquelm: /* Performance de Julia: na prática */</p>
<hr />
<div>Julia é uma linguagem relativamente nova de programação que começou a ser desenvolvida em 2009 por Jeff Bezanson, Stefan Karpinski, Viral B. Shah, e Alan Edelman, um grupo do MIT. Ela foi oficialmente lançada para o mundo em 2012.<br />
<br />
Em uma entrevista, quando perguntaram a Alan o por quê do nome Julia, ele disse que numa conversa anos atrás alguém sugeriu que Julia seria um bom nome para uma linguagem de programação.<br />
<br />
Julia pode ser usada para propósitos gerais de programação, assim como Python, mas em sua criação foi visada a utilização de Julia para Cálculo Numérico.<br />
<br />
== Aspectos Gerais ==<br />
<br />
Julia é uma linguagem de alto nível, isso significa, de maneira sucinta, que ela não é executada utilizando somente o processador, assim como acontece com linguagens de baixo nível, como Assembly, por exemplo.<br />
<br />
É escrita em C, C++, e Scheme, usando a estrutura do compilador LLVM (para melhor entendimento, o compilador de C é o GCC, por exemplo), enquanto a maior parte da biblioteca padrão de Julia é implementada na própria Julia.<br />
<br />
Um fato importante sobre Julia para os programadores de Python é que todas as bibliotecas de Python são usáveis através de um comando simples: PyCall.<br />
<br />
Um fato importante sobre Julia para os programadores de C é que Julia possui APIs (Interfaces de Programação de Aplicativos) especiais para chamada de funções em C diretamente.<br />
<br />
== Velocidade ==<br />
<br />
De acordo com testes feitos pelos próprios criadores de Julia, sua velocidade é similar com a de C.<br />
<br />
<br />
<center>[[Arquivo:juliasvelocity.png|border]]<br />
Fonte: [https://julialang.org/benchmarks/]<br />
</center><br />
<br />
<br />
== Testes de Velocidade ==<br />
<br />
A fim de pessoalmente testar a velocidade da linguagem de programação, foi escrito um programa em Julia de maneira similar ao programa de Python para o FTCS aplicado na Equação de Difusão (também conhecida como Equação do Calor). <br />
<br />
A Equação da Difusão em uma dimensão pode ser escrita da forma:<br />
<br />
<center><math>\frac{df}{dt}=\frac{d^{2}f}{dx^{2}}</math></center><br />
<br />
No método de FTCS (Forward-Time Central-Space) definimos a derivada em t na forma não simetrizada (forward) e as derivadas em x na forma simetrizada:<br />
<br />
<br />
<center><math>\frac{df}{dt} = \frac{f(x, t+dt) - f(x,t)}{dt}</math></center><br />
<br />
<p><br />
<br />
<center><math>\frac{d^{2}f}{dx^{2}} = \frac{f(x+dx, t) + f(x-dx, t) - 2f(x,t)}{dx^{2}}</math></center><br />
<br />
E substuindo na equação da difusão, em notação discreta temos:<br />
<br />
<center><math>f_{j}^{n+1} = f_{j}^{n} + D\frac{dt}{(dx)^{2}}[f_{j+1}^{n} + f_{j-1}^{n} - 2 f_{j}^{n}]</math></center><br />
<br />
'''Observação:''' esse procedimento funciona bem se <math>k=D\frac{dt}{(dx)^{2}} <= 1/2</math>, segundo análise de estabilidade do método.<br />
<br />
<br />
Dessa forma, foi escrito um programa para integrar a Equação de Difusão através do método de FTCS nas linguagens Python e Julia.<br />
<br />
Para '''Python''':<br />
<pre><br />
# FTCS aplicado na equacao da difusao. Linguagem: PYTHON<br />
<br />
import copy<br />
import numpy as np<br />
import matplotlib.pyplot as plt<br />
<br />
def init():<br />
L=50;D=1.;dt=0.05;dx=1.;t=0;tmax=100.<br />
k=D*dt/(dx*dx) <br />
return L,k,dt,t,tmax<br />
<br />
L,k,dt,t,tmax = init()<br />
<br />
x = np.arange(0,L,1) <br />
f = np.zeros(x.shape)<br />
<br />
a = int(L/3)<br />
b = int(2*L/3)<br />
f[a:b]=1.<br />
f1 = copy.deepcopy(f) <br />
f2 = copy.deepcopy(f)<br />
<br />
while t<tmax:<br />
t+=dt<br />
f1[1:L-1]=f[1:L-1]+k*(f[0:L-2]+f[2:L]-2*f[1:L-1])<br />
f1[L-1]=f[L-1]+k*(f[L-2]+f[0]-2*f[L-1]) <br />
f1[0]=f[0]+k*(f[1]+f[L-1]-2*f[0]) <br />
f=copy.deepcopy(f1) <br />
<br />
sum0=sum(f1)<br />
sum1=sum(f2) <br />
<br />
print("Integral em t=0: %7.4f" % sum0)<br />
print("Integral em tmax: %7.4f" % sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
Em '''Julia''':<br />
<pre><br />
# FTCS aplicado na equacao da difusao. Linguagem: JULIA<br />
<br />
using PyPlot<br />
<br />
L=50<br />
D=1.<br />
dt=0.05<br />
dx=1.<br />
t=0<br />
tmax=100.<br />
k=D*dt/(dx*dx) <br />
<br />
x = collect(0:1:L-1)<br />
f = zeros(L)<br />
f1 = zeros(L)<br />
<br />
a = trunc(Int, L/3) <br />
b = trunc(Int, 2*L/3)<br />
<br />
f[a+1:b] .= 1.<br />
f2 = deepcopy(f)<br />
<br />
while t<tmax<br />
global t+=dt <br />
f1[2:L-1] = f[2:L-1] + k*(f[1:L-2] + f[3:L] - 2*f[2:L-1]) <br />
f1[L] = f[L] + k*(f[L-1] + f[1] - 2*f[L])<br />
f1[1] = f[1] + k*(f[2] + f[L] - 2*f[1]) <br />
global f = deepcopy(f1) <br />
end<br />
<br />
sum0 = sum(f1)<br />
sum1 = sum(f2)<br />
<br />
println("Integral em t=0: ", sum0)<br />
println("Integral em tmax: ", sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
<br />
Foi testado o tempo de execução da parte principal dos dois programas (isto é, sem fazer o gráfico dos resultados), através do timer do terminal, como mostra na próxima figura:<br />
<br />
<center>[[Arquivo:Ftcs_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o método de FTCS aplicado à Equação de Difusão<br />
</center><br />
<br />
É possível perceber, através da figura acima, que o tempo de execução de Python para o FTCS aplicado à Equação de Difusão é menor do que o de Julia. Em razão disso, foi testado um programa simples, como mostra abaixo, que incrementa uma variável 10 vezes, sendo o seu valor inicial 0.<br />
<br />
<br />
<center>[[Arquivo:For.png|border]]<br />
'''Legenda:''' Programa para incrementar o valor de uma variável, nesse caso ''i'', 10 vezes, escrito em Julia e em Python<br />
</center><br />
<br />
E posteriormente, novamente, foi testado o tempo de execução da parte principal dos programas através do terminal:<br />
<br />
<center>[[Arquivo:For_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o programa que incrementa o valor da variável 10 vezes<br />
</center><br />
<br />
É possível perceber que para esse simples programa de incrementação, Python ainda obtém melhor performance do que Julia.<br />
<br />
== Performance de Julia ==<br />
<br />
Tentando entender o que traria tal performance em Cálculo Numérico para Julia, foi chegado à conclusão de que ser uma linguagem que se utilizada de ''variáveis dinâmicas'' e ''multi-métodos'' seria uma das grandes contribuições da linguagem.<br />
<br />
'''Variáveis dinâmicas:'''<br />
<br />
Em Python as variáveis são interpretadas em runtime, ou seja, '''tempo de execução''' => o programa checa toda hora se a variável mudou e isso torna ele mais lento<br />
<br />
'''Variáveis estáticas:'''<br />
<br />
Em C as variáveis são fixas, e isso é visto é em '''tempo de compilação''' => precisa pensar nas variáveis e isso torna o tempo de programação mais lento<br />
<br />
Em Julia isso é basicamente opcional, não é preciso definir as variáveis, mas é possível, e elas podem mudar dinamicamente, em tempo de execução. E ainda, Julia se utiliza de multi-métodos para não ter que lidar com a constante checagem dos tipos das variáveis, como Python faz!<br />
<br />
'''Métodos Únicos'''<br />
<br />
Python => Métodos Únicos (single dispatch)<br />
- Não tenho sobrecarga de funções, eu simplesmente chamo uma função que já está escrita<br />
<br />
'''Multi-métodos'''<br />
<br />
Sobrecarga de funções (C++) => Multi-métodos (multiple dispatch)<br />
- Tenho uma função e dependendo dos parâmetros que eu coloco ao chamá-la, eu chamo uma função ou outra<br />
<br />
'''Exemplo de sobrecarga de funções em Julia:'''<br />
<br />
<pre> <br />
# Dependendo do tipo da minha variável x na chamada da função, será chamada uma função ou outra, mesmo que tenham o mesmo nome<br />
<br />
function printx(x::Float64)<br />
println(x)<br />
end<br />
<br />
function printx(x::String)<br />
println(x)<br />
end<br />
<br />
x="Oi"<br />
<br />
printx(x)<br />
</pre><br />
<br />
== Performance de Julia: na prática ==<br />
Para resumir, temos: <br />
<br />
Python => dynamic (variáveis dinâmicas) single dispatch (métodos únicos)<br />
<br />
C++ => static (variáveis estáticas) multiple dispatch (multi-métodos)<br />
<br />
Julia => dynamic multiple dispatch (''o melhor dos dois mundos!'')<br />
<br />
Na prática, é mostrado abaixo um exemplo da performance de Julia como linguagem de programação em dynamic multiple dispatch. <br />
<br />
O mesmo programa foi escrito em Julia e em C++. <br />
<br />
Em '''Julia''':<br />
<br />
<pre><br />
abstract type Animal end<br />
<br />
struct Cachorro <: Animal<br />
nome::String<br />
end<br />
<br />
struct Gato <: Animal<br />
nome::String<br />
end<br />
<br />
# Função de encontro que recebe tipo genérico de animal<br />
function encontroDeAnimais(a::Animal, b::Animal)<br />
acao = encontro(a,b)<br />
println("$(a.nome) encontra $(b.nome) e $acao")<br />
end<br />
<br />
# Funções de expressão única que recebem diferentes tipos de animais<br />
encontro(a::Cachorro, b::Cachorro) = "cheira" <br />
encontro(a::Cachorro, b::Gato) = "persegue"<br />
encontro(a::Gato, b::Gato) = "lambe"<br />
encontro(a::Gato, b::Cachorro) = "ignora" <br />
<br />
# Instanciando os bichinhos<br />
gato1 = Gato("Luciene Maria")<br />
gato2 = Gato("Mel")<br />
cachorro1 = Cachorro("Batata")<br />
cachorro2 = Cachorro("Snoopy")<br />
<br />
# Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2)<br />
encontroDeAnimais(gato1, cachorro2)<br />
encontroDeAnimais(cachorro1, cachorro2)<br />
</pre><br />
<br />
<br />
Em '''C++''':<br />
<br />
<pre><br />
#include <iostream><br />
using namespace std;<br />
<br />
class Animal { <br />
public:<br />
string nome;<br />
};<br />
<br />
string encontro(Animal a, Animal b) {}<br />
<br />
// Função de encontro que recebe tipo genérico de animal<br />
void encontroDeAnimais(Animal a, Animal b) {<br />
string acao = encontro(a,b);<br />
cout << a.nome << " encontra " << b.nome << " e " << acao << endl;<br />
}<br />
<br />
class Cachorro:public Animal {};<br />
class Gato:public Animal {};<br />
<br />
// Funções de expressão única que recebem diferentes tipos de animais<br />
string encontro(Cachorro a, Cachorro b) { return "cheira"; }<br />
string encontro(Cachorro a, Gato b) { return "persegue"; }<br />
string encontro(Gato a, Gato b) { return "lambe"; }<br />
string encontro(Gato a, Cachorro b) { return "ignora"; }<br />
<br />
int main() {<br />
// Instanciando os bichinhos<br />
Gato gato1; gato1.nome = "Luciene Maria";<br />
Gato gato2; gato2.nome = "Mel";<br />
Cachorro cachorro1; cachorro1.nome = "Batata";<br />
Cachorro cachorro2; cachorro2.nome = "Snoopy";<br />
<br />
// Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2);<br />
encontroDeAnimais(gato1, cachorro2);<br />
encontroDeAnimais(cachorro1, cachorro2);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Para '''Julia''' nós obtemos o seguinte '''resultado''':<br />
<br />
<pre><br />
Luciene Maria encontra Mel e lambe<br />
Luciene Maria encontra Snoopy e ignora<br />
Batata encontra Snoopy e cheira<br />
</pre><br />
<br />
Para '''C++''' o '''resultado''' é:<br />
<br />
<pre><br />
Luciene Maria encontra Mel e<br />
Falha de Segmentação<br />
</pre><br />
<br />
Isso acontece porque C++ não aceita que uma função utilize-se de uma variável sem antes saber qual o tipo dessa variável! Por isso, poder utilizar-se de variáveis dinâmicas quando há multi-métodos é um diferencial que acaba por incrementar a performance de Julia como linguagem de programação visada para o Cálculo Numérico.<br />
<br />
'''Observação:''' é importante ressaltar que os testes feitos não são conclusivos para debater a performance de Julia, em termos estatísticos, e além disso, ser uma linguagem de programação que utiliza de variáveis dinâmicas e multi-métodos não é o único motivo pelo qual Julia poderia trazer tal performance em Cálculo Numérico. Podemos ainda contar com a sua capacidade de '''metaprogramação''', ou seja, Julia pode usar macros e eles são aplicados em tempo de interpretação. Há ainda outros fatores da construção da linguagem que contribuem para sua performance que aqui não foram citados.<br />
<br />
== Aprendendo Julia ==<br />
<br />
Após feita a instalação de Julia, para abri-la no terminal de comando é preciso apenas digitar <pre>$Julia</pre> para entrar no seu ambiente de programação.<br />
<br />
É possível, também, programar em um arquivo de texto e executar o programa pelo terminal, fazendo simplesmente:<br />
<br />
<pre><br />
$julia programa.jl <br />
</pre><br />
<br />
'''Impressão na tela'''<br />
<pre><br />
println("Hello World")<br />
<br />
Saída:<br />
Hello World<br />
</pre><br />
<br />
'''Variáveis'''<br />
<br />
Variáveis são atribuídas dinamicamente e podem mudar.<br />
<pre><br />
s = 1<br />
s = "Oi"<br />
println(s)<br />
println(typeof(s))<br />
<br />
Saída:<br />
Oi<br />
String<br />
</pre><br />
<br />
<pre><br />
s::String<br />
s = 1<br />
println(s)<br />
<br />
Saída:<br />
TypeError: in typeassert, expected String, got Int32<br />
</pre><br />
<br />
'''Condicionais'''<br />
<pre><br />
cats = 12<br />
if cats < 1<br />
println("You should adopt a cat.")<br />
elseif cats >= 1 && cats <=6<br />
println("Not enough cats.")<br />
elseif cats >= 7 && cats <= 12<br />
println("Still not enough cats.")<br />
else<br />
println("Gato have more cats.")<br />
end<br />
<br />
Saída:<br />
Still not enough cats.<br />
</pre><br />
<br />
<pre><br />
i = 0<br />
while (i < 10)<br />
global i += 1<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
</pre><br />
<br />
<pre><br />
for i = 1:10<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
</pre><br />
<br />
<pre><br />
for i in [1,2,3]<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
3<br />
</pre><br />
<br />
'''Arrays'''<br />
<pre><br />
# Criando um array de zeros<br />
a1 = zeros()<br />
println(a1)<br />
# Posso definir o tipo e o tamanho do Array (linhas, colunas) também<br />
a1 = zeros(Int32, 1, 4)<br />
println(a1)<br />
<br />
Saída:<br />
0.0<br />
[0 0 0 0]<br />
</pre><br />
<br />
<pre><br />
# Criando um array do tipo inteiro<br />
a2 = Array{Int32}<br />
println(a2)<br />
# Criando um array (de outra maneira) do tipo float<br />
a3 = Float64[]<br />
println(a3)<br />
<br />
Saída:<br />
Array{Int32,N} where N<br />
Float64[]<br />
</pre><br />
<br />
<pre><br />
# Criando um array e definindo valores<br />
a4 = [1,2,3]<br />
#Imprimindo a4<br />
println("Array: ", a4)<br />
<br />
Saída:<br />
Array: [1, 2, 3]<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Imprimindo valor de um indíce específico<br />
println("Imprimindo primeiro elemento: ", a4[1])<br />
# Imprimindo último valor do array<br />
println("Imprimindo último elemento: ",a4[end])<br />
<br />
Saída:<br />
Imprimindo primeiro elemento: 1<br />
Imprimindo último elemento: 3<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
println(a4[2])<br />
# Valores podem mudar (diferente de Tuplas, que veremos adiante)<br />
a4[2] = 4<br />
println(a4[2])<br />
<br />
Saída:<br />
2<br />
4<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
println(a4)<br />
# Número de elementos<br />
println("Imprimindo número de elementos: ",length(a4))<br />
<br />
Saída:<br />
[1, 2, 3]<br />
Imprimindo número de elementos: 3<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Soma os valores do array<br />
println("Imprimindo soma dos elementos: ",sum(a4))<br />
# Põe os valores começando no índice 2<br />
splice!(a4, 2:1, [8,9])<br />
println("Imprimindo Array tendo feito splice!(a4, 2:1, [8,9]): ",a4)<br />
# Remove os itens do índice 2 ao 3<br />
4splice!(a4, 2:3)<br />
println("Imprimindo Array tendo feito splice!(a4, 2:3): ",a4)<br />
<br />
Saída:<br />
Imprimindo soma dos elementos: 6<br />
Imprimindo Array tendo feito splice!(a4, 2:1, [8,9]): [1, 8, 9, 2, 3]<br />
Imprimindo Array tendo feito splice!(a4, 2:3): [1, 2, 3]<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Pegar valor máximo e valor mínimo<br />
println("Imprimindo valor máximo: ",maximum(a4))<br />
println("Imprimindo Array valor mínimo: ",minimum(a4))<br />
# Multiplicando todos os elementos do array por outro número sem precisar de um␣<br />
println("Imprimindo multiplicação dos elementos por 2: ",a4 * 2)<br />
<br />
Saída:<br />
Imprimindo valor máximo: 3<br />
Imprimindo Array valor mínimo: 1<br />
Imprimindo multiplicação dos elementos por 2: [2, 4, 6]<br />
</pre><br />
<br />
<pre><br />
# Arrays podem conter funções<br />
a5 = [sin, cos, tan]<br />
for n in a5<br />
println(n(0))<br />
end<br />
<br />
Saída:<br />
0.0<br />
1.0<br />
0.0<br />
</pre><br />
<br />
<pre><br />
# Para os acostumados com range<br />
a6 = collect(1:5)<br />
println(a6)<br />
<br />
Saída:<br />
[1, 2, 3, 4, 5]<br />
</pre><br />
<br />
'''Tuplas'''<br />
<br />
A maioria das funções de array funciona com tuplas.<br />
<pre><br />
# Valores não podem mudar<br />
t1 = (1,2,3,4)<br />
println(t1[2])<br />
t1[2] = 5<br />
println(t1[2])<br />
<br />
Saída:<br />
2<br />
MethodError: no method matching setindex!(::NTuple{4,Int32}, ::Int32, ::Int32)<br />
</pre><br />
<br />
<pre><br />
# Imprimindo a tupla inteira<br />
println(t1)<br />
# Imprimindo a tupla inteira<br />
for i in t1<br />
println(i)<br />
end<br />
<br />
Saída:<br />
(1, 2, 3, 4)<br />
1<br />
2<br />
3<br />
4<br />
</pre><br />
<br />
'''Dicionários'''<br />
<br />
A palavra-chave deve ser única.<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Imprimir um valor<br />
println(d1["pi"])<br />
<br />
Saída:<br />
3.14<br />
</pre><br />
<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Imprimindo todas as palavras-chaves<br />
println(keys(d1))<br />
# Imprimindo todos os valores<br />
println(values(d1))<br />
# Adicionar uma palavra-chave<br />
d1["golden"] = 1.618<br />
# Deleter uma palavra-chave<br />
delete!(d1, "pi")<br />
# Imprimindo todas as palavras-chaves<br />
println(keys(d1))<br />
# Imprimindo todos os valores<br />
println(values(d1))<br />
<br />
Saída:<br />
["pi", "e"]<br />
[3.14, 2.718]<br />
["e", "golden"]<br />
[2.718, 1.618]<br />
</pre><br />
<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Ver se a palavra-chave existe<br />
println(haskey(d1, "pi"))<br />
# Imprimindo palavras-chaves E valores<br />
for kv in d1<br />
println(kv)<br />
end<br />
<br />
Saída:<br />
true<br />
"pi" => 3.14<br />
"e" => 2.718<br />
</pre><br />
<br />
'''Sets'''<br />
<br />
Sets são arrays com elementos únicos.<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
# Ele não pega os elementos repetidos<br />
println(st1)<br />
<br />
Saída:<br />
Set(["Pam", "Jim"])<br />
</pre><br />
<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
# Adicionando um elemento<br />
push!(st1, "Michael")<br />
println(st1)<br />
# Ver se um elemento está no Set<br />
println(in("Dwight", st1))<br />
<br />
Saída:<br />
Set(["Pam", "Michael", "Jim"])<br />
false<br />
</pre><br />
<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
st2 = Set(["Stanley", "Meredith"])<br />
# Combinando Sets<br />
println(union(st1, st2))<br />
# Imprimindo todo o elemento que os dois Sets tem em comum<br />
println(intersect(st1, st2))<br />
# Imprimindo elementos que estão no primeiro Set, mas não no segundo<br />
println(setdiff(st1, st2))<br />
<br />
Saída:<br />
Set(["Jim", "Meredith", "Stanley", "Pam"])<br />
Set(String[])<br />
Set(["Pam", "Jim"])<br />
</pre><br />
<br />
'''Funções'''<br />
<pre><br />
using Printf<br />
# Função de expressão única<br />
soma(x,y) = x + y<br />
x, y = 1, 2<br />
@printf("%d + %d = %d\n", x, y, x+y)<br />
<br />
Saída:<br />
1 + 2 = 3<br />
</pre><br />
<br />
<pre><br />
# Função de múltiplas expressões<br />
function adoptACat(cats)<br />
if cats <= 1<br />
println("You should adopt a cat.")<br />
else<br />
println("You should adopt a cat. They're cute.")<br />
end<br />
end<br />
adoptACat(2)<br />
<br />
Saída:<br />
You should adopt a cat. They're cute.<br />
</pre><br />
<br />
<pre><br />
v1 = 5<br />
function changeV1(v1)<br />
v1 = 10<br />
end<br />
changeV1(v1)<br />
println(v1)<br />
<br />
Saída:<br />
5<br />
</pre><br />
<br />
<pre><br />
v1 = 5<br />
function changeV1(v1)<br />
v1 = 10<br />
return v1<br />
end<br />
changeV1(v1)<br />
println(v1)<br />
v2 = changeV1(v1)<br />
println(v2)<br />
<br />
Saída:<br />
5<br />
10<br />
</pre><br />
<br />
<pre><br />
# Usando variáveis globais dentro da função<br />
v1 = 5<br />
function changeV12()<br />
global v1 = 10<br />
end<br />
changeV12()<br />
println(v1)<br />
<br />
Saída:<br />
10<br />
</pre><br />
<br />
<pre><br />
# Quando não sei quantos argumentos vou passar<br />
function soma(args...)<br />
sum = 0<br />
for i in args<br />
sum += i<br />
end<br />
println(sum)<br />
end<br />
soma(1,2,3)<br />
<br />
Saída:<br />
6<br />
</pre><br />
<br />
<pre><br />
# Retornando mais de um valor<br />
function retorna2(valor)<br />
return (valor + 1, valor + 2)<br />
end<br />
println(retorna2(4))<br />
<br />
Saída:<br />
(5, 6)<br />
</pre><br />
<br />
<pre><br />
# Map é uma função anônima que aplica uma função para cada elemento<br />
v = map(x -> x * x, [1,2,3])<br />
println(v)<br />
<br />
Saída:<br />
[1, 4, 9]<br />
<br />
'''Structs'''<br />
<pre><br />
struct Estudante<br />
name::String<br />
saldoTRI::Float32<br />
cartaoUFRGS::Int<br />
end<br />
# Criando um objeto<br />
estudante1 = Estudante("Raquel", 10.50, 244449)<br />
println(estudante1.name, "\n", estudante1.saldoTRI, "\n", estudante1.cartaoUFRGS)<br />
<br />
Saída:<br />
Raquel<br />
10.5<br />
244449<br />
9<br />
</pre><br />
<br />
'''Tipos Abstratos'''<br />
<br />
Tipos abstratos não podem ser instanciados como as Structs (instanciar => fazer estudante1 =<br />
Estudante(“Raquel”, 10.50, 244449) => criar um objeto) MAS podem ter subTipos e isso é muito<br />
útil!<br />
<br />
<pre><br />
abstract type animal end<br />
struct cachorro <: animal<br />
nome::String<br />
latido::String<br />
end<br />
struct gato <: animal<br />
nome::String<br />
miado::String<br />
end<br />
cachorro1 = cachorro("Urso", "Au Au")<br />
gato1 = gato("Lucia Irene", "Miau")<br />
# Criando funções pros subTipos<br />
function fazerSom(animal::cachorro)<br />
println("$(animal.nome) diz $(animal.latido)")<br />
end<br />
function fazerSom(animal::gato)<br />
println("$(animal.nome) diz $(animal.miado)")<br />
end<br />
fazerSom(cachorro1)<br />
fazerSom(gato1)<br />
<br />
Saída: <br />
Urso diz Au Au<br />
Lucia Irene diz Miau<br />
</pre></div>Raquelmhttp://fiscomp.if.ufrgs.br/index.php?title=Julia&diff=2509Julia2020-01-07T14:38:59Z<p>Raquelm: /* Performance de Julia */</p>
<hr />
<div>Julia é uma linguagem relativamente nova de programação que começou a ser desenvolvida em 2009 por Jeff Bezanson, Stefan Karpinski, Viral B. Shah, e Alan Edelman, um grupo do MIT. Ela foi oficialmente lançada para o mundo em 2012.<br />
<br />
Em uma entrevista, quando perguntaram a Alan o por quê do nome Julia, ele disse que numa conversa anos atrás alguém sugeriu que Julia seria um bom nome para uma linguagem de programação.<br />
<br />
Julia pode ser usada para propósitos gerais de programação, assim como Python, mas em sua criação foi visada a utilização de Julia para Cálculo Numérico.<br />
<br />
== Aspectos Gerais ==<br />
<br />
Julia é uma linguagem de alto nível, isso significa, de maneira sucinta, que ela não é executada utilizando somente o processador, assim como acontece com linguagens de baixo nível, como Assembly, por exemplo.<br />
<br />
É escrita em C, C++, e Scheme, usando a estrutura do compilador LLVM (para melhor entendimento, o compilador de C é o GCC, por exemplo), enquanto a maior parte da biblioteca padrão de Julia é implementada na própria Julia.<br />
<br />
Um fato importante sobre Julia para os programadores de Python é que todas as bibliotecas de Python são usáveis através de um comando simples: PyCall.<br />
<br />
Um fato importante sobre Julia para os programadores de C é que Julia possui APIs (Interfaces de Programação de Aplicativos) especiais para chamada de funções em C diretamente.<br />
<br />
== Velocidade ==<br />
<br />
De acordo com testes feitos pelos próprios criadores de Julia, sua velocidade é similar com a de C.<br />
<br />
<br />
<center>[[Arquivo:juliasvelocity.png|border]]<br />
Fonte: [https://julialang.org/benchmarks/]<br />
</center><br />
<br />
<br />
== Testes de Velocidade ==<br />
<br />
A fim de pessoalmente testar a velocidade da linguagem de programação, foi escrito um programa em Julia de maneira similar ao programa de Python para o FTCS aplicado na Equação de Difusão (também conhecida como Equação do Calor). <br />
<br />
A Equação da Difusão em uma dimensão pode ser escrita da forma:<br />
<br />
<center><math>\frac{df}{dt}=\frac{d^{2}f}{dx^{2}}</math></center><br />
<br />
No método de FTCS (Forward-Time Central-Space) definimos a derivada em t na forma não simetrizada (forward) e as derivadas em x na forma simetrizada:<br />
<br />
<br />
<center><math>\frac{df}{dt} = \frac{f(x, t+dt) - f(x,t)}{dt}</math></center><br />
<br />
<p><br />
<br />
<center><math>\frac{d^{2}f}{dx^{2}} = \frac{f(x+dx, t) + f(x-dx, t) - 2f(x,t)}{dx^{2}}</math></center><br />
<br />
E substuindo na equação da difusão, em notação discreta temos:<br />
<br />
<center><math>f_{j}^{n+1} = f_{j}^{n} + D\frac{dt}{(dx)^{2}}[f_{j+1}^{n} + f_{j-1}^{n} - 2 f_{j}^{n}]</math></center><br />
<br />
'''Observação:''' esse procedimento funciona bem se <math>k=D\frac{dt}{(dx)^{2}} <= 1/2</math>, segundo análise de estabilidade do método.<br />
<br />
<br />
Dessa forma, foi escrito um programa para integrar a Equação de Difusão através do método de FTCS nas linguagens Python e Julia.<br />
<br />
Para '''Python''':<br />
<pre><br />
# FTCS aplicado na equacao da difusao. Linguagem: PYTHON<br />
<br />
import copy<br />
import numpy as np<br />
import matplotlib.pyplot as plt<br />
<br />
def init():<br />
L=50;D=1.;dt=0.05;dx=1.;t=0;tmax=100.<br />
k=D*dt/(dx*dx) <br />
return L,k,dt,t,tmax<br />
<br />
L,k,dt,t,tmax = init()<br />
<br />
x = np.arange(0,L,1) <br />
f = np.zeros(x.shape)<br />
<br />
a = int(L/3)<br />
b = int(2*L/3)<br />
f[a:b]=1.<br />
f1 = copy.deepcopy(f) <br />
f2 = copy.deepcopy(f)<br />
<br />
while t<tmax:<br />
t+=dt<br />
f1[1:L-1]=f[1:L-1]+k*(f[0:L-2]+f[2:L]-2*f[1:L-1])<br />
f1[L-1]=f[L-1]+k*(f[L-2]+f[0]-2*f[L-1]) <br />
f1[0]=f[0]+k*(f[1]+f[L-1]-2*f[0]) <br />
f=copy.deepcopy(f1) <br />
<br />
sum0=sum(f1)<br />
sum1=sum(f2) <br />
<br />
print("Integral em t=0: %7.4f" % sum0)<br />
print("Integral em tmax: %7.4f" % sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
Em '''Julia''':<br />
<pre><br />
# FTCS aplicado na equacao da difusao. Linguagem: JULIA<br />
<br />
using PyPlot<br />
<br />
L=50<br />
D=1.<br />
dt=0.05<br />
dx=1.<br />
t=0<br />
tmax=100.<br />
k=D*dt/(dx*dx) <br />
<br />
x = collect(0:1:L-1)<br />
f = zeros(L)<br />
f1 = zeros(L)<br />
<br />
a = trunc(Int, L/3) <br />
b = trunc(Int, 2*L/3)<br />
<br />
f[a+1:b] .= 1.<br />
f2 = deepcopy(f)<br />
<br />
while t<tmax<br />
global t+=dt <br />
f1[2:L-1] = f[2:L-1] + k*(f[1:L-2] + f[3:L] - 2*f[2:L-1]) <br />
f1[L] = f[L] + k*(f[L-1] + f[1] - 2*f[L])<br />
f1[1] = f[1] + k*(f[2] + f[L] - 2*f[1]) <br />
global f = deepcopy(f1) <br />
end<br />
<br />
sum0 = sum(f1)<br />
sum1 = sum(f2)<br />
<br />
println("Integral em t=0: ", sum0)<br />
println("Integral em tmax: ", sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
<br />
Foi testado o tempo de execução da parte principal dos dois programas (isto é, sem fazer o gráfico dos resultados), através do timer do terminal, como mostra na próxima figura:<br />
<br />
<center>[[Arquivo:Ftcs_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o método de FTCS aplicado à Equação de Difusão<br />
</center><br />
<br />
É possível perceber, através da figura acima, que o tempo de execução de Python para o FTCS aplicado à Equação de Difusão é menor do que o de Julia. Em razão disso, foi testado um programa simples, como mostra abaixo, que incrementa uma variável 10 vezes, sendo o seu valor inicial 0.<br />
<br />
<br />
<center>[[Arquivo:For.png|border]]<br />
'''Legenda:''' Programa para incrementar o valor de uma variável, nesse caso ''i'', 10 vezes, escrito em Julia e em Python<br />
</center><br />
<br />
E posteriormente, novamente, foi testado o tempo de execução da parte principal dos programas através do terminal:<br />
<br />
<center>[[Arquivo:For_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o programa que incrementa o valor da variável 10 vezes<br />
</center><br />
<br />
É possível perceber que para esse simples programa de incrementação, Python ainda obtém melhor performance do que Julia.<br />
<br />
== Performance de Julia ==<br />
<br />
Tentando entender o que traria tal performance em Cálculo Numérico para Julia, foi chegado à conclusão de que ser uma linguagem que se utilizada de ''variáveis dinâmicas'' e ''multi-métodos'' seria uma das grandes contribuições da linguagem.<br />
<br />
'''Variáveis dinâmicas:'''<br />
<br />
Em Python as variáveis são interpretadas em runtime, ou seja, '''tempo de execução''' => o programa checa toda hora se a variável mudou e isso torna ele mais lento<br />
<br />
'''Variáveis estáticas:'''<br />
<br />
Em C as variáveis são fixas, e isso é visto é em '''tempo de compilação''' => precisa pensar nas variáveis e isso torna o tempo de programação mais lento<br />
<br />
Em Julia isso é basicamente opcional, não é preciso definir as variáveis, mas é possível, e elas podem mudar dinamicamente, em tempo de execução. E ainda, Julia se utiliza de multi-métodos para não ter que lidar com a constante checagem dos tipos das variáveis, como Python faz!<br />
<br />
'''Métodos Únicos'''<br />
<br />
Python => Métodos Únicos (single dispatch)<br />
- Não tenho sobrecarga de funções, eu simplesmente chamo uma função que já está escrita<br />
<br />
'''Multi-métodos'''<br />
<br />
Sobrecarga de funções (C++) => Multi-métodos (multiple dispatch)<br />
- Tenho uma função e dependendo dos parâmetros que eu coloco ao chamá-la, eu chamo uma função ou outra<br />
<br />
'''Exemplo de sobrecarga de funções em Julia:'''<br />
<br />
<pre> <br />
# Dependendo do tipo da minha variável x na chamada da função, será chamada uma função ou outra, mesmo que tenham o mesmo nome<br />
<br />
function printx(x::Float64)<br />
println(x)<br />
end<br />
<br />
function printx(x::String)<br />
println(x)<br />
end<br />
<br />
x="Oi"<br />
<br />
printx(x)<br />
</pre><br />
<br />
== Performance de Julia: na prática ==<br />
Para resumir, temos: <br />
<br />
Python => dynamic (variáveis dinâmicas) single<br />
dispatch<br />
<br />
C++ => static (variáveis estáticas) multiple dispatch<br />
<br />
Julia => dynamic multiple dispatch (''o melhor dos dois mundos!'')<br />
<br />
Na prática, é mostrado abaixo um exemplo da performance de Julia como linguagem de programação em dynamic multiple dispatch. <br />
<br />
O mesmo programa foi escrito em Julia e em C++. <br />
<br />
Em '''Julia''':<br />
<br />
<pre><br />
abstract type Animal end<br />
<br />
struct Cachorro <: Animal<br />
nome::String<br />
end<br />
<br />
struct Gato <: Animal<br />
nome::String<br />
end<br />
<br />
# Função de encontro que recebe tipo genérico de animal<br />
function encontroDeAnimais(a::Animal, b::Animal)<br />
acao = encontro(a,b)<br />
println("$(a.nome) encontra $(b.nome) e $acao")<br />
end<br />
<br />
# Funções de expressão única que recebem diferentes tipos de animais<br />
encontro(a::Cachorro, b::Cachorro) = "cheira" <br />
encontro(a::Cachorro, b::Gato) = "persegue"<br />
encontro(a::Gato, b::Gato) = "lambe"<br />
encontro(a::Gato, b::Cachorro) = "ignora" <br />
<br />
# Instanciando os bichinhos<br />
gato1 = Gato("Luciene Maria")<br />
gato2 = Gato("Mel")<br />
cachorro1 = Cachorro("Batata")<br />
cachorro2 = Cachorro("Snoopy")<br />
<br />
# Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2)<br />
encontroDeAnimais(gato1, cachorro2)<br />
encontroDeAnimais(cachorro1, cachorro2)<br />
</pre><br />
<br />
<br />
Em '''C++''':<br />
<br />
<pre><br />
#include <iostream><br />
using namespace std;<br />
<br />
class Animal { <br />
public:<br />
string nome;<br />
};<br />
<br />
string encontro(Animal a, Animal b) {}<br />
<br />
// Função de encontro que recebe tipo genérico de animal<br />
void encontroDeAnimais(Animal a, Animal b) {<br />
string acao = encontro(a,b);<br />
cout << a.nome << " encontra " << b.nome << " e " << acao << endl;<br />
}<br />
<br />
class Cachorro:public Animal {};<br />
class Gato:public Animal {};<br />
<br />
// Funções de expressão única que recebem diferentes tipos de animais<br />
string encontro(Cachorro a, Cachorro b) { return "cheira"; }<br />
string encontro(Cachorro a, Gato b) { return "persegue"; }<br />
string encontro(Gato a, Gato b) { return "lambe"; }<br />
string encontro(Gato a, Cachorro b) { return "ignora"; }<br />
<br />
int main() {<br />
// Instanciando os bichinhos<br />
Gato gato1; gato1.nome = "Luciene Maria";<br />
Gato gato2; gato2.nome = "Mel";<br />
Cachorro cachorro1; cachorro1.nome = "Batata";<br />
Cachorro cachorro2; cachorro2.nome = "Snoopy";<br />
<br />
// Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2);<br />
encontroDeAnimais(gato1, cachorro2);<br />
encontroDeAnimais(cachorro1, cachorro2);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Para '''Julia''' nós obtemos o seguinte '''resultado''':<br />
<br />
<pre><br />
Luciene Maria encontra Mel e lambe<br />
Luciene Maria encontra Snoopy e ignora<br />
Batata encontra Snoopy e cheira<br />
</pre><br />
<br />
Para '''C++''' o '''resultado''' é:<br />
<br />
<pre><br />
Luciene Maria encontra Mel e<br />
Falha de Segmentação<br />
</pre><br />
<br />
Isso acontece porque C++ não aceita que uma função utilize-se de uma variável sem antes saber qual o tipo dessa variável! Por isso, poder utilizar-se de variáveis dinâmicas quando há multi-métodos é um diferencial que acaba por incrementar a performance de Julia como linguagem de programação visada para o Cálculo Numérico.<br />
<br />
'''Observação:''' é importante ressaltar que os testes feitos não são conclusivos para debater a performance de Julia, em termos estatísticos, e além disso, ser uma linguagem de programação que utiliza de variáveis dinâmicas e multi-métodos não é o único motivo pelo qual Julia poderia trazer tal performance em Cálculo Numérico. Podemos ainda contar com a sua capacidade de '''metaprogramação''', ou seja, Julia pode usar macros e eles são aplicados em tempo de interpretação. Há ainda outros fatores da construção da linguagem que contribuem para sua performance que aqui não foram citados.<br />
<br />
<br />
== Aprendendo Julia ==<br />
<br />
Após feita a instalação de Julia, para abri-la no terminal de comando é preciso apenas digitar <pre>$Julia</pre> para entrar no seu ambiente de programação.<br />
<br />
É possível, também, programar em um arquivo de texto e executar o programa pelo terminal, fazendo simplesmente:<br />
<br />
<pre><br />
$julia programa.jl <br />
</pre><br />
<br />
'''Impressão na tela'''<br />
<pre><br />
println("Hello World")<br />
<br />
Saída:<br />
Hello World<br />
</pre><br />
<br />
'''Variáveis'''<br />
<br />
Variáveis são atribuídas dinamicamente e podem mudar.<br />
<pre><br />
s = 1<br />
s = "Oi"<br />
println(s)<br />
println(typeof(s))<br />
<br />
Saída:<br />
Oi<br />
String<br />
</pre><br />
<br />
<pre><br />
s::String<br />
s = 1<br />
println(s)<br />
<br />
Saída:<br />
TypeError: in typeassert, expected String, got Int32<br />
</pre><br />
<br />
'''Condicionais'''<br />
<pre><br />
cats = 12<br />
if cats < 1<br />
println("You should adopt a cat.")<br />
elseif cats >= 1 && cats <=6<br />
println("Not enough cats.")<br />
elseif cats >= 7 && cats <= 12<br />
println("Still not enough cats.")<br />
else<br />
println("Gato have more cats.")<br />
end<br />
<br />
Saída:<br />
Still not enough cats.<br />
</pre><br />
<br />
<pre><br />
i = 0<br />
while (i < 10)<br />
global i += 1<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
</pre><br />
<br />
<pre><br />
for i = 1:10<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
</pre><br />
<br />
<pre><br />
for i in [1,2,3]<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
3<br />
</pre><br />
<br />
'''Arrays'''<br />
<pre><br />
# Criando um array de zeros<br />
a1 = zeros()<br />
println(a1)<br />
# Posso definir o tipo e o tamanho do Array (linhas, colunas) também<br />
a1 = zeros(Int32, 1, 4)<br />
println(a1)<br />
<br />
Saída:<br />
0.0<br />
[0 0 0 0]<br />
</pre><br />
<br />
<pre><br />
# Criando um array do tipo inteiro<br />
a2 = Array{Int32}<br />
println(a2)<br />
# Criando um array (de outra maneira) do tipo float<br />
a3 = Float64[]<br />
println(a3)<br />
<br />
Saída:<br />
Array{Int32,N} where N<br />
Float64[]<br />
</pre><br />
<br />
<pre><br />
# Criando um array e definindo valores<br />
a4 = [1,2,3]<br />
#Imprimindo a4<br />
println("Array: ", a4)<br />
<br />
Saída:<br />
Array: [1, 2, 3]<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Imprimindo valor de um indíce específico<br />
println("Imprimindo primeiro elemento: ", a4[1])<br />
# Imprimindo último valor do array<br />
println("Imprimindo último elemento: ",a4[end])<br />
<br />
Saída:<br />
Imprimindo primeiro elemento: 1<br />
Imprimindo último elemento: 3<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
println(a4[2])<br />
# Valores podem mudar (diferente de Tuplas, que veremos adiante)<br />
a4[2] = 4<br />
println(a4[2])<br />
<br />
Saída:<br />
2<br />
4<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
println(a4)<br />
# Número de elementos<br />
println("Imprimindo número de elementos: ",length(a4))<br />
<br />
Saída:<br />
[1, 2, 3]<br />
Imprimindo número de elementos: 3<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Soma os valores do array<br />
println("Imprimindo soma dos elementos: ",sum(a4))<br />
# Põe os valores começando no índice 2<br />
splice!(a4, 2:1, [8,9])<br />
println("Imprimindo Array tendo feito splice!(a4, 2:1, [8,9]): ",a4)<br />
# Remove os itens do índice 2 ao 3<br />
4splice!(a4, 2:3)<br />
println("Imprimindo Array tendo feito splice!(a4, 2:3): ",a4)<br />
<br />
Saída:<br />
Imprimindo soma dos elementos: 6<br />
Imprimindo Array tendo feito splice!(a4, 2:1, [8,9]): [1, 8, 9, 2, 3]<br />
Imprimindo Array tendo feito splice!(a4, 2:3): [1, 2, 3]<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Pegar valor máximo e valor mínimo<br />
println("Imprimindo valor máximo: ",maximum(a4))<br />
println("Imprimindo Array valor mínimo: ",minimum(a4))<br />
# Multiplicando todos os elementos do array por outro número sem precisar de um␣<br />
println("Imprimindo multiplicação dos elementos por 2: ",a4 * 2)<br />
<br />
Saída:<br />
Imprimindo valor máximo: 3<br />
Imprimindo Array valor mínimo: 1<br />
Imprimindo multiplicação dos elementos por 2: [2, 4, 6]<br />
</pre><br />
<br />
<pre><br />
# Arrays podem conter funções<br />
a5 = [sin, cos, tan]<br />
for n in a5<br />
println(n(0))<br />
end<br />
<br />
Saída:<br />
0.0<br />
1.0<br />
0.0<br />
</pre><br />
<br />
<pre><br />
# Para os acostumados com range<br />
a6 = collect(1:5)<br />
println(a6)<br />
<br />
Saída:<br />
[1, 2, 3, 4, 5]<br />
</pre><br />
<br />
'''Tuplas'''<br />
<br />
A maioria das funções de array funciona com tuplas.<br />
<pre><br />
# Valores não podem mudar<br />
t1 = (1,2,3,4)<br />
println(t1[2])<br />
t1[2] = 5<br />
println(t1[2])<br />
<br />
Saída:<br />
2<br />
MethodError: no method matching setindex!(::NTuple{4,Int32}, ::Int32, ::Int32)<br />
</pre><br />
<br />
<pre><br />
# Imprimindo a tupla inteira<br />
println(t1)<br />
# Imprimindo a tupla inteira<br />
for i in t1<br />
println(i)<br />
end<br />
<br />
Saída:<br />
(1, 2, 3, 4)<br />
1<br />
2<br />
3<br />
4<br />
</pre><br />
<br />
'''Dicionários'''<br />
<br />
A palavra-chave deve ser única.<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Imprimir um valor<br />
println(d1["pi"])<br />
<br />
Saída:<br />
3.14<br />
</pre><br />
<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Imprimindo todas as palavras-chaves<br />
println(keys(d1))<br />
# Imprimindo todos os valores<br />
println(values(d1))<br />
# Adicionar uma palavra-chave<br />
d1["golden"] = 1.618<br />
# Deleter uma palavra-chave<br />
delete!(d1, "pi")<br />
# Imprimindo todas as palavras-chaves<br />
println(keys(d1))<br />
# Imprimindo todos os valores<br />
println(values(d1))<br />
<br />
Saída:<br />
["pi", "e"]<br />
[3.14, 2.718]<br />
["e", "golden"]<br />
[2.718, 1.618]<br />
</pre><br />
<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Ver se a palavra-chave existe<br />
println(haskey(d1, "pi"))<br />
# Imprimindo palavras-chaves E valores<br />
for kv in d1<br />
println(kv)<br />
end<br />
<br />
Saída:<br />
true<br />
"pi" => 3.14<br />
"e" => 2.718<br />
</pre><br />
<br />
'''Sets'''<br />
<br />
Sets são arrays com elementos únicos.<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
# Ele não pega os elementos repetidos<br />
println(st1)<br />
<br />
Saída:<br />
Set(["Pam", "Jim"])<br />
</pre><br />
<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
# Adicionando um elemento<br />
push!(st1, "Michael")<br />
println(st1)<br />
# Ver se um elemento está no Set<br />
println(in("Dwight", st1))<br />
<br />
Saída:<br />
Set(["Pam", "Michael", "Jim"])<br />
false<br />
</pre><br />
<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
st2 = Set(["Stanley", "Meredith"])<br />
# Combinando Sets<br />
println(union(st1, st2))<br />
# Imprimindo todo o elemento que os dois Sets tem em comum<br />
println(intersect(st1, st2))<br />
# Imprimindo elementos que estão no primeiro Set, mas não no segundo<br />
println(setdiff(st1, st2))<br />
<br />
Saída:<br />
Set(["Jim", "Meredith", "Stanley", "Pam"])<br />
Set(String[])<br />
Set(["Pam", "Jim"])<br />
</pre><br />
<br />
'''Funções'''<br />
<pre><br />
using Printf<br />
# Função de expressão única<br />
soma(x,y) = x + y<br />
x, y = 1, 2<br />
@printf("%d + %d = %d\n", x, y, x+y)<br />
<br />
Saída:<br />
1 + 2 = 3<br />
</pre><br />
<br />
<pre><br />
# Função de múltiplas expressões<br />
function adoptACat(cats)<br />
if cats <= 1<br />
println("You should adopt a cat.")<br />
else<br />
println("You should adopt a cat. They're cute.")<br />
end<br />
end<br />
adoptACat(2)<br />
<br />
Saída:<br />
You should adopt a cat. They're cute.<br />
</pre><br />
<br />
<pre><br />
v1 = 5<br />
function changeV1(v1)<br />
v1 = 10<br />
end<br />
changeV1(v1)<br />
println(v1)<br />
<br />
Saída:<br />
5<br />
</pre><br />
<br />
<pre><br />
v1 = 5<br />
function changeV1(v1)<br />
v1 = 10<br />
return v1<br />
end<br />
changeV1(v1)<br />
println(v1)<br />
v2 = changeV1(v1)<br />
println(v2)<br />
<br />
Saída:<br />
5<br />
10<br />
</pre><br />
<br />
<pre><br />
# Usando variáveis globais dentro da função<br />
v1 = 5<br />
function changeV12()<br />
global v1 = 10<br />
end<br />
changeV12()<br />
println(v1)<br />
<br />
Saída:<br />
10<br />
</pre><br />
<br />
<pre><br />
# Quando não sei quantos argumentos vou passar<br />
function soma(args...)<br />
sum = 0<br />
for i in args<br />
sum += i<br />
end<br />
println(sum)<br />
end<br />
soma(1,2,3)<br />
<br />
Saída:<br />
6<br />
</pre><br />
<br />
<pre><br />
# Retornando mais de um valor<br />
function retorna2(valor)<br />
return (valor + 1, valor + 2)<br />
end<br />
println(retorna2(4))<br />
<br />
Saída:<br />
(5, 6)<br />
</pre><br />
<br />
<pre><br />
# Map é uma função anônima que aplica uma função para cada elemento<br />
v = map(x -> x * x, [1,2,3])<br />
println(v)<br />
<br />
Saída:<br />
[1, 4, 9]<br />
<br />
'''Structs'''<br />
<pre><br />
struct Estudante<br />
name::String<br />
saldoTRI::Float32<br />
cartaoUFRGS::Int<br />
end<br />
# Criando um objeto<br />
estudante1 = Estudante("Raquel", 10.50, 244449)<br />
println(estudante1.name, "\n", estudante1.saldoTRI, "\n", estudante1.cartaoUFRGS)<br />
<br />
Saída:<br />
Raquel<br />
10.5<br />
244449<br />
9<br />
</pre><br />
<br />
'''Tipos Abstratos'''<br />
<br />
Tipos abstratos não podem ser instanciados como as Structs (instanciar => fazer estudante1 =<br />
Estudante(“Raquel”, 10.50, 244449) => criar um objeto) MAS podem ter subTipos e isso é muito<br />
útil!<br />
<br />
<pre><br />
abstract type animal end<br />
struct cachorro <: animal<br />
nome::String<br />
latido::String<br />
end<br />
struct gato <: animal<br />
nome::String<br />
miado::String<br />
end<br />
cachorro1 = cachorro("Urso", "Au Au")<br />
gato1 = gato("Lucia Irene", "Miau")<br />
# Criando funções pros subTipos<br />
function fazerSom(animal::cachorro)<br />
println("$(animal.nome) diz $(animal.latido)")<br />
end<br />
function fazerSom(animal::gato)<br />
println("$(animal.nome) diz $(animal.miado)")<br />
end<br />
fazerSom(cachorro1)<br />
fazerSom(gato1)<br />
<br />
Saída: <br />
Urso diz Au Au<br />
Lucia Irene diz Miau<br />
</pre></div>Raquelmhttp://fiscomp.if.ufrgs.br/index.php?title=Julia&diff=2508Julia2020-01-07T14:37:58Z<p>Raquelm: /* Performance de Julia */</p>
<hr />
<div>Julia é uma linguagem relativamente nova de programação que começou a ser desenvolvida em 2009 por Jeff Bezanson, Stefan Karpinski, Viral B. Shah, e Alan Edelman, um grupo do MIT. Ela foi oficialmente lançada para o mundo em 2012.<br />
<br />
Em uma entrevista, quando perguntaram a Alan o por quê do nome Julia, ele disse que numa conversa anos atrás alguém sugeriu que Julia seria um bom nome para uma linguagem de programação.<br />
<br />
Julia pode ser usada para propósitos gerais de programação, assim como Python, mas em sua criação foi visada a utilização de Julia para Cálculo Numérico.<br />
<br />
== Aspectos Gerais ==<br />
<br />
Julia é uma linguagem de alto nível, isso significa, de maneira sucinta, que ela não é executada utilizando somente o processador, assim como acontece com linguagens de baixo nível, como Assembly, por exemplo.<br />
<br />
É escrita em C, C++, e Scheme, usando a estrutura do compilador LLVM (para melhor entendimento, o compilador de C é o GCC, por exemplo), enquanto a maior parte da biblioteca padrão de Julia é implementada na própria Julia.<br />
<br />
Um fato importante sobre Julia para os programadores de Python é que todas as bibliotecas de Python são usáveis através de um comando simples: PyCall.<br />
<br />
Um fato importante sobre Julia para os programadores de C é que Julia possui APIs (Interfaces de Programação de Aplicativos) especiais para chamada de funções em C diretamente.<br />
<br />
== Velocidade ==<br />
<br />
De acordo com testes feitos pelos próprios criadores de Julia, sua velocidade é similar com a de C.<br />
<br />
<br />
<center>[[Arquivo:juliasvelocity.png|border]]<br />
Fonte: [https://julialang.org/benchmarks/]<br />
</center><br />
<br />
<br />
== Testes de Velocidade ==<br />
<br />
A fim de pessoalmente testar a velocidade da linguagem de programação, foi escrito um programa em Julia de maneira similar ao programa de Python para o FTCS aplicado na Equação de Difusão (também conhecida como Equação do Calor). <br />
<br />
A Equação da Difusão em uma dimensão pode ser escrita da forma:<br />
<br />
<center><math>\frac{df}{dt}=\frac{d^{2}f}{dx^{2}}</math></center><br />
<br />
No método de FTCS (Forward-Time Central-Space) definimos a derivada em t na forma não simetrizada (forward) e as derivadas em x na forma simetrizada:<br />
<br />
<br />
<center><math>\frac{df}{dt} = \frac{f(x, t+dt) - f(x,t)}{dt}</math></center><br />
<br />
<p><br />
<br />
<center><math>\frac{d^{2}f}{dx^{2}} = \frac{f(x+dx, t) + f(x-dx, t) - 2f(x,t)}{dx^{2}}</math></center><br />
<br />
E substuindo na equação da difusão, em notação discreta temos:<br />
<br />
<center><math>f_{j}^{n+1} = f_{j}^{n} + D\frac{dt}{(dx)^{2}}[f_{j+1}^{n} + f_{j-1}^{n} - 2 f_{j}^{n}]</math></center><br />
<br />
'''Observação:''' esse procedimento funciona bem se <math>k=D\frac{dt}{(dx)^{2}} <= 1/2</math>, segundo análise de estabilidade do método.<br />
<br />
<br />
Dessa forma, foi escrito um programa para integrar a Equação de Difusão através do método de FTCS nas linguagens Python e Julia.<br />
<br />
Para '''Python''':<br />
<pre><br />
# FTCS aplicado na equacao da difusao. Linguagem: PYTHON<br />
<br />
import copy<br />
import numpy as np<br />
import matplotlib.pyplot as plt<br />
<br />
def init():<br />
L=50;D=1.;dt=0.05;dx=1.;t=0;tmax=100.<br />
k=D*dt/(dx*dx) <br />
return L,k,dt,t,tmax<br />
<br />
L,k,dt,t,tmax = init()<br />
<br />
x = np.arange(0,L,1) <br />
f = np.zeros(x.shape)<br />
<br />
a = int(L/3)<br />
b = int(2*L/3)<br />
f[a:b]=1.<br />
f1 = copy.deepcopy(f) <br />
f2 = copy.deepcopy(f)<br />
<br />
while t<tmax:<br />
t+=dt<br />
f1[1:L-1]=f[1:L-1]+k*(f[0:L-2]+f[2:L]-2*f[1:L-1])<br />
f1[L-1]=f[L-1]+k*(f[L-2]+f[0]-2*f[L-1]) <br />
f1[0]=f[0]+k*(f[1]+f[L-1]-2*f[0]) <br />
f=copy.deepcopy(f1) <br />
<br />
sum0=sum(f1)<br />
sum1=sum(f2) <br />
<br />
print("Integral em t=0: %7.4f" % sum0)<br />
print("Integral em tmax: %7.4f" % sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
Em '''Julia''':<br />
<pre><br />
# FTCS aplicado na equacao da difusao. Linguagem: JULIA<br />
<br />
using PyPlot<br />
<br />
L=50<br />
D=1.<br />
dt=0.05<br />
dx=1.<br />
t=0<br />
tmax=100.<br />
k=D*dt/(dx*dx) <br />
<br />
x = collect(0:1:L-1)<br />
f = zeros(L)<br />
f1 = zeros(L)<br />
<br />
a = trunc(Int, L/3) <br />
b = trunc(Int, 2*L/3)<br />
<br />
f[a+1:b] .= 1.<br />
f2 = deepcopy(f)<br />
<br />
while t<tmax<br />
global t+=dt <br />
f1[2:L-1] = f[2:L-1] + k*(f[1:L-2] + f[3:L] - 2*f[2:L-1]) <br />
f1[L] = f[L] + k*(f[L-1] + f[1] - 2*f[L])<br />
f1[1] = f[1] + k*(f[2] + f[L] - 2*f[1]) <br />
global f = deepcopy(f1) <br />
end<br />
<br />
sum0 = sum(f1)<br />
sum1 = sum(f2)<br />
<br />
println("Integral em t=0: ", sum0)<br />
println("Integral em tmax: ", sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
<br />
Foi testado o tempo de execução da parte principal dos dois programas (isto é, sem fazer o gráfico dos resultados), através do timer do terminal, como mostra na próxima figura:<br />
<br />
<center>[[Arquivo:Ftcs_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o método de FTCS aplicado à Equação de Difusão<br />
</center><br />
<br />
É possível perceber, através da figura acima, que o tempo de execução de Python para o FTCS aplicado à Equação de Difusão é menor do que o de Julia. Em razão disso, foi testado um programa simples, como mostra abaixo, que incrementa uma variável 10 vezes, sendo o seu valor inicial 0.<br />
<br />
<br />
<center>[[Arquivo:For.png|border]]<br />
'''Legenda:''' Programa para incrementar o valor de uma variável, nesse caso ''i'', 10 vezes, escrito em Julia e em Python<br />
</center><br />
<br />
E posteriormente, novamente, foi testado o tempo de execução da parte principal dos programas através do terminal:<br />
<br />
<center>[[Arquivo:For_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o programa que incrementa o valor da variável 10 vezes<br />
</center><br />
<br />
É possível perceber que para esse simples programa de incrementação, Python ainda obtém melhor performance do que Julia.<br />
<br />
== Performance de Julia ==<br />
<br />
Tentando entender o que traria tal performance em Cálculo Numérico para Julia, foi chegado à conclusão de que ser uma linguagem que se utilizada de ''variáveis dinâmicas'' e ''multi-métodos'' seria uma das grandes contribuições da linguagem.<br />
<br />
'''Variáveis dinâmicas:'''<br />
<br />
Em Python as variáveis são interpretadas em runtime, ou seja, '''tempo de execução''' => o programa checa toda hora se a variável mudou e isso torna ele mais lento<br />
<br />
'''Variáveis estáticas:'''<br />
<br />
Em C as variáveis são fixas, e isso é visto é em '''tempo de compilação''' => precisa pensar nas variáveis e isso torna o tempo de programação mais lento<br />
<br />
Em Julia isso é basicamente opcional, não é preciso definir as variáveis, mas é possível, e elas podem mudar dinamicamente, em tempo de execução. E ainda, Julia se utiliza de multi-métodos para não ter que lidar com a constante checagem dos tipos das variáveis, como Python faz!<br />
<br />
'''Métodos Únicos'''<br />
<br />
Python => Métodos Únicos (single dispatch)<br />
- Não tenho sobrecarga de funções, eu simplesmente chamo uma função que já está escrita<br />
<br />
'''Multi-métodos'''<br />
<br />
Sobrecarga de funções (C++) => Multi-métodos (multiple dispatch)<br />
- Tenho uma função e dependendo dos parâmetros que eu coloco ao chamá-la, eu chamo uma função ou outra<br />
<br />
'''Exemplo de sobrecarga de funções em Julia:'''<br />
<br />
<pre> <br />
//dependendo do tipo da minha variavel x na chamada da funcao, sera chamado uma funcao ou outra, mesmo que tenham o mesmo nome<br />
<br />
function printx(x::Float64)<br />
println(x)<br />
end<br />
<br />
function printx(x::String)<br />
println(x)<br />
end<br />
<br />
x="Oi"<br />
<br />
printx(x)<br />
</pre><br />
<br />
== Performance de Julia: na prática ==<br />
Para resumir, temos: <br />
<br />
Python => dynamic (variáveis dinâmicas) single<br />
dispatch<br />
<br />
C++ => static (variáveis estáticas) multiple dispatch<br />
<br />
Julia => dynamic multiple dispatch (''o melhor dos dois mundos!'')<br />
<br />
Na prática, é mostrado abaixo um exemplo da performance de Julia como linguagem de programação em dynamic multiple dispatch. <br />
<br />
O mesmo programa foi escrito em Julia e em C++. <br />
<br />
Em '''Julia''':<br />
<br />
<pre><br />
abstract type Animal end<br />
<br />
struct Cachorro <: Animal<br />
nome::String<br />
end<br />
<br />
struct Gato <: Animal<br />
nome::String<br />
end<br />
<br />
# Função de encontro que recebe tipo genérico de animal<br />
function encontroDeAnimais(a::Animal, b::Animal)<br />
acao = encontro(a,b)<br />
println("$(a.nome) encontra $(b.nome) e $acao")<br />
end<br />
<br />
# Funções de expressão única que recebem diferentes tipos de animais<br />
encontro(a::Cachorro, b::Cachorro) = "cheira" <br />
encontro(a::Cachorro, b::Gato) = "persegue"<br />
encontro(a::Gato, b::Gato) = "lambe"<br />
encontro(a::Gato, b::Cachorro) = "ignora" <br />
<br />
# Instanciando os bichinhos<br />
gato1 = Gato("Luciene Maria")<br />
gato2 = Gato("Mel")<br />
cachorro1 = Cachorro("Batata")<br />
cachorro2 = Cachorro("Snoopy")<br />
<br />
# Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2)<br />
encontroDeAnimais(gato1, cachorro2)<br />
encontroDeAnimais(cachorro1, cachorro2)<br />
</pre><br />
<br />
<br />
Em '''C++''':<br />
<br />
<pre><br />
#include <iostream><br />
using namespace std;<br />
<br />
class Animal { <br />
public:<br />
string nome;<br />
};<br />
<br />
string encontro(Animal a, Animal b) {}<br />
<br />
// Função de encontro que recebe tipo genérico de animal<br />
void encontroDeAnimais(Animal a, Animal b) {<br />
string acao = encontro(a,b);<br />
cout << a.nome << " encontra " << b.nome << " e " << acao << endl;<br />
}<br />
<br />
class Cachorro:public Animal {};<br />
class Gato:public Animal {};<br />
<br />
// Funções de expressão única que recebem diferentes tipos de animais<br />
string encontro(Cachorro a, Cachorro b) { return "cheira"; }<br />
string encontro(Cachorro a, Gato b) { return "persegue"; }<br />
string encontro(Gato a, Gato b) { return "lambe"; }<br />
string encontro(Gato a, Cachorro b) { return "ignora"; }<br />
<br />
int main() {<br />
// Instanciando os bichinhos<br />
Gato gato1; gato1.nome = "Luciene Maria";<br />
Gato gato2; gato2.nome = "Mel";<br />
Cachorro cachorro1; cachorro1.nome = "Batata";<br />
Cachorro cachorro2; cachorro2.nome = "Snoopy";<br />
<br />
// Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2);<br />
encontroDeAnimais(gato1, cachorro2);<br />
encontroDeAnimais(cachorro1, cachorro2);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Para '''Julia''' nós obtemos o seguinte '''resultado''':<br />
<br />
<pre><br />
Luciene Maria encontra Mel e lambe<br />
Luciene Maria encontra Snoopy e ignora<br />
Batata encontra Snoopy e cheira<br />
</pre><br />
<br />
Para '''C++''' o '''resultado''' é:<br />
<br />
<pre><br />
Luciene Maria encontra Mel e<br />
Falha de Segmentação<br />
</pre><br />
<br />
Isso acontece porque C++ não aceita que uma função utilize-se de uma variável sem antes saber qual o tipo dessa variável! Por isso, poder utilizar-se de variáveis dinâmicas quando há multi-métodos é um diferencial que acaba por incrementar a performance de Julia como linguagem de programação visada para o Cálculo Numérico.<br />
<br />
'''Observação:''' é importante ressaltar que os testes feitos não são conclusivos para debater a performance de Julia, em termos estatísticos, e além disso, ser uma linguagem de programação que utiliza de variáveis dinâmicas e multi-métodos não é o único motivo pelo qual Julia poderia trazer tal performance em Cálculo Numérico. Podemos ainda contar com a sua capacidade de '''metaprogramação''', ou seja, Julia pode usar macros e eles são aplicados em tempo de interpretação. Há ainda outros fatores da construção da linguagem que contribuem para sua performance que aqui não foram citados.<br />
<br />
<br />
== Aprendendo Julia ==<br />
<br />
Após feita a instalação de Julia, para abri-la no terminal de comando é preciso apenas digitar <pre>$Julia</pre> para entrar no seu ambiente de programação.<br />
<br />
É possível, também, programar em um arquivo de texto e executar o programa pelo terminal, fazendo simplesmente:<br />
<br />
<pre><br />
$julia programa.jl <br />
</pre><br />
<br />
'''Impressão na tela'''<br />
<pre><br />
println("Hello World")<br />
<br />
Saída:<br />
Hello World<br />
</pre><br />
<br />
'''Variáveis'''<br />
<br />
Variáveis são atribuídas dinamicamente e podem mudar.<br />
<pre><br />
s = 1<br />
s = "Oi"<br />
println(s)<br />
println(typeof(s))<br />
<br />
Saída:<br />
Oi<br />
String<br />
</pre><br />
<br />
<pre><br />
s::String<br />
s = 1<br />
println(s)<br />
<br />
Saída:<br />
TypeError: in typeassert, expected String, got Int32<br />
</pre><br />
<br />
'''Condicionais'''<br />
<pre><br />
cats = 12<br />
if cats < 1<br />
println("You should adopt a cat.")<br />
elseif cats >= 1 && cats <=6<br />
println("Not enough cats.")<br />
elseif cats >= 7 && cats <= 12<br />
println("Still not enough cats.")<br />
else<br />
println("Gato have more cats.")<br />
end<br />
<br />
Saída:<br />
Still not enough cats.<br />
</pre><br />
<br />
<pre><br />
i = 0<br />
while (i < 10)<br />
global i += 1<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
</pre><br />
<br />
<pre><br />
for i = 1:10<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
</pre><br />
<br />
<pre><br />
for i in [1,2,3]<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
3<br />
</pre><br />
<br />
'''Arrays'''<br />
<pre><br />
# Criando um array de zeros<br />
a1 = zeros()<br />
println(a1)<br />
# Posso definir o tipo e o tamanho do Array (linhas, colunas) também<br />
a1 = zeros(Int32, 1, 4)<br />
println(a1)<br />
<br />
Saída:<br />
0.0<br />
[0 0 0 0]<br />
</pre><br />
<br />
<pre><br />
# Criando um array do tipo inteiro<br />
a2 = Array{Int32}<br />
println(a2)<br />
# Criando um array (de outra maneira) do tipo float<br />
a3 = Float64[]<br />
println(a3)<br />
<br />
Saída:<br />
Array{Int32,N} where N<br />
Float64[]<br />
</pre><br />
<br />
<pre><br />
# Criando um array e definindo valores<br />
a4 = [1,2,3]<br />
#Imprimindo a4<br />
println("Array: ", a4)<br />
<br />
Saída:<br />
Array: [1, 2, 3]<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Imprimindo valor de um indíce específico<br />
println("Imprimindo primeiro elemento: ", a4[1])<br />
# Imprimindo último valor do array<br />
println("Imprimindo último elemento: ",a4[end])<br />
<br />
Saída:<br />
Imprimindo primeiro elemento: 1<br />
Imprimindo último elemento: 3<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
println(a4[2])<br />
# Valores podem mudar (diferente de Tuplas, que veremos adiante)<br />
a4[2] = 4<br />
println(a4[2])<br />
<br />
Saída:<br />
2<br />
4<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
println(a4)<br />
# Número de elementos<br />
println("Imprimindo número de elementos: ",length(a4))<br />
<br />
Saída:<br />
[1, 2, 3]<br />
Imprimindo número de elementos: 3<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Soma os valores do array<br />
println("Imprimindo soma dos elementos: ",sum(a4))<br />
# Põe os valores começando no índice 2<br />
splice!(a4, 2:1, [8,9])<br />
println("Imprimindo Array tendo feito splice!(a4, 2:1, [8,9]): ",a4)<br />
# Remove os itens do índice 2 ao 3<br />
4splice!(a4, 2:3)<br />
println("Imprimindo Array tendo feito splice!(a4, 2:3): ",a4)<br />
<br />
Saída:<br />
Imprimindo soma dos elementos: 6<br />
Imprimindo Array tendo feito splice!(a4, 2:1, [8,9]): [1, 8, 9, 2, 3]<br />
Imprimindo Array tendo feito splice!(a4, 2:3): [1, 2, 3]<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Pegar valor máximo e valor mínimo<br />
println("Imprimindo valor máximo: ",maximum(a4))<br />
println("Imprimindo Array valor mínimo: ",minimum(a4))<br />
# Multiplicando todos os elementos do array por outro número sem precisar de um␣<br />
println("Imprimindo multiplicação dos elementos por 2: ",a4 * 2)<br />
<br />
Saída:<br />
Imprimindo valor máximo: 3<br />
Imprimindo Array valor mínimo: 1<br />
Imprimindo multiplicação dos elementos por 2: [2, 4, 6]<br />
</pre><br />
<br />
<pre><br />
# Arrays podem conter funções<br />
a5 = [sin, cos, tan]<br />
for n in a5<br />
println(n(0))<br />
end<br />
<br />
Saída:<br />
0.0<br />
1.0<br />
0.0<br />
</pre><br />
<br />
<pre><br />
# Para os acostumados com range<br />
a6 = collect(1:5)<br />
println(a6)<br />
<br />
Saída:<br />
[1, 2, 3, 4, 5]<br />
</pre><br />
<br />
'''Tuplas'''<br />
<br />
A maioria das funções de array funciona com tuplas.<br />
<pre><br />
# Valores não podem mudar<br />
t1 = (1,2,3,4)<br />
println(t1[2])<br />
t1[2] = 5<br />
println(t1[2])<br />
<br />
Saída:<br />
2<br />
MethodError: no method matching setindex!(::NTuple{4,Int32}, ::Int32, ::Int32)<br />
</pre><br />
<br />
<pre><br />
# Imprimindo a tupla inteira<br />
println(t1)<br />
# Imprimindo a tupla inteira<br />
for i in t1<br />
println(i)<br />
end<br />
<br />
Saída:<br />
(1, 2, 3, 4)<br />
1<br />
2<br />
3<br />
4<br />
</pre><br />
<br />
'''Dicionários'''<br />
<br />
A palavra-chave deve ser única.<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Imprimir um valor<br />
println(d1["pi"])<br />
<br />
Saída:<br />
3.14<br />
</pre><br />
<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Imprimindo todas as palavras-chaves<br />
println(keys(d1))<br />
# Imprimindo todos os valores<br />
println(values(d1))<br />
# Adicionar uma palavra-chave<br />
d1["golden"] = 1.618<br />
# Deleter uma palavra-chave<br />
delete!(d1, "pi")<br />
# Imprimindo todas as palavras-chaves<br />
println(keys(d1))<br />
# Imprimindo todos os valores<br />
println(values(d1))<br />
<br />
Saída:<br />
["pi", "e"]<br />
[3.14, 2.718]<br />
["e", "golden"]<br />
[2.718, 1.618]<br />
</pre><br />
<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Ver se a palavra-chave existe<br />
println(haskey(d1, "pi"))<br />
# Imprimindo palavras-chaves E valores<br />
for kv in d1<br />
println(kv)<br />
end<br />
<br />
Saída:<br />
true<br />
"pi" => 3.14<br />
"e" => 2.718<br />
</pre><br />
<br />
'''Sets'''<br />
<br />
Sets são arrays com elementos únicos.<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
# Ele não pega os elementos repetidos<br />
println(st1)<br />
<br />
Saída:<br />
Set(["Pam", "Jim"])<br />
</pre><br />
<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
# Adicionando um elemento<br />
push!(st1, "Michael")<br />
println(st1)<br />
# Ver se um elemento está no Set<br />
println(in("Dwight", st1))<br />
<br />
Saída:<br />
Set(["Pam", "Michael", "Jim"])<br />
false<br />
</pre><br />
<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
st2 = Set(["Stanley", "Meredith"])<br />
# Combinando Sets<br />
println(union(st1, st2))<br />
# Imprimindo todo o elemento que os dois Sets tem em comum<br />
println(intersect(st1, st2))<br />
# Imprimindo elementos que estão no primeiro Set, mas não no segundo<br />
println(setdiff(st1, st2))<br />
<br />
Saída:<br />
Set(["Jim", "Meredith", "Stanley", "Pam"])<br />
Set(String[])<br />
Set(["Pam", "Jim"])<br />
</pre><br />
<br />
'''Funções'''<br />
<pre><br />
using Printf<br />
# Função de expressão única<br />
soma(x,y) = x + y<br />
x, y = 1, 2<br />
@printf("%d + %d = %d\n", x, y, x+y)<br />
<br />
Saída:<br />
1 + 2 = 3<br />
</pre><br />
<br />
<pre><br />
# Função de múltiplas expressões<br />
function adoptACat(cats)<br />
if cats <= 1<br />
println("You should adopt a cat.")<br />
else<br />
println("You should adopt a cat. They're cute.")<br />
end<br />
end<br />
adoptACat(2)<br />
<br />
Saída:<br />
You should adopt a cat. They're cute.<br />
</pre><br />
<br />
<pre><br />
v1 = 5<br />
function changeV1(v1)<br />
v1 = 10<br />
end<br />
changeV1(v1)<br />
println(v1)<br />
<br />
Saída:<br />
5<br />
</pre><br />
<br />
<pre><br />
v1 = 5<br />
function changeV1(v1)<br />
v1 = 10<br />
return v1<br />
end<br />
changeV1(v1)<br />
println(v1)<br />
v2 = changeV1(v1)<br />
println(v2)<br />
<br />
Saída:<br />
5<br />
10<br />
</pre><br />
<br />
<pre><br />
# Usando variáveis globais dentro da função<br />
v1 = 5<br />
function changeV12()<br />
global v1 = 10<br />
end<br />
changeV12()<br />
println(v1)<br />
<br />
Saída:<br />
10<br />
</pre><br />
<br />
<pre><br />
# Quando não sei quantos argumentos vou passar<br />
function soma(args...)<br />
sum = 0<br />
for i in args<br />
sum += i<br />
end<br />
println(sum)<br />
end<br />
soma(1,2,3)<br />
<br />
Saída:<br />
6<br />
</pre><br />
<br />
<pre><br />
# Retornando mais de um valor<br />
function retorna2(valor)<br />
return (valor + 1, valor + 2)<br />
end<br />
println(retorna2(4))<br />
<br />
Saída:<br />
(5, 6)<br />
</pre><br />
<br />
<pre><br />
# Map é uma função anônima que aplica uma função para cada elemento<br />
v = map(x -> x * x, [1,2,3])<br />
println(v)<br />
<br />
Saída:<br />
[1, 4, 9]<br />
<br />
'''Structs'''<br />
<pre><br />
struct Estudante<br />
name::String<br />
saldoTRI::Float32<br />
cartaoUFRGS::Int<br />
end<br />
# Criando um objeto<br />
estudante1 = Estudante("Raquel", 10.50, 244449)<br />
println(estudante1.name, "\n", estudante1.saldoTRI, "\n", estudante1.cartaoUFRGS)<br />
<br />
Saída:<br />
Raquel<br />
10.5<br />
244449<br />
9<br />
</pre><br />
<br />
'''Tipos Abstratos'''<br />
<br />
Tipos abstratos não podem ser instanciados como as Structs (instanciar => fazer estudante1 =<br />
Estudante(“Raquel”, 10.50, 244449) => criar um objeto) MAS podem ter subTipos e isso é muito<br />
útil!<br />
<br />
<pre><br />
abstract type animal end<br />
struct cachorro <: animal<br />
nome::String<br />
latido::String<br />
end<br />
struct gato <: animal<br />
nome::String<br />
miado::String<br />
end<br />
cachorro1 = cachorro("Urso", "Au Au")<br />
gato1 = gato("Lucia Irene", "Miau")<br />
# Criando funções pros subTipos<br />
function fazerSom(animal::cachorro)<br />
println("$(animal.nome) diz $(animal.latido)")<br />
end<br />
function fazerSom(animal::gato)<br />
println("$(animal.nome) diz $(animal.miado)")<br />
end<br />
fazerSom(cachorro1)<br />
fazerSom(gato1)<br />
<br />
Saída: <br />
Urso diz Au Au<br />
Lucia Irene diz Miau<br />
</pre></div>Raquelmhttp://fiscomp.if.ufrgs.br/index.php?title=Julia&diff=2507Julia2020-01-07T14:36:41Z<p>Raquelm: /* Performance de Julia */</p>
<hr />
<div>Julia é uma linguagem relativamente nova de programação que começou a ser desenvolvida em 2009 por Jeff Bezanson, Stefan Karpinski, Viral B. Shah, e Alan Edelman, um grupo do MIT. Ela foi oficialmente lançada para o mundo em 2012.<br />
<br />
Em uma entrevista, quando perguntaram a Alan o por quê do nome Julia, ele disse que numa conversa anos atrás alguém sugeriu que Julia seria um bom nome para uma linguagem de programação.<br />
<br />
Julia pode ser usada para propósitos gerais de programação, assim como Python, mas em sua criação foi visada a utilização de Julia para Cálculo Numérico.<br />
<br />
== Aspectos Gerais ==<br />
<br />
Julia é uma linguagem de alto nível, isso significa, de maneira sucinta, que ela não é executada utilizando somente o processador, assim como acontece com linguagens de baixo nível, como Assembly, por exemplo.<br />
<br />
É escrita em C, C++, e Scheme, usando a estrutura do compilador LLVM (para melhor entendimento, o compilador de C é o GCC, por exemplo), enquanto a maior parte da biblioteca padrão de Julia é implementada na própria Julia.<br />
<br />
Um fato importante sobre Julia para os programadores de Python é que todas as bibliotecas de Python são usáveis através de um comando simples: PyCall.<br />
<br />
Um fato importante sobre Julia para os programadores de C é que Julia possui APIs (Interfaces de Programação de Aplicativos) especiais para chamada de funções em C diretamente.<br />
<br />
== Velocidade ==<br />
<br />
De acordo com testes feitos pelos próprios criadores de Julia, sua velocidade é similar com a de C.<br />
<br />
<br />
<center>[[Arquivo:juliasvelocity.png|border]]<br />
Fonte: [https://julialang.org/benchmarks/]<br />
</center><br />
<br />
<br />
== Testes de Velocidade ==<br />
<br />
A fim de pessoalmente testar a velocidade da linguagem de programação, foi escrito um programa em Julia de maneira similar ao programa de Python para o FTCS aplicado na Equação de Difusão (também conhecida como Equação do Calor). <br />
<br />
A Equação da Difusão em uma dimensão pode ser escrita da forma:<br />
<br />
<center><math>\frac{df}{dt}=\frac{d^{2}f}{dx^{2}}</math></center><br />
<br />
No método de FTCS (Forward-Time Central-Space) definimos a derivada em t na forma não simetrizada (forward) e as derivadas em x na forma simetrizada:<br />
<br />
<br />
<center><math>\frac{df}{dt} = \frac{f(x, t+dt) - f(x,t)}{dt}</math></center><br />
<br />
<p><br />
<br />
<center><math>\frac{d^{2}f}{dx^{2}} = \frac{f(x+dx, t) + f(x-dx, t) - 2f(x,t)}{dx^{2}}</math></center><br />
<br />
E substuindo na equação da difusão, em notação discreta temos:<br />
<br />
<center><math>f_{j}^{n+1} = f_{j}^{n} + D\frac{dt}{(dx)^{2}}[f_{j+1}^{n} + f_{j-1}^{n} - 2 f_{j}^{n}]</math></center><br />
<br />
'''Observação:''' esse procedimento funciona bem se <math>k=D\frac{dt}{(dx)^{2}} <= 1/2</math>, segundo análise de estabilidade do método.<br />
<br />
<br />
Dessa forma, foi escrito um programa para integrar a Equação de Difusão através do método de FTCS nas linguagens Python e Julia.<br />
<br />
Para '''Python''':<br />
<pre><br />
# FTCS aplicado na equacao da difusao. Linguagem: PYTHON<br />
<br />
import copy<br />
import numpy as np<br />
import matplotlib.pyplot as plt<br />
<br />
def init():<br />
L=50;D=1.;dt=0.05;dx=1.;t=0;tmax=100.<br />
k=D*dt/(dx*dx) <br />
return L,k,dt,t,tmax<br />
<br />
L,k,dt,t,tmax = init()<br />
<br />
x = np.arange(0,L,1) <br />
f = np.zeros(x.shape)<br />
<br />
a = int(L/3)<br />
b = int(2*L/3)<br />
f[a:b]=1.<br />
f1 = copy.deepcopy(f) <br />
f2 = copy.deepcopy(f)<br />
<br />
while t<tmax:<br />
t+=dt<br />
f1[1:L-1]=f[1:L-1]+k*(f[0:L-2]+f[2:L]-2*f[1:L-1])<br />
f1[L-1]=f[L-1]+k*(f[L-2]+f[0]-2*f[L-1]) <br />
f1[0]=f[0]+k*(f[1]+f[L-1]-2*f[0]) <br />
f=copy.deepcopy(f1) <br />
<br />
sum0=sum(f1)<br />
sum1=sum(f2) <br />
<br />
print("Integral em t=0: %7.4f" % sum0)<br />
print("Integral em tmax: %7.4f" % sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
Em '''Julia''':<br />
<pre><br />
# FTCS aplicado na equacao da difusao. Linguagem: JULIA<br />
<br />
using PyPlot<br />
<br />
L=50<br />
D=1.<br />
dt=0.05<br />
dx=1.<br />
t=0<br />
tmax=100.<br />
k=D*dt/(dx*dx) <br />
<br />
x = collect(0:1:L-1)<br />
f = zeros(L)<br />
f1 = zeros(L)<br />
<br />
a = trunc(Int, L/3) <br />
b = trunc(Int, 2*L/3)<br />
<br />
f[a+1:b] .= 1.<br />
f2 = deepcopy(f)<br />
<br />
while t<tmax<br />
global t+=dt <br />
f1[2:L-1] = f[2:L-1] + k*(f[1:L-2] + f[3:L] - 2*f[2:L-1]) <br />
f1[L] = f[L] + k*(f[L-1] + f[1] - 2*f[L])<br />
f1[1] = f[1] + k*(f[2] + f[L] - 2*f[1]) <br />
global f = deepcopy(f1) <br />
end<br />
<br />
sum0 = sum(f1)<br />
sum1 = sum(f2)<br />
<br />
println("Integral em t=0: ", sum0)<br />
println("Integral em tmax: ", sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
<br />
Foi testado o tempo de execução da parte principal dos dois programas (isto é, sem fazer o gráfico dos resultados), através do timer do terminal, como mostra na próxima figura:<br />
<br />
<center>[[Arquivo:Ftcs_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o método de FTCS aplicado à Equação de Difusão<br />
</center><br />
<br />
É possível perceber, através da figura acima, que o tempo de execução de Python para o FTCS aplicado à Equação de Difusão é menor do que o de Julia. Em razão disso, foi testado um programa simples, como mostra abaixo, que incrementa uma variável 10 vezes, sendo o seu valor inicial 0.<br />
<br />
<br />
<center>[[Arquivo:For.png|border]]<br />
'''Legenda:''' Programa para incrementar o valor de uma variável, nesse caso ''i'', 10 vezes, escrito em Julia e em Python<br />
</center><br />
<br />
E posteriormente, novamente, foi testado o tempo de execução da parte principal dos programas através do terminal:<br />
<br />
<center>[[Arquivo:For_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o programa que incrementa o valor da variável 10 vezes<br />
</center><br />
<br />
É possível perceber que para esse simples programa de incrementação, Python ainda obtém melhor performance do que Julia.<br />
<br />
== Performance de Julia ==<br />
<br />
Tentando entender o que traria tal performance em Cálculo Numérico para Julia, foi chegado à conclusão de que ser uma linguagem que se utilizada de ''variáveis dinâmicas'' e ''multi-métodos'' seria uma das grandes contribuições da linguagem.<br />
<br />
'''Variáveis dinâmicas:'''<br />
<br />
Em Python as variáveis são interpretadas em runtime, ou seja, '''tempo de execução''' => o programa checa toda hora se a variável mudou e isso torna ele mais lento<br />
<br />
'''Variáveis estáticas:'''<br />
<br />
Em C as variáveis são fixas, e isso é visto é em '''tempo de compilação''' => precisa pensar nas variáveis e isso torna o tempo de programação mais lento<br />
<br />
Em Julia isso é basicamente opcional, não é preciso definir as variáveis, mas é possível, e elas podem mudar dinamicamente, em tempo de execução. E ainda, Julia se utiliza de multi-métodos para não ter que lidar com a constante checagem dos tipos das variáveis, como Python faz!<br />
<br />
'''Métodos Únicos'''<br />
<br />
Python => single dispatch => Métodos Únicos<br />
- Não tenho sobrecarga de funções, eu simplesmente chamo uma função que já está escrita<br />
<br />
'''Multi-métodos'''<br />
<br />
Sobrecarga de funções (C++) => Multi-métodos (multiple dispatch)<br />
- Tenho uma função e dependendo dos parâmetros que eu coloco ao chamá-la, eu chamo uma função ou outra<br />
<br />
'''Exemplo de sobrecarga de funções em Julia:'''<br />
<br />
<pre> <br />
//dependendo do tipo da minha variavel x na chamada da funcao, sera chamado uma funcao ou outra, mesmo que tenham o mesmo nome<br />
<br />
function printx(x::Float64)<br />
println(x)<br />
end<br />
<br />
function printx(x::String)<br />
println(x)<br />
end<br />
<br />
x="Oi"<br />
<br />
printx(x)<br />
</pre><br />
<br />
== Performance de Julia: na prática ==<br />
Para resumir, temos: <br />
<br />
Python => dynamic (variáveis dinâmicas) single<br />
dispatch<br />
<br />
C++ => static (variáveis estáticas) multiple dispatch<br />
<br />
Julia => dynamic multiple dispatch (''o melhor dos dois mundos!'')<br />
<br />
Na prática, é mostrado abaixo um exemplo da performance de Julia como linguagem de programação em dynamic multiple dispatch. <br />
<br />
O mesmo programa foi escrito em Julia e em C++. <br />
<br />
Em '''Julia''':<br />
<br />
<pre><br />
abstract type Animal end<br />
<br />
struct Cachorro <: Animal<br />
nome::String<br />
end<br />
<br />
struct Gato <: Animal<br />
nome::String<br />
end<br />
<br />
# Função de encontro que recebe tipo genérico de animal<br />
function encontroDeAnimais(a::Animal, b::Animal)<br />
acao = encontro(a,b)<br />
println("$(a.nome) encontra $(b.nome) e $acao")<br />
end<br />
<br />
# Funções de expressão única que recebem diferentes tipos de animais<br />
encontro(a::Cachorro, b::Cachorro) = "cheira" <br />
encontro(a::Cachorro, b::Gato) = "persegue"<br />
encontro(a::Gato, b::Gato) = "lambe"<br />
encontro(a::Gato, b::Cachorro) = "ignora" <br />
<br />
# Instanciando os bichinhos<br />
gato1 = Gato("Luciene Maria")<br />
gato2 = Gato("Mel")<br />
cachorro1 = Cachorro("Batata")<br />
cachorro2 = Cachorro("Snoopy")<br />
<br />
# Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2)<br />
encontroDeAnimais(gato1, cachorro2)<br />
encontroDeAnimais(cachorro1, cachorro2)<br />
</pre><br />
<br />
<br />
Em '''C++''':<br />
<br />
<pre><br />
#include <iostream><br />
using namespace std;<br />
<br />
class Animal { <br />
public:<br />
string nome;<br />
};<br />
<br />
string encontro(Animal a, Animal b) {}<br />
<br />
// Função de encontro que recebe tipo genérico de animal<br />
void encontroDeAnimais(Animal a, Animal b) {<br />
string acao = encontro(a,b);<br />
cout << a.nome << " encontra " << b.nome << " e " << acao << endl;<br />
}<br />
<br />
class Cachorro:public Animal {};<br />
class Gato:public Animal {};<br />
<br />
// Funções de expressão única que recebem diferentes tipos de animais<br />
string encontro(Cachorro a, Cachorro b) { return "cheira"; }<br />
string encontro(Cachorro a, Gato b) { return "persegue"; }<br />
string encontro(Gato a, Gato b) { return "lambe"; }<br />
string encontro(Gato a, Cachorro b) { return "ignora"; }<br />
<br />
int main() {<br />
// Instanciando os bichinhos<br />
Gato gato1; gato1.nome = "Luciene Maria";<br />
Gato gato2; gato2.nome = "Mel";<br />
Cachorro cachorro1; cachorro1.nome = "Batata";<br />
Cachorro cachorro2; cachorro2.nome = "Snoopy";<br />
<br />
// Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2);<br />
encontroDeAnimais(gato1, cachorro2);<br />
encontroDeAnimais(cachorro1, cachorro2);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Para '''Julia''' nós obtemos o seguinte '''resultado''':<br />
<br />
<pre><br />
Luciene Maria encontra Mel e lambe<br />
Luciene Maria encontra Snoopy e ignora<br />
Batata encontra Snoopy e cheira<br />
</pre><br />
<br />
Para '''C++''' o '''resultado''' é:<br />
<br />
<pre><br />
Luciene Maria encontra Mel e<br />
Falha de Segmentação<br />
</pre><br />
<br />
Isso acontece porque C++ não aceita que uma função utilize-se de uma variável sem antes saber qual o tipo dessa variável! Por isso, poder utilizar-se de variáveis dinâmicas quando há multi-métodos é um diferencial que acaba por incrementar a performance de Julia como linguagem de programação visada para o Cálculo Numérico.<br />
<br />
'''Observação:''' é importante ressaltar que os testes feitos não são conclusivos para debater a performance de Julia, em termos estatísticos, e além disso, ser uma linguagem de programação que utiliza de variáveis dinâmicas e multi-métodos não é o único motivo pelo qual Julia poderia trazer tal performance em Cálculo Numérico. Podemos ainda contar com a sua capacidade de '''metaprogramação''', ou seja, Julia pode usar macros e eles são aplicados em tempo de interpretação. Há ainda outros fatores da construção da linguagem que contribuem para sua performance que aqui não foram citados.<br />
<br />
<br />
== Aprendendo Julia ==<br />
<br />
Após feita a instalação de Julia, para abri-la no terminal de comando é preciso apenas digitar <pre>$Julia</pre> para entrar no seu ambiente de programação.<br />
<br />
É possível, também, programar em um arquivo de texto e executar o programa pelo terminal, fazendo simplesmente:<br />
<br />
<pre><br />
$julia programa.jl <br />
</pre><br />
<br />
'''Impressão na tela'''<br />
<pre><br />
println("Hello World")<br />
<br />
Saída:<br />
Hello World<br />
</pre><br />
<br />
'''Variáveis'''<br />
<br />
Variáveis são atribuídas dinamicamente e podem mudar.<br />
<pre><br />
s = 1<br />
s = "Oi"<br />
println(s)<br />
println(typeof(s))<br />
<br />
Saída:<br />
Oi<br />
String<br />
</pre><br />
<br />
<pre><br />
s::String<br />
s = 1<br />
println(s)<br />
<br />
Saída:<br />
TypeError: in typeassert, expected String, got Int32<br />
</pre><br />
<br />
'''Condicionais'''<br />
<pre><br />
cats = 12<br />
if cats < 1<br />
println("You should adopt a cat.")<br />
elseif cats >= 1 && cats <=6<br />
println("Not enough cats.")<br />
elseif cats >= 7 && cats <= 12<br />
println("Still not enough cats.")<br />
else<br />
println("Gato have more cats.")<br />
end<br />
<br />
Saída:<br />
Still not enough cats.<br />
</pre><br />
<br />
<pre><br />
i = 0<br />
while (i < 10)<br />
global i += 1<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
</pre><br />
<br />
<pre><br />
for i = 1:10<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
</pre><br />
<br />
<pre><br />
for i in [1,2,3]<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
3<br />
</pre><br />
<br />
'''Arrays'''<br />
<pre><br />
# Criando um array de zeros<br />
a1 = zeros()<br />
println(a1)<br />
# Posso definir o tipo e o tamanho do Array (linhas, colunas) também<br />
a1 = zeros(Int32, 1, 4)<br />
println(a1)<br />
<br />
Saída:<br />
0.0<br />
[0 0 0 0]<br />
</pre><br />
<br />
<pre><br />
# Criando um array do tipo inteiro<br />
a2 = Array{Int32}<br />
println(a2)<br />
# Criando um array (de outra maneira) do tipo float<br />
a3 = Float64[]<br />
println(a3)<br />
<br />
Saída:<br />
Array{Int32,N} where N<br />
Float64[]<br />
</pre><br />
<br />
<pre><br />
# Criando um array e definindo valores<br />
a4 = [1,2,3]<br />
#Imprimindo a4<br />
println("Array: ", a4)<br />
<br />
Saída:<br />
Array: [1, 2, 3]<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Imprimindo valor de um indíce específico<br />
println("Imprimindo primeiro elemento: ", a4[1])<br />
# Imprimindo último valor do array<br />
println("Imprimindo último elemento: ",a4[end])<br />
<br />
Saída:<br />
Imprimindo primeiro elemento: 1<br />
Imprimindo último elemento: 3<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
println(a4[2])<br />
# Valores podem mudar (diferente de Tuplas, que veremos adiante)<br />
a4[2] = 4<br />
println(a4[2])<br />
<br />
Saída:<br />
2<br />
4<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
println(a4)<br />
# Número de elementos<br />
println("Imprimindo número de elementos: ",length(a4))<br />
<br />
Saída:<br />
[1, 2, 3]<br />
Imprimindo número de elementos: 3<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Soma os valores do array<br />
println("Imprimindo soma dos elementos: ",sum(a4))<br />
# Põe os valores começando no índice 2<br />
splice!(a4, 2:1, [8,9])<br />
println("Imprimindo Array tendo feito splice!(a4, 2:1, [8,9]): ",a4)<br />
# Remove os itens do índice 2 ao 3<br />
4splice!(a4, 2:3)<br />
println("Imprimindo Array tendo feito splice!(a4, 2:3): ",a4)<br />
<br />
Saída:<br />
Imprimindo soma dos elementos: 6<br />
Imprimindo Array tendo feito splice!(a4, 2:1, [8,9]): [1, 8, 9, 2, 3]<br />
Imprimindo Array tendo feito splice!(a4, 2:3): [1, 2, 3]<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Pegar valor máximo e valor mínimo<br />
println("Imprimindo valor máximo: ",maximum(a4))<br />
println("Imprimindo Array valor mínimo: ",minimum(a4))<br />
# Multiplicando todos os elementos do array por outro número sem precisar de um␣<br />
println("Imprimindo multiplicação dos elementos por 2: ",a4 * 2)<br />
<br />
Saída:<br />
Imprimindo valor máximo: 3<br />
Imprimindo Array valor mínimo: 1<br />
Imprimindo multiplicação dos elementos por 2: [2, 4, 6]<br />
</pre><br />
<br />
<pre><br />
# Arrays podem conter funções<br />
a5 = [sin, cos, tan]<br />
for n in a5<br />
println(n(0))<br />
end<br />
<br />
Saída:<br />
0.0<br />
1.0<br />
0.0<br />
</pre><br />
<br />
<pre><br />
# Para os acostumados com range<br />
a6 = collect(1:5)<br />
println(a6)<br />
<br />
Saída:<br />
[1, 2, 3, 4, 5]<br />
</pre><br />
<br />
'''Tuplas'''<br />
<br />
A maioria das funções de array funciona com tuplas.<br />
<pre><br />
# Valores não podem mudar<br />
t1 = (1,2,3,4)<br />
println(t1[2])<br />
t1[2] = 5<br />
println(t1[2])<br />
<br />
Saída:<br />
2<br />
MethodError: no method matching setindex!(::NTuple{4,Int32}, ::Int32, ::Int32)<br />
</pre><br />
<br />
<pre><br />
# Imprimindo a tupla inteira<br />
println(t1)<br />
# Imprimindo a tupla inteira<br />
for i in t1<br />
println(i)<br />
end<br />
<br />
Saída:<br />
(1, 2, 3, 4)<br />
1<br />
2<br />
3<br />
4<br />
</pre><br />
<br />
'''Dicionários'''<br />
<br />
A palavra-chave deve ser única.<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Imprimir um valor<br />
println(d1["pi"])<br />
<br />
Saída:<br />
3.14<br />
</pre><br />
<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Imprimindo todas as palavras-chaves<br />
println(keys(d1))<br />
# Imprimindo todos os valores<br />
println(values(d1))<br />
# Adicionar uma palavra-chave<br />
d1["golden"] = 1.618<br />
# Deleter uma palavra-chave<br />
delete!(d1, "pi")<br />
# Imprimindo todas as palavras-chaves<br />
println(keys(d1))<br />
# Imprimindo todos os valores<br />
println(values(d1))<br />
<br />
Saída:<br />
["pi", "e"]<br />
[3.14, 2.718]<br />
["e", "golden"]<br />
[2.718, 1.618]<br />
</pre><br />
<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Ver se a palavra-chave existe<br />
println(haskey(d1, "pi"))<br />
# Imprimindo palavras-chaves E valores<br />
for kv in d1<br />
println(kv)<br />
end<br />
<br />
Saída:<br />
true<br />
"pi" => 3.14<br />
"e" => 2.718<br />
</pre><br />
<br />
'''Sets'''<br />
<br />
Sets são arrays com elementos únicos.<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
# Ele não pega os elementos repetidos<br />
println(st1)<br />
<br />
Saída:<br />
Set(["Pam", "Jim"])<br />
</pre><br />
<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
# Adicionando um elemento<br />
push!(st1, "Michael")<br />
println(st1)<br />
# Ver se um elemento está no Set<br />
println(in("Dwight", st1))<br />
<br />
Saída:<br />
Set(["Pam", "Michael", "Jim"])<br />
false<br />
</pre><br />
<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
st2 = Set(["Stanley", "Meredith"])<br />
# Combinando Sets<br />
println(union(st1, st2))<br />
# Imprimindo todo o elemento que os dois Sets tem em comum<br />
println(intersect(st1, st2))<br />
# Imprimindo elementos que estão no primeiro Set, mas não no segundo<br />
println(setdiff(st1, st2))<br />
<br />
Saída:<br />
Set(["Jim", "Meredith", "Stanley", "Pam"])<br />
Set(String[])<br />
Set(["Pam", "Jim"])<br />
</pre><br />
<br />
'''Funções'''<br />
<pre><br />
using Printf<br />
# Função de expressão única<br />
soma(x,y) = x + y<br />
x, y = 1, 2<br />
@printf("%d + %d = %d\n", x, y, x+y)<br />
<br />
Saída:<br />
1 + 2 = 3<br />
</pre><br />
<br />
<pre><br />
# Função de múltiplas expressões<br />
function adoptACat(cats)<br />
if cats <= 1<br />
println("You should adopt a cat.")<br />
else<br />
println("You should adopt a cat. They're cute.")<br />
end<br />
end<br />
adoptACat(2)<br />
<br />
Saída:<br />
You should adopt a cat. They're cute.<br />
</pre><br />
<br />
<pre><br />
v1 = 5<br />
function changeV1(v1)<br />
v1 = 10<br />
end<br />
changeV1(v1)<br />
println(v1)<br />
<br />
Saída:<br />
5<br />
</pre><br />
<br />
<pre><br />
v1 = 5<br />
function changeV1(v1)<br />
v1 = 10<br />
return v1<br />
end<br />
changeV1(v1)<br />
println(v1)<br />
v2 = changeV1(v1)<br />
println(v2)<br />
<br />
Saída:<br />
5<br />
10<br />
</pre><br />
<br />
<pre><br />
# Usando variáveis globais dentro da função<br />
v1 = 5<br />
function changeV12()<br />
global v1 = 10<br />
end<br />
changeV12()<br />
println(v1)<br />
<br />
Saída:<br />
10<br />
</pre><br />
<br />
<pre><br />
# Quando não sei quantos argumentos vou passar<br />
function soma(args...)<br />
sum = 0<br />
for i in args<br />
sum += i<br />
end<br />
println(sum)<br />
end<br />
soma(1,2,3)<br />
<br />
Saída:<br />
6<br />
</pre><br />
<br />
<pre><br />
# Retornando mais de um valor<br />
function retorna2(valor)<br />
return (valor + 1, valor + 2)<br />
end<br />
println(retorna2(4))<br />
<br />
Saída:<br />
(5, 6)<br />
</pre><br />
<br />
<pre><br />
# Map é uma função anônima que aplica uma função para cada elemento<br />
v = map(x -> x * x, [1,2,3])<br />
println(v)<br />
<br />
Saída:<br />
[1, 4, 9]<br />
<br />
'''Structs'''<br />
<pre><br />
struct Estudante<br />
name::String<br />
saldoTRI::Float32<br />
cartaoUFRGS::Int<br />
end<br />
# Criando um objeto<br />
estudante1 = Estudante("Raquel", 10.50, 244449)<br />
println(estudante1.name, "\n", estudante1.saldoTRI, "\n", estudante1.cartaoUFRGS)<br />
<br />
Saída:<br />
Raquel<br />
10.5<br />
244449<br />
9<br />
</pre><br />
<br />
'''Tipos Abstratos'''<br />
<br />
Tipos abstratos não podem ser instanciados como as Structs (instanciar => fazer estudante1 =<br />
Estudante(“Raquel”, 10.50, 244449) => criar um objeto) MAS podem ter subTipos e isso é muito<br />
útil!<br />
<br />
<pre><br />
abstract type animal end<br />
struct cachorro <: animal<br />
nome::String<br />
latido::String<br />
end<br />
struct gato <: animal<br />
nome::String<br />
miado::String<br />
end<br />
cachorro1 = cachorro("Urso", "Au Au")<br />
gato1 = gato("Lucia Irene", "Miau")<br />
# Criando funções pros subTipos<br />
function fazerSom(animal::cachorro)<br />
println("$(animal.nome) diz $(animal.latido)")<br />
end<br />
function fazerSom(animal::gato)<br />
println("$(animal.nome) diz $(animal.miado)")<br />
end<br />
fazerSom(cachorro1)<br />
fazerSom(gato1)<br />
<br />
Saída: <br />
Urso diz Au Au<br />
Lucia Irene diz Miau<br />
</pre></div>Raquelmhttp://fiscomp.if.ufrgs.br/index.php?title=Julia&diff=2506Julia2020-01-07T14:02:39Z<p>Raquelm: /* Testes de Velocidade */</p>
<hr />
<div>Julia é uma linguagem relativamente nova de programação que começou a ser desenvolvida em 2009 por Jeff Bezanson, Stefan Karpinski, Viral B. Shah, e Alan Edelman, um grupo do MIT. Ela foi oficialmente lançada para o mundo em 2012.<br />
<br />
Em uma entrevista, quando perguntaram a Alan o por quê do nome Julia, ele disse que numa conversa anos atrás alguém sugeriu que Julia seria um bom nome para uma linguagem de programação.<br />
<br />
Julia pode ser usada para propósitos gerais de programação, assim como Python, mas em sua criação foi visada a utilização de Julia para Cálculo Numérico.<br />
<br />
== Aspectos Gerais ==<br />
<br />
Julia é uma linguagem de alto nível, isso significa, de maneira sucinta, que ela não é executada utilizando somente o processador, assim como acontece com linguagens de baixo nível, como Assembly, por exemplo.<br />
<br />
É escrita em C, C++, e Scheme, usando a estrutura do compilador LLVM (para melhor entendimento, o compilador de C é o GCC, por exemplo), enquanto a maior parte da biblioteca padrão de Julia é implementada na própria Julia.<br />
<br />
Um fato importante sobre Julia para os programadores de Python é que todas as bibliotecas de Python são usáveis através de um comando simples: PyCall.<br />
<br />
Um fato importante sobre Julia para os programadores de C é que Julia possui APIs (Interfaces de Programação de Aplicativos) especiais para chamada de funções em C diretamente.<br />
<br />
== Velocidade ==<br />
<br />
De acordo com testes feitos pelos próprios criadores de Julia, sua velocidade é similar com a de C.<br />
<br />
<br />
<center>[[Arquivo:juliasvelocity.png|border]]<br />
Fonte: [https://julialang.org/benchmarks/]<br />
</center><br />
<br />
<br />
== Testes de Velocidade ==<br />
<br />
A fim de pessoalmente testar a velocidade da linguagem de programação, foi escrito um programa em Julia de maneira similar ao programa de Python para o FTCS aplicado na Equação de Difusão (também conhecida como Equação do Calor). <br />
<br />
A Equação da Difusão em uma dimensão pode ser escrita da forma:<br />
<br />
<center><math>\frac{df}{dt}=\frac{d^{2}f}{dx^{2}}</math></center><br />
<br />
No método de FTCS (Forward-Time Central-Space) definimos a derivada em t na forma não simetrizada (forward) e as derivadas em x na forma simetrizada:<br />
<br />
<br />
<center><math>\frac{df}{dt} = \frac{f(x, t+dt) - f(x,t)}{dt}</math></center><br />
<br />
<p><br />
<br />
<center><math>\frac{d^{2}f}{dx^{2}} = \frac{f(x+dx, t) + f(x-dx, t) - 2f(x,t)}{dx^{2}}</math></center><br />
<br />
E substuindo na equação da difusão, em notação discreta temos:<br />
<br />
<center><math>f_{j}^{n+1} = f_{j}^{n} + D\frac{dt}{(dx)^{2}}[f_{j+1}^{n} + f_{j-1}^{n} - 2 f_{j}^{n}]</math></center><br />
<br />
'''Observação:''' esse procedimento funciona bem se <math>k=D\frac{dt}{(dx)^{2}} <= 1/2</math>, segundo análise de estabilidade do método.<br />
<br />
<br />
Dessa forma, foi escrito um programa para integrar a Equação de Difusão através do método de FTCS nas linguagens Python e Julia.<br />
<br />
Para '''Python''':<br />
<pre><br />
# FTCS aplicado na equacao da difusao. Linguagem: PYTHON<br />
<br />
import copy<br />
import numpy as np<br />
import matplotlib.pyplot as plt<br />
<br />
def init():<br />
L=50;D=1.;dt=0.05;dx=1.;t=0;tmax=100.<br />
k=D*dt/(dx*dx) <br />
return L,k,dt,t,tmax<br />
<br />
L,k,dt,t,tmax = init()<br />
<br />
x = np.arange(0,L,1) <br />
f = np.zeros(x.shape)<br />
<br />
a = int(L/3)<br />
b = int(2*L/3)<br />
f[a:b]=1.<br />
f1 = copy.deepcopy(f) <br />
f2 = copy.deepcopy(f)<br />
<br />
while t<tmax:<br />
t+=dt<br />
f1[1:L-1]=f[1:L-1]+k*(f[0:L-2]+f[2:L]-2*f[1:L-1])<br />
f1[L-1]=f[L-1]+k*(f[L-2]+f[0]-2*f[L-1]) <br />
f1[0]=f[0]+k*(f[1]+f[L-1]-2*f[0]) <br />
f=copy.deepcopy(f1) <br />
<br />
sum0=sum(f1)<br />
sum1=sum(f2) <br />
<br />
print("Integral em t=0: %7.4f" % sum0)<br />
print("Integral em tmax: %7.4f" % sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
Em '''Julia''':<br />
<pre><br />
# FTCS aplicado na equacao da difusao. Linguagem: JULIA<br />
<br />
using PyPlot<br />
<br />
L=50<br />
D=1.<br />
dt=0.05<br />
dx=1.<br />
t=0<br />
tmax=100.<br />
k=D*dt/(dx*dx) <br />
<br />
x = collect(0:1:L-1)<br />
f = zeros(L)<br />
f1 = zeros(L)<br />
<br />
a = trunc(Int, L/3) <br />
b = trunc(Int, 2*L/3)<br />
<br />
f[a+1:b] .= 1.<br />
f2 = deepcopy(f)<br />
<br />
while t<tmax<br />
global t+=dt <br />
f1[2:L-1] = f[2:L-1] + k*(f[1:L-2] + f[3:L] - 2*f[2:L-1]) <br />
f1[L] = f[L] + k*(f[L-1] + f[1] - 2*f[L])<br />
f1[1] = f[1] + k*(f[2] + f[L] - 2*f[1]) <br />
global f = deepcopy(f1) <br />
end<br />
<br />
sum0 = sum(f1)<br />
sum1 = sum(f2)<br />
<br />
println("Integral em t=0: ", sum0)<br />
println("Integral em tmax: ", sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
<br />
Foi testado o tempo de execução da parte principal dos dois programas (isto é, sem fazer o gráfico dos resultados), através do timer do terminal, como mostra na próxima figura:<br />
<br />
<center>[[Arquivo:Ftcs_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o método de FTCS aplicado à Equação de Difusão<br />
</center><br />
<br />
É possível perceber, através da figura acima, que o tempo de execução de Python para o FTCS aplicado à Equação de Difusão é menor do que o de Julia. Em razão disso, foi testado um programa simples, como mostra abaixo, que incrementa uma variável 10 vezes, sendo o seu valor inicial 0.<br />
<br />
<br />
<center>[[Arquivo:For.png|border]]<br />
'''Legenda:''' Programa para incrementar o valor de uma variável, nesse caso ''i'', 10 vezes, escrito em Julia e em Python<br />
</center><br />
<br />
E posteriormente, novamente, foi testado o tempo de execução da parte principal dos programas através do terminal:<br />
<br />
<center>[[Arquivo:For_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o programa que incrementa o valor da variável 10 vezes<br />
</center><br />
<br />
É possível perceber que para esse simples programa de incrementação, Python ainda obtém melhor performance do que Julia.<br />
<br />
== Performance de Julia ==<br />
<br />
Tentando entender o que traria tal performance em Cálculo Numérico para Julia, foi chegado à conclusão de que ser uma linguagem que se utilizada de ''variáveis dinâmicas'' e ''multi-métodos'' seria uma das grandes contribuições da linguagem.<br />
<br />
'''Variáveis dinâmicas:'''<br />
<br />
Em Python elas são interpretadas em runtime, ou seja, '''tempo de execução''' => o programa checa toda hora se a variável mudou e isso torna ele mais lento<br />
<br />
'''Variáveis estáticas:'''<br />
<br />
Em C as variáveis são fixas, e isso é visto é em '''tempo de compilação''' => precisa pensar nas variáveis e isso torna o tempo de programação mais lento<br />
<br />
Em Julia isso é basicamente opcional, não é preciso definir as variáveis, mas é possível, e elas podem mudar dinamicamente, em tempo de execução. E ainda, Julia se utiliza de multi-métodos para não ter que lidar com a constante checagem dos tipos das variáveis, como Python faz!<br />
<br />
'''Métodos Únicos'''<br />
<br />
Python => single dispatch => Métodos Únicos<br />
- Não tenho sobrecarga de funções, eu simplesmente chamo uma função que já está escrita<br />
<br />
'''Multi-métodos'''<br />
<br />
Sobrecarga de funções (C++) => Multi-métodos (multiple dispatch)<br />
- Tenho uma função e dependendo dos parâmetros que eu coloco ao chamá-la, eu chamo uma função ou outra<br />
<br />
'''Exemplo de sobrecarga de funções em Julia:'''<br />
<br />
<pre> <br />
//dependendo do tipo da minha variavel x na chamada da funcao, sera chamado uma funcao ou outra, mesmo que tenham o mesmo nome<br />
<br />
function printx(x::Float64)<br />
println(x)<br />
end<br />
<br />
function printx(x::String)<br />
println(x)<br />
end<br />
<br />
x="Oi"<br />
<br />
printx(x)<br />
</pre><br />
<br />
<br />
<br />
== Performance de Julia: na prática ==<br />
Para resumir, temos: <br />
<br />
Python => dynamic (variáveis dinâmicas) single<br />
dispatch<br />
<br />
C++ => static (variáveis estáticas) multiple dispatch<br />
<br />
Julia => dynamic multiple dispatch (''o melhor dos dois mundos!'')<br />
<br />
Na prática, é mostrado abaixo um exemplo da performance de Julia como linguagem de programação em dynamic multiple dispatch. <br />
<br />
O mesmo programa foi escrito em Julia e em C++. <br />
<br />
Em '''Julia''':<br />
<br />
<pre><br />
abstract type Animal end<br />
<br />
struct Cachorro <: Animal<br />
nome::String<br />
end<br />
<br />
struct Gato <: Animal<br />
nome::String<br />
end<br />
<br />
# Função de encontro que recebe tipo genérico de animal<br />
function encontroDeAnimais(a::Animal, b::Animal)<br />
acao = encontro(a,b)<br />
println("$(a.nome) encontra $(b.nome) e $acao")<br />
end<br />
<br />
# Funções de expressão única que recebem diferentes tipos de animais<br />
encontro(a::Cachorro, b::Cachorro) = "cheira" <br />
encontro(a::Cachorro, b::Gato) = "persegue"<br />
encontro(a::Gato, b::Gato) = "lambe"<br />
encontro(a::Gato, b::Cachorro) = "ignora" <br />
<br />
# Instanciando os bichinhos<br />
gato1 = Gato("Luciene Maria")<br />
gato2 = Gato("Mel")<br />
cachorro1 = Cachorro("Batata")<br />
cachorro2 = Cachorro("Snoopy")<br />
<br />
# Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2)<br />
encontroDeAnimais(gato1, cachorro2)<br />
encontroDeAnimais(cachorro1, cachorro2)<br />
</pre><br />
<br />
<br />
Em '''C++''':<br />
<br />
<pre><br />
#include <iostream><br />
using namespace std;<br />
<br />
class Animal { <br />
public:<br />
string nome;<br />
};<br />
<br />
string encontro(Animal a, Animal b) {}<br />
<br />
// Função de encontro que recebe tipo genérico de animal<br />
void encontroDeAnimais(Animal a, Animal b) {<br />
string acao = encontro(a,b);<br />
cout << a.nome << " encontra " << b.nome << " e " << acao << endl;<br />
}<br />
<br />
class Cachorro:public Animal {};<br />
class Gato:public Animal {};<br />
<br />
// Funções de expressão única que recebem diferentes tipos de animais<br />
string encontro(Cachorro a, Cachorro b) { return "cheira"; }<br />
string encontro(Cachorro a, Gato b) { return "persegue"; }<br />
string encontro(Gato a, Gato b) { return "lambe"; }<br />
string encontro(Gato a, Cachorro b) { return "ignora"; }<br />
<br />
int main() {<br />
// Instanciando os bichinhos<br />
Gato gato1; gato1.nome = "Luciene Maria";<br />
Gato gato2; gato2.nome = "Mel";<br />
Cachorro cachorro1; cachorro1.nome = "Batata";<br />
Cachorro cachorro2; cachorro2.nome = "Snoopy";<br />
<br />
// Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2);<br />
encontroDeAnimais(gato1, cachorro2);<br />
encontroDeAnimais(cachorro1, cachorro2);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Para '''Julia''' nós obtemos o seguinte '''resultado''':<br />
<br />
<pre><br />
Luciene Maria encontra Mel e lambe<br />
Luciene Maria encontra Snoopy e ignora<br />
Batata encontra Snoopy e cheira<br />
</pre><br />
<br />
Para '''C++''' o '''resultado''' é:<br />
<br />
<pre><br />
Luciene Maria encontra Mel e<br />
Falha de Segmentação<br />
</pre><br />
<br />
Isso acontece porque C++ não aceita que uma função utilize-se de uma variável sem antes saber qual o tipo dessa variável! Por isso, poder utilizar-se de variáveis dinâmicas quando há multi-métodos é um diferencial que acaba por incrementar a performance de Julia como linguagem de programação visada para o Cálculo Numérico.<br />
<br />
'''Observação:''' é importante ressaltar que os testes feitos não são conclusivos para debater a performance de Julia, em termos estatísticos, e além disso, ser uma linguagem de programação que utiliza de variáveis dinâmicas e multi-métodos não é o único motivo pelo qual Julia poderia trazer tal performance em Cálculo Numérico. Podemos ainda contar com a sua capacidade de '''metaprogramação''', ou seja, Julia pode usar macros e eles são aplicados em tempo de interpretação. Há ainda outros fatores da construção da linguagem que contribuem para sua performance que aqui não foram citados.<br />
<br />
<br />
== Aprendendo Julia ==<br />
<br />
Após feita a instalação de Julia, para abri-la no terminal de comando é preciso apenas digitar <pre>$Julia</pre> para entrar no seu ambiente de programação.<br />
<br />
É possível, também, programar em um arquivo de texto e executar o programa pelo terminal, fazendo simplesmente:<br />
<br />
<pre><br />
$julia programa.jl <br />
</pre><br />
<br />
'''Impressão na tela'''<br />
<pre><br />
println("Hello World")<br />
<br />
Saída:<br />
Hello World<br />
</pre><br />
<br />
'''Variáveis'''<br />
<br />
Variáveis são atribuídas dinamicamente e podem mudar.<br />
<pre><br />
s = 1<br />
s = "Oi"<br />
println(s)<br />
println(typeof(s))<br />
<br />
Saída:<br />
Oi<br />
String<br />
</pre><br />
<br />
<pre><br />
s::String<br />
s = 1<br />
println(s)<br />
<br />
Saída:<br />
TypeError: in typeassert, expected String, got Int32<br />
</pre><br />
<br />
'''Condicionais'''<br />
<pre><br />
cats = 12<br />
if cats < 1<br />
println("You should adopt a cat.")<br />
elseif cats >= 1 && cats <=6<br />
println("Not enough cats.")<br />
elseif cats >= 7 && cats <= 12<br />
println("Still not enough cats.")<br />
else<br />
println("Gato have more cats.")<br />
end<br />
<br />
Saída:<br />
Still not enough cats.<br />
</pre><br />
<br />
<pre><br />
i = 0<br />
while (i < 10)<br />
global i += 1<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
</pre><br />
<br />
<pre><br />
for i = 1:10<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
</pre><br />
<br />
<pre><br />
for i in [1,2,3]<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
3<br />
</pre><br />
<br />
'''Arrays'''<br />
<pre><br />
# Criando um array de zeros<br />
a1 = zeros()<br />
println(a1)<br />
# Posso definir o tipo e o tamanho do Array (linhas, colunas) também<br />
a1 = zeros(Int32, 1, 4)<br />
println(a1)<br />
<br />
Saída:<br />
0.0<br />
[0 0 0 0]<br />
</pre><br />
<br />
<pre><br />
# Criando um array do tipo inteiro<br />
a2 = Array{Int32}<br />
println(a2)<br />
# Criando um array (de outra maneira) do tipo float<br />
a3 = Float64[]<br />
println(a3)<br />
<br />
Saída:<br />
Array{Int32,N} where N<br />
Float64[]<br />
</pre><br />
<br />
<pre><br />
# Criando um array e definindo valores<br />
a4 = [1,2,3]<br />
#Imprimindo a4<br />
println("Array: ", a4)<br />
<br />
Saída:<br />
Array: [1, 2, 3]<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Imprimindo valor de um indíce específico<br />
println("Imprimindo primeiro elemento: ", a4[1])<br />
# Imprimindo último valor do array<br />
println("Imprimindo último elemento: ",a4[end])<br />
<br />
Saída:<br />
Imprimindo primeiro elemento: 1<br />
Imprimindo último elemento: 3<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
println(a4[2])<br />
# Valores podem mudar (diferente de Tuplas, que veremos adiante)<br />
a4[2] = 4<br />
println(a4[2])<br />
<br />
Saída:<br />
2<br />
4<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
println(a4)<br />
# Número de elementos<br />
println("Imprimindo número de elementos: ",length(a4))<br />
<br />
Saída:<br />
[1, 2, 3]<br />
Imprimindo número de elementos: 3<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Soma os valores do array<br />
println("Imprimindo soma dos elementos: ",sum(a4))<br />
# Põe os valores começando no índice 2<br />
splice!(a4, 2:1, [8,9])<br />
println("Imprimindo Array tendo feito splice!(a4, 2:1, [8,9]): ",a4)<br />
# Remove os itens do índice 2 ao 3<br />
4splice!(a4, 2:3)<br />
println("Imprimindo Array tendo feito splice!(a4, 2:3): ",a4)<br />
<br />
Saída:<br />
Imprimindo soma dos elementos: 6<br />
Imprimindo Array tendo feito splice!(a4, 2:1, [8,9]): [1, 8, 9, 2, 3]<br />
Imprimindo Array tendo feito splice!(a4, 2:3): [1, 2, 3]<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Pegar valor máximo e valor mínimo<br />
println("Imprimindo valor máximo: ",maximum(a4))<br />
println("Imprimindo Array valor mínimo: ",minimum(a4))<br />
# Multiplicando todos os elementos do array por outro número sem precisar de um␣<br />
println("Imprimindo multiplicação dos elementos por 2: ",a4 * 2)<br />
<br />
Saída:<br />
Imprimindo valor máximo: 3<br />
Imprimindo Array valor mínimo: 1<br />
Imprimindo multiplicação dos elementos por 2: [2, 4, 6]<br />
</pre><br />
<br />
<pre><br />
# Arrays podem conter funções<br />
a5 = [sin, cos, tan]<br />
for n in a5<br />
println(n(0))<br />
end<br />
<br />
Saída:<br />
0.0<br />
1.0<br />
0.0<br />
</pre><br />
<br />
<pre><br />
# Para os acostumados com range<br />
a6 = collect(1:5)<br />
println(a6)<br />
<br />
Saída:<br />
[1, 2, 3, 4, 5]<br />
</pre><br />
<br />
'''Tuplas'''<br />
<br />
A maioria das funções de array funciona com tuplas.<br />
<pre><br />
# Valores não podem mudar<br />
t1 = (1,2,3,4)<br />
println(t1[2])<br />
t1[2] = 5<br />
println(t1[2])<br />
<br />
Saída:<br />
2<br />
MethodError: no method matching setindex!(::NTuple{4,Int32}, ::Int32, ::Int32)<br />
</pre><br />
<br />
<pre><br />
# Imprimindo a tupla inteira<br />
println(t1)<br />
# Imprimindo a tupla inteira<br />
for i in t1<br />
println(i)<br />
end<br />
<br />
Saída:<br />
(1, 2, 3, 4)<br />
1<br />
2<br />
3<br />
4<br />
</pre><br />
<br />
'''Dicionários'''<br />
<br />
A palavra-chave deve ser única.<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Imprimir um valor<br />
println(d1["pi"])<br />
<br />
Saída:<br />
3.14<br />
</pre><br />
<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Imprimindo todas as palavras-chaves<br />
println(keys(d1))<br />
# Imprimindo todos os valores<br />
println(values(d1))<br />
# Adicionar uma palavra-chave<br />
d1["golden"] = 1.618<br />
# Deleter uma palavra-chave<br />
delete!(d1, "pi")<br />
# Imprimindo todas as palavras-chaves<br />
println(keys(d1))<br />
# Imprimindo todos os valores<br />
println(values(d1))<br />
<br />
Saída:<br />
["pi", "e"]<br />
[3.14, 2.718]<br />
["e", "golden"]<br />
[2.718, 1.618]<br />
</pre><br />
<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Ver se a palavra-chave existe<br />
println(haskey(d1, "pi"))<br />
# Imprimindo palavras-chaves E valores<br />
for kv in d1<br />
println(kv)<br />
end<br />
<br />
Saída:<br />
true<br />
"pi" => 3.14<br />
"e" => 2.718<br />
</pre><br />
<br />
'''Sets'''<br />
<br />
Sets são arrays com elementos únicos.<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
# Ele não pega os elementos repetidos<br />
println(st1)<br />
<br />
Saída:<br />
Set(["Pam", "Jim"])<br />
</pre><br />
<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
# Adicionando um elemento<br />
push!(st1, "Michael")<br />
println(st1)<br />
# Ver se um elemento está no Set<br />
println(in("Dwight", st1))<br />
<br />
Saída:<br />
Set(["Pam", "Michael", "Jim"])<br />
false<br />
</pre><br />
<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
st2 = Set(["Stanley", "Meredith"])<br />
# Combinando Sets<br />
println(union(st1, st2))<br />
# Imprimindo todo o elemento que os dois Sets tem em comum<br />
println(intersect(st1, st2))<br />
# Imprimindo elementos que estão no primeiro Set, mas não no segundo<br />
println(setdiff(st1, st2))<br />
<br />
Saída:<br />
Set(["Jim", "Meredith", "Stanley", "Pam"])<br />
Set(String[])<br />
Set(["Pam", "Jim"])<br />
</pre><br />
<br />
'''Funções'''<br />
<pre><br />
using Printf<br />
# Função de expressão única<br />
soma(x,y) = x + y<br />
x, y = 1, 2<br />
@printf("%d + %d = %d\n", x, y, x+y)<br />
<br />
Saída:<br />
1 + 2 = 3<br />
</pre><br />
<br />
<pre><br />
# Função de múltiplas expressões<br />
function adoptACat(cats)<br />
if cats <= 1<br />
println("You should adopt a cat.")<br />
else<br />
println("You should adopt a cat. They're cute.")<br />
end<br />
end<br />
adoptACat(2)<br />
<br />
Saída:<br />
You should adopt a cat. They're cute.<br />
</pre><br />
<br />
<pre><br />
v1 = 5<br />
function changeV1(v1)<br />
v1 = 10<br />
end<br />
changeV1(v1)<br />
println(v1)<br />
<br />
Saída:<br />
5<br />
</pre><br />
<br />
<pre><br />
v1 = 5<br />
function changeV1(v1)<br />
v1 = 10<br />
return v1<br />
end<br />
changeV1(v1)<br />
println(v1)<br />
v2 = changeV1(v1)<br />
println(v2)<br />
<br />
Saída:<br />
5<br />
10<br />
</pre><br />
<br />
<pre><br />
# Usando variáveis globais dentro da função<br />
v1 = 5<br />
function changeV12()<br />
global v1 = 10<br />
end<br />
changeV12()<br />
println(v1)<br />
<br />
Saída:<br />
10<br />
</pre><br />
<br />
<pre><br />
# Quando não sei quantos argumentos vou passar<br />
function soma(args...)<br />
sum = 0<br />
for i in args<br />
sum += i<br />
end<br />
println(sum)<br />
end<br />
soma(1,2,3)<br />
<br />
Saída:<br />
6<br />
</pre><br />
<br />
<pre><br />
# Retornando mais de um valor<br />
function retorna2(valor)<br />
return (valor + 1, valor + 2)<br />
end<br />
println(retorna2(4))<br />
<br />
Saída:<br />
(5, 6)<br />
</pre><br />
<br />
<pre><br />
# Map é uma função anônima que aplica uma função para cada elemento<br />
v = map(x -> x * x, [1,2,3])<br />
println(v)<br />
<br />
Saída:<br />
[1, 4, 9]<br />
<br />
'''Structs'''<br />
<pre><br />
struct Estudante<br />
name::String<br />
saldoTRI::Float32<br />
cartaoUFRGS::Int<br />
end<br />
# Criando um objeto<br />
estudante1 = Estudante("Raquel", 10.50, 244449)<br />
println(estudante1.name, "\n", estudante1.saldoTRI, "\n", estudante1.cartaoUFRGS)<br />
<br />
Saída:<br />
Raquel<br />
10.5<br />
244449<br />
9<br />
</pre><br />
<br />
'''Tipos Abstratos'''<br />
<br />
Tipos abstratos não podem ser instanciados como as Structs (instanciar => fazer estudante1 =<br />
Estudante(“Raquel”, 10.50, 244449) => criar um objeto) MAS podem ter subTipos e isso é muito<br />
útil!<br />
<br />
<pre><br />
abstract type animal end<br />
struct cachorro <: animal<br />
nome::String<br />
latido::String<br />
end<br />
struct gato <: animal<br />
nome::String<br />
miado::String<br />
end<br />
cachorro1 = cachorro("Urso", "Au Au")<br />
gato1 = gato("Lucia Irene", "Miau")<br />
# Criando funções pros subTipos<br />
function fazerSom(animal::cachorro)<br />
println("$(animal.nome) diz $(animal.latido)")<br />
end<br />
function fazerSom(animal::gato)<br />
println("$(animal.nome) diz $(animal.miado)")<br />
end<br />
fazerSom(cachorro1)<br />
fazerSom(gato1)<br />
<br />
Saída: <br />
Urso diz Au Au<br />
Lucia Irene diz Miau<br />
</pre></div>Raquelmhttp://fiscomp.if.ufrgs.br/index.php?title=Julia&diff=2479Julia2020-01-07T00:21:26Z<p>Raquelm: /* Aprendendo Julia */</p>
<hr />
<div>Julia é uma linguagem relativamente nova de programação que começou a ser desenvolvida em 2009 por Jeff Bezanson, Stefan Karpinski, Viral B. Shah, e Alan Edelman, um grupo do MIT. Ela foi oficialmente lançada para o mundo em 2012.<br />
<br />
Em uma entrevista, quando perguntaram a Alan o por quê do nome Julia, ele disse que numa conversa anos atrás alguém sugeriu que Julia seria um bom nome para uma linguagem de programação.<br />
<br />
Julia pode ser usada para propósitos gerais de programação, assim como Python, mas em sua criação foi visada a utilização de Julia para Cálculo Numérico.<br />
<br />
== Aspectos Gerais ==<br />
<br />
Julia é uma linguagem de alto nível, isso significa, de maneira sucinta, que ela não é executada utilizando somente o processador, assim como acontece com linguagens de baixo nível, como Assembly, por exemplo.<br />
<br />
É escrita em C, C++, e Scheme, usando a estrutura do compilador LLVM (para melhor entendimento, o compilador de C é o GCC, por exemplo), enquanto a maior parte da biblioteca padrão de Julia é implementada na própria Julia.<br />
<br />
Um fato importante sobre Julia para os programadores de Python é que todas as bibliotecas de Python são usáveis através de um comando simples: PyCall.<br />
<br />
Um fato importante sobre Julia para os programadores de C é que Julia possui APIs (Interfaces de Programação de Aplicativos) especiais para chamada de funções em C diretamente.<br />
<br />
== Velocidade ==<br />
<br />
De acordo com testes feitos pelos próprios criadores de Julia, sua velocidade é similar com a de C.<br />
<br />
<br />
<center>[[Arquivo:juliasvelocity.png|border]]<br />
Fonte: [https://julialang.org/benchmarks/]<br />
</center><br />
<br />
<br />
== Testes de Velocidade ==<br />
<br />
A fim de pessoalmente testar a velocidade da linguagem de programação, foi escrito um programa em Julia de maneira similar ao programa de Python para o FTCS aplicado na Equação de Difusão (também conhecida como Equação do Calor). <br />
<br />
A Equação da Difusão em uma dimensão pode ser escrita da forma:<br />
<br />
<center><math>\frac{df}{dt}=\frac{d^{2}f}{dx^{2}}</math></center><br />
<br />
No método de FTCS (Forward-Time Central-Space) definimos a derivada em t na forma não simetrizada (forward) e as derivadas em x na forma simetrizada:<br />
<br />
<br />
<center><math>\frac{df}{dt} = \frac{f(x, t+dt) - f(x,t)}{dt}</math></center><br />
<br />
<p><br />
<br />
<center><math>\frac{d^{2}f}{dx^{2}} = \frac{f(x+dx, t) + f(x-dx, t) - 2f(x,t)}{dx^{2}}</math></center><br />
<br />
E substuindo na equação da difusão, em notação discreta temos:<br />
<br />
<center><math>f_{j}^{n+1} = f_{j}^{n} + D\frac{dt}{(dx)^{2}}[f_{j+1}^{n} + f_{j-1}^{n} - 2 f_{j}^{n}]</math></center><br />
<br />
'''Observação:''' esse procedimento funciona bem se <math>k=D\frac{dt}{(dx)^{2}} <= 1/2</math>, segundo análise de estabilidade do método.<br />
<br />
<br />
Dessa forma, foi escrito um programa para integrar a Equação de Difusão através do método de FTCS nas linguagens Python e Julia.<br />
<br />
Para '''Python''':<br />
<pre><br />
//FTCS aplicado na equacao da difusao. Linguagem: PYTHON<br />
<br />
import copy<br />
import numpy as np<br />
import matplotlib.pyplot as plt<br />
<br />
def init():<br />
L=50;D=1.;dt=0.05;dx=1.;t=0;tmax=100.<br />
k=D*dt/(dx*dx) <br />
return L,k,dt,t,tmax<br />
<br />
L,k,dt,t,tmax = init()<br />
<br />
x = np.arange(0,L,1) <br />
f = np.zeros(x.shape)<br />
<br />
a = int(L/3)<br />
b = int(2*L/3)<br />
f[a:b]=1.<br />
f1 = copy.deepcopy(f) <br />
f2 = copy.deepcopy(f)<br />
<br />
while t<tmax:<br />
t+=dt<br />
f1[1:L-1]=f[1:L-1]+k*(f[0:L-2]+f[2:L]-2*f[1:L-1])<br />
f1[L-1]=f[L-1]+k*(f[L-2]+f[0]-2*f[L-1]) <br />
f1[0]=f[0]+k*(f[1]+f[L-1]-2*f[0]) <br />
f=copy.deepcopy(f1) <br />
<br />
sum0=sum(f1)<br />
sum1=sum(f2) <br />
<br />
print("Integral em t=0: %7.4f" % sum0)<br />
print("Integral em tmax: %7.4f" % sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
Em '''Julia''':<br />
<pre><br />
//FTCS aplicado na equacao da difusao. Linguagem: JULIA<br />
<br />
using PyPlot<br />
<br />
L=50<br />
D=1.<br />
dt=0.05<br />
dx=1.<br />
t=0<br />
tmax=100.<br />
k=D*dt/(dx*dx) <br />
<br />
x = collect(0:1:L-1)<br />
f = zeros(L)<br />
f1 = zeros(L)<br />
<br />
a = trunc(Int, L/3) <br />
b = trunc(Int, 2*L/3)<br />
<br />
f[a+1:b] .= 1.<br />
f2 = deepcopy(f)<br />
<br />
while t<tmax<br />
global t+=dt <br />
f1[2:L-1] = f[2:L-1] + k*(f[1:L-2] + f[3:L] - 2*f[2:L-1]) <br />
f1[L] = f[L] + k*(f[L-1] + f[1] - 2*f[L])<br />
f1[1] = f[1] + k*(f[2] + f[L] - 2*f[1]) <br />
global f = deepcopy(f1) <br />
end<br />
<br />
sum0 = sum(f1)<br />
sum1 = sum(f2)<br />
<br />
println("Integral em t=0: ", sum0)<br />
println("Integral em tmax: ", sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
<br />
Foi testado o tempo de execução da parte principal dos dois programas (isto é, sem fazer o gráfico dos resultados), através do timer do terminal, como mostra na próxima figura:<br />
<br />
<center>[[Arquivo:Ftcs_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o método de FTCS aplicado à Equação de Difusão<br />
</center><br />
<br />
É possível perceber, através da figura acima, que o tempo de execução de Python para o FTCS aplicado à Equação de Difusão é menor do que o de Julia. Em razão disso, foi testado um programa simples, como mostra abaixo, que incrementa uma variável 10 vezes, sendo o seu valor inicial 0.<br />
<br />
<br />
<center>[[Arquivo:For.png|border]]<br />
'''Legenda:''' Programa para incrementar o valor de uma variável, nesse caso ''i'', 10 vezes, escrito em Julia e em Python<br />
</center><br />
<br />
E posteriormente, novamente, foi testado o tempo de execução da parte principal dos programas através do terminal:<br />
<br />
<center>[[Arquivo:For_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o programa que incrementa o valor da variável 10 vezes<br />
</center><br />
<br />
É possível perceber que para esse simples programa de incrementação, Python ainda obtém melhor performance do que Julia.<br />
<br />
<br />
== Performance de Julia ==<br />
<br />
Tentando entender o que traria tal performance em Cálculo Numérico para Julia, foi chegado à conclusão de que ser uma linguagem que se utilizada de ''variáveis dinâmicas'' e ''multi-métodos'' seria uma das grandes contribuições da linguagem.<br />
<br />
'''Variáveis dinâmicas:'''<br />
<br />
Em Python elas são interpretadas em runtime, ou seja, '''tempo de execução''' => o programa checa toda hora se a variável mudou e isso torna ele mais lento<br />
<br />
'''Variáveis estáticas:'''<br />
<br />
Em C as variáveis são fixas, e isso é visto é em '''tempo de compilação''' => precisa pensar nas variáveis e isso torna o tempo de programação mais lento<br />
<br />
Em Julia isso é basicamente opcional, não é preciso definir as variáveis, mas é possível, e elas podem mudar dinamicamente, em tempo de execução. E ainda, Julia se utiliza de multi-métodos para não ter que lidar com a constante checagem dos tipos das variáveis, como Python faz!<br />
<br />
'''Métodos Únicos'''<br />
<br />
Python => single dispatch => Métodos Únicos<br />
- Não tenho sobrecarga de funções, eu simplesmente chamo uma função que já está escrita<br />
<br />
'''Multi-métodos'''<br />
<br />
Sobrecarga de funções (C++) => Multi-métodos (multiple dispatch)<br />
- Tenho uma função e dependendo dos parâmetros que eu coloco ao chamá-la, eu chamo uma função ou outra<br />
<br />
'''Exemplo de sobrecarga de funções em Julia:'''<br />
<br />
<pre> <br />
//dependendo do tipo da minha variavel x na chamada da funcao, sera chamado uma funcao ou outra, mesmo que tenham o mesmo nome<br />
<br />
function printx(x::Float64)<br />
println(x)<br />
end<br />
<br />
function printx(x::String)<br />
println(x)<br />
end<br />
<br />
x="Oi"<br />
<br />
printx(x)<br />
</pre><br />
<br />
<br />
<br />
== Performance de Julia: na prática ==<br />
Para resumir, temos: <br />
<br />
Python => dynamic (variáveis dinâmicas) single<br />
dispatch<br />
<br />
C++ => static (variáveis estáticas) multiple dispatch<br />
<br />
Julia => dynamic multiple dispatch (''o melhor dos dois mundos!'')<br />
<br />
Na prática, é mostrado abaixo um exemplo da performance de Julia como linguagem de programação em dynamic multiple dispatch. <br />
<br />
O mesmo programa foi escrito em Julia e em C++. <br />
<br />
Em '''Julia''':<br />
<br />
<pre><br />
abstract type Animal end<br />
<br />
struct Cachorro <: Animal<br />
nome::String<br />
end<br />
<br />
struct Gato <: Animal<br />
nome::String<br />
end<br />
<br />
# Função de encontro que recebe tipo genérico de animal<br />
function encontroDeAnimais(a::Animal, b::Animal)<br />
acao = encontro(a,b)<br />
println("$(a.nome) encontra $(b.nome) e $acao")<br />
end<br />
<br />
# Funções de expressão única que recebem diferentes tipos de animais<br />
encontro(a::Cachorro, b::Cachorro) = "cheira" <br />
encontro(a::Cachorro, b::Gato) = "persegue"<br />
encontro(a::Gato, b::Gato) = "lambe"<br />
encontro(a::Gato, b::Cachorro) = "ignora" <br />
<br />
# Instanciando os bichinhos<br />
gato1 = Gato("Luciene Maria")<br />
gato2 = Gato("Mel")<br />
cachorro1 = Cachorro("Batata")<br />
cachorro2 = Cachorro("Snoopy")<br />
<br />
# Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2)<br />
encontroDeAnimais(gato1, cachorro2)<br />
encontroDeAnimais(cachorro1, cachorro2)<br />
</pre><br />
<br />
<br />
Em '''C++''':<br />
<br />
<pre><br />
#include <iostream><br />
using namespace std;<br />
<br />
class Animal { <br />
public:<br />
string nome;<br />
};<br />
<br />
string encontro(Animal a, Animal b) {}<br />
<br />
// Função de encontro que recebe tipo genérico de animal<br />
void encontroDeAnimais(Animal a, Animal b) {<br />
string acao = encontro(a,b);<br />
cout << a.nome << " encontra " << b.nome << " e " << acao << endl;<br />
}<br />
<br />
class Cachorro:public Animal {};<br />
class Gato:public Animal {};<br />
<br />
// Funções de expressão única que recebem diferentes tipos de animais<br />
string encontro(Cachorro a, Cachorro b) { return "cheira"; }<br />
string encontro(Cachorro a, Gato b) { return "persegue"; }<br />
string encontro(Gato a, Gato b) { return "lambe"; }<br />
string encontro(Gato a, Cachorro b) { return "ignora"; }<br />
<br />
int main() {<br />
// Instanciando os bichinhos<br />
Gato gato1; gato1.nome = "Luciene Maria";<br />
Gato gato2; gato2.nome = "Mel";<br />
Cachorro cachorro1; cachorro1.nome = "Batata";<br />
Cachorro cachorro2; cachorro2.nome = "Snoopy";<br />
<br />
// Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2);<br />
encontroDeAnimais(gato1, cachorro2);<br />
encontroDeAnimais(cachorro1, cachorro2);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Para '''Julia''' nós obtemos o seguinte '''resultado''':<br />
<br />
<pre><br />
Luciene Maria encontra Mel e lambe<br />
Luciene Maria encontra Snoopy e ignora<br />
Batata encontra Snoopy e cheira<br />
</pre><br />
<br />
Para '''C++''' o '''resultado''' é:<br />
<br />
<pre><br />
Luciene Maria encontra Mel e<br />
Falha de Segmentação<br />
</pre><br />
<br />
Isso acontece porque C++ não aceita que uma função utilize-se de uma variável sem antes saber qual o tipo dessa variável! Por isso, poder utilizar-se de variáveis dinâmicas quando há multi-métodos é um diferencial que acaba por incrementar a performance de Julia como linguagem de programação visada para o Cálculo Numérico.<br />
<br />
'''Observação:''' é importante ressaltar que os testes feitos não são conclusivos para debater a performance de Julia, em termos estatísticos, e além disso, ser uma linguagem de programação que utiliza de variáveis dinâmicas e multi-métodos não é o único motivo pelo qual Julia poderia trazer tal performance em Cálculo Numérico. Podemos ainda contar com a sua capacidade de '''metaprogramação''', ou seja, Julia pode usar macros e eles são aplicados em tempo de interpretação. Há ainda outros fatores da construção da linguagem que contribuem para sua performance que aqui não foram citados.<br />
<br />
<br />
== Aprendendo Julia ==<br />
<br />
Após feita a instalação de Julia, para abri-la no terminal de comando é preciso apenas digitar <pre>$Julia</pre> para entrar no seu ambiente de programação.<br />
<br />
É possível, também, programar em um arquivo de texto e executar o programa pelo terminal, fazendo simplesmente:<br />
<br />
<pre><br />
$julia programa.jl <br />
</pre><br />
<br />
'''Impressão na tela'''<br />
<pre><br />
println("Hello World")<br />
<br />
Saída:<br />
Hello World<br />
</pre><br />
<br />
'''Variáveis'''<br />
<br />
Variáveis são atribuídas dinamicamente e podem mudar.<br />
<pre><br />
s = 1<br />
s = "Oi"<br />
println(s)<br />
println(typeof(s))<br />
<br />
Saída:<br />
Oi<br />
String<br />
</pre><br />
<br />
<pre><br />
s::String<br />
s = 1<br />
println(s)<br />
<br />
Saída:<br />
TypeError: in typeassert, expected String, got Int32<br />
</pre><br />
<br />
'''Condicionais'''<br />
<pre><br />
cats = 12<br />
if cats < 1<br />
println("You should adopt a cat.")<br />
elseif cats >= 1 && cats <=6<br />
println("Not enough cats.")<br />
elseif cats >= 7 && cats <= 12<br />
println("Still not enough cats.")<br />
else<br />
println("Gato have more cats.")<br />
end<br />
<br />
Saída:<br />
Still not enough cats.<br />
</pre><br />
<br />
<pre><br />
i = 0<br />
while (i < 10)<br />
global i += 1<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
</pre><br />
<br />
<pre><br />
for i = 1:10<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
</pre><br />
<br />
<pre><br />
for i in [1,2,3]<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
3<br />
</pre><br />
<br />
'''Arrays'''<br />
<pre><br />
# Criando um array de zeros<br />
a1 = zeros()<br />
println(a1)<br />
# Posso definir o tipo e o tamanho do Array (linhas, colunas) também<br />
a1 = zeros(Int32, 1, 4)<br />
println(a1)<br />
<br />
Saída:<br />
0.0<br />
[0 0 0 0]<br />
</pre><br />
<br />
<pre><br />
# Criando um array do tipo inteiro<br />
a2 = Array{Int32}<br />
println(a2)<br />
# Criando um array (de outra maneira) do tipo float<br />
a3 = Float64[]<br />
println(a3)<br />
<br />
Saída:<br />
Array{Int32,N} where N<br />
Float64[]<br />
</pre><br />
<br />
<pre><br />
# Criando um array e definindo valores<br />
a4 = [1,2,3]<br />
#Imprimindo a4<br />
println("Array: ", a4)<br />
<br />
Saída:<br />
Array: [1, 2, 3]<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Imprimindo valor de um indíce específico<br />
println("Imprimindo primeiro elemento: ", a4[1])<br />
# Imprimindo último valor do array<br />
println("Imprimindo último elemento: ",a4[end])<br />
<br />
Saída:<br />
Imprimindo primeiro elemento: 1<br />
Imprimindo último elemento: 3<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
println(a4[2])<br />
# Valores podem mudar (diferente de Tuplas, que veremos adiante)<br />
a4[2] = 4<br />
println(a4[2])<br />
<br />
Saída:<br />
2<br />
4<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
println(a4)<br />
# Número de elementos<br />
println("Imprimindo número de elementos: ",length(a4))<br />
<br />
Saída:<br />
[1, 2, 3]<br />
Imprimindo número de elementos: 3<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Soma os valores do array<br />
println("Imprimindo soma dos elementos: ",sum(a4))<br />
# Põe os valores começando no índice 2<br />
splice!(a4, 2:1, [8,9])<br />
println("Imprimindo Array tendo feito splice!(a4, 2:1, [8,9]): ",a4)<br />
# Remove os itens do índice 2 ao 3<br />
4splice!(a4, 2:3)<br />
println("Imprimindo Array tendo feito splice!(a4, 2:3): ",a4)<br />
<br />
Saída:<br />
Imprimindo soma dos elementos: 6<br />
Imprimindo Array tendo feito splice!(a4, 2:1, [8,9]): [1, 8, 9, 2, 3]<br />
Imprimindo Array tendo feito splice!(a4, 2:3): [1, 2, 3]<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Pegar valor máximo e valor mínimo<br />
println("Imprimindo valor máximo: ",maximum(a4))<br />
println("Imprimindo Array valor mínimo: ",minimum(a4))<br />
# Multiplicando todos os elementos do array por outro número sem precisar de um␣<br />
println("Imprimindo multiplicação dos elementos por 2: ",a4 * 2)<br />
<br />
Saída:<br />
Imprimindo valor máximo: 3<br />
Imprimindo Array valor mínimo: 1<br />
Imprimindo multiplicação dos elementos por 2: [2, 4, 6]<br />
</pre><br />
<br />
<pre><br />
# Arrays podem conter funções<br />
a5 = [sin, cos, tan]<br />
for n in a5<br />
println(n(0))<br />
end<br />
<br />
Saída:<br />
0.0<br />
1.0<br />
0.0<br />
</pre><br />
<br />
<pre><br />
# Para os acostumados com range<br />
a6 = collect(1:5)<br />
println(a6)<br />
<br />
Saída:<br />
[1, 2, 3, 4, 5]<br />
</pre><br />
<br />
'''Tuplas'''<br />
<br />
A maioria das funções de array funciona com tuplas.<br />
<pre><br />
# Valores não podem mudar<br />
t1 = (1,2,3,4)<br />
println(t1[2])<br />
t1[2] = 5<br />
println(t1[2])<br />
<br />
Saída:<br />
2<br />
MethodError: no method matching setindex!(::NTuple{4,Int32}, ::Int32, ::Int32)<br />
</pre><br />
<br />
<pre><br />
# Imprimindo a tupla inteira<br />
println(t1)<br />
# Imprimindo a tupla inteira<br />
for i in t1<br />
println(i)<br />
end<br />
<br />
Saída:<br />
(1, 2, 3, 4)<br />
1<br />
2<br />
3<br />
4<br />
</pre><br />
<br />
'''Dicionários'''<br />
<br />
A palavra-chave deve ser única.<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Imprimir um valor<br />
println(d1["pi"])<br />
<br />
Saída:<br />
3.14<br />
</pre><br />
<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Imprimindo todas as palavras-chaves<br />
println(keys(d1))<br />
# Imprimindo todos os valores<br />
println(values(d1))<br />
# Adicionar uma palavra-chave<br />
d1["golden"] = 1.618<br />
# Deleter uma palavra-chave<br />
delete!(d1, "pi")<br />
# Imprimindo todas as palavras-chaves<br />
println(keys(d1))<br />
# Imprimindo todos os valores<br />
println(values(d1))<br />
<br />
Saída:<br />
["pi", "e"]<br />
[3.14, 2.718]<br />
["e", "golden"]<br />
[2.718, 1.618]<br />
</pre><br />
<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Ver se a palavra-chave existe<br />
println(haskey(d1, "pi"))<br />
# Imprimindo palavras-chaves E valores<br />
for kv in d1<br />
println(kv)<br />
end<br />
<br />
Saída:<br />
true<br />
"pi" => 3.14<br />
"e" => 2.718<br />
</pre><br />
<br />
'''Sets'''<br />
<br />
Sets são arrays com elementos únicos.<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
# Ele não pega os elementos repetidos<br />
println(st1)<br />
<br />
Saída:<br />
Set(["Pam", "Jim"])<br />
</pre><br />
<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
# Adicionando um elemento<br />
push!(st1, "Michael")<br />
println(st1)<br />
# Ver se um elemento está no Set<br />
println(in("Dwight", st1))<br />
<br />
Saída:<br />
Set(["Pam", "Michael", "Jim"])<br />
false<br />
</pre><br />
<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
st2 = Set(["Stanley", "Meredith"])<br />
# Combinando Sets<br />
println(union(st1, st2))<br />
# Imprimindo todo o elemento que os dois Sets tem em comum<br />
println(intersect(st1, st2))<br />
# Imprimindo elementos que estão no primeiro Set, mas não no segundo<br />
println(setdiff(st1, st2))<br />
<br />
Saída:<br />
Set(["Jim", "Meredith", "Stanley", "Pam"])<br />
Set(String[])<br />
Set(["Pam", "Jim"])<br />
</pre><br />
<br />
'''Funções'''<br />
<pre><br />
using Printf<br />
# Função de expressão única<br />
soma(x,y) = x + y<br />
x, y = 1, 2<br />
@printf("%d + %d = %d\n", x, y, x+y)<br />
<br />
Saída:<br />
1 + 2 = 3<br />
</pre><br />
<br />
<pre><br />
# Função de múltiplas expressões<br />
function adoptACat(cats)<br />
if cats <= 1<br />
println("You should adopt a cat.")<br />
else<br />
println("You should adopt a cat. They're cute.")<br />
end<br />
end<br />
adoptACat(2)<br />
<br />
Saída:<br />
You should adopt a cat. They're cute.<br />
</pre><br />
<br />
<pre><br />
v1 = 5<br />
function changeV1(v1)<br />
v1 = 10<br />
end<br />
changeV1(v1)<br />
println(v1)<br />
<br />
Saída:<br />
5<br />
</pre><br />
<br />
<pre><br />
v1 = 5<br />
function changeV1(v1)<br />
v1 = 10<br />
return v1<br />
end<br />
changeV1(v1)<br />
println(v1)<br />
v2 = changeV1(v1)<br />
println(v2)<br />
<br />
Saída:<br />
5<br />
10<br />
</pre><br />
<br />
<pre><br />
# Usando variáveis globais dentro da função<br />
v1 = 5<br />
function changeV12()<br />
global v1 = 10<br />
end<br />
changeV12()<br />
println(v1)<br />
<br />
Saída:<br />
10<br />
</pre><br />
<br />
<pre><br />
# Quando não sei quantos argumentos vou passar<br />
function soma(args...)<br />
sum = 0<br />
for i in args<br />
sum += i<br />
end<br />
println(sum)<br />
end<br />
soma(1,2,3)<br />
<br />
Saída:<br />
6<br />
</pre><br />
<br />
<pre><br />
# Retornando mais de um valor<br />
function retorna2(valor)<br />
return (valor + 1, valor + 2)<br />
end<br />
println(retorna2(4))<br />
<br />
Saída:<br />
(5, 6)<br />
</pre><br />
<br />
<pre><br />
# Map é uma função anônima que aplica uma função para cada elemento<br />
v = map(x -> x * x, [1,2,3])<br />
println(v)<br />
<br />
Saída:<br />
[1, 4, 9]<br />
<br />
'''Structs'''<br />
<pre><br />
struct Estudante<br />
name::String<br />
saldoTRI::Float32<br />
cartaoUFRGS::Int<br />
end<br />
# Criando um objeto<br />
estudante1 = Estudante("Raquel", 10.50, 244449)<br />
println(estudante1.name, "\n", estudante1.saldoTRI, "\n", estudante1.cartaoUFRGS)<br />
<br />
Saída:<br />
Raquel<br />
10.5<br />
244449<br />
9<br />
</pre><br />
<br />
'''Tipos Abstratos'''<br />
<br />
Tipos abstratos não podem ser instanciados como as Structs (instanciar => fazer estudante1 =<br />
Estudante(“Raquel”, 10.50, 244449) => criar um objeto) MAS podem ter subTipos e isso é muito<br />
útil!<br />
<br />
<pre><br />
abstract type animal end<br />
struct cachorro <: animal<br />
nome::String<br />
latido::String<br />
end<br />
struct gato <: animal<br />
nome::String<br />
miado::String<br />
end<br />
cachorro1 = cachorro("Urso", "Au Au")<br />
gato1 = gato("Lucia Irene", "Miau")<br />
# Criando funções pros subTipos<br />
function fazerSom(animal::cachorro)<br />
println("$(animal.nome) diz $(animal.latido)")<br />
end<br />
function fazerSom(animal::gato)<br />
println("$(animal.nome) diz $(animal.miado)")<br />
end<br />
fazerSom(cachorro1)<br />
fazerSom(gato1)<br />
<br />
Saída: <br />
Urso diz Au Au<br />
Lucia Irene diz Miau<br />
</pre></div>Raquelmhttp://fiscomp.if.ufrgs.br/index.php?title=Julia&diff=2478Julia2020-01-07T00:16:17Z<p>Raquelm: /* Aprendendo Julia */</p>
<hr />
<div>Julia é uma linguagem relativamente nova de programação que começou a ser desenvolvida em 2009 por Jeff Bezanson, Stefan Karpinski, Viral B. Shah, e Alan Edelman, um grupo do MIT. Ela foi oficialmente lançada para o mundo em 2012.<br />
<br />
Em uma entrevista, quando perguntaram a Alan o por quê do nome Julia, ele disse que numa conversa anos atrás alguém sugeriu que Julia seria um bom nome para uma linguagem de programação.<br />
<br />
Julia pode ser usada para propósitos gerais de programação, assim como Python, mas em sua criação foi visada a utilização de Julia para Cálculo Numérico.<br />
<br />
== Aspectos Gerais ==<br />
<br />
Julia é uma linguagem de alto nível, isso significa, de maneira sucinta, que ela não é executada utilizando somente o processador, assim como acontece com linguagens de baixo nível, como Assembly, por exemplo.<br />
<br />
É escrita em C, C++, e Scheme, usando a estrutura do compilador LLVM (para melhor entendimento, o compilador de C é o GCC, por exemplo), enquanto a maior parte da biblioteca padrão de Julia é implementada na própria Julia.<br />
<br />
Um fato importante sobre Julia para os programadores de Python é que todas as bibliotecas de Python são usáveis através de um comando simples: PyCall.<br />
<br />
Um fato importante sobre Julia para os programadores de C é que Julia possui APIs (Interfaces de Programação de Aplicativos) especiais para chamada de funções em C diretamente.<br />
<br />
== Velocidade ==<br />
<br />
De acordo com testes feitos pelos próprios criadores de Julia, sua velocidade é similar com a de C.<br />
<br />
<br />
<center>[[Arquivo:juliasvelocity.png|border]]<br />
Fonte: [https://julialang.org/benchmarks/]<br />
</center><br />
<br />
<br />
== Testes de Velocidade ==<br />
<br />
A fim de pessoalmente testar a velocidade da linguagem de programação, foi escrito um programa em Julia de maneira similar ao programa de Python para o FTCS aplicado na Equação de Difusão (também conhecida como Equação do Calor). <br />
<br />
A Equação da Difusão em uma dimensão pode ser escrita da forma:<br />
<br />
<center><math>\frac{df}{dt}=\frac{d^{2}f}{dx^{2}}</math></center><br />
<br />
No método de FTCS (Forward-Time Central-Space) definimos a derivada em t na forma não simetrizada (forward) e as derivadas em x na forma simetrizada:<br />
<br />
<br />
<center><math>\frac{df}{dt} = \frac{f(x, t+dt) - f(x,t)}{dt}</math></center><br />
<br />
<p><br />
<br />
<center><math>\frac{d^{2}f}{dx^{2}} = \frac{f(x+dx, t) + f(x-dx, t) - 2f(x,t)}{dx^{2}}</math></center><br />
<br />
E substuindo na equação da difusão, em notação discreta temos:<br />
<br />
<center><math>f_{j}^{n+1} = f_{j}^{n} + D\frac{dt}{(dx)^{2}}[f_{j+1}^{n} + f_{j-1}^{n} - 2 f_{j}^{n}]</math></center><br />
<br />
'''Observação:''' esse procedimento funciona bem se <math>k=D\frac{dt}{(dx)^{2}} <= 1/2</math>, segundo análise de estabilidade do método.<br />
<br />
<br />
Dessa forma, foi escrito um programa para integrar a Equação de Difusão através do método de FTCS nas linguagens Python e Julia.<br />
<br />
Para '''Python''':<br />
<pre><br />
//FTCS aplicado na equacao da difusao. Linguagem: PYTHON<br />
<br />
import copy<br />
import numpy as np<br />
import matplotlib.pyplot as plt<br />
<br />
def init():<br />
L=50;D=1.;dt=0.05;dx=1.;t=0;tmax=100.<br />
k=D*dt/(dx*dx) <br />
return L,k,dt,t,tmax<br />
<br />
L,k,dt,t,tmax = init()<br />
<br />
x = np.arange(0,L,1) <br />
f = np.zeros(x.shape)<br />
<br />
a = int(L/3)<br />
b = int(2*L/3)<br />
f[a:b]=1.<br />
f1 = copy.deepcopy(f) <br />
f2 = copy.deepcopy(f)<br />
<br />
while t<tmax:<br />
t+=dt<br />
f1[1:L-1]=f[1:L-1]+k*(f[0:L-2]+f[2:L]-2*f[1:L-1])<br />
f1[L-1]=f[L-1]+k*(f[L-2]+f[0]-2*f[L-1]) <br />
f1[0]=f[0]+k*(f[1]+f[L-1]-2*f[0]) <br />
f=copy.deepcopy(f1) <br />
<br />
sum0=sum(f1)<br />
sum1=sum(f2) <br />
<br />
print("Integral em t=0: %7.4f" % sum0)<br />
print("Integral em tmax: %7.4f" % sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
Em '''Julia''':<br />
<pre><br />
//FTCS aplicado na equacao da difusao. Linguagem: JULIA<br />
<br />
using PyPlot<br />
<br />
L=50<br />
D=1.<br />
dt=0.05<br />
dx=1.<br />
t=0<br />
tmax=100.<br />
k=D*dt/(dx*dx) <br />
<br />
x = collect(0:1:L-1)<br />
f = zeros(L)<br />
f1 = zeros(L)<br />
<br />
a = trunc(Int, L/3) <br />
b = trunc(Int, 2*L/3)<br />
<br />
f[a+1:b] .= 1.<br />
f2 = deepcopy(f)<br />
<br />
while t<tmax<br />
global t+=dt <br />
f1[2:L-1] = f[2:L-1] + k*(f[1:L-2] + f[3:L] - 2*f[2:L-1]) <br />
f1[L] = f[L] + k*(f[L-1] + f[1] - 2*f[L])<br />
f1[1] = f[1] + k*(f[2] + f[L] - 2*f[1]) <br />
global f = deepcopy(f1) <br />
end<br />
<br />
sum0 = sum(f1)<br />
sum1 = sum(f2)<br />
<br />
println("Integral em t=0: ", sum0)<br />
println("Integral em tmax: ", sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
<br />
Foi testado o tempo de execução da parte principal dos dois programas (isto é, sem fazer o gráfico dos resultados), através do timer do terminal, como mostra na próxima figura:<br />
<br />
<center>[[Arquivo:Ftcs_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o método de FTCS aplicado à Equação de Difusão<br />
</center><br />
<br />
É possível perceber, através da figura acima, que o tempo de execução de Python para o FTCS aplicado à Equação de Difusão é menor do que o de Julia. Em razão disso, foi testado um programa simples, como mostra abaixo, que incrementa uma variável 10 vezes, sendo o seu valor inicial 0.<br />
<br />
<br />
<center>[[Arquivo:For.png|border]]<br />
'''Legenda:''' Programa para incrementar o valor de uma variável, nesse caso ''i'', 10 vezes, escrito em Julia e em Python<br />
</center><br />
<br />
E posteriormente, novamente, foi testado o tempo de execução da parte principal dos programas através do terminal:<br />
<br />
<center>[[Arquivo:For_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o programa que incrementa o valor da variável 10 vezes<br />
</center><br />
<br />
É possível perceber que para esse simples programa de incrementação, Python ainda obtém melhor performance do que Julia.<br />
<br />
<br />
== Performance de Julia ==<br />
<br />
Tentando entender o que traria tal performance em Cálculo Numérico para Julia, foi chegado à conclusão de que ser uma linguagem que se utilizada de ''variáveis dinâmicas'' e ''multi-métodos'' seria uma das grandes contribuições da linguagem.<br />
<br />
'''Variáveis dinâmicas:'''<br />
<br />
Em Python elas são interpretadas em runtime, ou seja, '''tempo de execução''' => o programa checa toda hora se a variável mudou e isso torna ele mais lento<br />
<br />
'''Variáveis estáticas:'''<br />
<br />
Em C as variáveis são fixas, e isso é visto é em '''tempo de compilação''' => precisa pensar nas variáveis e isso torna o tempo de programação mais lento<br />
<br />
Em Julia isso é basicamente opcional, não é preciso definir as variáveis, mas é possível, e elas podem mudar dinamicamente, em tempo de execução. E ainda, Julia se utiliza de multi-métodos para não ter que lidar com a constante checagem dos tipos das variáveis, como Python faz!<br />
<br />
'''Métodos Únicos'''<br />
<br />
Python => single dispatch => Métodos Únicos<br />
- Não tenho sobrecarga de funções, eu simplesmente chamo uma função que já está escrita<br />
<br />
'''Multi-métodos'''<br />
<br />
Sobrecarga de funções (C++) => Multi-métodos (multiple dispatch)<br />
- Tenho uma função e dependendo dos parâmetros que eu coloco ao chamá-la, eu chamo uma função ou outra<br />
<br />
'''Exemplo de sobrecarga de funções em Julia:'''<br />
<br />
<pre> <br />
//dependendo do tipo da minha variavel x na chamada da funcao, sera chamado uma funcao ou outra, mesmo que tenham o mesmo nome<br />
<br />
function printx(x::Float64)<br />
println(x)<br />
end<br />
<br />
function printx(x::String)<br />
println(x)<br />
end<br />
<br />
x="Oi"<br />
<br />
printx(x)<br />
</pre><br />
<br />
<br />
<br />
== Performance de Julia: na prática ==<br />
Para resumir, temos: <br />
<br />
Python => dynamic (variáveis dinâmicas) single<br />
dispatch<br />
<br />
C++ => static (variáveis estáticas) multiple dispatch<br />
<br />
Julia => dynamic multiple dispatch (''o melhor dos dois mundos!'')<br />
<br />
Na prática, é mostrado abaixo um exemplo da performance de Julia como linguagem de programação em dynamic multiple dispatch. <br />
<br />
O mesmo programa foi escrito em Julia e em C++. <br />
<br />
Em '''Julia''':<br />
<br />
<pre><br />
abstract type Animal end<br />
<br />
struct Cachorro <: Animal<br />
nome::String<br />
end<br />
<br />
struct Gato <: Animal<br />
nome::String<br />
end<br />
<br />
# Função de encontro que recebe tipo genérico de animal<br />
function encontroDeAnimais(a::Animal, b::Animal)<br />
acao = encontro(a,b)<br />
println("$(a.nome) encontra $(b.nome) e $acao")<br />
end<br />
<br />
# Funções de expressão única que recebem diferentes tipos de animais<br />
encontro(a::Cachorro, b::Cachorro) = "cheira" <br />
encontro(a::Cachorro, b::Gato) = "persegue"<br />
encontro(a::Gato, b::Gato) = "lambe"<br />
encontro(a::Gato, b::Cachorro) = "ignora" <br />
<br />
# Instanciando os bichinhos<br />
gato1 = Gato("Luciene Maria")<br />
gato2 = Gato("Mel")<br />
cachorro1 = Cachorro("Batata")<br />
cachorro2 = Cachorro("Snoopy")<br />
<br />
# Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2)<br />
encontroDeAnimais(gato1, cachorro2)<br />
encontroDeAnimais(cachorro1, cachorro2)<br />
</pre><br />
<br />
<br />
Em '''C++''':<br />
<br />
<pre><br />
#include <iostream><br />
using namespace std;<br />
<br />
class Animal { <br />
public:<br />
string nome;<br />
};<br />
<br />
string encontro(Animal a, Animal b) {}<br />
<br />
// Função de encontro que recebe tipo genérico de animal<br />
void encontroDeAnimais(Animal a, Animal b) {<br />
string acao = encontro(a,b);<br />
cout << a.nome << " encontra " << b.nome << " e " << acao << endl;<br />
}<br />
<br />
class Cachorro:public Animal {};<br />
class Gato:public Animal {};<br />
<br />
// Funções de expressão única que recebem diferentes tipos de animais<br />
string encontro(Cachorro a, Cachorro b) { return "cheira"; }<br />
string encontro(Cachorro a, Gato b) { return "persegue"; }<br />
string encontro(Gato a, Gato b) { return "lambe"; }<br />
string encontro(Gato a, Cachorro b) { return "ignora"; }<br />
<br />
int main() {<br />
// Instanciando os bichinhos<br />
Gato gato1; gato1.nome = "Luciene Maria";<br />
Gato gato2; gato2.nome = "Mel";<br />
Cachorro cachorro1; cachorro1.nome = "Batata";<br />
Cachorro cachorro2; cachorro2.nome = "Snoopy";<br />
<br />
// Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2);<br />
encontroDeAnimais(gato1, cachorro2);<br />
encontroDeAnimais(cachorro1, cachorro2);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Para '''Julia''' nós obtemos o seguinte '''resultado''':<br />
<br />
<pre><br />
Luciene Maria encontra Mel e lambe<br />
Luciene Maria encontra Snoopy e ignora<br />
Batata encontra Snoopy e cheira<br />
</pre><br />
<br />
Para '''C++''' o '''resultado''' é:<br />
<br />
<pre><br />
Luciene Maria encontra Mel e<br />
Falha de Segmentação<br />
</pre><br />
<br />
Isso acontece porque C++ não aceita que uma função utilize-se de uma variável sem antes saber qual o tipo dessa variável! Por isso, poder utilizar-se de variáveis dinâmicas quando há multi-métodos é um diferencial que acaba por incrementar a performance de Julia como linguagem de programação visada para o Cálculo Numérico.<br />
<br />
'''Observação:''' é importante ressaltar que os testes feitos não são conclusivos para debater a performance de Julia, em termos estatísticos, e além disso, ser uma linguagem de programação que utiliza de variáveis dinâmicas e multi-métodos não é o único motivo pelo qual Julia poderia trazer tal performance em Cálculo Numérico. Podemos ainda contar com a sua capacidade de '''metaprogramação''', ou seja, Julia pode usar macros e eles são aplicados em tempo de interpretação. Há ainda outros fatores da construção da linguagem que contribuem para sua performance que aqui não foram citados.<br />
<br />
<br />
== Aprendendo Julia ==<br />
<br />
Após feita a instalação de Julia, para abri-la no terminal de comando é preciso apenas digitar <pre>$Julia</pre> para entrar no seu ambiente de programação.<br />
<br />
É possível, também, programar em um arquivo de texto e executar o programa pelo terminal, fazendo simplesmente:<br />
<br />
<pre><br />
$julia programa.jl <br />
</pre><br />
<br />
'''Impressão na tela'''<br />
<pre><br />
println("Hello World")<br />
<br />
Saída:<br />
Hello World<br />
</pre><br />
<br />
'''Variáveis'''<br />
<br />
Variáveis são atribuídas dinamicamente e podem mudar.<br />
<pre><br />
s = 1<br />
s = "Oi"<br />
println(s)<br />
println(typeof(s))<br />
<br />
Saída:<br />
Oi<br />
String<br />
</pre><br />
<br />
<pre><br />
s::String<br />
s = 1<br />
println(s)<br />
<br />
Saída:<br />
TypeError: in typeassert, expected String, got Int32<br />
</pre><br />
<br />
'''Condicionais'''<br />
<pre><br />
cats = 12<br />
if cats < 1<br />
println("You should adopt a cat.")<br />
elseif cats >= 1 && cats <=6<br />
println("Not enough cats.")<br />
elseif cats >= 7 && cats <= 12<br />
println("Still not enough cats.")<br />
else<br />
println("Gato have more cats.")<br />
end<br />
<br />
Saída:<br />
Still not enough cats.<br />
</pre><br />
<br />
<pre><br />
i = 0<br />
while (i < 10)<br />
global i += 1<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
</pre><br />
<br />
<pre><br />
for i = 1:10<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
</pre><br />
<br />
<pre><br />
for i in [1,2,3]<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
3<br />
</pre><br />
<br />
'''Arrays'''<br />
<pre><br />
# Criando um array de zeros<br />
a1 = zeros()<br />
println(a1)<br />
# Posso definir o tipo e o tamanho do Array (linhas, colunas) também<br />
a1 = zeros(Int32, 1, 4)<br />
println(a1)<br />
<br />
Saída:<br />
0.0<br />
[0 0 0 0]<br />
</pre><br />
<br />
<pre><br />
# Criando um array do tipo inteiro<br />
a2 = Array{Int32}<br />
println(a2)<br />
# Criando um array (de outra maneira) do tipo float<br />
a3 = Float64[]<br />
println(a3)<br />
<br />
Saída:<br />
Array{Int32,N} where N<br />
Float64[]<br />
</pre><br />
<br />
<pre><br />
# Criando um array e definindo valores<br />
a4 = [1,2,3]<br />
#Imprimindo a4<br />
println("Array: ", a4)<br />
<br />
Saída:<br />
Array: [1, 2, 3]<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Imprimindo valor de um indíce específico<br />
println("Imprimindo primeiro elemento: ", a4[1])<br />
# Imprimindo último valor do array<br />
println("Imprimindo último elemento: ",a4[end])<br />
<br />
Saída:<br />
Imprimindo primeiro elemento: 1<br />
Imprimindo último elemento: 3<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
println(a4[2])<br />
# Valores podem mudar (diferente de Tuplas, que veremos adiante)<br />
a4[2] = 4<br />
println(a4[2])<br />
<br />
Saída:<br />
2<br />
4<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
println(a4)<br />
# Número de elementos<br />
println("Imprimindo número de elementos: ",length(a4))<br />
<br />
Saída:<br />
[1, 2, 3]<br />
Imprimindo número de elementos: 3<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Soma os valores do array<br />
println("Imprimindo soma dos elementos: ",sum(a4))<br />
# Põe os valores começando no índice 2<br />
splice!(a4, 2:1, [8,9])<br />
println("Imprimindo Array tendo feito splice!(a4, 2:1, [8,9]): ",a4)<br />
# Remove os itens do índice 2 ao 3<br />
4splice!(a4, 2:3)<br />
println("Imprimindo Array tendo feito splice!(a4, 2:3): ",a4)<br />
<br />
Saída:<br />
Imprimindo soma dos elementos: 6<br />
Imprimindo Array tendo feito splice!(a4, 2:1, [8,9]): [1, 8, 9, 2, 3]<br />
Imprimindo Array tendo feito splice!(a4, 2:3): [1, 2, 3]<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Pegar valor máximo e valor mínimo<br />
println("Imprimindo valor máximo: ",maximum(a4))<br />
println("Imprimindo Array valor mínimo: ",minimum(a4))<br />
# Multiplicando todos os elementos do array por outro número sem precisar de um␣<br />
println("Imprimindo multiplicação dos elementos por 2: ",a4 * 2)<br />
<br />
Saída:<br />
Imprimindo valor máximo: 3<br />
Imprimindo Array valor mínimo: 1<br />
Imprimindo multiplicação dos elementos por 2: [2, 4, 6]<br />
</pre><br />
<br />
<pre><br />
# Arrays podem conter funções<br />
a5 = [sin, cos, tan]<br />
for n in a5<br />
println(n(0))<br />
end<br />
<br />
Saída:<br />
0.0<br />
1.0<br />
0.0<br />
</pre><br />
<br />
<pre><br />
# Para os acostumados com range<br />
a6 = collect(1:5)<br />
println(a6)<br />
<br />
Saída:<br />
[1, 2, 3, 4, 5]<br />
4<br />
</pre><br />
<br />
'''Tuplas'''<br />
<br />
A maioria das funções de array funciona com tuplas.<br />
<pre><br />
# Valores não podem mudar<br />
t1 = (1,2,3,4)<br />
println(t1[2])<br />
t1[2] = 5<br />
println(t1[2])<br />
<br />
Saída:<br />
2<br />
MethodError: no method matching setindex!(::NTuple{4,Int32}, ::Int32, ::Int32)<br />
</pre><br />
<br />
<pre><br />
# Imprimindo a tupla inteira<br />
println(t1)<br />
# Imprimindo a tupla inteira<br />
for i in t1<br />
println(i)<br />
end<br />
<br />
Saída:<br />
(1, 2, 3, 4)<br />
1<br />
2<br />
3<br />
4<br />
</pre><br />
<br />
'''Dicionários'''<br />
<br />
A palavra-chave deve ser única.<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Imprimir um valor<br />
println(d1["pi"])<br />
<br />
Saída:<br />
3.14<br />
</pre><br />
<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Imprimindo todas as palavras-chaves<br />
println(keys(d1))<br />
# Imprimindo todos os valores<br />
println(values(d1))<br />
# Adicionar uma palavra-chave<br />
d1["golden"] = 1.618<br />
# Deleter uma palavra-chave<br />
delete!(d1, "pi")<br />
# Imprimindo todas as palavras-chaves<br />
println(keys(d1))<br />
# Imprimindo todos os valores<br />
println(values(d1))<br />
<br />
Saída:<br />
["pi", "e"]<br />
[3.14, 2.718]<br />
["e", "golden"]<br />
[2.718, 1.618]<br />
</pre><br />
<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Ver se a palavra-chave existe<br />
println(haskey(d1, "pi"))<br />
# Imprimindo palavras-chaves E valores<br />
for kv in d1<br />
println(kv)<br />
end<br />
<br />
Saída:<br />
true<br />
"pi" => 3.14<br />
"e" => 2.718<br />
6<br />
</pre><br />
<br />
'''Sets'''<br />
<br />
Sets são arrays com elementos únicos.<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
# Ele não pega os elementos repetidos<br />
println(st1)<br />
<br />
Saída:<br />
Set(["Pam", "Jim"])<br />
</pre><br />
<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
# Adicionando um elemento<br />
push!(st1, "Michael")<br />
println(st1)<br />
# Ver se um elemento está no Set<br />
println(in("Dwight", st1))<br />
<br />
Saída:<br />
Set(["Pam", "Michael", "Jim"])<br />
false<br />
</pre><br />
<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
st2 = Set(["Stanley", "Meredith"])<br />
# Combinando Sets<br />
println(union(st1, st2))<br />
# Imprimindo todo o elemento que os dois Sets tem em comum<br />
println(intersect(st1, st2))<br />
# Imprimindo elementos que estão no primeiro Set, mas não no segundo<br />
println(setdiff(st1, st2))<br />
<br />
Saída:<br />
Set(["Jim", "Meredith", "Stanley", "Pam"])<br />
Set(String[])<br />
Set(["Pam", "Jim"])<br />
</pre><br />
<br />
'''Funções'''<br />
<pre><br />
using Printf<br />
# Função de expressão única<br />
soma(x,y) = x + y<br />
x, y = 1, 2<br />
@printf("%d + %d = %d\n", x, y, x+y)<br />
<br />
Saída:<br />
1 + 2 = 3<br />
</pre><br />
<br />
<pre><br />
# Função de múltiplas expressões<br />
function adoptACat(cats)<br />
if cats <= 1<br />
println("You should adopt a cat.")<br />
else<br />
println("You should adopt a cat. They're cute.")<br />
end<br />
end<br />
adoptACat(2)<br />
You should adopt a cat. They're cute.<br />
</pre><br />
<br />
<pre><br />
v1 = 5<br />
function changeV1(v1)<br />
v1 = 10<br />
end<br />
changeV1(v1)<br />
println(v1)<br />
<br />
Saída:<br />
5<br />
</pre><br />
<br />
<pre><br />
v1 = 5<br />
function changeV1(v1)<br />
v1 = 10<br />
return v1<br />
end<br />
changeV1(v1)<br />
println(v1)<br />
v2 = changeV1(v1)<br />
println(v2)<br />
<br />
Saída:<br />
5<br />
10<br />
</pre><br />
<br />
<pre><br />
# Usando variáveis globais dentro da função<br />
v1 = 5<br />
function changeV12()<br />
global v1 = 10<br />
end<br />
changeV12()<br />
println(v1)<br />
<br />
Saída:<br />
10<br />
</pre><br />
<br />
<pre><br />
# Quando não sei quantos argumentos vou passar<br />
function soma(args...)<br />
sum = 0<br />
9for i in args<br />
sum += i<br />
end<br />
println(sum)<br />
end<br />
soma(1,2,3)<br />
<br />
Saída:<br />
6<br />
</pre><br />
<br />
<pre><br />
# Retornando mais de um valor<br />
function retorna2(valor)<br />
return (valor + 1, valor + 2)<br />
end<br />
println(retorna2(4))<br />
<br />
Saída:<br />
(5, 6)<br />
</pre><br />
<br />
<pre><br />
# Map é uma função anônima que aplica uma função para cada elemento<br />
v = map(x -> x * x, [1,2,3])<br />
println(v)<br />
<br />
Saída:<br />
[1, 4, 9]<br />
<br />
'''Structs'''<br />
<pre><br />
struct Estudante<br />
name::String<br />
saldoTRI::Float32<br />
cartaoUFRGS::Int<br />
end<br />
# Criando um objeto<br />
estudante1 = Estudante("Raquel", 10.50, 244449)<br />
println(estudante1.name, "\n", estudante1.saldoTRI, "\n", estudante1.cartaoUFRGS)<br />
<br />
Saída:<br />
Raquel<br />
10.5<br />
244449<br />
9<br />
</pre><br />
<br />
'''Tipos Abstratos'''<br />
<br />
Tipos abstratos não podem ser instanciados como as Structs (instanciar => fazer estudante1 =<br />
Estudante(“Raquel”, 10.50, 244449) => criar um objeto) MAS podem ter subTipos e isso é muito<br />
útil!<br />
<br />
<pre><br />
abstract type animal end<br />
struct cachorro <: animal<br />
nome::String<br />
latido::String<br />
end<br />
struct gato <: animal<br />
nome::String<br />
miado::String<br />
end<br />
cachorro1 = cachorro("Urso", "Au Au")<br />
gato1 = gato("Lucia Irene", "Miau")<br />
# Criando funções pros subTipos<br />
function fazerSom(animal::cachorro)<br />
println("$(animal.nome) diz $(animal.latido)")<br />
end<br />
function fazerSom(animal::gato)<br />
println("$(animal.nome) diz $(animal.miado)")<br />
end<br />
fazerSom(cachorro1)<br />
fazerSom(gato1)<br />
<br />
Saída: <br />
Urso diz Au Au<br />
Lucia Irene diz Miau<br />
</pre></div>Raquelmhttp://fiscomp.if.ufrgs.br/index.php?title=Julia&diff=2477Julia2020-01-07T00:15:26Z<p>Raquelm: /* Aprendendo Julia */</p>
<hr />
<div>Julia é uma linguagem relativamente nova de programação que começou a ser desenvolvida em 2009 por Jeff Bezanson, Stefan Karpinski, Viral B. Shah, e Alan Edelman, um grupo do MIT. Ela foi oficialmente lançada para o mundo em 2012.<br />
<br />
Em uma entrevista, quando perguntaram a Alan o por quê do nome Julia, ele disse que numa conversa anos atrás alguém sugeriu que Julia seria um bom nome para uma linguagem de programação.<br />
<br />
Julia pode ser usada para propósitos gerais de programação, assim como Python, mas em sua criação foi visada a utilização de Julia para Cálculo Numérico.<br />
<br />
== Aspectos Gerais ==<br />
<br />
Julia é uma linguagem de alto nível, isso significa, de maneira sucinta, que ela não é executada utilizando somente o processador, assim como acontece com linguagens de baixo nível, como Assembly, por exemplo.<br />
<br />
É escrita em C, C++, e Scheme, usando a estrutura do compilador LLVM (para melhor entendimento, o compilador de C é o GCC, por exemplo), enquanto a maior parte da biblioteca padrão de Julia é implementada na própria Julia.<br />
<br />
Um fato importante sobre Julia para os programadores de Python é que todas as bibliotecas de Python são usáveis através de um comando simples: PyCall.<br />
<br />
Um fato importante sobre Julia para os programadores de C é que Julia possui APIs (Interfaces de Programação de Aplicativos) especiais para chamada de funções em C diretamente.<br />
<br />
== Velocidade ==<br />
<br />
De acordo com testes feitos pelos próprios criadores de Julia, sua velocidade é similar com a de C.<br />
<br />
<br />
<center>[[Arquivo:juliasvelocity.png|border]]<br />
Fonte: [https://julialang.org/benchmarks/]<br />
</center><br />
<br />
<br />
== Testes de Velocidade ==<br />
<br />
A fim de pessoalmente testar a velocidade da linguagem de programação, foi escrito um programa em Julia de maneira similar ao programa de Python para o FTCS aplicado na Equação de Difusão (também conhecida como Equação do Calor). <br />
<br />
A Equação da Difusão em uma dimensão pode ser escrita da forma:<br />
<br />
<center><math>\frac{df}{dt}=\frac{d^{2}f}{dx^{2}}</math></center><br />
<br />
No método de FTCS (Forward-Time Central-Space) definimos a derivada em t na forma não simetrizada (forward) e as derivadas em x na forma simetrizada:<br />
<br />
<br />
<center><math>\frac{df}{dt} = \frac{f(x, t+dt) - f(x,t)}{dt}</math></center><br />
<br />
<p><br />
<br />
<center><math>\frac{d^{2}f}{dx^{2}} = \frac{f(x+dx, t) + f(x-dx, t) - 2f(x,t)}{dx^{2}}</math></center><br />
<br />
E substuindo na equação da difusão, em notação discreta temos:<br />
<br />
<center><math>f_{j}^{n+1} = f_{j}^{n} + D\frac{dt}{(dx)^{2}}[f_{j+1}^{n} + f_{j-1}^{n} - 2 f_{j}^{n}]</math></center><br />
<br />
'''Observação:''' esse procedimento funciona bem se <math>k=D\frac{dt}{(dx)^{2}} <= 1/2</math>, segundo análise de estabilidade do método.<br />
<br />
<br />
Dessa forma, foi escrito um programa para integrar a Equação de Difusão através do método de FTCS nas linguagens Python e Julia.<br />
<br />
Para '''Python''':<br />
<pre><br />
//FTCS aplicado na equacao da difusao. Linguagem: PYTHON<br />
<br />
import copy<br />
import numpy as np<br />
import matplotlib.pyplot as plt<br />
<br />
def init():<br />
L=50;D=1.;dt=0.05;dx=1.;t=0;tmax=100.<br />
k=D*dt/(dx*dx) <br />
return L,k,dt,t,tmax<br />
<br />
L,k,dt,t,tmax = init()<br />
<br />
x = np.arange(0,L,1) <br />
f = np.zeros(x.shape)<br />
<br />
a = int(L/3)<br />
b = int(2*L/3)<br />
f[a:b]=1.<br />
f1 = copy.deepcopy(f) <br />
f2 = copy.deepcopy(f)<br />
<br />
while t<tmax:<br />
t+=dt<br />
f1[1:L-1]=f[1:L-1]+k*(f[0:L-2]+f[2:L]-2*f[1:L-1])<br />
f1[L-1]=f[L-1]+k*(f[L-2]+f[0]-2*f[L-1]) <br />
f1[0]=f[0]+k*(f[1]+f[L-1]-2*f[0]) <br />
f=copy.deepcopy(f1) <br />
<br />
sum0=sum(f1)<br />
sum1=sum(f2) <br />
<br />
print("Integral em t=0: %7.4f" % sum0)<br />
print("Integral em tmax: %7.4f" % sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
Em '''Julia''':<br />
<pre><br />
//FTCS aplicado na equacao da difusao. Linguagem: JULIA<br />
<br />
using PyPlot<br />
<br />
L=50<br />
D=1.<br />
dt=0.05<br />
dx=1.<br />
t=0<br />
tmax=100.<br />
k=D*dt/(dx*dx) <br />
<br />
x = collect(0:1:L-1)<br />
f = zeros(L)<br />
f1 = zeros(L)<br />
<br />
a = trunc(Int, L/3) <br />
b = trunc(Int, 2*L/3)<br />
<br />
f[a+1:b] .= 1.<br />
f2 = deepcopy(f)<br />
<br />
while t<tmax<br />
global t+=dt <br />
f1[2:L-1] = f[2:L-1] + k*(f[1:L-2] + f[3:L] - 2*f[2:L-1]) <br />
f1[L] = f[L] + k*(f[L-1] + f[1] - 2*f[L])<br />
f1[1] = f[1] + k*(f[2] + f[L] - 2*f[1]) <br />
global f = deepcopy(f1) <br />
end<br />
<br />
sum0 = sum(f1)<br />
sum1 = sum(f2)<br />
<br />
println("Integral em t=0: ", sum0)<br />
println("Integral em tmax: ", sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
<br />
Foi testado o tempo de execução da parte principal dos dois programas (isto é, sem fazer o gráfico dos resultados), através do timer do terminal, como mostra na próxima figura:<br />
<br />
<center>[[Arquivo:Ftcs_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o método de FTCS aplicado à Equação de Difusão<br />
</center><br />
<br />
É possível perceber, através da figura acima, que o tempo de execução de Python para o FTCS aplicado à Equação de Difusão é menor do que o de Julia. Em razão disso, foi testado um programa simples, como mostra abaixo, que incrementa uma variável 10 vezes, sendo o seu valor inicial 0.<br />
<br />
<br />
<center>[[Arquivo:For.png|border]]<br />
'''Legenda:''' Programa para incrementar o valor de uma variável, nesse caso ''i'', 10 vezes, escrito em Julia e em Python<br />
</center><br />
<br />
E posteriormente, novamente, foi testado o tempo de execução da parte principal dos programas através do terminal:<br />
<br />
<center>[[Arquivo:For_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o programa que incrementa o valor da variável 10 vezes<br />
</center><br />
<br />
É possível perceber que para esse simples programa de incrementação, Python ainda obtém melhor performance do que Julia.<br />
<br />
<br />
== Performance de Julia ==<br />
<br />
Tentando entender o que traria tal performance em Cálculo Numérico para Julia, foi chegado à conclusão de que ser uma linguagem que se utilizada de ''variáveis dinâmicas'' e ''multi-métodos'' seria uma das grandes contribuições da linguagem.<br />
<br />
'''Variáveis dinâmicas:'''<br />
<br />
Em Python elas são interpretadas em runtime, ou seja, '''tempo de execução''' => o programa checa toda hora se a variável mudou e isso torna ele mais lento<br />
<br />
'''Variáveis estáticas:'''<br />
<br />
Em C as variáveis são fixas, e isso é visto é em '''tempo de compilação''' => precisa pensar nas variáveis e isso torna o tempo de programação mais lento<br />
<br />
Em Julia isso é basicamente opcional, não é preciso definir as variáveis, mas é possível, e elas podem mudar dinamicamente, em tempo de execução. E ainda, Julia se utiliza de multi-métodos para não ter que lidar com a constante checagem dos tipos das variáveis, como Python faz!<br />
<br />
'''Métodos Únicos'''<br />
<br />
Python => single dispatch => Métodos Únicos<br />
- Não tenho sobrecarga de funções, eu simplesmente chamo uma função que já está escrita<br />
<br />
'''Multi-métodos'''<br />
<br />
Sobrecarga de funções (C++) => Multi-métodos (multiple dispatch)<br />
- Tenho uma função e dependendo dos parâmetros que eu coloco ao chamá-la, eu chamo uma função ou outra<br />
<br />
'''Exemplo de sobrecarga de funções em Julia:'''<br />
<br />
<pre> <br />
//dependendo do tipo da minha variavel x na chamada da funcao, sera chamado uma funcao ou outra, mesmo que tenham o mesmo nome<br />
<br />
function printx(x::Float64)<br />
println(x)<br />
end<br />
<br />
function printx(x::String)<br />
println(x)<br />
end<br />
<br />
x="Oi"<br />
<br />
printx(x)<br />
</pre><br />
<br />
<br />
<br />
== Performance de Julia: na prática ==<br />
Para resumir, temos: <br />
<br />
Python => dynamic (variáveis dinâmicas) single<br />
dispatch<br />
<br />
C++ => static (variáveis estáticas) multiple dispatch<br />
<br />
Julia => dynamic multiple dispatch (''o melhor dos dois mundos!'')<br />
<br />
Na prática, é mostrado abaixo um exemplo da performance de Julia como linguagem de programação em dynamic multiple dispatch. <br />
<br />
O mesmo programa foi escrito em Julia e em C++. <br />
<br />
Em '''Julia''':<br />
<br />
<pre><br />
abstract type Animal end<br />
<br />
struct Cachorro <: Animal<br />
nome::String<br />
end<br />
<br />
struct Gato <: Animal<br />
nome::String<br />
end<br />
<br />
# Função de encontro que recebe tipo genérico de animal<br />
function encontroDeAnimais(a::Animal, b::Animal)<br />
acao = encontro(a,b)<br />
println("$(a.nome) encontra $(b.nome) e $acao")<br />
end<br />
<br />
# Funções de expressão única que recebem diferentes tipos de animais<br />
encontro(a::Cachorro, b::Cachorro) = "cheira" <br />
encontro(a::Cachorro, b::Gato) = "persegue"<br />
encontro(a::Gato, b::Gato) = "lambe"<br />
encontro(a::Gato, b::Cachorro) = "ignora" <br />
<br />
# Instanciando os bichinhos<br />
gato1 = Gato("Luciene Maria")<br />
gato2 = Gato("Mel")<br />
cachorro1 = Cachorro("Batata")<br />
cachorro2 = Cachorro("Snoopy")<br />
<br />
# Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2)<br />
encontroDeAnimais(gato1, cachorro2)<br />
encontroDeAnimais(cachorro1, cachorro2)<br />
</pre><br />
<br />
<br />
Em '''C++''':<br />
<br />
<pre><br />
#include <iostream><br />
using namespace std;<br />
<br />
class Animal { <br />
public:<br />
string nome;<br />
};<br />
<br />
string encontro(Animal a, Animal b) {}<br />
<br />
// Função de encontro que recebe tipo genérico de animal<br />
void encontroDeAnimais(Animal a, Animal b) {<br />
string acao = encontro(a,b);<br />
cout << a.nome << " encontra " << b.nome << " e " << acao << endl;<br />
}<br />
<br />
class Cachorro:public Animal {};<br />
class Gato:public Animal {};<br />
<br />
// Funções de expressão única que recebem diferentes tipos de animais<br />
string encontro(Cachorro a, Cachorro b) { return "cheira"; }<br />
string encontro(Cachorro a, Gato b) { return "persegue"; }<br />
string encontro(Gato a, Gato b) { return "lambe"; }<br />
string encontro(Gato a, Cachorro b) { return "ignora"; }<br />
<br />
int main() {<br />
// Instanciando os bichinhos<br />
Gato gato1; gato1.nome = "Luciene Maria";<br />
Gato gato2; gato2.nome = "Mel";<br />
Cachorro cachorro1; cachorro1.nome = "Batata";<br />
Cachorro cachorro2; cachorro2.nome = "Snoopy";<br />
<br />
// Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2);<br />
encontroDeAnimais(gato1, cachorro2);<br />
encontroDeAnimais(cachorro1, cachorro2);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Para '''Julia''' nós obtemos o seguinte '''resultado''':<br />
<br />
<pre><br />
Luciene Maria encontra Mel e lambe<br />
Luciene Maria encontra Snoopy e ignora<br />
Batata encontra Snoopy e cheira<br />
</pre><br />
<br />
Para '''C++''' o '''resultado''' é:<br />
<br />
<pre><br />
Luciene Maria encontra Mel e<br />
Falha de Segmentação<br />
</pre><br />
<br />
Isso acontece porque C++ não aceita que uma função utilize-se de uma variável sem antes saber qual o tipo dessa variável! Por isso, poder utilizar-se de variáveis dinâmicas quando há multi-métodos é um diferencial que acaba por incrementar a performance de Julia como linguagem de programação visada para o Cálculo Numérico.<br />
<br />
'''Observação:''' é importante ressaltar que os testes feitos não são conclusivos para debater a performance de Julia, em termos estatísticos, e além disso, ser uma linguagem de programação que utiliza de variáveis dinâmicas e multi-métodos não é o único motivo pelo qual Julia poderia trazer tal performance em Cálculo Numérico. Podemos ainda contar com a sua capacidade de '''metaprogramação''', ou seja, Julia pode usar macros e eles são aplicados em tempo de interpretação. Há ainda outros fatores da construção da linguagem que contribuem para sua performance que aqui não foram citados.<br />
<br />
<br />
== Aprendendo Julia ==<br />
<br />
Após feita a instalação de Julia, para abri-la no terminal de comando é preciso apenas digitar <pre>$Julia</pre> para entrar no seu ambiente de programação.<br />
<br />
É possível, também, programar em um arquivo de texto e executar o programa pelo terminal, fazendo simplesmente:<br />
<br />
<pre><br />
$julia programa.jl <br />
</pre><br />
<br />
Print<br />
<pre><br />
println("Hello World")<br />
<br />
Saída:<br />
Hello World<br />
</pre><br />
<br />
Variáveis<br />
<br />
Variáveis são atribuídas dinamicamente e podem mudar.<br />
<pre><br />
s = 1<br />
s = "Oi"<br />
println(s)<br />
println(typeof(s))<br />
<br />
Saída:<br />
Oi<br />
String<br />
</pre><br />
<br />
<pre><br />
s::String<br />
s = 1<br />
println(s)<br />
<br />
Saída:<br />
TypeError: in typeassert, expected String, got Int32<br />
</pre><br />
<br />
'''Condicionais'''<br />
<pre><br />
cats = 12<br />
if cats < 1<br />
println("You should adopt a cat.")<br />
elseif cats >= 1 && cats <=6<br />
println("Not enough cats.")<br />
elseif cats >= 7 && cats <= 12<br />
println("Still not enough cats.")<br />
else<br />
println("Gato have more cats.")<br />
end<br />
<br />
Saída:<br />
Still not enough cats.<br />
</pre><br />
<br />
<pre><br />
i = 0<br />
while (i < 10)<br />
global i += 1<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
</pre><br />
<br />
<pre><br />
for i = 1:10<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
4<br />
5<br />
6<br />
7<br />
8<br />
9<br />
10<br />
</pre><br />
<br />
<pre><br />
for i in [1,2,3]<br />
println(i)<br />
end<br />
<br />
Saída:<br />
1<br />
2<br />
3<br />
3<br />
</pre><br />
<br />
'''Arrays'''<br />
<pre><br />
# Criando um array de zeros<br />
a1 = zeros()<br />
println(a1)<br />
# Posso definir o tipo e o tamanho do Array (linhas, colunas) também<br />
a1 = zeros(Int32, 1, 4)<br />
println(a1)<br />
<br />
Saída:<br />
0.0<br />
[0 0 0 0]<br />
</pre><br />
<br />
<pre><br />
# Criando um array do tipo inteiro<br />
a2 = Array{Int32}<br />
println(a2)<br />
# Criando um array (de outra maneira) do tipo float<br />
a3 = Float64[]<br />
println(a3)<br />
<br />
Saída:<br />
Array{Int32,N} where N<br />
Float64[]<br />
</pre><br />
<br />
<pre><br />
# Criando um array e definindo valores<br />
a4 = [1,2,3]<br />
#Imprimindo a4<br />
println("Array: ", a4)<br />
<br />
Saída:<br />
Array: [1, 2, 3]<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Imprimindo valor de um indíce específico<br />
println("Imprimindo primeiro elemento: ", a4[1])<br />
# Imprimindo último valor do array<br />
println("Imprimindo último elemento: ",a4[end])<br />
<br />
Saída:<br />
Imprimindo primeiro elemento: 1<br />
Imprimindo último elemento: 3<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
println(a4[2])<br />
# Valores podem mudar (diferente de Tuplas, que veremos adiante)<br />
a4[2] = 4<br />
println(a4[2])<br />
<br />
Saída:<br />
2<br />
4<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
println(a4)<br />
# Número de elementos<br />
println("Imprimindo número de elementos: ",length(a4))<br />
<br />
Saída:<br />
[1, 2, 3]<br />
Imprimindo número de elementos: 3<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Soma os valores do array<br />
println("Imprimindo soma dos elementos: ",sum(a4))<br />
# Põe os valores começando no índice 2<br />
splice!(a4, 2:1, [8,9])<br />
println("Imprimindo Array tendo feito splice!(a4, 2:1, [8,9]): ",a4)<br />
# Remove os itens do índice 2 ao 3<br />
4splice!(a4, 2:3)<br />
println("Imprimindo Array tendo feito splice!(a4, 2:3): ",a4)<br />
<br />
Saída:<br />
Imprimindo soma dos elementos: 6<br />
Imprimindo Array tendo feito splice!(a4, 2:1, [8,9]): [1, 8, 9, 2, 3]<br />
Imprimindo Array tendo feito splice!(a4, 2:3): [1, 2, 3]<br />
</pre><br />
<br />
<pre><br />
a4 = [1,2,3]<br />
# Pegar valor máximo e valor mínimo<br />
println("Imprimindo valor máximo: ",maximum(a4))<br />
println("Imprimindo Array valor mínimo: ",minimum(a4))<br />
# Multiplicando todos os elementos do array por outro número sem precisar de um␣<br />
println("Imprimindo multiplicação dos elementos por 2: ",a4 * 2)<br />
<br />
Saída:<br />
Imprimindo valor máximo: 3<br />
Imprimindo Array valor mínimo: 1<br />
Imprimindo multiplicação dos elementos por 2: [2, 4, 6]<br />
</pre><br />
<br />
<pre><br />
# Arrays podem conter funções<br />
a5 = [sin, cos, tan]<br />
for n in a5<br />
println(n(0))<br />
end<br />
<br />
Saída:<br />
0.0<br />
1.0<br />
0.0<br />
</pre><br />
<br />
<pre><br />
# Para os acostumados com range<br />
a6 = collect(1:5)<br />
println(a6)<br />
<br />
Saída:<br />
[1, 2, 3, 4, 5]<br />
4<br />
</pre><br />
<br />
'''Tuplas'''<br />
<br />
A maioria das funções de array funciona com tuplas.<br />
<pre><br />
# Valores não podem mudar<br />
t1 = (1,2,3,4)<br />
println(t1[2])<br />
t1[2] = 5<br />
println(t1[2])<br />
<br />
Saída:<br />
2<br />
MethodError: no method matching setindex!(::NTuple{4,Int32}, ::Int32, ::Int32)<br />
</pre><br />
<br />
<pre><br />
# Imprimindo a tupla inteira<br />
println(t1)<br />
# Imprimindo a tupla inteira<br />
for i in t1<br />
println(i)<br />
end<br />
<br />
Saída:<br />
(1, 2, 3, 4)<br />
1<br />
2<br />
3<br />
4<br />
</pre><br />
<br />
'''Dicionários'''<br />
<br />
A palavra-chave deve ser única.<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Imprimir um valor<br />
println(d1["pi"])<br />
<br />
Saída:<br />
3.14<br />
</pre><br />
<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Imprimindo todas as palavras-chaves<br />
println(keys(d1))<br />
# Imprimindo todos os valores<br />
println(values(d1))<br />
# Adicionar uma palavra-chave<br />
d1["golden"] = 1.618<br />
# Deleter uma palavra-chave<br />
delete!(d1, "pi")<br />
# Imprimindo todas as palavras-chaves<br />
println(keys(d1))<br />
# Imprimindo todos os valores<br />
println(values(d1))<br />
<br />
Saída:<br />
["pi", "e"]<br />
[3.14, 2.718]<br />
["e", "golden"]<br />
[2.718, 1.618]<br />
</pre><br />
<br />
<pre><br />
d1 = Dict("pi"=>3.14, "e"=>2.718)<br />
# Ver se a palavra-chave existe<br />
println(haskey(d1, "pi"))<br />
# Imprimindo palavras-chaves E valores<br />
for kv in d1<br />
println(kv)<br />
end<br />
<br />
Saída:<br />
true<br />
"pi" => 3.14<br />
"e" => 2.718<br />
6<br />
</pre><br />
<br />
'''Sets'''<br />
<br />
Sets são arrays com elementos únicos.<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
# Ele não pega os elementos repetidos<br />
println(st1)<br />
<br />
Saída:<br />
Set(["Pam", "Jim"])<br />
</pre><br />
<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
# Adicionando um elemento<br />
push!(st1, "Michael")<br />
println(st1)<br />
# Ver se um elemento está no Set<br />
println(in("Dwight", st1))<br />
<br />
Saída:<br />
Set(["Pam", "Michael", "Jim"])<br />
false<br />
</pre><br />
<br />
<pre><br />
st1 = Set(["Jim", "Pam", "Jim"])<br />
st2 = Set(["Stanley", "Meredith"])<br />
# Combinando Sets<br />
println(union(st1, st2))<br />
# Imprimindo todo o elemento que os dois Sets tem em comum<br />
println(intersect(st1, st2))<br />
# Imprimindo elementos que estão no primeiro Set, mas não no segundo<br />
println(setdiff(st1, st2))<br />
<br />
Saída:<br />
Set(["Jim", "Meredith", "Stanley", "Pam"])<br />
Set(String[])<br />
Set(["Pam", "Jim"])<br />
</pre><br />
<br />
'''Funções'''<br />
<pre><br />
using Printf<br />
# Função de expressão única<br />
soma(x,y) = x + y<br />
x, y = 1, 2<br />
@printf("%d + %d = %d\n", x, y, x+y)<br />
<br />
Saída:<br />
1 + 2 = 3<br />
</pre><br />
<br />
<pre><br />
# Função de múltiplas expressões<br />
function adoptACat(cats)<br />
if cats <= 1<br />
println("You should adopt a cat.")<br />
else<br />
println("You should adopt a cat. They're cute.")<br />
end<br />
end<br />
adoptACat(2)<br />
You should adopt a cat. They're cute.<br />
</pre><br />
<br />
<pre><br />
v1 = 5<br />
function changeV1(v1)<br />
v1 = 10<br />
end<br />
changeV1(v1)<br />
println(v1)<br />
<br />
Saída:<br />
5<br />
</pre><br />
<br />
<pre><br />
v1 = 5<br />
function changeV1(v1)<br />
v1 = 10<br />
return v1<br />
end<br />
changeV1(v1)<br />
println(v1)<br />
v2 = changeV1(v1)<br />
println(v2)<br />
<br />
Saída:<br />
5<br />
10<br />
</pre><br />
<br />
<pre><br />
# Usando variáveis globais dentro da função<br />
v1 = 5<br />
function changeV12()<br />
global v1 = 10<br />
end<br />
changeV12()<br />
println(v1)<br />
<br />
Saída:<br />
10<br />
</pre><br />
<br />
<pre><br />
# Quando não sei quantos argumentos vou passar<br />
function soma(args...)<br />
sum = 0<br />
9for i in args<br />
sum += i<br />
end<br />
println(sum)<br />
end<br />
soma(1,2,3)<br />
<br />
Saída:<br />
6<br />
</pre><br />
<br />
<pre><br />
# Retornando mais de um valor<br />
function retorna2(valor)<br />
return (valor + 1, valor + 2)<br />
end<br />
println(retorna2(4))<br />
<br />
Saída:<br />
(5, 6)<br />
</pre><br />
<br />
<pre><br />
# Map é uma função anônima que aplica uma função para cada elemento<br />
v = map(x -> x * x, [1,2,3])<br />
println(v)<br />
<br />
Saída:<br />
[1, 4, 9]<br />
<br />
'''Structs'''<br />
<pre><br />
struct Estudante<br />
name::String<br />
saldoTRI::Float32<br />
cartaoUFRGS::Int<br />
end<br />
# Criando um objeto<br />
estudante1 = Estudante("Raquel", 10.50, 244449)<br />
println(estudante1.name, "\n", estudante1.saldoTRI, "\n", estudante1.cartaoUFRGS)<br />
<br />
Saída:<br />
Raquel<br />
10.5<br />
244449<br />
9<br />
</pre><br />
<br />
'''Tipos Abstratos'''<br />
<br />
Tipos abstratos não podem ser instanciados como as Structs (instanciar => fazer estudante1 =<br />
Estudante(“Raquel”, 10.50, 244449) => criar um objeto) MAS podem ter subTipos e isso é muito<br />
útil!<br />
<br />
<pre><br />
abstract type animal end<br />
struct cachorro <: animal<br />
nome::String<br />
latido::String<br />
end<br />
struct gato <: animal<br />
nome::String<br />
miado::String<br />
end<br />
cachorro1 = cachorro("Urso", "Au Au")<br />
gato1 = gato("Lucia Irene", "Miau")<br />
# Criando funções pros subTipos<br />
function fazerSom(animal::cachorro)<br />
println("$(animal.nome) diz $(animal.latido)")<br />
end<br />
function fazerSom(animal::gato)<br />
println("$(animal.nome) diz $(animal.miado)")<br />
end<br />
fazerSom(cachorro1)<br />
fazerSom(gato1)<br />
<br />
Saída: <br />
Urso diz Au Au<br />
Lucia Irene diz Miau<br />
</pre></div>Raquelmhttp://fiscomp.if.ufrgs.br/index.php?title=Julia&diff=2476Julia2020-01-06T23:53:17Z<p>Raquelm: </p>
<hr />
<div>Julia é uma linguagem relativamente nova de programação que começou a ser desenvolvida em 2009 por Jeff Bezanson, Stefan Karpinski, Viral B. Shah, e Alan Edelman, um grupo do MIT. Ela foi oficialmente lançada para o mundo em 2012.<br />
<br />
Em uma entrevista, quando perguntaram a Alan o por quê do nome Julia, ele disse que numa conversa anos atrás alguém sugeriu que Julia seria um bom nome para uma linguagem de programação.<br />
<br />
Julia pode ser usada para propósitos gerais de programação, assim como Python, mas em sua criação foi visada a utilização de Julia para Cálculo Numérico.<br />
<br />
== Aspectos Gerais ==<br />
<br />
Julia é uma linguagem de alto nível, isso significa, de maneira sucinta, que ela não é executada utilizando somente o processador, assim como acontece com linguagens de baixo nível, como Assembly, por exemplo.<br />
<br />
É escrita em C, C++, e Scheme, usando a estrutura do compilador LLVM (para melhor entendimento, o compilador de C é o GCC, por exemplo), enquanto a maior parte da biblioteca padrão de Julia é implementada na própria Julia.<br />
<br />
Um fato importante sobre Julia para os programadores de Python é que todas as bibliotecas de Python são usáveis através de um comando simples: PyCall.<br />
<br />
Um fato importante sobre Julia para os programadores de C é que Julia possui APIs (Interfaces de Programação de Aplicativos) especiais para chamada de funções em C diretamente.<br />
<br />
== Velocidade ==<br />
<br />
De acordo com testes feitos pelos próprios criadores de Julia, sua velocidade é similar com a de C.<br />
<br />
<br />
<center>[[Arquivo:juliasvelocity.png|border]]<br />
Fonte: [https://julialang.org/benchmarks/]<br />
</center><br />
<br />
<br />
== Testes de Velocidade ==<br />
<br />
A fim de pessoalmente testar a velocidade da linguagem de programação, foi escrito um programa em Julia de maneira similar ao programa de Python para o FTCS aplicado na Equação de Difusão (também conhecida como Equação do Calor). <br />
<br />
A Equação da Difusão em uma dimensão pode ser escrita da forma:<br />
<br />
<center><math>\frac{df}{dt}=\frac{d^{2}f}{dx^{2}}</math></center><br />
<br />
No método de FTCS (Forward-Time Central-Space) definimos a derivada em t na forma não simetrizada (forward) e as derivadas em x na forma simetrizada:<br />
<br />
<br />
<center><math>\frac{df}{dt} = \frac{f(x, t+dt) - f(x,t)}{dt}</math></center><br />
<br />
<p><br />
<br />
<center><math>\frac{d^{2}f}{dx^{2}} = \frac{f(x+dx, t) + f(x-dx, t) - 2f(x,t)}{dx^{2}}</math></center><br />
<br />
E substuindo na equação da difusão, em notação discreta temos:<br />
<br />
<center><math>f_{j}^{n+1} = f_{j}^{n} + D\frac{dt}{(dx)^{2}}[f_{j+1}^{n} + f_{j-1}^{n} - 2 f_{j}^{n}]</math></center><br />
<br />
'''Observação:''' esse procedimento funciona bem se <math>k=D\frac{dt}{(dx)^{2}} <= 1/2</math>, segundo análise de estabilidade do método.<br />
<br />
<br />
Dessa forma, foi escrito um programa para integrar a Equação de Difusão através do método de FTCS nas linguagens Python e Julia.<br />
<br />
Para '''Python''':<br />
<pre><br />
//FTCS aplicado na equacao da difusao. Linguagem: PYTHON<br />
<br />
import copy<br />
import numpy as np<br />
import matplotlib.pyplot as plt<br />
<br />
def init():<br />
L=50;D=1.;dt=0.05;dx=1.;t=0;tmax=100.<br />
k=D*dt/(dx*dx) <br />
return L,k,dt,t,tmax<br />
<br />
L,k,dt,t,tmax = init()<br />
<br />
x = np.arange(0,L,1) <br />
f = np.zeros(x.shape)<br />
<br />
a = int(L/3)<br />
b = int(2*L/3)<br />
f[a:b]=1.<br />
f1 = copy.deepcopy(f) <br />
f2 = copy.deepcopy(f)<br />
<br />
while t<tmax:<br />
t+=dt<br />
f1[1:L-1]=f[1:L-1]+k*(f[0:L-2]+f[2:L]-2*f[1:L-1])<br />
f1[L-1]=f[L-1]+k*(f[L-2]+f[0]-2*f[L-1]) <br />
f1[0]=f[0]+k*(f[1]+f[L-1]-2*f[0]) <br />
f=copy.deepcopy(f1) <br />
<br />
sum0=sum(f1)<br />
sum1=sum(f2) <br />
<br />
print("Integral em t=0: %7.4f" % sum0)<br />
print("Integral em tmax: %7.4f" % sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
Em '''Julia''':<br />
<pre><br />
//FTCS aplicado na equacao da difusao. Linguagem: JULIA<br />
<br />
using PyPlot<br />
<br />
L=50<br />
D=1.<br />
dt=0.05<br />
dx=1.<br />
t=0<br />
tmax=100.<br />
k=D*dt/(dx*dx) <br />
<br />
x = collect(0:1:L-1)<br />
f = zeros(L)<br />
f1 = zeros(L)<br />
<br />
a = trunc(Int, L/3) <br />
b = trunc(Int, 2*L/3)<br />
<br />
f[a+1:b] .= 1.<br />
f2 = deepcopy(f)<br />
<br />
while t<tmax<br />
global t+=dt <br />
f1[2:L-1] = f[2:L-1] + k*(f[1:L-2] + f[3:L] - 2*f[2:L-1]) <br />
f1[L] = f[L] + k*(f[L-1] + f[1] - 2*f[L])<br />
f1[1] = f[1] + k*(f[2] + f[L] - 2*f[1]) <br />
global f = deepcopy(f1) <br />
end<br />
<br />
sum0 = sum(f1)<br />
sum1 = sum(f2)<br />
<br />
println("Integral em t=0: ", sum0)<br />
println("Integral em tmax: ", sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
<br />
Foi testado o tempo de execução da parte principal dos dois programas (isto é, sem fazer o gráfico dos resultados), através do timer do terminal, como mostra na próxima figura:<br />
<br />
<center>[[Arquivo:Ftcs_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o método de FTCS aplicado à Equação de Difusão<br />
</center><br />
<br />
É possível perceber, através da figura acima, que o tempo de execução de Python para o FTCS aplicado à Equação de Difusão é menor do que o de Julia. Em razão disso, foi testado um programa simples, como mostra abaixo, que incrementa uma variável 10 vezes, sendo o seu valor inicial 0.<br />
<br />
<br />
<center>[[Arquivo:For.png|border]]<br />
'''Legenda:''' Programa para incrementar o valor de uma variável, nesse caso ''i'', 10 vezes, escrito em Julia e em Python<br />
</center><br />
<br />
E posteriormente, novamente, foi testado o tempo de execução da parte principal dos programas através do terminal:<br />
<br />
<center>[[Arquivo:For_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o programa que incrementa o valor da variável 10 vezes<br />
</center><br />
<br />
É possível perceber que para esse simples programa de incrementação, Python ainda obtém melhor performance do que Julia.<br />
<br />
<br />
== Performance de Julia ==<br />
<br />
Tentando entender o que traria tal performance em Cálculo Numérico para Julia, foi chegado à conclusão de que ser uma linguagem que se utilizada de ''variáveis dinâmicas'' e ''multi-métodos'' seria uma das grandes contribuições da linguagem.<br />
<br />
'''Variáveis dinâmicas:'''<br />
<br />
Em Python elas são interpretadas em runtime, ou seja, '''tempo de execução''' => o programa checa toda hora se a variável mudou e isso torna ele mais lento<br />
<br />
'''Variáveis estáticas:'''<br />
<br />
Em C as variáveis são fixas, e isso é visto é em '''tempo de compilação''' => precisa pensar nas variáveis e isso torna o tempo de programação mais lento<br />
<br />
Em Julia isso é basicamente opcional, não é preciso definir as variáveis, mas é possível, e elas podem mudar dinamicamente, em tempo de execução. E ainda, Julia se utiliza de multi-métodos para não ter que lidar com a constante checagem dos tipos das variáveis, como Python faz!<br />
<br />
'''Métodos Únicos'''<br />
<br />
Python => single dispatch => Métodos Únicos<br />
- Não tenho sobrecarga de funções, eu simplesmente chamo uma função que já está escrita<br />
<br />
'''Multi-métodos'''<br />
<br />
Sobrecarga de funções (C++) => Multi-métodos (multiple dispatch)<br />
- Tenho uma função e dependendo dos parâmetros que eu coloco ao chamá-la, eu chamo uma função ou outra<br />
<br />
'''Exemplo de sobrecarga de funções em Julia:'''<br />
<br />
<pre> <br />
//dependendo do tipo da minha variavel x na chamada da funcao, sera chamado uma funcao ou outra, mesmo que tenham o mesmo nome<br />
<br />
function printx(x::Float64)<br />
println(x)<br />
end<br />
<br />
function printx(x::String)<br />
println(x)<br />
end<br />
<br />
x="Oi"<br />
<br />
printx(x)<br />
</pre><br />
<br />
<br />
<br />
== Performance de Julia: na prática ==<br />
Para resumir, temos: <br />
<br />
Python => dynamic (variáveis dinâmicas) single<br />
dispatch<br />
<br />
C++ => static (variáveis estáticas) multiple dispatch<br />
<br />
Julia => dynamic multiple dispatch (''o melhor dos dois mundos!'')<br />
<br />
Na prática, é mostrado abaixo um exemplo da performance de Julia como linguagem de programação em dynamic multiple dispatch. <br />
<br />
O mesmo programa foi escrito em Julia e em C++. <br />
<br />
Em '''Julia''':<br />
<br />
<pre><br />
abstract type Animal end<br />
<br />
struct Cachorro <: Animal<br />
nome::String<br />
end<br />
<br />
struct Gato <: Animal<br />
nome::String<br />
end<br />
<br />
# Função de encontro que recebe tipo genérico de animal<br />
function encontroDeAnimais(a::Animal, b::Animal)<br />
acao = encontro(a,b)<br />
println("$(a.nome) encontra $(b.nome) e $acao")<br />
end<br />
<br />
# Funções de expressão única que recebem diferentes tipos de animais<br />
encontro(a::Cachorro, b::Cachorro) = "cheira" <br />
encontro(a::Cachorro, b::Gato) = "persegue"<br />
encontro(a::Gato, b::Gato) = "lambe"<br />
encontro(a::Gato, b::Cachorro) = "ignora" <br />
<br />
# Instanciando os bichinhos<br />
gato1 = Gato("Luciene Maria")<br />
gato2 = Gato("Mel")<br />
cachorro1 = Cachorro("Batata")<br />
cachorro2 = Cachorro("Snoopy")<br />
<br />
# Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2)<br />
encontroDeAnimais(gato1, cachorro2)<br />
encontroDeAnimais(cachorro1, cachorro2)<br />
</pre><br />
<br />
<br />
Em '''C++''':<br />
<br />
<pre><br />
#include <iostream><br />
using namespace std;<br />
<br />
class Animal { <br />
public:<br />
string nome;<br />
};<br />
<br />
string encontro(Animal a, Animal b) {}<br />
<br />
// Função de encontro que recebe tipo genérico de animal<br />
void encontroDeAnimais(Animal a, Animal b) {<br />
string acao = encontro(a,b);<br />
cout << a.nome << " encontra " << b.nome << " e " << acao << endl;<br />
}<br />
<br />
class Cachorro:public Animal {};<br />
class Gato:public Animal {};<br />
<br />
// Funções de expressão única que recebem diferentes tipos de animais<br />
string encontro(Cachorro a, Cachorro b) { return "cheira"; }<br />
string encontro(Cachorro a, Gato b) { return "persegue"; }<br />
string encontro(Gato a, Gato b) { return "lambe"; }<br />
string encontro(Gato a, Cachorro b) { return "ignora"; }<br />
<br />
int main() {<br />
// Instanciando os bichinhos<br />
Gato gato1; gato1.nome = "Luciene Maria";<br />
Gato gato2; gato2.nome = "Mel";<br />
Cachorro cachorro1; cachorro1.nome = "Batata";<br />
Cachorro cachorro2; cachorro2.nome = "Snoopy";<br />
<br />
// Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2);<br />
encontroDeAnimais(gato1, cachorro2);<br />
encontroDeAnimais(cachorro1, cachorro2);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Para '''Julia''' nós obtemos o seguinte '''resultado''':<br />
<br />
<pre><br />
Luciene Maria encontra Mel e lambe<br />
Luciene Maria encontra Snoopy e ignora<br />
Batata encontra Snoopy e cheira<br />
</pre><br />
<br />
Para '''C++''' o '''resultado''' é:<br />
<br />
<pre><br />
Luciene Maria encontra Mel e<br />
Falha de Segmentação<br />
</pre><br />
<br />
Isso acontece porque C++ não aceita que uma função utilize-se de uma variável sem antes saber qual o tipo dessa variável! Por isso, poder utilizar-se de variáveis dinâmicas quando há multi-métodos é um diferencial que acaba por incrementar a performance de Julia como linguagem de programação visada para o Cálculo Numérico.<br />
<br />
'''Observação:''' é importante ressaltar que os testes feitos não são conclusivos para debater a performance de Julia, em termos estatísticos, e além disso, ser uma linguagem de programação que utiliza de variáveis dinâmicas e multi-métodos não é o único motivo pelo qual Julia poderia trazer tal performance em Cálculo Numérico. Podemos ainda contar com a sua capacidade de '''metaprogramação''', ou seja, Julia pode usar macros e eles são aplicados em tempo de interpretação. Há ainda outros fatores da construção da linguagem que contribuem para sua performance que aqui não foram citados.<br />
<br />
<br />
== Aprendendo Julia ==<br />
<br />
Após feita a instalação de Julia, para abri-la no terminal de comando é preciso apenas digitar <pre>$Julia</pre> para entrar no seu ambiente de programação.<br />
<br />
É possível, também, programar em um arquivo de texto e executar o programa pelo terminal, fazendo simplesmente:<br />
<br />
<pre><br />
$julia programa.jl <br />
</pre></div>Raquelmhttp://fiscomp.if.ufrgs.br/index.php?title=Julia&diff=2475Julia2020-01-06T23:47:31Z<p>Raquelm: </p>
<hr />
<div>Julia é uma linguagem relativamente nova de programação que começou a ser desenvolvida em 2009 por Jeff Bezanson, Stefan Karpinski, Viral B. Shah, e Alan Edelman, um grupo do MIT. Ela foi oficialmente lançada para o mundo em 2012.<br />
<br />
Em uma entrevista, quando perguntaram a Alan o por quê do nome Julia, ele disse que numa conversa anos atrás alguém sugeriu que Julia seria um bom nome para uma linguagem de programação.<br />
<br />
Julia pode ser usada para propósitos gerais de programação, assim como Python, mas em sua criação foi visada a utilização de Julia para Cálculo Numérico.<br />
<br />
== Aspectos Gerais ==<br />
<br />
Julia é uma linguagem de alto nível, isso significa, de maneira sucinta, que ela não é executada utilizando somente o processador, assim como acontece com linguagens de baixo nível, como Assembly, por exemplo.<br />
<br />
É escrita em C, C++, e Scheme, usando a estrutura do compilador LLVM (para melhor entendimento, o compilador de C é o GCC, por exemplo), enquanto a maior parte da biblioteca padrão de Julia é implementada na própria Julia.<br />
<br />
Um fato importante sobre Julia para os programadores de Python é que todas as bibliotecas de Python são usáveis através de um comando simples: PyCall.<br />
<br />
Um fato importante sobre Julia para os programadores de C é que Julia possui APIs (Interfaces de Programação de Aplicativos) especiais para chamada de funções em C diretamente.<br />
<br />
== Velocidade ==<br />
<br />
De acordo com testes feitos pelos próprios criadores de Julia, sua velocidade é similar com a de C.<br />
<br />
<br />
<center>[[Arquivo:juliasvelocity.png|border]]<br />
Fonte: [https://julialang.org/benchmarks/]<br />
</center><br />
<br />
<br />
== Testes de Velocidade ==<br />
<br />
A fim de pessoalmente testar a velocidade da linguagem de programação, foi escrito um programa em Julia de maneira similar ao programa de Python para o FTCS aplicado na Equação de Difusão (também conhecida como Equação do Calor). <br />
<br />
A Equação da Difusão em uma dimensão pode ser escrita da forma:<br />
<br />
<center><math>\frac{df}{dt}=\frac{d^{2}f}{dx^{2}}</math></center><br />
<br />
No método de FTCS (Forward-Time Central-Space) definimos a derivada em t na forma não simetrizada (forward) e as derivadas em x na forma simetrizada:<br />
<br />
<br />
<center><math>\frac{df}{dt} = \frac{f(x, t+dt) - f(x,t)}{dt}</math></center><br />
<br />
<p><br />
<br />
<center><math>\frac{d^{2}f}{dx^{2}} = \frac{f(x+dx, t) + f(x-dx, t) - 2f(x,t)}{dx^{2}}</math></center><br />
<br />
E substuindo na equação da difusão, em notação discreta temos:<br />
<br />
<center><math>f_{j}^{n+1} = f_{j}^{n} + D\frac{dt}{(dx)^{2}}[f_{j+1}^{n} + f_{j-1}^{n} - 2 f_{j}^{n}]</math></center><br />
<br />
'''Observação:''' esse procedimento funciona bem se <math>k=D\frac{dt}{(dx)^{2}} <= 1/2</math>, segundo análise de estabilidade do método.<br />
<br />
<br />
Dessa forma, foi escrito um programa para integrar a Equação de Difusão através do método de FTCS nas linguagens Python e Julia.<br />
<br />
Para '''Python''':<br />
<pre><br />
//FTCS aplicado na equacao da difusao. Linguagem: PYTHON<br />
<br />
import copy<br />
import numpy as np<br />
import matplotlib.pyplot as plt<br />
<br />
def init():<br />
L=50;D=1.;dt=0.05;dx=1.;t=0;tmax=100.<br />
k=D*dt/(dx*dx) <br />
return L,k,dt,t,tmax<br />
<br />
L,k,dt,t,tmax = init()<br />
<br />
x = np.arange(0,L,1) <br />
f = np.zeros(x.shape)<br />
<br />
a = int(L/3)<br />
b = int(2*L/3)<br />
f[a:b]=1.<br />
f1 = copy.deepcopy(f) <br />
f2 = copy.deepcopy(f)<br />
<br />
while t<tmax:<br />
t+=dt<br />
f1[1:L-1]=f[1:L-1]+k*(f[0:L-2]+f[2:L]-2*f[1:L-1])<br />
f1[L-1]=f[L-1]+k*(f[L-2]+f[0]-2*f[L-1]) <br />
f1[0]=f[0]+k*(f[1]+f[L-1]-2*f[0]) <br />
f=copy.deepcopy(f1) <br />
<br />
sum0=sum(f1)<br />
sum1=sum(f2) <br />
<br />
print("Integral em t=0: %7.4f" % sum0)<br />
print("Integral em tmax: %7.4f" % sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
Em '''Julia''':<br />
<pre><br />
//FTCS aplicado na equacao da difusao. Linguagem: JULIA<br />
<br />
using PyPlot<br />
<br />
L=50<br />
D=1.<br />
dt=0.05<br />
dx=1.<br />
t=0<br />
tmax=100.<br />
k=D*dt/(dx*dx) <br />
<br />
x = collect(0:1:L-1)<br />
f = zeros(L)<br />
f1 = zeros(L)<br />
<br />
a = trunc(Int, L/3) <br />
b = trunc(Int, 2*L/3)<br />
<br />
f[a+1:b] .= 1.<br />
f2 = deepcopy(f)<br />
<br />
while t<tmax<br />
global t+=dt <br />
f1[2:L-1] = f[2:L-1] + k*(f[1:L-2] + f[3:L] - 2*f[2:L-1]) <br />
f1[L] = f[L] + k*(f[L-1] + f[1] - 2*f[L])<br />
f1[1] = f[1] + k*(f[2] + f[L] - 2*f[1]) <br />
global f = deepcopy(f1) <br />
end<br />
<br />
sum0 = sum(f1)<br />
sum1 = sum(f2)<br />
<br />
println("Integral em t=0: ", sum0)<br />
println("Integral em tmax: ", sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
<br />
Foi testado o tempo de execução da parte principal dos dois programas (isto é, sem fazer o gráfico dos resultados), através do timer do terminal, como mostra na próxima figura:<br />
<br />
<center>[[Arquivo:Ftcs_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o método de FTCS aplicado à Equação de Difusão<br />
</center><br />
<br />
É possível perceber, através da figura acima, que o tempo de execução de Python para o FTCS aplicado à Equação de Difusão é menor do que o de Julia. Em razão disso, foi testado um programa simples, como mostra abaixo, que incrementa uma variável 10 vezes, sendo o seu valor inicial 0.<br />
<br />
<br />
<center>[[Arquivo:For.png|border]]<br />
'''Legenda:''' Programa para incrementar o valor de uma variável, nesse caso ''i'', 10 vezes, escrito em Julia e em Python<br />
</center><br />
<br />
E posteriormente, novamente, foi testado o tempo de execução da parte principal dos programas através do terminal:<br />
<br />
<center>[[Arquivo:For_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o programa que incrementa o valor da variável 10 vezes<br />
</center><br />
<br />
É possível perceber que para esse simples programa de incrementação, Python ainda obtém melhor performance do que Julia.<br />
<br />
<br />
== Performance de Julia ==<br />
<br />
Tentando entender o que traria tal performance em Cálculo Numérico para Julia, foi chegado à conclusão de que ser uma linguagem que se utilizada de ''variáveis dinâmicas'' e ''multi-métodos'' seria uma das grandes contribuições da linguagem.<br />
<br />
'''Variáveis dinâmicas:'''<br />
<br />
Em Python elas são interpretadas em runtime, ou seja, '''tempo de execução''' => o programa checa toda hora se a variável mudou e isso torna ele mais lento<br />
<br />
'''Variáveis estáticas:'''<br />
<br />
Em C as variáveis são fixas, e isso é visto é em '''tempo de compilação''' => precisa pensar nas variáveis e isso torna o tempo de programação mais lento<br />
<br />
Em Julia isso é basicamente opcional, não é preciso definir as variáveis, mas é possível, e elas podem mudar dinamicamente, em tempo de execução. E ainda, Julia se utiliza de multi-métodos para não ter que lidar com a constante checagem dos tipos das variáveis, como Python faz!<br />
<br />
'''Métodos Únicos'''<br />
<br />
Python => single dispatch => Métodos Únicos<br />
- Não tenho sobrecarga de funções, eu simplesmente chamo uma função que já está escrita<br />
<br />
'''Multi-métodos'''<br />
<br />
Sobrecarga de funções (C++) => Multi-métodos (multiple dispatch)<br />
- Tenho uma função e dependendo dos parâmetros que eu coloco ao chamá-la, eu chamo uma função ou outra<br />
<br />
'''Exemplo de sobrecarga de funções em Julia:'''<br />
<br />
<pre> <br />
//dependendo do tipo da minha variavel x na chamada da funcao, sera chamado uma funcao ou outra, mesmo que tenham o mesmo nome<br />
<br />
function printx(x::Float64)<br />
println(x)<br />
end<br />
<br />
function printx(x::String)<br />
println(x)<br />
end<br />
<br />
x="Oi"<br />
<br />
printx(x)<br />
</pre><br />
<br />
<br />
<br />
== Performance de Julia: na prática ==<br />
Para resumir, temos: <br />
<br />
Python => dynamic (variáveis dinâmicas) single<br />
dispatch<br />
<br />
C++ => static (variáveis estáticas) multiple dispatch<br />
<br />
Julia => dynamic multiple dispatch (''o melhor dos dois mundos!'')<br />
<br />
Na prática, é mostrado abaixo um exemplo da performance de Julia como linguagem de programação em dynamic multiple dispatch. <br />
<br />
O mesmo programa foi escrito em Julia e em C++. <br />
<br />
Em '''Julia''':<br />
<br />
<pre><br />
abstract type Animal end<br />
<br />
struct Cachorro <: Animal<br />
nome::String<br />
end<br />
<br />
struct Gato <: Animal<br />
nome::String<br />
end<br />
<br />
# Função de encontro que recebe tipo genérico de animal<br />
function encontroDeAnimais(a::Animal, b::Animal)<br />
acao = encontro(a,b)<br />
println("$(a.nome) encontra $(b.nome) e $acao")<br />
end<br />
<br />
# Funções de expressão única que recebem diferentes tipos de animais<br />
encontro(a::Cachorro, b::Cachorro) = "cheira" <br />
encontro(a::Cachorro, b::Gato) = "persegue"<br />
encontro(a::Gato, b::Gato) = "lambe"<br />
encontro(a::Gato, b::Cachorro) = "ignora" <br />
<br />
# Instanciando os bichinhos<br />
gato1 = Gato("Luciene Maria")<br />
gato2 = Gato("Mel")<br />
cachorro1 = Cachorro("Batata")<br />
cachorro2 = Cachorro("Snoopy")<br />
<br />
# Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2)<br />
encontroDeAnimais(gato1, cachorro2)<br />
encontroDeAnimais(cachorro1, cachorro2)<br />
</pre><br />
<br />
<br />
Em '''C++''':<br />
<br />
<pre><br />
#include <iostream><br />
using namespace std;<br />
<br />
class Animal { <br />
public:<br />
string nome;<br />
};<br />
<br />
string encontro(Animal a, Animal b) {}<br />
<br />
// Função de encontro que recebe tipo genérico de animal<br />
void encontroDeAnimais(Animal a, Animal b) {<br />
string acao = encontro(a,b);<br />
cout << a.nome << " encontra " << b.nome << " e " << acao << endl;<br />
}<br />
<br />
class Cachorro:public Animal {};<br />
class Gato:public Animal {};<br />
<br />
// Funções de expressão única que recebem diferentes tipos de animais<br />
string encontro(Cachorro a, Cachorro b) { return "cheira"; }<br />
string encontro(Cachorro a, Gato b) { return "persegue"; }<br />
string encontro(Gato a, Gato b) { return "lambe"; }<br />
string encontro(Gato a, Cachorro b) { return "ignora"; }<br />
<br />
int main() {<br />
// Instanciando os bichinhos<br />
Gato gato1; gato1.nome = "Luciene Maria";<br />
Gato gato2; gato2.nome = "Mel";<br />
Cachorro cachorro1; cachorro1.nome = "Batata";<br />
Cachorro cachorro2; cachorro2.nome = "Snoopy";<br />
<br />
// Chamando função encontroDeAnimais<br />
encontroDeAnimais(gato1, gato2);<br />
encontroDeAnimais(gato1, cachorro2);<br />
encontroDeAnimais(cachorro1, cachorro2);<br />
<br />
return 0;<br />
}<br />
</pre><br />
<br />
Para '''Julia''' nós obtemos o seguinte '''resultado''':<br />
<br />
<pre><br />
Luciene Maria encontra Mel e lambe<br />
Luciene Maria encontra Snoopy e ignora<br />
Batata encontra Snoopy e cheira<br />
</pre><br />
<br />
Para '''C++''' o '''resultado''' é:<br />
<br />
<pre><br />
Luciene Maria encontra Mel e<br />
Falha de Segmentação<br />
</pre><br />
<br />
Isso acontece porque C++ não aceita que uma função utilize-se de uma variável sem antes saber qual o tipo dessa variável! Por isso, poder utilizar-se de variáveis dinâmicas quando há multi-métodos é um diferencial que acaba por incrementar a performance de Julia como linguagem de programação visada para o Cálculo Numérico.<br />
<br />
'''Observação:''' é importante ressaltar que os testes feitos não são conclusivos para debater a performance de Julia, em termos estatísticos, e além disso, ser uma linguagem de programação que utiliza de variáveis dinâmicas e multi-métodos não é o único motivo pelo qual Julia poderia trazer tal performance em Cálculo Numérico. Podemos ainda contar com a sua capacidade de '''metaprogramação''', ou seja, Julia pode usar macros e eles são aplicados em tempo de interpretação. Há ainda outros fatores da construção da linguagem que contribuem para sua performance que aqui não foram citados.</div>Raquelmhttp://fiscomp.if.ufrgs.br/index.php?title=Julia&diff=2474Julia2020-01-06T23:33:27Z<p>Raquelm: /* Performance de Julia */</p>
<hr />
<div>Julia é uma linguagem relativamente nova de programação que começou a ser desenvolvida em 2009 por Jeff Bezanson, Stefan Karpinski, Viral B. Shah, e Alan Edelman, um grupo do MIT. Ela foi oficialmente lançada para o mundo em 2012.<br />
<br />
Em uma entrevista, quando perguntaram a Alan o por quê do nome Julia, ele disse que numa conversa anos atrás alguém sugeriu que Julia seria um bom nome para uma linguagem de programação.<br />
<br />
Julia pode ser usada para propósitos gerais de programação, assim como Python, mas em sua criação foi visada a utilização de Julia para Cálculo Numérico.<br />
<br />
== Aspectos Gerais ==<br />
<br />
Julia é uma linguagem de alto nível, isso significa, de maneira sucinta, que ela não é executada utilizando somente o processador, assim como acontece com linguagens de baixo nível, como Assembly, por exemplo.<br />
<br />
É escrita em C, C++, e Scheme, usando a estrutura do compilador LLVM (para melhor entendimento, o compilador de C é o GCC, por exemplo), enquanto a maior parte da biblioteca padrão de Julia é implementada na própria Julia.<br />
<br />
Um fato importante sobre Julia para os programadores de Python é que todas as bibliotecas de Python são usáveis através de um comando simples: PyCall.<br />
<br />
Um fato importante sobre Julia para os programadores de C é que Julia possui APIs (Interfaces de Programação de Aplicativos) especiais para chamada de funções em C diretamente.<br />
<br />
== Velocidade ==<br />
<br />
De acordo com testes feitos pelos próprios criadores de Julia, sua velocidade é similar com a de C.<br />
<br />
<br />
<center>[[Arquivo:juliasvelocity.png|border]]<br />
Fonte: [https://julialang.org/benchmarks/]<br />
</center><br />
<br />
<br />
== Testes de Velocidade ==<br />
<br />
A fim de pessoalmente testar a velocidade da linguagem de programação, foi escrito um programa em Julia de maneira similar ao programa de Python para o FTCS aplicado na Equação de Difusão (também conhecida como Equação do Calor). <br />
<br />
A Equação da Difusão em uma dimensão pode ser escrita da forma:<br />
<br />
<center><math>\frac{df}{dt}=\frac{d^{2}f}{dx^{2}}</math></center><br />
<br />
No método de FTCS (Forward-Time Central-Space) definimos a derivada em t na forma não simetrizada (forward) e as derivadas em x na forma simetrizada:<br />
<br />
<br />
<center><math>\frac{df}{dt} = \frac{f(x, t+dt) - f(x,t)}{dt}</math></center><br />
<br />
<p><br />
<br />
<center><math>\frac{d^{2}f}{dx^{2}} = \frac{f(x+dx, t) + f(x-dx, t) - 2f(x,t)}{dx^{2}}</math></center><br />
<br />
E substuindo na equação da difusão, em notação discreta temos:<br />
<br />
<center><math>f_{j}^{n+1} = f_{j}^{n} + D\frac{dt}{(dx)^{2}}[f_{j+1}^{n} + f_{j-1}^{n} - 2 f_{j}^{n}]</math></center><br />
<br />
'''Observação:''' esse procedimento funciona bem se <math>k=D\frac{dt}{(dx)^{2}} <= 1/2</math>, segundo análise de estabilidade do método.<br />
<br />
<br />
Dessa forma, foi escrito um programa para integrar a Equação de Difusão através do método de FTCS nas linguagens Python e Julia.<br />
<br />
Para '''Python''':<br />
<pre><br />
//FTCS aplicado na equacao da difusao. Linguagem: PYTHON<br />
<br />
import copy<br />
import numpy as np<br />
import matplotlib.pyplot as plt<br />
<br />
def init():<br />
L=50;D=1.;dt=0.05;dx=1.;t=0;tmax=100.<br />
k=D*dt/(dx*dx) <br />
return L,k,dt,t,tmax<br />
<br />
L,k,dt,t,tmax = init()<br />
<br />
x = np.arange(0,L,1) <br />
f = np.zeros(x.shape)<br />
<br />
a = int(L/3)<br />
b = int(2*L/3)<br />
f[a:b]=1.<br />
f1 = copy.deepcopy(f) <br />
f2 = copy.deepcopy(f)<br />
<br />
while t<tmax:<br />
t+=dt<br />
f1[1:L-1]=f[1:L-1]+k*(f[0:L-2]+f[2:L]-2*f[1:L-1])<br />
f1[L-1]=f[L-1]+k*(f[L-2]+f[0]-2*f[L-1]) <br />
f1[0]=f[0]+k*(f[1]+f[L-1]-2*f[0]) <br />
f=copy.deepcopy(f1) <br />
<br />
sum0=sum(f1)<br />
sum1=sum(f2) <br />
<br />
print("Integral em t=0: %7.4f" % sum0)<br />
print("Integral em tmax: %7.4f" % sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
Em '''Julia''':<br />
<pre><br />
//FTCS aplicado na equacao da difusao. Linguagem: JULIA<br />
<br />
using PyPlot<br />
<br />
L=50<br />
D=1.<br />
dt=0.05<br />
dx=1.<br />
t=0<br />
tmax=100.<br />
k=D*dt/(dx*dx) <br />
<br />
x = collect(0:1:L-1)<br />
f = zeros(L)<br />
f1 = zeros(L)<br />
<br />
a = trunc(Int, L/3) <br />
b = trunc(Int, 2*L/3)<br />
<br />
f[a+1:b] .= 1.<br />
f2 = deepcopy(f)<br />
<br />
while t<tmax<br />
global t+=dt <br />
f1[2:L-1] = f[2:L-1] + k*(f[1:L-2] + f[3:L] - 2*f[2:L-1]) <br />
f1[L] = f[L] + k*(f[L-1] + f[1] - 2*f[L])<br />
f1[1] = f[1] + k*(f[2] + f[L] - 2*f[1]) <br />
global f = deepcopy(f1) <br />
end<br />
<br />
sum0 = sum(f1)<br />
sum1 = sum(f2)<br />
<br />
println("Integral em t=0: ", sum0)<br />
println("Integral em tmax: ", sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
<br />
Foi testado o tempo de execução da parte principal dos dois programas (isto é, sem fazer o gráfico dos resultados), através do timer do terminal, como mostra na próxima figura:<br />
<br />
<center>[[Arquivo:Ftcs_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o método de FTCS aplicado à Equação de Difusão<br />
</center><br />
<br />
É possível perceber, através da figura acima, que o tempo de execução de Python para o FTCS aplicado à Equação de Difusão é menor do que o de Julia. Em razão disso, foi testado um programa simples, como mostra abaixo, que incrementa uma variável 10 vezes, sendo o seu valor inicial 0.<br />
<br />
<br />
<center>[[Arquivo:For.png|border]]<br />
'''Legenda:''' Programa para incrementar o valor de uma variável, nesse caso ''i'', 10 vezes, escrito em Julia e em Python<br />
</center><br />
<br />
E posteriormente, novamente, foi testado o tempo de execução da parte principal dos programas através do terminal:<br />
<br />
<center>[[Arquivo:For_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o programa que incrementa o valor da variável 10 vezes<br />
</center><br />
<br />
É possível perceber que para esse simples programa de incrementação, Python ainda obtém melhor performance do que Julia.<br />
<br />
<br />
== Performance de Julia ==<br />
<br />
Tentando entender o que traria tal performance em Cálculo Numérico para Julia, foi chegado à conclusão de que ser uma linguagem que se utilizada de ''variáveis dinâmicas'' e ''multi-métodos'' seria uma das grandes contribuições da linguagem.<br />
<br />
'''Variáveis dinâmicas:'''<br />
<br />
Em Python elas são interpretadas em runtime, ou seja, '''tempo de execução''' => o programa checa toda hora se a variável mudou e isso torna ele mais lento<br />
<br />
'''Variáveis estáticas:'''<br />
<br />
Em C as variáveis são fixas, e isso é visto é em '''tempo de compilação''' => precisa pensar nas variáveis e isso torna o tempo de programação mais lento<br />
<br />
Em Julia isso é basicamente opcional, não é preciso definir as variáveis, mas é possível, e elas podem mudar dinamicamente, em tempo de execução. E ainda, Julia se utiliza de multi-métodos para não ter que lidar com a constante checagem dos tipos das variáveis, como Python faz!<br />
<br />
'''Métodos Únicos'''<br />
<br />
Python => single dispatch => Métodos Únicos<br />
- Não tenho sobrecarga de funções, eu simplesmente chamo uma função que já está escrita<br />
<br />
'''Multi-métodos'''<br />
<br />
Sobrecarga de funções (C++) => Multi-métodos (multiple dispatch)<br />
- Tenho uma função e dependendo dos parâmetros que eu coloco ao chamá-la, eu chamo uma função ou outra<br />
<br />
'''Exemplo de sobrecarga de funções em Julia:'''<br />
<br />
<pre> <br />
//dependendo do tipo da minha variavel x na chamada da funcao, sera chamado uma funcao ou outra, mesmo que tenham o mesmo nome<br />
<br />
function printx(x::Float64)<br />
println(x)<br />
end<br />
<br />
function printx(x::String)<br />
println(x)<br />
end<br />
<br />
x="Oi"<br />
<br />
printx(x)<br />
</pre></div>Raquelmhttp://fiscomp.if.ufrgs.br/index.php?title=Julia&diff=2473Julia2020-01-06T23:21:08Z<p>Raquelm: </p>
<hr />
<div>Julia é uma linguagem relativamente nova de programação que começou a ser desenvolvida em 2009 por Jeff Bezanson, Stefan Karpinski, Viral B. Shah, e Alan Edelman, um grupo do MIT. Ela foi oficialmente lançada para o mundo em 2012.<br />
<br />
Em uma entrevista, quando perguntaram a Alan o por quê do nome Julia, ele disse que numa conversa anos atrás alguém sugeriu que Julia seria um bom nome para uma linguagem de programação.<br />
<br />
Julia pode ser usada para propósitos gerais de programação, assim como Python, mas em sua criação foi visada a utilização de Julia para Cálculo Numérico.<br />
<br />
== Aspectos Gerais ==<br />
<br />
Julia é uma linguagem de alto nível, isso significa, de maneira sucinta, que ela não é executada utilizando somente o processador, assim como acontece com linguagens de baixo nível, como Assembly, por exemplo.<br />
<br />
É escrita em C, C++, e Scheme, usando a estrutura do compilador LLVM (para melhor entendimento, o compilador de C é o GCC, por exemplo), enquanto a maior parte da biblioteca padrão de Julia é implementada na própria Julia.<br />
<br />
Um fato importante sobre Julia para os programadores de Python é que todas as bibliotecas de Python são usáveis através de um comando simples: PyCall.<br />
<br />
Um fato importante sobre Julia para os programadores de C é que Julia possui APIs (Interfaces de Programação de Aplicativos) especiais para chamada de funções em C diretamente.<br />
<br />
== Velocidade ==<br />
<br />
De acordo com testes feitos pelos próprios criadores de Julia, sua velocidade é similar com a de C.<br />
<br />
<br />
<center>[[Arquivo:juliasvelocity.png|border]]<br />
Fonte: [https://julialang.org/benchmarks/]<br />
</center><br />
<br />
<br />
== Testes de Velocidade ==<br />
<br />
A fim de pessoalmente testar a velocidade da linguagem de programação, foi escrito um programa em Julia de maneira similar ao programa de Python para o FTCS aplicado na Equação de Difusão (também conhecida como Equação do Calor). <br />
<br />
A Equação da Difusão em uma dimensão pode ser escrita da forma:<br />
<br />
<center><math>\frac{df}{dt}=\frac{d^{2}f}{dx^{2}}</math></center><br />
<br />
No método de FTCS (Forward-Time Central-Space) definimos a derivada em t na forma não simetrizada (forward) e as derivadas em x na forma simetrizada:<br />
<br />
<br />
<center><math>\frac{df}{dt} = \frac{f(x, t+dt) - f(x,t)}{dt}</math></center><br />
<br />
<p><br />
<br />
<center><math>\frac{d^{2}f}{dx^{2}} = \frac{f(x+dx, t) + f(x-dx, t) - 2f(x,t)}{dx^{2}}</math></center><br />
<br />
E substuindo na equação da difusão, em notação discreta temos:<br />
<br />
<center><math>f_{j}^{n+1} = f_{j}^{n} + D\frac{dt}{(dx)^{2}}[f_{j+1}^{n} + f_{j-1}^{n} - 2 f_{j}^{n}]</math></center><br />
<br />
'''Observação:''' esse procedimento funciona bem se <math>k=D\frac{dt}{(dx)^{2}} <= 1/2</math>, segundo análise de estabilidade do método.<br />
<br />
<br />
Dessa forma, foi escrito um programa para integrar a Equação de Difusão através do método de FTCS nas linguagens Python e Julia.<br />
<br />
Para '''Python''':<br />
<pre><br />
//FTCS aplicado na equacao da difusao. Linguagem: PYTHON<br />
<br />
import copy<br />
import numpy as np<br />
import matplotlib.pyplot as plt<br />
<br />
def init():<br />
L=50;D=1.;dt=0.05;dx=1.;t=0;tmax=100.<br />
k=D*dt/(dx*dx) <br />
return L,k,dt,t,tmax<br />
<br />
L,k,dt,t,tmax = init()<br />
<br />
x = np.arange(0,L,1) <br />
f = np.zeros(x.shape)<br />
<br />
a = int(L/3)<br />
b = int(2*L/3)<br />
f[a:b]=1.<br />
f1 = copy.deepcopy(f) <br />
f2 = copy.deepcopy(f)<br />
<br />
while t<tmax:<br />
t+=dt<br />
f1[1:L-1]=f[1:L-1]+k*(f[0:L-2]+f[2:L]-2*f[1:L-1])<br />
f1[L-1]=f[L-1]+k*(f[L-2]+f[0]-2*f[L-1]) <br />
f1[0]=f[0]+k*(f[1]+f[L-1]-2*f[0]) <br />
f=copy.deepcopy(f1) <br />
<br />
sum0=sum(f1)<br />
sum1=sum(f2) <br />
<br />
print("Integral em t=0: %7.4f" % sum0)<br />
print("Integral em tmax: %7.4f" % sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
Em '''Julia''':<br />
<pre><br />
//FTCS aplicado na equacao da difusao. Linguagem: JULIA<br />
<br />
using PyPlot<br />
<br />
L=50<br />
D=1.<br />
dt=0.05<br />
dx=1.<br />
t=0<br />
tmax=100.<br />
k=D*dt/(dx*dx) <br />
<br />
x = collect(0:1:L-1)<br />
f = zeros(L)<br />
f1 = zeros(L)<br />
<br />
a = trunc(Int, L/3) <br />
b = trunc(Int, 2*L/3)<br />
<br />
f[a+1:b] .= 1.<br />
f2 = deepcopy(f)<br />
<br />
while t<tmax<br />
global t+=dt <br />
f1[2:L-1] = f[2:L-1] + k*(f[1:L-2] + f[3:L] - 2*f[2:L-1]) <br />
f1[L] = f[L] + k*(f[L-1] + f[1] - 2*f[L])<br />
f1[1] = f[1] + k*(f[2] + f[L] - 2*f[1]) <br />
global f = deepcopy(f1) <br />
end<br />
<br />
sum0 = sum(f1)<br />
sum1 = sum(f2)<br />
<br />
println("Integral em t=0: ", sum0)<br />
println("Integral em tmax: ", sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
<br />
Foi testado o tempo de execução da parte principal dos dois programas (isto é, sem fazer o gráfico dos resultados), através do timer do terminal, como mostra na próxima figura:<br />
<br />
<center>[[Arquivo:Ftcs_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o método de FTCS aplicado à Equação de Difusão<br />
</center><br />
<br />
É possível perceber, através da figura acima, que o tempo de execução de Python para o FTCS aplicado à Equação de Difusão é menor do que o de Julia. Em razão disso, foi testado um programa simples, como mostra abaixo, que incrementa uma variável 10 vezes, sendo o seu valor inicial 0.<br />
<br />
<br />
<center>[[Arquivo:For.png|border]]<br />
'''Legenda:''' Programa para incrementar o valor de uma variável, nesse caso ''i'', 10 vezes, escrito em Julia e em Python<br />
</center><br />
<br />
E posteriormente, novamente, foi testado o tempo de execução da parte principal dos programas através do terminal:<br />
<br />
<center>[[Arquivo:For_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o programa que incrementa o valor da variável 10 vezes<br />
</center><br />
<br />
É possível perceber que para esse simples programa de incrementação, Python ainda obtém melhor performance do que Julia.<br />
<br />
<br />
== Performance de Julia ==<br />
<br />
Tentando entender o que traria tal performance em Cálculo Numérico para Julia, foi chegado à conclusão de que ser uma linguagem que se utilizada de ''variáveis dinâmicas'' e ''multi-métodos'' seria uma das grandes contribuições da linguagem.<br />
'''<br />
Variáveis dinâmicas:'''<br />
<br />
Em Python elas são interpretadas em runtime => o programa checa toda hora se a variável mudou e isso torna ele mais lento<br />
<br />
'''Variáveis estáticas:'''<br />
<br />
Em C as variáveis são fixas, e isso é visto é emtempo de compilação => precisa pensar nas variáveis e isso torna o tempo de programação mais lento</div>Raquelmhttp://fiscomp.if.ufrgs.br/index.php?title=Julia&diff=2472Julia2020-01-06T23:12:09Z<p>Raquelm: /* Testes de Velocidade */</p>
<hr />
<div>Julia é uma linguagem relativamente nova de programação que começou a ser desenvolvida em 2009 por Jeff Bezanson, Stefan Karpinski, Viral B. Shah, e Alan Edelman, um grupo do MIT. Ela foi oficialmente lançada para o mundo em 2012.<br />
<br />
Em uma entrevista, quando perguntaram a Alan o por quê do nome Julia, ele disse que numa conversa anos atrás alguém sugeriu que Julia seria um bom nome para uma linguagem de programação.<br />
<br />
Julia pode ser usada para propósitos gerais de programação, assim como Python, mas em sua criação foi visada a utilização de Julia para Cálculo Numérico.<br />
<br />
== Aspectos Gerais ==<br />
<br />
Julia é uma linguagem de alto nível, isso significa, de maneira sucinta, que ela não é executada utilizando somente o processador, assim como acontece com linguagens de baixo nível, como Assembly, por exemplo.<br />
<br />
É escrita em C, C++, e Scheme, usando a estrutura do compilador LLVM (para melhor entendimento, o compilador de C é o GCC, por exemplo), enquanto a maior parte da biblioteca padrão de Julia é implementada na própria Julia.<br />
<br />
Um fato importante sobre Julia para os programadores de Python é que todas as bibliotecas de Python são usáveis através de um comando simples: PyCall.<br />
<br />
Um fato importante sobre Julia para os programadores de C é que Julia possui APIs (Interfaces de Programação de Aplicativos) especiais para chamada de funções em C diretamente.<br />
<br />
== Velocidade ==<br />
<br />
De acordo com testes feitos pelos próprios criadores de Julia, sua velocidade é similar com a de C.<br />
<br />
<br />
<center>[[Arquivo:juliasvelocity.png|border]]<br />
Fonte: [https://julialang.org/benchmarks/]<br />
</center><br />
<br />
<br />
== Testes de Velocidade ==<br />
<br />
A fim de pessoalmente testar a velocidade da linguagem de programação, foi escrito um programa em Julia de maneira similar ao programa de Python para o FTCS aplicado na Equação de Difusão (também conhecida como Equação do Calor). <br />
<br />
A Equação da Difusão em uma dimensão pode ser escrita da forma:<br />
<br />
<center><math>\frac{df}{dt}=\frac{d^{2}f}{dx^{2}}</math></center><br />
<br />
No método de FTCS (Forward-Time Central-Space) definimos a derivada em t na forma não simetrizada (forward) e as derivadas em x na forma simetrizada:<br />
<br />
<br />
<center><math>\frac{df}{dt} = \frac{f(x, t+dt) - f(x,t)}{dt}</math></center><br />
<br />
<p><br />
<br />
<center><math>\frac{d^{2}f}{dx^{2}} = \frac{f(x+dx, t) + f(x-dx, t) - 2f(x,t)}{dx^{2}}</math></center><br />
<br />
E substuindo na equação da difusão, em notação discreta temos:<br />
<br />
<center><math>f_{j}^{n+1} = f_{j}^{n} + D\frac{dt}{(dx)^{2}}[f_{j+1}^{n} + f_{j-1}^{n} - 2 f_{j}^{n}]</math></center><br />
<br />
'''Observação:''' esse procedimento funciona bem se <math>k=D\frac{dt}{(dx)^{2}} <= 1/2</math>, segundo análise de estabilidade do método.<br />
<br />
<br />
Dessa forma, foi escrito um programa para integrar a Equação de Difusão através do método de FTCS nas linguagens Python e Julia.<br />
<br />
Para '''Python''':<br />
<pre><br />
//FTCS aplicado na equacao da difusao. Linguagem: PYTHON<br />
<br />
import copy<br />
import numpy as np<br />
import matplotlib.pyplot as plt<br />
<br />
def init():<br />
L=50;D=1.;dt=0.05;dx=1.;t=0;tmax=100.<br />
k=D*dt/(dx*dx) <br />
return L,k,dt,t,tmax<br />
<br />
L,k,dt,t,tmax = init()<br />
<br />
x = np.arange(0,L,1) <br />
f = np.zeros(x.shape)<br />
<br />
a = int(L/3)<br />
b = int(2*L/3)<br />
f[a:b]=1.<br />
f1 = copy.deepcopy(f) <br />
f2 = copy.deepcopy(f)<br />
<br />
while t<tmax:<br />
t+=dt<br />
f1[1:L-1]=f[1:L-1]+k*(f[0:L-2]+f[2:L]-2*f[1:L-1])<br />
f1[L-1]=f[L-1]+k*(f[L-2]+f[0]-2*f[L-1]) <br />
f1[0]=f[0]+k*(f[1]+f[L-1]-2*f[0]) <br />
f=copy.deepcopy(f1) <br />
<br />
sum0=sum(f1)<br />
sum1=sum(f2) <br />
<br />
print("Integral em t=0: %7.4f" % sum0)<br />
print("Integral em tmax: %7.4f" % sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
Em '''Julia''':<br />
<pre><br />
//FTCS aplicado na equacao da difusao. Linguagem: JULIA<br />
<br />
using PyPlot<br />
<br />
L=50<br />
D=1.<br />
dt=0.05<br />
dx=1.<br />
t=0<br />
tmax=100.<br />
k=D*dt/(dx*dx) <br />
<br />
x = collect(0:1:L-1)<br />
f = zeros(L)<br />
f1 = zeros(L)<br />
<br />
a = trunc(Int, L/3) <br />
b = trunc(Int, 2*L/3)<br />
<br />
f[a+1:b] .= 1.<br />
f2 = deepcopy(f)<br />
<br />
while t<tmax<br />
global t+=dt <br />
f1[2:L-1] = f[2:L-1] + k*(f[1:L-2] + f[3:L] - 2*f[2:L-1]) <br />
f1[L] = f[L] + k*(f[L-1] + f[1] - 2*f[L])<br />
f1[1] = f[1] + k*(f[2] + f[L] - 2*f[1]) <br />
global f = deepcopy(f1) <br />
end<br />
<br />
sum0 = sum(f1)<br />
sum1 = sum(f2)<br />
<br />
println("Integral em t=0: ", sum0)<br />
println("Integral em tmax: ", sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
<br />
Foi testado o tempo de execução da parte principal dos dois programas (isto é, sem fazer o gráfico dos resultados), através do timer do terminal, como mostra na próxima figura:<br />
<br />
<center>[[Arquivo:Ftcs_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o método de FTCS aplicado à Equação de Difusão<br />
</center><br />
<br />
É possível perceber, através da figura acima, que o tempo de execução de Python para o FTCS aplicado à Equação de Difusão é menor do que o de Julia. Em razão disso, foi testado um programa simples, como mostra abaixo, que incrementa uma variável 10 vezes, sendo o seu valor inicial 0.<br />
<br />
<br />
<center>[[Arquivo:For.png|border]]<br />
'''Legenda:''' Programa para incrementar o valor de uma variável, nesse caso ''i'', 10 vezes, escrito em Julia e em Python<br />
</center><br />
<br />
E posteriormente, novamente, foi testado o tempo de execução da parte principal dos programas através do terminal:<br />
<br />
<center>[[Arquivo:For_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o programa que incrementa o valor da variável 10 vezes<br />
</center><br />
<br />
É possível perceber que para esse simples programa de incrementação, Python ainda obtém melhor performance do que Julia.<br />
<br />
== Performance de Julia ==</div>Raquelmhttp://fiscomp.if.ufrgs.br/index.php?title=Julia&diff=2471Julia2020-01-06T23:03:50Z<p>Raquelm: </p>
<hr />
<div>Julia é uma linguagem relativamente nova de programação que começou a ser desenvolvida em 2009 por Jeff Bezanson, Stefan Karpinski, Viral B. Shah, e Alan Edelman, um grupo do MIT. Ela foi oficialmente lançada para o mundo em 2012.<br />
<br />
Em uma entrevista, quando perguntaram a Alan o por quê do nome Julia, ele disse que numa conversa anos atrás alguém sugeriu que Julia seria um bom nome para uma linguagem de programação.<br />
<br />
Julia pode ser usada para propósitos gerais de programação, assim como Python, mas em sua criação foi visada a utilização de Julia para Cálculo Numérico.<br />
<br />
== Aspectos Gerais ==<br />
<br />
Julia é uma linguagem de alto nível, isso significa, de maneira sucinta, que ela não é executada utilizando somente o processador, assim como acontece com linguagens de baixo nível, como Assembly, por exemplo.<br />
<br />
É escrita em C, C++, e Scheme, usando a estrutura do compilador LLVM (para melhor entendimento, o compilador de C é o GCC, por exemplo), enquanto a maior parte da biblioteca padrão de Julia é implementada na própria Julia.<br />
<br />
Um fato importante sobre Julia para os programadores de Python é que todas as bibliotecas de Python são usáveis através de um comando simples: PyCall.<br />
<br />
Um fato importante sobre Julia para os programadores de C é que Julia possui APIs (Interfaces de Programação de Aplicativos) especiais para chamada de funções em C diretamente.<br />
<br />
== Velocidade ==<br />
<br />
De acordo com testes feitos pelos próprios criadores de Julia, sua velocidade é similar com a de C.<br />
<br />
<br />
<center>[[Arquivo:juliasvelocity.png|border]]<br />
Fonte: [https://julialang.org/benchmarks/]<br />
</center><br />
<br />
<br />
== Testes de Velocidade ==<br />
<br />
A fim de pessoalmente testar a velocidade da linguagem de programação, foi escrito um programa em Julia de maneira similar ao programa de Python para o FTCS aplicado na Equação de Difusão (também conhecida como Equação do Calor). <br />
<br />
A Equação da Difusão em uma dimensão pode ser escrita da forma:<br />
<br />
<center><math>\frac{df}{dt}=\frac{d^{2}f}{dx^{2}}</math></center><br />
<br />
No método de FTCS (Forward-Time Central-Space) definimos a derivada em t na forma não simetrizada (forward) e as derivadas em x na forma simetrizada:<br />
<br />
<br />
<center><math>\frac{df}{dt} = \frac{f(x, t+dt) - f(x,t)}{dt}</math></center><br />
<br />
<p><br />
<br />
<center><math>\frac{d^{2}f}{dx^{2}} = \frac{f(x+dx, t) + f(x-dx, t) - 2f(x,t)}{dx^{2}}</math></center><br />
<br />
E substuindo na equação da difusão, em notação discreta temos:<br />
<br />
<center><math>f_{j}^{n+1} = f_{j}^{n} + D\frac{dt}{(dx)^{2}}[f_{j+1}^{n} + f_{j-1}^{n} - 2 f_{j}^{n}]</math></center><br />
<br />
'''Observação:''' esse procedimento funciona bem se <math>k=D\frac{dt}{(dx)^{2}} <= 1/2</math>, segundo análise de estabilidade do método.<br />
<br />
<br />
Dessa forma, foi escrito um programa para integrar a Equação de Difusão através do método de FTCS nas linguagens Python e Julia.<br />
<br />
Para '''Python''':<br />
<pre><br />
//FTCS aplicado na equacao da difusao. Linguagem: PYTHON<br />
<br />
import copy<br />
import numpy as np<br />
import matplotlib.pyplot as plt<br />
<br />
def init():<br />
L=50;D=1.;dt=0.05;dx=1.;t=0;tmax=100.<br />
k=D*dt/(dx*dx) <br />
return L,k,dt,t,tmax<br />
<br />
L,k,dt,t,tmax = init()<br />
<br />
x = np.arange(0,L,1) <br />
f = np.zeros(x.shape)<br />
<br />
a = int(L/3)<br />
b = int(2*L/3)<br />
f[a:b]=1.<br />
f1 = copy.deepcopy(f) <br />
f2 = copy.deepcopy(f)<br />
<br />
while t<tmax:<br />
t+=dt<br />
f1[1:L-1]=f[1:L-1]+k*(f[0:L-2]+f[2:L]-2*f[1:L-1])<br />
f1[L-1]=f[L-1]+k*(f[L-2]+f[0]-2*f[L-1]) <br />
f1[0]=f[0]+k*(f[1]+f[L-1]-2*f[0]) <br />
f=copy.deepcopy(f1) <br />
<br />
sum0=sum(f1)<br />
sum1=sum(f2) <br />
<br />
print("Integral em t=0: %7.4f" % sum0)<br />
print("Integral em tmax: %7.4f" % sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
Em '''Julia''':<br />
<pre><br />
//FTCS aplicado na equacao da difusao. Linguagem: JULIA<br />
<br />
using PyPlot<br />
<br />
L=50<br />
D=1.<br />
dt=0.05<br />
dx=1.<br />
t=0<br />
tmax=100.<br />
k=D*dt/(dx*dx) <br />
<br />
x = collect(0:1:L-1)<br />
f = zeros(L)<br />
f1 = zeros(L)<br />
<br />
a = trunc(Int, L/3) <br />
b = trunc(Int, 2*L/3)<br />
<br />
f[a+1:b] .= 1.<br />
f2 = deepcopy(f)<br />
<br />
while t<tmax<br />
global t+=dt <br />
f1[2:L-1] = f[2:L-1] + k*(f[1:L-2] + f[3:L] - 2*f[2:L-1]) <br />
f1[L] = f[L] + k*(f[L-1] + f[1] - 2*f[L])<br />
f1[1] = f[1] + k*(f[2] + f[L] - 2*f[1]) <br />
global f = deepcopy(f1) <br />
end<br />
<br />
sum0 = sum(f1)<br />
sum1 = sum(f2)<br />
<br />
println("Integral em t=0: ", sum0)<br />
println("Integral em tmax: ", sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
<br />
Foi testado o tempo de execução da parte principal dos dois programas (isto é, sem fazer o gráfico dos resultados), através do timer do terminal, como mostra na próxima figura:<br />
<br />
<center>[[Arquivo:Ftcs_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o método de FTCS aplicado à Equação de Difusão<br />
</center><br />
<br />
É possível perceber, através da figura acima, que o tempo de execução de Python para o FTCS aplicado à Equação de Difusão é menor do que o de Julia. Em razão disso, foi testado um programa simples, como mostra abaixo, que incrementa uma variável 10 vezes, sendo o seu valor inicial 0.<br />
<br />
<br />
<center>[[Arquivo:For.png|border]]<br />
'''Legenda:''' Programa para incrementar o valor de uma variável, nesse caso ''i'', 10 vezes, escrito em Julia e em Python<br />
</center><br />
<br />
E posteriormente, novamente, foi testado o tempo de execução da parte principal dos programas através do terminal:<br />
<br />
<center>[[Arquivo:For_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o programa que incrementa o valor da variável 10 vezes<br />
</center><br />
<br />
É possível perceber que para esse simples programa de incrementação, Python ainda obtém melhor performance do que Julia.<br />
<br />
<br />
== Performance de Julia ==</div>Raquelmhttp://fiscomp.if.ufrgs.br/index.php?title=Julia&diff=2470Julia2020-01-06T22:59:23Z<p>Raquelm: </p>
<hr />
<div>Julia é uma linguagem relativamente nova de programação que começou a ser desenvolvida em 2009 por Jeff Bezanson, Stefan Karpinski, Viral B. Shah, e Alan Edelman, um grupo do MIT. Ela foi oficialmente lançada para o mundo em 2012.<br />
<br />
Em uma entrevista, quando perguntaram a Alan o por quê do nome Julia, ele disse que numa conversa anos atrás alguém sugeriu que Julia seria um bom nome para uma linguagem de programação.<br />
<br />
Julia pode ser usada para propósitos gerais de programação, assim como Python, mas em sua criação foi visada a utilização de Julia para Cálculo Numérico.<br />
<br />
== Aspectos Gerais ==<br />
<br />
Julia é uma linguagem de alto nível, isso significa, de maneira sucinta, que ela não é executada utilizando somente o processador, assim como acontece com linguagens de baixo nível, como Assembly, por exemplo.<br />
<br />
É escrita em C, C++, e Scheme, usando a estrutura do compilador LLVM (para melhor entendimento, o compilador de C é o GCC, por exemplo), enquanto a maior parte da biblioteca padrão de Julia é implementada na própria Julia.<br />
<br />
Um fato importante sobre Julia para os programadores de Python é que todas as bibliotecas de Python são usáveis através de um comando simples: PyCall.<br />
<br />
Um fato importante sobre Julia para os programadores de C é que Julia possui APIs (Interfaces de Programação de Aplicativos) especiais para chamada de funções em C diretamente.<br />
<br />
== Velocidade ==<br />
<br />
De acordo com testes feitos pelos próprios criadores de Julia, sua velocidade é similar com a de C.<br />
<br />
<br />
<center>[[Arquivo:juliasvelocity.png|border]]<br />
Fonte: [https://julialang.org/benchmarks/]<br />
</center><br />
<br />
<br />
== Testes de Velocidade ==<br />
<br />
A fim de pessoalmente testar a velocidade da linguagem de programação, foi escrito um programa em Julia de maneira similar ao programa de Python para o FTCS aplicado na Equação de Difusão (também conhecida como Equação do Calor). <br />
<br />
A Equação da Difusão em uma dimensão pode ser escrita da forma:<br />
<br />
<center><math>\frac{df}{dt}=\frac{d^{2}f}{dx^{2}}</math></center><br />
<br />
No método de FTCS (Forward-Time Central-Space) definimos a derivada em t na forma não simetrizada (forward) e as derivadas em x na forma simetrizada:<br />
<br />
<br />
<center><math>\frac{df}{dt} = \frac{f(x, t+dt) - f(x,t)}{dt}</math></center><br />
<br />
<p><br />
<br />
<center><math>\frac{d^{2}f}{dx^{2}} = \frac{f(x+dx, t) + f(x-dx, t) - 2f(x,t)}{dx^{2}}</math></center><br />
<br />
E substuindo na equação da difusão, em notação discreta temos:<br />
<br />
<center><math>f_{j}^{n+1} = f_{j}^{n} + D\frac{dt}{(dx)^{2}}[f_{j+1}^{n} + f_{j-1}^{n} - 2 f_{j}^{n}]</math></center><br />
<br />
'''Observação:''' esse procedimento funciona bem se <math>k=D\frac{dt}{(dx)^{2}} <= 1/2</math>, segundo análise de estabilidade do método.<br />
<br />
<br />
Dessa forma, foi escrito um programa para integrar a Equação de Difusão através do método de FTCS nas linguagens Python e Julia.<br />
<br />
Para '''Python''':<br />
<pre><br />
//FTCS aplicado na equacao da difusao. Linguagem: PYTHON<br />
<br />
import copy<br />
import numpy as np<br />
import matplotlib.pyplot as plt<br />
<br />
def init():<br />
L=50;D=1.;dt=0.05;dx=1.;t=0;tmax=100.<br />
k=D*dt/(dx*dx) <br />
return L,k,dt,t,tmax<br />
<br />
L,k,dt,t,tmax = init()<br />
<br />
x = np.arange(0,L,1) <br />
f = np.zeros(x.shape)<br />
<br />
a = int(L/3)<br />
b = int(2*L/3)<br />
f[a:b]=1.<br />
f1 = copy.deepcopy(f) <br />
f2 = copy.deepcopy(f)<br />
<br />
while t<tmax:<br />
t+=dt<br />
f1[1:L-1]=f[1:L-1]+k*(f[0:L-2]+f[2:L]-2*f[1:L-1])<br />
f1[L-1]=f[L-1]+k*(f[L-2]+f[0]-2*f[L-1]) <br />
f1[0]=f[0]+k*(f[1]+f[L-1]-2*f[0]) <br />
f=copy.deepcopy(f1) <br />
<br />
sum0=sum(f1)<br />
sum1=sum(f2) <br />
<br />
print("Integral em t=0: %7.4f" % sum0)<br />
print("Integral em tmax: %7.4f" % sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
Em '''Julia''':<br />
<pre><br />
//FTCS aplicado na equacao da difusao. Linguagem: JULIA<br />
<br />
using PyPlot<br />
<br />
L=50<br />
D=1.<br />
dt=0.05<br />
dx=1.<br />
t=0<br />
tmax=100.<br />
k=D*dt/(dx*dx) <br />
<br />
x = collect(0:1:L-1)<br />
f = zeros(L)<br />
f1 = zeros(L)<br />
<br />
a = trunc(Int, L/3) <br />
b = trunc(Int, 2*L/3)<br />
<br />
f[a+1:b] .= 1.<br />
f2 = deepcopy(f)<br />
<br />
while t<tmax<br />
global t+=dt <br />
f1[2:L-1] = f[2:L-1] + k*(f[1:L-2] + f[3:L] - 2*f[2:L-1]) <br />
f1[L] = f[L] + k*(f[L-1] + f[1] - 2*f[L])<br />
f1[1] = f[1] + k*(f[2] + f[L] - 2*f[1]) <br />
global f = deepcopy(f1) <br />
end<br />
<br />
sum0 = sum(f1)<br />
sum1 = sum(f2)<br />
<br />
println("Integral em t=0: ", sum0)<br />
println("Integral em tmax: ", sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
Foi testado o tempo de execução da parte principal dos dois programas (isto é, sem fazer o gráfico dos resultados), através do timer do terminal, como mostra na próxima figura:<br />
<br />
<center>[[Arquivo:Ftcs_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o método de FTCS aplicado à Equação de Difusão<br />
</center><br />
<br />
É possível perceber, através da figura acima, que o tempo de execução de Python para o FTCS aplicado à Equação de Difusão é menor do que o de Julia. Em razão disso, foi testado um programa simples, como mostra abaixo, que incrementa uma variável 10 vezes, sendo o seu valor inicial 0.<br />
<br />
<br />
<center>[[Arquivo:For.png|border]]<br />
'''Legenda:''' Programa para incrementar o valor de uma variável, nesse caso ''i'', 10 vezes, escrito em Julia e em Python<br />
</center><br />
<br />
E posteriormente, novamente, foi testado o tempo de execução da parte principal dos programas através do terminal:<br />
<br />
<br />
<center>[[Arquivo:For_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o programa que incrementa o valor da variável 10 vezes<br />
</center><br />
<br />
É possível perceber que para esse simples programa de incrementação, Python ainda obtém melhor performance do que Julia.<br />
<br />
<br />
== Potencial de performance de Julia: origem ==</div>Raquelmhttp://fiscomp.if.ufrgs.br/index.php?title=Julia&diff=2469Julia2020-01-06T22:57:55Z<p>Raquelm: </p>
<hr />
<div>Julia é uma linguagem relativamente nova de programação que começou a ser desenvolvida em 2009 por Jeff Bezanson, Stefan Karpinski, Viral B. Shah, e Alan Edelman, um grupo do MIT. Ela foi oficialmente lançada para o mundo em 2012.<br />
<br />
Em uma entrevista, quando perguntaram a Alan o por quê do nome Julia, ele disse que numa conversa anos atrás alguém sugeriu que Julia seria um bom nome para uma linguagem de programação.<br />
<br />
Julia pode ser usada para propósitos gerais de programação, assim como Python, mas em sua criação foi visada a utilização de Julia para Cálculo Numérico.<br />
<br />
== Aspectos Gerais ==<br />
<br />
Julia é uma linguagem de alto nível, isso significa, de maneira sucinta, que ela não é executada utilizando somente o processador, assim como acontece com linguagens de baixo nível, como Assembly, por exemplo.<br />
<br />
É escrita em C, C++, e Scheme, usando a estrutura do compilador LLVM (para melhor entendimento, o compilador de C é o GCC, por exemplo), enquanto a maior parte da biblioteca padrão de Julia é implementada na própria Julia.<br />
<br />
Um fato importante sobre Julia para os programadores de Python é que todas as bibliotecas de Python são usáveis através de um comando simples: PyCall.<br />
<br />
Um fato importante sobre Julia para os programadores de C é que Julia possui APIs (Interfaces de Programação de Aplicativos) especiais para chamada de funções em C diretamente.<br />
<br />
== Velocidade ==<br />
<br />
De acordo com testes feitos pelos próprios criadores de Julia, sua velocidade é similar com a de C.<br />
<br />
<br />
<center>[[Arquivo:juliasvelocity.png|border]]<br />
Fonte: [https://julialang.org/benchmarks/]<br />
</center><br />
<br />
<br />
== Testes de Velocidade ==<br />
<br />
A fim de pessoalmente testar a velocidade da linguagem de programação, foi escrito um programa em Julia de maneira similar ao programa de Python para o FTCS aplicado na Equação de Difusão (também conhecida como Equação do Calor). <br />
<br />
A Equação da Difusão em uma dimensão pode ser escrita da forma:<br />
<br />
<center><math>\frac{df}{dt}=\frac{d^{2}f}{dx^{2}}</math></center><br />
<br />
No método de FTCS (Forward-Time Central-Space) definimos a derivada em t na forma não simetrizada (forward) e as derivadas em x na forma simetrizada:<br />
<br />
<br />
<center><math>\frac{df}{dt} = \frac{f(x, t+dt) - f(x,t)}{dt}</math></center><br />
<br />
<p><br />
<br />
<center><math>\frac{d^{2}f}{dx^{2}} = \frac{f(x+dx, t) + f(x-dx, t) - 2f(x,t)}{dx^{2}}</math></center><br />
<br />
E substuindo na equação da difusão, em notação discreta temos:<br />
<br />
<center><math>f_{j}^{n+1} = f_{j}^{n} + D\frac{dt}{(dx)^{2}}[f_{j+1}^{n} + f_{j-1}^{n} - 2 f_{j}^{n}]</math></center><br />
<br />
'''Observação:''' esse procedimento funciona bem se <math>k=D\frac{dt}{(dx)^{2}} <= 1/2</math>, segundo análise de estabilidade do método.<br />
<br />
<br />
Dessa forma, foi escrito um programa para integrar a Equação de Difusão através do método de FTCS nas linguagens Python e Julia.<br />
<br />
Para '''Python''':<br />
<pre><br />
//FTCS aplicado na equacao da difusao. Linguagem: PYTHON<br />
<br />
import copy<br />
import numpy as np<br />
import matplotlib.pyplot as plt<br />
<br />
def init():<br />
L=50;D=1.;dt=0.05;dx=1.;t=0;tmax=100.<br />
k=D*dt/(dx*dx) <br />
return L,k,dt,t,tmax<br />
<br />
L,k,dt,t,tmax = init()<br />
<br />
x = np.arange(0,L,1) <br />
f = np.zeros(x.shape)<br />
<br />
a = int(L/3)<br />
b = int(2*L/3)<br />
f[a:b]=1.<br />
f1 = copy.deepcopy(f) <br />
f2 = copy.deepcopy(f)<br />
<br />
while t<tmax:<br />
t+=dt<br />
f1[1:L-1]=f[1:L-1]+k*(f[0:L-2]+f[2:L]-2*f[1:L-1])<br />
f1[L-1]=f[L-1]+k*(f[L-2]+f[0]-2*f[L-1]) <br />
f1[0]=f[0]+k*(f[1]+f[L-1]-2*f[0]) <br />
f=copy.deepcopy(f1) <br />
<br />
sum0=sum(f1)<br />
sum1=sum(f2) <br />
<br />
print("Integral em t=0: %7.4f" % sum0)<br />
print("Integral em tmax: %7.4f" % sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
Em '''Julia''':<br />
<pre><br />
//FTCS aplicado na equacao da difusao. Linguagem: JULIA<br />
<br />
using PyPlot<br />
<br />
L=50<br />
D=1.<br />
dt=0.05<br />
dx=1.<br />
t=0<br />
tmax=100.<br />
k=D*dt/(dx*dx) <br />
<br />
x = collect(0:1:L-1)<br />
f = zeros(L)<br />
f1 = zeros(L)<br />
<br />
a = trunc(Int, L/3) <br />
b = trunc(Int, 2*L/3)<br />
<br />
f[a+1:b] .= 1.<br />
f2 = deepcopy(f)<br />
<br />
while t<tmax<br />
global t+=dt <br />
f1[2:L-1] = f[2:L-1] + k*(f[1:L-2] + f[3:L] - 2*f[2:L-1]) <br />
f1[L] = f[L] + k*(f[L-1] + f[1] - 2*f[L])<br />
f1[1] = f[1] + k*(f[2] + f[L] - 2*f[1]) <br />
global f = deepcopy(f1) <br />
end<br />
<br />
sum0 = sum(f1)<br />
sum1 = sum(f2)<br />
<br />
println("Integral em t=0: ", sum0)<br />
println("Integral em tmax: ", sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
Foi testado o tempo de execução da parte principal dos dois programas (isto é, sem fazer o gráfico dos resultados), através do timer do terminal, como mostra na próxima figura:<br />
<br />
<center>[[Arquivo:Ftcs_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o método de FTCS aplicado à Equação de Difusão<br />
</center><br />
<br />
É possível perceber, através da figura acima, que o tempo de execução de Python para o FTCS aplicado à Equação de Difusão é menor do que o de Julia. Em razão disso, foi testado um programa simples, como mostra abaixo, que incrementa uma variável 10 vezes, sendo o seu valor inicial 0.<br />
<br />
<br />
<center>[[Arquivo:For.png|border]]<br />
'''Legenda:''' Programa para incrementar o valor de uma variável, nesse caso ''i'', 10 vezes, escrito em Julia e em Python<br />
</center><br />
<br />
E posteriormente, novamente, foi testado o tempo de execução da parte principal dos programas através do terminal:<br />
<br />
<br />
<center>[[Arquivo:For_time.png|border]]<br />
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o programa que incrementa o valor da variável 10 vezes<br />
</center><br />
<br />
É possível perceber que para esse simples programa de incrementação, Python ainda obtém melhor performance do que Julia.</div>Raquelmhttp://fiscomp.if.ufrgs.br/index.php?title=Arquivo:For_time.png&diff=2468Arquivo:For time.png2020-01-06T22:40:33Z<p>Raquelm: </p>
<hr />
<div></div>Raquelmhttp://fiscomp.if.ufrgs.br/index.php?title=Arquivo:For.png&diff=2467Arquivo:For.png2020-01-06T22:40:20Z<p>Raquelm: </p>
<hr />
<div></div>Raquelmhttp://fiscomp.if.ufrgs.br/index.php?title=Arquivo:Ftcs_time.png&diff=2466Arquivo:Ftcs time.png2020-01-06T22:39:58Z<p>Raquelm: </p>
<hr />
<div></div>Raquelmhttp://fiscomp.if.ufrgs.br/index.php?title=Julia&diff=2465Julia2020-01-06T22:32:12Z<p>Raquelm: /* Testes de Velocidade */</p>
<hr />
<div>Julia é uma linguagem relativamente nova de programação que começou a ser desenvolvida em 2009 por Jeff Bezanson, Stefan Karpinski, Viral B. Shah, e Alan Edelman, um grupo do MIT. Ela foi oficialmente lançada para o mundo em 2012.<br />
<br />
Em uma entrevista, quando perguntaram a Alan o por quê do nome Julia, ele disse que numa conversa anos atrás alguém sugeriu que Julia seria um bom nome para uma linguagem de programação.<br />
<br />
Julia pode ser usada para propósitos gerais de programação, assim como Python, mas em sua criação foi visada a utilização de Julia para Cálculo Numérico.<br />
<br />
== Aspectos Gerais ==<br />
<br />
Julia é uma linguagem de alto nível, isso significa, de maneira sucinta, que ela não é executada utilizando somente o processador, assim como acontece com linguagens de baixo nível, como Assembly, por exemplo.<br />
<br />
É escrita em C, C++, e Scheme, usando a estrutura do compilador LLVM (para melhor entendimento, o compilador de C é o GCC, por exemplo), enquanto a maior parte da biblioteca padrão de Julia é implementada na própria Julia.<br />
<br />
Um fato importante sobre Julia para os programadores de Python é que todas as bibliotecas de Python são usáveis através de um comando simples: PyCall.<br />
<br />
Um fato importante sobre Julia para os programadores de C é que Julia possui APIs (Interfaces de Programação de Aplicativos) especiais para chamada de funções em C diretamente.<br />
<br />
== Velocidade ==<br />
<br />
De acordo com testes feitos pelos próprios criadores de Julia, sua velocidade é similar com a de C.<br />
<br />
<br />
<center>[[Arquivo:juliasvelocity.png|border]]<br />
Fonte: [https://julialang.org/benchmarks/]<br />
</center><br />
<br />
<br />
== Testes de Velocidade ==<br />
<br />
A fim de pessoalmente testar a velocidade da linguagem de programação, foi escrito um programa em Julia de maneira similar ao programa de Python para o FTCS aplicado na Equação de Difusão (também conhecida como Equação do Calor). <br />
<br />
A Equação da Difusão em uma dimensão pode ser escrita da forma:<br />
<br />
<center><math>\frac{df}{dt}=\frac{d^{2}f}{dx^{2}}</math></center><br />
<br />
No método de FTCS (Forward-Time Central-Space) definimos a derivada em t na forma não simetrizada (forward) e as derivadas em x na forma simetrizada:<br />
<br />
<br />
<center><math>\frac{df}{dt} = \frac{f(x, t+dt) - f(x,t)}{dt}</math></center><br />
<br />
<p><br />
<br />
<center><math>\frac{d^{2}f}{dx^{2}} = \frac{f(x+dx, t) + f(x-dx, t) - 2f(x,t)}{dx^{2}}</math></center><br />
<br />
E substuindo na equação da difusão, em notação discreta temos:<br />
<br />
<center><math>f_{j}^{n+1} = f_{j}^{n} + D\frac{dt}{(dx)^{2}}[f_{j+1}^{n} + f_{j-1}^{n} - 2 f_{j}^{n}]</math></center><br />
<br />
'''Observação:''' esse procedimento funciona bem se <math>k=D\frac{dt}{(dx)^{2}} <= 1/2</math>, segundo análise de estabilidade do método.<br />
<br />
<br />
Dessa forma, foi escrito um programa para integrar a Equação de Difusão através do método de FTCS nas linguagens Python e Julia.<br />
<br />
Para '''Python''':<br />
<pre><br />
//FTCS aplicado na equacao da difusao. Linguagem: PYTHON<br />
<br />
import copy<br />
import numpy as np<br />
import matplotlib.pyplot as plt<br />
<br />
def init():<br />
L=50;D=1.;dt=0.05;dx=1.;t=0;tmax=100.<br />
k=D*dt/(dx*dx) <br />
return L,k,dt,t,tmax<br />
<br />
L,k,dt,t,tmax = init()<br />
<br />
x = np.arange(0,L,1) <br />
f = np.zeros(x.shape)<br />
<br />
a = int(L/3)<br />
b = int(2*L/3)<br />
f[a:b]=1.<br />
f1 = copy.deepcopy(f) <br />
f2 = copy.deepcopy(f)<br />
<br />
while t<tmax:<br />
t+=dt<br />
f1[1:L-1]=f[1:L-1]+k*(f[0:L-2]+f[2:L]-2*f[1:L-1])<br />
f1[L-1]=f[L-1]+k*(f[L-2]+f[0]-2*f[L-1]) <br />
f1[0]=f[0]+k*(f[1]+f[L-1]-2*f[0]) <br />
f=copy.deepcopy(f1) <br />
<br />
sum0=sum(f1)<br />
sum1=sum(f2) <br />
<br />
print("Integral em t=0: %7.4f" % sum0)<br />
print("Integral em tmax: %7.4f" % sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre><br />
<br />
Em '''Julia''':<br />
<pre><br />
//FTCS aplicado na equacao da difusao. Linguagem: JULIA<br />
<br />
using PyPlot<br />
<br />
L=50<br />
D=1.<br />
dt=0.05<br />
dx=1.<br />
t=0<br />
tmax=100.<br />
k=D*dt/(dx*dx) <br />
<br />
x = collect(0:1:L-1)<br />
f = zeros(L)<br />
f1 = zeros(L)<br />
<br />
a = trunc(Int, L/3) <br />
b = trunc(Int, 2*L/3)<br />
<br />
f[a+1:b] .= 1.<br />
f2 = deepcopy(f)<br />
<br />
while t<tmax<br />
global t+=dt <br />
f1[2:L-1] = f[2:L-1] + k*(f[1:L-2] + f[3:L] - 2*f[2:L-1]) <br />
f1[L] = f[L] + k*(f[L-1] + f[1] - 2*f[L])<br />
f1[1] = f[1] + k*(f[2] + f[L] - 2*f[1]) <br />
global f = deepcopy(f1) <br />
end<br />
<br />
sum0 = sum(f1)<br />
sum1 = sum(f2)<br />
<br />
println("Integral em t=0: ", sum0)<br />
println("Integral em tmax: ", sum1)<br />
<br />
plt.plot(x,f,x,f2)<br />
plt.show()<br />
</pre></div>Raquelmhttp://fiscomp.if.ufrgs.br/index.php?title=Julia&diff=2464Julia2020-01-06T22:13:35Z<p>Raquelm: /* Testes de Velocidade */</p>
<hr />
<div>Julia é uma linguagem relativamente nova de programação que começou a ser desenvolvida em 2009 por Jeff Bezanson, Stefan Karpinski, Viral B. Shah, e Alan Edelman, um grupo do MIT. Ela foi oficialmente lançada para o mundo em 2012.<br />
<br />
Em uma entrevista, quando perguntaram a Alan o por quê do nome Julia, ele disse que numa conversa anos atrás alguém sugeriu que Julia seria um bom nome para uma linguagem de programação.<br />
<br />
Julia pode ser usada para propósitos gerais de programação, assim como Python, mas em sua criação foi visada a utilização de Julia para Cálculo Numérico.<br />
<br />
== Aspectos Gerais ==<br />
<br />
Julia é uma linguagem de alto nível, isso significa, de maneira sucinta, que ela não é executada utilizando somente o processador, assim como acontece com linguagens de baixo nível, como Assembly, por exemplo.<br />
<br />
É escrita em C, C++, e Scheme, usando a estrutura do compilador LLVM (para melhor entendimento, o compilador de C é o GCC, por exemplo), enquanto a maior parte da biblioteca padrão de Julia é implementada na própria Julia.<br />
<br />
Um fato importante sobre Julia para os programadores de Python é que todas as bibliotecas de Python são usáveis através de um comando simples: PyCall.<br />
<br />
Um fato importante sobre Julia para os programadores de C é que Julia possui APIs (Interfaces de Programação de Aplicativos) especiais para chamada de funções em C diretamente.<br />
<br />
== Velocidade ==<br />
<br />
De acordo com testes feitos pelos próprios criadores de Julia, sua velocidade é similar com a de C.<br />
<br />
<br />
<center>[[Arquivo:juliasvelocity.png|border]]<br />
Fonte: [https://julialang.org/benchmarks/]<br />
</center><br />
<br />
<br />
== Testes de Velocidade ==<br />
<br />
A fim de pessoalmente testar a velocidade da linguagem de programação, foi escrito um programa em Julia de maneira similar ao programa de Python para o FTCS aplicado na Equação de Difusão (também conhecida como Equação do Calor). <br />
<br />
A Equação da Difusão em uma dimensão pode ser escrita da forma:<br />
<br />
<center><math>\frac{df}{dt}=\frac{d^{2}f}{dx^{2}}</math></center><br />
<br />
No método de FTCS (Forward-Time Central-Space) definimos a derivada em t na forma não simetrizada (forward) e as derivadas em x na forma simetrizada:<br />
<br />
<br />
<center><math>\frac{df}{dt} = \frac{f(x, t+dt) - f(x,t)}{dt}</math></center><br />
<br />
<p><br />
<br />
<center><math>\frac{d^{2}f}{dx^{2}} = \frac{f(x+dx, t) + f(x-dx, t) - 2f(x,t)}{dx^{2}}</math></center><br />
<br />
E substuindo na equação da difusão, em notação discreta temos:<br />
<br />
<center><math>f_{j}^{n+1} = f_{j}^{n} + D\frac{dt}{(dx)^{2}}[f_{j+1}^{n} + f_{j-1}^{n} - 2 f_{j}^{n}]</math></center><br />
<br />
'''Observação:''' esse procedimento funciona bem se <math>k=D\frac{dt}{(dx)^{2}} <= 1/2</math>, segundo análise de estabilidade do método.</div>Raquelmhttp://fiscomp.if.ufrgs.br/index.php?title=Julia&diff=2463Julia2020-01-06T20:41:45Z<p>Raquelm: /* Aspectos Gerais */</p>
<hr />
<div>Julia é uma linguagem relativamente nova de programação que começou a ser desenvolvida em 2009 por Jeff Bezanson, Stefan Karpinski, Viral B. Shah, e Alan Edelman, um grupo do MIT. Ela foi oficialmente lançada para o mundo em 2012.<br />
<br />
Em uma entrevista, quando perguntaram a Alan o por quê do nome Julia, ele disse que numa conversa anos atrás alguém sugeriu que Julia seria um bom nome para uma linguagem de programação.<br />
<br />
Julia pode ser usada para propósitos gerais de programação, assim como Python, mas em sua criação foi visada a utilização de Julia para Cálculo Numérico.<br />
<br />
== Aspectos Gerais ==<br />
<br />
Julia é uma linguagem de alto nível, isso significa, de maneira sucinta, que ela não é executada utilizando somente o processador, assim como acontece com linguagens de baixo nível, como Assembly, por exemplo.<br />
<br />
É escrita em C, C++, e Scheme, usando a estrutura do compilador LLVM (para melhor entendimento, o compilador de C é o GCC, por exemplo), enquanto a maior parte da biblioteca padrão de Julia é implementada na própria Julia.<br />
<br />
Um fato importante sobre Julia para os programadores de Python é que todas as bibliotecas de Python são usáveis através de um comando simples: PyCall.<br />
<br />
Um fato importante sobre Julia para os programadores de C é que Julia possui APIs (Interfaces de Programação de Aplicativos) especiais para chamada de funções em C diretamente.<br />
<br />
== Velocidade ==<br />
<br />
De acordo com testes feitos pelos próprios criadores de Julia, sua velocidade é similar com a de C.<br />
<br />
<br />
<center>[[Arquivo:juliasvelocity.png|border]]<br />
Fonte: [https://julialang.org/benchmarks/]<br />
</center><br />
<br />
<br />
== Testes de Velocidade ==</div>Raquelmhttp://fiscomp.if.ufrgs.br/index.php?title=Julia&diff=2462Julia2020-01-06T20:40:56Z<p>Raquelm: </p>
<hr />
<div>Julia é uma linguagem relativamente nova de programação que começou a ser desenvolvida em 2009 por Jeff Bezanson, Stefan Karpinski, Viral B. Shah, e Alan Edelman, um grupo do MIT. Ela foi oficialmente lançada para o mundo em 2012.<br />
<br />
Em uma entrevista, quando perguntaram a Alan o por quê do nome Julia, ele disse que numa conversa anos atrás alguém sugeriu que Julia seria um bom nome para uma linguagem de programação.<br />
<br />
Julia pode ser usada para propósitos gerais de programação, assim como Python, mas em sua criação foi visada a utilização de Julia para Cálculo Numérico.<br />
<br />
== Aspectos Gerais ==<br />
<br />
Julia é uma linguagem de alto nível, isso significa, de maneira sucinta, que ela não é executada utilizando somente o processador, assim como acontece com linguagens de baixo nível, como Assembly, por exemplo.<br />
<br />
É escrita em C, C++, e Scheme, usando a estrutura do compilador LLVM (para melhor entendimento, o compilador de C é o GCC, por exemplo), enquanto a maior parte da biblioteca padrão de Julia é implementada na própria Julia.<br />
<br />
Um fato importante sobre Julia para os programadores de Python é que todas as bibliotecas de Python são usáveis através de um comando simples: PyCall.<br />
<br />
Um fato importante sobre JUlia para os programadores de C é que Julia possui APIs (Interfaces de Programação de Aplicativos) especiais para chamada de funções em C diretamente.<br />
<br />
== Velocidade ==<br />
<br />
De acordo com testes feitos pelos próprios criadores de Julia, sua velocidade é similar com a de C.<br />
<br />
<br />
<center>[[Arquivo:juliasvelocity.png|border]]<br />
Fonte: [https://julialang.org/benchmarks/]<br />
</center><br />
<br />
<br />
== Testes de Velocidade ==</div>Raquelmhttp://fiscomp.if.ufrgs.br/index.php?title=Julia&diff=2461Julia2020-01-06T20:39:31Z<p>Raquelm: </p>
<hr />
<div>Julia é uma linguagem relativamente nova de programação que começou a ser desenvolvida em 2009 por Jeff Bezanson, Stefan Karpinski, Viral B. Shah, e Alan Edelman, um grupo do MIT. Ela foi oficialmente lançada para o mundo em 2012.<br />
<br />
Em uma entrevista, quando perguntaram a Alan o por quê do nome Julia, ele disse que numa conversa anos atrás alguém sugeriu que Julia seria um bom nome para uma linguagem de programação.<br />
<br />
Julia pode ser usada para propósitos gerais de programação, assim como Python, mas em sua criação foi visada a utilização em Cálculo Numérico.<br />
<br />
== Aspectos Gerais ==<br />
<br />
Julia é uma linguagem de alto nível, isso significa, de maneira sucinta, que ela não é executada utilizando somente o processador, assim como acontece com linguagens de baixo nível, como Assembly, por exemplo.<br />
<br />
É escrita em C, C++, e Scheme, usando a estrutura do compilador LLVM (para melhor entendimento, o compilador de C é o GCC, por exemplo), enquanto a maior parte da biblioteca padrão de Julia é implementada na própria Julia.<br />
<br />
Um fato importante sobre Julia para os programadores de Python é que todas as bibliotecas de Python são usáveis através de um comando simples: PyCall.<br />
<br />
Um fato importante sobre JUlia para os programadores de C é que Julia possui APIs (Interfaces de Programação de Aplicativos) especiais para chamada de funções em C diretamente.<br />
<br />
== Velocidade ==<br />
<br />
De acordo com testes feitos pelos próprios criadores de Julia, sua velocidade é similar com a de C.<br />
<br />
<br />
<center>[[Arquivo:juliasvelocity.png|border]]<br />
Fonte: [https://julialang.org/benchmarks/]<br />
</center><br />
<br />
<br />
== Testes de Velocidade ==</div>Raquelmhttp://fiscomp.if.ufrgs.br/index.php?title=Julia&diff=2460Julia2020-01-06T20:38:54Z<p>Raquelm: Criou página com 'Julia é uma linguagem relativamente nova de programação que começou a ser desenvolvida em 2009 por Jeff Bezanson, Stefan Karpinski, Viral B. Shah, and Alan Edelman, um gru...'</p>
<hr />
<div>Julia é uma linguagem relativamente nova de programação que começou a ser desenvolvida em 2009 por Jeff Bezanson, Stefan Karpinski, Viral B. Shah, and Alan Edelman, um grupo do MIT. Ela foi oficialmente lançada para o mundo em 2012.<br />
<br />
Em uma entrevista, quando perguntaram a Alan o por quê do nome Julia, ele disse que numa conversa anos atrás alguém sugeriu que Julia seria um bom nome para uma linguagem de programação.<br />
<br />
Julia pode ser usada para propósitos gerais de programação, assim como Python, mas em sua criação foi visada a utilização em Cálculo Numérico.<br />
<br />
== Aspectos Gerais ==<br />
<br />
Julia é uma linguagem de alto nível, isso significa, de maneira sucinta, que ela não é executada utilizando somente o processador, assim como acontece com linguagens de baixo nível, como Assembly, por exemplo.<br />
<br />
É escrita em C, C++, e Scheme, usando a estrutura do compilador LLVM (para melhor entendimento, o compilador de C é o GCC, por exemplo), enquanto a maior parte da biblioteca padrão de Julia é implementada na própria Julia.<br />
<br />
Um fato importante sobre Julia para os programadores de Python é que todas as bibliotecas de Python são usáveis através de um comando simples: PyCall.<br />
<br />
Um fato importante sobre JUlia para os programadores de C é que Julia possui APIs (Interfaces de Programação de Aplicativos) especiais para chamada de funções em C diretamente.<br />
<br />
== Velocidade ==<br />
<br />
De acordo com testes feitos pelos próprios criadores de Julia, sua velocidade é similar com a de C.<br />
<br />
<br />
<center>[[Arquivo:juliasvelocity.png|border]]<br />
Fonte: [https://julialang.org/benchmarks/]<br />
</center><br />
<br />
<br />
== Testes de Velocidade ==</div>Raquelmhttp://fiscomp.if.ufrgs.br/index.php?title=Arquivo:Juliasvelocity.png&diff=2459Arquivo:Juliasvelocity.png2020-01-06T20:18:49Z<p>Raquelm: </p>
<hr />
<div></div>Raquelmhttp://fiscomp.if.ufrgs.br/index.php?title=M%C3%A9todos_computacionais&diff=2403Métodos computacionais2020-01-04T20:49:13Z<p>Raquelm: /* Ferramentas */</p>
<hr />
<div>Física computacional é uma abordagem da '''física teórica''' com o auxílio do computador essencialmente<br />
quando a complexidade do problema impossibilita o avanço pela via analítica e/ou porque os cálculos<br />
numéricos são longos demais para serem feitos sem automação.<br />
Alguns consideram a '''física computacional''' um terceiro (e mais recente) vértice do triângulo da maneira de se fazer física, onde os outros dois vértices são a '''física teórica''' e a '''física experimental'''.<br />
<br />
'''Métodos computacionais''' é a disciplina onde estudamos ferramentas, métodos e algoritmos numéricos para a resolução de problemas de física onde uma abordagem analítica é extremamente complexa ou impossível.<br />
<br />
Alguns exemplos de aplicação são: a solução numérica de equações diferenciais ordinárias, integração numérica via métodos de aproximação ou estatísticos como método de Monte Carlo, equações diferencias parciais como as equações de Maxwell e de Schroedinger, métodos matriciais para a solução de problemas de autovalor e autovetor como os encontrados na Mecânica Quântica.<br />
<br />
==Breve Historia da Computação==<br />
<br />
De Conrad Zuse (1941) ao IBM Blue/Gene (2006)<br />
<br />
==Arquitectura==<br />
<br />
[http://en.wikipedia.org/wiki/Image:Personal_computer%2C_exploded_5.svg Diagrama de PC]<br />
<br />
== Ferramentas ==<br />
===== [[Comandos Unix/Linux]] =====<br />
===== [[Gnuplot]] e [[xmgrace]] =====<br />
===== [[LaTex]] =====<br />
===== [[FORTRAN]] =====<br />
===== [[C]] =====<br />
===== [[Julia]] =====<br />
<br />
== Métodos Computacionais A ==<br />
===== [[Derivada Numérica]] =====<br />
===== [[Integração Numérica]] =====<br />
===== [[Interpolação e extrapolação]] =====<br />
====== [[Fórmula de Lagrange]]======<br />
====== [[Spline cúbico]]======<br />
<!--- ===== [[Eliminação gaussiana e retro-substituição]] ===== ---><br />
===== [[Zeros de Funções]]=====<br />
===== [[Mínimos Quadrados]] =====<br />
===== [[Listas de exercícios]] =====<br />
====== [[Área 1]] ======<br />
====== [[Área 2]] ======<br />
====== [[Área 3]] ======<br />
<br />
== Métodos Computacionais B ==<br />
<br />
===== [[Integração numérica de equações diferenciais ordinárias]] =====<br />
<br />
<br />
===== [[Métodos multipassos]]=====<br />
<br />
===== [[Métodos de passo variável]]=====<br />
<br />
===== [[Aplicações (Mapas)]]=====<br />
<br />
===== [[Números Aleatórios]]=====<br />
<br />
===== [[Histogramas e Densidade de Probabilidade ]] =====<br />
<br />
===== [[Método de Monte Carlo (integração numérica)]]=====<br />
<br />
<br />
== Métodos Computacionais C ==<br />
<br />
===== [[Equações Diferenciais Parciais]] =====<br />
<br />
=====[[Grupo1 - Dif em 2D]] =====<br />
<br />
=====[[Grupo2 - Ondas1]]=====<br />
<br />
=====[[Grupo3 - Ondas2]]=====<br />
<br />
=====[[Grupo4 - FFT]]=====<br />
<br />
=====[[Grupo5 - Eq. Schroedinger]]=====<br />
<br />
<br />
=====[[Grupo - Ising 2D]]=====<br />
<br />
===== [[Monte Carlo]] =====<br />
<br />
=====[[Grupo - Lennard Jones]]=====<br />
<br />
=====[[Grupo - BOIDS]]=====<br />
<br />
=====[[Grupo - Tráfego]]=====<br />
<br />
===== [[Teste_conv]] =====<br />
<br />
===== [[Teste2]] =====<br />
<br />
===== [[Grupo - Dilema Do Prisioneiro]] =====<br />
<br />
===== [[Grupo - Modelo Sznajd]] =====<br />
<br />
=====[[Grupo - Modelo de Potts]]=====<br />
<br />
=====[[Grupo - Conservação do Parâmetro de Ordem]]=====<br />
<br />
=====[[ Movimento Coletivo ]] =====<br />
<br />
=====[[Grupo - Modelo de Szabó]]=====<br />
<br />
=====[[ Ressonância Estocástica ]] =====<br />
<br />
=====[[Grupo - Eqs. de Schrödinger não-lineares acopladas]]=====</div>Raquelm