CoCalc Public FilesFÍSICA-EXPERIMENTAL-1-EXE.ipynbOpen with one click!
Author: João Marcello Pereira
Views : 660
Compute Environment: Ubuntu 18.04 (Deprecated)

FÍSICA EXPERIMENTAL - 2020 - PARTE I

Carga Horária: 4h

Prof João Marcello Pereira ([email protected])

INTRODUÇÃO

O CoCalc ("Collaborative Calculation in the cloud") é um sofisticado ambiente on-line colaborativo para cálculo matemático, estatística e ciência de dados, autoria de documentos e computação de propósito geral de código fonte aberto, executado sobre o sistema operacional Ubuntu 18.04.3 LTS e liberado sob a licença GNU Affero General Public License versão 3+. Foi criado em maio de 2017 pelo professor de matemática da Universidade de Washington, William Stein, como uma remodelagem do projeto SageMath Cloud (Versão Web do SageMath para desktop) lançado em abril de 2013. O SageMath é um software matemático livre e de código aberto (open source), desenvolvido sob a licença GPL por uma comunidade de programadores e matemáticos. De acordo com os seus desenvolvedores, o objetivos do SageMath é ser uma alternativa aos principais sistemas proprietários de software matemático como o Magma ® , Maple ® , Mathematica ® e Matlab ® (THE SAGE GROUP, 2017), compatível com Windows ® , MacOS ® e Linux. Entre as características do CoCalc, podemos destacar:

  • Interface gráfica compatível com vários navegadores.
  • Interpretador de comandos baseado no IPython.
  • Computação paralela, usando processadores multinúcleo, multiprocessamento simétrico e computação distribuída.
  • Cálculo simbólico com Maxima e SymPy.
  • Álgebra linear numérica, utilizando GNU Scientific Library, SciPy, NumPy e Julia.
  • Bibliotecas de funções elementares e especiais.
  • Gráficos 2D e 3D de funções simbólicas e dados numéricos.
  • Manipulação de matrizes, incluindo matrizes esparsas.
  • Bibliotecas de estatísticas multivariáveis, usando R e SciPy.
  • Ferramentas para o processamento de imagens, usando Pylab e Python.
  • Bibliotecas para funções de teoria dos números.
  • Filtros para importação e exportação de dados, imagens, vídeo, áudio, CAD e GIS.
  • Suporte para números complexos, aritmética de precisão arbitrária e matemática simbólica.
  • MoinMoin para gerar conteúdo do tipo Wiki.
  • Criação de documentação (Sphinx).
  • Interface para alguns softwares proprietários, como o Mathematica, Magma e Maple.
  • Compartilhamento de projetos e construção de salas de aulas virtuais.

A cronologia do projeto é visualizada na figura abaixo:

COMANDOS BÁSICOS E MATEMÁTICA BÁSICA

COMO USAR OS COMANDOS DO COCALC

Os comandos da linguagem CoCalc são muito parecidos com os comandos do MatLab/Python, porém, não há a necessidade de terminar um comando com o " ; ". Vejamos alguns pontos interessantes:

  • Ponto e virgula ao final do comando oculta o resultado;
  • Comentários são iniciados com #
  • CoCalc é "Case-Sensitive" F e f são diferentes;
  • Não é necessário digitar todo o comando/função, basta digitar uma parte da comando/função e teclar TAB para completar.
  • TAB também mostra outros comandos/Funções associados ao objeto, basta utilizar "OBJETO.<TAB>"
  • Textos em Latex podem ser inseridos em células do tipo "Text" do Jupyter na forma $Latex$
  • Sempre verifique o status da CPU e memória do projeto. Caso ultrapasse o limite do projeto ou apresente instabilidade, execute um reload da página ou restart kernel.

Comandos preliminares

In [2]:
# informações sobre a versão e lançamento do kernel version()
'SageMath version 9.0, Release Date: 2020-01-01'
In [4]:
# Ajuda (?função ou função?)

Matemática Básica

Operação Matemática

Sintaxe CoCalc

Exemplo

Resultado

Valor Absoluto de xx

