Física Computacional - Contribuições do usuário [pt-br]

Dinâmica Molecular

2015-04-08T18:00:07Z

Caca:

===== [[Introdução à Dinâmica Molecular (DM)]] =====
===== [[DM: um primeiro programa]] =====
===== [[Medidas estáticas e dinâmicas]] =====
===== [[Otimizações]] =====
===== [[DM à temperatura constante]] =====
===== [[DM de potenciais descontínuos]] =====
===== [[DM de partículas não esféricas]] =====
===== [[DM de sistemas fora do equilíbrio]] =====

Dinâmica Molecular

2015-03-30T18:59:45Z

Caca: Criou página com 'teste'

teste

Página principal

2015-03-30T18:59:04Z

Caca:

''A Wiki is a collaboratively edited Web site designed to promote the accumulation and refining of data with the least possible hassle. Any user viewing a Wiki can edit anything they see quickly and easily''

Bem vindos a '''ComplexWiki''', ambiente de trabalho cooperativo para [[#Pesquisa]], [[#Ensino]] e dicas sobre [[#Linux]].
É preciso se cadastrar para fazer contribuições.
ComplexWiki está dentro do [http://www.if.ufrgs.br Instituto de Física].
-- ''Sebastián Gonçalves''


Consulte [http://meta.wikipedia.org/wiki/MediaWiki_User%27s_Guide User's Guide] para informações de como usar o software wiki (em inglês) e [[ComplexWiki:Sobre]] sobre o estilo local.

== Pesquisa ==

* [[Atrito]]

* [[Econofísica]]

* [[Epidemias]]

* [[Laboratório de Estruturas Celulares]]

[[Instituições de pesquisa]] sobre complexidade no mundo

[[Conferencias]]

== Administração ==

* [[Planejamento Estratégico IF-UFRGS]]

== Ensino ==

===[[Métodos computacionais]]===

===[[FIP20706 Tópicos em Física Estatística: redes e dinâmica de epidemias]]===

===[[Introdução a Sistemas Dinâmicos]]===

===[[Dinâmica Molecular]]===

===Texto de Apoio ao Ensino de Física===

* [[Ondas]]

* [[Raio X]]

===[[Applets]]===

===[[Dicas para apresentações]]===

==Linux Forum==

====Hardware====

* [[Touchpad (Synaptic/ALPS)]]

* [[Impressoras multifuncionais]]: instalando o scanner

* [[linux & vaio sz]]

====Software====

* [[instalação de linux basica pela rede]]: procedimento

* [[Reinstalando todos os pacotes de instalação antiga]]

* [[sources.list]]: configurando automaticamente

* [[kubuntu]]: como configurar senha de root

* f90 da Intel: [[upgrade para Edgy]]

* [[32 bits rodando em 64]]: como configurar

* [[thunderbird & firefox]]: como escolher o navegador que abre os links do thunderbird

* [[thunderbird]]: instalando dicionários

* [[XFig]]: truques

* [[pdf]]

* [[latex, emacs, UTF-8 e acentos]]

* [[c cedilha no Ubuntu]]

* [[sincronizar estação]]

* [[colocar legendas num video]]

== Mix ==

[[Distribuição Docente 2007]]

== Consulta (wiki) ==
* [[mysql]]
* [http://meta.wikimedia.org/wiki/Setting_user_rights_in_MediaWiki Dando privilégio de Administrador (sysop ou OpSys) para um usuário]
* [[Mudando o titulo da página principal (mainpage)]]
* [[Modificando a barra de navegação (navigation bar)]]
* [http://meta.wikimedia.org/wiki/Page_access_restriction_with_MediaWiki#Get_the_patch Restringindo páginas]
* [[Fórmulas]] e [http://meta.wikimedia.org/wiki/Help:Table tabelas]
* [http://isaacnewton.princeton.edu/index.php/MediaWiki:Color_Names As cores do mediawiki]
* [http://en.wikipedia.org/wiki/Wikipedia:Extended_image_syntax#Location Imágens (avanzado)]
* [http://meta.wikimedia.org/wiki/Layout_customization Customization]
* [[Backup de servidor wiki]]
* [http://meta.wikimedia.org/wiki/Help:Upgrading_MediaWiki Upgrade do mediawiki]
* [http://www.mediawiki.org/wiki/Help:Configuration_settings Configuration settings list]
* [http://www.mediawiki.org/wiki/Help:FAQ MediaWiki FAQ]
* [http://mail.wikipedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]
* [http://meta.wikimedia.org/wiki/Gnuplot Extensão para Gnuplot]
* [[Moodle]]
* [[mediawiki: dicas]]

== Novidades ==

Adicionado suporte para Gnuplot (veja [[Espaço dos alunos]] )



<analytics uacct="UA-379257-2"></analytics>

<--'''MediaWiki instalado com sucesso.'''

Consulte o [http://meta.wikimedia.org/wiki/Help:Contents Manual de Usuário] para informações de como usar o software wiki.

== Começando ==

* [http://www.mediawiki.org/wiki/Manual:Configuration_settings Lista de opções de configuração]
* [http://www.mediawiki.org/wiki/Manual:FAQ FAQ do MediaWiki]
* [https://lists.wikimedia.org/mailman/listinfo/mediawiki-announce Lista de discussão com avisos de novas versões do MediaWiki]
-->

Área 3

2012-06-21T19:08:18Z

Caca:

A) Interpolação e Extrapolação
--------------------------------------------

1 - Explique a ideia do algoritmo de Neville (linhas gerais).

2 - Em aula fizemos um algoritmo que interpola um conjunto de pontos usando o algoritmo de Neville.
Na ocasião, eu propus que os polinômios fossem mapeados em uma matriz quadrada A de dimensão NxN, onde os elementos da primeira coluna eram os pontos P11, P22, P33, etc e os demais elementos eram colocados nas demais colunas...
Agora eu quero propor uma outra maneira de mapear e isto implica uma outra maneira de construir o algoritmo. O objetivo é que você ENTENDA os passos, construa o seu algortimo com calma.
Mapeie da seguinte maneira:
os polinômios P11, P22, P33, etc (os quais são dados do problema) são colocados na diagonal principal da matrix A (A[1][1], A[2][2], etc). Em seguida, os polinômios P12, P23, P34, etc, são colocados na diagonal seguinte (A[1][2], A[2][3], etc) . Os poliômios P123, P234, etc na outra diagonal (A[1][3], A[2][4], etc) e assim sucessivamente.
Este algoritmo terá uma fórmula de recorrência difente daquele feito em aula e também a maneira de variar os índices será outra.

Use os seguintes N=4 pontos como dados de entrada:

0.000000 0.000000

1.500000 0.997495

3.000000 0.141120

4.500000 -0.977530

Uma vez que o algoritmo esteja funcionando para N=4, use os seguintes N=9 pontos:

0.000000 0.000000

0.750000 0.681639

1.500000 0.997495

2.250000 0.778073

3.000000 0.141120

3.750000 -0.571561

4.500000 -0.977530

5.250000 -0.858935

6.000000 -0.279415

O ideal é fazer um programa que leia estes dados de dentro de um arquivo de entrada e faça a interpolação para um valor de N qualquer que o usuário queira.

3 - Use o algorimo construído em 2 para interpolar os seguintes N=11 pontos:

0.000000 -0.200000

0.600000 -0.227273

1.200000 -0.263158

1.800000 -0.312500

2.400000 -0.384615

3.000000 -0.500000

3.600000 -0.714286

4.200000 -1.250000

4.800000 -4.999993

5.400000 2.500002

6.000000 1.000000

Desenhe no gnuplot estes pontos e os valores interpolados pelo seu programa. Varie x entre 0 e 6 varrendo x a cada 0.2.

B) Zeros de Funções
------------------------------

Legenda para esta seção:
F(x) = f(x) + x

F'(x) é a derivada de F(x) com relação à x

Considere a função <math>f(x) = exp(-0.1*x)*sin(2*x)</math>.

4 - Faça no gnuplot um gráfico desta função dentro do intervalo pedido [-5:5]. Desenhe junto a linha y=0 para que você possa visualizar graficamente quantas raízes há neste intervalo.

5 - Retome o programa (fornecido em aula e que está no moodle) que calcula zeros de funções usando o método de Newton-Raphson e adapte-do para encotrar TODOS os zeros da função f(x) no intervalo [-5:5]. Imprima estas raízes num arquivo chamado raizes.dat.
Fundamental se dar conta de alguns "detalhes" antes de executar esta tarefa:
* Como o método de Newton-Raphson encontra apenas uma raiz para cada valor "chute" de x ("x_init"), então você deverá relançar o método várias vezes até encontrar todas as raízes do intervalo. Isto exige que você faça um loop variando "x_init" e, para cada x_init, você aplica o método de iteração.
* Note que o método pode (e provavelmente vai) encontrar a mesma raiz mais de uma vez. Você não deve estocar raízes repedidas! e isto implica que você deve pensar em uma maneira de fazer isto (dicas no final da lista para os que quiserem)

6 - Faça exatamente o mesmo procedimento que fizeste no problema 5 com o método de iteração simples. Uma vez feito o algoritmo do problema 5, basta você alterar a parte que calcula a iteração para usar o método de iteração simples visto em aula.
Usando este método, quantas raízes você consegue encontrar?
Calcule F'(x) para cada raiz encontrada no problema 5 e interprete o resultado que você acaba de obter à luz do que foi discutido em aula sobre a estabalidade do método de iteração simples.

7- método de bissecção: discuta brevemente as desvantagens deste método.

Dicas para o problema 5 (no ponto onde você vai verificar se a nova raiz encontrada já foi calculada)
a) você pode estocar as raízes em uma matriz (ex raizes[] ) e, a cada vez que o algoritmo encontra uma raiz, ele deve comparar com as demais raízes já estocadas na matriz raizes[].
b) quando você for comparar a nova raiz encontrada (digamos x) com os elementos da matriz raizes[] (digamos raizes[i]), perceba que você estará comparando números reais. Então cuidado com os operadores de igual (==) ou diferente (!=), pois um número será diferente do outro se e somente se todas os algarismos significativos o forem! portanto, ao invés de comparar se x!=raizes[i], faça fabs(x-raizes[i]) < PRECISAO, onde fmod(a) é o módulo de a.
c) não hesite em "debugar" o seu programa ! Isto vai ajudá-la(o) a entender o que há de errado.

C) Ajuste de curvas usando o método dos mínimos quadrados
------------------------------------------------------------------------------------

8) Dados os pontos;

x: 0.10 0.20 0.30 0.40 0.50 0.60 0.70 0.80 0.90 1.00

y: 0.62 0.63 0.64 0.66 0.68 0.71 0.76 0.81 0.89 1.00

Ajuste uma função do tipo f(x) = a0+a1*x+a2*x2 usando o método dos mínimos quadrados. Depois faça um gráfico usando os pontos da tabela e compare com a curva teórica que você calculou.

9) A resistência à compressão do concreto ( chamada de sigma ), decresce com o aumento da razão água/cimento (w/c, cuja unidade é em galões de água por saco de cimento). A resistência à compressão de várias amostras é dada na tabela a seguir:

w/c: 4.5 5.0 5.5 6.0 6.5 7.0 7.5 8.0 8.5 9.0

sigma: 7000 6125 5237 4665 4123 3810 3107 3070 2580 2287

Usando o método dos mínimos quadrados e utilizando uma função do tipo <math>g(x)= a *exp( -b * x )</math> , onde <math>g(x)=sigma</math> e <math>x=w/c</math>, ajuste o sigma aos dados da tabela.
Note que é possível linearizar a g(x) fazendo uma substituição de variável: <math>f(x) = ln(g(x)) = ln(a) - b x</math>. Isto recai exatamente na função linear <math>f(x)=a0+a1x</math>, onde <math>a0=ln(a)</math> e <math>a1=-b</math>. É importante dar-se conta, no momento de ajustar a g(x), que você usou o <math>ln(g(x))</math> para chegar a sua forma linearizada. Portanto, no momento de ajustar os pontos forncecidos, você deve também transformar o "sigma" pela mesma função: <math>ln(sigma)</math>.

Grafique junto os pontos forncecidos na tabela acima com a função exponencial g(x) (usando obviamente os valores de a e b encontrados com o seu programa).

Área 3

2012-06-21T19:07:37Z

Caca:

A) Interpolação e Extrapolação
--------------------------------------------

1 - Explique a ideia do algoritmo de Neville (linhas gerais).

2 - Em aula fizemos um algoritmo que interpola um conjunto de pontos usando o algoritmo de Neville.
Na ocasião, eu propus que os polinômios fossem mapeados em uma matriz quadrada A de dimensão NxN, onde os elementos da primeira coluna eram os pontos P11, P22, P33, etc e os demais elementos eram colocados nas demais colunas...
Agora eu quero propor uma outra maneira de mapear e isto implica uma outra maneira de construir o algoritmo. O objetivo é que você ENTENDA os passos, construa o seu algortimo com calma.
Mapeie da seguinte maneira:
os polinômios P11, P22, P33, etc (os quais são dados do problema) são colocados na diagonal principal da matrix A (A[1][1], A[2][2], etc). Em seguida, os polinômios P12, P23, P34, etc, são colocados na diagonal seguinte (A[1][2], A[2][3], etc) . Os poliômios P123, P234, etc na outra diagonal (A[1][3], A[2][4], etc) e assim sucessivamente.
Este algoritmo terá uma fórmula de recorrência difente daquele feito em aula e também a maneira de variar os índices será outra.

Use os seguintes N=4 pontos como dados de entrada:

0.000000 0.000000

1.500000 0.997495

3.000000 0.141120

4.500000 -0.977530

Uma vez que o algoritmo esteja funcionando para N=4, use os seguintes N=9 pontos:

0.000000 0.000000

0.750000 0.681639

1.500000 0.997495

2.250000 0.778073

3.000000 0.141120

3.750000 -0.571561

4.500000 -0.977530

5.250000 -0.858935

6.000000 -0.279415

O ideal é fazer um programa que leia estes dados de dentro de um arquivo de entrada e faça a interpolação para um valor de N qualquer que o usuário queira.

3 - Use o algorimo construído em 2 para interpolar os seguintes N=11 pontos:

0.000000 -0.200000

0.600000 -0.227273

1.200000 -0.263158

1.800000 -0.312500

2.400000 -0.384615

3.000000 -0.500000

3.600000 -0.714286

4.200000 -1.250000

4.800000 -4.999993

5.400000 2.500002

6.000000 1.000000

Desenhe no gnuplot estes pontos e os valores interpolados pelo seu programa. Varie x entre 0 e 6 varrendo x a cada 0.2.

B) Zeros de Funções
------------------------------

Legenda para esta seção:
F(x) = f(x) + x

F'(x) é a derivada de F(x) com relação à x

Considere a função <math>f(x) = exp(-0.1*x)*sin(2*x)</math>.

4 - Faça no gnuplot um gráfico desta função dentro do intervalo pedido [-5:5]. Desenhe junto a linha y=0 para que você possa visualizar graficamente quantas raízes há neste intervalo.

5 - Retome o programa (fornecido em aula e que está no moodle) que calcula zeros de funções usando o método de Newton-Raphson e adapte-do para encotrar TODOS os zeros da função f(x) no intervalo [-5:5]. Imprima estas raízes num arquivo chamado raizes.dat.
Fundamental se dar conta de alguns "detalhes" antes de executar esta tarefa:
* Como o método de Newton-Raphson encontra apenas uma raiz para cada valor "chute" de x ("x_init"), então você deverá relançar o método várias vezes até encontrar todas as raízes do intervalo. Isto exige que você faça um loop variando "x_init" e, para cada x_init, você aplica o método de iteração.
* Note que o método pode (e provavelmente vai) encontrar a mesma raiz mais de uma vez. Você não deve estocar raízes repedidas! e isto implica que você deve pensar em uma maneira de fazer isto (dicas no final da lista para os que quiserem)

6 - Faça exatamente o mesmo procedimento que fizeste no problema 5 com o método de iteração simples. Uma vez feito o algoritmo do problema 5, basta você alterar a parte que calcula a iteração para usar o método de iteração simples visto em aula.
Usando este método, quantas raízes você consegue encontrar?
Calcule F'(x) para cada raiz encontrada no problema 5 e interprete o resultado que você acaba de obter à luz do que foi discutido em aula sobre a estabalidade do método de iteração simples.

7- método de bissecção: discuta brevemente as desvantagens deste método.

Dicas para o problema 5 (no ponto onde você vai verificar se a nova raiz encontrada já foi calculada)
a) você pode estocar as raízes em uma matriz (ex raizes[] ) e, a cada vez que o algoritmo encontra uma raiz, ele deve comparar com as demais raízes já estocadas na matriz raizes[].
b) quando você for comparar a nova raiz encontrada (digamos x) com os elementos da matriz raizes[] (digamos raizes[i]), perceba que você estará comparando números reais. Então cuidado com os operadores de igual (==) ou diferente (!=), pois um número será diferente do outro se e somente se todas os algarismos significativos o forem! portanto, ao invés de comparar se x!=raizes[i], faça fabs(x-raizes[i]) < PRECISAO, onde fmod(a) é o módulo de a.
c) não hesite em "debugar" o seu programa ! Isto vai ajudá-la(o) a entender o que há de errado.

C) Ajuste de curvas usando o método dos mínimos quadrados
------------------------------------------------------------------------------------

8) Dados os pontos;

x: 0.10 0.20 0.30 0.40 0.50 0.60 0.70 0.80 0.90 1.00

y: 0.62 0.63 0.64 0.66 0.68 0.71 0.76 0.81 0.89 1.00

Ajuste uma função do tipo f(x) = a0+a1*x+a2*x2 usando o método dos mínimos quadrados. Depois faça um gráfico usando os pontos da tabela e compare com a curva teórica que você calculou.

9) A resistência à compressão do concreto ( chamada de sigma ), decresce com o aumento da razão água/cimento (w/c, cuja unidade é em galões de água por saco de cimento). A resistência à compressão de várias amostras é dada na tabela a seguir:

w/c: 4.5 5.0 5.5 6.0 6.5 7.0 7.5 8.0 8.5 9.0

sigma: 7000 6125 5237 4665 4123 3810 3107 3070 2580 2287

Usando o método dos mínimos quadrados e utilizando uma função do tipo <math>g(x)= a *exp( -b * x )</math> , onde <math>g(x)=sigma</math> e <math>x=w/c</math>, ajuste o sigma aos dados da tabela.
Note que é possível linearizar a g(x) fazendo uma substituição de variável: <math>f(x) = ln(g(x)) = ln(a) - b x</math>. Isto recai exatamente na função linear <math>f(x)-=a0+a1x</math>, onde <math>a0=ln(a)</math> e <math>a1=-b</math>. É importante dar-se conta, no momento de ajustar a g(x), que você usou o <math>ln(g(x))</math> para chegar a sua forma linearizada. Portanto, no momento de ajustar os pontos forncecidos, você deve também transformar o "sigma" pela mesma função: <math>ln(sigma)</math>.

Grafique junto os pontos forncecidos na tabela acima com a função exponencial g(x) (usando obviamente os valores de a e b encontrados com o seu programa).

Área 3

2012-06-21T19:05:00Z

Caca:

A) Interpolação e Extrapolação
--------------------------------------------

1 - Explique a ideia do algoritmo de Neville (linhas gerais).

2 - Em aula fizemos um algoritmo que interpola um conjunto de pontos usando o algoritmo de Neville.
Na ocasião, eu propus que os polinômios fossem mapeados em uma matriz quadrada A de dimensão NxN, onde os elementos da primeira coluna eram os pontos P11, P22, P33, etc e os demais elementos eram colocados nas demais colunas...
Agora eu quero propor uma outra maneira de mapear e isto implica uma outra maneira de construir o algoritmo. O objetivo é que você ENTENDA os passos, construa o seu algortimo com calma.
Mapeie da seguinte maneira:
os polinômios P11, P22, P33, etc (os quais são dados do problema) são colocados na diagonal principal da matrix A (A[1][1], A[2][2], etc). Em seguida, os polinômios P12, P23, P34, etc, são colocados na diagonal seguinte (A[1][2], A[2][3], etc) . Os poliômios P123, P234, etc na outra diagonal (A[1][3], A[2][4], etc) e assim sucessivamente.
Este algoritmo terá uma fórmula de recorrência difente daquele feito em aula e também a maneira de variar os índices será outra.

Use os seguintes N=4 pontos como dados de entrada:

0.000000 0.000000

1.500000 0.997495

3.000000 0.141120

4.500000 -0.977530

Uma vez que o algoritmo esteja funcionando para N=4, use os seguintes N=9 pontos:

0.000000 0.000000

0.750000 0.681639

1.500000 0.997495

2.250000 0.778073

3.000000 0.141120

3.750000 -0.571561

4.500000 -0.977530

5.250000 -0.858935

6.000000 -0.279415

O ideal é fazer um programa que leia estes dados de dentro de um arquivo de entrada e faça a interpolação para um valor de N qualquer que o usuário queira.

3 - Use o algorimo construído em 2 para interpolar os seguintes N=11 pontos:

0.000000 -0.200000

0.600000 -0.227273

1.200000 -0.263158

1.800000 -0.312500

2.400000 -0.384615

3.000000 -0.500000

3.600000 -0.714286

4.200000 -1.250000

4.800000 -4.999993

5.400000 2.500002

6.000000 1.000000

Desenhe no gnuplot estes pontos e os valores interpolados pelo seu programa. Varie x entre 0 e 6 varrendo x a cada 0.2.

B) Zeros de Funções
------------------------------

Legenda para esta seção:
F(x) = f(x) + x

F'(x) é a derivada de F(x) com relação à x

Considere a função <math>f(x) = exp(-0.1*x)*sin(2*x)</math>.

4 - Faça no gnuplot um gráfico desta função dentro do intervalo pedido [-5:5]. Desenhe junto a linha y=0 para que você possa visualizar graficamente quantas raízes há neste intervalo.

5 - Retome o programa (fornecido em aula e que está no moodle) que calcula zeros de funções usando o método de Newton-Raphson e adapte-do para encotrar TODOS os zeros da função f(x) no intervalo [-5:5]. Imprima estas raízes num arquivo chamado raizes.dat.
Fundamental se dar conta de alguns "detalhes" antes de executar esta tarefa:
* Como o método de Newton-Raphson encontra apenas uma raiz para cada valor "chute" de x ("x_init"), então você deverá relançar o método várias vezes até encontrar todas as raízes do intervalo. Isto exige que você faça um loop variando "x_init" e, para cada x_init, você aplica o método de iteração.
* Note que o método pode (e provavelmente vai) encontrar a mesma raiz mais de uma vez. Você não deve estocar raízes repedidas! e isto implica que você deve pensar em uma maneira de fazer isto (dicas no final da lista para os que quiserem)

6 - Faça exatamente o mesmo procedimento que fizeste no problema 5 com o método de iteração simples. Uma vez feito o algoritmo do problema 5, basta você alterar a parte que calcula a iteração para usar o método de iteração simples visto em aula.
Usando este método, quantas raízes você consegue encontrar?
Calcule F'(x) para cada raiz encontrada no problema 5 e interprete o resultado que você acaba de obter à luz do que foi discutido em aula sobre a estabalidade do método de iteração simples.

7- método de bissecção: discuta brevemente as desvantagens deste método.

Dicas para o problema 5 (no ponto onde você vai verificar se a nova raiz encontrada já foi calculada)
a) você pode estocar as raízes em uma matriz (ex raizes[] ) e, a cada vez que o algoritmo encontra uma raiz, ele deve comparar com as demais raízes já estocadas na matriz raizes[].
b) quando você for comparar a nova raiz encontrada (digamos x) com os elementos da matriz raizes[] (digamos raizes[i]), perceba que você estará comparando números reais. Então cuidado com os operadores de igual (==) ou diferente (!=), pois um número será diferente do outro se e somente se todas os algarismos significativos o forem! portanto, ao invés de comparar se x!=raizes[i], faça fabs(x-raizes[i]) < PRECISAO, onde fmod(a) é o módulo de a.
c) não hesite em "debugar" o seu programa ! Isto vai ajudá-la(o) a entender o que há de errado.

