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

Julia

2024-08-24T14:31:32Z

Marcospasa: /* Modularizando códigos em Julia */

Julia é uma linguagem relativamente nova de programação que começou a ser desenvolvida em 2009 por Jeff Bezanson, Stefan Karpinski, Viral B. Shah, e Alan Edelman, um grupo do MIT. Ela foi oficialmente lançada para o mundo em 2012.

Em uma entrevista, quando perguntaram a Alan o por quê do nome Julia, ele disse que numa conversa anos atrás alguém sugeriu que Julia seria um bom nome para uma linguagem de programação.

Julia pode ser usada para propósitos gerais de programação, assim como Python, mas em sua criação foi visada a utilização de Julia para Cálculo Numérico.

== Aspectos Gerais ==

Julia é uma linguagem de alto nível, isso significa, de maneira sucinta, que ela não é executada utilizando somente o processador, assim como acontece com linguagens de baixo nível, como Assembly, por exemplo.

É escrita em C, C++, e Scheme, usando a estrutura do compilador LLVM (para melhor entendimento, o compilador de C é o GCC, por exemplo), enquanto a maior parte da biblioteca padrão de Julia é implementada na própria Julia.

Um fato importante sobre Julia para os programadores de Python é que todas as bibliotecas de Python são usáveis através de um comando simples: PyCall.

Um fato importante sobre Julia para os programadores de C é que Julia possui APIs (Interfaces de Programação de Aplicativos) especiais para chamada de funções em C diretamente.

== Velocidade ==

De acordo com testes feitos pelos próprios criadores de Julia, sua velocidade é similar com a de C.

