Introdução à linguagem de programação Julia

(1)

Introdução à linguagem de programação Julia

Prof. Angelo Aliano Filho

UTFPR Universidade Tecnológica Federal do Paraná

(2)

Sumário

1 Instalação e introdução 2 Operações matemáticas 3 Vetores e matrizes 4 Plotando grácos 5 Functions 6 Estruturas de repetição 7 Pacotes especiais

(3)

Sumário

(4)

Instalação e introdução

Porque usarmos linguagem Julia?

A computação cientíca tem tradicionalmente exigido o mais alto desempenho possível.

A linguagem de programação Julia é uma linguagem dinâmica exível, apropriada para computação cientíca e numérica, com um desempenho comparável às linguagens tradicionais.

Julia apresenta tipagem opcional, despacho múltiplo, e bom desempenho, alcançado usando inferência de tipo e compilação just-in-time (JIT)

Julia proporciona facilidade e expressividade para programação numérica de alto nível, da mesma forma que linguagens como R, MATLAB, e Python, mas também suporta programação geral.

(5)

Instalação e introdução

Porque usarmos linguagem Julia?

As justicativas mais signicativas são: Open source

Não há necessidade de vetorizar o código para o desempenho; o código desvetorizado é rápido.

O core da linguagem impõe muito pouco; a base Julia e a

biblioteca padrão são escritas na própria Julia, incluindo operações primitivas como a aritmética inteira.

Chamar diretamente as funções C (não são necessários invólucros ou APIs especiais).

Bom desempenho, aproximando-se das linguagens estaticamente compiladas como a C.

(6)

Instalação e introdução

Sucesso da linguagem Julia atualmente

Mais de 3.500 pacotes registrados Mais de 35 milhões de downloads 78% de crescimento anual

É útil lembrar também de uma comunidade para discutir e tirar dúvidas: só acessar: discourse.julialang.org após realizar um pequeno cadastro

(7)

Instalação e introdução

Tabela:Crescimento da linguagem Julia - alguma métricas

Total cumulativo Total cumulativo Crescimento desde 2018 desde 2019

Total de download 1,8 milhão 3,2 milhões +78%

Total de pacotes 1.688 2.462 +46%

Número de novos artigos com citação 93 253 +172% Fórum (questões) 8.620 16.363 +90% Número de novos iniciantes 9,626 19,472 +102% Citações do artigo: 613 1.048 +71% A fresh Approach to numerical Computing (2017)

(8)

Instalação e introdução

2012 2013 2014 2015 2016 2017 2018 2019 0 1 2 3 ·104 # do wnl oads

(9)

Instalação e introdução

C Julia Python MATLAB R

0 10 20 1 1.11 1.22 2.11 23 sp eed up em relação a C

(10)

Instalação e introdução

Instalação do Julia Professional

Método 1: diretamente do site:

Acesse https://juliacomputing.com/products/juliapro Escolher o sistema operacional. O acesso dará a versão mais atual da linguagem (v1.5.0-1).

Fazer um cadastro com e-mail da UTFPR

(11)

Instalação e introdução

(12)

Instalação e introdução

(13)

Instalação e introdução

Método 2: acesso a versões mais antigas e instalação em dois passos: Acessar https://julialang.org/downloads/oldreleases/ Escolher a versão e baixar o executável.

Em minha página pessoal há também (versão 1.0.4): acesse http://paginapessoal.utfpr.edu.br/angeloaliano em seguida na pasta Linguagem de programação Julia.

(14)

Instalação e introdução

(15)

Instalação e introdução

(16)

Instalação e introdução

(17)

Instalação e introdução

Método 2: acesso a versões mais antigas e instalação em dois passos: Acessar https://atom.io/

Faça o download do editor ATOM Em seguida, rode o executável baixado

Precisamos, agora, congurar o ATOM para a linguagem Julia e escrever os códigos para compilação

(18)

Instalação e introdução

Conguração do ambiente ATOM: Abra o ATOM.

Vá em settings install para instalar os pacotes para o ATOM Na caixinha install Packages digite uber-juno e dê um enter para instalar o pacote uber-juno clicando em install. Este pacote serve para congurar o ATOM para a linguagem Julia

(19)

Instalação e introdução

(20)

Instalação e introdução

(21)

Instalação e introdução

Conguração do ambiente ATOM:

Depois disso, vá em settings packages julia-client Clique em settings

Insira o caminho de onde está intalado o executável ...\JuliaPro-1.0.4.1\Julia-1.0.4\bin\julia.exe

(22)

Instalação e introdução

(23)

Instalação e introdução

Primeiros passos

A forma mais fácil de aprender e experimentar com Julia é iniciar uma sessão interativa REPL na linha de comando.

Alternativamente, você pode criar um arquivo e salvá-lo no formato .jl e compilar cada linha selecionando-a e dando ctrl+enter ou pressionar o pequeno triângulo.

(24)

Instalação e introdução

(25)

Instalação e introdução

(26)

Operações matemáticas

Primeiros passos

Para sair da sessão interactiva, digite ctrl+d ou digite exit() Se uma expressão é introduzida numa sessão interativa com um ponto-e-vírgula, o seu valor não é mostrado. Caso contrário é. A variável aans está ligada ao valor da última expressão avaliada, quer seja mostrada ou não

Para avaliar expressões escritas num arquivo fonte.jl, escreva include("file.jl").

Para limpar o prompt de comando, só digitar ctrl+l Todo comentário é inserido ao colocarmos #

(27)

Sumário

(28)

Operações matemáticas

Tabela:Alguns operadores matemáticos

Expressão Nome Descrição

x+y Soma binária Executa adição

x-y Subtração binária Executa subtração

x*y Multiplicação binária Executa multiplicação

x\y Divisão Executa divisão

x/y Divisão inversa Executa divisão inversa

x^y Potenciação Executa a potenciação

(29)

Operações matemáticas

Efetuando cálculos aritméticos básicos

É recomendável que cada explicação seja acompanhada em tempo real. Você pode criar um \arquivo1.jl para fazer os testes aritméticos a seguir.

Números em formato racional são expressos com o comando //. Por exemplo: 2//3 + 7//13 resulta em 47//39.

Sem as barras duplas a conta é feita em ponto utuante, ie, 2/3 + 7/13 resulta em 1.205.

Notação inxa: +(3,4,7) resulta em 14 que o mesmo que 3+4+7 Operação de potência são feita ao usarmos ^. Exemplo: 2^5 resulta em 32

(30)

Operações matemáticas

Priorização das operações: 1 + 3*2 resulta em 7 ao passo que (1+3)*2 resulta em 8.