C) Ajuste de curvas usando o método dos mínimos quadrados
------------------------------------------------------------------------------------

8) Dados os pontos;

x: 0.10 0.20 0.30 0.40 0.50 0.60 0.70 0.80 0.90 1.00

y: 0.62 0.63 0.64 0.66 0.68 0.71 0.76 0.81 0.89 1.00

Ajuste uma função do tipo f(x) = a0+a1*x+a2*x2 usando o método dos mínimos quadrados. Depois faça um gráfico usando os pontos da tabela e compare com a curva teórica que você calculou.

9) A resistência à compressão do concreto ( chamada de sigma ), decresce com o aumento da razão água/cimento (w/c, cuja unidade é em galões de água por saco de cimento). A resistência à compressão de várias amostras é dada na tabela a seguir:

w/c: 4.5 5.0 5.5 6.0 6.5 7.0 7.5 8.0 8.5 9.0

sigma: 7000 6125 5237 4665 4123 3810 3107 3070 2580 2287

Usando o método dos mínimos quadrados e utilizando uma função do tipo <math>g(x)= a *exp( -b * x )</math> , onde <math>g(x)=sigma</math> e <math>x=w/c</math> ajuste sigma aos dados da tabela.
Note que é possível linearizar a g(x) fazendo uma substituição de variável: <math>f(x) = ln(g(x)) = ln(a) - b x</math>. Isto recai exatamente na função linear <math>f(x)-=a0+a1x</math>, onde <math>a0=exp(a)</math> e <math>a1=-b</math>. É importante dar-se conta, no momento de ajustar a g(x), que você usou o <math>ln(g(x))</math> para chegar a sua forma linearizada. Portanto, no momento de ajustar os pontos forncecidos, você deve também transformar o "sigma" pela mesma função: <math>ln(sigma)</math>.

Grafique junto os pontos forncecidos na tabela acima com a função exponencial g(x) (usando obviamente os valores de a e b encontrados com o seu programa).

Área 3

2012-06-21T18:59:02Z

Caca:

A) Interpolação e Extrapolação
--------------------------------------------

1 - Explique a ideia do algoritmo de Neville (linhas gerais).

2 - Em aula fizemos um algoritmo que interpola um conjunto de pontos usando o algoritmo de Neville.
Na ocasião, eu propus que os polinômios fossem mapeados em uma matriz quadrada A de dimensão NxN, onde os elementos da primeira coluna eram os pontos P11, P22, P33, etc e os demais elementos eram colocados nas demais colunas...
Agora eu quero propor uma outra maneira de mapear e isto implica uma outra maneira de construir o algoritmo. O objetivo é que você ENTENDA os passos, construa o seu algortimo com calma.
Mapeie da seguinte maneira:
os polinômios P11, P22, P33, etc (os quais são dados do problema) são colocados na diagonal principal da matrix A (A[1][1], A[2][2], etc). Em seguida, os polinômios P12, P23, P34, etc, são colocados na diagonal seguinte (A[1][2], A[2][3], etc) . Os poliômios P123, P234, etc na outra diagonal (A[1][3], A[2][4], etc) e assim sucessivamente.
Este algoritmo terá uma fórmula de recorrência difente daquele feito em aula e também a maneira de variar os índices será outra.

Use os seguintes N=4 pontos como dados de entrada:

0.000000 0.000000

1.500000 0.997495

3.000000 0.141120

4.500000 -0.977530

Uma vez que o algoritmo esteja funcionando para N=4, use os seguintes N=9 pontos:

0.000000 0.000000

0.750000 0.681639

1.500000 0.997495

2.250000 0.778073

3.000000 0.141120

3.750000 -0.571561

4.500000 -0.977530

5.250000 -0.858935

6.000000 -0.279415

O ideal é fazer um programa que leia estes dados de dentro de um arquivo de entrada e faça a interpolação para um valor de N qualquer que o usuário queira.

3 - Use o algorimo construído em 8 para interpolar os seguintes N=11 pontos:

0.000000 -0.200000

0.600000 -0.227273

1.200000 -0.263158

1.800000 -0.312500

2.400000 -0.384615

3.000000 -0.500000

3.600000 -0.714286

4.200000 -1.250000

4.800000 -4.999993

5.400000 2.500002

6.000000 1.000000

Desenhe no gnuplot estes pontos e os valores interpolados pelo seu programa. Varie x entre 0 e 6 varrendo x a cada 0.2.

B) Zeros de Funções
------------------------------

Legenda para esta seção:
F(x) = f(x) + x

F'(x) é a derivada de F(x) com relação à x

Considere a função <math>f(x) = exp(-0.1*x)*sin(2*x)</math>.

4 - Faça no gnuplot um gráfico desta função dentro do intervalo pedido [-5:5]. Desenhe junto a linha y=0 para que você possa visualizar graficamente quantas raízes há neste intervalo.

5 - Retome o programa (fornecido em aula e que está no moodle) que calcula zeros de funções usando o método de Newton-Raphson e adapte-do para encotrar TODOS os zeros da função f(x) no intervalo [-5:5]. Imprima estas raízes num arquivo chamado raizes.dat.
Fundamental se dar conta de alguns "detalhes" antes de executar esta tarefa:
* Como o método de Newton-Raphson encontra apenas uma raiz para cada valor "chute" de x ("x_init"), então você deverá relançar o método várias vezes até encontrar todas as raízes do intervalo. Isto exige que você faça um loop variando "x_init" e, para cada x_init, você aplica o método de iteração.
* Note que o método pode (e provavelmente vai) encontrar a mesma raiz mais de uma vez. Você não deve estocar raízes repedidas! e isto implica que você deve pensar em uma maneira de fazer isto (dicas no final da lista para os que quiserem)

6 - Faça exatamente o mesmo procedimento que fizeste no problema 5 com o método de iteração simples. Uma vez feito o algoritmo do problema 5, basta você alterar a parte que calcula a iteração para usar o método de iteração simples visto em aula.
Usando este método, quantas raízes você consegue encontrar?
Calcule F'(x) para cada raiz encontrada no problema 5 e interprete o resultado que você acaba de obter à luz do que foi discutido em aula sobre a estabalidade do método de iteração simples.

7- método de bissecção: discuta brevemente as desvantagens deste método.

Dicas para o problema 5 (no ponto onde você vai verificar se a nova raiz encontrada já foi calculada)
a) você pode estocar as raízes em uma matriz (ex raizes[] ) e, a cada vez que o algoritmo encontra uma raiz, ele deve comparar com as demais raízes já estocadas na matriz raizes[].
b) quando você for comparar a nova raiz encontrada (digamos x) com os elementos da matriz raizes[] (digamos raizes[i]), perceba que você estará comparando números reais. Então cuidado com os operadores de igual (==) ou diferente (!=), pois um número será diferente do outro se e somente se todas os algarismos significativos o forem! portanto, ao invés de comparar se x!=raizes[i], faça fabs(x-raizes[i]) < PRECISAO, onde fmod(a) é o módulo de a.
c) não hesite em "debugar" o seu programa ! Isto vai ajudá-la(o) a entender o que há de errado.

C) Ajuste de curvas usando o método dos mínimos quadrados
------------------------------------------------------------------------------------

8) Dados os pontos;

x: 0.10 0.20 0.30 0.40 0.50 0.60 0.70 0.80 0.90 1.00

y: 0.62 0.63 0.64 0.66 0.68 0.71 0.76 0.81 0.89 1.00

Ajuste uma função do tipo f(x) = a0+a1*x+a2*x2 usando o método dos mínimos quadrados. Depois faça um gráfico usando os pontos da tabela e compare com a curva teórica que você calculou.

9) A resistência à compressão do concreto ( chamada de sigma ), decresce com o aumento da razão água/cimento (w/c, cuja unidade é em galões de água por saco de cimento). A resistência à compressão de várias amostras é dada na tabela a seguir:

w/c: 4.5 5.0 5.5 6.0 6.5 7.0 7.5 8.0 8.5 9.0

sigma: 7000 6125 5237 4665 4123 3810 3107 3070 2580 2287

Usando o método dos mínimos quadrados e utilizando uma função do tipo <math>g(x)= a *exp( -b * x )</math> , onde <math>g(x)=sigma</math> e <math>x=w/c</math> ajuste sigma aos dados da tabela.
Note que é possível linearizar a g(x) fazendo uma substituição de variável: <math>f(x) = ln(g(x)) = ln(a) - b x</math>. Isto recai exatamente na função linear <math>f(x)-=a0+a1x</math>, onde <math>a0=exp(a)</math> e <math>a1=-b</math>. É importante dar-se conta, no momento de ajustar a g(x), que você usou o <math>ln(g(x))</math> para chegar a sua forma linearizada. Portanto, no momento de ajustar os pontos forncecidos, você deve também transformar o "sigma" pela mesma função: <math>ln(sigma)</math>.

Grafique junto os pontos forncecidos na tabela acima com a função exponencial g(x) (usando obviamente os valores de a e b encontrados com o seu programa).

Área 3

2012-06-21T18:52:19Z

Caca:

A) Interpolação e Extrapolação
--------------------------------------------

1 - Explique a ideia do algoritmo de Neville (linhas gerais).

2 - Em aula fizemos um algoritmo que interpola um conjunto de pontos usando o algoritmo de Neville.
Na ocasião, eu propus que os polinômios fossem mapeados em uma matriz quadrada A de dimensão NxN, onde os elementos da primeira coluna eram os pontos P11, P22, P33, etc e os demais elementos eram colocados nas demais colunas...
Agora eu quero propor uma outra maneira de mapear e isto implica uma outra maneira de construir o algoritmo. O objetivo é que você ENTENDA os passos, construa o seu algortimo com calma.
Mapeie da seguinte maneira:
os polinômios P11, P22, P33, etc (os quais são dados do problema) são colocados na diagonal principal da matrix A (A[1][1], A[2][2], etc). Em seguida, os polinômios P12, P23, P34, etc, são colocados na diagonal seguinte (A[1][2], A[2][3], etc) . Os poliômios P123, P234, etc na outra diagonal (A[1][3], A[2][4], etc) e assim sucessivamente.
Este algoritmo terá uma fórmula de recorrência difente daquele feito em aula e também a maneira de variar os índices será outra.

Use os seguintes N=4 pontos como dados de entrada:

0.000000 0.000000

1.500000 0.997495

3.000000 0.141120

4.500000 -0.977530

Uma vez que o algoritmo esteja funcionando para N=4, use os seguintes N=9 pontos:

0.000000 0.000000

0.750000 0.681639

1.500000 0.997495

2.250000 0.778073

3.000000 0.141120

3.750000 -0.571561

4.500000 -0.977530

5.250000 -0.858935

6.000000 -0.279415

O ideal é fazer um programa que leia estes dados de dentro de um arquivo de entrada e faça a interpolação para um valor de N qualquer que o usuário queira.

3 - Use o algorimo construído em 8 para interpolar os seguintes N=11 pontos:

0.000000 -0.200000

0.600000 -0.227273

1.200000 -0.263158

1.800000 -0.312500

2.400000 -0.384615

3.000000 -0.500000

3.600000 -0.714286

4.200000 -1.250000

4.800000 -4.999993

5.400000 2.500002

6.000000 1.000000

Desenhe no gnuplot estes pontos e os valores interpolados pelo seu programa. Varie x entre 0 e 6 varrendo x a cada 0.2.

B) Zeros de Funções
------------------------------

Legenda para esta seção:
F(x) = f(x) + x

F'(x) é a derivada de F(x) com relação à x

Considere a função <math>f(x) = exp(-0.1*x)*sin(2*x)</math>.

4 - Faça no gnuplot um gráfico desta função dentro do intervalo pedido [-5:5]. Desenhe junto a linha y=0 para que você possa visualizar graficamente quantas raízes há neste intervalo.

5 - Retome o programa (fornecido em aula e que está no moodle) que calcula zeros de funções usando o método de Newton-Raphson e adapte-do para encotrar TODOS os zeros da função f(x) no intervalo [-5:5]. Imprima estas raízes num arquivo chamado raizes.dat.
Fundamental se dar conta de alguns "detalhes" antes de executar esta tarefa:
* Como o método de Newton-Raphson encontra apenas uma raiz para cada valor "chute" de x ("x_init"), então você deverá relançar o método várias vezes até encontrar todas as raízes do intervalo. Isto exige que você faça um loop variando "x_init" e, para cada x_init, você aplica o método de iteração.
* Note que o método pode (e provavelmente vai) encontrar a mesma raiz mais de uma vez. Você não deve estocar raízes repedidas! e isto implica que você deve pensar em uma maneira de fazer isto (dicas no final da lista para os que quiserem)

6 - Faça exatamente o mesmo procedimento que fizeste no problema 5 com o método de iteração simples. Uma vez feito o algoritmo do problema 5, basta você alterar a parte que calcula a iteração para usar o método de iteração simples visto em aula.
Usando este método, quantas raízes você consegue encontrar?
Calcule F'(x) para cada raiz encontrada no problema 5 e interprete o resultado que você acaba de obter à luz do que foi discutido em aula sobre a estabalidade do método de iteração simples.

7- método de bissecção: discuta brevemente as desvantagens deste método.

Dicas para o problema 5 (no ponto onde você vai verificar se a nova raiz encontrada já foi calculada)
a) você pode estocar as raízes em uma matriz (ex raizes[] ) e, a cada vez que o algoritmo encontra uma raiz, ele deve comparar com as demais raízes já estocadas na matriz raizes[].
b) quando você for comparar a nova raiz encontrada (digamos x) com os elementos da matriz raizes[] (digamos raizes[i]), perceba que você estará comparando números reais. Então cuidado com os operadores de igual (==) ou diferente (!=), pois um número será diferente do outro se e somente se todas os algarismos significativos o forem! portanto, ao invés de comparar se x!=raizes[i], faça fabs(x-raizes[i]) < PRECISAO, onde fmod(a) é o módulo de a.
c) não hesite em "debugar" o seu programa ! Isto vai ajudá-la(o) a entender o que há de errado.

C) Ajuste de curvas usando o método dos mínimos quadrados
------------------------------------------------------------------------------------

8) Dados os pontos;

x: 0.10 0.20 0.30 0.40 0.50 0.60 0.70 0.80 0.90 1.00

y: 0.62 0.63 0.64 0.66 0.68 0.71 0.76 0.81 0.89 1.00

Ajuste uma função do tipo f(x) = a0+a1*x+a2*x2 usando o método dos mínimos quadrados. Depois faça um gráfico usando os pontos da tabela e compare com a curva teórica que você calculou.

9) A resistência à compressão do concreto ( chamada de sigma ), decresce com o aumento da razão água/cimento (w/c, cuja unidade é em galões de água por saco de cimento). A resistência à compressão de várias amostras é dada na tabela a seguir:

w/c: 4.5 5.0 5.5 6.0 6.5 7.0 7.5 8.0 8.5 9.0

sigma: 7000 6125 5237 4665 4123 3810 3107 3070 2580 2287

Usando o método dos mínimos quadrados e utilizando uma função do tipo f(x)= a *exp( f * x ), onde <math>f(x)=sigma</math> e <math>x=w/c</math> ajuste sigma aos dados da tabela.
Note que é possível linearizar a f(x) fazendo uma substituição de variável: <math>f2(x) = ln*f(x) = ln(a) - b x</math>. Isto recai exatamente na função linear <math>f(x)-=a0+a1x</math>, onde <math>a0=exp(a)</math> e <math>a1=-b</math>.
Grafique os pontos da tabela e a função obtida.

Área 2

2012-05-21T18:59:29Z

Caca:

A) "tecnicalidades"
--------------------------

O que estes programas escrevem na tela?

1)
<pre>
...
j=0;
do{
j++;
i = 4*j ;
printf("i=%d j=%d \n", i, j) ;
}while(i<=10) ;
printf("\n j=%d \n", j) ;
...
</pre>

2)