<center>[[Arquivo:juliasvelocity.png|border]]
Fonte: [https://julialang.org/benchmarks/]
</center>

== Testes de Velocidade ==

A fim de pessoalmente testar a velocidade da linguagem de programação, foi escrito um programa em Julia de maneira similar ao programa de Python para o FTCS aplicado na Equação de Difusão (também conhecida como Equação do Calor).

A Equação da Difusão em uma dimensão pode ser escrita da forma:

<center><math>\frac{df}{dt}=\frac{d^{2}f}{dx^{2}}</math></center>

No método de FTCS (Forward-Time Central-Space) definimos a derivada em t na forma não simetrizada (forward) e as derivadas em x na forma simetrizada:

<center><math>\frac{df}{dt} = \frac{f(x, t+dt) - f(x,t)}{dt}</math></center>

<p>

<center><math>\frac{d^{2}f}{dx^{2}} = \frac{f(x+dx, t) + f(x-dx, t) - 2f(x,t)}{dx^{2}}</math></center>

E substuindo na equação da difusão, em notação discreta temos:

<center><math>f_{j}^{n+1} = f_{j}^{n} + D\frac{dt}{(dx)^{2}}[f_{j+1}^{n} + f_{j-1}^{n} - 2 f_{j}^{n}]</math></center>

'''Observação:''' esse procedimento funciona bem se <math>k=D\frac{dt}{(dx)^{2}} <= 1/2</math>, segundo análise de estabilidade do método.

Dessa forma, foi escrito um programa para integrar a Equação de Difusão através do método de FTCS nas linguagens Python e Julia.

Para '''Python''':
<pre>
# FTCS aplicado na equacao da difusao. Linguagem: PYTHON

import copy
import numpy as np
import matplotlib.pyplot as plt

def init():
L=50;D=1.;dt=0.05;dx=1.;t=0;tmax=100.
k=D*dt/(dx*dx)
return L,k,dt,t,tmax

L,k,dt,t,tmax = init()

x = np.arange(0,L,1)
f = np.zeros(x.shape)

a = int(L/3)
b = int(2*L/3)
f[a:b]=1.
f1 = copy.deepcopy(f)
f2 = copy.deepcopy(f)

while t<tmax:
t+=dt
f1[1:L-1]=f[1:L-1]+k*(f[0:L-2]+f[2:L]-2*f[1:L-1])
f1[L-1]=f[L-1]+k*(f[L-2]+f[0]-2*f[L-1])
f1[0]=f[0]+k*(f[1]+f[L-1]-2*f[0])
f=copy.deepcopy(f1)

sum0=sum(f1)
sum1=sum(f2)

print("Integral em t=0: %7.4f" % sum0)
print("Integral em tmax: %7.4f" % sum1)

plt.plot(x,f,x,f2)
plt.show()
</pre>

Em '''Julia''':
<pre>
# FTCS aplicado na equacao da difusao. Linguagem: JULIA

using PyPlot

L=50
D=1.
dt=0.05
dx=1.
t=0
tmax=100.
k=D*dt/(dx*dx)

x = collect(0:1:L-1)
f = zeros(L)
f1 = zeros(L)

a = trunc(Int, L/3)
b = trunc(Int, 2*L/3)

f[a+1:b] .= 1.
f2 = deepcopy(f)

while t<tmax
global t+=dt
f1[2:L-1] = f[2:L-1] + k*(f[1:L-2] + f[3:L] - 2*f[2:L-1])
f1[L] = f[L] + k*(f[L-1] + f[1] - 2*f[L])
f1[1] = f[1] + k*(f[2] + f[L] - 2*f[1])
global f = deepcopy(f1)
end

sum0 = sum(f1)
sum1 = sum(f2)

println("Integral em t=0: ", sum0)
println("Integral em tmax: ", sum1)

plt.plot(x,f,x,f2)
plt.show()
</pre>

Foi testado o tempo de execução da parte principal dos dois programas (isto é, sem fazer o gráfico dos resultados), através do timer do terminal, como mostra na próxima figura:

<center>[[Arquivo:Ftcs_time.png|border]]
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o método de FTCS aplicado à Equação de Difusão
</center>

É possível perceber, através da figura acima, que o tempo de execução de Python para o FTCS aplicado à Equação de Difusão é menor do que o de Julia. Em razão disso, foi testado um programa simples, como mostra abaixo, que incrementa uma variável 10 vezes, sendo o seu valor inicial 0.

<center>[[Arquivo:For.png|border]]
'''Legenda:''' Programa para incrementar o valor de uma variável, nesse caso ''i'', 10 vezes, escrito em Julia e em Python
</center>

E posteriormente, novamente, foi testado o tempo de execução da parte principal dos programas através do terminal:

<center>[[Arquivo:For_time.png|border]]
'''Legenda:''' Tempo de execução dos dois programas, em Julia e em Python, para o programa que incrementa o valor da variável 10 vezes
</center>

É possível perceber que para esse simples programa de incrementação, Python ainda obtém melhor performance do que Julia.

== Performance de Julia ==

Tentando entender o que traria tal performance em Cálculo Numérico para Julia, foi chegado à conclusão de que ser uma linguagem que se utilizada de ''variáveis dinâmicas'' e ''multi-métodos'' seria uma das grandes contribuições da linguagem.

'''Variáveis dinâmicas:'''

Em Python as variáveis são interpretadas em runtime, ou seja, '''tempo de execução''' => o programa checa toda hora se a variável mudou e isso torna ele mais lento

'''Variáveis estáticas:'''

Em C as variáveis são fixas, e isso é visto é em '''tempo de compilação''' => precisa pensar nas variáveis e isso torna o tempo de programação mais lento

Em Julia isso é basicamente opcional, não é preciso definir as variáveis, mas é possível, e elas podem mudar dinamicamente, em tempo de execução. E ainda, Julia se utiliza de multi-métodos para não ter que lidar com a constante checagem dos tipos das variáveis, como Python faz!

'''Despacho único:'''

Em geral, em linguagens de programação funções podem ter o mesmo nome, portanto deve existir algum mecanismo que irá realizar o despacho da
chamada de tais funções, resolvendo o conflito dos nomes iguais.

Na maioria das linguagens de programação populares (python, C++, javascript, C#), o despacho da chamada de funções ocorre apenas levando em consideração o primeiro argumento da mesma, tal mecanismo é chamado de '''despacho único'''. Como exemplo, vamos considerar o seguinte exemplo em python

<syntaxhighlight lang="python">
class MyClass1:
def some_function(self, a):
print("Value-1:", a)

class MyClass2:
def some_function(self, a):
print("Value-2:", a)

my_obj_1 = MyClass1()
my_obj_2 = MyClass2()
</syntaxhighlight>

Existem duas funções com o nome <code>some_function</code>, e obviamente tentar chamá-las dessa forma <code>some_function("some_text")</code> não funciona. A chamada correta é feita da seguinte forma:

* <code>my_obj_1.some_function("some_text")</code>: Executa a função em <code>MyClass1</code>.
* <code>my_obj_2.some_function("some_text")</code>: Executa a função em <code>MyClass2</code>

A sintaxe para chamar funções <code>my_obj.some_function(...)</code> é apenas o padrão adotado pelo python, mas ela é equivalente a <code>some_function(my_obj, ...) </code>, ou seja, quem determina qual função é de fato executada, é o primeiro argumento da chamada, os demais argumentos não são levados em consideração no momento do despacho.

'''Despacho múltiplo:'''

Em Julia, o despacho da execução de funções leva em consideração todos os seus argumentos, não apenas o primeiro, esse mecanismo leva o nome de '''despacho múltiplo'''. Para ilustrar o despacho múltiplo em ação, considere que estamos trabalhando em um código de dinâmica de partículas, e estamos precisando escrever uma função para calcular a energia potencial do sistema, que depende das massas, então podemos implementar a seguinte função

<syntaxhighlight lang="julia">
function potencial_energy(mass, positions, pars)
println("Calculando energia potencial")
end
</syntaxhighlight>

em que

* mass: Massas das partícula.
* positions: Posições das partículas.
* pars: Parâmetros do potencial em questão.

mas suponha que agora estamos interessados em explorar o sistemas quando todas as massas são iguais, e desejamos usar essa condição para melhorar o desempenho do cálculo da energia potencial. Poderíamos adicionar algumas estruturas condicionais dentro da função acima para isso, mas uma melhor forma é fazer com que a função <code>potencial_energy</code> despache no argumento <code>mass</code>, então, precisamos criar um tipo que represente massas iguais, que apenas vai possui um único atributo (a massa comum a todas as partículas) e um novo método para <code>potencial_energy</code> que despacha utilizando esse tipo:

<syntaxhighlight lang="julia">
struct SameMass
masss::Float64
end

function potencial_energy(mass::SameMass, positions, pars)
println("Calculando energia potencial com otimização para massas iguais")
end
</syntaxhighlight>

Esse novo método possui uma implementação otimizada para o caso em que todas as massas são iguais. Nada precisa mudar no código que chama <code>potencial_energy</code>, pois o despacho múltiplo vai fazer com que seja executado a implementação correta.

Agora suponha que estamos interessado em outro potencial (Potencial2), ao invés de criar uma nova função para Potencial2, vamos fazer com que <code>potencial_energy</code> despache no argumento <code>pars</code>

<syntaxhighlight lang="julia">
struct Potencial2
par1::Int
par2::Float64
end

function potencial_energy(mass, positions, pars::Potencial2)
println("Calculando energia potencial para Potencial2")
end
</syntaxhighlight>

Ainda, podemos fazer um método para Potencial2 que é otimizado para todas as massas iguais

<syntaxhighlight lang="julia">
function potencial_energy(mass::SameMass, positions, pars::Potencial2)
println(""Calculando energia potencial com otimização para massas iguais para Potencial2")
end
</syntaxhighlight>

Agora que estamos trabalhando com dois potencias, é inteligente também criar um tipo para o primeiro potencial, que vamos chamar de Potencial1:

<syntaxhighlight lang="julia">
struct Potencial1
par1::Float64
par2::Float64
end
</syntaxhighlight>

O seguinte exemplo utiliza os métodos que criamos

<syntaxhighlight lang="julia">
positions = [] # Suponha que as posições das partículas estejam aqui

pars_1 = Potencial1(3.14, 2.71)
pars_2 = Potencial2(137, 3.48)

mass = [] # Suponha que as diferentes massas das partículas estejam aqui
same_mass = SameMass(1)

potencial_energy(mass, positions, pars_1)
potencial_energy(mass, positions, pars_2)
potencial_energy(same_mass, positions, pars_1)
potencial_energy(same_mass, positions, pars_2)
</syntaxhighlight>

executando, temos a seguinte saída:

Calculando energia potencial
Calculando energia potencial para Potencial2
Calculando energia potencial com otimização para massas iguais
Calculando energia potencial com otimização para massas iguais para Potencial2

== Performance de Julia: na prática ==
Para resumir, temos:

Python => dynamic (variáveis dinâmicas) single dispatch (métodos únicos)

C++ => static (variáveis estáticas) single dispatch

Julia => dynamic multiple dispatch

Na prática, é mostrado abaixo um exemplo da performance de Julia como linguagem de programação em dynamic multiple dispatch.

O mesmo programa foi escrito em Julia e em C++.

Em '''Julia''':

<pre>
abstract type Animal end

struct Cachorro <: Animal
nome::String
end

struct Gato <: Animal
nome::String
end

# Função de encontro que recebe tipo genérico de animal
function encontroDeAnimais(a::Animal, b::Animal)
acao = encontro(a,b)
println("$(a.nome) encontra $(b.nome) e $acao")
end

# Funções de expressão única que recebem diferentes tipos de animais
encontro(a::Cachorro, b::Cachorro) = "cheira"
encontro(a::Cachorro, b::Gato) = "persegue"
encontro(a::Gato, b::Gato) = "lambe"
encontro(a::Gato, b::Cachorro) = "ignora"

# Instanciando os bichinhos
gato1 = Gato("Luciene Maria")
gato2 = Gato("Mel")
cachorro1 = Cachorro("Batata")
cachorro2 = Cachorro("Snoopy")

# Chamando função encontroDeAnimais
encontroDeAnimais(gato1, gato2)
encontroDeAnimais(gato1, cachorro2)
encontroDeAnimais(cachorro1, cachorro2)
</pre>

Em '''C++''':

<pre>
#include <iostream>
using namespace std;

class Animal {
public:
string nome;
};

string encontro(Animal a, Animal b) {}

// Função de encontro que recebe tipo genérico de animal
void encontroDeAnimais(Animal a, Animal b) {
string acao = encontro(a,b);
cout << a.nome << " encontra " << b.nome << " e " << acao << endl;
}

class Cachorro:public Animal {};
class Gato:public Animal {};

// Funções de expressão única que recebem diferentes tipos de animais
string encontro(Cachorro a, Cachorro b) { return "cheira"; }
string encontro(Cachorro a, Gato b) { return "persegue"; }
string encontro(Gato a, Gato b) { return "lambe"; }
string encontro(Gato a, Cachorro b) { return "ignora"; }

int main() {
// Instanciando os bichinhos
Gato gato1; gato1.nome = "Luciene Maria";
Gato gato2; gato2.nome = "Mel";
Cachorro cachorro1; cachorro1.nome = "Batata";
Cachorro cachorro2; cachorro2.nome = "Snoopy";

// Chamando função encontroDeAnimais
encontroDeAnimais(gato1, gato2);
encontroDeAnimais(gato1, cachorro2);
encontroDeAnimais(cachorro1, cachorro2);

return 0;
}
</pre>

Para '''Julia''' nós obtemos o seguinte '''resultado''':

<pre>
Luciene Maria encontra Mel e lambe
Luciene Maria encontra Snoopy e ignora
Batata encontra Snoopy e cheira
</pre>

Para '''C++''' o '''resultado''' é:

<pre>
Luciene Maria encontra Mel e
Falha de Segmentação
</pre>

Isso acontece porque C++ não aceita que uma função utilize-se de uma variável sem antes saber qual o tipo dessa variável! Por isso, poder utilizar-se de variáveis dinâmicas quando há multi-métodos é um diferencial que acaba por incrementar a performance de Julia como linguagem de programação visada para o Cálculo Numérico.

'''Observação:''' é importante ressaltar que os testes feitos não são conclusivos para debater a performance de Julia, em termos estatísticos, e além disso, ser uma linguagem de programação que utiliza de variáveis dinâmicas e multi-métodos não é o único motivo pelo qual Julia poderia trazer tal performance em Cálculo Numérico. Podemos ainda contar com a sua capacidade de '''metaprogramação''', ou seja, Julia pode usar macros e eles são aplicados em tempo de interpretação. Há ainda outros fatores da construção da linguagem que contribuem para sua performance que aqui não foram citados.

== Aprendendo Julia ==

'''Ambiente de programação'''

Após feita a instalação de Julia, para abri-la no seu terminal de comando é preciso apenas digitar: <pre>$julia</pre> para entrar em seu ambiente de programação.

É possível, também, programar em um arquivo de texto (salvo como .jl) e executar o programa pelo terminal, fazendo simplesmente:

<pre>
$julia programa.jl
</pre>

'''Impressão na tela'''
<pre>
println("Hello World")

Saída:
Hello World
</pre>

'''Variáveis'''

Variáveis são atribuídas dinamicamente e podem mudar.
<pre>
s = 1
s = "Oi"
println(s)
println(typeof(s))

Saída:
Oi
String
</pre>

<pre>
s::String
s = 1
println(s)

Saída:
TypeError: in typeassert, expected String, got Int32
</pre>

'''Condicionais'''
<pre>
cats = 12
if cats < 1
println("You should adopt a cat.")
elseif cats >= 1 && cats <=6
println("Not enough cats.")
elseif cats >= 7 && cats <= 12
println("Still not enough cats.")
else
println("Gato have more cats.")
end

Saída:
Still not enough cats.
</pre>

<pre>
i = 0
while (i < 10)
global i += 1
println(i)
end

Saída:
1
2
3
4
5
6
7
8
9
10
</pre>

<pre>
for i = 1:10
println(i)
end

Saída:
1
2
3
4
5
6
7
8
9
10
</pre>

<pre>
for i in [1,2,3]
println(i)
end

Saída:
1
2
3
</pre>

'''Arrays'''
<pre>
# Criando um array de zeros
a1 = zeros()
println(a1)
# Posso definir o tipo e o tamanho do Array (linhas, colunas) também
a1 = zeros(Int32, 1, 4)
println(a1)

Saída:
0.0
[0 0 0 0]
</pre>

<pre>
# Criando um array do tipo inteiro
a2 = Array{Int32}
println(a2)
# Criando um array (de outra maneira) do tipo float
a3 = Float64[]
println(a3)

Saída:
Array{Int32,N} where N [...]
Float64[]
</pre>

<pre>
# Criando um array e definindo valores
a4 = [1,2,3]
#Imprimindo a4
println("Array: ", a4)

Saída:
Array: [1, 2, 3]
</pre>

<pre>
a4 = [1,2,3]
# Imprimindo valor de um indíce específico
println("Imprimindo primeiro elemento: ", a4[1])
# Imprimindo último valor do array
println("Imprimindo último elemento: ",a4[end])

Saída:
Imprimindo primeiro elemento: 1
Imprimindo último elemento: 3
</pre>

<pre>
a4 = [1,2,3]
println(a4[2])
# Valores podem mudar (diferente de Tuplas, que veremos adiante)
a4[2] = 4
println(a4[2])

Saída:
2
4
</pre>

<pre>
a4 = [1,2,3]
println(a4)
# Número de elementos
println("Imprimindo número de elementos: ",length(a4))

Saída:
[1, 2, 3]
Imprimindo número de elementos: 3
</pre>

<pre>
a4 = [1,2,3]
# Soma os valores do array
println("Imprimindo soma dos elementos: ",sum(a4))
# Põe os valores começando no índice 2
splice!(a4, 2:1, [8,9])
println("Imprimindo Array tendo feito splice!(a4, 2:1, [8,9]): ",a4)
# Remove os itens do índice 2 ao 3
4splice!(a4, 2:3)
println("Imprimindo Array tendo feito splice!(a4, 2:3): ",a4)

Saída:
Imprimindo soma dos elementos: 6
Imprimindo Array tendo feito splice!(a4, 2:1, [8,9]): [1, 8, 9, 2, 3]
Imprimindo Array tendo feito splice!(a4, 2:3): [1, 2, 3]
</pre>

<pre>
a4 = [1,2,3]
# Pegar valor máximo e valor mínimo
println("Imprimindo valor máximo: ",maximum(a4))
println("Imprimindo Array valor mínimo: ",minimum(a4))
# Multiplicando todos os elementos do array por outro número sem precisar de um for
println("Imprimindo multiplicação dos elementos por 2: ",a4 * 2)

Saída:
Imprimindo valor máximo: 3
Imprimindo Array valor mínimo: 1
Imprimindo multiplicação dos elementos por 2: [2, 4, 6]
</pre>

<pre>
# Arrays podem conter funções
a5 = [sin, cos, tan]
for n in a5
println(n(0))
end

Saída:
0.0
1.0
0.0
</pre>

<pre>
# Para os acostumados com range
a6 = collect(1:5)
println(a6)

Saída:
[1, 2, 3, 4, 5]
</pre>

'''Tuplas'''

A maioria das funções de array funciona com tuplas.
<pre>
# Valores não podem mudar
t1 = (1,2,3,4)
println(t1[2])
t1[2] = 5
println(t1[2])

Saída:
2
MethodError: no method matching setindex!(::NTuple{4,Int32}, ::Int32, ::Int32)
</pre>

<pre>
# Imprimindo a tupla inteira
println(t1)
# Imprimindo a tupla inteira
for i in t1
println(i)
end

Saída:
(1, 2, 3, 4)
1
2
3
4
</pre>

'''Dicionários'''

A palavra-chave deve ser única.
<pre>
d1 = Dict("pi"=>3.14, "e"=>2.718)
# Imprimir um valor
println(d1["pi"])

Saída:
3.14
</pre>

<pre>
d1 = Dict("pi"=>3.14, "e"=>2.718)
# Imprimindo todas as palavras-chaves
println(keys(d1))
# Imprimindo todos os valores
println(values(d1))
# Adicionar uma palavra-chave
d1["golden"] = 1.618
# Deleter uma palavra-chave
delete!(d1, "pi")
# Imprimindo todas as palavras-chaves
println(keys(d1))
# Imprimindo todos os valores
println(values(d1))

Saída:
["pi", "e"]
[3.14, 2.718]
["e", "golden"]
[2.718, 1.618]
</pre>

<pre>
d1 = Dict("pi"=>3.14, "e"=>2.718)
# Ver se a palavra-chave existe
println(haskey(d1, "pi"))
# Imprimindo palavras-chaves E valores
for kv in d1
println(kv)
end

Saída:
true
"pi" => 3.14
"e" => 2.718
</pre>

'''Sets'''

Sets são arrays com elementos únicos.
<pre>
st1 = Set(["Jim", "Pam", "Jim"])
# Ele não pega os elementos repetidos
println(st1)

Saída:
Set(["Pam", "Jim"])
</pre>

<pre>
st1 = Set(["Jim", "Pam", "Jim"])
# Adicionando um elemento
push!(st1, "Michael")
println(st1)
# Ver se um elemento está no Set
println(in("Dwight", st1))

Saída:
Set(["Pam", "Michael", "Jim"])
false
</pre>

<pre>
st1 = Set(["Jim", "Pam", "Jim"])
st2 = Set(["Stanley", "Meredith"])
# Combinando Sets
println(union(st1, st2))
# Imprimindo todo o elemento que os dois Sets tem em comum
println(intersect(st1, st2))
# Imprimindo elementos que estão no primeiro Set, mas não no segundo
println(setdiff(st1, st2))

Saída:
Set(["Jim", "Meredith", "Stanley", "Pam"])
Set(String[])
Set(["Pam", "Jim"])
</pre>

'''Funções'''
<pre>
using Printf
# Função de expressão única
soma(x,y) = x + y
x, y = 1, 2
@printf("%d + %d = %d\n", x, y, x+y)

Saída:
1 + 2 = 3
</pre>

<pre>
# Função de múltiplas expressões
function adoptACat(cats)
if cats <= 1
println("You should adopt a cat.")
else
println("You should adopt a cat. They're cute.")
end
end
adoptACat(2)

Saída:
You should adopt a cat. They're cute.
</pre>

<pre>
v1 = 5
function changeV1(v1)
v1 = 10
end
changeV1(v1)
println(v1)

Saída:
5
</pre>

<pre>
v1 = 5
function changeV1(v1)
v1 = 10
return v1
end
changeV1(v1)
println(v1)
v2 = changeV1(v1)
println(v2)

Saída:
5
10
</pre>

<pre>
# Usando variáveis globais dentro da função
v1 = 5
function changeV12()
global v1 = 10
end
changeV12()
println(v1)

Saída:
10
</pre>

<pre>
# Quando não sei quantos argumentos vou passar
function soma(args...)
sum = 0
for i in args
sum += i
end
println(sum)
end
soma(1,2,3)

Saída:
6
</pre>

<pre>
# Retornando mais de um valor
function retorna2(valor)
return (valor + 1, valor + 2)
end
println(retorna2(4))

Saída:
(5, 6)
</pre>

<pre>
# Map é uma função anônima que aplica uma função para cada elemento
v = map(x -> x * x, [1,2,3])
println(v)

Saída:
[1, 4, 9]
</pre>

'''Structs'''
<pre>
struct Estudante
name::String
saldoTRI::Float32
cartaoUFRGS::Int
end
# Criando um objeto
estudante1 = Estudante("Raquel", 10.50, 244449)
println(estudante1.name, "\n", estudante1.saldoTRI, "\n", estudante1.cartaoUFRGS)

Saída:
Raquel
10.5
244449
</pre>

'''Tipos Abstratos'''

Tipos abstratos não podem ser instanciados como as Structs (instanciar => fazer estudante1 =
Estudante(“Raquel”, 10.50, 244449) => criar um objeto) MAS podem ter subTipos e isso é muito
útil!

<pre>
abstract type animal end
struct cachorro <: animal
nome::String
latido::String
end
struct gato <: animal
nome::String
miado::String
end
cachorro1 = cachorro("Urso", "Au Au")
gato1 = gato("Lucia Irene", "Miau")
# Criando funções pros subTipos
function fazerSom(animal::cachorro)
println("$(animal.nome) diz $(animal.latido)")
end
function fazerSom(animal::gato)
println("$(animal.nome) diz $(animal.miado)")
end
fazerSom(cachorro1)
fazerSom(gato1)

Saída:
Urso diz Au Au
Lucia Irene diz Miau
</pre>

== Modularizando códigos em Julia ==

== Módulos ==
Na Julia é possível agrupar pedaços de códigos em módulos, cuja função é puramente de organização. Módulos são definidos pela palavra-chave `module` e eles introduzem um novo escopo, por exemplo:

<syntaxhighlight lang="julia">
module MyModule
struct SomeStruct
some_attr::Float64
end

function sum(a ,b)
println(a + b)
end

function product(a ,b)
println(a * b)
end
end
</syntaxhighlight>

Para acessar o conteúdo dos módulos fora deles, é necessário qualificar o nome do item de interesse, por exemplo, podemos utilizar a função `sum` da seguinte forma:

<syntaxhighlight lang="julia">
module MyModule
...
end

function main()
MyModule.sum(1, 3)
end
main()
</syntaxhighlight>

Em python, cada arquivo <code>.py</code> é um módulo, em Julia não existe esse conceito, um arquivo <code>.jl</code> pode conter diversos módulos e um módulo pode estar espalhado em diversos arquivos.

* Mais informações sobre módulos podem ser encontradas no [https://docs.julialang.org/en/v1/manual/modules/#modules manual da Julia]

== Separando o código em arquivos ==
A Julia não possui o conceito de código em diferentes arquivos, assim como é no python por exemplo (cada arquivo é um módulo), mas podemos, apenas por questão de conveniência, separar o código em diferentes arquivos, no entanto um deles vai ser o arquivo principal, e seu dever e incluir todos os outros arquivos utilizando o comando `include`.

== Criando pacotes ==
Vamos criar um pacote que pode ser utilizado em qualquer lugar em sua máquina (utilizando <code>using MyPkgName</code>), para isso navegue para o local em que se deseja color os arquivos do pacote, abra um REPL e execute

<syntaxhighlight lang="julia">
using PkgTemplate
t = Template(dir=".")
t("MyPkg")
</syntaxhighlight>

Isto irá automaticamente criar uma pasta contendo os arquivos do pacote na localização atual. Para podermos utilizá-lo em qualquer lugar, precisamos adicioná-lo no ambiente atual, que pode ser feito da seguinte forma:
* Utilizando o mesmo REPL que foi utilizado para criar o pacote, entre no modo de gerenciamento de pacotes (aparte ] com a entrada do REPL vazia)
* Execute o comanndo
:<syntaxhighlight lang="julia">
pkg> activate MyPkg
</syntaxhighlight>

a partir de agora, qualquer arquivo pode utilizar

<syntaxhighlight lang="julia">
using MyPkg
</syntaxhighlight>

* Para mais informações sobre como gerenciar/criar pacotes em julia, [https://pkgdocs.julialang.org/v1/#**1.**-Introduction clique aqui].
* Para mais informações sobre como criar pacotes com o PkgTemplate, [https://juliaci.github.io/PkgTemplates.jl/stable/user/#PkgTemplates-User-Guide clique aqui].

Julia

2024-08-24T14:08:12Z

Marcospasa:

Página principal

2024-08-24T11:56:50Z

Marcospasa: /* Ensino */

''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]]

* [[Ecologia]]

* [[Econofísica]]

* [[Epidemias]]

* [[Laboratório de Estruturas Celulares]]

* [[Teoria de Redes e Crime]]

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

[[Conferencias]]

== 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]]===

===[[Monte Carlo]]===

===[[FIS01183 - Física III-C]]===

===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]
-->

