Abra a imagem SVG em separado aqui.
Arquivo da categoria: Aulas
Física A – EARTE – Semanas 11 até 13
Semana 11 – Aula Síncrona 1 – Terça Feira dia 17 de Novembro, 19h. A aula será realizada a Avaliação A3. Temas compreendidos entre colisões e sistemas contrínuos de partículas.
Semana 11 – Aula Síncrona 2 – Quinta Feira dia 19 de Novembro, 19h; A aula será realizada pelo aplicativo Skype. O link será enviado para o email dos alunos usando o Google Classroom, aproximadamente 30 min antes da aula.
Tema da aula: Trataremos da estática de corpos rígidos, com destaque para alavancas. Trata-se de um conteúdo simples mas achei prudente dar destaque a ele pela sua pegada conceitual forte.
Semana 12 – Aula Síncrona 1 – Terça Feira dia 24 de Novembro, 19h; A aula será realizada pelo aplicativo Skype. O link será enviado para o email dos alunos usando o Google Classroom, aproximadamente 30 min antes da aula.
Tema da aula: Trataremos da cinemática de rotacional.
Semana 12 – Aula Síncrona 2 – Quinta Feira dia 26 de Novembro, 19h; A aula será realizada pelo aplicativo Skype. O link será enviado para o email dos alunos usando o Google Classroom, aproximadamente 30 min antes da aula.
Tema da aula: Trataremos de dinâmica rotacional.
Semana 13 – Aula Síncrona 1 – Terça Feira dia 01 de Dezembro, 19h; A aula será realizada pelo aplicativo Skype. O link será enviado para o email dos alunos usando o Google Classroom, aproximadamente 30 min antes da aula.
Tema da aula: Aula adicional apenas com exercícios envolvendo rotacões.
Semana 13 – Aula Síncrona 2 – Terça Feira dia 03 de Dezembro, 19h; A aula será realizada a Avaliação A4. Temas compreendidos entre Estática de Corpos Rígidos e Dinâmica Rotacional.
Leitura relacionada a aula: A parte de Estática consta em livros de ensino fundamental e médio. Nos livros de ensino superior geralmente tudo se resume a uma seção dedicada a estática. Então a leitura dos links e dos slides deve ser suficiente. Quem desejar, há uma seção de um livro texto sobre Rotação no Equilíbrio (que é a Estática). As partes de Cinemática e Dinâmica Rotacional são absolutamente consolidadas na maioria dos livros de Mecânica Elementar do Ensino Superior, escolha seu livro favorito e boa leitura. Nós seguiremos o livro do Física vol1 do Resnick * Halliday * Krane 5ª Ed.
- Material de Ensino superior sobre Estática de Corpos Rígidos, veja aqui.
- Material de Ensino médio sobre Estática, veja aqui.
- Material de Ensino médio sobre Alavancas, veja aqui.
- Material de Ensino fundamental sobre Alavancas, veja aqui.
- Material de Cinemática e Dinâmica Rotacional, veja um resumo aqui.
- Material de Específico de cinemática rotacional, veja aqui.
- Material de Específico de dinâmica dinâmica, veja aqui.
Lista de Exercícios Sugeridos:
Todos os exercícios são do Livro Física vol1 do Resnick * Halliday * Krane 5ª Ed.
Estática de Corpos Extensos: Revisite os Problemas Resolvidos do 9.6, 9.7 e 9.8. Faça os Exercícios: 22, 23, 25, 27 e 29 (muito bom exercício).
Cinemática Roacional: Multipla Escolha: 2, 4, 5, 7. Questões: 2, 5, 12, 14. Exercícios: 2, 3, 4, 9 (o mais legal), 13, 14, 17, 18. Problemas: 2.
Dinâmica Rotacional: Multipla Escolha: 8. Questões: 4, 8, 16, 24,35. Exercícios: 19, 34
Exercícios de preparação e fixação: Os enunciados serão postados diretamente no Google Class Room. Semana 11 até 13 – Preparação 1, Preparação 2, Fixação.
Materiais gerados para aulas síncronas:
Slides sobre Estática de Corpos Rígidos e Alavancas. Slides sobre Cinemática Rotacional. Slides sobre Dinâmica Rotacional. Slides de Exercícios..
Conteúdo complementar:
A utilização adequada das marchas de um automóvel ( e outros veículos com motor a combustão ou não) é um exemplo de aplicação dessa ciência.
Para estudar se divertindo:
Algumas ilusões de ótica podem ser criadas usando a cinemática rotacional de alguma forma engenhosa. Existe toda sorte de pequenos truques, alguns são vistos apenas usando câmeras mas outros pode ser observados ao vivo.
Um bom resumo sobre o assunto pode ser encontrado aqui.
Física A – EARTE – Semanas 10.
Semana 10 – Aula Síncrona 1 – Terça Feira dia 10 de Novembro, 19h. A aula será realizada pelo aplicativo Skype. O link será enviado para o email dos alunos usando o Google Classroom, aproximadamente 30 min antes da aula.
Tema da aula: Sistemas com muitas partículas, abordagem para sistemas discretos usando centro de massa.
Semana 10 – Aula Síncrona 2 – Terça Feira dia 12 de Novembro, 19h; A aula será realizada pelo aplicativo Skype. O link será enviado para o email dos alunos usando o Google Classroom, aproximadamente 30 min antes da aula.
Tema da aula: Exemplos de como calcular a posição do centro de massa para arranjos mais complexos.
Leitura relacionada a aula: Esse conteúdo é bastante consolidado em todas as bibliografias do Plano de Ensino. Sua exposição é feita geralmente junto do capítulo de Conservação da Quantidade de Movimento. Menos no livro do Tipler e Mosca que faz a parte específica do Centro de Massa no capítulo de Aplicações das Leis de Newton.
Qualquer leitura é bem vinda, quem não tiver um livro favorito pode acessar os links abaixo.
- Se você não sabe nem começar, tente esse link aqui, é para o nível de ensino médio. Mas saiba que ele não é suficiente, é apenas uma preparação.
- Material sobre Centro de Massa, veja no link.
- Material sobre Sistemas de Partículas, veja no link.
Lista de Exercícios Sugeridos:
Colisões: Toda a lista está no Cap 7 do Livro Física 1 – Resnick*Halliday*Krane 5ed.: Multipla Escolha 1,2,4, 7, 9, 11 e 12. Questões: 2, 4, 7, 10, 12*, 13. Exercícios: 1, 2, 3, 7,13, 16, 18. Problemas: 1, 3, 4. Link para Leitura Adicional relacionada aos exercícios, veja aqui. Não há necessidade de entregar, mas é bom fazer, nossas avaliações são inspiradas nesses exercícios.
Exercícios de preparação e fixação: Os enunciados serão postados diretamente no Google Class Room. Semana 10 – Preparação 1, Preparação 2, Fixação.
Materiais gerados para aulas síncronas:
Slides sobre sistemas de Partículas discretos. Slides sobre Centro de Massa em sistemas com distribuição contínua de massa.
Conteúdo complementar:
- Vídeo aulas com Exemplos de Problemas Envolvendo a Posição do Centro de Massa.
Para estudar se divertindo:
Esse é um conteúdo totalmente aberto. Então não há desculpas para não consumir.
O que o Coyote possivelmente é o maior cientista dos Desenhos Animados, para infelicidade dele, o poder do protagonismo é maior que o da ciência….
A animação acima mostra exatamente a situação da Questão 12( ela tem um asterisco na lista acima).
Qual a veracidade do que vemos na animação? Estaria o Coyote certo novamente?
Esse sistema de propulsão já foi alvo de muita discussão, e sua ciência é acessível mesmo para alunos de Ensino Médio, já que foi uma questão apresentada no ENEM 2018.
Vez ou outra é alvo de elaboradas explicações …
Física A – EARTE – Semanas 8.
Semana 8 – Aula Síncrona 1 – Terça Feira dia 27 de Outubro, 18h – 19:30h será realizada a Avaliação Síncrona 2 (A2). Neste mesmo dia será dado início aos estudos de Colisões, entre às 19:45h e 21h. A aula será realizada pelo aplicativo Skype. O link será enviado para o email dos alunos usando o Google Classroom, aproximadamente 30 min antes da aula.
Tema da aula: Nesta aula faremos o estudo inicial de Colisões. Abordaremos Impulso, Colisões Perfeitamente Inelásticas e Elásticas. Faremos exemplos e relacionaremos o que será exposto com o mundo real.
Semana 8 – Aula Síncrona 2 – Quinta-Feira dia 29 de Outubro de 2020; A aula ocorrerá às 19:30h pelo aplicativo Skype. O link será enviado para o e-mail dos alunos usando o Google Classroom, aproximadamente 30 min antes da aula.
Tema das aulas: Começaremos o estudo de Sistemas de Partículas e Centro de Massa. Também estudaremos colisões no referencial do Centro de Massa.
Leitura relacionada a aula: Esse conteúdo é bastante consolidado em todas as bibliografias do Plano de Ensino. Sua exposição é feita geralmente junto do capítulo de Conservação da Quantidade de Movimento.
Qualquer leitura é bem vinda, quem não tiver um livro favorito pode acessar os links abaixo.
- Se você não sabe nem começar, tente esse link aqui, é para o nível de ensino médio. Mas saiba que ele não é suficiente, é apenas uma preparação.
- O material a seguir é de nível superior, veja no link, e está mais próximo do que faremos em colisões. Não há necessidade de se preocupar com colisões bidimensionais ainda.
- Material sobre Centro de Massa, veja no link.
Lista de Exercícios Sugeridos:
Colisões: Toda a lista está no Cap 6 do Livro Física 1 – Resnick*Halliday*Krane 5ed.: Multipla Escolha 1,2,3, 4 e 5. Questões: 3, 4, 9. Exercícios: 1, 4, 7,19, 20, 23,24,29. Link para Leitura Adicional relacionada aos exercícios, veja aqui. Não há necessidade de entregar, mas é bom fazer, nossas avaliações são inspiradas nesses exercícios.
Exercícios de preparação e fixação: Os enunciados serão postados diretamente no Google Class Room. Semana 8 – Preparação 1, Preparação 2, Fixação.
Teste ou Trabalho: Não há para esse tema.
Materiais gerados para aulas síncronas:
Slides sobre colisões unidimensionais. Slides sobre Centro de Massa e colisões no referencial centro de massa de colisões. Slides sobre tópicos adicionais em colisões.
Conteúdo complementar:
- Experimento com pêndulo balístico usando uma arma real. Está ai um ótimo problema real para ser resolvido.
- Vídeo aula introdutória sobre Centro de Massa.
Para estudar se divertindo:
Esse é um conteúdo totalmente aberto. Então não há desculpas para não consumir.
https://www.dw.com/embed/480/av-17507939
No vídeo um professor de Física Alemão explica o Hóquei no gelo. Existe uma brutal simplificação de algumas contas, não sei dizer se é obra da tradutora ou do próprio professor que simplifica para o público. Isso importa pouco, pois o vídeo é divertido, ilustrativo e educativo.
Física A – EARTE – Semanas 6 e 7.
Aula Síncrona 6 – Dias 13 de Outubro de 2020; Às 19:30h pelo aplicativo Jitsi meet Skype. O link será enviado para o email dos alunos usando o Google Classroom, aproximadamente 30 min antes da aula.
Tema da aula: Nestas aulas vamos abordar a Mecânica Newtoniana utilizando Trabalho e Energia. São conceitos que permeiam as ciência já antes de Galileu ou Newton, mas que só ganharam os contornos atuais no século 19, Isso em física clássica significa ser algo muito novo.
Podemos destacar o Gaspard Coriollis como alguém chave, ele propôs a ideia do trabalho de uma força (o elo que liga as forças de Newton e o conceito de Energia elaborada por outros cientistas).
Aulas Síncronas 7 – Dias 20 e 22 de Outubro de 2020; Às 19:30h pelo aplicativo Skype. O link será enviado para o email dos alunos usando o Google Classroom, aproximadamente 30 min antes da aula.
Tema das aulas:
Na aula do dia 20 vamos complementar a aula da semana 6, falando de potência e resolvendo um exemplo.
Na aula do dia 22 falaremos de energia potencial e do princípio da conservação da energia. Novo material de Leitura foi postado para essa aula
Leitura relacionada a aula: Esse conteúdo é bastante consolidado em todas as bibliografias do Plano de Ensino. Sua exposição é feita geralmente após Leis de Newton, a exceção é o Livro Física 1, do Renick * Halliday * Krane, que apresenta o conteúdo mais tarde, após rotações.
Qualquer leitura é bem vinda, mas o foco que eu darei é mais próximo do que encontramos no livro Física – Para Cientistas e Engenheiros de Tipler e Mosca 6 ed.
- Materiais para Leitura das aulas dos dias 15 e 20: Download.
- Materiais para Leitura da aula do dia 22: Download.
Nota: Os arquivos estão armazenados no Google Drive institucional, então talvez seja necessário fazer login com e-mail institucional para conseguir acessar.
Lista de Exercícios: Cap 6 do Tipler e Mosca 6ed – 1,3,18, 34, 36, 37, 69, 74. Cap 7 do Tipler e Mosca 6 ed – 3, 5, 8, 29, 42, 65, 108. E outros a serem adicionados no Google Classroom. Não será necessário entregar.
Lista de exercícios adicional: Todos os exercícios resolvidos do seu livro texto favorito.
Teste ou Trabalho: Não há para esse tema.
Materiais gerados para aulas síncronas: Slides 1 e Slides 2 sobre Trabalho e Energia Cinética, Slides sobre Conservação da Energia.
Você deve fazer download dos Slides, descompactar e abrir no seu navegador.
Conteúdo complementar:
- Biografia do Gaspard Gustave Coriolis , acesse aqui.
- Um pouco da história do Trabalho e Energia acessível ao ensino médio, acesse aqui.
Para estudar se divertindo:
Esse material é totalmente protegido por direitos autorais, então só poderá usufruir plenamente dele quem o adquirir. Por isso não é algo indispensável a disciplina, mas é divertido e isso é que importa nessa seção.
Já pensou em ter como Leitura Introdutória de algo um texto repleto de figuras e situações engraçadas. A série do Guia Mangá faz isso por você…na falta do material original, aqui um blog que faz uma resenha breve do Guia Mangá de Física – Mecânica Clássica.
Física A – EARTE – Semana 3 e 4
Aula Síncrona 3 e 4 – Dias 29 de Setembro e 01 de Outubro de 2020; Ambas 19:30h pelo aplicativo Jitsi meet. O link será enviado para o email dos alunos usando o portal do professor e o Google Classroom, até 1h antes da aula.
Tema das aulas: Nestas aulas vamos falar abordar problemas a serem resolvidos em Dinâmica e Cinemática. Dando particular importância as máquinas simples usando polias. Também faremos a abordagem inicial sobre partículas pontuais que giram.
Leitura relacionada a aula: Na maioria dos livros, o conteúdo dessas aulas é fragmentado em 2 ou mais capítulos. As leituras que são mais próximas estão nos capítulos 4 e 5 do Livro Curso de Física Básica 1 do Moysés. E o capítulo 9 do livro Lições de Física do Feynman. Visando condensar em um documento, fiz um apanhado das principais ideias e as digitei no documento identificado em Notas de aula. Os demais documentos são para auxiliar seu estudo. Todos os conteúdos devem ser estudados com antecedência, os 3 primeiros para a aula de terça feira e o quarto documento “Elementos do Movimento Circular” será essencial para aula de quinta feira.
- Notas de aula do Professor Ramón : Download.
- Anexo das notas de aula: Download.
- Outros materiais pertinentes: Download 1 e Download 2
- Elementos do Movimento Circular: Download.
Nota: Os estão armazenados no Google Drive institucional, então talvez seja necessário fazer login com e-mail institucional para conseguir acessar.
Lista de Exercícios: Lista de Exercício para entrega foi postada no Google Classroom.
Lista de exercícios adicional: Todos os exercícios de fixação das notas de aula.
Teste ou Trabalho: Acesse por aqui o trabalho computacional T2.
Você deve fazer parte do grupo da UFES no Google para poder acessar este arquivo.
Material gerado para aula Síncrona: 1)Slides sobre Dinâmica e 2) Vídeo com slides sobre Movimento Circular.
Conteúdo complementar:
- Matéria da Super Interessante sobre Richard Feynman, acesse aqui.
Para estudar se divertindo:
No desenho infantil Peppa Pig, temos uma porquinha rosa (certamente) inglesa que vive aventuras do dia dia. Em um dado, episódio da 5ª Temporada, chamado “A Chave Perdida”, o pai da Peppa deixa cair em um poço as chaves do carro da família.
Com a finalidade de montar uma estratégia para resgatar a chave do Papai Pig, a dona Coelha (faz tudo do desenho) joga uma pedra no poço e aguarda ela bater no fundo, dessa forma eles esperam estimar a profundidade do poço.
No desenho, a ideia serve para categorizar o poço (raso, fundo, muito fundo), mas de fato a engenhosa estratégia da Dona Coelha é cientificamente relevante e consta como exercício em diversos livros texto que abordam cinemática elementar.
O conteúdo não é de acesso livre, seu repositório atual é a Netflix e a Discouvery Kids. Não se trata de um conteúdo indispensável para disciplina. Mas é divertido.
Física A – EARTE – Semana 2
Aula Síncrona 2 – Dia 17 de Setembro 2020 – 19:30h pelo aplicativo Jitsi meet. O link será enviado para o email dos alunos usando o portal do professor e o Google Classroom, até 1h antes da aula.
Tema da aula: Nesta aula vamos falar brevemente sobre transformações de unidades, como um complemento da semana passada. E vamos focar mais pesadamente nas revisões de matemática que são pertinentes para disciplina Física A.
Leitura relacionada a aula: Capítulo correspondente a revisão de ferramentas matemáticas de qualquer dos livros da bibliografia básica. Esse capítulo não existe no Livro Física 1, Resnick * Halliday * Krane, 5ª ed. Se não dispor de nenhum seguem alguns links de boas fontes, não se assustem com a quantidade de fontes, eu optei pela diversidade e vocês não precisam ver tudo:
- Sítio do e-fisica sobre o Matemática Elementar para Mecânica, do IF USP: Download.
- Sítio do e-fisica sobre o Vetores para Mecânica, do IF USP, acesse por aqui.
- Sítio do IMPA sobre Vetores: Download.
- Sítio do brasilescola sobre as motivações por trás das derivadas, acesse por aqui.
- Sítio do brasilescola sobre a aplicação mais elementar das integrais, acesse por aqui.
- Sítio da IMPA sobre Revisão de Derivada: Download.
- Sítio da USP sobre Revisão de Integral: Download.
Lista de Exercícios: Lista de Exercício para entrega foi postada no Google Classroom.
Lista de exercícios adicional: Essa é aquela que não precisa ser entregue: Problemas 3.13, 3.16 , 3.23, 3.32, 3.43 do livro Fundamentos de Física 1 – Halliday * Renick * Walker – 8ª Ed.
Teste ou Trabalho: Não há novo trabalho ou teste.
Material Utilizado na aula síncrona: Acesse a pasta Google Drive .
Acessível apenas para membros do grupo UFES do Google Drive.
Conteúdo complementar:
- Sítio do IMPA sobre toda a revisão de funções e cálculo básico (toneladas de material que pode ajudar nas aulas de cálculo), veja aqui.
- Simulação sobre o corte ideal de pizzas em formatos exóticos, veja aqui.
- Artigo que revisita o ensino de cálculo no Brasil, talvez vocês se identifiquem, veja aqui.
- Dissertação de Mestrado sobre o cálculo no ensino médio Brasileiro, veja aqui, pode ler só os capítulos 1 e 2.
Para estudar se divertindo:
O conteúdo não é de acesso livre, apesar de poder ser assistido legalmente pelo Crunchyroll. Não se trata de um conteúdo indispensável para disciplina.
Quem tiver meios para tanto, assista ao episódio 17 da 4ª Temporada de Boku no Hero Academia (no Crunchyroll é o ep 80 ). O título é “Orgulhem-se , candidatos à licença provisória”.
Vou dar o contexto da coisa, nesse anime acompanhamos um grupo de estudantes secundaristas do curso de SUPER HÉROIS da melhor escola de SUPER HÉROIS do Japão. E nesse episódio esse pessoal tem de resolver uma integral definida em uma aula. Esso levanta várias questões interessantes, a primeira delas é o eterno “para que eles vão precisar disso?”, ou “isso tem resposta mesmo?”, entre outras…
No Brasil já se estudou isso no ensino médio, e eu coloquei material sobre isso acima, no Japão isso é tão comum que aparece até em animes de luta para garotada.
Física A EARTE – Semana 1
Aula Síncrona 1 – Dia 10 de Setembro 2020 – 19:30h pelo aplicativo Google Meet Jitsi meet. O link será enviado para o email dos alunos usando o portal do professor, 1h antes da aula.
Tema da aula: Nesta aula vamos discutir detalhes do plano de ensino e fazer uma aula inicial bem leve sobre sistemas de unidades e medidas em Física e outras ciências.
Leitura relacionada a aula: Capítulo correspondente ao sistema de unidades de qualquer dos livros da bibliografia básica. Se não dispor de nenhum seguem alguns links de boas fontes:
- Resumo de Sistema Internacional do INMETRO: Download
- Sítio do e-fisica sobre o assunto, do IF USP, seções 1,3,4 e 5, acesse por aqui.
- Sítio do brasilescola sobre o assunto, acesse por aqui.
Lista de Exercícios: Faça download da Lista 1, essa lista deve ser entregue em data a ser definida.
Aqui tem uma lista adicional com exercícios sugeridos, essa lista não precisa ser entregue.
Primeiro Teste ou Trabalho: Faça download do Teste 1 aqui.
Faça download da lista de itens aleatórios aqui.
No Teste 1 há menção linhas da lista de itens aleatórios, essa lista é feita digitando tudo e embaralhando aleatoramente cada coluna. Isso foi feito para que houvesse diversidade itens pesquisados e comparados. Como existem níveis de dificuldade para localizar informações, essa parecia a escolha mais justa (deixar o acaso decidir quem pega pesquisa fácil e quem pega pesquisa difícil).
Caso seu número de matrícula não esteja na lista envie um e-mail para mim usando seu login-unico@edu.ufes.br.
Material Gerado Para Aula 1: Foi discutido o plano de ensino.
Conteúdo complementar:
- Mudança recente nos padrões do Sistema Internacional, veja aqui.
- O padeiro moderno, com trena, balança digital e planilha eletrônica, veja no youtube.
- Unidades de medida agrárias brasileiras, acesse por aqui.
- Um pouco do sistema de medidas inglês, veja aqui, é superinteressante.
Para estudar se divertindo:
O conteúdo não é de acesso livre, portanto não se trata de um conteúdo indispensável para disciplina. Mas é divertido e essa é a ideia do tópico.
Quem tiver meios para tanto, assista ao episódio 24 da 5ª Temporada de Jovens Titãs em Ação! O título é O Sistema Métrico Contra a Liberdade, é impagável e com informações suficientemente verdadeiras.
Os canais de acesso oficiais são a Netflix e o Cartoon Network. É possível encontrar por outros meios na internet, mas eu NÃO recomendo que vocês façam isso, pois pirataria é crime.
Python – Aula 4
Computação Simbólica no IPython Notebook usando sympy
Disciplina “Computação no Ensino de Física” (CEF) da UFES/Alegre
Curso de Licenciatura em Física – Turma 2014/2
Autoria : Prof. Ramón Giostri Campos – 2014/2.
Veremos abaixo como usar o IPython notebook e o pacote matplotlib para fazer gráficos profissionais
Carregar o IPyhon notebook e os pacotes iniciais:
Digite $ipython notebook
no terminal do seu sistema operacional (shell no linux e prompt no windowns);
Abaixo vamos chamar os principais pacotes, separando eles por contexto
In [1]: %pylab inline
Populating the interactive namespace from numpy and matplotlib
%pylab inline = chama o pylab e coloca os graficos embutidos;
In [2]: import numpy as np
In [3]: import scipy as sp
In [4]: import matplotlib as mpl
In [5]: import matplotlib.pyplot as plt
In [6]: #ion() #isso liga o modo interativo do matplotlib, usamos só se o inline nao for usado no primeiro comando!
Exercício 1
Escreva um comentário ilustrativo sobre cada uma das linhas de input, assim como foi feito abaixo da primeira (e na ultima) linha da sequência de comandos;
# %pylab inline = chama o pylab e coloca os graficos embutidos;
(...)
#ion() #isso liga o modo interativo do matplotlib, usamos so se o inline nao for usado no primeiro comando!
Pintando curvas, pontos, e figuras geométricas;
Um gráfico bruto de uma reta, dado as coordenadas;
In [7]: plt.plot([1.0,3.4],[4.7,5.9])
Out[7]: [<matplotlib.lines.Line2D at 0x3dd5ad0>]
A ideia do matplotlib é usar uma interpolação linear dos pontos para gerar os gráficos, isso para retas não tem problema, mas para curvas…
In [8]:
x1=np.arange(-2,3) #domínio y1=(x1)**2 #Imagem plt.plot(x1,y1)
Out[8]: [<matplotlib.lines.Line2D at 0x41241d0>]
Claramente temos de almentar o número de pontos no intervalo para ter uma melhor interpolação…+ é bom não exagerar! Além disso podemos fazer uma coisa sistematizada mais elegante!
In [9]:
xi=-2. # limite inferior do domínio xf=2. #liminte superior do domínio numd=100. #número de divisões dx=(xf-xi)/numd #intervalo das divisões x1=np.arange(xi,xf+dx,dx) # Gera o vetor domínio y1=(x1)**2 # Gera o vetor imagem plt.plot(x1,y1)
Out[9]: [<matplotlib.lines.Line2D at 0x433d550>]
Poderíamos encurtar a coisa usando o comando…
linspace
Vamos aprender mais um pouco sobre esse comando…
In [13]: help(linspace)
numpy.core.function_base:
linspace(start, stop, num=50, endpoint=True, retstep=False)
Return evenly spaced numbers over a specified interval.
Returns `num` evenly spaced samples, calculated over the
interval [`start`, `stop` ].
The endpoint of the interval can optionally be excluded.
Parameters
----------
start : scalar
The starting value of the sequence.
stop : scalar
The end value of the sequence, unless `endpoint` is set to False.
In that case, the sequence consists of all but the last of ``num + 1``
evenly spaced samples, so that `stop` is excluded. Note that the step
size changes when `endpoint` is False.
num : int, optional
Number of samples to generate. Default is 50.
endpoint : bool, optional
If True, `stop` is the last sample. Otherwise, it is not included.
Default is True.
retstep : bool, optional
If True, return (`samples`, `step`), where `step` is the spacing
between samples.
Returns
-------
samples : ndarray
There are `num` equally spaced samples in the closed interval
``[start, stop]`` or the half-open interval ``[start, stop)``
(depending on whether `endpoint` is True or False).
step : float (only if `retstep` is True)
Size of spacing between samples.
See Also
--------
arange : Similar to `linspace`, but uses a step size (instead of the
number of samples).
logspace : Samples uniformly distributed in log space.
Examples
--------
>>> np.linspace(2.0, 3.0, num=5)
array([ 2. , 2.25, 2.5 , 2.75, 3. ])
>>> np.linspace(2.0, 3.0, num=5, endpoint=False)
array([ 2. , 2.2, 2.4, 2.6, 2.8])
>>> np.linspace(2.0, 3.0, num=5, retstep=True)
(array([ 2. , 2.25, 2.5 , 2.75, 3. ]), 0.25)
Graphical illustration:
>>> import matplotlib.pyplot as plt
>>> N = 8
>>> y = np.zeros(N)
>>> x1 = np.linspace(0, 10, N, endpoint=True)
>>> x2 = np.linspace(0, 10, N, endpoint=False)
>>> plt.plot(x1, y, 'o')
[<matplotlib.lines.Line2D object at 0x...>]
>>> plt.plot(x2, y + 0.5, 'o')
[<matplotlib.lines.Line2D object at 0x...>]
>>> plt.ylim([-0.5, 1])
(-0.5, 1)
>>> plt.show()
De qualquer forma isso é uma questão de gosto!
Vamos voltar aos nosso gráficos e tentar ver os pontos de um e do outro para enteder melhor o que se passa!
In [12]:
#Código para gerar os gráficos sobrepostos # xi=-2. # limite inferior do domínio xf=2. #liminte superior do domínio # # 5 Pontos, a subdivisão e os vetores de pontos correspondente # numd=5. #número de divisões dx=(xf-xi)/numd #intervalo das divisões x1=np.arange(xi,xf+dx,dx) y1=(x1)**2 # # 20 Pontos a subdivisão e vetor de pontos correspondente # numd=10. #número de divisões dx=(xf-xi)/numd #intervalo das divisões x2=np.arange(xi,xf+dx,dx) y2=(x2)**2 plt.plot(x1,y1,'r-',x2,y2,'go',x2,y2,'b-') #Isso sim é código mastigado!!!
Out[12]:
[<matplotlib.lines.Line2D at 0x4a05ed0>, <matplotlib.lines.Line2D at 0x4a093d0>, <matplotlib.lines.Line2D at 0x4a09890>]
Exercício 2:
Tente descobri o que significam as opções ‘r-‘, ‘go’ e ‘b-‘ no gráfico acima.
Vamos as figuras geométricas agora:
Triângulos:
In [13]: plt.plot([-1,0.5,1,-1],[0,2,1,0])
Out[13]: <matplotlib.lines.Line2D at 0x4c33390>]
Você provavelmente notou que a sintax do python é diferente do que estamos acostumados lá da Geometria Analítica:
Em GA temos pares (x,y) e com 3 desses pares (não colineares) fazemos o triângulo.
No Matplotlib é fornecido duas listas, uma com todos os x’s e outra com todos os y’s;
Mas com um pouco de programação podemos tornar o matplotlib mais intuitivo.
In [21]:
#Script para fazer triângulos usandos os pares ordenados. # #Escreva os pares ordenados abaixo: pares=([-1,0],[0.5,2],[1,1]) print pares pares_f=pares+(pares[0],) # essa operação inclui um termo adicional igual ao primeiro termo na ultima posição; print pares_f pares_t=np.transpose(pares_f) # essa operação é a transposição da matriz (uma tupla do python que se comporta como matriz; print pares_t plt.plot(*pares_t)
([-1, 0], [0.5, 2], [1, 1]) ([-1, 0], [0.5, 2], [1, 1], [-1, 0]) [[-1. 0.5 1. -1. ] [ 0. 2. 1. 0. ]]
Out[21]: [<matplotlib.lines.Line2D at 0x599a390>]
In [22]:
#Script para fazer triângulos usandos os pares ordenados. # #Escreva os pares ordenados abaixo: pares=([-1,0],[0.5,2],[1,1],[2,1]) print pares pares_f=pares+(pares[0],) # essa operação inclui um termo adicional igual ao primeiro termo na ultima posição; print pares_f pares_t=np.transpose(pares_f) # essa operação é a transposição da matriz (uma tupla do python que se comporta como matriz; print pares_t plt.plot(*pares_t)
([-1, 0], [0.5, 2], [1, 1], [2, 1]) ([-1, 0], [0.5, 2], [1, 1], [2, 1], [-1, 0]) [[-1. 0.5 1. 2. -1. ] [ 0. 2. 1. 1. 0. ]]
Out[22]: [<matplotlib.lines.Line2D at 0x5b76a50>]
Aqui também podemos tentar algo mais elaborado, com cores e legenda.
In [23]:
from __future__ import unicode_literals # isso permite incluir acentos nos gráficos. E era um exercício em outra aula.
In [24]:
#Script para fazer triângulos usandos os pares ordenados e com legendas.
#
#Escreva os pares ordenados abaixo:
pares=([-1,0],[0.5,2],[1,1])
#
#
pares_f=pares+(pares[0],) # essa operacao inclui um termo adicional igual ao primeiro termo na ultima posicao;
pares_t=np.transpose(pares_f) # essa operacao e a transposicao da matriz (uma tupla do python que se comporta como matriz;
plt.plot(pares_t[0],pares_t[1],'ro', label='Vértices')
plt.plot(pares_t[0],pares_t[1],label='Lados')
plt.title('Triângulo')
plt.ylim((-0.1,2.1)) #expande a area visivel do eixo y
plt.xlim((-1.1,1.1)) #expande a area visivel do eixo y
plt.legend(loc='upper left') # legenda inclusive especificando a posição na figura
plt.show()
Pintando pontos, e outros símbolos;
Se você passou por isso tudo, acredito que já tenha entendido como plotar pontos.
Vamos resumir para facilitar:
1 – Tome as duas listas de mesmo tamanho, uma representando os valores x’dos pontos e outra para os y’dos pontos (evidente que só pode ter número na lista).
2 – Insira as duas listas em sequência no comando PLOT (no nosso CONTEXTO plt.plot).
3 – Acrescente ‘o’ para o estilo de marcação de pontos, “-” para linha e “–” para linha tracejada.
Vamos mais exemplos;
Pontos aleatórios:
In [29]:
num_p=100 #total de pontos x=np.random.random_sample(num_p) #faz uma amostragem aleatório dos pontos para o x y= np.random.random_sample(num_p) #idem para o y plt.plot(x,y,'o')
Out[29]: [<matplotlib.lines.Line2D at 0x6583e50>]
Exercício 3:
Se em lugar de bolinhas azuis, tivéssemos sinais ‘+’ vermelhos, como faríamos isso?
Pontos de figuras regulares:
In [35]:
num=15 #numero de lados da figura
dt= 2*np.pi/num
#usamos a matriz de rotação sobre o vetor (1,1) para gerar os pares x e y
lista_x=map(lambda t:(np.cos(t)+np.sin(t)),arange(0,2*pi+dt,dt))
lista_xf=append(lista_x,lista_x[0])
lista_y=map(lambda t:(-np.sin(t)+np.cos(t)),arange(0,2*pi+dt,dt))
lista_yf=append(lista_y,lista_x[0])
#expande a area visivel do eixo y
plt.ylim((-1.5,1.5)) #usamos o valor de 1.5, pois o maior valor que pode ser alcançado aqui é raiz de 2;
plt.xlim((-1.5,1.5))
#
plt.plot(lista_x,lista_y) #linhas
plt.plot(lista_x,lista_y,'o',label='Vértices') # vertices
plt.legend(loc='upper left')
# acerta a proporção dos eixos, você lembra que isso foi um problema na aula passada usando SymPy!
plt.axes().set_aspect('equal')
In [21]:
num=5#numero de lados da figura
dt= 2*np.pi/num
#usamos a matriz de rotação sobre o vetor (1,1) para gerar os pares x e y
lista_x=map(lambda t:(np.cos(t)+np.sin(t)),arange(0,2*pi+dt,dt))
lista_xf=append(lista_x,lista_x[0])
lista_y=map(lambda t:(-np.sin(t)+np.cos(t)),arange(0,2*pi+dt,dt))
lista_yf=append(lista_y,lista_x[0])
#expande a area visivel do eixo y
plt.ylim((-1.5,1.5)) #usamos o valor de 1.5, pois o maior valor que pode ser alcançado aqui é raiz de 2;
plt.xlim((-1.5,1.5))
#
plt.plot(lista_x,lista_y)
# acerta a proporção dos eixos, você lembra que isso foi um problema na aula passada usando SymPy!
plt.axes().set_aspect('equal')
Movimento Browniano – Caminho aletório – Andar do Bêbado. Usando Scatter Plot;
Comecemos com um caso unidimensional que não precisa de gráfico.
In [41]:
num_p= 1000 #número de passos
pa=0
lista_p=[0]
for i in range(num_p-1):
pn = 1.0*random_integers(0,1) # isso indica que ele pode dar um passo a frente(1) ou ficar parado (0)
#alternativamente pode-se colocar -1 no lugar do ZERO, assim dizemos que o bêbado pode voltar um passo;
pa=pn+pa
lista_p=append(lista_p,pa)
print 'A fração do caminho percorrido ao final de', +len(lista_p), 'passos foi',+ lista_p[-1]/len(lista_p)
A fração do caminho percorrido ao final de 1000 passos foi 0.499
Agora vamos construir duas listas usando esse procedimento e fazer o problema bidimensional;
In [47]:
num_p= 200 #número de passos
pax=0
pay=0
lista_px=[0]
lista_py=[0]
for i in range(num_p-1):
pnx = 1.0*random_integers(0,1) # isso indica que ele pode dar um passo a frente(1) ou ficar parado (0)
#alternativamente pode-se colocar -1 no lugar do ZERO, assim dizemos que o bêbado pode voltar um passo;
pax=pnx+pax
lista_px=append(lista_px,pax)
pny = 1.0*random_integers(-1,1)
pay=pny+pay
lista_py=append(lista_py,pay)
plt.scatter(lista_px,lista_py)
Out[47]:
<matplotlib.collections.PathCollection at 0x7201350>
Note que o código é muito parecido com o anterior, apenas duplicamos as funções do loop e no lugar de mostrar o print, fazemos o gráfico, no caso usando um scatter plot (genuino gráfico de pontinhos);
In [52]:
num_p= 10000 #número de passos
pax=0
pay=0
lista_px=[0]
lista_py=[0]
lista=[0]
for i in range(num_p-1):
lista=append(lista,i)
pnx = 1.0*random_integers(-1,1) # isso indica que ele pode dar um passo a frente(1) ou ficar parado (0)
#alternativamente pode-se colocar -1 no lugar do ZERO, assim dizemos que o bêbado pode voltar um passo;
pax=pnx+pax
lista_px=append(lista_px,pax)
pny = 1.0*random_integers(-1,1)
pay=pny+pay
lista_py=append(lista_py,pay)
plt.scatter(lista_px,lista_py,s=50,c=lista) #pinta todos os pontos seguindo a distribuição do "i" para as cores;
plt.scatter(lista_px[0],lista_py[0],s=120, c= 'g') #pinta o ultimo ponto maior e em vermelho
plt.scatter(lista_px[-1],lista_py[-1],s=120, c= 'r') #pinta o ultimo ponto maior e em vermelho
plt.show()
Gráficos de funções, de uma ou mais variáveis
Como vimos acima, tudo gira em torno de criar as listas corretas, uma de domínio (x) e uma para a imagem (f(x));
Usar em sequência para plotar os gráficos, vamos ver alguns exemplos:
Funções trigonométricas
In [53]:
xi=-2*pi # limite inferior do domínio xf=2*pi #liminte superior do domínio # numd=500. #número de divisões dx=(xf-xi)/numd x_lista=np.arange(xi,xf+dx,dx)
Seno e cosseno
In [54]:
y_sen=np.sin(x_lista)
y_cos=np.cos(x_lista)
plt.plot(x_lista,y_cos,'r--', label='Cos(x)')
plt.plot(x_lista,y_sen,'b-',label='Sen(x)')
plt.title('Trigonometria')
plt.xlabel('x')
plt.ylabel('f (x)')
plt.legend(loc='upper right') # legenda inclusive especificando a posição na figura
plt.show()
In [55]:
y_sen=np.sin(10.0*x_lista)*np.cos(x_lista)
y_cos=np.cos(x_lista)
plt.plot(x_lista,y_cos,'r--', label='+ - Sen(x)')
plt.plot(x_lista,y_sen,'b-',label='Sen(10x)*Cos(x)')
plt.plot(x_lista,-y_sen,'b-') # sem o label = sem aparecer na legenda!
plt.title('Trigonometria')
plt.xlabel('x')
plt.ylabel('f (x)')
plt.legend(loc='upper right') # legenda inclusive especificando a posição na figura
plt.show()
Gráficos paramétricos
Curiosamente, dada a forma como os gráficos são feitos em Python isso se torna trivial…
In [56]:
ti=0 # limite inferior do parâmetro
tf=10*pi #liminte superior do parâmetro
#
numd=500. #número de divisões
dt=(tf-ti)/numd
t_lista=np.arange(ti,tf+dt,dt) #Lista dos pontos do parâmetro
x_cost=t_lista*np.cos(t_lista) #como x se relaciona com o parâmetro
y_sent=t_lista*np.sin(t_lista) #como y se relaciona com o parâmetro
plt.plot(x_cost,y_sent)
plt.axes().set_aspect('equal')
Out[56]:
[<matplotlib.lines.Line2D at 0x7228f90>]
In [64]:
# Usando teoria de coordenadas polares;
ti=0 # limite inferior do parâmetro
tf=10*pi #liminte superior do parâmetro
#
numd=1000. #número de divisões
dt=(tf-ti)/numd
t_lista=np.arange(ti,tf+dt,dt) #Lista dos pontos do parâmetro
r_polar = cos(3*t_lista) #Raio das coordenadas pelares
x_cost=r_polar*np.cos(t_lista) # x em termos de r e t
y_sent=r_polar*np.sin(t_lista) # y em termosde r e t
plt.plot(x_cost,y_sent)
plt.axes().set_aspect('equal')
Out[64]:
[<matplotlib.lines.Line2D at 0x88e4b50>]
In [68]:
# Usando teoria de coordenadas polares;
ti=0 # limite inferior do parâmetro
tf=10*pi #liminte superior do parâmetro
#
numd=1000. #número de divisões
dt=(tf-ti)/numd
t_lista=np.arange(ti,tf+dt,dt) #Lista dos pontos do parâmetro
r_polar = cos(t_lista)*sin(t_lista) #Raio das coordenadas pelares
x_cost=r_polar*np.cos(t_lista) # x em termos de r e t
y_sent=r_polar*np.sin(t_lista) # y em termosde r e t
plt.plot(x_cost,y_sent)
plt.axes().set_aspect('equal')
Out[68]:
[<matplotlib.lines.Line2D at 0x923e110>]
Outros gráficos 2D interessantes:
Regiões:
In [69]:
x = np.linspace(0, 4,100) y = np.sin(4*np.pi*x) * np.exp(-0.5 * x) plt.fill(x,y, 'b') plt.show()
Podemos inclusive misturar as coisas…
In [70]:
x = np.linspace(0, 6,100) y = np.sin(4*np.pi*x) * np.exp(-0.5 * x) plt.fill(x,y, 'r', label='Oscilação') y_e= np.exp(-0.5 * x) plt.plot(x,y_e, 'b', label='+ - Envoltória') plt.plot(x,-y_e,'b') plt.legend(loc='upper right') plt.show()
Histograma:
In [71]:
mu = 100 # media da disbribuicao
sigma = 15 # desvio padrao
x = mu + sigma * np.random.randn(10000) # amostra de 10 mil numeros
num_bins = 50
# esse comando gera 3 resutados;
n, bins, patches = plt.hist(x, num_bins, normed=1, facecolor='green', alpha=0.4)
# fazendo o ajuste da curva normal ao histograma
y = mlab.normpdf(bins, mu, sigma)
plt.plot(bins, y, 'r--')
#Titulos
plt.xlabel('Valores Prováveis')
plt.ylabel('Probabilidade')
plt.title(r'Histograma de IQ: $\mu=100$, $\sigma=15$')
# chega os graficos para o lado
plt.subplots_adjust(left=0.15)
plt.show()
Visualização de figuras de mais variáveis;
In [72]:
from mpl_toolkits.mplot3d import Axes3D #para fazer gráficos 3D
In [74]:
mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() ax = fig.gca(projection='3d') theta = np.linspace(-4 * np.pi, 4 * np.pi, 100) z = np.linspace(-2, 2, 100) x = np.sin(theta) y = np.cos(theta) ax.plot(x, y, z, label='Curva Espiral') ax.legend() plt.show()
In [77]:
mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() ax = fig.gca(projection='3d') theta = np.linspace(0, 4 * np.pi, 200) r = theta x = r*np.sin(4*theta) y = r*np.cos(4*theta) z = theta**0.5 ax.plot(x, y, z, label='Tornado') ax.legend() plt.show()
In [79]:
mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() ax = fig.gca(projection='3d') theta = np.linspace(0, 4 * np.pi, 200) r = theta x = r*np.sin(4*theta) y = r*np.cos(4*theta) z = theta ax.plot(x, y, z, label='Tornado') ax.plot(0.5*x, 0.5*y, 3*z, label='Outro Tornado') ax.legend() plt.show()
In [91]:
mpl.rcParams['legend.fontsize'] = 10 fig = plt.figure() ax = fig.gca(projection='3d') theta = np.linspace(0, 4 * np.pi, 200) r = theta x = r*np.sin(4*theta) y = r*np.cos(4*theta) z = theta ax.plot(x, y, z, label='Tornado') plt.plot(x, y, label='Sombra do Tornado') ax.plot(x,0.*y+15,z, label='Outra Sombra do Tornado') #ax.legend() plt.show()
Campo Vetorial
In [99]:
Y, X = np.mgrid[-3:3:100j, -3:3:100j] U = -1 - X**2 + Y V = 1 + X - Y**2 speed = np.sqrt(U*U + V*V) plt.streamplot(X, Y, U, V, color=U, linewidth=2, cmap=plt.cm.autumn) plt.colorbar() f, (ax1, ax2) = plt.subplots(ncols=2) ax1.streamplot(X, Y, U, V, density=[0.5, 1]) lw = 5*speed/speed.max() ax2.streamplot(X, Y, U, V, density=0.6, color='k', linewidth=lw) plt.show()
In [39]:
#Campo elétrico da carga elétrica pontual! Y, X = np.mgrid[-3:3:100j, -3:3:100j] #Pontos do vetor r U = X/(X**2 +Y**2)**1.5 # Coordenada X do Campo V = Y/(X**2 +Y**2)**1.5 # Coordenada Y do Campo plt.streamplot(X, Y,U,V, color=U, linewidth=2, cmap=plt.cm.autumn) plt.show()
In [94]:
#Campo magnético do fio retilíneo Y, X = np.mgrid[-3:3:100j, -3:3:100j] #Pontos do vetor r U = -Y/(X**2 +Y**2)**1.5 # Coordenada X do Campo V = X/(X +Y**2)**1.5 # Coordenada Y do Campo plt.streamplot(X, Y,U,V, color=U, linewidth=2, cmap=plt.cm.autumn) plt.show()
Animação
As vezes é importante rodar as coisas em um script separado, abaixo temos um exemplo!
In [95]:
#Retire os comentarios das linhas 2 abaixo apenas nos scripts. Nao coloque acentos no comentario do script.
#import numpy as np
#import matplotlib.pyplot as plt
import matplotlib.animation as animation
fig = plt.figure()
def f(x, y):
return np.sin(x) + np.cos(y)
x = np.linspace(0, 2 * np.pi, 120)
y = np.linspace(0, 2 * np.pi, 100).reshape(-1, 1)
im = plt.imshow(f(x, y), cmap=plt.get_cmap('jet'))
def updatefig(*args):
global x,y
x += np.pi / 15.
y += np.pi / 20.
im.set_array(f(x,y))
return im,
ani = animation.FuncAnimation(fig, updatefig, interval=50, blit=True)
plt.show()
In [ ]:
Outra coisa que pode ficar melhor de ver com script separado…
In [111]:
# Retire os comentarios das linhas 3 abaixo apenas nos scripts.
#import numpy as np
#from mpl_toolkits.mplot3d import Axes3D
#import matplotlib.pyplot as plt
# Nao coloque acentos no comentario do script.
fig = plt.figure()
ax = fig.gca(projection='3d')
num_p= 1000 #numero de passos
pax=0
pay=0
paz=0
lista_px=[0]
lista_py=[0]
lista_pz=[0]
lista=[0]
for i in range(num_p-1):
lista=np.append(lista,i)
#Numeros do x
pnx = 1.0*np.random.random_integers(-1,1) # isso indica que ele pode dar um passo a frente(1) ou ficar parado (0)
#alternativamente pode-se colocar -1 no lugar do ZERO, assim dizemos que o bebado pode voltar um passo;
pax=pnx+pax
lista_px=np.append(lista_px,pax)
#Numeros do y
pny = 1.0*np.random.random_integers(-1,1)
pay=pny+pay
lista_py=np.append(lista_py,pay)
#Numeros do z
pnz = 1.0*np.random.random_integers(-1,1)
paz=pnz+paz
lista_pz=np.append(lista_pz,paz)
ax.scatter(lista_px,lista_py,lista_pz,s=15,c=lista,marker='+') #pinta todos os pontos seguindo a distribuicao do "i" para as cores;
ax.scatter(lista_px[0],lista_py[0],lista_pz[0],s=400, c= 'g') #pinta o ultimo ponto maior e em vermelho
ax.scatter(lista_px[-1],lista_py[-1],lista_pz[-1],s=400, c= 'r') #pinta o ultimo ponto maior e em vermelho
plt.show()
:
Python – Aula 3
Computação Simbólica no IPython Notebook usando sympy
Disciplina “Computação no Ensino de Física” (CEF) da UFES/Alegre
Curso de Licenciatura em Física – Turma 2013/2
Autoria : Prof. Ramón Giostri Campos – 2014/1.
Veremos abaixo como usar o IPython notebook para realizar cálculos simbólicos, usando o pacote sympy, no processo vamos exercitar a definição de funções (def) em python e gráficos usando o próprio sympy.
Carregar o IPyhon notebook e os pacotes iniciais:
Digite $ipython notebook
no terminal do seu sistema operacional (shell no linux e prompt no windowns);
Abaixo vamos chamar os principais pacotes
In [1]:
%pylab inline
Populating the interactive namespace from numpy and matplotlib
É importante usar os pacotes compatíveis, como estamos usando o ipython novo, devemos usar o sympy novo.
No ubuntu uma solução é fazer download do sympy mais novo no sítio:
http://sympy.org/pt/download.html
Dai descompactamos e colocamos o arquivo que queremos executar (file.ipynb) dentro do diretório do recém descompactado.
In [2]:
import sympy as sym # importa as funções do sympy em um contexto diferenciado (no caso sym) from sympy import *
A mudança de contexto presente na primeira linha é importante para não sobrepor as funções vindas do sympy com as funções nativas do python e do pylab.
Executamos agora um comando para ver qual a versão do sympy, se tudo foi feito corretamente, o número que aparece aqui é o mesmo que está no pacote baixado do site e descompactado posteriormente;
In [3]:
from sympy import __version__ __version__
Out[3]:
'0.7.4.1'
Primeiro estágio: Operações básicas e considerações iniciais
In [4]:
3*pi/2 + exp(I*x) / (x**2 + y)
--------------------------------------------------------------------------- NameError Traceback (most recent call last) <ipython-input-4-057106a93d7b> in <module>() ----> 1 3*pi/2 + exp(I*x) / (x**2 + y) NameError: name 'x' is not defined
É importante dizer para o sympy quais as objetos são SÍMBOLOS;
In [5]:
x, y, z, t = symbols("x y z t") # Define símbolos para variáveis genericas
k, m, n = symbols("k m n", integer=True) # Define símbolos para variáveis inteiras
f, g, h = map(Function, 'fgh') # define símbolos para funções
In [6]:
3*pi/2 + sym.exp(I*x) / (x**2 + y)
Out[6]:
3*pi/2 + exp(I*x)/(x**2 + y)
Agora o Python entendeu o que fazer, pois x e y são símbolos.
Mas essa forma 1D é difícil de ler e muito feia…vamos melhorar isso.
Para isso devemos carregar o comando abaixo:
In [7]:
init_printing()
Vamos repetir o nosso teste;
In [8]:
3*pi/2 + sym.exp(I*x) / (x**2 + y) #Muito mais bonito!
Out[8]:
3π2+eixx2+y
Algumas ações que podem ser feitas com expressões simbólicas: expandir (expand), simplificar(simplify) e resolver(solve);
In [9]:
eq = ((x+y)**2 * (x+1)) eq
Out[9]:
(x+1)(x+y)2
In [10]:
expand(eq)
Out[10]:
x3+2x2y+x2+xy2+2xy+y2
In [11]:
a = 1/x + (x*sin(x) - 1)/x print(a) #assim fica feito display(a) #assim fica bonito
In [12]:
simplify(a)
Out[12]:
sin(x)
In [13]:
eq2 = Eq(x**3 - 3*x**2 + 4*x + 8., 0) display(eq2)
x3−3×2+4x+8.0=0
Notem que a equação gerada usa o comando “Eq”, para definir a igualdade;
In [14]:
solve(eq2,x)
Out[14]:
[−1.0,2.0−2.0i,2.0+2.0i]
Exercícios 1: Tente resolver equações de ordem maior que 3 e equações transcendentais com o solve para ver o que ocorre;
Terceiro esstágio: Física B;
Vamos começar com o sistema massa mola: F=-kx; A segunda lei de Newtom para ele nos gera ma+k*x=0, que em termo de derivadas e já dividindo pela massa fica:
In [15]:
w0=symbols("w_0",real=True)
Atentem para a Flag “real”, isso significa que o símbolo w0 é REAL;
In [16]:
eqn = Eq(Derivative(x(t),t,t) + w0**2*x(t), 0) # já trocamos k/m por w0**2 display(eqn) dsolve(eqn, x(t))
E se houvesse atrito, como ficaria.
In [17]:
b=symbols("b",real=True)
In [18]:
eqn2 = Eq(Derivative(x(t),t,t) +b*Derivative(x(t),t)+ w0**2*x(t), 0) # já trocamos k/m por w0**2 display(eqn2) dsolve(eqn2, x(t))
Out[18]:
Não se assunste, isso é feio assim pois o sympy não sabe quem é maior, b ou w0
Se b e w0 forem conhecidos teremoss algo relativamente simples;
In [19]:
eqn2_crit = Eq(Derivative(x(t),t,t) +4*Derivative(x(t),t)+ (2**2)*x(t), 0) # já trocamos w0=2 e b=4 display(eqn2_crit) dsolve(eqn2_crit, x(t))
Out[19]:
In [20]:
eqn2_super = Eq(Derivative(x(t),t,t) +5*Derivative(x(t),t)+ (2**2)*x(t), 0) # já trocamos w0=2 e b=5 display(eqn2_super) dsolve(eqn2_super, x(t))
Out[20]:
In [21]:
eqn2_sub = Eq(Derivative(x(t),t,t) +3*Derivative(x(t),t)+ (2**2)*x(t), 0) # já trocamos w0=2 e b=3 display(eqn2_sub) dsolve(eqn2_sub, x(t))
Out[21]:
E se houvesse uma força externa, por exemplo senoidal!
In [22]:
wp, A=symbols("w_p A",real=True)
In [23]:
eqn3 = Eq(Derivative(x(t),t,t) + w0**2*x(t)-A*sin(wp*t), 0) # já trocamos k/m por w0**2 display(eqn3) sol3=dsolve(eqn3, x(t)) display(sol3)
Exercício 2: Descubra se é possível reaproveitar o que é gerado do solve e do dsolve sem necessariamente digitar as equações manualmente;
Terceiro estágio: Cálculo B;
Primeiro vejamos uma derivada, já usamos ela acima nas equações diferencias.
Usamos os comandos “Derivative” para escrever a derivada e o comando “diff” para realizar a derivação;
In [24]:
Derivative(cos(m*x**k)**10,x)
Out[24]: Esse mostra a equação
In [25]:
diff(cos(m*x**k)**10,x)
Out[25]: Esse resolve a equação
Note que o comando “Derivative” é esperto, e se tivermos uma expressão com duas VARIÁVEIS, ele imprime na tela uma derivada parcial em lugar da derivada ordinária;
In [26]:
Derivative(cos(y*x**k),x)
Out[26]:
∂cos(xky)/∂x
Agora vamos a integral, não necessariamente uma simples.
Usamos o comando “Integral” para escrever a INTEGRAL sem resolve-la e o comando “integrate” para INTEGRAR e ver o resultado;
In [27]:
Integral(sin(k*x)*sin(m*x),(x,-pi/2,pi/2))
Out[27]: Esse mostra a equação
In [28]:
integrate(sin(k*x)*sin(m*x),(x,-pi/2,pi/2))
Out[28]: Esse resolve a equação
Essa é uma das integrais da base da Série de Fourier, usada nas séries de Fourier, muito importante para resolver problemas de MECÂNICA CLÁSSICA e ELETROMAGNETISMO.
Exercício 3: Pesquise quais as outras integrais dessa base e use o sympy para resolve-las;
Vamos a um exemplo mais trabalhoso, vamos investigar as Séries de Taylor:
Séries de Taylor (e outros tipos) são uma formas de aproximar funções ao redor de um ponto de avaliação.
In [29]:
series(f(x),x,0,6)
Out[29]:
Ainda é possível fazer de outra forma…
In [30]:
f(x).series(x,0,6)
Out[30]:
Adiantes vamos estudar graficamente a questão da aproximação das seríes de Taylor.
Tendo o SYMPY em funcionamento, é possivel fazer gráficos nele usando um comando tipo PLOT, porém o sym.plot é menos rico que o plt.plot (do MATPLOTLIB) que usamos na aula passada. Mas ele quebra bem o galho e tem uma sintax super simples;
Plot do sympy básico
In [31]:
sym.plot(cos(x))
Out[31]:
<sympy.plotting.plot.Plot at 0x5d261d0>
Note que não houve necessidade de gerar o dois vetores de números (usando NUMPY ARANGE) para gerar o gráfico (na verdade essa sintax é absurdamente simples).
In [32]:
sym.plot(cos(x),sin(x),log(x)) # vários gráficos
Out[32]:
<sympy.plotting.plot.Plot at 0x61eb810>
In [33]:
sym.plot(cos(x),log(x),(x,0.1,2*pi)) # gráficos com intervalos semelhantes definidos
Out[33]:
<sympy.plotting.plot.Plot at 0x6203490>
In [34]:
sym.plot((cos(x),(x,-pi,2*pi)),(log(x),(x,0.1,2*pi))) # gráficos com intervalos diferentes definidos
Out[34]:
<sympy.plotting.plot.Plot at 0x6478950>
Para inspecionar coisas simples, esse comando funciona muito bem, para gráficos realmente profissionais devemos usar o MATPLOTLIB. A a sintax simples é muito limitada e mesmo ações simples como mudar a cor dos gráficos já deixa deixa a simplicidade de lado;
In [35]:
p=sym.plot((cos(x),(x,-pi,2*pi)),(log(x),(x,0.1,2*pi)), show=False) p[0].line_color = 'red' p[1].line_color = 'green' p.title = 'Figuras Coloridass' p.show()
In [36]:
p=sym.plot((cos(x),(x,-pi,2*pi)),(log(x),(x,0.1,2*pi)), show=False) p[0].line_color = (0.5,1,1) #aqui usando RGB; p[1].line_color = lambda a : log(a) # Aqui usando uma função para mapear a cor; p.title = 'Figuras Coloridass' p.show()
Exercício 4: Pesquise se é possível colocar o nome dos eixos nos gráficos do sympy; Se sim, mostre um exemplo;
Quarto estágio: O que você não faria facilmente;
Vamos agora fazer uma função que faça a comparação da função e da séries;
In [37]:
def f_taylor_ordem(func, var=x, ordem=5):
ftaylor = func.series(var,0,ordem).removeO()
return ftaylor
Definimos uma função que faz a série de Taylor de uma função genérica (variável func), expandida na variável específica (var), que por omissão é escolhida variável x (var=x) e na ordem que quisermos (ordem), que por omissão é a ordem 5 (ordem=5);
Atente para o remove0() do final, ele serve para transformar a sérei em polinômio.
In [38]:
f_taylor_ordem(sinh(x*cos(t))) #tudo funcionando por omissão
Out[38]:
x36cos3(t)+xcos(t)
In [39]:
f_taylor_ordem(sinh(x*cos(t)),t,5)#aqui espeficicando a variável e a ordem
Out[39]:
t4(x28sinh(x)+x24cosh(x))−t2x2cosh(x)+sinh(x)
Vamos agora unir essa função a estrutura que gera gráficos do sympy;
In [40]:
def plot_taylor_compara(func, var=x, rang=(-1,1),yrang=(-1.2,1.2),ordem=[1,5]):
xrang = (var,)+rang
arg_plot=(func,)+tuple(map(lambda num:f_taylor_ordem(func,var,num),ordem))+(xrang,)
display(arg_plot)
sym.plot(*arg_plot,ylim=yrang)
Existem 4 soluções importantes usadas aqui que merecem destaque:
1 – Operações com TUPLAS: Note que a forma de definir o intervalo do plot é uma tupla, fazermos uma operação de soma com duas tuplas para gerar o formato esperado pelo plot;
2 – Uso do MAP, map mapeia em uma função os elementos listados;
map(f(x),[1,2,3]) = [f(1),f(2),f(3)]
Mas o map mapeia em uma função e devemos avisar para ele qual é a variável que ele deve mapear, para isso usamos…
3 – Função LAMBDA, essa função basicamente deixa aberto o espaço da variável declarada na função em que está aplicada. O map mapeará nesse espaço aberto;
O MAP + LAMBDA poderiam ser substituidos por um loop, mas em geral o loop é mais lento que o MAP + LAMBDA;
4 – Usar o “” para aplicar uma tupla como argumento de uma função do python; Apenas substituir a tupla não funciona, umando nome_da_tupla, os n elementos são aplicados um após o outro como argumentos da função;
Exercício 5: Como verificamos que a forma de definir intervalo no sym.plot é uma tupla?
Exercício 6: Faça o loop correspondente ao MAP abaixo;
In [41]:
map(lambda x:sin(pi*x/8),range(10))
Vamos testar nossa criação: plot_taylor_compara
In [42]:
plot_taylor_compara(tan(x)) # com omissão dos parâmetros
(tan(x),0,x33+x,(x,−1,1))
In [43]:
plot_taylor_compara(tan(x),x,(-1.5,1.5),(-3,3),[1,3,5,7,9]) # especificando tudo
(tan(x),0,x,x33+x,2×515+x33+x,17×7315+2×515+x33+x,(x,−1.5,1.5))
Fica uma confusão para ler essses gráficos;
Vamos incluir cores:
In [44]:
def plot_taylor_compara_color(func, var=x, rang=(-3.14,3.14),yrang=(-1.2,1.2),ordem=[1,5]):
xrang = (var,)+rang
arg_plot=(func,)+tuple(map(lambda num:f_taylor_ordem(func,var,num),ordem))+(xrang,)
gr=sym.plot(*arg_plot,ylim=yrang,title= "Grafico "+string0(func) + "e suas expansoes nas ordens "+string0(ordem),show=False)
for i in range(1,len(ordem)+1):
rgb=((1./random_integers(1,15)),(1./random_integers(1,15)),(1./random_integers(5,15)))
gr[i].line_color = rgb
gr.show()
print 'A função ' + string0(func) + ' sempre é azul!'
Exercício 7: Qual a serventia do random_integers?
Vamos ver o resultado do nosso trabalho…
In [45]:
plot_taylor_compara_color(exp(x)) # isso não ajudou muito!
A função exp(x) sempre é azul!
In [46]:
plot_taylor_compara_color(exp(x),x,(-8,20),(-10,200),range(1,8,1)) # especificando tudo
A função exp(x) sempre é azul!
In [47]:
plot_taylor_compara_color(exp(x),x,(-8,20),(155,165),range(1,8,1)) # Vamos mexer no yrange para ver melhor o que ocorre x=5;
A função exp(x) sempre é azul!
In [48]:
plot_taylor_compara_color(log(x+1),x,(0,2),(-0.75,1.5),range(2,15,1)) # Só está aqui pq é legal!
A função log(x + 1) sempre é azul!
Um pouco mais sobre gráficos do sympy
Como dissemos antes, para gráficos realmente profissionais devemos usar o MATPLOTLIB.
Mas mesmo com suas limitações, os gráficos do sympy são bastante versátis e com eles é possível esboçar muita coisa;
Gráficos implícitos;
In [49]:
sym.plot_implicit(Eq(x**2 + y**2, 4))
Out[49]:
<sympy.plotting.plot.Plot at 0x69da0d0>
In [50]:
plot_implicit(y > x**2 ,(x,-1,1)) # podemos pintar áreas
Out[50]:
<sympy.plotting.plot.Plot at 0x79d1390>
In [51]:
plot_implicit(And(y > x**2 , y < sqrt(x)),(x,-1,1.5),(y,-1,2),title='Intersecao de duas curvas') # podemos fazer algumas operações lógicas
Out[51]:
<sympy.plotting.plot.Plot at 0x6729750>
In [52]:
plot_implicit(Or(And(y > x**2 , y < sqrt(x)),And(y < -x**2 , y > -sqrt(-x))),(x,-1,1.5),(y,-1,2)) # Um pouco mais de operações lógicas
Out[52]:
<sympy.plotting.plot.Plot at 0x7d442d0>
Gráficos paramétricos
In [53]:
from sympy.plotting import plot_parametric
In [54]:
plot_parametric(cos(x), sin(x), (x, 0, 2*pi))
Out[54]:
<sympy.plotting.plot.Plot at 0x79d1110>
In [55]:
plot_parametric(x*cos(x), x*sin(x), (x, 0, 10*pi))
Out[55]:
<sympy.plotting.plot.Plot at 0x6217390>
In [56]:
plot_parametric(cos(x)*cos(x), cos(x)*sin(x), (x, 0, 2*pi))
Out[56]:
<sympy.plotting.plot.Plot at 0x7a6bf90>
In [57]:
plot_parametric(cos(20*x)*cos(x), cos(10*x)*sin(x), (x, 0, 2*pi),axis=False) # Até um pouco de arte da para fazer!
Out[57]:
<sympy.plotting.plot.Plot at 0xb155e50>
In [58]:
pl=plot_parametric(cos(20*x)*cos(x), cos(10*x)*sin(x), (x, 0, 2*pi),axis=False,show=False) pl[0].line_color= lambda a: log(0.001*a) pl.show()