Métodos computacionais / 2019

Davi C. Rodrigues
Aula 9

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

Item 0: revisao dos últimos exercícios para nota
item 1: Fizeram os exercícios que não eram para nota?
item 2: revisão da última aula

Exrecícios

N[1.23`10, 30]

12.123123`2

N[1.12345`,1]

1.12345`

N[1.1234567890123456789, 3]

1.1234567890123456789`3.

ScientificForm[1.234,2]

1.0 - 0.999999999999
Precision[ 0.999999999999]

$MachinePrecision

Precision[2.000 + 45.565]

Precision[1.0-0.999999999999]
Precision[1.0`13-0.999999999999`13]
Precision[1.0`15.95-0.999999999999`15.95]

0.9999999999`1000

FullForm[(9999999999/(10^10))]

Rationalize[0.23452345,0]

$MachinePrecision

0.999999999999
N[(1000022122208/1000022122209),100]

n1 = Rationalize[1.0,0];
n2 = Rationalize[0.999999999999`100,0]
n1-n2
N[%,20]

n1 = Rationalize[1.0,0];
n2 = Rationalize[0.999999999999`100,0];
n1-n2
N[%,20]

n1 = 1.0`100;
n2 = 0.999999999999`100;
n1-n2
N[%,20]

Atenção!

Rationalize[0.999999,0]
Rationalize[0.999999999999,0]
Rationalize[0.999999999999`100,0]

SetPrecision[0.999999999999,50]
N[Rationalize[0.999999999999,0],50]
N[Rationalize[0.999999999999`50,0],50]
0.999999999999`50

$MachinePrecision / Log10[2]

$MachinePrecision = 100

Cap.8:  Problemas numéricos - Continuacao

8.4 Aplicações

FindRoot: uso básico

Primeiro vamos aprender a usar a função FindRoot, que é uma das mais básicas de operação numérica.

O objetivo dela é encontrar raízes reais.

?FindRoot

f[x_] = ((x^2)-2)Sin[x];
Plot[f[x], {x,-5,5}]

FindRoot[f[x], {x,0}]
FindRoot[f[x], {x,2}]
FindRoot[f[x], {x,3}]

Plot[f'[x], {x,-5,5}]

FindRoot[f'[x], {x,1}]
FindRoot[f'[x], {x,3}]

Exercício (nota): Use FindRoot para definir uma função inversa da função f no intervalo 0.756 até 2.454

Plot[BesselJ[1,x],{x,-40,40}]

Precision[2.123123213`]

Precision[1.12345234523452345235248572097459082745892374509872439057`]

3.8317059702075125`

3.831705970207511`,3.831705970207512`,3.8317059702075125`

Attributes[SetPrecision]

SetPrecision[{123.1342,1.1} ,3]

tab = Table[x/. FindRoot[BesselJ[1,x], {x,k}], {k,40}]
Union[Round[%,0.01]]

2.2123`2 == 2.2125`2
2.2123`20 == 2.2125`20
Union[{2.2123`2 ,2.2125`2}]

Precision[1.23`10 + 1.23`20]

ScientificForm[0.0000000000000001]

tab = Table[x/. FindRoot[BesselJ[1,x], {x,k}], {k,40}];
Union[Round[%,0.0000000000000001]]//Length

tab2 = Table[x/. FindRoot[BesselJ[1,x], {x,k}, WorkingPrecision-> 40, PrecisionGoal-> ∞, AccuracyGoal->20], {k,40}];
Union[Round[%,0.0000000000000001]]//Length

3.831705970207511136`3.

Position[tab, -51.04353518357151`]

FindRoot[BesselJ[1,x], {x,18}]

f'[3]

(∂_x)f[x] /. x-> 3

Derivative[10][f][3]

D[f[x],{x,10}] /. x-> 10

N[Derivative[0,1][BesselJ][1,18]]

ListPlot@{{18,N[Derivative[0,1][BesselJ][1,18]]}}

Graphics[Disk[], ImageSize->20]

Graphics[Directive[{Disk[], ImageSize[20]}]]

Graphics[{Green,Disk[]}, ImageSize->20]

ListPlot[{Table[{k,N[Derivative[0,1][BesselJ][1,k]]}, {k,40}],{{18,N[Derivative[0,1][BesselJ][1,18]]}}} , PlotMarkers->{Graphics[{Green,Disk[]}, ImageSize->20], Graphics[{Red,Disk[]}, ImageSize->20]} ]

FindRoot[BesselJ[1,x], {x,5}] // Timing
FindRoot[BesselJ[1,x], {x,5}, WorkingPrecision->5]// Timing
FindRoot[BesselJ[1,x], {x,5}, WorkingPrecision->30]// Timing
FindRoot[BesselJ[1,x], {x,5}, WorkingPrecision->30, AccuracyGoal -> 2, PrecisionGoal-> 2]// Timing
FindRoot[BesselJ[1,x], {x,5}, WorkingPrecision->30, AccuracyGoal -> 3, PrecisionGoal-> ∞]// Timing
FindRoot[BesselJ[1,x], {x,5}, WorkingPrecision->30, AccuracyGoal -> 5, PrecisionGoal-> 5]// Timing

Note que o resultado estranho em x=18 não se deve à precisão numérica da computação interna de FindRoot.

FindRoot[BesselJ[1,x], {x,18}] // Timing
FindRoot[BesselJ[1,x], {x,18}, WorkingPrecision->5]// Timing
FindRoot[BesselJ[1,x], {x,18}, WorkingPrecision->100]// Timing
FindRoot[BesselJ[1,x], {x,18}, WorkingPrecision->30, AccuracyGoal -> ∞, PrecisionGoal-> 2]// Timing
FindRoot[BesselJ[1,x], {x,18}, WorkingPrecision->30, AccuracyGoal -> 3, PrecisionGoal-> ∞]// Timing
FindRoot[BesselJ[1,x], {x,18}, WorkingPrecision->30, AccuracyGoal -> 5, PrecisionGoal-> 5]// Timing

N@BesselJZero[1,16]

{-51.04`,0.`,3.83`,7.0200000000000005`,10.17`,13.32`,16.47`,19.62`,22.76`,25.900000000000002`,29.05`,32.19`,35.33`,38.47`,41.62`}

Breve comentário sobre compilação em de C

Pode-se usar o Mathematica para compilar um código em C, seguem dois exemplos de realização da função “Add”, uma no mathematica e outra em C.

Embora em geral a versão compialda em C tenha a vantagem de ser mais rápida, no exemplo abaixo é mais lenta por um fator 2. O principal objetivo no momento é comentar sobre o tratamento de números, não sobre velocidade de computação.

mAdd[n_] := n + 1
cAdd = Compile[{{x, _Integer}}, 
FindRoot[BesselJ[1,x], {x,18}], 
CompilationTarget->"C"]

cAdd[2]

TeXForm[n+1.3434 2 - (x^2)]

Python

CForm[n+1.3434 2 - (x^2)]

FortranForm

mAdd[6]
cAdd[6]

AbsoluteTiming[cAdd[3]]
AbsoluteTiming[mAdd[3]]

FindRoot: refazendo a definição

Implementando opções de precisão...