Página principal

2024-08-24T11:53:07Z

Marcospasa: /* Ensino */

''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]]

* [[Ecologia]]

* [[Econofísica]]

* [[Epidemias]]

* [[Laboratório de Estruturas Celulares]]

* [[Teoria de Redes e Crime]]

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

[[Conferencias]]

== 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]]===

===[[Monte Carlo]]===

===[[FIS01183 - Física III-C]]===

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

* [[Ondas]]

* [[Raio X]]

===[[Applets]]===

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

===[[Julia]]===

==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]
-->

Pêndulos Estocásticos

2024-08-21T02:20:20Z

Marcospasa: /* Pêndulo invertido */

'''Grupo :''' Gustavo H. Guesser, Joshua L. Kipper, Marcos Pasa.

== Pêndulo Simples ==
===Equação de movimento===
Primeiramente vamos inserir ruído em um pêndulo simples, que é constituído de uma barra de comprimento <math>l</math>, sem massa e rígida que contém uma massa <math>m</math> pontual em sua ponta, conforme ilustrado na figura a seguir.

<center>
[[Arquivo:Pendulo_simples.png|thumb|upright=2|center|Esquema de um pêndulo simples em um campo gravitacional constante.]]
</center>

Considerando que o pêndulo está sob o efeito da gravidade e se encontra submerso em um fluido viscoso (como o ar), tal que a força de resistência que atua na massa é <math>-2b\vec v</math>, a equação de movimento é dada por:

<center>
<math>
\ddot \theta(t) = -\frac{2b}{m}\dot \theta - \frac{g}{l}sen(\theta) </math>
</center>

Vamos supor que existe uma força ruidosa atuando em <math>m</math>, tal que sua componente tangencial (<math>F_{r}(t)</math>) pode ser modelada por um ruído branco gaussiano <math>\xi(t)</math> da seguinte forma

<center>
<math>
F_r(t) = m \alpha \xi(t)
</math>
</center>

em que <math>\alpha</math> é a intensidade do ruído. <math>\xi(t)</math> é caracterizado pelas seguintes propriedades:

<center>
<math>
\langle \xi(t) \rangle = 0,~~ \langle \xi(t_2)\xi(t_1) \rangle = \delta(t_2 -t_1)
</math>
</center>

Adicionando essa nova força nas equações de movimento, ficamos com

<center>
<math>
\ddot \theta(t) = -\frac{2b}{m}\dot \theta - \frac{g}{l}sen(\theta) + \frac{\alpha}{l}\xi(t) </math>
</center>

A partir de agora, por questão de simplicidade, vamos supor que <math>g = l = 1 </math>, então

<center>
<math>
\ddot \theta(t) = -2b\dot \theta - sen(\theta) + \alpha\xi(t) </math>
</center>

