Métodos computacionais / 2019

Davi C. Rodrigues
Aula 1

e-mail: davi@cosmo-ufes.org
página do curso: davi.cosmo-ufes.org/metodoscomputacionais2019

Estrutura do curso

Ementa  
Fundamentos e aplicações de programação procedural e funcional, representações numéricas, convergência numérica, otimização matemática multidimensional (minimização), aplicações para análise de dados, resolução de equações diferenciais e integrais (por métodos numéricos e analíticos), otimização de performance.

Programa 
a. Introdução ao Mathematica, seus princípios e funções básicas, e breve introdução ao Python e comparação com outras linguagens.
b. Programação procedural e funcional: fundamentos e aplicações.
c. Criação de pacotes.
d. Representações numéricas e critérios gerais de convergência
e. Resolução de integrais e equações diferenciais. Métodos analíticos e numéricos. 
f. Otimização matemática (minimização) multidimensional: princípios, métodos e aplicações.
g. Aplicações para análise de dados: inclui manipulação de arquivos, tabelas, histogramas, PDF’s, curvas de confiança e outros tópicos de estatística.
h. Computação paralela e otimização de códigos.

Bibliografia
Bibliografia principal:
   P. Wellin, Programming with Mathematica, Cambridge (2013)
   S. Mangano, Mathematica Cookbook,  O’Reilly Media (2010) 
Bibliografia complementar:
   W. McKinney, Python for Data Analysis, O’Reilly Media; 2 edition (October 20, 2017)
   A. Gelman et al, Bayesian Data Analysis, Chapman and Hall/CRC; 3 edition (2013) 
Outros:
   Documentação incluída no mathematica (“Help”).
   https://mathematica.stackexchange.com  (!!) -- Essencial!
   Google -- Já ouviram falar?
   stackoverflow.com -- Dúvidas gerais de programação
   
Avaliações
- Problemas a serem feitos em casa e enviados por email: 50% da nota
- Resolução e apresentação oral de um trabalho-desafio no final do semestre: 30% 
- Participação em sala de aula: 20%

Brincando com a estrutura das funções do Mathematica...

1+((((3/(1 +(((2+99))^2)))))^(1/3))

% +1

% // N