<pre>
...
for(j=0 ; j<3 ; j++)
{
printf(" j=%d \n\n", j );
for(i=j; i<3 ; i++)
{
k=i+j ;
printf("i=%d k=%d\n", i, k);
}
}
...
</pre>

3) Abaixo você encontra partes de programas. Eles contêm erros. Identifique-os e pense no que você faria para resolvê-los.

3.a) Ponto a ser observado: uso de variáreis globais e/ou locais

<pre>
...
float A ;
void main()
{
float B ;
operações dentro da função main() ...
}
float Soma()
{
return (A+B);
}
...
</pre>

Como você faria para construir uma função que retornasse a soma de dois números reais?

3.b) Ponto a ser observado: alocação estática de memória

<pre>
...
main()
{
int i;
float mat1[ i ] ;

for (i=0; i<10; i++)
mat1[ i ] = (float)rand()/RAND_MAX ;
}
...
</pre>

B) Derivação e integração numéricas
------------------------------------------------------

Legenda para esta seção:

f'(x) : derivada primeira da função f(x)
h = (xb-xa)/N , xa, xb são início e fim do intervalo de intregração respectivamente e N é o número de vezes que este intervalo é dividido.
Considere as seguintes funções

<math>f(x) = x^2 + 6x</math>

<math>g(x) = 1/(x+3) </math>

<math>p(x)=exp(-x)/(x^3-1)</math>

1- Usando o método da derivada à direita, calcule f'(x) nos pontos x=-2 e 2.
Como você sabe se o valor encontrado é correto sem calcular o valor analítico de f'(x) ?

2- Use o mesmo programa feito em (1) para calcular g'(-10), g'(-2).
Faça h variar de <math>h=10^{-10}</math> até h=1.
O intervalo de h durante o qual g'(x) é constante é o mesmo para x=-10 e para x=-2? Como você interpreta isto?

3- Informação: o erro associado ao método da derivada à direita é linear em h, enquanto o método da derivada centrada tem um erro da ordem de h2.

3a - O que significa isto?

3b - Mostre analiticamente (dica: se baseia no que está feito na complex-wiki e foi discutido em aula)

4 - Use o método da derivada centrada para calcular a derivada da função p(x) nos pontos x: -2, 0.5, 2 e 5. Para cada um destes pontos, faça "h" variar bastante (digamos, entre 10-10 e 1) e compare os resultatos num gráfico feito em gnuplot. Faça um gráfico com as curvas p'(x) em todos os pontos pedidos com seus respectivos valores analíticos comparativos. Note que o intervalo para o qual a derivada numérica converge para o seu valor analítico depende da proximidade do valor de x ao ponto de divergência da função g(x). Por quê?

5 - Construa um programa usando o método de Simpson para calcular a integral de g(x) entre -10 e -4.
Compare a precisão do resultado obtido com o programa feito em aula onde aplicamos o método do trapézio.

6 - Aplique o método de Simpson para diversos valores de N. Calcule o erro usando Erro(N) = |Int(N)-Int(N-2)|/|Int(N)|, onde Int(N) é o valor da integral de g(x) para um dado N. Faça este processo até que o erro atinja um valor mínimo estipulado pelo usuário.

7 - Mostre analiticamente que o método do trapézio tem um erro da ordem de f''(x)*h3.
Dica para fazer esta demonstração:

1- escreva a expressão da regra do trapézio para a f(x) E compare-a com o valor exato de uma integral da f(x)

2- expanda a expressão f(x) na expressão do trapézio E na expressão do valor exato

3- compare termo a termo as duas expressões. Você verá que os termos são idênticos até a ordem <math>h^2</math>. A partir de <math>h^3</math> eles têm uma diferença.

PS: O algoritmo de Simpson tem um erro da ordem de <math>h^5*f(4)</math> . O procedimento para demonstração é o mesmo, mas neste é mais longo. Faça se quiser, mas o importante é que você entenda a idéia.

Área 1

2012-04-24T17:05:44Z

Caca:

Abaixo há exercícios e/ou problemas bem diversos, com vários níveis de dificuldade. Tente fazer todos ou pelo menos pensar sobre todos. Os primeiros são os mesmos do trabalho 4 e voce já deve ter feito 2 deles. Pense e tente fazer os demais.Quando for pedido apenas para fazer o algoritmo, faça também o programa.

1) Faça um algoritmo para calcular a mensalidade pelos alunos de uma academia de ginástica que tem como mensalidade básica R$85 e aplica os seguintes descontos

- mulheres com idade igual ou inferior a 15 anos terão desconto de 15%

- mulheres com idade superior a 15 anos terão desconto de 10%

- homens com idade inferior a 22 anos não terão desconto

- homens com idade igual ou superior a 22 anos terão desconto de 20%

2) Faça um algoritmo para calcular a nota resultante de um aluno que fez 3 provas. A nota é definida como sendo a média aritmética das 3 provas.

Considere a seguinte tabela:

- aprovado se nota >= 7

- em exame se 5 <= nota < 7

- reprovado se nota < 5

3) Faça um algoritmo que determine se um dado número [escolhido pelo usuário e lido pelo algoritmo] é par.

4) Faça um algoritmo que determine se um dado número [escolhido pelo usuário e lido pelo algoritmo] é primo

5) Faça um algoritmo que leia 3 números da tela e os retorne em

5.1- ordem crescente

5.2- ordem decrescente

6) Faça um algortimo para determinar todos os divisores do número N que estão entre os inteiros i1 e i2

7) Peça para o usuário entrar com um valor de temperatura em Celsius, transforme para Fahrenheit e coloque o valor na tela.

8) Calcule os zeros de uma função de segundo grau (ax2+bx+c=0).

a) na primeira versão, peça para o usuário entrar com os valores de "a" e "b".

b) na segunda versão, crie um arquivo com os parâmetros "a" e "b" e leia-os a partir de um arquivo externo ao programa

Em ambos os casos, não esqueça de verificar as limitações e ambiguidades do algoritmo que fará este cálculo.

9) Peça para o usuário escolher um número N. Determine se este número N é primo ou não e diga para o usuário.
Use o algoritmo feito em 4) para fazer um programa em C.
Coloque o programa num arquivo de latex. Use o comando "verbatim"

10) Construa duas matrizes de duas dimensões de inteiros, digamos A[N][M] e B[M][N]. Elas não precisam ter mesma dimensão, ou seja, N e M não são necessariamente os mesmos.
Primeiramente escolha M e N pequenos (em torno de 2 ou 3) para que você possa imprimi-las na tela.
Depois calcule o produto de A por B e mostre a matriz resultante na tela tb.
Crie de dentro do seu programa um arquivo de saída que contenha as matrizes A, B e o produto das duas.

11) Leia o arquivo "dados.dat" que está no moodle e coloque-os numa matriz do tipo "float" que se chama, por exemplo X.
Considerando a sequência de números X[i], faça:

a) Encontre o valor máximo desta sequencia de números

b) Ordene esta sequência de menor à maior

12) Números de Fibonacci são uma sequência definida como recursiva pela fórmula abaixo:

:<math>F(n) =\left\{ \begin{matrix} 0\,,\qquad\qquad\qquad\quad\,\ \ \,&&\mbox{se }n=0\,;\ \ \\ 1,\qquad\qquad\qquad\qquad\,&&\mbox{se }n=1;\ \ \,\\ F(n-1)+F(n-2)&&\mbox{outros casos.} \end{matrix} \right. </math>

Na prática: você começa com 0 e 1, e então produz o próximo número de Fibonacci somando os dois anteriores para formar o próximo. Os primeiros Números de Fibonacci para n = 0, 1,… são

0,1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946…

Faça um programa que gera uma sequência de Fibonacci. Peça para o usuário escolher quantos termos da série serão mostrados.
Coloque a sequência num arquivo (você deve abri-lo e escrever nele de dentro do programa). Chame este arquivo usando um script em gnuplot e faça um gráfico em eps.

13) Faça um programa que calcule o ln(1+x), |x| < 1 com base na expansão em serie de Taylor:

<math>ln(1+x)=\sum_{n=0}^{n=\infty}\frac{(-1)^n}{n+1}x^{n+1}</math>

Note: num programa você não poderá somar termos infinitamente. O somatório deverá ser de 0 até N. Teste vários valores de N para verificar quando o log(1+x) converge. Você pode comparar com o valor que você obtém se fizer o cálculo na calculadora.

O usuário deve fornecer os valores de x e N e você deve verificar no seu programa que o |x| é menor do que 1

14) Em t=0 um bloco de massa <math>m=2kg</math> é lançado no campo gravitacional terrestre a partir do solo (<math>x_0=0;y_0=0</math>) com velocidade inicial <math>\vec{v_0}=v_{0x}\vec{i}+v_{0y}\vec{j}</math>. Considere <math>g=-10m/s^2</math>.

a- Faça um programa ara determinar os vetores posição e velocidade do desse bloco para sucessivos valores de tempo <math>t</math> separados por
um intervalo <math>\Delta t = t_{max}/100</math>, onde <math>t_{max}</math> é o tempo que leva para o corpo voltar ao solo. O programa deve parar neste momento.

b- Faça gráficos da trajetória e do módulo da velocidade para
as seguintes condições iniciais (em m/s):

b1) <math>v_0= 1 \vec{i}+ 5\vec{j}</math>

b2) <math>v_0= 2 \vec{i}+ 5\vec{j}</math>

b3) <math>v_0= 1 \vec{i}+ 8\vec{j}</math>

b4) <math>v_0= 2 \vec{i}+ 8\vec{j}</math>

b5) <math>v_0= 3 \vec{i}+ 8\vec{j}</math>

15 - Em <math>t=0</math> o motorista de um carro de <math>m=700kg</math>$ que se move a <math>32m/s</math> percebe um obstáculo (parado) na pista <math>L</math> metros à sua frente. Sem tentar desviar, o motorista freia com aceleração <math>a=-8m/s^2</math>$ até parar (ou bater).

15a) Faça um algoritmo para determinar a posição (suponha <math>x=0</math>) e a velocidade desse carro para sucessivos valores de tempo <math>t</math> separados por um intervalo <math>\Delta t=0.1s</math>. O programa deve indicar a se o carro atingiu o obstáculo ou não. Caso não tenha atingido, deve indicar a distância ao obstáculo.

15b) Faça um programa para o algoritmo da questão anterior. A distância do obstáculo deve ser lida como entrada. A saída deve mostrar na tela se houve ou não colisão. Caso não haja, deve indicar a distância até o obstáculo. Além disso, os valores de posição contra tempo e velocidade
contra tempo devem ser escritos em um arquivo de três colunas <math>(t,x,v)</math> de nome ``dadosCarro.dat''. Teste seu programa para as seguintes
distâncias ao obstáculo: <math> L= 40, 50, 60 </math>

Área 1

2012-04-22T07:11:22Z

Caca:

Abaixo há exercícios e/ou problemas bem diversos, com vários níveis de dificuldade. Tente fazer todos ou pelo menos pensar sobre todos. Os primeiros são os mesmos do trabalho 4 e voce já deve ter feito 2 deles. Pense e tente fazer os demais.Quando for pedido apenas para fazer o algoritmo, faça também o programa.

1) Faça um algoritmo para calcular a mensalidade pelos alunos de uma academia de ginástica que tem como mensalidade básica R$85 e aplica os seguintes descontos

- mulheres com idade igual ou inferior a 15 anos terão desconto de 15%

- mulheres com idade superior a 15 anos terão desconto de 10%

- homens com idade inferior a 22 anos não terão desconto

- homens com idade igual ou superior a 22 anos terão desconto de 20%

2) Faça um algoritmo para calcular a nota resultante de um aluno que fez 3 provas. A nota é definida como sendo a média aritmética das 3 provas.

Considere a seguinte tabela:

- aprovado se nota >= 7

- em exame se 5 <= nota < 7

- reprovado se nota < 5

3) Faça um algoritmo que determine se um dado número [escolhido pelo usuário e lido pelo algoritmo] é par.

4) Faça um algoritmo que determine se um dado número [escolhido pelo usuário e lido pelo algoritmo] é primo

5) Faça um algoritmo que leia 3 números da tela e os retorne em

5.1- ordem crescente

5.2- ordem decrescente

6) Faça um algortimo para determinar todos os divisores do número N que estão entre os inteiros i1 e i2

7) Peça para o usuário entrar com um valor de temperatura em Celsius, transforme para Fahrenheit e coloque o valor na tela.

8) Calcule os zeros de uma função de segundo grau (ax2+bx+c=0).

a) na primeira versão, peça para o usuário entrar com os valores de "a" e "b".

b) na segunda versão, crie um arquivo com os parâmetros "a" e "b" e leia-os a partir de um arquivo externo ao programa

Em ambos os casos, não esqueça de verificar as limitações e ambiguidades do algoritmo que fará este cálculo.

9) Peça para o usuário escolher um número N. Determine se este número N é primo ou não e diga para o usuário.
Use o algoritmo feito em 4) para fazer um programa em C.
Coloque o programa num arquivo de latex. Use o comando "verbatim"

10) Construa duas matrizes de duas dimensões de inteiros, digamos A[N][M] e B[M][N]. Elas não precisam ter mesma dimensão, ou seja, N e M não são necessariamente os mesmos.
Primeiramente escolha M e N pequenos (em torno de 2 ou 3) para que você possa imprimi-las na tela.
Depois calcule o produto de A por B e mostre a matriz resultante na tela tb.
Crie de dentro do seu programa um arquivo de saída que contenha as matrizes A, B e o produto das duas.

11) Leia o arquivo "dados.dat" que está no moodle e coloque-os numa matriz do tipo "float" que se chama, por exemplo X.
Considerando a sequência de números X[i], faça:

a) Encontre o valor máximo desta sequencia de números

b) Ordene esta sequência de menor à maior

12) Números de Fibonacci são uma sequência definida como recursiva pela fórmula abaixo:

:<math>F(n) =\left\{ \begin{matrix} 0\,,\qquad\qquad\qquad\quad\,\ \ \,&&\mbox{se }n=0\,;\ \ \\ 1,\qquad\qquad\qquad\qquad\,&&\mbox{se }n=1;\ \ \,\\ F(n-1)+F(n-2)&&\mbox{outros casos.} \end{matrix} \right. </math>

Na prática: você começa com 0 e 1, e então produz o próximo número de Fibonacci somando os dois anteriores para formar o próximo. Os primeiros Números de Fibonacci para n = 0, 1,… são

0,1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946…

Faça um programa que gera uma sequência de Fibonacci. Peça para o usuário escolher quantos termos da série serão mostrados.
Coloque a sequência num arquivo (você deve abri-lo e escrever nele de dentro do programa). Chame este arquivo usando um script em gnuplot e faça um gráfico em eps.

13) Faça um programa que calcule o log(1+x), |x| < 1 com base na expansão em serie de Taylor:

Note: num programa você não poderá somar termos infinitamente. O somatório deverá ser de 1 até N. Teste vários valores de N para verificar quando o log(1+x) converge. Você pode comparar com o valor que você obtém se fizer o cálculo na calculadora.

O usuário deve fornecer os valores de x e N e você deve verificar no seu programa que o |x| é menor do que 1

14) Em t=0 um bloco de massa <math>m=2kg</math> é lançado no campo gravitacional terrestre a partir do solo (<math>x_0=0;y_0=0</math>) com velocidade inicial <math>\vec{v_0}=v_{0x}\vec{i}+v_{0y}\vec{j}</math>. Considere <math>g=-10m/s^2</math>.

a- Faça um programa ara determinar os vetores posição e velocidade do desse bloco para sucessivos valores de tempo <math>t</math> separados por
um intervalo <math>\Delta t = t_{max}/100</math>, onde <math>t_{max}</math> é o tempo que leva para o corpo voltar ao solo. O programa deve parar neste momento.

b- Faça gráficos da trajetória e do módulo da velocidade para
as seguintes condições iniciais (em m/s):

b1) <math>v_0= 1 \vec{i}+ 5\vec{j}</math>

b2) <math>v_0= 2 \vec{i}+ 5\vec{j}</math>

b3) <math>v_0= 1 \vec{i}+ 8\vec{j}</math>

b4) <math>v_0= 2 \vec{i}+ 8\vec{j}</math>

b5) <math>v_0= 3 \vec{i}+ 8\vec{j}</math>

15 - Em <math>t=0</math> o motorista de um carro de <math>m=700kg</math>$ que se move a <math>32m/s</math> percebe um obstáculo (parado) na pista <math>L</math> metros à sua frente. Sem tentar desviar, o motorista freia com aceleração <math>a=-8m/s^2</math>$ até parar (ou bater).

15a) Faça um algoritmo para determinar a posição (suponha <math>x=0</math>) e a velocidade desse carro para sucessivos valores de tempo <math>t</math> separados por um intervalo <math>\Delta t=0.1s</math>. O programa deve indicar a se o carro atingiu o obstáculo ou não. Caso não tenha atingido, deve indicar a distância ao obstáculo.

15b) Faça um programa para o algoritmo da questão anterior. A distância do obstáculo deve ser lida como entrada. A saída deve mostrar na tela se houve ou não colisão. Caso não haja, deve indicar a distância até o obstáculo. Além disso, os valores de posição contra tempo e velocidade
contra tempo devem ser escritos em um arquivo de três colunas <math>(t,x,v)</math> de nome ``dadosCarro.dat''. Teste seu programa para as seguintes
distâncias ao obstáculo: <math> L= 40, 50, 60 </math>

Área 1

2012-04-22T07:05:27Z

Caca:

Abaixo há exercícios e/ou problemas bem diversos, com vários níveis de dificuldade. Tente fazer todos ou pelo menos pensar sobre todos. Os primeiros são os mesmos do trabalho 4 e voce já deve ter feito 2 deles; pense e tente fazer os demais.
Quando for pedido apenas para fazer o algoritmo, faça também o programa.

1) Faça um algoritmo para calcular a mensalidade pelos alunos de uma academia de ginástica que tem como mensalidade básica R$85 e aplica os seguintes descontos

- mulheres com idade igual ou inferior a 15 anos terão desconto de 15%

- mulheres com idade superior a 15 anos terão desconto de 10%

- homens com idade inferior a 22 anos não terão desconto

- homens com idade igual ou superior a 22 anos terão desconto de 20%

2) Faça um algoritmo para calcular a nota resultante de um aluno que fez 3 provas. A nota é definida como sendo a média aritmética das 3 provas.

Considere a seguinte tabela:

- aprovado se nota >= 7

- em exame se 5 <= nota < 7

- reprovado se nota < 5

3) Faça um algoritmo que determine se um dado número [escolhido pelo usuário e lido pelo algoritmo] é par.

4) Faça um algoritmo que determine se um dado número [escolhido pelo usuário e lido pelo algoritmo] é primo

5) Faça um algoritmo que leia 3 números da tela e os retorne em

5.1- ordem crescente

5.2- ordem decrescente

6) Faça um algortimo para determinar todos os divisores do número N que estão entre os inteiros i1 e i2

7) Peça para o usuário entrar com um valor de temperatura em Celsius, transforme para Fahrenheit e coloque o valor na tela.

8) Calcule os zeros de uma função de segundo grau (ax2+bx+c=0).

a) na primeira versão, peça para o usuário entrar com os valores de "a" e "b".

b) na segunda versão, crie um arquivo com os parâmetros "a" e "b" e leia-os a partir de um arquivo externo ao programa

Em ambos os casos, não esqueça de verificar as limitações e ambiguidades do algoritmo que fará este cálculo.

9) Peça para o usuário escolher um número N. Determine se este número N é primo ou não e diga para o usuário.
Use o algoritmo feito em 4) para fazer um programa em C.
Coloque o programa num arquivo de latex. Use o comando "verbatim"

10) Construa duas matrizes de duas dimensões de inteiros, digamos A[N][M] e B[M][N]. Elas não precisam ter mesma dimensão, ou seja, N e M não são necessariamente os mesmos.
Primeiramente escolha M e N pequenos (em torno de 2 ou 3) para que você possa imprimi-las na tela.
Depois calcule o produto de A por B e mostre a matriz resultante na tela tb.
Crie de dentro do seu programa um arquivo de saída que contenha as matrizes A, B e o produto das duas.

11) Leia o arquivo "dados.dat" que está no moodle e coloque-os numa matriz do tipo "float" que se chama, por exemplo X.
Considerando a sequência de números X[i], faça:

a) Encontre o valor máximo desta sequencia de números

b) Ordene esta sequência de menor à maior

12) Números de Fibonacci são uma sequência definida como recursiva pela fórmula abaixo:

:<math>F(n) =\left\{ \begin{matrix} 0\,,\qquad\qquad\qquad\quad\,\ \ \,&&\mbox{se }n=0\,;\ \ \\ 1,\qquad\qquad\qquad\qquad\,&&\mbox{se }n=1;\ \ \,\\ F(n-1)+F(n-2)&&\mbox{outros casos.} \end{matrix} \right. </math>

Na prática: você começa com 0 e 1, e então produz o próximo número de Fibonacci somando os dois anteriores para formar o próximo. Os primeiros Números de Fibonacci para n = 0, 1,… são

0,1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946…

Faça um programa que gera uma sequência de Fibonacci. Peça para o usuário escolher quantos termos da série serão mostrados.
Coloque a sequência num arquivo (você deve abri-lo e escrever nele de dentro do programa). Chame este arquivo usando um script em gnuplot e faça um gráfico em eps.

13) Faça um programa que calcule o log(1+x), |x| < 1 com base na expansão em serie de Taylor:

Note: num programa você não poderá somar termos infinitamente. O somatório deverá ser de 1 até N. Teste vários valores de N para verificar quando o log(1+x) converge. Você pode comparar com o valor que você obtém se fizer o cálculo na calculadora.

O usuário deve fornecer os valores de x e N e você deve verificar no seu programa que o |x| é menor do que 1

14) Em t=0 um bloco de massa <math>m=2kg</math> é lançado no campo gravitacional terrestre a partir do solo (<math>x_0=0;y_0=0</math>) com velocidade inicial <math>\vec{v_0}=v_{0x}\vec{i}+v_{0y}\vec{j}</math>. Considere <math>g=-10m/s^2</math>.

a- Faça um programa ara determinar os vetores posição e velocidade do desse bloco para sucessivos valores de tempo <math>t</math> separados por
um intervalo <math>\Delta t = t_{max}/100</math>, onde <math>t_{max}</math> é o tempo que leva para o corpo voltar ao solo. O programa deve parar neste momento.

b- Faça gráficos da trajetória e do módulo da velocidade para
as seguintes condições iniciais (em m/s):

b1) <math>v_0= 1 \vec{i}+ 5\vec{j}</math>

b2) <math>v_0= 2 \vec{i}+ 5\vec{j}</math>

b3) <math>v_0= 1 \vec{i}+ 8\vec{j}</math>

b4) <math>v_0= 2 \vec{i}+ 8\vec{j}</math>

b5) <math>v_0= 3 \vec{i}+ 8\vec{j}</math>

15 - Em <math>t=0</math> o motorista de um carro de <math>m=700kg</math>$ que se move a <math>32m/s</math> percebe um obstáculo (parado) na pista <math>L</math> metros à sua frente. Sem tentar desviar, o motorista freia com aceleração <math>a=-8m/s^2</math>$ até parar (ou bater).

15a) Faça um algoritmo para determinar a posição (suponha <math>x=0</math>) e a velocidade desse carro para sucessivos valores de tempo <math>t</math> separados por um intervalo <math>\Delta t=0.1s</math>. O programa deve indicar a se o carro atingiu o obstáculo ou não. Caso não tenha atingido, deve indicar a distância ao obstáculo.

15b) Faça um programa para o algoritmo da questão anterior. A distância do obstáculo deve ser lida como entrada. A saída deve mostrar na tela se houve ou não colisão. Caso não haja, deve indicar a distância até o obstáculo. Além disso, os valores de posição contra tempo e velocidade
contra tempo devem ser escritos em um arquivo de três colunas <math>(t,x,v)</math> de nome ``dadosCarro.dat''. Teste seu programa para as seguintes
distâncias ao obstáculo: <math> L= 40, 50, 60 </math>

Área 1

2012-04-22T06:53:19Z

Caca:

Abaixo há exercícios e/ou problemas bem diversos, com vários níveis de dificuldade. Tente fazer todos ou pelo menos pensar sobre todos. Os primeiros são os mesmos do trabalho 4 e voce já deve ter feito 2 deles; pense e tente fazer os demais.

1) Faça um algoritmo para calcular a mensalidade pelos alunos de uma acedmia de ginástica que tem como mensalidade básica R$85 e aplica os seguintes descontos

- mulheres com idade igual ou inferior a 15 anos terão desconto de 15%

- mulheres com idade superior a 15 anos terão desconto de 10%

- homens com idade inferior a 22 anos não terão desconto

- homens com idade igual ou superior a 22 anos terão desconto de 20%

2) Faça um algoritmo para calcular a nota resultante de um aluno que fez 3 provas. A nota é definida como sendo a média aritmética das 3 provas.

Considere a seguinte tabela:

- aprovado se nota >= 7

- em exame se 5 <= nota < 7

- reprovado se nota < 5

3) Faça um algoritmo que determine se um dado número [escolhido pelo usuário e lido pelo algoritmo] é par.

4) Faça um algoritmo que determine se um dado número [escolhido pelo usuário e lido pelo algoritmo] é primo

5) Faça um algoritmo que leia 3 números da tela e os retorne em

5.1- ordem crescente

5.2- ordem decrescente

6) Faça um algortimo para determinar todos os divisores do número N que estão entre os inteiros i1 e i2

7) Peça para o usuário entrar com um valor de temperatura em Celsius, transforme para Fahrenheit e coloque o valor na tela.

8) Calcule os zeros de uma função de segundo grau (ax2+bx+c=0).

a) na primeira versão, peça para o usuário entrar com os valores de "a" e "b".

b) na segunda versão, crie um arquivo com os parâmetros "a" e "b" e leia-os a partir de um arquivo externo ao programa

Em ambos os casos, não esqueça de verificar as limitações e ambiguidades do algoritmo que fará este cálculo.

9) Peça para o usuário escolher um número N. Determine se este número N é primo ou não e diga para o usuário.
Use o algoritmo feito em 4) para fazer um programa em C.
Coloque o programa num arquivo de latex. Use o comando "verbatim"

10) Construa duas matrizes de duas dimensões de inteiros, digamos A[N][M] e B[M][N]. Elas não precisam ter mesma dimensão, ou seja, N e M não são necessariamente os mesmos.
Primeiramente escolha M e N pequenos (em torno de 2 ou 3) para que você possa imprimi-las na tela.
Depois calcule o produto de A por B e mostre a matriz resultante na tela tb.
Crie de dentro do seu programa um arquivo de saída que contenha as matrizes A, B e o produto das duas.

11) Leia o arquivo "dados.dat" que está no moodle e coloque-os numa matriz do tipo "float" que se chama, por exemplo X.
Considerando a sequência de números X[i], faça:

a) Encontre o valor máximo desta sequencia de números

b) Ordene esta sequência de menor à maior

12) Números de Fibonacci são uma sequência definida como recursiva pela fórmula abaixo:

:<math>F(n) =\left\{ \begin{matrix} 0\,,\qquad\qquad\qquad\quad\,\ \ \,&&\mbox{se }n=0\,;\ \ \\ 1,\qquad\qquad\qquad\qquad\,&&\mbox{se }n=1;\ \ \,\\ F(n-1)+F(n-2)&&\mbox{outros casos.} \end{matrix} \right. </math>

Na prática: você começa com 0 e 1, e então produz o próximo número de Fibonacci somando os dois anteriores para formar o próximo. Os primeiros Números de Fibonacci para n = 0, 1,… são

0,1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946…

Faça um programa que gera uma sequência de Fibonacci. Peça para o usuário escolher quantos termos da série serão mostrados.
Coloque a sequência num arquivo (você deve abri-lo e escrever nele de dentro do programa). Chame este arquivo usando um script em gnuplot e faça um gráfico em eps.

13) Faça um programa que calcule o log(1+x), |x| < 1 com base na expansão em serie de Taylor:

Note: num programa você não poderá somar termos infinitamente. O somatório deverá ser de 1 até N. Teste vários valores de N para verificar quando o log(1+x) converge. Você pode comparar com o valor que você obtém se fizer o cálculo na calculadora.

O usuário deve fornecer os valores de x e N e você deve verificar no seu programa que o |x| é menor do que 1

14) Em t=0 um bloco de massa <math>m=2kg</math> é lançado no campo gravitacional terrestre a partir do solo (<math>x_0=0;y_0=0</math>) com velocidade inicial <math>\vec{v_0}=v_{0x}\vec{i}+v_{0y}\vec{j}</math>. Considere <math>g=-10m/s^2</math>.

a- Faça um programa ara determinar os vetores posição e velocidade do desse bloco para sucessivos valores de tempo <math>t</math> separados por
um intervalo <math>\Delta t = t_{max}/100</math>, onde <math>t_{max}</math> é o tempo que leva para o corpo voltar ao solo. O programa deve parar neste momento.

b- Faça gráficos da trajetória e do módulo da velocidade para
as seguintes condições iniciais (em m/s):

b1) <math>v_0= 1 \vec{i}+ 5\vec{j}</math>

b2) <math>v_0= 2 \vec{i}+ 5\vec{j}</math>

b3) <math>v_0= 1 \vec{i}+ 8\vec{j}</math>

b4) <math>v_0= 2 \vec{i}+ 8\vec{j}</math>

b5) <math>v_0= 3 \vec{i}+ 8\vec{j}</math>

Comandos Unix/Linux

2012-03-05T16:18:35Z

Caca: /* Mais comandos */

'''SUGESTÃO''': a melhor maneira de aprender é testar cada um no terminal de comandos.

A '''esquerda''' de '''<-''' o comando, a '''direita''' de '''<-''' o que ele faz. Entre aspas indicamos o argumento
(são comandos que precisam dele), mas as aspas devem ser omitidas na prática.

== Os primeiros ==

<pre>
date <- dá data e hora
who <- responde quem está logado
finger "nome" <- dá informações do usuário "nome"
ping "máquina" <- informa se "máquina" está acessível na rede
clear <- limpa a tela
locate "file" <- mostra todos os arquivos do disco que tem "file" como parte do nome
which "comando" <- responde onde (em que diretório) se encontra "comando"
du -h "dir" <- lista o espaço ocupado pelos diretórios abaixo do "dir".
O -h é uma opção para mostrar o resultado em unidades humanas(bytes)
</pre>

Exemplos com argumentos (alguns argumentos só funcionam no lief):
{| style="background:paleturquoise"
| finger || alex
|-
| ping || pequim
|-
| locate || firefox
|-
|| which || gnuplot
|-
| du -h || /home
|}

== Básicos ==

<pre>
ls <- listagem do diretório
ls -l <- idem com mais informação
ls --color <- idem com esquema de cores
ls -a <- mostra arquivos ocultos do sistema (os .*)
</pre>

A seguir se o comando precisa de argumento colocamos um nome genérico (ex: ''dir, file,'' etc) e sem aspas
<pre>
mkdir dir <- cria o diretório dir
cd dir <- troca para o diretório dir
pwd <- responde onde você está (qual diretório)
cd .. <- volta ao diretório que está em cima
cd ~ <- vai para o nosso diretório de partida: /home/eu
rmdir dir <- apaga o diretório (se ele estiver vazio) dir

cp file1 file2 <- copia o arquivo file1 no file2
rm file <- apaga o file
rm * <- PERIGO! Apaga tudo o que está no diretório,
rm *.dat <- que apaga só os .dat
rm -i * <- apaga tudo no diretório atual, mas perguntando antes
cp file1 dir/file2 <- copia file1 no file2 no diretório dir
mv file1 file2 <- troca o nome de file1 para file2
mv file dir/ <- coloca o file no subdiretório dir

cat file <- mostra o conteúdo de file
more file <- também, mas página por página
</pre>

O '''more''' pode ser usado para mostrar qualquer coisa na tela, uma página por vez.

Exemplo: se ls -l dá muita informação, pode-se usar more. Aí aparece a

primeira página e espera por mais (dar <space> para continuar, <enter>

avança uma linha, <q> para sair ou <ctrl>+<c> para interromper).

ls -l | more <- dá o diretório atual página x página

== Sobre arquivos ==

<pre>
sort file <- ordena alfabeticamente o arquivo file
wc file <- conta as linhas, palavras e bytes do arquivo file
tail file <- mostra as últimas 10 linhas de file
head file <- mostra as primeiras 10 linhas de file
diff file file1 <- compara e mostra as diferenças entre file1 e file2

split file <- separa file em pedaços iguais
lpr file <- imprime file
</pre>

== Editores ==

O '''emacs''' fornece um ambiente especializado por tarefa (manual mínimo em html ou nos formatos pdf
e ps em ftp://lief.if.ufrgs.br/ftp/pub/emacs/).

Existem editores mais simples como '''jed,''' versão reduzida do emacs
Outro edito gráfico é o '''kate''' que vem junto com o '''konqueror'''

O '''vi''' pode resultar pouco amigável, porém é o único que não falta em nenhum sistema que rode Unix
<pre>
vi <- chama o vi e depois ...
a <- para inserir texto
<esc> <- para desativar a função
No vi você não pode começar a digitar sem antes digitar "a"
/palavra <enter> <- para procurar palavra
x <- para apagar por letra
dd <- apaga uma linha
:w <- para salvar
:q <- para sair
:q! <- para sair sem salvar
:wq <- para sair salvando
</pre>

Um dos principais problemas encontrados por usuários do '''vi''' é descobrir como se faz para
substituir palavras no texto. Isto é feito com as mesmas '''expressões regulares''' válidas
no editor '''sed'''. Assim para substituir a palavra ''word1'' por ''word2'' se faz

<pre>
:s/word1/word2/g <- substitui word1 por word2 (uma por vez)
:%s/word1/word2/g <- substitui todas as ocorrencias de word1 por word2
</pre>

== Mais comandos ==

<pre>
write colega <- estabelece comunicação on-line com o colega, se estiver logado na mesma máquina
man comando <- dá informação a respeito do comando
import nome_arq1.jpg <- importa da tela uma imagem selecionada (com o mouse) e gera um arquivo com nome "nome_arq1" e extensão jpg
import nome_arq2.ps <- importa da tela uma imagem selecionada (com o mouse) e gera um arquivo com nome "nome_arq2" e extensão ps
convert arq.jpg arq.ps <- converte o arquivo "arq" do formato "jpg" para "ps"
</pre>

== Comandos especiais ==
=== grep ===
<pre>
grep kk file
</pre>
verifica se a palvra '''''kk''''' está no arquivo '''''file''''' 
Muito útil quando se procura um arquivo perdido com um determinado assunto. 
Exemplo: você não sabe qual o arquivo com o relatório sobre "decaimento". 
Então digita:
<pre>
grep decai *
</pre>
e vai mostrar os arquivos (se tiver algum), contendo a palavra '''''decai'''''. 
Se você procura duas palavras juntas deve usar aspas. Por exemplo:

<pre>
grep "pi =" *.tex
</pre>

mostra os arquivos '''''tex''''' contendo '''''pi ='''''

=== sed ===
<pre>
sed 's/word1/word2/g' file
</pre>
troca '''word1''' por '''word2''' no arquivo '''file'''. O resultado vai para a tela

<pre>
sed 's/word1/word2/g' file > file2
</pre>
faz o mesmo salvando o resultado no arquivo '''file2'''camante

=== awk ===
awk é um processador de linhas de arquivo com muita funcionalidade.
Ele opera assim: lei uma a uma as linhas de um arquivo (pp por exemplo)
e dessas linhas podemos decidir o que imprimir e quando imprimir ouate imprimir as linhas modificadas
(por uma opração matemática ou por substituição de palavras)
A melhor forma de entender como funciona como sempre é através de exemplos:
<pre>
awk '{print $1, $4}' notas
</pre>
neste exemplo o awk imprime a '''primeira''' ($1) e '''quarta'''($4) colunas de cada linha do arquivo ''notas''
Se o conteúdo desse arquivo são as notas de uma turma:
<pre>
juan 4 8 6
pedro 7 4 10
mateus 7 8 5
felipe 8 3 7
</pre>

depois de executar a linha da awk acima teremos
<pre>
juan 6
pedro 10
mateus 5
felipe 7
</pre>

Aparece aqui um conceito importante da linguagem de comandos: as variáveis, neste caso $1, $2
indicam a primeira, segunda, etc palavras (podem ser números ou combinações dos dois).
Como sabe o ''awk'' onde termina uma e começa a outra? Pelo espaço em branco (pode ser um ou mais espaços)
que definem o fim de uma e começo da seguinte.

Outro detalhe, compare as duas linhas quase idênticas:

<pre>
awk '{print $1, $3, $4}' notas
awk '{print $1, $3 $4}' notas
</pre>

A vírgula (,) entre as variáveis ($3 e $4) faz toda a diferença!

Mas este, se bem é muito prático é apenas uma amostra do que ''awk'' pode fazer
Ele pode filtrar de acordo a critérios. Por exemplo para imprimir as notas dos alunos
que tiraram mais de 7 na primeira:
<pre>
awk '{ if ($2 >= 7) print $1, $2, $3, $4}' notas
</pre>

== Vários ==

<pre>
echo alo, alo <- é um eco mesmo, devolve o que se manda para ele
cal <- mostra um calendário, teste agora e verá
cal 2000 <- aqui terá o ano inteiro
</pre>

== Sessões remotas e transferência de arquivos ==
<pre>
ssh usuario@maquina.dominio <- programa para entrar em máquina e fazer sessão remota
scp usuario@máquina.dominio:arquivo-remoto arquivo-local <- comunicação para troca de arquivos
</pre>

== Monitoramento de processos ==
<pre>
ps x <- mostra seus processos, incluindo ssh, etc
ps aux <- o mesmo do sistema todo
top <- o mesmo com mais informação
kill -9 <- mata o processo que não está dando certo
</pre>

== Compactado e armazenado de arquivos ==
<pre>
gzip file <- comprime os arquivos
tar cvf todos_meus_dados.tar *.dat <- arquiva um conjunto de arquivos (no exemplo todos os .dat)
tar cvfz todos_meus_dados.tgz *.dat <- faz o mesmo criando um arquivo ja comprimido
tar xvf todos_meus_dados.tar <- desarquiva (explode) o conjunto de dados
tar xvfz todos_meus_dados.tgz <- faz o mesmo de um arquivo comprimido
</pre>

Mais
<pre>
chmod +x file <- dá a file permissão para ser executado
ln -s file dir/ <- cria um atalho (link) de file no diretório dir/
alias <- mostra os alias que estão definidos
alias dir='ls -l --color' <- define um alias
</pre>

== Caracteres de significado especial no UNIX ==

{| style="background:paleturquoise"
|<tt>></tt>||redirecionando a saída padrão (tela)
|-
|<tt><</tt>||redirecionando a entrada padrão (teclado)
|-
|<tt>>></tt>||adicionando a saída padrão à um arquivo existente
|-
|<tt><pre>|</pre></tt>||pipe (duto) passa a saída padrão de um comando para o próximo
|-
|<tt>&</tt>||coloca o programa em "background" devolvendo controle do terminal
|-
|<tt>$</tt>||para referir-se a variáveis
|-
|<tt>*</tt>||é o curinga para referência de nomes de arquivos
|}

== Programas de uso corrente ==

(requerem de sessão gráfica)
<pre>
xterm <- abre um terminal de comandos
rxvt <- o mesmo com outra aparência
gv exemplo.ps <- visualiza um arquivo postscript (ex: exemplo.ps)

xv <- visualizador de arquivos gráficos: tif, gif, jpg, etc
xfig <- programa para fazer desenhos simples (tipo paintbrush do win)
gimp <- programa para tratamento de imagens

konqueror <- gerenciador de arquivos e navegador (do kde)
kdehelp <- interface tipo netscape para help
firefox ou mozilla <- navegadorores de página da web
</pre>

== Discutidos em capítulos separados ==

* [[gnuplot]], [[xmgrace]]: para fazer gráficos
* [[LaTex]]: para processar texto com qualidade de publicação
* '''gcc, f77 ou f90''': compiladores C e [[FORTRAN]]

Comandos Unix/Linux

2012-03-05T16:14:02Z

Caca: /* Mais comandos */

'''SUGESTÃO''': a melhor maneira de aprender é testar cada um no terminal de comandos.

A '''esquerda''' de '''<-''' o comando, a '''direita''' de '''<-''' o que ele faz. Entre aspas indicamos o argumento
(são comandos que precisam dele), mas as aspas devem ser omitidas na prática.

== Os primeiros ==

<pre>
date <- dá data e hora
who <- responde quem está logado
finger "nome" <- dá informações do usuário "nome"
ping "máquina" <- informa se "máquina" está acessível na rede
clear <- limpa a tela
locate "file" <- mostra todos os arquivos do disco que tem "file" como parte do nome
which "comando" <- responde onde (em que diretório) se encontra "comando"
du -h "dir" <- lista o espaço ocupado pelos diretórios abaixo do "dir".
O -h é uma opção para mostrar o resultado em unidades humanas(bytes)
</pre>

Exemplos com argumentos (alguns argumentos só funcionam no lief):
{| style="background:paleturquoise"
| finger || alex
|-
| ping || pequim
|-
| locate || firefox
|-
|| which || gnuplot
|-
| du -h || /home
|}

== Básicos ==

<pre>
ls <- listagem do diretório
ls -l <- idem com mais informação
ls --color <- idem com esquema de cores
ls -a <- mostra arquivos ocultos do sistema (os .*)
</pre>

A seguir se o comando precisa de argumento colocamos um nome genérico (ex: ''dir, file,'' etc) e sem aspas
<pre>
mkdir dir <- cria o diretório dir
cd dir <- troca para o diretório dir
pwd <- responde onde você está (qual diretório)
cd .. <- volta ao diretório que está em cima
cd ~ <- vai para o nosso diretório de partida: /home/eu
rmdir dir <- apaga o diretório (se ele estiver vazio) dir

cp file1 file2 <- copia o arquivo file1 no file2
rm file <- apaga o file
rm * <- PERIGO! Apaga tudo o que está no diretório,
rm *.dat <- que apaga só os .dat
rm -i * <- apaga tudo no diretório atual, mas perguntando antes
cp file1 dir/file2 <- copia file1 no file2 no diretório dir
mv file1 file2 <- troca o nome de file1 para file2
mv file dir/ <- coloca o file no subdiretório dir

cat file <- mostra o conteúdo de file
more file <- também, mas página por página
</pre>

O '''more''' pode ser usado para mostrar qualquer coisa na tela, uma página por vez.

Exemplo: se ls -l dá muita informação, pode-se usar more. Aí aparece a

primeira página e espera por mais (dar <space> para continuar, <enter>

avança uma linha, <q> para sair ou <ctrl>+<c> para interromper).

ls -l | more <- dá o diretório atual página x página

== Sobre arquivos ==

<pre>
sort file <- ordena alfabeticamente o arquivo file
wc file <- conta as linhas, palavras e bytes do arquivo file
tail file <- mostra as últimas 10 linhas de file
head file <- mostra as primeiras 10 linhas de file
diff file file1 <- compara e mostra as diferenças entre file1 e file2

split file <- separa file em pedaços iguais
lpr file <- imprime file
</pre>

== Editores ==

O '''emacs''' fornece um ambiente especializado por tarefa (manual mínimo em html ou nos formatos pdf
e ps em ftp://lief.if.ufrgs.br/ftp/pub/emacs/).

Existem editores mais simples como '''jed,''' versão reduzida do emacs
Outro edito gráfico é o '''kate''' que vem junto com o '''konqueror'''

O '''vi''' pode resultar pouco amigável, porém é o único que não falta em nenhum sistema que rode Unix
<pre>
vi <- chama o vi e depois ...
a <- para inserir texto
<esc> <- para desativar a função
No vi você não pode começar a digitar sem antes digitar "a"
/palavra <enter> <- para procurar palavra
x <- para apagar por letra
dd <- apaga uma linha
:w <- para salvar
:q <- para sair
:q! <- para sair sem salvar
:wq <- para sair salvando
</pre>

Um dos principais problemas encontrados por usuários do '''vi''' é descobrir como se faz para
substituir palavras no texto. Isto é feito com as mesmas '''expressões regulares''' válidas
no editor '''sed'''. Assim para substituir a palavra ''word1'' por ''word2'' se faz

<pre>
:s/word1/word2/g <- substitui word1 por word2 (uma por vez)
:%s/word1/word2/g <- substitui todas as ocorrencias de word1 por word2
</pre>

== Mais comandos ==

<pre>
write colega <- estabelece comunicação on-line com o colega, se estiver logado na mesma máquina
man comando <- dá informação a respeito do comando
import nome_arq1.jpg <- importa da tela uma imagem selecionada (com o mouse) e gera um arquivo com nome "nome_arq1" e extensão jpg
import nome_arq2.ps <- importa da tela uma imagem selecionada (com o mouse) e gera um arquivo com nome "nome_arq2" e extensão ps
</pre>

== Comandos especiais ==
=== grep ===
<pre>
grep kk file
</pre>
verifica se a palvra '''''kk''''' está no arquivo '''''file''''' 
Muito útil quando se procura um arquivo perdido com um determinado assunto. 
Exemplo: você não sabe qual o arquivo com o relatório sobre "decaimento". 
Então digita:
<pre>
grep decai *
</pre>
e vai mostrar os arquivos (se tiver algum), contendo a palavra '''''decai'''''. 
Se você procura duas palavras juntas deve usar aspas. Por exemplo:

<pre>
grep "pi =" *.tex
</pre>

mostra os arquivos '''''tex''''' contendo '''''pi ='''''

=== sed ===
<pre>
sed 's/word1/word2/g' file
</pre>
troca '''word1''' por '''word2''' no arquivo '''file'''. O resultado vai para a tela

<pre>
sed 's/word1/word2/g' file > file2
</pre>
faz o mesmo salvando o resultado no arquivo '''file2'''camante

=== awk ===
awk é um processador de linhas de arquivo com muita funcionalidade.
Ele opera assim: lei uma a uma as linhas de um arquivo (pp por exemplo)
e dessas linhas podemos decidir o que imprimir e quando imprimir ouate imprimir as linhas modificadas
(por uma opração matemática ou por substituição de palavras)
A melhor forma de entender como funciona como sempre é através de exemplos:
<pre>
awk '{print $1, $4}' notas
</pre>
neste exemplo o awk imprime a '''primeira''' ($1) e '''quarta'''($4) colunas de cada linha do arquivo ''notas''
Se o conteúdo desse arquivo são as notas de uma turma:
<pre>
juan 4 8 6
pedro 7 4 10
mateus 7 8 5
felipe 8 3 7
</pre>

depois de executar a linha da awk acima teremos
<pre>
juan 6
pedro 10
mateus 5
felipe 7
</pre>

Aparece aqui um conceito importante da linguagem de comandos: as variáveis, neste caso $1, $2
indicam a primeira, segunda, etc palavras (podem ser números ou combinações dos dois).
Como sabe o ''awk'' onde termina uma e começa a outra? Pelo espaço em branco (pode ser um ou mais espaços)
que definem o fim de uma e começo da seguinte.

Outro detalhe, compare as duas linhas quase idênticas:

<pre>
awk '{print $1, $3, $4}' notas
awk '{print $1, $3 $4}' notas
</pre>

A vírgula (,) entre as variáveis ($3 e $4) faz toda a diferença!

Mas este, se bem é muito prático é apenas uma amostra do que ''awk'' pode fazer
Ele pode filtrar de acordo a critérios. Por exemplo para imprimir as notas dos alunos
que tiraram mais de 7 na primeira:
<pre>
awk '{ if ($2 >= 7) print $1, $2, $3, $4}' notas
</pre>

== Vários ==

<pre>
echo alo, alo <- é um eco mesmo, devolve o que se manda para ele
cal <- mostra um calendário, teste agora e verá
cal 2000 <- aqui terá o ano inteiro
</pre>

== Sessões remotas e transferência de arquivos ==
<pre>
ssh usuario@maquina.dominio <- programa para entrar em máquina e fazer sessão remota
scp usuario@máquina.dominio:arquivo-remoto arquivo-local <- comunicação para troca de arquivos
</pre>

== Monitoramento de processos ==
<pre>
ps x <- mostra seus processos, incluindo ssh, etc
ps aux <- o mesmo do sistema todo
top <- o mesmo com mais informação
kill -9 <- mata o processo que não está dando certo
</pre>

== Compactado e armazenado de arquivos ==
<pre>
gzip file <- comprime os arquivos
tar cvf todos_meus_dados.tar *.dat <- arquiva um conjunto de arquivos (no exemplo todos os .dat)
tar cvfz todos_meus_dados.tgz *.dat <- faz o mesmo criando um arquivo ja comprimido
tar xvf todos_meus_dados.tar <- desarquiva (explode) o conjunto de dados
tar xvfz todos_meus_dados.tgz <- faz o mesmo de um arquivo comprimido
</pre>

Mais
<pre>
chmod +x file <- dá a file permissão para ser executado
ln -s file dir/ <- cria um atalho (link) de file no diretório dir/
alias <- mostra os alias que estão definidos
alias dir='ls -l --color' <- define um alias
</pre>

== Caracteres de significado especial no UNIX ==

{| style="background:paleturquoise"
|<tt>></tt>||redirecionando a saída padrão (tela)
|-
|<tt><</tt>||redirecionando a entrada padrão (teclado)
|-
|<tt>>></tt>||adicionando a saída padrão à um arquivo existente
|-
|<tt><pre>|</pre></tt>||pipe (duto) passa a saída padrão de um comando para o próximo
|-
|<tt>&</tt>||coloca o programa em "background" devolvendo controle do terminal
|-
|<tt>$</tt>||para referir-se a variáveis
|-
|<tt>*</tt>||é o curinga para referência de nomes de arquivos
|}

== Programas de uso corrente ==

(requerem de sessão gráfica)
<pre>
xterm <- abre um terminal de comandos
rxvt <- o mesmo com outra aparência
gv exemplo.ps <- visualiza um arquivo postscript (ex: exemplo.ps)

xv <- visualizador de arquivos gráficos: tif, gif, jpg, etc
xfig <- programa para fazer desenhos simples (tipo paintbrush do win)
gimp <- programa para tratamento de imagens

konqueror <- gerenciador de arquivos e navegador (do kde)
kdehelp <- interface tipo netscape para help
firefox ou mozilla <- navegadorores de página da web
</pre>

== Discutidos em capítulos separados ==

* [[gnuplot]], [[xmgrace]]: para fazer gráficos
* [[LaTex]]: para processar texto com qualidade de publicação
* '''gcc, f77 ou f90''': compiladores C e [[FORTRAN]]

Fórmula de Lagrange

2011-10-20T18:44:54Z

Caca:

== Polinômios de Lagrange ==

Baseado no fato de que sobre <math>N</math> pontos <math>(X_1,Y_1), (X_2,Y_2), \cdots, (X_N,Y_N)</math> passa um ''único'' polinômio de grau <math>N-1</math>, o '''Polinômio de Lagrange''' pode ser usado como fórmula de interpolação ou extrapolação:

<math>
P(x)=\sum_{i=1}^N Y_i L_i(x)
</math>

onde

<math>
L_i(x)=\prod_{j=1,j\ne i}^N\frac{x-X_j}{X_i-X_j}=\frac{x-X_1}{X_i-X_1}\cdots\frac{x-X_{i-1}}{X_i-X_{i-1}}
\frac{x-X_{i+1}}{X_i-X_{i+1}}\cdots\frac{x-X_N}{X_i-X_N}
</math>

é um polinômio de grau <math>\;N-1</math> em <math>\;x</math>.
Tendo em vista que <math>L_i(X_j)=\delta_{i,j}\;,</math> onde o delta de Kronecker

<math>\delta_{ij} = \left\{\begin{matrix}
1, & \mbox{se } i=j \\
0, & \mbox{se } i \ne j \end{matrix}\right.
</math>

é fácil verificar que, de fato,<math>\;P(X_i)=Y_i</math>. Assim,<math>\;P(x)</math> pode ser empregado para se estimar o valor de <math>\;Y(x)</math> em pontos <math>\;x</math> não tabulados.

== Exemplo 1 ==

[[Image:lagrangen2.png|right|frame|Fórmula de Lagrange para N=2.]]

Para exemplificar a fórmula de Lagrange, consideramos primeiramente uma reta que passa pelos pontos <math>(X_1,Y_1) = (1,9)</math> e <math>(X_2,Y_2) = (2,13)</math>, tendo assim <math>N = 2</math>. Aplicando a fórmula de Lagrange, temos

:<math>L_1 = \frac{x-X_2}{X_1-X_2} = \frac{x-2}{1-2} = -(x-2)</math>
e
:<math>L_2 = \frac{x-X_1}{X_2-X_1} = \frac{x-1}{2-1} = (x-1)</math>,
assim, o polinômio de Lagrange que passa pelos pontos desejados é dado por:
:<math>P(x)=\sum_{i=1}^N Y_i L_i(x) = Y_1L_1 + Y_2L_2 = 9(-x+2) + 13(x-1) = 4x + 5 </math>.

Note que substituindo na equação acima, <math>P(1) = 9</math> e <math>P(2) = 13</math>.

== Exemplo 2 ==

[[Image:lagrangen3.png|right|frame|Fórmula de Lagrange para N=3.]]

Verificando a fórmula de Lagrange para <math>N = 3</math>. Suponhamos que desejamos encontrar qual é o polinômio que passa pelos pontos <math>(X_1,Y_1) = (2,4)</math>, <math>(X_2,Y_2) = (3,9)</math> e <math>(X_3,Y_3) = (6,36)</math>. Temos que:

:<math>L_1 = \left(\frac{x-X_2}{X_1-X_2}\right) \left(\frac{x-X_3}{X_1-X_3}\right) = \left(\frac{x-3}{2-3}\right) \left(\frac{x-6}{2-6}\right) = \frac{x^2-9x+18}{4}</math>,

:<math>L_2 = \left(\frac{x-X_1}{X_2-X_1}\right) \left(\frac{x-X_3}{X_2-X_3}\right) = \left(\frac{x-2}{3-2}\right) \left(\frac{x-6}{3-6}\right) = -\frac{x^2-8x+12}{3}</math>

e

:<math>L_3 = \left(\frac{x-X_1}{X_3-X_1}\right) \left(\frac{x-X_2}{X_3-X_2}\right) = \left(\frac{x-2}{6-2}\right) \left(\frac{x-3}{6-3}\right) = \frac{x^2-5x+6}{12}</math>,

assim

:<math>P(x)=\sum_{i=1}^N Y_i L_i(x) = Y_1L_1 + Y_2L_2 + Y_3L_3 = 4\frac{x^2-9x+18}{4} - 9\frac{x^2-8x+12}{3} + 36\frac{x^2-5x+6}{12} = x^2 </math>.

== Exemplo 3 ==

Para ilustrar graficamente o método da fórmula de Lagrange, usaremos um exemplo com <math>N=4</math>. Considerando os quatro pontos <math>(X_1,Y_1) = (-1,5)</math>, <math>(X_2,Y_3) = (1,2)</math>, <math>(X_3,Y_3) = (-3,5)</math> e <math>(X_4,Y_4) = (7,4)</math>, as equações <math>L_i</math> ficam

:<math>L_1 = -\frac{1}{64}(x^3-11x^2+31x-21)</math>,

:<math>L_2 = \frac{1}{24}(x^3-9x^2+11x+21)</math>,

:<math>L_3 = -\frac{1}{32}(x^3-7x^2-x+7)</math>

e

:<math>L_4 = \frac{1}{192}(x^3-3x^2-x+3)</math>.

O gráfico abaixo mostra os quatro pontos <math>(X_i,Y_i)</math>, as curvas <math>L_iY_i</math> e a curva final <math>P(x)</math>. Lembre-se que <math>P(x)</math> é a curva gerada pela soma dos polinômios <math>L_iY_i</math>. Note que a curva <math>L_1Y_1</math> passa pelo ponto <math>(X_1,Y_1)</math>, assim como as demais e a curva <math>P(x)</math> passa por todos os pontos.

[[Imagem:lagrange.png|800px]]

== Numericamente ==

Na prática, a implementação numérica do polinômio de Lagrange é complicada.
Computacionalmente não é possível fazer um programa geral para interpolação de ordem arbitrária, isto é fazer um programa que, com os N pontos de entrada <math>{X_i,Y_i}</math>, devolva um polinômio <math>P(x)</math> interpolador de grau N. Isto envolve computação simbólica (do tipo utilizada em programas proprietários como o Mathematica, Maple, ou livres como Maxima).
Por outro lado a implementação numérica do método na força bruta envolve um duplo laço de ordem N:
devem ser somados N termos (os <math>L_i(x)</math>) onde cada um deles é construído como um produto de N-1 termos; ao todo <math>N^2</math> cálculos para cada ponto x (isto fica como exercício a partir da fórmula
geral do <math>P(x)</math>).

O Algoritmo de Neville [http://www.physics.utah.edu/~detar/phys6720/handouts/interpolation/interpolation/node4.html] é muito útil na realização desta tarefa.Ao final, veremos que o polinômio interpolador de grau n pode ser reconstruído com polinômios de grau n-1. Este processo gera uma fórmula de recorrência, que é um recurso bastante comum em algoritmos computacionais.

Para deduzirmos esta fórmula de recorrência, começamos aproximando cada intervalo por um valor constante. Podemos representar esta aproximação por
<math>P_1(x)=Y_1,\; P_2(x)=Y_2,\; \cdots\,\; P_N(x)=Y_N</math>.
Melhorando a descrição, empregando agora uma aproximação linear em cada intervalo <math>[X_i,\;X_{i+1}]</math>, denotamos por <math>P_{12}(x),\;P_{23}(x),\; \cdots,\; P_{N-1,N}(x)</math>, onde <math>P_{i,i+1}(x)\;</math>é o polinômio que passa exatamente sobre
<math>(X_i,Y_i)\;</math>e<math>\;(X_{i+1},Y_{i+1})</math>:

<math>
P_{i,i+1}(x)=\frac{x-X_{i+1}}{X_i-X_{i+1}}Y_i+\frac{x-X_i}{X_{i+1}-X_i}Y_{i+1}\;.
</math>

Vemos que <math>P_{i, i+1}(x)\;</math>pode ser escrito como:

<math>
P_{i,i+1}(x)=\frac{(x-X_{i+1})P_i(x)-(x-X_i)P_{i+1}(x)}{X_i-X_{i+1}}
</math>

Isto sugere que há uma relação entre os polinômios de ordem <math>\;n</math> com os de ordem <math>\;n+1</math>.
Para verificar isto, vamos considerar, agora, uma parábola passando exatamente sobre
<math>(X_i,Y_i)\;,(X_{i+1},Y_{i+1})</math> e<math>\;(X_{i+2},Y_{i+2})</math>, que denotaremos por,<math>\;P_{i,i+1,i+2}(x)</math>:

<math>
P_{i,i+1,i+2}(x)=\frac{x-X_{i+1}}{X_i-X_{i+1}}\frac{x-X_{i+2}}{X_i -X_{i+2}}Y_i
+\frac{x-X_i}{X_{i+1}-X_i}\frac{x-X_{i+2}}{X_{i+1}-X_{i+2}}Y_{i+1}
+\frac{x-X_i}{X_{i+2}-X_i}\frac{x-X_{i+1}}{X_{i+2}-X_{i+1}}Y_{i+2}
</math>

Fatorando <math>\;1/(X_i-X_{i+2})</math> e somando e subtraindo <math>\frac{x-X_i}{X_{i+1}-X_i}(x-X_{i+2})Y_{i+1}</math>, obtemos:

<math>
P_{i,i+1,i+2}(x) =\frac{1}{X_i-X_{i+2}}\left[(x-X_{i+2})P_{i,i+1}(x)
-F(x)\right]
</math>

onde

<math>
F(x)=(x-X_i)\left[\frac{x-X_{i+1}}{X_{i+2}-X_{i+1}}Y_{i+2}
-\frac{X_i-X_{i+2}}{X_{i+1}-X_i}\frac{x-X_{i+2}}{X_{i+1}-X_{i+2}}Y_{i+1}
+\frac{x-X_{i+2}}{X_{i+1}-X_i}Y_{i+1}\right]\;.
</math>

Note que o último termo desta expressão corresponde àquele que foi subtraído após seu termo de sinal contrário ter
sido somado à expressão que levou a<math>\;P_{i,i+1}(x)</math> na equação para<math>\;P_{i,i+1,i+2}(x)</math>.
Rearranjando os termos acima, encontramos:

<math>
F(x)=(x-X_i)\left[\frac{x-X_{i+2}}{X_{i+1}-X_{i+2}}Y_{i+1}+\frac{x-X_{i+1}}{X_{i+2}-X_{i+1}}Y_{i+2}\right]
=(x-X_i)P_{i+1,i+2}(x)\;.
</math>

Substituindo este resultado na equação para<math>\;P_{i,i+1,i+2}(x)</math>, obtemos finalmente:

<math>
P_{i,i+1,i+2}(x) =\frac{1}{X_i-X_{i+2}}\left[(x-X_{i+2})P_{i,i+1}(x)
-(x-X_i)P_{i+1,i+2}(x)\right]
</math>

Assim, notamos que, de fato, há uma relação de recorrência bastante simples entre os polinômios que envolvem
<math>\;n</math> e <math>\;n+1</math> pontos, cuja forma geral é dada por:

<math>
P_{i,i+1,\cdots,i+k}(x) =\frac{1}{X_i-X_{i+k}}\left[(x-X_{i+k})P_{i,i+1,\cdots,i+k-1}(x)
-(x-X_i)P_{i+1,i+2,\cdots,i+k}(x)\right]
</math>

Por ser muito mais simples de se implementar numericamente do que a expressão original para <math>\;P(x)</math>,
é esta relação de recorrência que é, de fato, utilizada em cálculos numéricos. Os erros cometidos podem ser estimados calculando-se as diferenças entre as diferentes ordens do polinômio:

<math>
D^{(1)}_{k,i}(x)=P_{i,i+1,\cdots,i+k}(x)-P_{i,i+1,\cdots,i+k-1}(x)
</math>

e

<math>
D^{(2)}_{k,i}(x)=P_{i,i+1,\cdots,i+k}(x)-P_{i+1,i+2,\cdots,i+k}(x)\;.
</math>

Ao invés de se gerar <math>\;P(x)</math> a partir da relação de recorrência para <math>P_{i,i+1,\cdots,i+k}(x)</math>, pode-se utilizar as equações acima e obter relações de recorrência para <math>\;D^{(1)} \mbox{ e } D^{(2)}</math>. No final, obtemos <math>\;P(x)</math> a partir destas quantidades. Este desenvolvimento é deixado como exercício.

É importante notar que em nenhum ponto da discussão foi evocada a necessidade dos pontos <math>\;\{X_i\}</math> serem igualmente espaçados. Portanto, as fórmulas apresentadas aqui podem ser aplicadas em situações bastante gerais.

----

Como discutido na seção [[Interpolação e extrapolação]], é desaconselhável o uso de polinômios de grau elevado. Por isto, apenas um pequeno subconjunto dos valores tabulados, nas vizinhanças do ponto de interesse <math>\;X</math>, deve ser empregado.
Por exemplo, digamos que temos uma tabela com 100 pontos <math>\;\{(X_i,Y_i)\}</math>. Se desejamos estimar o valor de <math>\;Y</math> no interior da região <math>[X_1,\; X_N]</math>, ao invés de construir um polinômio de grau 99, podemos, por exemplo, dividir o espaço em 25 sub-regiões e usar polinômios cúbicos em cada uma delas,
utilizando apenas <math>(X_{i-1},Y_{i-1}),\; (X_i,Y_i),\; (X_{i+1},Y_{i+1})</math> e<math>\;(X_{i+2},Y_{i+2})</math>.

Contudo, devemos notar que, embora a interpolação seja contínua nas interfaces das regiões, a continuidade das derivadas 1a e 2a não é garantida. Em situações em que estas propriedades importam, outras aproximações devem ser adotadas (veja, por exemplo, [[Spline cúbico]]).

----

Fórmula de Lagrange

2011-10-20T18:43:59Z

Caca:

== Interpolação polinimial & Polinômios de Lagrange ==

Baseado no fato de que sobre <math>N</math> pontos <math>(X_1,Y_1), (X_2,Y_2), \cdots, (X_N,Y_N)</math> passa um ''único'' polinômio de grau <math>N-1</math>, o '''Polinômio de Lagrange''' pode ser usado como fórmula de interpolação ou extrapolação:

<math>
P(x)=\sum_{i=1}^N Y_i L_i(x)
</math>

onde

<math>
L_i(x)=\prod_{j=1,j\ne i}^N\frac{x-X_j}{X_i-X_j}=\frac{x-X_1}{X_i-X_1}\cdots\frac{x-X_{i-1}}{X_i-X_{i-1}}
\frac{x-X_{i+1}}{X_i-X_{i+1}}\cdots\frac{x-X_N}{X_i-X_N}
</math>

é um polinômio de grau <math>\;N-1</math> em <math>\;x</math>.
Tendo em vista que <math>L_i(X_j)=\delta_{i,j}\;,</math> onde o delta de Kronecker

<math>\delta_{ij} = \left\{\begin{matrix}
1, & \mbox{se } i=j \\
0, & \mbox{se } i \ne j \end{matrix}\right.
</math>

é fácil verificar que, de fato,<math>\;P(X_i)=Y_i</math>. Assim,<math>\;P(x)</math> pode ser empregado para se estimar o valor de <math>\;Y(x)</math> em pontos <math>\;x</math> não tabulados.

== Exemplo 1 ==

[[Image:lagrangen2.png|right|frame|Fórmula de Lagrange para N=2.]]

Para exemplificar a fórmula de Lagrange, consideramos primeiramente uma reta que passa pelos pontos <math>(X_1,Y_1) = (1,9)</math> e <math>(X_2,Y_2) = (2,13)</math>, tendo assim <math>N = 2</math>. Aplicando a fórmula de Lagrange, temos

:<math>L_1 = \frac{x-X_2}{X_1-X_2} = \frac{x-2}{1-2} = -(x-2)</math>
e
:<math>L_2 = \frac{x-X_1}{X_2-X_1} = \frac{x-1}{2-1} = (x-1)</math>,
assim, o polinômio de Lagrange que passa pelos pontos desejados é dado por:
:<math>P(x)=\sum_{i=1}^N Y_i L_i(x) = Y_1L_1 + Y_2L_2 = 9(-x+2) + 13(x-1) = 4x + 5 </math>.

Note que substituindo na equação acima, <math>P(1) = 9</math> e <math>P(2) = 13</math>.

== Exemplo 2 ==

[[Image:lagrangen3.png|right|frame|Fórmula de Lagrange para N=3.]]

Verificando a fórmula de Lagrange para <math>N = 3</math>. Suponhamos que desejamos encontrar qual é o polinômio que passa pelos pontos <math>(X_1,Y_1) = (2,4)</math>, <math>(X_2,Y_2) = (3,9)</math> e <math>(X_3,Y_3) = (6,36)</math>. Temos que:

:<math>L_1 = \left(\frac{x-X_2}{X_1-X_2}\right) \left(\frac{x-X_3}{X_1-X_3}\right) = \left(\frac{x-3}{2-3}\right) \left(\frac{x-6}{2-6}\right) = \frac{x^2-9x+18}{4}</math>,

:<math>L_2 = \left(\frac{x-X_1}{X_2-X_1}\right) \left(\frac{x-X_3}{X_2-X_3}\right) = \left(\frac{x-2}{3-2}\right) \left(\frac{x-6}{3-6}\right) = -\frac{x^2-8x+12}{3}</math>

e

:<math>L_3 = \left(\frac{x-X_1}{X_3-X_1}\right) \left(\frac{x-X_2}{X_3-X_2}\right) = \left(\frac{x-2}{6-2}\right) \left(\frac{x-3}{6-3}\right) = \frac{x^2-5x+6}{12}</math>,

assim

:<math>P(x)=\sum_{i=1}^N Y_i L_i(x) = Y_1L_1 + Y_2L_2 + Y_3L_3 = 4\frac{x^2-9x+18}{4} - 9\frac{x^2-8x+12}{3} + 36\frac{x^2-5x+6}{12} = x^2 </math>.

== Exemplo 3 ==

Para ilustrar graficamente o método da fórmula de Lagrange, usaremos um exemplo com <math>N=4</math>. Considerando os quatro pontos <math>(X_1,Y_1) = (-1,5)</math>, <math>(X_2,Y_3) = (1,2)</math>, <math>(X_3,Y_3) = (-3,5)</math> e <math>(X_4,Y_4) = (7,4)</math>, as equações <math>L_i</math> ficam

:<math>L_1 = -\frac{1}{64}(x^3-11x^2+31x-21)</math>,

:<math>L_2 = \frac{1}{24}(x^3-9x^2+11x+21)</math>,

:<math>L_3 = -\frac{1}{32}(x^3-7x^2-x+7)</math>

e

:<math>L_4 = \frac{1}{192}(x^3-3x^2-x+3)</math>.

O gráfico abaixo mostra os quatro pontos <math>(X_i,Y_i)</math>, as curvas <math>L_iY_i</math> e a curva final <math>P(x)</math>. Lembre-se que <math>P(x)</math> é a curva gerada pela soma dos polinômios <math>L_iY_i</math>. Note que a curva <math>L_1Y_1</math> passa pelo ponto <math>(X_1,Y_1)</math>, assim como as demais e a curva <math>P(x)</math> passa por todos os pontos.

[[Imagem:lagrange.png|800px]]

== Numericamente ==

Na prática, a implementação numérica do polinômio de Lagrange é complicada.
Computacionalmente não é possível fazer um programa geral para interpolação de ordem arbitrária, isto é fazer um programa que, com os N pontos de entrada <math>{X_i,Y_i}</math>, devolva um polinômio <math>P(x)</math> interpolador de grau N. Isto envolve computação simbólica (do tipo utilizada em programas proprietários como o Mathematica, Maple, ou livres como Maxima).
Por outro lado a implementação numérica do método na força bruta envolve um duplo laço de ordem N:
devem ser somados N termos (os <math>L_i(x)</math>) onde cada um deles é construído como um produto de N-1 termos; ao todo <math>N^2</math> cálculos para cada ponto x (isto fica como exercício a partir da fórmula
geral do <math>P(x)</math>).

O Algoritmo de Neville [http://www.physics.utah.edu/~detar/phys6720/handouts/interpolation/interpolation/node4.html] é muito útil na realização desta tarefa.Ao final, veremos que o polinômio interpolador de grau n pode ser reconstruído com polinômios de grau n-1. Este processo gera uma fórmula de recorrência, que é um recurso bastante comum em algoritmos computacionais.

Para deduzirmos esta fórmula de recorrência, começamos aproximando cada intervalo por um valor constante. Podemos representar esta aproximação por
<math>P_1(x)=Y_1,\; P_2(x)=Y_2,\; \cdots\,\; P_N(x)=Y_N</math>.
Melhorando a descrição, empregando agora uma aproximação linear em cada intervalo <math>[X_i,\;X_{i+1}]</math>, denotamos por <math>P_{12}(x),\;P_{23}(x),\; \cdots,\; P_{N-1,N}(x)</math>, onde <math>P_{i,i+1}(x)\;</math>é o polinômio que passa exatamente sobre
<math>(X_i,Y_i)\;</math>e<math>\;(X_{i+1},Y_{i+1})</math>:

<math>
P_{i,i+1}(x)=\frac{x-X_{i+1}}{X_i-X_{i+1}}Y_i+\frac{x-X_i}{X_{i+1}-X_i}Y_{i+1}\;.
</math>

Vemos que <math>P_{i, i+1}(x)\;</math>pode ser escrito como:

<math>
P_{i,i+1}(x)=\frac{(x-X_{i+1})P_i(x)-(x-X_i)P_{i+1}(x)}{X_i-X_{i+1}}
</math>

Isto sugere que há uma relação entre os polinômios de ordem <math>\;n</math> com os de ordem <math>\;n+1</math>.
Para verificar isto, vamos considerar, agora, uma parábola passando exatamente sobre
<math>(X_i,Y_i)\;,(X_{i+1},Y_{i+1})</math> e<math>\;(X_{i+2},Y_{i+2})</math>, que denotaremos por,<math>\;P_{i,i+1,i+2}(x)</math>:

<math>
P_{i,i+1,i+2}(x)=\frac{x-X_{i+1}}{X_i-X_{i+1}}\frac{x-X_{i+2}}{X_i -X_{i+2}}Y_i
+\frac{x-X_i}{X_{i+1}-X_i}\frac{x-X_{i+2}}{X_{i+1}-X_{i+2}}Y_{i+1}
+\frac{x-X_i}{X_{i+2}-X_i}\frac{x-X_{i+1}}{X_{i+2}-X_{i+1}}Y_{i+2}
</math>

Fatorando <math>\;1/(X_i-X_{i+2})</math> e somando e subtraindo <math>\frac{x-X_i}{X_{i+1}-X_i}(x-X_{i+2})Y_{i+1}</math>, obtemos:

<math>
P_{i,i+1,i+2}(x) =\frac{1}{X_i-X_{i+2}}\left[(x-X_{i+2})P_{i,i+1}(x)
-F(x)\right]
</math>

onde

<math>
F(x)=(x-X_i)\left[\frac{x-X_{i+1}}{X_{i+2}-X_{i+1}}Y_{i+2}
-\frac{X_i-X_{i+2}}{X_{i+1}-X_i}\frac{x-X_{i+2}}{X_{i+1}-X_{i+2}}Y_{i+1}
+\frac{x-X_{i+2}}{X_{i+1}-X_i}Y_{i+1}\right]\;.
</math>

Note que o último termo desta expressão corresponde àquele que foi subtraído após seu termo de sinal contrário ter
sido somado à expressão que levou a<math>\;P_{i,i+1}(x)</math> na equação para<math>\;P_{i,i+1,i+2}(x)</math>.
Rearranjando os termos acima, encontramos:

<math>
F(x)=(x-X_i)\left[\frac{x-X_{i+2}}{X_{i+1}-X_{i+2}}Y_{i+1}+\frac{x-X_{i+1}}{X_{i+2}-X_{i+1}}Y_{i+2}\right]
=(x-X_i)P_{i+1,i+2}(x)\;.
</math>

Substituindo este resultado na equação para<math>\;P_{i,i+1,i+2}(x)</math>, obtemos finalmente:

<math>
P_{i,i+1,i+2}(x) =\frac{1}{X_i-X_{i+2}}\left[(x-X_{i+2})P_{i,i+1}(x)
-(x-X_i)P_{i+1,i+2}(x)\right]
</math>

Assim, notamos que, de fato, há uma relação de recorrência bastante simples entre os polinômios que envolvem
<math>\;n</math> e <math>\;n+1</math> pontos, cuja forma geral é dada por:

<math>
P_{i,i+1,\cdots,i+k}(x) =\frac{1}{X_i-X_{i+k}}\left[(x-X_{i+k})P_{i,i+1,\cdots,i+k-1}(x)
-(x-X_i)P_{i+1,i+2,\cdots,i+k}(x)\right]
</math>

Por ser muito mais simples de se implementar numericamente do que a expressão original para <math>\;P(x)</math>,
é esta relação de recorrência que é, de fato, utilizada em cálculos numéricos. Os erros cometidos podem ser estimados calculando-se as diferenças entre as diferentes ordens do polinômio:

<math>
D^{(1)}_{k,i}(x)=P_{i,i+1,\cdots,i+k}(x)-P_{i,i+1,\cdots,i+k-1}(x)
</math>

e

<math>
D^{(2)}_{k,i}(x)=P_{i,i+1,\cdots,i+k}(x)-P_{i+1,i+2,\cdots,i+k}(x)\;.
</math>

Ao invés de se gerar <math>\;P(x)</math> a partir da relação de recorrência para <math>P_{i,i+1,\cdots,i+k}(x)</math>, pode-se utilizar as equações acima e obter relações de recorrência para <math>\;D^{(1)} \mbox{ e } D^{(2)}</math>. No final, obtemos <math>\;P(x)</math> a partir destas quantidades. Este desenvolvimento é deixado como exercício.

É importante notar que em nenhum ponto da discussão foi evocada a necessidade dos pontos <math>\;\{X_i\}</math> serem igualmente espaçados. Portanto, as fórmulas apresentadas aqui podem ser aplicadas em situações bastante gerais.

----

Como discutido na seção [[Interpolação e extrapolação]], é desaconselhável o uso de polinômios de grau elevado. Por isto, apenas um pequeno subconjunto dos valores tabulados, nas vizinhanças do ponto de interesse <math>\;X</math>, deve ser empregado.
Por exemplo, digamos que temos uma tabela com 100 pontos <math>\;\{(X_i,Y_i)\}</math>. Se desejamos estimar o valor de <math>\;Y</math> no interior da região <math>[X_1,\; X_N]</math>, ao invés de construir um polinômio de grau 99, podemos, por exemplo, dividir o espaço em 25 sub-regiões e usar polinômios cúbicos em cada uma delas,
utilizando apenas <math>(X_{i-1},Y_{i-1}),\; (X_i,Y_i),\; (X_{i+1},Y_{i+1})</math> e<math>\;(X_{i+2},Y_{i+2})</math>.

Contudo, devemos notar que, embora a interpolação seja contínua nas interfaces das regiões, a continuidade das derivadas 1a e 2a não é garantida. Em situações em que estas propriedades importam, outras aproximações devem ser adotadas (veja, por exemplo, [[Spline cúbico]]).

----

Interpolação e extrapolação

2011-10-20T18:42:41Z

Caca:

Dado um conjunto de dados <math>(X_1,Y_1), (X_2,Y_2), \cdots (X_N,Y_N)</math>, onde <math>\;Y_i</math> corresponde ao valor da grandeza <math>\;Y</math> em <math>\;X=X_i</math>, aproximações podem ser desenvolvidas para se obter estimativas de <math>\;Y(X)</math>, em valores de <math>\;X</math> que não constam do conjunto. Se <math>X_1 \le X \le X_N</math> esta estimativa é denominada '''interpolação''', caso contrário, chamamos de '''extrapolação'''. Usualmente, os mesmos algoritmos são usados nos dois casos.

Em geral, extrapolações são mais perigosas, uma vez que deve-se presumir o comportamento da função em regiões onde não se conhece nada sobre ela. Supõe-se que o comportamento perto da fronteira da região conhecida se estende até o ponto de interesse, o que constitui um "ato de fé". Embora seja extremamente útil para se estimar valores da grandeza além da região conhecida, cabe ressaltar que atrasos significativos no desenvolvimento de grande parte da física moderna teriam ocorrido se tivéssemos nos limitado a extrapolações ao invés de se realizar medidas pois muitos comportamentos diferentes, provenientes de um física nova, foram observados. Apesar disto, extrapolações cuidadosas constituem uma poderosa ferramenta em várias áreas, como por exemplo, na resolução numérica de equações diferencias.

Embora a interpolação possa parecer inofensiva, dificuldades também podem ser encontradas. Um exemplo clássico, evocado no livro [http://www.nr.com Numerical Recipes], é a função:

<math>
f(x)=3x^2+\frac{\log[(\pi-x)^2]}{\pi^4}+1
</math>

A figura abaixo mostra valores de <math>f(x)</math> calculados a partir desta fórmula, usando valores de <math>X_i</math> igualmente espaçados em <math>0.01</math>, no intervalo <math>0\le X\le 10</math>. Note que, este nível de detalhe de conhecimento sobre a função é, em geral, muito satisfatório tanto em cálculos numéricos quanto em medidas experimentais. Contudo, embora a função
pareça crescer monotonamente, o detalhe mostrado no interior da figura revela claramente que erros grosseiros serão cometidos por fórmulas de interpolação na região <math>x\approx\pi</math>.
A curva em vermelho corresponde à fórmula acima, enquanto que os pontos representam os valores tabulados.
Isto mostra que, como sempre, em se tratando de aproximações numéricas, todas as "receitas" devem sempre ser analisadas cuidadosamente em cada aplicação.

[[Imagem:pathology.jpg]]

Além dos aspectos sutis levantados acima, outra regra importante a ser observada em cálculos numéricos é que polinômios de grau elevado devem ser evitados. Embora seu uso permita a imposição de várias propriedades desejadas, como a imposição da continuidade das derivadas da função, por exemplo, um polinômio de grau <math>\;n</math> possui o mesmo número de raízes. Isto faz com que eles oscilem fortemente. Logo, isto pode levar a comportamentos indesejados em extrapolações.

No caso da interpolação, este efeito também ocorre. Ou seja, o uso de polinômios de grau elevado por causar problemas. Por construção, os valores da função são
reproduzidos nos pontos <math>\;X_i</math>. No entanto, ainda assim podem ocorrer fortes oscilaçõesê entre 2 pontos adjacentes se a ordem do polinômio for muito elevada. Não há regras simples para se determinar, no caso geral, qual é o melhor grau a ser utilizado. Os teoremas matemáticos genéricos requerem tanta informação sobre a função que, na verdade, se as conhecessemos, não precisaríamos fazer aproximações polinomiais. Uma boa receita para se evitar dificuldades consiste em se utilizar o polinômio de ordem mais baixa possível que garanta as propriedades e precisão desejadas. No caso em que os dados em consideração são obtidos a partir de cálculos numéricos, maior precisão pode ser obtida aumentando-se o número de pontos do conjunto de dados, mantendo-se o grau do polinômio empregado. Em se tratando de dados experimentais, onde em geral pode não ser simples (até mesmo por razões de custo) se obter mais pontos intermediários, aumentar um pouco o grau do polinômio pode ser uma solução aceitável. Se ainda assim isto não for suficiente, cabe ressaltar que existem outros métodos vai além de aproximações polinomiais e que técnicas baseadas em razões entre polinômios diferentes ou envolvendo funções mais complexas podem ser utilizadas com segurança.

No link a seguir, "Interpolação polinomial e Fórmula de Lagrange", há um exemplo de interpolação / extrapolação polinomial.

Este assunto é muito vasto para ser tratado nesta abordagem introdutória. Uma discussão mais completa pode ser encontrada, por exemplo, no livro [http://www.nr.com Numerical Recipes]. Em particular, boa parte da discussão a seguir, sobre a [[Fórmula de Lagrange]] e [[Spline cúbico]], é fortemente baseada na apresentação deste livro.

----

Voltar para o índice de [[Métodos computacionais]].

Interpolação e extrapolação

2011-10-20T18:33:48Z

Caca:

Dado um conjunto de dados <math>(X_1,Y_1), (X_2,Y_2), \cdots (X_N,Y_N)</math>, onde <math>\;Y_i</math> corresponde ao valor da grandeza <math>\;Y</math> em <math>\;X=X_i</math>, aproximações podem ser desenvolvidas para se obter estimativas de <math>\;Y(X)</math>, em valores de <math>\;X</math> que não constam do conjunto. Se <math>X_1 \le X \le X_N</math> esta estimativa é denominada '''interpolação''', caso contrário, chamamos de '''extrapolação'''. Usualmente, os mesmos algoritmos são usados nos dois casos.

Em geral, extrapolações são mais perigosas, uma vez que deve-se presumir o comportamento da função em regiões onde não se conhece nada sobre ela. Supõe-se que o comportamento perto da fronteira da região conhecida se estende até o ponto de interesse, o que constitui um "ato de fé". Embora seja extremamente útil para se estimar valores da grandeza além da região conhecida, cabe ressaltar que atrasos significativos no desenvolvimento de grande parte da física moderna teriam ocorrido se tivéssemos nos limitado a extrapolações ao invés de se realizar medidas pois muitos comportamentos diferentes, provenientes de um física nova, foram observados. Apesar disto, extrapolações cuidadosas constituem uma poderosa ferramenta em várias áreas, como por exemplo, na resolução numérica de equações diferencias.

Embora a interpolação possa parecer inofensiva, dificuldades também podem ser encontradas. Um exemplo clássico, evocado no livro [http://www.nr.com Numerical Recipes], é a função:

<math>
f(x)=3x^2+\frac{\log[(\pi-x)^2]}{\pi^4}+1
</math>

A figura abaixo mostra valores de <math>f(x)</math> calculados a partir desta fórmula, usando valores de <math>X_i</math> igualmente espaçados em <math>0.01</math>, no intervalo <math>0\le X\le 10</math>. Note que, este nível de detalhe de conhecimento sobre a função é, em geral, muito satisfatório tanto em cálculos numéricos quanto em medidas experimentais. Contudo, embora a função
pareça crescer monotonamente, o detalhe mostrado no interior da figura revela claramente que erros grosseiros serão cometidos por fórmulas de interpolação na região <math>x\approx\pi</math>.
A curva em vermelho corresponde à fórmula acima, enquanto que os pontos representam os valores tabulados.
Isto mostra que, como sempre, em se tratando de aproximações numéricas, todas as "receitas" devem sempre ser analisadas cuidadosamente em cada aplicação.

[[Imagem:pathology.jpg]]

Além dos aspectos sutis levantados acima, outra regra importante a ser observada em cálculos numéricos é que polinômios de grau elevado devem ser evitados. Embora seu uso permita a imposição de várias propriedades desejadas, como a imposição da continuidade das derivadas da função, por exemplo, um polinômio de grau <math>\;n</math> possui o mesmo número de raízes. Isto faz com que eles oscilem fortemente. Logo, isto pode levar a comportamentos indesejados em extrapolações.

No caso da interpolação, este efeito também ocorre. Ou seja, o uso de polinômios de grau elevado por causar problemas. Por construção, os valores da função são
reproduzidos nos pontos <math>\;X_i</math>. No entanto, ainda assim podem ocorrer fortes oscilaçõesê entre 2 pontos adjacentes se a ordem do polinômio for muito elevada. Não há regras simples para se determinar, no caso geral, qual é o melhor grau a ser utilizado. Os teoremas matemáticos genéricos requerem tanta informação sobre a função que, na verdade, se as conhecessemos, não precisaríamos fazer aproximações polinomiais. Uma boa receita para se evitar dificuldades consiste em se utilizar o polinômio de ordem mais baixa possível que garanta as propriedades e precisão desejadas. No caso em que os dados em consideração são obtidos a partir de cálculos numéricos, maior precisão pode ser obtida aumentando-se o número de pontos do conjunto de dados, mantendo-se o grau do polinômio empregado. Em se tratando de dados experimentais, onde em geral pode não ser simples (até mesmo por razões de custo) se obter mais pontos intermediários, aumentar um pouco o grau do polinômio pode ser uma solução aceitável. Se ainda assim isto não for suficiente, cabe ressaltar que existem outros métodos vai além de aproximações polinomiais e que técnicas baseadas em razões entre polinômios diferentes ou envolvendo funções mais complexas podem ser utilizadas com segurança.

Este assunto é muito vasto para ser tratado nesta abordagem introdutória. Uma discussão mais completa pode ser encontrada, por exemplo, no livro [http://www.nr.com Numerical Recipes]. Em particular, boa parte da discussão a seguir, sobre a [[Fórmula de Lagrange]] e [[Spline cúbico]], é fortemente baseada na apresentação deste livro.

----

Voltar para o índice de [[Métodos computacionais]].

Integração Numérica

2011-10-20T18:26:14Z

Caca:

[[Image:integral.jpg|thumb|right|A integração numérica consiste em achar a aproximação numérica para o valor de <math>S</math>]]

'''Integração numérica''' é um termo amplo que abrange até a integração de equações diferenciais como é discutido
em Métodos Computacionais B. Aqui nos referimos exclusivamente ao cálculo numérico da '''integral definida''':

:<math> S = \int_{a}^{b} f(x) dx</math>

O termo '''definida''', quer dizer que a integral se faz entre limites definidos, no caso '''a''' e '''b'''.

O interesse de fazer esse cálculo numericamente se deve a:

# existência de funções contínuas sem '''primitiva,''' o que inviabiliza a conta analítica.
# funções descontinuas ou definidas por trechos
# funções (ou tabelas) provenientes de experimentos
# funções continuas e com primitiva de representação simbólica, porem de difícil avaliação na prática (mais difícil que avaliar a própria função)

== Definição ==

Revisemos o conceito de '''integral''' do cálculo:
A '''integral''' definida de uma função f(x) no intervalo [a, b] se define como:

:<math>S = \int_a^b f(x)\, dx = \lim_{N\to\infty} \sum_{i=0}^{N} f(x_i) \Delta x </math>

A integral de f(x) pode ser entendida como a soma de pequenos retângulos de base dx e altura f(x), onde o produto f(x) dx é a área deste retângulo. 
A soma de todas estas pequenas áreas, ou áreas infinitesimais, fornece a área total abaixo da curva. 
Mais precisamente podemos dizer que a integral acima é o valor limite da soma:
: <math> \sum_{i=0}^{N} f(x_i) \Delta x. </math>
onde:
:<math>\Delta x = \frac{b-a}{N}</math>
é o comprimento dos pequenos intervalos nos quais dividimos o intervalo (b-a), <math>f(x_i)</math>
é o valor da função em algum ponto deste intervalo. 
Quando <math>N \to \infty</math> o valor da soma acima é igual a área abaixo da curva.

A integral também é conhecida como antiderivada:
:<math> \int f(x)dx = F(x) \Leftrightarrow \frac{dF(x)}{dx}= f(x)</math>
Relembremos porque:

== Teorema Fundamental do Cálculo ==

Se resolvermos a integral acima entre os limites ''a'' e ''b'', o resultado pode ser escrito como dependendo só dos extremos:

:<math> S = \int_{a}^{b} f(x) dx = F(b) - F(a) </math>

Vamos ver agora como se isso for válido, então F(x) é a primitiva procurada.

Calculando a integral entre <math>x</math> e <math>x + \Delta x</math>:

:<math> \int_{x}^{x+\Delta x} f(x') dx' = F(x + \Delta x) - F(x) </math>

Pela definição da integral entre limites definidos podemos escrevê-la como:

:<math> \int_{x}^{x+\Delta x} f(x') dx' = f(x'') \Delta x = F(x + \Delta x) - F(x) </math>

onde <math> x''</math> é um valor de <math>x</math> entre os extremos do intervalo.

Passando o <math>\Delta x</math> para a direita e tomando o limite quando ele vai para zero:

:<math> \lim_{\Delta x \to 0 } f(x'') = \lim_{\Delta x \to 0 } \frac{ F(x + \Delta x) - F(x) }{ \Delta x } \Rightarrow f(x) = \frac{d}{dx} F(x) </math>

Demonstramos que a derivada de F(x) resulta ser a função f(x) que queremos integrar. Em outras palavras, o '''Teorema fundamental do Cálculo'''
diz que resolver uma integral se resume a achar a ''primitiva'', ou seja uma função cuja derivada seja o integrando.

'''O problema prático é que não todas as funções tem primitiva.'''.
Vejamos então.

== Cálculo Numérico ==

[[Image:Trapezio.png|right|frame|Ilustração da regra do retângulo.]]

[[Image:integrationtrapezio.png|right|frame|Ilustração da regra do trapézio.]]

[[Image:Integrationsimpson.png|right|frame|Ilustração da regra de Simpson.]]

O cálculo numérico de uma integral definida se baseia na própria definição acima.
Com a diferença que N é finito. Obviamente quanto maior, melhor. 
-Temos que pelos retângulos definidos pelo extremo esquerdo de cada subintervalo:
:<math>\int_a^b f(x)\, dx \approx S_e = \sum_{i=0}^{N-1} f(x_i) \Delta x </math>
-E pelos retângulos definidos pelo extremo direito de cada subintervalo:
:<math>\int_a^b f(x)\, dx \approx S_d = \sum_{i=1}^{N} f(x_i) \Delta x </math>

Regra do Trapézio:
:<math>\int_a^b f(x)dx \approx S_t = \sum_{i=0}^{N-1} \frac{f(x_i)+f(x_i+\Delta x)}{2}\Delta x</math>
onde:
:<math>x_i = a + i \Delta x,\;\; \Delta x = \frac{b-a}{N}</math>

Esta última pode ser reescrita como:
:<math>\left(\frac{f(a)+f(b)}{2} + \sum_{i=1}^{N-1} f(x_i)\right)\Delta x</math>

Também pode se verificar que a integral calculada com os trapézios é a média das integrais calculadas com retângulos:
:<math>S_t = (S_e + S_d)/2</math>

Regra de Simpson:

Notemos que o método do trapézio é baseado na ideia de passar uma reta por 2 pontos e aproximar a área da função f(x) pela área sob a curva definida pelo trapézio.

A regra de Simpson é uma extensão disto: a ideia é passar uma parábola por três pontos consecutivos e calcular a área definida por ela. Se tivermos apenas 3 pontos, a integral da parábola que passa entre <math> x_{0} , x_{2}</math> é dada por:

:<math>S= \int_{x_0}^{x_2} f(x) \, dx \approx \frac{x_2-x_0}{6}\left[f(x_0) + 4f\left(\frac{x_0+x_2}{2}\right)+f(x_2)\right]</math>

No entanto, para integrarmos sobre toda o intervalo <math>\left[ x_{1} ; x_{n}\right]</math> com boa precisão, é necessário dividi-lo em N intervalos, com N grande (e par!). Assim, é preciso traçar uma parábola a cada três pontos consecutivos e a expressão final da fórmula de Simpson é então a soma da área sob todas as parábolas do intervalo <math>\left[ x_{0} ; x_{n}\right]</math> :

:<math>S= \int_{x_0}^{x_n} f(x)dx \simeq \frac{h}{3}\left[f(x_0)+4f(x_1)+2f(x_2)+4f(x_3)+\ldots+4f(x_{n-1})+f(x_n)\right]</math>,

onde <math> h = (x_{n} - x_{0} )/N </math> .

A dedução da regra de Simpson pode ser encontrada por exemplo em [http://www.math.ist.utl.pt/~calves/courses/integra/capiii33.html].

== Programação ==
A seguir um trecho do programa para cálculo da integral da função f(x) (''external function f(x)'') 
entre a e b com N pontos, usando o método dos retângulos pela esquerda:

<pre>
...
Read*, a, b, N
dx = (b-a)/N; S=0

Do i = 0, N-1
x = a + i*dx
S = S + f(x)
EndDo
Print*, "Integral S=", S*dx
...
</pre>

Os outros métodos se programam de maneira similar mudando limites (índice do laço) 
e/ou tratando de forma diferente os valores das pontas.

== Erro associado ao método numérico ==

O método de integração numérico não retorna o valor exato de uma função, visto que não podemos ter no computador <math>N\to\infty</math>. O erro aqui discutido estará vinculado ao número de divisões <math>N</math> realizada na função <math>f(x)</math> dentro do intervalo que se quer saber o valor da integral. Assim, o erro é definido como

:<math>erro=\frac{Int(N)-Int(N-1)}{Int(N)}</math>,
onde <math>Int(N)</math> é o valor retornado pelo método numérico utilizado utilizando <math>N</math> divisões e <math>Int(N-1)</math> utilizando <math>N-1</math> divisões. Note que um teste simples para verificar quando a resposta está convergindo é aumentar <math>N</math> e calcular o erro a cada incremento no seu valor.

Integração Numérica

2011-10-19T10:20:43Z

Caca:

[[Image:integral.jpg|thumb|right|A integração numérica consiste em achar a aproximação numérica para o valor de <math>S</math>]]

'''Integração numérica''' é um termo amplo que abrange até a integração de equações diferenciais como é discutido
em Métodos Computacionais B. Aqui nos referimos exclusivamente ao cálculo numérico da '''integral definida''':

:<math> S = \int_{a}^{b} f(x) dx</math>

O termo '''definida''', quer dizer que a integral se faz entre limites definidos, no caso '''a''' e '''b'''.

O interesse de fazer esse cálculo numericamente se deve a:

# existência de funções contínuas sem '''primitiva,''' o que inviabiliza a conta analítica.
# funções descontinuas ou definidas por trechos
# funções (ou tabelas) provenientes de experimentos
# funções continuas e com primitiva de representação simbólica, porem de difícil avaliação na prática (mais difícil que avaliar a própria função)

== Definição ==

Revisemos o conceito de '''integral''' do cálculo:
A '''integral''' definida de uma função f(x) no intervalo [a, b] se define como:

:<math>S = \int_a^b f(x)\, dx = \lim_{N\to\infty} \sum_{i=0}^{N} f(x_i) \Delta x </math>

A integral de f(x) pode ser entendida como a soma de pequenos retângulos de base dx e altura f(x), onde o produto f(x) dx é a área deste retângulo. 
A soma de todas estas pequenas áreas, ou áreas infinitesimais, fornece a área total abaixo da curva. 
Mais precisamente podemos dizer que a integral acima é o valor limite da soma:
: <math> \sum_{i=0}^{N} f(x_i) \Delta x. </math>
onde:
:<math>\Delta x = \frac{b-a}{N}</math>
é o comprimento dos pequenos intervalos nos quais dividimos o intervalo (b-a), <math>f(x_i)</math>
é o valor da função em algum ponto deste intervalo. 
Quando <math>N \to \infty</math> o valor da soma acima é igual a área abaixo da curva.

A integral também é conhecida como antiderivada:
:<math> \int f(x)dx = F(x) \Leftrightarrow \frac{dF(x)}{dx}= f(x)</math>
Relembremos porque:

== Teorema Fundamental do Cálculo ==

Se resolvermos a integral acima entre os limites ''a'' e ''b'', o resultado pode ser escrito como dependendo só dos extremos:

:<math> S = \int_{a}^{b} f(x) dx = F(b) - F(a) </math>

Vamos ver agora como se isso for válido, então F(x) é a primitiva procurada.

Calculando a integral entre <math>x</math> e <math>x + \Delta x</math>:

:<math> \int_{x}^{x+\Delta x} f(x') dx' = F(x + \Delta x) - F(x) </math>

Pela definição da integral entre limites definidos podemos escrevê-la como:

:<math> \int_{x}^{x+\Delta x} f(x') dx' = f(x'') \Delta x = F(x + \Delta x) - F(x) </math>

onde <math> x''</math> é um valor de <math>x</math> entre os extremos do intervalo.

Passando o <math>\Delta x</math> para a direita e tomando o limite quando ele vai para zero:

:<math> \lim_{\Delta x \to 0 } f(x'') = \lim_{\Delta x \to 0 } \frac{ F(x + \Delta x) - F(x) }{ \Delta x } \Rightarrow f(x) = \frac{d}{dx} F(x) </math>

Demonstramos que a derivada de F(x) resulta ser a função f(x) que queremos integrar. Em outras palavras, o '''Teorema fundamental do Cálculo'''
diz que resolver uma integral se resume a achar a ''primitiva'', ou seja uma função cuja derivada seja o integrando.

'''O problema prático é que não todas as funções tem primitiva.'''.
Vejamos então.

== Cálculo Numérico ==

[[Image:Trapezio.png|right|frame|Ilustração da regra do retângulo.]]

[[Image:integrationtrapezio.png|right|frame|Ilustração da regra do trapézio.]]

[[Image:Integrationsimpson.png|right|frame|Ilustração da regra de Simpson.]]

O cálculo numérico de uma integral definida se baseia na própria definição acima.
Com a diferença que N é finito. Obviamente quanto maior, melhor. 
-Temos que pelos retângulos definidos pelo extremo esquerdo de cada subintervalo:
:<math>\int_a^b f(x)\, dx \approx S_e = \sum_{i=0}^{N-1} f(x_i) \Delta x </math>
-E pelos retângulos definidos pelo extremo direito de cada subintervalo:
:<math>\int_a^b f(x)\, dx \approx S_d = \sum_{i=1}^{N} f(x_i) \Delta x </math>

Regra do Trapézio:
:<math>\int_a^b f(x)dx \approx S_t = \sum_{i=0}^{N-1} \frac{f(x_i)+f(x_i+\Delta x)}{2}\Delta x</math>
onde:
:<math>x_i = a + i \Delta x,\;\; \Delta x = \frac{b-a}{N}</math>

Esta última pode ser reescrita como:
:<math>\left(\frac{f(a)+f(b)}{2} + \sum_{i=1}^{N-1} f(x_i)\right)\Delta x</math>

Também pode se verificar que a integral calculada com os trapézios é a média das integrais calculadas com retângulos:
:<math>S_t = (S_e + S_d)/2</math>

Regra de Simpson:

Notemos que o método do trapézio é baseado na ideia de passar uma reta por 2 pontos e aproximar a área da função f(x) pela área sob a curva definida pelo trapézio.

A regra de Simpson é uma extensão disto: a ideia é passar uma parábola por três pontos consecutivos e calcular a área definida por ela. Se tivermos apenas 3 pontos, a integral da parábola que passa entre <math> x_{1} , x_{3}</math> é dada por:

:<math>S= \int_{x_0}^{x_2} f(x) \, dx \approx \frac{x_2-x_0}{6}\left[f(x_0) + 4f\left(\frac{x_0+x_2}{2}\right)+f(x_2)\right]</math>

No entanto, para integrarmos sobre toda o intervalo <math>\left[ x_{1} ; x_{n}\right]</math> com boa precisão, é necessário dividi-lo em N intervalos, com N grande (e par!). Assim, é preciso traçar uma parábola a cada três pontos consecutivo e a expressão final da fórmula de Simpson é então a soma da área sob todas as parábolas do intervalo <math>\left[ x_{0} ; x_{n}\right]</math> :

:<math>S= \int_{x_0}^{x_n} f(x)dx \simeq \frac{h}{3}\left[f(x_0)+4f(x_1)+2f(x_2)+4f(x_3)+\ldots+4f(x_{n-1})+f(x_n)\right]</math>,

onde <math> h = (x_{n} - x_{0} )/N </math> .

A dedução da regra de Simpson pode ser encontrada por exemplo em [http://www.math.ist.utl.pt/~calves/courses/integra/capiii33.html].

== Programação ==
A seguir um trecho do programa para cálculo da integral da função f(x) (''external function f(x)'') 
entre a e b com N pontos, usando o método dos retângulos pela esquerda:

<pre>
...
Read*, a, b, N
dx = (b-a)/N; S=0

Do i = 0, N-1
x = a + i*dx
S = S + f(x)
EndDo
Print*, "Integral S=", S*dx
...
</pre>

Os outros métodos se programam de maneira similar mudando limites (índice do laço) 
e/ou tratando de forma diferente os valores das pontas.

== Erro associado ao método numérico ==

O método de integração numérico não retorna o valor exato de uma função, visto que não podemos ter no computador <math>N\to\infty</math>. O erro aqui discutido estará vinculado ao número de divisões <math>N</math> realizada na função <math>f(x)</math> dentro do intervalo que se quer saber o valor da integral. Assim, o erro é definido como

:<math>erro=\frac{Int(N)-Int(N-1)}{Int(N)}</math>,
onde <math>Int(N)</math> é o valor retornado pelo método numérico utilizado utilizando <math>N</math> divisões e <math>Int(N-1)</math> utilizando <math>N-1</math> divisões. Note que um teste simples para verificar quando a resposta está convergindo é aumentar <math>N</math> e calcular o erro a cada incremento no seu valor.

Integração Numérica

2011-10-18T17:16:52Z

Caca:

[[Image:integral.jpg|thumb|right|A integração numérica consiste em achar a aproximação numérica para o valor de <math>S</math>]]

'''Integração numérica''' é um termo amplo que abrange até a integração de equações diferenciais como é discutido
em Métodos Computacionais B. Aqui nos referimos exclusivamente ao cálculo numérico da '''integral definida''':

:<math> S = \int_{a}^{b} f(x) dx</math>

O termo '''definida''', quer dizer que a integral se faz entre limites definidos, no caso '''a''' e '''b'''.

O interesse de fazer esse cálculo numericamente se deve a:

# existência de funções contínuas sem '''primitiva,''' o que inviabiliza a conta analítica.
# funções descontinuas ou definidas por trechos
# funções (ou tabelas) provenientes de experimentos
# funções continuas e com primitiva de representação simbólica, porem de difícil avaliação na prática (mais difícil que avaliar a própria função)

== Definição ==

Revisemos o conceito de '''integral''' do cálculo:
A '''integral''' definida de uma função f(x) no intervalo [a, b] se define como:

:<math>S = \int_a^b f(x)\, dx = \lim_{N\to\infty} \sum_{i=0}^{N} f(x_i) \Delta x </math>

A integral de f(x) pode ser entendida como a soma de pequenos retângulos de base dx e altura f(x), onde o produto f(x) dx é a área deste retângulo. 
A soma de todas estas pequenas áreas, ou áreas infinitesimais, fornece a área total abaixo da curva. 
Mais precisamente podemos dizer que a integral acima é o valor limite da soma:
: <math> \sum_{i=0}^{N} f(x_i) \Delta x. </math>
onde:
:<math>\Delta x = \frac{b-a}{N}</math>
é o comprimento dos pequenos intervalos nos quais dividimos o intervalo (b-a), <math>f(x_i)</math>
é o valor da função em algum ponto deste intervalo. 
Quando <math>N \to \infty</math> o valor da soma acima é igual a área abaixo da curva.

A integral também é conhecida como antiderivada:
:<math> \int f(x)dx = F(x) \Leftrightarrow \frac{dF(x)}{dx}= f(x)</math>
Relembremos porque:

== Teorema Fundamental do Cálculo ==

Se resolvermos a integral acima entre os limites ''a'' e ''b'', o resultado pode ser escrito como dependendo só dos extremos:

:<math> S = \int_{a}^{b} f(x) dx = F(b) - F(a) </math>

Vamos ver agora como se isso for válido, então F(x) é a primitiva procurada.

Calculando a integral entre <math>x</math> e <math>x + \Delta x</math>:

:<math> \int_{x}^{x+\Delta x} f(x') dx' = F(x + \Delta x) - F(x) </math>

Pela definição da integral entre limites definidos podemos escrevê-la como:

:<math> \int_{x}^{x+\Delta x} f(x') dx' = f(x'') \Delta x = F(x + \Delta x) - F(x) </math>

onde <math> x''</math> é um valor de <math>x</math> entre os extremos do intervalo.

Passando o <math>\Delta x</math> para a direita e tomando o limite quando ele vai para zero:

:<math> \lim_{\Delta x \to 0 } f(x'') = \lim_{\Delta x \to 0 } \frac{ F(x + \Delta x) - F(x) }{ \Delta x } \Rightarrow f(x) = \frac{d}{dx} F(x) </math>

Demonstramos que a derivada de F(x) resulta ser a função f(x) que queremos integrar. Em outras palavras, o '''Teorema fundamental do Cálculo'''
diz que resolver uma integral se resume a achar a ''primitiva'', ou seja uma função cuja derivada seja o integrando.

'''O problema prático é que não todas as funções tem primitiva.'''.
Vejamos então.

== Cálculo Numérico ==

[[Image:Trapezio.png|right|frame|Ilustração da regra do retângulo.]]

[[Image:integrationtrapezio.png|right|frame|Ilustração da regra do trapézio.]]

[[Image:Integrationsimpson.png|right|frame|Ilustração da regra de Simpson.]]

O cálculo numérico de uma integral definida se baseia na própria definição acima.
Com a diferença que N é finito. Obviamente quanto maior, melhor. 
-Temos que pelos retângulos definidos pelo extremo esquerdo de cada subintervalo:
:<math>\int_a^b f(x)\, dx \approx S_e = \sum_{i=0}^{N-1} f(x_i) \Delta x </math>
-E pelos retângulos definidos pelo extremo direito de cada subintervalo:
:<math>\int_a^b f(x)\, dx \approx S_d = \sum_{i=1}^{N} f(x_i) \Delta x </math>

Regra do Trapézio:
:<math>\int_a^b f(x)dx \approx S_t = \sum_{i=0}^{N-1} \frac{f(x_i)+f(x_i+\Delta x)}{2}\Delta x</math>
onde:
:<math>x_i = a + i \Delta x,\;\; \Delta x = \frac{b-a}{N}</math>

Esta última pode ser reescrita como:
:<math>\left(\frac{f(a)+f(b)}{2} + \sum_{i=1}^{N-1} f(x_i)\right)\Delta x</math>

Também pode se verificar que a integral calculada com os trapézios é a média das integrais calculadas com retângulos:
:<math>S_t = (S_e + S_d)/2</math>

Regra de Simpson:

Notemos que o método do trapézio é baseado na ideia de passar uma reta por 2 pontos e aproximar a área da função f(x) pela área sob a curva definida pelo trapézio.

A regra de Simpson é uma extensão disto: a ideia é passar uma parábola por três pontos consecutivos e calcular a área definida por ela. Se tivermos apenas 3 pontos, a integral da parábola que passa entre <math> x_{1} , x_{3}</math> é dada por:

:<math>S= \int_{x_1}^{x_3} f(x) \, dx \approx \frac{x_3-x_1}{6}\left[f(x_1) + 4f\left(\frac{x_1+x_3}{2}\right)+f(x_3)\right]</math>

No entanto, para integrarmos sobre toda o intervalo <math>\left[ x_{1} ; x_{n}\right]</math> com boa precisão, é necessário dividi-lo em N intervalos, com N grande (e par!). Assim, é preciso traçar uma parábola a cada três pontos consecutivo e a expressão final da fórmula de Simpson é então a soma da área sob todas as parábolas do intervalo <math>\left[ x_{1} ; x_{n}\right]</math> :

:<math>S= \int_{x_1}^{x_n} f(x)dx \simeq \frac{h}{3}\left[f(x_1)+4f(x_2)+2f(x_3)+4f(x_4)+\ldots+4f(x_{n-1})+f(x_n)\right]</math>,

onde <math> h = (x_{n} - x_{1} )/N </math> .

A dedução da regra de Simpson pode ser encontrada por exemplo em [http://www.math.ist.utl.pt/~calves/courses/integra/capiii33.html].

== Programação ==
A seguir um trecho do programa para cálculo da integral da função f(x) (''external function f(x)'') 
entre a e b com N pontos, usando o método dos retângulos pela esquerda:

<pre>
...
Read*, a, b, N
dx = (b-a)/N; S=0

Do i = 0, N-1
x = a + i*dx
S = S + f(x)
EndDo
Print*, "Integral S=", S*dx
...
</pre>

Os outros métodos se programam de maneira similar mudando limites (índice do laço) 
e/ou tratando de forma diferente os valores das pontas.

== Erro associado ao método numérico ==

O método de integração numérico não retorna o valor exato de uma função, visto que não podemos ter no computador <math>N\to\infty</math>. O erro aqui discutido estará vinculado ao número de divisões <math>N</math> realizada na função <math>f(x)</math> dentro do intervalo que se quer saber o valor da integral. Assim, o erro é definido como

:<math>erro=\frac{Int(N)-Int(N-1)}{Int(N)}</math>,
onde <math>Int(N)</math> é o valor retornado pelo método numérico utilizado utilizando <math>N</math> divisões e <math>Int(N-1)</math> utilizando <math>N-1</math> divisões. Note que um teste simples para verificar quando a resposta está convergindo é aumentar <math>N</math> e calcular o erro a cada incremento no seu valor.

Integração Numérica

2011-10-18T17:15:19Z

Caca:

[[Image:integral.jpg|thumb|right|A integração numérica consiste em achar a aproximação numérica para o valor de <math>S</math>]]

'''Integração numérica''' é um termo amplo que abrange até a integração de equações diferenciais como é discutido
em Métodos Computacionais B. Aqui nos referimos exclusivamente ao cálculo numérico da '''integral definida''':

:<math> S = \int_{a}^{b} f(x) dx</math>

O termo '''definida''', quer dizer que a integral se faz entre limites definidos, no caso '''a''' e '''b'''.

O interesse de fazer esse cálculo numericamente se deve a:

# existência de funções contínuas sem '''primitiva,''' o que inviabiliza a conta analítica.
# funções descontinuas ou definidas por trechos mas para as quais a integral não existe (no fundo é a falta de uma primitiva)
# funções (ou tabelas) provenientes de experimentos
# funções continuas e com primitiva de representação simbólica, porem de difícil avaliação na prática (mais difícil que avaliar a própria função)

== Definição ==

Revisemos o conceito de '''integral''' do cálculo:
A '''integral''' definida de uma função f(x) no intervalo [a, b] se define como:

:<math>S = \int_a^b f(x)\, dx = \lim_{N\to\infty} \sum_{i=0}^{N} f(x_i) \Delta x </math>

A integral de f(x) pode ser entendida como a soma de pequenos retângulos de base dx e altura f(x), onde o produto f(x) dx é a área deste retângulo. 
A soma de todas estas pequenas áreas, ou áreas infinitesimais, fornece a área total abaixo da curva. 
Mais precisamente podemos dizer que a integral acima é o valor limite da soma:
: <math> \sum_{i=0}^{N} f(x_i) \Delta x. </math>
onde:
:<math>\Delta x = \frac{b-a}{N}</math>
é o comprimento dos pequenos intervalos nos quais dividimos o intervalo (b-a), <math>f(x_i)</math>
é o valor da função em algum ponto deste intervalo. 
Quando <math>N \to \infty</math> o valor da soma acima é igual a área abaixo da curva.

A integral também é conhecida como antiderivada:
:<math> \int f(x)dx = F(x) \Leftrightarrow \frac{dF(x)}{dx}= f(x)</math>
Relembremos porque:

== Teorema Fundamental do Cálculo ==

Se resolvermos a integral acima entre os limites ''a'' e ''b'', o resultado pode ser escrito como dependendo só dos extremos:

:<math> S = \int_{a}^{b} f(x) dx = F(b) - F(a) </math>

Vamos ver agora como se isso for válido, então F(x) é a primitiva procurada.

Calculando a integral entre <math>x</math> e <math>x + \Delta x</math>:

:<math> \int_{x}^{x+\Delta x} f(x') dx' = F(x + \Delta x) - F(x) </math>

Pela definição da integral entre limites definidos podemos escrevê-la como:

:<math> \int_{x}^{x+\Delta x} f(x') dx' = f(x'') \Delta x = F(x + \Delta x) - F(x) </math>

onde <math> x''</math> é um valor de <math>x</math> entre os extremos do intervalo.

Passando o <math>\Delta x</math> para a direita e tomando o limite quando ele vai para zero:

:<math> \lim_{\Delta x \to 0 } f(x'') = \lim_{\Delta x \to 0 } \frac{ F(x + \Delta x) - F(x) }{ \Delta x } \Rightarrow f(x) = \frac{d}{dx} F(x) </math>

Demonstramos que a derivada de F(x) resulta ser a função f(x) que queremos integrar. Em outras palavras, o '''Teorema fundamental do Cálculo'''
diz que resolver uma integral se resume a achar a ''primitiva'', ou seja uma função cuja derivada seja o integrando.

'''O problema prático é que não todas as funções tem primitiva.'''.
Vejamos então.

== Cálculo Numérico ==

[[Image:Trapezio.png|right|frame|Ilustração da regra do retângulo.]]

[[Image:integrationtrapezio.png|right|frame|Ilustração da regra do trapézio.]]

[[Image:Integrationsimpson.png|right|frame|Ilustração da regra de Simpson.]]

O cálculo numérico de uma integral definida se baseia na própria definição acima.
Com a diferença que N é finito. Obviamente quanto maior, melhor. 
-Temos que pelos retângulos definidos pelo extremo esquerdo de cada subintervalo:
:<math>\int_a^b f(x)\, dx \approx S_e = \sum_{i=0}^{N-1} f(x_i) \Delta x </math>
-E pelos retângulos definidos pelo extremo direito de cada subintervalo:
:<math>\int_a^b f(x)\, dx \approx S_d = \sum_{i=1}^{N} f(x_i) \Delta x </math>

Regra do Trapézio:
:<math>\int_a^b f(x)dx \approx S_t = \sum_{i=0}^{N-1} \frac{f(x_i)+f(x_i+\Delta x)}{2}\Delta x</math>
onde:
:<math>x_i = a + i \Delta x,\;\; \Delta x = \frac{b-a}{N}</math>

Esta última pode ser reescrita como:
:<math>\left(\frac{f(a)+f(b)}{2} + \sum_{i=1}^{N-1} f(x_i)\right)\Delta x</math>

Também pode se verificar que a integral calculada com os trapézios é a média das integrais calculadas com retângulos:
:<math>S_t = (S_e + S_d)/2</math>

Regra de Simpson:

Notemos que o método do trapézio é baseado na ideia de passar uma reta por 2 pontos e aproximar a área da função f(x) pela área sob a curva definida pelo trapézio.

A regra de Simpson é uma extensão disto: a ideia é passar uma parábola por três pontos consecutivos e calcular a área definida por ela. Se tivermos apenas 3 pontos, a integral da parábola que passa entre <math> x_{1} , x_{3}</math> é dada por:

:<math>S= \int_{x_1}^{x_3} f(x) \, dx \approx \frac{x_3-x_1}{6}\left[f(x_1) + 4f\left(\frac{x_1+x_3}{2}\right)+f(x_3)\right]</math>

No entanto, para integrarmos sobre toda o intervalo <math>\left[ x_{1} ; x_{n}\right]</math> com boa precisão, é necessário dividi-lo em N intervalos, com N grande (e par!). Assim, é preciso traçar uma parábola a cada três pontos consecutivo e a expressão final da fórmula de Simpson é então a soma da área sob todas as parábolas do intervalo <math>\left[ x_{1} ; x_{n}\right]</math> :

:<math>S= \int_{x_1}^{x_n} f(x)dx \simeq \frac{h}{3}\left[f(x_1)+4f(x_2)+2f(x_3)+4f(x_4)+\ldots+4f(x_{n-1})+f(x_n)\right]</math>,

onde <math> h = (x_{n} - x_{1} )/N </math> .

A dedução da regra de Simpson pode ser encontrada por exemplo em [http://www.math.ist.utl.pt/~calves/courses/integra/capiii33.html].

== Programação ==
A seguir um trecho do programa para cálculo da integral da função f(x) (''external function f(x)'') 
entre a e b com N pontos, usando o método dos retângulos pela esquerda:

<pre>
...
Read*, a, b, N
dx = (b-a)/N; S=0

Do i = 0, N-1
x = a + i*dx
S = S + f(x)
EndDo
Print*, "Integral S=", S*dx
...
</pre>

Os outros métodos se programam de maneira similar mudando limites (índice do laço) 
e/ou tratando de forma diferente os valores das pontas.

== Erro associado ao método numérico ==

O método de integração numérico não retorna o valor exato de uma função, visto que não podemos ter no computador <math>N\to\infty</math>. O erro aqui discutido estará vinculado ao número de divisões <math>N</math> realizada na função <math>f(x)</math> dentro do intervalo que se quer saber o valor da integral. Assim, o erro é definido como

:<math>erro=\frac{Int(N)-Int(N-1)}{Int(N)}</math>,
onde <math>Int(N)</math> é o valor retornado pelo método numérico utilizado utilizando <math>N</math> divisões e <math>Int(N-1)</math> utilizando <math>N-1</math> divisões. Note que um teste simples para verificar quando a resposta está convergindo é aumentar <math>N</math> e calcular o erro a cada incremento no seu valor.