===Método de integração===
Vamos montar um métodos para integrar o sistema no tempo. Primeiramente vamos dividir a equação em duas equações diferencias de primeira ordem, introduzindo a variável <math>\omega := \dot \theta </math>, então ficamos com o seguinte sistema

<center>
<math>
\begin{aligned}
\dot \theta &= \omega \\
\dot \omega &= -2b \omega - sen(\theta) + \alpha\xi(t)
\end{aligned}
</math>
</center>

que pode ser escrito na forma diferencial

<center>
<math>
\begin{aligned}
d\theta &= \omega dt \\
d\omega &= (-2b \omega - sen(\theta))dt + \alpha\xi(t)dt
\end{aligned}
</math>
</center>

mas <math>\xi(t)dt</math> é o incremento do processo de Wiener (<math>W(t) = \int_0^t \xi(t')dt' </math>), então

<center>
<math>
\begin{aligned}
d\theta &= \omega dt \\
d\omega &= (-2b\omega - sen(\theta))dt + \alpha dW(t)
\end{aligned}
</math>
</center>

Discretizando o tempo e lembrando que a densidade de probabilidade de transição de <math>W(t)</math> para <math>W(t+\Delta t)</math> tem desvio padrão igual a <math>\sqrt{\Delta t}</math>

<center>
<math>
\begin{aligned}
\theta_{j+1} &= \theta_{j} + \omega_j \Delta t \\
\omega_{j+1} &= \omega_{j} + (-2b \omega_j - sen(\theta_j))\Delta t + \alpha {R_G}_j \sqrt{\Delta t}
\end{aligned}
</math>
</center>

em que <math>R_G</math> é uma amostra de uma distribuição gaussiana com média 0 e variância 1, e o método de Euler foi utilizado para a parte determinística da equação.

Nas próximas seções será analisado a energia do sistema, e como o método de Euler não é muito bom para preservar a energia de sistemas conservativos, será utilizado o método preditor corretor (com adição do método de Heun para <math> \theta </math>) para a parte determinística da equação, que consiste nos seguintes passos:

* Calcular um theta intermediário:
<math> \theta^{(2)}_{j+1} = \theta_j + \omega_j \Delta t </math>

* Com <math> \theta^{(2)}_{j+1} </math> calcular um theta médio e utilizá-lo para obter um omega intermediário:
<math>
\begin{aligned}
\bar \theta_j &= \frac{\theta^{(2)}_{j+1} + \theta_j}{2} \\
\omega^{(2)}_{j+1} &= \omega_j + f(\bar \theta_j, \omega_j, {R_G}_j)
\end{aligned}
</math>
:Em que <math>f</math> é a expressão do método de Euler visto logo acima.

* Recalcular theta utilizando um omega intermediário
<math> \begin{aligned}
\bar \omega_j &= \frac{\omega^{(2)}_{j+1} + \omega_j}{2} \\
\theta_{j+1} &= \theta_j + \bar \omega_j \Delta t
\end{aligned} </math>

* Recalcular omega com um theta intermediário atualizado
<math>
\begin{aligned}
\bar \theta^{(2)}_j &= \frac{\theta_{j+1} + \theta_j}{2} \\
\omega_{j+1} &= \omega_j + f(\bar \theta^{(2)}_j, \bar \omega_j, {R_G}_j)
\end{aligned}
</math>
:OBS: No cálculo de <math>\omega^{(2)}_{j+1}</math> e <math>\omega_{j+1}</math> foi utilizado o mesmo <math>{R_G}_j</math>.

===Energia (Sem amortecimento)===
Logo após terminar a implementação do método numérico, rapidamente notamos que a adição do ruído aumento a energia mecânica do pêndulo (<math>E</math>), vamos explorar esse fenômeno, sempre utilizando <math>\beta = 0</math>. Para ilustrar esse efeito, segue uma animação do pêndulo partindo do repouso na configuração de equilíbrio estável (<math>\theta(0) = 0,~ \omega(0)=0</math>) com <math>\alpha = 0.1</math>

[[Arquivo:Energy_demo.gif|frame|center|Pêndulo partindo do repouso com ruído.]]

Para realizar uma exploração quantitativa, o seguinte procedimento foi feito para vários valores de <math> \alpha </math>:
* Utilizando <math>\Delta t = 0.01</math>, integrar o sistema até <math>t_f = 100</math>, calculando e armazenando a energia em cada passo temporal. Repetir essa integração 700 vezes para fazer médias temporais. Como exemplo, segue os dados obtidos da energia em função do tempo (com a média temporal feita) para um determinado <math> \alpha </math> utilizado

<center>
[[Arquivo:Energy_example.png|thumb|upright=2|center|Energia média em função tempo.]]
</center>

:O gráfico nos indica que o ruído gera uma potência média sobre o pêndulo.

* Realizar um ajuste linear nos dados <math>\langle E \rangle_t \times t</math> para obter o coeficiente angular, que corresponde a potência média gerada pelo ruído (<math>\bar P</math>).

Com as simulações executadas, foi realizado o gráfico <math>\bar P \times \alpha</math>. Notamos que os dados se alinham em linha reta com os eixos em escala logarítmica, ou seja, os mesmos seguem uma lei de potência <math>\bar P = ae^{b \alpha}</math>), então foi realizado outro ajuste linear para encontra o expoente <math>b</math>, a figura a seguir ilustra os dados e os resultados do ajuste:

[[Arquivo:Power.png|frame|center|Potência em função do ruído (<math>\alpha</math>). O painel da esquerda possui eixos em escala linear e o da direita em escala logarítmica.]]

Portanto, <math>\bar P</math> aumenta, aproximadamente, de forma quadrática com <math>\alpha</math>. Por fim, gostaríamos de mostrar que mesmo para <math> \alpha</math> muito pequeno, ainda existe energia sendo injetada no sistema com taxa constante, e isso não é um artefato da simulação. Para tal, foram realizadas 700 simulações com <math>\alpha=5\cdot10^{-4}</math> e os resultados foram comparados com <math> \alpha = 0</math>

[[Arquivo:Test_low_alpha.png|frame|center|Energia média para <math>\alpha</math> muito pequeno comparado com <math>\alpha</math> nulo.]]

===Energia (Com amortecimento)===
Até o momento, o amortecimento foi negligenciado. Vamos, então, introduzi-lo e rodar várias simulações (700, neste caso) e observar como a média temporal da energia evolui ao longo do tempo, assim como foi feita na seção anterior. Utilizando <math>\beta =0.1</math> e <math>\alpha = 0.485</math> foi obtido o seguinte resultado

[[Arquivo:Energy_beta_example.png|frame|center|Energia mecânica média em função do tempo com amortecimento.]]