Podemos denir/declarar variáveis: exemplo a=2;b=3 quando compilado (ctrl+enter) resulta armazena o resultado. Quando compilamos a+b o resultado é 5.

Cuidado: no aquivo .jl compilar linha por linha para evitar erro not defined

(31)

Operações matemáticas

Algumas constantes pré-denidas: pi,e,im exp(2) é a o mesmo que e2_.

Tentamos executar: F=10

d=5

\theta=30*pi/180 \tau=F*d*cos(\theta)

a="o valor de \tau é $\tau"

(32)

Operações matemáticas

Efetuando cálculos aritméticos vetorizados

Basta inserir um . antes do operador.

Por exemplo, [1,2,3]^3 não é denida, ao passo que [1,2,3].^3 efetua o cubo elemento a elemento, produzindo [1,8,27]

Do mesmo modo, se quisermos as raízes quadradas de cada componente do vetor [1,2,3] damos o comando sqrt.([1,2,3])

(33)

Operações matemáticas

Tabela:Alguns operadores e testes matemáticos

Operador Nome

== Igualdade

!= Diferente

<,<= Menor, Menor igual

>,>= Maior, Maior igual

isequal(x,y) Testa se x e \verb|y| são iguais isfinite(x) Testa se x é nito

isinf(x) Testa se x é innito

(34)

Operações matemáticas

Tabela:Algumas funções matemáticas

Operador Descrição Operador Descrição

round(x) Arredonda hypot(x,y) Calcula a hipotenusa round(x),digits=n Arredonda com n casas exp(x) Exponencial natural floor(x) Arredonda para baixo log(x) Logaritmo natural ceil(x) Arredonda para cima log(b,x) Logaritmo de base b abs(x) Calcula o módulo sin,cos,tan,... Funções trigonométricas sign(x) Determina o sinal sind,cosd,tand,... Funções trigonométricas sqrt(x) Raiz quadrada com argumento em radiano cbrt(x) Raiz cúbica Demais funções Rode o pacote SpecialFunctions.jl

Toda aritmética com números complexos é feita bastando considerar i =√−1 com o comando im

(35)

Operações matemáticas em formato simbólico

Em formato simbólico poderemos efetuar algumas operações matemáticas; só instalar o pacote SymEngine e depois using SymEngine

Denimos das variáveis simbólicas do seguinte modo: a,b = symbols("x y") ou @vars x y

Por exemplo, denimos a expressão simbólica y = x2_+y2

y2₊₁ do

seguinte modo:

z = (x^2+y^2)/(y^2+1);

Se quisermos encontrar, por exemplo, as derivadas parciais de ordem 2 desta função entramos com o comando diff:

dzdx = diff(z,x,2) dzdy = diff(z,y,2)

(36)

Operações matemáticas em formato simbólico

Para quem usa o LA_{TEX, instalar e rodar o pacote Latexify é útil.}