f[x_] = (x^2); 
∫(f''[x] + (1/x) f'[x] + (1-(( (m^2))/(x^2)))f[x])\[DifferentialD]x
Clear[f]

TreeForm[  ∫(f''[x] + (1/x) f'[x] + (1-(( (m^2))/(x^2)))f[x])\[DifferentialD]x]

CompleteGraph[#, PlotLabel->#] & /@ Range[3,24,2] // Row   // Rasterize

newrange = DeleteCases[Range[3,24], x_/; IntegerQ[(x^2)/3]];
CompleteGraph[#, PlotLabel->#]  & /@  newrange // Row   // Rasterize

TreeForm[Hold[CompleteGraph[#, PlotLabel->#] & /@ Range[3,30,3] // Row]]

Brincando um pouco mais... Exemplo do tambor e funções de Bessel
(ver arquivo anexo para versão completa)

(∇^2)ϕ (x,t) - (1/(v^2))(Overscript[ϕ, ..])(x,t) =0

ϕ (x,t) =ϕ (r,φ,t) = R(r) Θ(θ) T(t).

R''(x) + (1/x)R'(x)+ (1 - ((m^2)/(x^2)))R(x) = 0,

DSolve[{f''[x] + (1/x) f'[x] + (1-(( (m^2))/(x^2)))f[x] == 0}, f[x], x]

Row[{Plot[{BesselJ[0,x], BesselJ[1,x], BesselJ[2,x], BesselJ[3,x]}, {x,-10,10}, PlotTheme->"Detailed", ImageSize->Medium],
Plot[{BesselJ[0,x], BesselJ[1,x], BesselJ[2,x],BesselJ[3,x]}, {x,-50,50}, PlotRange -> All,PlotTheme->"Detailed",ImageSize->Medium]}]

Plot[{BesselY[0,x], BesselY[1,x], BesselY[2,x], BesselY[3,x]}, {x,-1,30},PlotTheme->"Detailed"]

Limit[BesselJ[0,x], x-> 0, Direction -> -1]
Limit[BesselY[0,x], x-> 0, Direction -> -1]
Limit[BesselJ[n,x], x-> 0, Direction -> -1, Assumptions -> n>0]
Limit[BesselY[n,x], x-> 0, Direction -> -1, Assumptions -> n>  0]

FindRoot[BesselJ[0,x] == 0, {x, 1}] (* Procura por uma raiz usando x == 1 como ponto de partida*)

FindRoot[BesselJ[0,x] == 0, {x, 4} ] 

FindRoot[BesselJ[0,x] == 0, {x, 8}]

N[Table[BesselJZero[i,j], {j,1,10}, {i,0,30}]] // TableForm

k01 = N[BesselJZero[0,1]];
k02 = N[BesselJZero[0,2]];
k11 = N[BesselJZero[1,1]];
k21 = N[BesselJZero[2,1]];
k22 = N[BesselJZero[2,2]];

ϕ01[r_,θ_,t_] = Cos[k01 t]  BesselJ[0,(k01 r)]

RevolutionPlot3D[ϕ01[r,θ,0],{r,0,1},{θ,0,2π}, AxesLabel-> "  ϕ(r,θ,0)" ]

Animate[ RevolutionPlot3D[ϕ01[r,θ,t],{r,0,1},{θ,0,2π}, AxesLabel-> "  ϕ(r,θ,t)" ,Mesh->True, PlotRange->{{-1,1}, {-1,1}, {-1,1}}], {t,0,((2π)/k01)},SaveDefinitions->True,AnimationRunning->False]

ϕ11[r_,θ_,t_] = Cos[k11 t]  Cos[θ] BesselJ[1,(k11 r)];
Animate[ RevolutionPlot3D[ϕ11[r,θ,t],{r,0,1},{θ,0,2π}, AxesLabel-> "  ϕ(r,θ,t)" ,Mesh->True, PlotRange->{{-1,1}, {-1,1}, {-1,1}}], {t,0,((2π)/k11)},SaveDefinitions->True,AnimationRunning->False]

ϕ22[r_,θ_,t_] = Cos[k22 t]  Cos[2 θ] BesselJ[2,(k22 r)];
Animate[ RevolutionPlot3D[ϕ22[r,θ,t],{r,0,1},{θ,0,2π}, AxesLabel-> "  ϕ(r,θ,0)" ,Mesh->True, PlotRange->{{-1,1}, {-1,1}, {-1,1}}], {t,0,((2π)/k22)},SaveDefinitions->True,AnimationRunning->False]

Diferentes linguages para trabalhos científicos...

Há muitos textos sobre o assunto, algumas curiosidades:

Um curioso é este “benchmark” feito por uma linguagem pouco conhecida no nosso meio, Julia. Que pretende ter uma interface de alto nível (user-friendly), semelhante ao Mathematica, mas com uma performance semelhante ao C: https://julialang.org/benchmarks/ . Não sei o quão sólidos são esses benchmarks, mas é interessante ver comparações de performance com várias linguagens. No momento, o Julia essencialmente não é usado em minha área, mas quem sabe no futuro... 

Comparação de linguagens e suas compatibilidades com diferentes paradigmas de programação: https://en.wikipedia.org/wiki/Comparison_of_multi-paradigm_programming _languages #cite _note-118

Sobre a interface de programação via notebook: https://en.wikipedia.org/wiki/Notebook_interface

Um pouco de história sobre essas três linguagens científicas, Fortran, Mathematica e Python:  
https://en.wikipedia.org/wiki/Fortran#History , 
https://en.wikipedia.org/wiki/Python_(programming_language), 
https://en.wikipedia.org/wiki/Wolfram_Mathematica