abs( x )

abs( -2 )

2

Raiz quadrada x x

sqrt( x )

sqrt(225)

15

Raíz de xx ordem nn

x**( 1/n ) ou x^( 1/n )

8^( 1/ 3 )

2

Exponencial na Base ee

exp( x )

exp( 2 )

e^2

Logaritmo Natural de xx

ln( x )

ln( e )

1

Logaritmo de xx na Base bb

log( x , b )

log( 1024,2 )

10

Seno de x sin( x ) sin( pi ) 1
Cosseno de x cos( x ) cos( pi/2 ) 0
Tangente de x tan( x ) tan( 3*pi/4 ) -1
Secante de x sec( x ) sec( pi/3 ) 2
Cosecante de x csc( x ) csc( pi/3 ) 2/3*sqrt(3)
Cotangente cot ( x ) cot( pi/3 ) 1/3*sqrt(3)

Coeficiente Binomial de nn sobre rr

binomial( n, r )

binomial( 5, 2 )

10

Fatorial de nn

factorial( n )

factorial( 5 )

120

Fatoração de primo de nn

factor( n )

factor( 12 )

2^2*3

MDC de aa e bb

gcd( a, b)

gcd( 12, 16 )

4

Valor Máximo

max( x,y,z w,... )

max( 1, 2.7, 4.8 )

4.8

Valor Mínimo

min( x,y,z w,... )

min( 1, 2.7, 4.8 )

2.7

Menor Inteiro maior ou igual a xx

ceil( x )

ceil( 1.4 )

2

Maior Inteiro menor ou igual a xx

floor( x )

floor( pi )

3

Inteiro mais próximo ou igual a xx

round( x )

round( 2.8456 )

3

Parte inteira xx

int( x )

Int ( 2.8456 )

2

Número aleatório maior ou igual a zero e menor que 1

random()

random()

0.7311469958220904

Número inteiro aleatório em [a,b][a,b]

randint( a , b )

randint(1, 100 )

46

In [9]:
# matematica simples (adicao, muliplicacao, divisao , potenciacao, radiciação) 25^0.5
5.00000000000000
In [13]:
# potencia de 10 5e2
500.000000000000
In [14]:
# exponencial e^3 ou exp(valor) exp(2)
e^2

Cálculo trigonometrico/Hiperbólico

sin(x) cos(x) tan(x) cot(x) sec(x) csc(x)

sinh(x) cosh(x) tanh(x) coth(x) sech(x) csch(x)

asin(x) acos(x) atan(x) acot(x) asec(x) acsc(x) acoth(x) asech(x) acsch(x)

In [24]:
# radiandos sin(pi/2)
1

Cálculo Logaritmo

In [13]:
# Função exponencial natural em x: exp(numero)
In [25]:
# log(numero, base) log(100, 10)
2

Memória Células

In [26]:
# Qual dado de entrada da 5ª Célula? In[25]
'# log(numero, base)\n\nlog(Integer(100), Integer(10))'
In [27]:
# Qual dado de saída da 5ª Célula? Out[25]
2

Cálculo anteior

In [28]:
# Expressão qualquer 10^2 + log(100, 10)
102
In [34]:
# Calculo anterior n(_)
102.000000000000
In [25]:
# Calculo anterior numerico

Calcular o tempo de processamento

In [35]:
%%time 2*log(100) + sin(50000) / sqrt(sqrt(100))^exp(20)
CPU times: user 1.39 ms, sys: 0 ns, total: 1.39 ms Wall time: 1.41 ms
sin(50000)/10^(1/2*e^20) + 4*log(10)
In [36]:
%%timeit 2*log(100) + sin(50000) / sqrt(sqrt(100))^exp(20)
10000 loops, best of 5: 119 µs per loop

Precisão Numérica

In [37]:
# divisão 1.9/6 1.9/6
0.316666666666667
In [40]:
# Precisão numérica algarismos significativos n(1.9/6, digits=5)
0.31667
In [41]:
# Fixar Notação científica para todos os resultados RR.scientific_notation(True)
In [42]:
1.9/6
3.16666666666667e-1
In [45]:
# Fixar Precisão Numérica por número de bits (padrão = 53) e notação científica para todos os resultados RealNumber = RealField(20, sci_not = True)
In [46]:
1.9/6
3.1667e-1

Comandos de impressão

In [59]:
sqrt(2.0)*pi
1.41421318054199⋅π
In [51]:
# print print(sqrt(2.0)*pi)
1.4142e0*pi
In [52]:
# display display(sqrt(2.0)*pi)
1.4142e0*pi
In [54]:
# show show(sqrt(2.0)*pi)
1.4142×100π1.4142 \times 10^{0} \, \pi

Latex

(a1+a2+...+an) \sum{(a_1 + a_2 + ...+a_n)}

In [46]:
# expressão para latex

cole o texto aqui

log(x22x)\log\left(x^{2} - \frac{2}{x}\right)

In [58]:
%display unicode_art
In [61]:
# Input num = int(input("escolha um valor de 0 a 10")) print('quadrado =', num^2)
escolha um valor de 0 a 10
quadrado = 81

Variáveis

O Python é uma linguagem de tipagem dinâmica, dessa form uma variável possui um valor associado enquanto durar o processamento e pode variar em tempo e execução. Para associar o valor a uma variável, basta utilizar "=". Para eliminar o valor de uma variável, use reset() para todas as variáveis ou reset('var1, var2...') para variáveis específicas.

In [65]:
# Definir as variáveis x(inteiro), y(real) e z(racional) x = 2 y = 2.5 z = 4/3
In [69]:
# imprimir as variáveis x, y, z
( 2, 2.5000e0, 4/3 )
In [70]:
# Verificar o tipo de x type(x)
<class 'sage.rings.integer.Integer'>
In [71]:
# Verificar o tipo z type(y)
<class 'sage.rings.real_mpfr.RealNumber'>
In [72]:
# Resetar variável z reset('z')
In [74]:
# Resetar todas as variaveis reset()
In [6]:
cos(x).subs(x==pi)
-1
In [10]:
angl
--------------------------------------------------------------------------- NameError Traceback (most recent call last) <ipython-input-10-78371c365ff2> in <module>() ----> 1 angle_measurements('degrees') 2 cos(RealNumber('60.')) NameError: name 'angle_measurements' is not defined
In [75]:
# variável simbólica w var('w')
w
In [80]:
# Expressão (x+x)/(w+w+w)
2⋅x ─── 3⋅w

Strings

Strings são sequências de caracteres, sejam eles letras, números, espaços, caracteres especiais, e etc., e assim como os tipos numéricos vistos anteriormente, strings também são imutáveis. Strings podem ser delimitadas por aspas simples, duplas ou triplas.

s t r i n g

0 1 2 3 4 5

In [81]:
# definir string secitec 2019 str1 = 'secitec 2019'
In [84]:
# imprimir os caracteres da posição 0 a 5 str1[0:10]
secitec 20
In [87]:
# imprimir os caracteres da posição 5 até o fim str1[5:]
ec 2019

Listas

Uma lista é uma coleção de elementos.

[Elemento 1, Elemento 2, Elemento 3, Elemento 4, Elemento 5, ..., Elemento n]

        0        ,        1        ,        2        ,        3        ,        4        ,...,     n~~~~~~~~0~~~~~~~~,~~~~~~~~1~~~~~~~~,~~~~~~~~2~~~~~~~~,~~~~~~~~3~~~~~~~~,~~~~~~~~4~~~~~~~~,...,~~~~~n

In [1]:
# criar listas l1 e l2 l1 = [1, 2, 3, 4] l2 = [5.5, 10.5, 12.3, 8.8] l1, l2
([1, 2, 3, 4], [5.50000000000000, 10.5000000000000, 12.3000000000000, 8.80000000000000])
In [93]:
# Comprimento lista len(l2)
4
In [97]:
# Adicionar elemento final lista l1.append(78) l1
[ 1, 2, 3, 4, 9, 9, 9, 78 ]
In [99]:
# Alterando um elemento l1[2] = 34 l1
[ 1, 2, 34, 4, 9, 9, 9, 78 ]
In [100]:
# adiciona mais de um elemento ao final da lista l1.extend([99,77]) l1
[ 1, 2, 34, 4, 9, 9, 9, 78, 99, 77 ]
In [101]:
# retirando elemento do final da lista l1.pop()
77
In [102]:
l1
[ 1, 2, 34, 4, 9, 9, 9, 78, 99 ]
In [103]:
# inserir um elemento em uma posição específica l1.insert(4, 500)
In [104]:
l1
[ 1, 2, 34, 4, 500, 9, 9, 9, 78, 99 ]
In [105]:
# retirar elemento específico. l1.remove(500) l1
[ 1, 2, 34, 4, 9, 9, 9, 78, 99 ]
In [106]:
# valor máximo da lista max(l1)
99
In [107]:
# valor mínimo min(l1)
1
In [114]:
l2
[ 5.50000000000000e0, 1.05000000000000e1, 1.23000000000000e1, 8.80000000000000e0 ]
In [14]:
%display unicode_art
In [9]:
# formar pares zip(l1, l2)
[(1,5.50000000000000),(2,10.5000000000000),(3,12.3000000000000),(4,8.80000000000000)]\left[\left(1, 5.50000000000000\right), \left(2, 10.5000000000000\right), \left(3, 12.3000000000000\right), \left(4, 8.80000000000000\right)\right]
In [15]:
# fatiamento de listas l1[0:2]
[ 1, 2 ]
In [16]:
# fatiamento de listas l1[:2]
[ 1, 2 ]
In [ ]:
# fatiamento de listas

Sequencias

Uma sequencia é uma lista na forma sequencial na forma de numeros inteiros ou decimais (ponto flutuante) dada pelo comando range. Os comandos vistos (append, remove, ...) também valem para range

In [17]:
# Range inteiro de 10 elementos inteiros s1 = range(10) s1
[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
In [19]:
# Range de 0 a 10, tomados 2 a 2 s2 = range(0, 10, 2) s2
[ 0, 2, 4, 6, 8 ]
In [21]:
# Range de 50 a 0, tomados de 10 a 10 s3 = range(50, 0, -10) s3
[ 50, 40, 30, 20, 10 ]
In [23]:
# Range do tipo sequencia formada por numeros Decimais (ponto flutuante) de 0 a 1, tomados de 0.25 s4 = srange(0, 1, 0.25) s4
[ 0.000000000000000, 0.250000000000000, 0.500000000000000, 0.750000000000000 ]

Lista aninhada. Formatação da lista como matriz

Lista = [ a1, a2, a3, ... , an] sendo a1, a2, a3, ... , an elementos únicos ou outra lista, matriz, etc.

In [27]:
# lista aninhadas l1 = [[4,5], ['a','b','c'], 6] l1
[ [ 4, 5 ], [ a, b, c ], 6 ]
In [29]:
l1[1][1]
b

Vetores

In [32]:
# Criando um vetor 2d v2d1 e v2d2 v2d1 = vector([1,3]) v2d2 = vector([-2, 4])
In [33]:
# Gráfico v2d1 plot(v2d2)
In [37]:
v2ds = v2d1 +v2d2
In [39]:
# Gráfico v2d1, v2d2 e resultante plot(v2d1) + plot(v2d2, color = 'red') + plot(v2ds, color = 'black')
In [40]:
# Criando vetores 3d v3d1 e v3d2 v3d1 = vector([1,2,3])
In [44]:
# Gráfico v3d1 plot(v3d1)
In [45]:
# Gráfico v2d1, v2d2 e resultante
In [ ]:

Matrizes

In [7]:
# Definir as matrizes M1 e M2
In [26]:
# Imprimir as matrizes M1 e M2
In [8]:
# Gráfico M1
In [109]:
# soma/subtração de matrizes

RESOLUÇÃO DE SISTEMAS LINEARES

_

In [49]:
%display unicode_art
In [9]:
# # divisão usando M.Vv = Vs

FIM