claramente o comportamento neste caso é diferente do observado sem amortecimento, agora a anergia aumenta até um certo valor e permanecenele. Para explorar este novo fenômeno, os seguintes passos foram feitos para cada valor de <math>\beta = 0.01, 0.1, 0.2 </math>:

* Para diversos valores de <math>\alpha</math>, executar 700 simulações até a energia estabilizar, salvando a média da energia entre as simulações.
* Para cada conjunto de dados gerados por um determinado <math>\alpha</math>, selecionar um intervalo de tempo onde a energia está estabilizada e calcular a sua média (<math>\langle E \rangle</math>).

Produzindo o gráfico de <math>\langle E \rangle \times \alpha</math> obtemos

[[Arquivo:Power_beta_mosaic.png|frame|center|Energia estabilizada média em função de <math>\alpha</math> para diferentes valores de amortecimento. Os painéis da esquerda possui eixos em escala linear e os da direita em escala logarítmica.]]

as linhas vermelhas são os melhores ajustas de leis de potência na forma <math>\langle E \rangle = a \alpha^b </math>. Para <math>\beta=0.1</math> os dados utilizados no ajuste foram apenas até <math>\alpha = 0.6</math> (indicado pela reta preta vertical no gráfico), pois após esse limite, a lei de potência deixa de ser um ótimo ajuste. É chamativo o fato de todos os coeficientes, independente de <math>\beta</math>, serem aproximadamente 2.

== Pêndulo invertido ==
O próximo pêndulo a ser considerado é um pêndulo invertido, que possui um potencial harmônico em seu ângulo, ou seja, um dos termos de sua energia potential é <math>\frac{k}{2}\theta^2 </math>, sendo que agora <math>\theta</math> é zero quando a haste está apontando para cima, conforme ilustrado na figura a seguir

<center>
[[Arquivo:Pendulo_invertido.png|thumb|upright=2|center|Esquema do pêndulo invertido com movimento vertical livre na base.]]
</center>