Após obtermos dzdx e dzdy, podemos transformar o resultado em código LA_TEX: Cod_Lat = latexify(dfdy) para termos: −8 · y2 (1 + y2₎2 − 2 · x2_{+ y}2 (1 + y2₎2 + 8 · x2_{+ y}2_{· y}2 (1 + y2₎3 + 2 · 1 + y 2−1

(eu não z nada, apenas comandos Julia!) Podemos também expandir expressões: z = expand((x+2y)^4)

(37)

Operações matemáticas em formato simbólico

Podemos fazer substituição de expressões simbólicas em outras. Veja o exemplo: z = x*y^3 A = expand(A(y=> 1-2x)) resulta em x - 6*x^2 + 12*x^3 - 8*x^4 Outro exemplo: f(x) = cos(x)*sin(x) g(x) = diff(f(x),x,3) subs(g(x),x,pi) resulta em -4 Substituições múltiplas: subs(x^2+(y-2)^2, a=>2, b=>3) resulta em 5.

(38)

Operações matemáticas em formato simbólico

Podemos trabalhar com matrizes. Veja o exemplo: A = [symbols("a_$i$j") for i in 1:3, j in 1:4]

que, se convertida em LA_{TEX(latexify(A)) se transforma em:}

  a11 a12 a13 a14 a21 a22 a23 a24 a31 a32 a33 a34   (1)

Podemos ainda fazer operações com esta matriz: B = A*[1;2;3;4]

resultando em

3-element Array{Basic,1}:

a_11 + 2*a_12 + 3*a_13 + 4*a_14 a_21 + 2*a_22 + 3*a_23 + 4*a_24 a_31 + 2*a_32 + 3*a_33 + 4*a_34

(39)

Sumário

(40)

Vetores e matrizes

Uma matriz é uma coleção ordenada de elementos. É

frequentemente indicada com parênteses retos e os elementos separados por vírgula.

Em Júlia, as matrizes são utilizadas para listas, vetores, tabelas, e matrizes.

Uma matriz unidimensional atua como um vector ou lista. Uma matriz 2-D pode ser usada como uma tabela ou matriz. E matrizes 3-D ou mais são pensadas de forma semelhante como matrizes multi-dimensionais.

(41)

Vetores e matrizes

Criando arrays

Aqui uma maneira de criar um array simples de uma dimensão: a = [1, 2, 3, 4, 5]

Outro exemplo:

s = ["Este", "é", "um", "array", "de", "strings"] ou ainda um array de funções:

(42)

Vetores e matrizes

Criando arrays

Criando arrays com tipos especícos: a = int64[1,2,3,4]

Arrays vazios: b = Float64[]

Compare os comandos: [1,2,3,4,5]; [1 2 3 4 5]

no primeiro caso o array tem dimensão 1, na segunda dimensão 2 (1 linha e 5 colunas)

(43)

Vetores e matrizes

Criando arrays

Criando matrizes: basta separar cada linha por ;. Exemplo: A = [1 2 3; 4 5 6]

resulta numa matriz 2 × 3.

Arrays aleatórios: por exemplo, se queremos uma matriz 5 × 3 aleatória, podemos usar:

A = rand(5,3)

Podemos criar arrays usando intervalos: a=1:0.1:10 cria um array com primeiro elemento igual a 0, de 0.1 em 0.1 até chegar em 10. O mesmo seria produzido usando o comando collect(1:0.1:10) Podemos dar um incremento negativo: collect(10:-0.2:1)

(44)

Vetores e matrizes

Criando arrays

Outra função útil é range(). Por exemplo:

range(1,length=12,stop=100) cria um vetor de 12 componentes igualmente espaçadas, iniciando em 1 e terminando em 100. Basta inserir

collect(range(1, length=12, stop=100)) Podemos calcular 10n _{para n em um array usando:}

exp10.(range(2.0, stop=3.0, length=5))

Note que, no comando collect você não precisa usar um looping para coletar todos os valores do array.

(45)

Vetores e matrizes

Criando arrays

Utilizando geradores para criar matrizes:

Por exemplo, se quisermos um array [1,4,9,16,25] basta usar o comando

[n^2 for n in 1:5]

E podemos usar dois iteradores. Por exemplo: [r*c for r in 1:5, c in 1:5] produz: 5x5 Array{Int64,2}: 1 2 3 4 5 2 4 6 8 10 3 6 9 12 15 4 8 12 16 20 5 10 15 20 25

(46)

Vetores e matrizes

Criando arrays

Podemos acrescentar um if na instrução. Por exemplo, [i^2 for i=1:10 if i <= 5]' produz [1 4 9 16 25] porque transpomos o array com o apóstrofe '.

Podemos criar uma matriz 2 × 3 de zeros introduzindo zeros(2,3). Se quisermos que ela seja inteira, basta utilizar zeros(Int64,2,3) Matriz de 1's pode ser criada de maneira similar: ones(2,3)

(47)

Vetores e matrizes

Criando arrays

O comando rand(m,n) cria uma matriz m × n cuja entrada é um número aleatório entre 0 e 1.

Já rand(1:10,m,n) cria uma matriz m × n cuja entrada é um número inteiro de 1 a 10.

Para distribuição normal, utilize randn(m,n) com média 0 e desvio padrão 1.

Comando fill é útil para replicar valores. Experimente fill(42,9,3)

Podemos também criar arrays de arrays: veja em a=Array[[1, 2], [3,4]]

(48)

Vetores e matrizes

Todas as funções disponíveis para trabalhar em matrizes podem ser utilizadas (se as dimensões o permitirem) como matrizes. Uma forma rápida de escrever uma matriz é separar os elementos usando espaços (para fazer linhas) e usar ponto-e-vírgula para separar as linhas.

Acessando elementos de arrays

[[1, 2, 3] [4, 5, 6]] produz uma matriz 3 × 2

[[1, 2, 3], [4, 5, 6]] produz uma matriz um array de array Para separar os elementos de uma mesma linha podemos omitir as vírgulas juntamente com [ ]

Assim, [[1 2 3];[4 5 6]] e [1 2 3;4 5 6] geram o mesmo objeto

(49)

Vetores e matrizes

Para acessar aos elementos de uma matriz, seguir o nome da matriz pelo número do elemento entre parênteses retos.

Experimente a=[10,20,30,40] e a[3] resulta em 30

O primeiro elemento da lista é o índice 1; o último é conseguido com a[end] para dar 40

Podemos fornecer um conjunto de índices, entre parênteses: a[1,3,4] produz 10,30,40

Pode-se selecionar os elementos com true e false: a[[true,false,true]] gera 10,30

(50)

Vetores e matrizes

Se a=[1 2 3;4 5 6;7 8 9] e queremos a segunda coluna, basta digitar a[:,2]. Se queremos a terceira linha, use a[3,:]

Gere o vetor: r = rand(0:10, 10). Para achar o maior ou o menor elemento desta lista, basta usar maximum(r) ou minimum(r) Para determinar o índice onde ocorre o máximo, basta usar o comando findmax que ele retorna o máximo (primeiro argumento) e o índice que ele aparece (segundo argumento)

(51)

Vetores e matrizes

Encontrando elementos em arrays

Se quisermos saber se um dado elemento está numa lista, use a função in(). Exemplo, se a=1:10, então 3 \in a resulta em true Há um conjunto de funções do tipo nd: findall(),

findfirst() e findlast(), que são usadas para obter indices de arrays. Vamos exemplicar.

Seja a = [2,3,5,7,11,13,17,19,23,29].

Primeira ocorrência de um número: findfirst(isequal(13),a) resulta em 6

(52)

Vetores e matrizes

Encontrando elementos em arrays

findall() retorna uma array de indices onde a função retorna true quando aplicada. Exemplo: findall(isinteger,a) retorna 1,...,10 ou ainda findall(a.<= 13) resulta em 1,...,6 Agora, findlast(a .<=13) retorna 6;

Outro exemplo: se b=[0 1 0 0 1], então findlast(b .== 1) resulta em 5

(53)

Vetores e matrizes

Outras funções

Precisamos rodar o pacote Pkg.add(Statistics) e em seguida using Statistics. Suponha a=[1,4,7,-1,3,7]

sum(a) retorna 21 prod(a) retorna -588 mean(a) retorna 3.5 std(a) retorna 3.209 middle(a) retorna 3

(54)

Vetores e matrizes

Outras funções

Pacote combinatório: Pkg.add(Combinatorics) e em seguida using Combinatorics.

Então collect(permutations(a)) resulta num array de arrays com todas as permutações deste conjunto (as 720!)

collect(combinations(a,3)) retorna todas as combinações dos elementos de a, tomados 3 a 3.

length() retorna o comprimento de um vetor. size() retorna a dimensão de uma matriz.

(55)

Vetores e matrizes

Modicando o conteúdo de arrays

Seja a=collect(1:10). Para adicionar itens no nal de um array, utilize push!(a,20).

Para adicionar um item na frente, use pushfirst!(a,0) Para inserir um elemento num array em um certo indice, use splice!(). Suponha a=[1,2,3,5]. Usamos splice!(a,4,23) resultará em a=[1,2,3,23]

Suponha a=[1,2,3,5], então splice!(a,3:4,3:5) resulta em a=[1,2,3,4,5]

A mesma função pode ser usada para remover elementos de uma lista. Suponha a=collect(1:10). Então splice(a,5) resulta na mesma lista sem o 5

(56)

Vetores e matrizes

Operações aritméticas com matrizes

Considere A=reshape(1:16,4,4) e B=ones(4,4) e o pacote LinearAlgebra

Para calcular A + B basta usar A+B Para calcular AB basta usar A*B

Para calcular AB elemento a elemento, basta usar A.*B Para calcular a inversa de A (se ela existir), use inv(A) Para somar 1 em todas as entradas, basta utilizar A .+ 1

(57)

Vetores e matrizes

Se quisermos saber quais elementos de A são menores que 6, basta utilizar A .< 6.

Podemos multiplicar matriz por vetor se as dimensões são compatíveis. Se A=reshape(1:12,3,4) e v=collect(1:4) então A*v é bem denida.

O produto interno de dois vetores é usado com o comando dot() ou digitando \cdot e teclando tab em seguida.

(58)

Vetores e matrizes

Se quisermos saber quais são os autovalores de A basta compilar eigvals(A)

Se quisermos saber quais são os autovetores de A basta compilar eigvecs(A)

Para determinar a fatoração LU de A basta entrar com (L,U,P) = factorize(A), onde P é a matriz de permutação. Se A for simétrica, podemos fazer a fatoração de Cholesky de A com o comando R = cholesky(A)

(59)

Vetores e matrizes

Concatenando matrizes

Usaremos as funções hcat() (adiciona na horizontal) e vcat() (adiciona na vertical) para juntar matrizes se suas dimensões permitirem. Considere A = reshape(1:12, 3, 4) e

B = reshape(100:100:1200, 3, 4) hcat(A, B) adiciona B na frente de A hcat(A, B) adiciona B abaixo de A vec(A) transforma A em um vetor

Seja: a = Array[[1, 2], [3, 4], [5, 6]]. Então hcat(a...) converte o array de arrays em uma matriz.

(60)

Vetores e matrizes

Extendendo arrays

Muitas vezes deseja-se criar uma matriz e depois acrescentar-lhe mais elementos. Embora possa fazer isto com vcat() e hcat(), esteja ciente de que ambas as operações criam novas matrizes temporárias e copiam elementos, por isso nem sempre produzem o código mais rápido.

Uma maneira melhor é usar o push()! Esta é uma operação eciente que alarga a matriz.

Considere o código: a = [] for i = 1:80 push!(a, i) end cria [1,2,...,80]

(61)

Vetores e matrizes

Extendendo arrays

Para converter o array produzido em uma matriz, basta utilizar reshape(a,10,:) para ter uma matriz de 10 linha e tantas colunas que forem necessárias.

push!() não permite trabalhar com elementos bidimensionais, apenas unidimensionais

det(A) calcula o determinante de A rank(A) determina o posto de A

(62)

Vetores e matrizes

Usando funções em matrizes

Considere A=reshape(1:9,3,3).

sum(A) calcula a soma de todos os elementos de A. sum(A, dims=(1)) soma cada coluna.

sum(A, dims=(2)) soma cada linha.

mean(A) calcula a média dos elementos de A (podemos considerar a dimensão também)

(63)

Vetores e matrizes

Usando funções em matrizes

Sejam A = rand(-1:2:1, 3, 3) e B = rand(-2:4:2, 3, 3). min.(A,B) retorna uma nova matriz cuja componente é menor elemento correspondente entre A e B

norm(x,p) determina a norma p do vetor x norm(A,p) determina a norma p da matriz A p = ∞ também funciona!

(64)

Vetores e matrizes

Sorting arrays

Julia tem uma função sort() exível que devolve uma cópia ordenada de um array, e uma versão de sort!() que muda o array para que seja ordenado. Seja rp=randperm(10) (precisa rodar o pacote Random)

\sort(rp) ordena o vetor em ordem crescente

\sort(rp,rev=true) ordena o vetor em ordem decrescente Se A=reshape(rand(1:20, 20), 4, 5) então:

I sort(A, dims=(1)) ordena cada coluna I sort(A, dims=(2)) ordena cada linha

(65)

Vetores e matrizes

Sorting arrays

A função sortperm() é semelhante à sort(), mas não devolve uma cópia ordenada da colecção. Em vez disso, devolve uma lista de índices que poderiam ser aplicados à coleção para produzir uma versão ordenada.

Seja r = rand(100:110, 10), então sortperm(r) devolve os indices do vetor r que resultam na ordenação crescente

Efeito pode ser conseguido com uma ordenação decrescente usando sortperm(r,rev=true)

(66)

Sumário

(67)

Plotando grácos

Para plotar grácos, precisamos instalar o pacote Plots e inserir using Plots; plotly();. Mais detalhes, consultar em

https://docs.juliaplots.org/latest/generated/plotly/. Podemos plotar uma lista de

valores do seguinte modo: seja a=rand(1:10,10) então plot(a) fornece uma poligonal Criando outro vetor, digamos b=rand(1:10,10) e dando plot!(b), inserimos na mesma imagem anterior a nova

poligonal

Podemos, assim que a gura for gerada, dar o comando savefig("nome_da_figura") e salvá-la.

(68)

Plotando grácos

Suponha a=rand(1:10,10) e b=rand(1:10,10). Se quisermos plotar as coordenadas (ai, bi), i = 1, · · · , 10(sem

ligá-las) basta utilizar o comando scatter(a,b) Se quisermos plotar (i, ai) e

(j, bj)separadamente, usamos

(69)

Plotando grácos

Podemos plotar funções na variável x. Seja

f (x) = −7.65 sin(x) + 9.87 sin(2x + 206), 1 ≤ x ≤ 335 é plotada com comando plot(f,1:365) antes denindo que f(x)=-7.65 \sin(x) + 9.87sin(2x + 206)

e podemos inserir mais funções na mesma tela lembrando de usar o comando plot!() para a nova função

(70)

Plotando grácos

Customização

Considere x=1:10 e y=rand(10,2) Agora dê o comando

\verb!plot(x,y,title="two lines",label=["Line 1" "Line 2"],lw=3)! Como output, obtemos:

(71)

Plotando grácos

Customização

Se quisermos mudar o nome do eixo x por exemplo, basta acrescentar

xlabel!(Meu eixo x) Se quisermos trocar a cor das linhas, basta acrescentar color=["yellow" "red"] Se quisermos alterar as marcas, acrescente

(72)

Plotando grácos

Podemos combinar várias parcelas como sub-quadrantes utilizando layouts.

Customização

Suponhamos que temos 4 séries com dez pontos cada e queremos esboça-las uma abaixo da outra.

Podemos fazer isto dando o comando

y = rand(10, 4)

(73)

Plotando grácos

Podemos combinar várias parcelas como sub-quadrantes utilizando layouts.

Customização

Suponhamos que temos 4 séries com dez pontos cada e queremos esboça-las uma abaixo da outra.

Podemos fazer isto dando o comando

y = rand(10, 4)

(74)

Plotando grácos

Podemos misturar grácos de diferentes tipos. Veja: p1 = plot(x, y) #4 linhas

p2 = scatter(x, y) #Faça só os pontos p3 = plot(x, y, xlabel = "Este tem label",

lw = 3, title = "Subtitulo")

p4 = histogram(x, y[:,1]) #4 histogramas

(75)

Plotando grácos

Customização

Podemos preencher áreas abaixo de funções. Veja o código abaixo: plot(0:0.01:pi, sin.(0:0.01:pi), fillrange = 0.0, fillalpha = 0.5, fillcolor = :blue )

(76)

Plotando grácos

Podemos fazer histogramas: x = randn(1000)

p = histogram(x,color="blue") savefig("hist")

Um gráco de barras é feito de forma similar, trocando histogram por bar

(77)

Plotando grácos

Podemos fazer grácos em coordenadas polares. Veja:

Customização

Insira os comandos

theta = 0:2*pi/1000:2*pi+2*pi/1000 r=(cos.(4*theta))

(78)

Plotando grácos

Podemos fazer grácos em 3D, como curvas vetoriais. Veja:

Customização Insira os comandos t=0:pi/200:7*pi x=cos.(t) y=sin.(t) plot3d(x,y,t,lw=2,leg=false)

(79)

Plotando grácos

Podemos fazer grácos em 3D, como superfícies. Veja:

Customização Insira os comandos x=-1:0.01:1 y=-1:0.01:1 h(x,y)=x^2-y^2; surface(x,y,h)

(80)

Sumário

(81)

Functions

Em Júlia, uma função é um objeto que mapeia uma conjunto argumento para valores de retorno.

As funções Júlia não são funções puramente matemáticas, porque podem ser alteradas e ser afetadas pelo estado global do programa. A sintaxe básica para denir funções em Júlia é:

function nomefuncao(args) expressao-1 expressao-2 expressao-3 ... expressao-n end

Esta função aceita os argumentos args e executa cada comando expressao-i

(82)

Functions

Um exemplo de function é: function f(x,y)

x + y end

f (generic function with 1 method)

Esta função aceita dois argumentos x e y e retorna o valor da última expressão avaliada, que é x + y.

(83)

Functions

Existe uma segunda sintaxe, mais concisa, para denir uma função em Júlia.

A sintaxe tradicional da declaração da função demonstrada acima é equivalente à seguinte forma compacta de atribuição:

f(x,y) = x + y

f (generic function with 1 method)

A forma de atribuição, o corpo da função deve ser uma única expressão, embora possa ser uma expressão com vários argumentos A função é chamada usando parêntesis: f(2,3) resulta em 5

(84)

Functions

Passagem de Argumentos

O valor devolvido por uma função é o valor da última expressão avaliada

A palavra-chave return faz com que uma função retorne imediatamente o objeto desejado

Exemplo:

function g(x,y)

return (x*y,x + y) end

(85)

Functions

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

(86)

Functions

Função dentro de uma função

using Plots plotly() function Grafico_polar(theta,r,a,b) plot(theta,r, proj=:polar) end theta = a:0.001:b; r = cos.(5*theta) Grafico_polar(theta,r,0,2*pi)

(87)

Functions

Número variável de argumentos

É possível denir funções com argumentos opcionais, para que a função possa utilizar padrões sensíveis se não forem fornecidos valores especícos. É fornecido um símbolo e um valor por denição na lista de argumentos:

function xyzpos(x, y, z=0) println("$x, $y, $z") end

(88)

Functions

Número variável de argumentos

Quando chamamos esta função, se não fornecermos o terceiro argumento, a variável z é denida em 0 e usa os demais valores normalmente:

xyzpos(1,2) 1, 2, 0

xyzpos(1,2,3) 1, 2, 3

(89)

Functions

Variáveis locais e funções

Veja a função:

function teste(a,b,c) subtotal = a + b + c end

Inserindo teste(1,2,3) obtemos 6

Porém, ao chamar subtotal aparece o erro

(90)

Functions

Função map

Se já tiver uma função e uma matriz, pode chamar a função para cada elemento da matriz utilizando o map. Isto chama a função para cada elemento, recolhe os resultados, e devolve-os num array. Este processo é chamado de mapeamento.

a=1:10; map(sin, a)

resulta no seno de 1 a 10 alocados em um vetor

Claro que nesse caso teríamos o mesmo resultado com sin.(1:10). Mas o tempo computacional não seria igual:

@time map(sin, 1:10000);

0.045417 seconds (152.71 k allocations: 7.737 MiB) @time sin.(1:10000);

(91)

Sumário

(92)

Controle de uxo

Estrutura if

Se estiver habituado a outras linguagens, não se preocupe com o espaço branco, identação, recuo, parênteses, ponto e vírgula, ou qualquer coisa do gênero, mas lembre-se de terminar a construção condicional com o end.

nome = "Julia" if nome == "Julia"

println("Eu gosto de Julia") elseif nome == "Python"

println("Eu gosto de Pyton.") println("Mas eu prefiro Julia.") else

println("Eu não sei o que gosto.") end

(93)

Controle de uxo

Função if-else

Podemos usar a função ifelse. Ela pode ser usada da seguinte maneira:

s = ifelse(false, "Alô", "Tchau") * "palavra" resulta em Tchau palavra

(94)

Controle de uxo

Estrutura for

Trabalhar através de uma lista ou um conjunto de valores ou desde um valor inicial até um valor nal são todos exemplos de iteração, e a construção nal de for-end.

Aqui está a sintaxe padrão para uma simples iteração através de um range de valores:

for i in 0:10:100 println(i) end

(95)

Controle de uxo

Estrutura for

for cor in ["vermelho", "verde", "azul"] # um array print(cor, " ")

end

(96)

Controle de uxo

Estrutura for

Pode iterar através de uma matriz 2D, passando por cada coluna, de cima para baixo. Vejamos um exemplo:

a = reshape(1:100, (10, 10)); for n in a

print(n, " ") end

(97)

Controle de uxo

Estrutura for

Iterando em um array e atualizando-a. Veja o exemplo: c = [1]; for i in c push!(c, i) @show c sleep(1) end

(98)

Controle de uxo

Estrutura for

A variável que passa por cada item - variável do laço - existe apenas dentro do laço, e desaparece assim que o laço termina.

for i in 1:10 @show i end

julia> i

(99)

Controle de uxo

Estrutura for

Se quiser lembrar o valor da variável do laço fora dele (por exemplo, se tiver de sair do laço e precisar de saber o valor alcançado), utilize a palavra-chave global para determiná-la

for i in 1:10 global quaolonge if i % 4 == 0 quaolonge = i end end julia> quaolonge 8

(100)

Controle de uxo

Estrutura for

De modo semelhante, se declarar uma nova variável dentro de um laço, ela não existirá uma vez que o laço termine. Neste exemplo, k é criada dentro: for i in 1:5 k = i^2 println("$(i) squared is $(k)") end julia> k

ERROR: UndefVarError: k not defined

Se quiser saber o valor de k, basta inserir a palavra global antes da denição da mesma

(101)

Controle de uxo

Estrutura for

O código a seguir não funciona: contador = 0

for i in 1:10

contador = contador + i end

ERROR: UndefVarError: contador not defined porque counter não foi denida como global

(102)

Controle de uxo

Estrutura for

Já o código a seguir roda perfeitamente: contador = 0 for i in 1:10 global contador contador = contador + i end julia> contador 55

(103)

Controle de uxo

Estrutura for

Este comportamento é porque estamos trabalhando no terminal. É geralmente melhor, na prática, colocar o seu código dentro de funções, onde não precisa de marcar variáveis fora do laço como globais: function f() contador = 0 for i in 1:10 contador = contador + i end return contador end julia> contador=f() 55

(104)

Controle de uxo

Vejamos os comandos em uma só linha de comando: [(i, sqrt(i)) for i in 1:10]

(1, 1.0) (2, 1.4142135623730951) (3, 1.7320508075688772) (4, 2.0) (5, 2.23606797749979) [(r,c) for r in 1:5, c in 1:2] (1, 1) (1, 2) (2, 1) (2, 2) (3, 1) (3, 2) (4, 1) (4, 2) (5, 1) (5, 2) [x for x in 1:100 if x % 7 == 0] 7 14 21 28 35 42 49 m = rand(0:9, 3, 3); [i for i in enumerate(m)] 3x3 Array{Tuple{Int64,Int64},2}: (1, 6) (4, 5) (7, 3) (2, 4) (5, 0) (8, 7) (3, 1) (6, 7) (9, 4)

(105)

Controle de uxo

Estrutura for

Por vezes deseja-se trabalhar em dois ou mais conjuntos ao mesmo tempo, tomando primeiro elemento de cada conjunto, depois o segundo, e assim por diante. Isto é possível utilizando a função zip(), bem conhecida: for i in zip(0:5, 100:105, 200:205) println(i) end (0,100,200) (1,101,201) (2,102,202) (3,103,203) (4,104,204) (5,105,205)

(106)

Controle de uxo

Estrutura for

As dimensões não precisam coincidir! for i in zip(0:15, 100:105, 200:205) println(i) end (0,100,200) (1,101,201) (2,102,202) (3,103,203) (4,104,204) (5,105,205)

(107)

Controle de uxo

Estrutura for

Outro exemplo últil:

for i = zip(3:2:7, ["blue" "red" "yellow"]) theta = 0:0.001:2*pi;

r = cos.(i[1].*theta)

display(plot!(theta,r,color=i[2])) end

(108)

Controle de uxo

Estrutura for

Loopings aninhados podem ser compactados: for x in 1:6 for y in 1:6 if y % 3 == 0 @show (x, y) end end end

(109)

Controle de uxo

Estrutura for ...é equivalente a: for x in 1:6, y in 1:6 if y % 3 == 0 @show (x, y) end end

(110)

Controle de uxo

Estrutura while

Para repetir algumas expressões enquanto uma condição é verdadeira, use o while...end: x = 0; while x < 4 println(x) global x = x + 1 end

(111)

Controle de uxo

Estrutura while

Para repetir algumas expressões enquanto uma condição é verdadeira, use o while...end: function f() x = 0; while x < 4 println(x) x = x + 1 end return x end

Não precisamos denir x como global porque inserimos while dentro de uma function

(112)

Controle de uxo

Estrutura while

Exemplo: verique quantos termos precisamos adicionar para que

k

X

n=1

(−1)n+1 4 2n − 1 aproxime π com uma precisão de 5 casas decimais.

(113)

Controle de uxo

Estrutura while

Fazemos o looping dentro de uma function imprimindo o erro, o número de iterações e o valor aproximado da série.

function f() S, k, e = 0, 0, 1 while e > 0.000005 k = k + 1 S = S + ((-1)^(k+1))*4/(2*k-1) e = abs(((-1)^(k+1))*4/(2*k-1)) end return (e,k,S) end

(114)

Sumário

(115)

Pacotes especiais resolução de EDOs

O pacote para resolução de EDOs tem documentação que pode ser acessada em https://diffeq.sciml.ai/stable/.

Para utilizá-lo, basta rodar Pkg.add("DifferentialEquations") e using DifferentialEquations

Neste exemplo, resolveremos a equação escalar:

du

dt = f (u, p, t), u(0) = u0 com t ∈ [0, 1] e f(u, p, t) = αu.

(116)

Pacotes especiais resolução de EDOs

Primeiro, denimos o problema, como a equação, condições iniciais e o range: using DifferentialEquations f(u,p,t) = 1.01*u u0 = 1/2 ts = (0.0,1.0) prob = ODEProblem(f,u0,ts)

dene automaticamente o solver mais eciente de acordo com as opções de tolerância, número de iterações máximo, etc

(117)

Pacotes especiais resolução de EDOs

Depois, controlamos o solver através do comando

sol = solve(prob, Tsit5(), reltol=1e-8, abstol=1e-8) Demais opções são acessadas em https://diffeq.sciml.ai/ stable/basics/common_solver_opts/#solver_options Poderemos escolher o solver para a resolução acessando

https://diffeq.sciml.ai/stable/tutorials/ode_example/ #Example-1-:-Solving-Scalar-Equations

Por exemplo, se quiséssemos o método de 5a _{ordem de Tsitouras}

era só entrar com

(118)

Pacotes especiais resolução de EDOs

Lidando com a solução encontrada:

Podemos acessar o quinto elemento da solução dando o comando sol[5] ou obter o oitavo termo de t através de sol.t[8]

De modo geral, as componentes de t e u são acessadas por [sol.t sol.u]

Elementos da solução sol intermediários são calculados por interpolação, por exemplo sol(0.456) = 0.7924

(119)

Pacotes especiais resolução de EDOs

Plotagem dos grácos das soluções: Basta inserir

sing Plots plotly()

plot(sol,linewidth=5,title="Solução da EDO",

xaxis="Tempo (t)",yaxis="u(t)",label="Minha curva!") E se você conhece a solução exata:

plot!(sol.t, t->0.5*exp(1.01t),lw=3,ls=:dash, label="Solução verdadeira!")

(120)

Pacotes especiais resolução de EDOs

O código completo para resolver este problema, onde u0= 1/2, é dado

a seguir. using DifferentialEquations f(u,p,t) = 1.01*u u0 = 1/2 ts = (0.0,1.0) prob = ODEProblem(f,u0,ts)

sol = solve(prob, Tsit5(), reltol=1e-8, abstol=1e-8) using Plots

plotly()

plot(sol,linewidth=5,title="Solução da EDO",

xaxis="Tempo (t)",yaxis="u(t)",label="Minha curva!") plot!(sol.t, t->0.5*exp(1.01t),lw=3,ls=:dash,

(121)

Pacotes especiais resolução de sistema de EDOs

O problema da mistura ([5]) é denido por:        dQ1 dt = 3 2 − 1 10Q1+ 3 40Q2 dQ2 dt = 3 + 1 10Q1− 1 5Q2 , Q1(0) = 25; Q2(0) = 15.

(122)

Pacotes especiais resolução de sistema de EDOs

Denimos uma função para escrever o modelo, como a seguir: function Mistura!(dQ,Q,p,t)

dQ[1] = p[1] + p[2]*Q[1] + p[3]*Q[2] dQ[2] = p[4] + p[5]*Q[1] + p[6]*Q[2] end

Denimos os dados iniciais e os parâmetros do modelo: Q0 =[25;15];

ts = (0,40);

p=[1.5;-0.2;3/40;3;0.1;-0.2]

sist = ODEProblem(Mistura!,Q0,ts,p) @time sol = solve(sist)

Finalmente, mandamos plotar as soluções determinadas: plot(sol,linewidth=5,label=["Q_1" "Q_2"])

(123)

Pacotes especiais resolução de sistema de EDOs

(124)

Pacotes especiais resolução de sistema de EDOs

O problema da mistura ([5]) é denido por:        dθ dt = ω(t) dω dt = − 3 2 g l sin θ(t) + 3 ml2M (t) , θ(0) = 0.01; ω(0) = 0. e M(t) = 0.1 sin t.

(125)

Pacotes especiais resolução de sistema de EDOs

function pendulo!(du,u,p,t) du[1] = u[2] du[2] = -3*p[3]/(2*p[1])*sin(u[1]) + 3/(p[2]*p[1]^2)*M(t) end p=[1;1;9.81] theta0 = 0.01 omega0 = 0.0 u0 = [theta0, omega0] ts = (0.0,10.0) M(t) = 0.7cos(t) prob = ODEProblem(pendulo!,u0,ts,p) sol = solve(prob) plot(sol,linewidth=2,xaxis="t",label=["theta [rad]" "omega [rad/s]"],color=["red" "green"],layout=(2,1))

(126)

Pacotes especiais resolução de sistema de EDOs

(127)

Pacotes especiais resolução de sistema de EDOs

O modelo SIR ([5]) é denido por:                  dS dt = −βSI dω dt = βSI − γI dω dt = γI , S(0) = S0; I(0) = I0; R(0) = 0.

(128)

Pacotes especiais resolução de sistema de EDOs

O modelo é implementado da seguinte forma:

function SIR!(du,u,p,t) beta, gama = p

du[1] = -beta*u[1]*u[2]

du[2] = beta*u[1]*u[2] - gamma*u[2] du[3] = gamma*u[2] end p = [0.85;0.15] u0 = [0.9;0.1;0.0] tspan = (0.0,50.0) prob = ODEProblem(SIR!,u0,tspan,p) sol = solve(prob) plot(sol,linewidth=2,xaxis="t",layout=(3,1), color=["red" "green" "blue"],

(129)

Pacotes especiais resolução de sistema de EDOs

(130)

Pacotes especiais ajuste de curvas

Documentação que pode ser acessada em

https://julianlsolvers.github.io/LsqFit.jl/latest/tutorial/. É a implementação do algoritmo Levenberg-Marquardt.

Rodar Pkg.add("LsqFit") e using LsqFit

Vamos testar um exemplo de ajuste de pontos por uma reta do tipo yi = β1+ β2xi+ εi, com β1 e β2 a serem determinados

Geramos os seguintes dados: tdata = collect(0:1:20)

(131)

Pacotes especiais ajuste de curvas

Em seguida descrevemos nosso modelo usando uma function: model(x,beta) = beta[1] .+ beta[2].*x;

p0 = [0.5, 0.5]

p0 é o parâmetro inicial para o algoritmo determinar os parâmetros.

Seguidamente, damos o comando para a determinação do ajuste: fit = curve_fit(model, tdata, ydata, p0)

param = fit.param

Pronto! os parâmetros foram determinados. Denindo f(x) = f(x) = param[1] + param[2]*x podemos plotar os grácos da função ajustada e dos pontos do experimento: plot(f,0:20,lw=2,)

(132)

Pacotes especiais ajuste de curvas

(133)

Pacotes especiais ajuste de curvas

O código completo está apresentado a seguir:

using LsqFit using Plots plotly()

tdata = collect(0:1:20)

ydata = 2*tdata .+ 1 .+ 0.8*randn(length(tdata)) model(x,beta) = beta[1] .+ beta[2].*x;

p0 = [0.5, 0.5]

fit = curve_fit(model, tdata, ydata, p0) param = fit.param

yfit = model(tdata, param) a = round.(param[1],digits=2) b = round.(param[2],digits=2) plot(tdata,yfit,lw=2,label="Dados")

scatter!(tdata,ydata,legend = :outertopright, label=["$a + $b*x" "dados"])

(134)

Pacotes especiais ajuste de curvas

Podemos fazer um ajuste por meio dos quadrados mínimos linear por meio de uma função quadrática:

f (x) = β1+ β2x + β3x2.

Sejam os dados:

xdata = collect(0:0.1:10); n=length(xdata)

ydata = 1 .- 2*xdata .+ xdata.^2 .+ 0.5*rand(-5:5,n) scatter(xdata,ydata)

Apresentamos o modelo:

model(x,beta) = beta[1] .+ beta[2].*x .+ beta[3].*x.^2; p0 = [0.5, 0.5, 0.5]

Finalmente determinamos os pontos ajustados: fit = curve_fit(model, xdata, ydata, p0) param = fit.param

(135)

Pacotes especiais ajuste de curvas

(136)

Pacotes especiais ajuste de curvas

Agora suponhamos que queremos ajustar um conjunto de pontos ao modelo não-linear: f (x) = β1 x β2 β3−1 exp − x β2 β3! .

Criamos o conjunto de dados:

xdata = [ 15.2; 19.9; 2.2; 11.8; 12.1; 18.1; 11.8; 13.4; 11.5; 0.5; 18.0; 10.2; 10.6; 13.8; 4.6; 3.8; 15.1; 15.1; 11.7; 4.2 ] ydata = [ 0.73; 0.19; 1.54; 2.08; 0.84; 0.42; 1.77; 0.86; 1.95; 0.27;

(137)

Pacotes especiais ajuste de curvas

Em seguida, criamos uma função para escrever o modelo:

model(x,beta) = beta[1] * ((x/beta[2]).^(beta[3]-1)) .* (exp.( - (x/beta[2]).^beta[3] ))

Para determinar β, chamamos a função

fit = curve_fit(model, xdata, ydata, [3.0, 8.0, 3.0]) beta = fit.param

para termos os valores ajustados, a saber: beta_fit = fit.param

(138)

Pacotes especiais ajuste de curvas

(139)

Pacotes especiais integração numérica

Se quisermos calcular uma integral denida do tipo A =

Z b

a

f (x) dx,

usando aproximações por somas de Riemann, basta utilizar: A ≈

n

X

k=1

f (x∗_i)∆x.

Isso pode ser feito fornecendo os seguintes comandos, supondo f (x) = e−x2, a = 0, b = 10 e n = 100000.

(140)

Pacotes especiais integração numérica

O código para isto é apresentado a seguir: a, b, n = 0, 10, 100000;

deltax = (b-a)/n;

x_estrela = a .+ (0:n) * delta f(x) = exp(-x^2)

f_em_x = map(f, x_estrela)

@time Int_approx = sum(f_em_x)*deltax que fornece R10

0 e −x2

(141)

Pacotes especiais integração numérica

Ou simplesmente, instalando o pacote QuadGK e depois using QuadGK, cujo manual é disponível em

https://juliamath.github.io/QuadGK.jl/latest/ e que implementa a quadratura de Gauss-Kronrod.

f(x) = exp(-x^2)

@time (integral,err) = quadgk(f, 0, 10, rtol=1e-8)

resultando nos mesmos 0.886. Temos também a opção de controlar o erro da aproximação.

(142)

Pacotes especiais otimização

Instalamos e rodamos o pacote Optm, ver documentação em http:// julianlsolvers.github.io/Optim.jl/v0.9.3/user/minimization/ que implementa diversos algoritmos de otimização não-linear

apresentados nos livros [6, 7]

Otimização irrestrita

Consideremos a função f(x1, x2) = (2x1− 3)4+ (3x1− x2)2.

Desejamos encontrar o seu mínimo absoluto. Primeiro, preparamos uma function em Julia:

function f(x)

return (2x[1] - 3)^4 + (3x[1] - x[2])^2 end

(143)

Pacotes especiais otimização

Chamamos esta função partindo do ponto inicial (x1, x2) = (0, 0)T:

using Optim opt = optimize(f, [0.0, 0.0]) println("vetor_ótimo = ", opt.minimizer) println("f_ótimo = ", opt.minimum) resulta em vetor ótimo = [1.5023336961799512, 4.507036749081916] f ótimo = 1.7462409416808738e-9

(144)

Pacotes especiais otimização

Poderemos trocar o algoritmo, que por default é Nelder-Mead. Outros tais como Simulated Annealing,

BroydenFletcherGoldfarbShanno (BFGS), Gradientes Conjugados estão disponíveis:

opt = optimize(f, [0.0, 0.0], BFGS())

(145)

Pacotes especiais otimização

Otimização box constrained

Quando as variáveis tem um lower and upper bounds.

Consideremos a minimização da mesma f sujeito às restrições 2 ≤ x1 ≤ 5 e 6 ≤ x2 ≤ 10. Preparamos a função-objetivo:

function f(x)

return (2x[1] - 3)^4 + (3x[1] - x[2])^2 end

Nós também preparamos os limitantes para as variáveis: lb = [2.0; 6.0]

ub = [5.0; 10.0] x0 = [3.0; 7.0]

(146)

Pacotes especiais otimização

Otimização box constrained

Escolhemos o otimizador: inner_optimizer = BFGS() E em seguida otimizador: resultados = optimize(f,lb,ub,x0, Fminbox(inner_optimizer)) Perguntamos os resultados resultados.minimizer -->> [2,6] resultados.minimum -->> 1 results.iterations -->> 7

(147)

Pacotes especiais otimização

Otimização em problemas mais gerais

Precisamos instalar e rodar o pacote JuMP cuja documentação é disponível em https://jump.dev/JuMP.jl/v0.19.0/index.html

Suponhamos que queiramos resolver o seguinte problema de otimização-não linear:

Min (x1− 3)3+ (x2− 4)2

sujeito a

(x1− 1)2+ (x2+ 1)3+ e−x1 ≤ 1,

Precisamos de duas macros @NLobjective e @NLconstraint para lidar com as não-linearidades.

(148)

Pacotes especiais otimização

Construimos o modelo (previamente rodar o solver de otimização não-linear restrito Ipopt):

m = Model(solver=IpoptSolver())

Em seguida denir as variáveis, restrições e função-objetivo por meio de macros:

@variable(modelo, x[1:2])

@NLobjective(modelo,Min,(x[1]-3)^3 + (x[2]-4)^2) @NLconstraint(modelo,(x[1]-1)^2 + (x[2]+1)^3

+ exp(-x[1]) <= 1) Em seguida, resolvemos o modelo optimize!(modelo)

(149)

Pacotes especiais otimização

Após resolvido, extraímos a solução e o valor ótimo:

println("** Valor mínimo = ",objective_value(modelo)) println("** Solução ótima = ",value.(x))

o que resulta em:

** Valor mínimo = 4.409110764366554

(150)

Referências I

D. P. Corina, L. S. Jose-Robertson, A. Guillemin, J. High, and A. R. Braun, Language lateralization in a bimanual language, Journal of Cognitive Neuroscience, vol. 15, no. 5, pp. 718730, 2003. J. Bezanson, A. Edelman, S. Karpinski, and V. B. Shah, Julia: A fresh approach to numerical computing, SIAM review, vol. 59, no. 1, pp. 6598, 2017.

A. Edelman, Julia: A fresh approach to technical computing and data processing, tech. rep., MASSACHUSETTS INST OF TECH CAMBRIDGE CAMBRIDGE, 2019.

I. Balbaert, Getting Started with Julia Programming: Enter the exciting world of Julia, a high-performance language for technical computing.

(151)

Referências II

W. E. Boyce and R. C. DiPrima, Equações diferenciais elementares e problemas de valores de contorno.

Guanabara Dois, 1985.

M. S. Bazaraa, H. D. Sherali, and C. M. Shetty, Nonlinear programming: theory and algorithms.

John Wiley & Sons, 2013.

J. Nocedal and S. Wright, Numerical optimization.

Introdução à linguagem de programação Julia