Métodos computacionais / 2019

Davi C. Rodrigues
Aula 6

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

Item 0: lembre dos novos exercícios.
Item 1: revisão dos exercícios enviados para nota.
Item 2: Exportação de dados para Python ou Fortran
Continuação do Paul Welling

Observação: exportação para Python ou Fortran

Antes, uma forma simples de exportar dados com suas definições na linguagem Wolfram :

Save[filename, {variáveis ou funções que se deseja exportar}];

Mostrar exemplo gerado por

Save[filenameaux, {Chi2Std,bulge, best, Chi2red, AChi2red,galaxyfitConstraints,gDist,σD, inc, σinc , VobsExp,Vgasplot, Vdiskplot, Vbulgeplot , VmodelVec, Chi2,Chi2TrackDistance,AChi2wPrior, AChi2} ]

Agora, uma versão para Fortran (que pode ser aproveitada para Python):

text1 = ToString@FortranForm@Chi2;
text2 = StringReplace[ToString[(Join[{best[[2,All,1]]},{FortranForm /@ best[[2,All,2]]}] // TableForm)], "\n\n" -> "\n"];
text3 = StringReplace[ToString[ {{"Dist", "DeltaD", "inc", "Deltainc"}, {gDist, σD, inc, σinc}} //TableForm], "\n\n" -> "\n"];
text4= ToString[FortranForm /@ galaxyfitConstraints];
Export[filenameaux2 , {"Chi2 expression:",text1, "", "Best fit data:",text2, "", "Reference values:", text3,"","Constraints:", text4}];

Mostrar resultado

Atenção: favor remover a tradução dos nomes das funções do Mathematica. Motivos: i) de nada ajudam, ii) não são boas traduções, iii) me irritam profundamente. :)

Cap.4:  Padrões (Patterns) e regras (rules) no Mathematica.

Já usamos regras nos nossos programas anteriores do Mathematica. Por exemplo,

{a,b,c,d,e}  /. d-> h

FullForm[Hold[{a,b,c,d,e} /. d-> h]]

{a,b,c,d,e} /. Rule[d,h]

Para complicar...

Rule[d,h] /. Rule-> Plus

f[x_] := (((2x))^4);
g[x_] = (((2x))^4);
DownValues[f]
DownValues[g]

Note que a regra abaixo leva ao mesmo resultado que a definição da função f, embora a função j não tenha sido definida.

a + f[h] - 24 
a + j[h] - 24 /. j[h] -> (((2h))^4)

Curiosidade, qual a diferença de -> para :> ?

FullForm[a:>b]

{x,x,x}/.x:>RandomReal[]

{x,x,x}/.x-> RandomReal[]

Regras

A definição de uma função já envolve a definição de uma regra (não necessariamente com sentido usual de uma função)

f[x_] = (x^2)/(Sqrt[ 1+ x]);

DownValues[f]

?? f

f[π]

f[Plot[x,{x,0,10}]]

f[]

list

list /. {x_,y_} -> x+y

4.1 Padrões

Em geral, qualquer expressão pode ser usada como um padrão (pattern),  mas num sentido mais restrito é uma expressão que  contém  “blanks”. Blanks podem ser simples (_), duplos (__) ou triplos (___). 

Exemplo: para definir a função f usamos um padrão, usamos x_.

Para analisar quais expressões correspondem a um dado padrão, pode-se usar MatchQ

MatchQ[Bob, _]

MatchQ[2, _]

MatchQ[{Bob,2}, _]

MatchQ[{(({Bob,2})^(1234 x)), 2}, _]

MatchQ[2, {_}]

MatchQ[2, ((_)^(_))]
MatchQ[(a^b), ((_)^(_))]

FullForm[((_)^(_))]
FullForm[(a^b)]

O símbolo  _  se refere a qualquer expressão no Mathematica.

Casos mais específicos:

Bob=NumberForm[1.]

Attributes[MatchQ]

MatchQ[Bob, #]& /@ {_, _Real, _String, _Symbol}

StringQ[1]

Head[1]

Head[Bob]

MatchQ[ #, _Plus] & /@ {a+b, a-b, "a+b"}

NumberForm[1.123412343]

TreeForm[a-b]

MatchQ[#, _Real] & /@ {a+b, 2.1341234}

MatchQ[{a+b, 2.34543},_Real]

Cases[{a+b, 2.34543, 12.2, 1.},_Real]

MatchQ[π, _Real]

MatchQ[Pi, _Number]

Head[N[π]]

Cases[{{1,2},{2},{3,4,1},{5,4},{3,3}, {π, asdfad}, {1,1,π}},{_,_}]

Clear[f]

Cases[{g[f[x]], f[g[x]], g[h], h[f], 2 g[x]}, _g]

Head[1.]

Head[g[f[x]]]

Duplo vazio / blank ( __ )

Cases[{{},{1,2},{2},{3,4,1},{5,4},{3,3}, {π, asdfad}, {1,1,π}},{_}]

l1=Cases[{{},{1,2},{2},{3,4,1},{5,4},{3,3}, {{1,2}, {2,3}}, {π, asdfad}, {1,1,π}},{__}]
l2=Cases[{{},{1,2},{2},{3,4,1},{5,4},{3,3}, {{1,2}, {2,3}}, {π, asdfad}, {1,1,π}},{__},2]

Complement[l1, l2]
Complement[l2, l1]

Cases[{{},{1,2},{2},{3,4,1},{5,4},{3,3}, {π, asdfad}, {1,1,π}},{___}]

_  (Blank) pode substituir qualquer expressão do Mathematica
__ (BlankSequence)pode substituir qualquer sequência de expressões do Mathematica
__ (BlankNullSequence) pode substituir qualquer sequência de expressões do Mathematica, incluindo o vazio.

Vamos usar esses dois últimos padrões para definir funções.

Clear[f]
f[x_,y__] := {x,y}
g[x_,y__] := Plus[x,y]

f[1]

f[1,2]
g[1,2]

f[1,2,3]
g[1,2,3]

f[1,{2,3,4}]
g[1,{2,3,4}]

Clear[g]
g[x_,z___] := {x,z}

g[1]

g[1,2]

Attributes[Plot]

SetAttributes[nPlot, {ReadProtected, HoldAll}];
nPlot[x_, y_, addoptions___] := Plot[x,y, addoptions,PlotPoints -> 5, MaxRecursion -> 0, PlotStyle->{Red, Green}, ImageSize -> Small]

Plot[{(x^3) - x, (x^2.9)},{x,0,5}]

x=2

nPlot[{(x^3) - x, (x^2.9)},{x,0,5}]

nPlot[{(x^3) - x, (x^2.9)},{x,0,5}, MaxRecursion-> 10]

Attributes[nPlot]

Busca por padrões mais complexos

Clear[x,v,t]
Cases[{(x^2), (10^5), (v^t), a + (b^c), 2 (v^t)}, ((x_)^(y_))]
Cases[{(x^2), (10^5), (v^t), a + (b^c), 2 (v^t)}, z_ ((x_)^(y_))]

TreeForm[-2 (v^t)]

TreeForm[(x^2)+ (10^5) + (v^k)+ a + (b^c)- 2 (v^t)]

Cases[{a[h],b[d],c[a]}, _a]

Head[a[h]]

Head[a]

Cases[(x^2)+ (10^5) + (v^k)+ a + (b^c)- 2 (v^t),  _Symbol, Infinity ]
Cases[(x^2)+ (10^5) + (v^k)+ a + (b^c)- 2 (v^t),  z_ ((x_)^(y_))]

Cases[{(v^t)}, ((_)^(_))]

(x^2)+ (10^5) +(v^t)+ a + (b^c)- 2 (v^t) /. Plus -> List

FullForm[2 (b^c)]

Cases[{100000,a,2 (b^c),-(v^t),(x^2)},((_)^(_))]
Cases[(x^2)+ (10^5) + (v^t)+ a + (b^c)- 2 (v^t),  (_)^_, Infinity]
Cases[(x^2)+ (10^5) + (v^t)+ a + (b^c)- 2 (v^t),  _ (_)^_]
Cases[(x^2)+ (10^5) + (v^t)+ a + (b^c)- 2 (v^t),  _ (_)^_]

{TreeForm[(x^2)+ (10^5) + (v^t)+ a + (b^c)- 2 (v^t)], TreeForm[(_)^_]}

Verificação de padrão com condição

Cases[ Range[10], n_]

Cases[ Range[100000], n_/;IntegerQ[(Sqrt[n])] && n<100] // AbsoluteTiming
Select[ Range[100000], IntegerQ[(Sqrt[#])] && # < 100 &] // AbsoluteTiming

/;

hh[x_] := (x^2) /;IntegerQ[x/2];

hh[1]

hh[2]

h[2.2]

h[4]

Clear[f]
f[x_?IntegerQ] = x + r

f[{1,2}]

f[2]

||

Or[True,True]
Xor[True,True]

Ok, tudo isso é muito divertido, mas vamos logo para os exercícios... Acompanhe também a teoria lendo o capítulo, é bem simples.

Exercício 1:

selecionar[x_] := Select[x,IntegerQ[#/2]||IntegerQ[#/3]||IntegerQ[#/5]&]

Exercício 5 :

abs[x_] := Abs[x] /; (x ∈ Rationals || x ∈ Integers ) 
abs[x_] :=(Sqrt[ ((re[x])^2) + ((im[x])^2)]) /; Head[x]== Complex

Exercício 6 :

swapTwo[x_]:= Join[x[[{2,1}]],x[[3;;]]] /; Length[x] ≥ 2;
swapTwo[x_]:= x /; Length[x] ≤ 1;

swapTwo[a,b,c,d]

selecionar[{3,10,1234,7,1, a}]

Outra forma para o exercício 1:

Uma forma de resolver...

Cases[{2,4564567,3, 9, 24, 10, π, 2/3,342345245, 1234,333, 11}, n_ /; IntegerQ[n/2] || IntegerQ[n/3] || IntegerQ[n/5]  ]

Outra forma....

Clear[list]
list[n_] := list[n]= RandomInteger[10,n];

list[10]

Cases[list[10]/2, _Integer] ⋃  Cases[list[10]/3, _Integer] ⋃ Cases[list[10]/5, _Integer]

Solução para o exercício 6

Sequence@@{a,b,c,d}

Exercício para nota (exercício 4)

Sem usar qualquer operador de derivação já definido pelo Mathematica, defina um novo operador capaz de derivar...

i) um monônimo arbitrário

ii) um polinômio arbitrário