Ainda, a base do pêndulo é livre para movimentar-se na direção vertical, é justamente nesse local onde será adicionado uma força ruidosa. A equação de movimento neste caso é

<center> <math>
\ddot \theta = \frac{-2b}{m}\dot \theta + \frac{1}{l}(g + \ddot u)sen(\theta) - \frac{k}{m}\theta
</math> </center>

O primeiro termo vem da resistência do ar, o segunda se origina da gravidade e do deslocamento de <math>u</math> e o último provém da "mola" em <math>\theta </math>. Vamos supor que existe um vínculo mantendo a base fixa, mas o local onda o pêndulo é fixado pode ser movimentar de forma aleatória na direção vertical, suponde que tal movimento pode ser modelado por ruído branco gaussiano, segue que <math>\ddot u(t) = \alpha \xi(t)</math>. Introduzindo a variável <math>\omega := \dot \theta</math>, ficamos com o seguinte sistemas de equações na forma diferencial

<center> <math>
\begin{aligned}
d\theta &= \omega dt \\
d\omega &= (\frac{-2b}{m}\omega + \frac{g}{l}sen(\theta) - \frac{k}{m}\theta )dt + sen(\theta) \frac{\alpha}{l}\overbrace{dW(t)}^{\xi(t)dt}
\end{aligned}
</math> </center>

Note que agora o ruído é multiplicativo, em contraste com o ruído aditivo dos pêndulos anteriores, para lidar com esta complicação, no momento da integração vamos utilizar um <math>\theta</math> médio no argumento do seno que multiplica <math>dW</math>

<center> <math>
\begin{aligned}
\theta_{j+1} &= \theta_j + \omega_j \Delta t \\
\bar \theta_j &= (\theta_{j+1} + \theta_{j} ) / 2 \\
\omega_{j+1} &= \omega_j + (\frac{-2b}{m}\omega_j + \frac{g}{l}sen(\bar \theta_j) - \frac{k}{m} \bar \theta_j ) \Delta t + sen(\bar \theta_j) \frac{\alpha}{l} {R_G}_j \sqrt{\Delta t}
\end{aligned}
</math> </center>

Esse tipo de pêndulo é de grande interesse em algumas áreas, como na engenharia estrutural, pois uma coluna comprimida pode ser modelada como um pêndulo invertido com uma mola na base, o ruído da base pode representar um terremoto.

Uma questão interessante neste modelo é sobre a estabilidade da configuração <math>\theta_0 = \omega_0 = 0 </math> quando é adicionado ruído e amortecimento. Se <math>k</math> é grande o suficiente, sem ruído, o equilíbrio é estável, mas é possível sair dessa configuração adicionando ruído, cujo valor limite vai depender do amortecimento. Podemos demostrar isso integrando o sistema, partindo da condição inicial <math>\theta_0 = 10^{-4}, \omega_0 = 0 </math>, com valores de <math>\alpha</math> muito próximos:

[[Arquivo:Inverted_no_exploded.png|upright=2|left|Esquema do pêndulo invertido com movimento vertical livre na base.]] [[Arquivo:Inverted_exploded.png|upright=2|right|Esquema do pêndulo invertido com movimento vertical livre na base.]]

os seguintes valores foram utilzados

* g = l = 1
* k = 1.1

No gráfico da esquerda, o ângulo oscilou um pouco e permaneceu em 0, já no outro, eventualmente, o ângulo explodiu. Abaixo segue uma animação dessa situação, mas com <math>\alpha=1</math> para o pêndulo sair do equilíbrio mais rápido

[[Arquivo:Inverted_going_crazy.gif|frame|center|Pêndulo invertido partindo do equilíbrio com ruído.]]

Arquivo:Inverted going crazy.gif

2024-08-21T02:16:33Z

Marcospasa:

Pêndulos Estocásticos

2024-08-20T02:47:20Z

2024-08-17T11:25:38Z

Marcospasa: Criou página com ''''Grupo :''' Gustavo H. Guesser, Joshua L. Kipper, Marcos Pasa. == Pêndulo Simples == Primeiramente vamos inserir ruído em um pêndulo simples, que é constituído de uma barra de comprimento <math>l</math>, sem massa e rígida que contém uma massa <math>m</math> pontual em sua ponta, conforme ilustrado na figura a seguir. <center> Esquema de um pêndulos simples em um campo gravitacional constante. </center>...'

'''Grupo :''' Gustavo H. Guesser, Joshua L. Kipper, Marcos Pasa.

== Pêndulo Simples ==
Primeiramente vamos inserir ruído em um pêndulo simples, que é constituído de uma barra de comprimento <math>l</math>, sem massa e rígida que contém uma massa <math>m</math> pontual em sua ponta, conforme ilustrado na figura a seguir.

<center>
[[Arquivo:Pendulo_simples.png|thumb|upright=2|center|Esquema de um pêndulos simples em um campo gravitacional constante.]]
</center>

Considerando que a força de resistência que atua na massa é <math>-2bl\dot \theta </math>
A equação de movimente para esse pêndulo é:

<center>
<math>
\theta(t) = -\frac{2b}{m}\dot \theta - \frac{g}{l}sen(\theta) </math>
</center>

Arquivo:Pendulo simples.png

2024-08-15T18:05:10Z

Marcospasa:

Trabalhos 2024/1

2024-08-15T17:50:01Z

Marcospasa:

== [[Pêndulos Estocásticos]] ==

== [[Corda Vibrante]] ==

== [[Equação de Ginzburg-Landau complexa]] ==

== [[Equação de Dirac]] ==

== [[Equação de Schrödinger Unidimensional]] ==

== [[Equação de Liouville-Bratu-Gelfand]] ==

Corda Vibrante

2024-04-24T13:40:19Z

2024-04-20T19:27:24Z

Marcospasa:

Arquivo:La power ana julia.png

2024-04-20T19:01:51Z

Marcospasa: