Project: Física-Experimental-SageMath-Cocalc

Path: FÍSICA-EXPERIMENTAL-1-EXE.ipynb

Views: ⁶⁹⁴

Kernel: SageMath 8.9

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 $x$	abs( x )	abs( -2 )	2
Raiz quadrada $x$	sqrt( x )	sqrt(225)	15
Raíz de $x$ ordem $n$	x**( 1/n ) ou x^( 1/n )	8^( 1/ 3 )	2
Exponencial na Base $e$	exp( x )	exp( 2 )	e^2
Logaritmo Natural de $x$	ln( x )	ln( e )	1
Logaritmo de $x$ na Base $b$	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 $n$ sobre $r$	binomial( n, r )	binomial( 5, 2 )	10
Fatorial de $n$	factorial( n )	factorial( 5 )	120
Fatoração de primo de $n$	factor( n )	factor( 12 )	2^2*3
MDC de $a$ e $b$	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 $x$	ceil( x )	ceil( 1.4 )	2
Maior Inteiro menor ou igual a $x$	floor( x )	floor( pi )	3
Inteiro mais próximo ou igual a $x$	round( x )	round( 2.8456 )	3
Parte inteira $x$	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]$	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)

Latex

$\sum{(a_1 + a_2 + ...+a_n)}$

In [46]:

# expressão para latex

cole o texto aqui

$\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$

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)

In [15]:

# fatiamento de listas

l1[0:2]

[ 1, 2 ]

In [16]:

# fatiamento de listas

l1[:2]

[ 1, 2 ]

In [0]:

# 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 [0]:

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