SymPy - Guia rápido
SymPy é uma biblioteca Python para realizar computação simbólica. É umcomputer algebra system(CAS) que pode ser usado como um aplicativo independente, como uma biblioteca para outros aplicativos. Sua sessão ao vivo também está disponível emhttps://live.sympy.org/. Por ser uma biblioteca Python pura, pode ser usada como modo interativo e como aplicativo programático. SymPy agora se tornou uma biblioteca simbólica popular para o ecossistema científico Python.
SymPy tem uma ampla gama de recursos aplicáveis no campo da aritmética simbólica básica, cálculo, álgebra, matemática discreta, física quântica, etc. SymPy é capaz de formatar os resultados em diversos formatos, incluindo LaTeX, MathML, etc. SymPy é distribuído em Nova licença BSD. Uma equipe de desenvolvedores liderada porOndřej Čertík e Aaron Meurer publicou a primeira versão do SymPy em 2007. Sua versão atual é 1.5.1.
Algumas das áreas de aplicação do SymPy são -
- Polynomials
- Calculus
- Matemática discreta
- Matrices
- Geometry
- Plotting
- Physics
- Statistics
- Combinatorics
SymPy tem uma importante biblioteca de pré-requisitos chamada mpmath. É uma biblioteca Python para aritmética real e complexa de ponto flutuante com precisão arbitrária. No entanto, o instalador de pacote do Python, PIP, o instala automaticamente quando o SymPy é instalado da seguinte maneira -
pip install sympyOutras distribuições Python, como Anaconda, Enthought Canopy, etc., podem já ter o SymPy empacotado. Para verificar, você pode digitar o seguinte no prompt do Python -
>>> import sympy
>>> sympy.__version__E você obtém a saída abaixo como a versão atual do sympy -
'1.5.1'
O código-fonte do pacote SymPy está disponível em https://github.com/sympy/sympy.
A computação simbólica se refere ao desenvolvimento de algoritmos para manipular expressões matemáticas e outros objetos matemáticos. A computação simbólica integra a matemática com a ciência da computação para resolver expressões matemáticas usando símbolos matemáticos. Um sistema de álgebra computacional (CAS) como o SymPy avalia as expressões algébricas exatamente (não aproximadamente) usando os mesmos símbolos que são usados no método manual tradicional. Por exemplo, calculamos a raiz quadrada de um número usando o módulo matemático do Python, conforme mostrado abaixo -
>>> import math
>>> print (math.sqrt(25), math.sqrt(7))A saída para o snippet de código acima é a seguinte -
5.0 2.6457513110645907
Como você pode ver, a raiz quadrada de 7 é calculada aproximadamente. Mas no SymPy raízes quadradas de números que não são quadrados perfeitos são deixadas sem avaliação por padrão, conforme mostrado abaixo -
>>> import sympy
>>> print (sympy.sqrt(7))A saída para o snippet de código acima é a seguinte -
sqrt(7)
É possível simplificar e mostrar o resultado da expressão simbolicamente com o trecho de código abaixo -
>>> import math
>>> print (math.sqrt(12))A saída para o snippet de código acima é a seguinte -
3.4641016151377544
Você precisa usar o trecho de código abaixo para executar o mesmo usando o sympy -
##sympy output
>>> print (sympy.sqrt(12))E a saída para isso é a seguinte -
2*sqrt(3)
O código SymPy, quando executado no notebook Jupyter, usa a biblioteca MathJax para renderizar símbolos matemáticos na forma LatEx. É mostrado no snippet de código abaixo -
>>> from sympy import *
>>> x=Symbol ('x')
>>> expr = integrate(x**x, x)
>>> exprAo executar o comando acima no shell python, a seguinte saída será gerada -
Integral(x**x, x)Que é equivalente a
$\int \mathrm{x}^{x}\,\mathrm{d}x$
A raiz quadrada de um quadrado não perfeito pode ser representada por Latex da seguinte forma, usando o símbolo tradicional -
>>> from sympy import *
>>> x=7
>>> sqrt(x)A saída para o snippet de código acima é a seguinte -
$\sqrt7$
Um sistema de computação simbólica como o SymPy faz todos os tipos de cálculos (como derivadas, integrais e limites, resolve equações, trabalha com matrizes) simbolicamente. O pacote SymPy possui diferentes módulos que suportam plotagem, impressão (como LATEX), física, estatística, combinatória, teoria dos números, geometria, lógica, etc.
O módulo principal do pacote SymPy contém a classe Number que representa os números atômicos. Esta classe possui duas subclasses: Float e Rational class. A classe Rational é posteriormente estendida pela classe Integer.
A classe float representa um número de ponto flutuante de precisão arbitrária.
>>> from sympy import Float
>>> Float(6.32)A saída para o snippet de código acima é a seguinte -
6.32
SymPy pode converter um inteiro ou uma string em float.
>>> Float(10)10.0
Float('1.33E5')# scientific notation133000.0
Ao converter para flutuante, também é possível especificar o número de dígitos para precisão, conforme fornecido abaixo -
>>> Float(1.33333,2)A saída para o snippet de código acima é a seguinte -
1.3
A representação de um número (p / q) é representada como objeto da classe Racional com q sendo um número diferente de zero.
>>> Rational(3/4)A saída para o snippet de código acima é a seguinte -
$\frac{3}{4}$
Se um número de ponto flutuante é passado para o construtor Rational (), ele retorna o valor subjacente de sua representação binária
>>> Rational(0.2)A saída para o snippet de código acima é a seguinte -
$\frac{3602879701896397}{18014398509481984}$
Para uma representação mais simples, especifique a limitação do denominador.
>>> Rational(0.2).limit_denominator(100)A saída para o snippet de código acima é a seguinte -
$\frac{1}{5}$
Quando uma string é passada para o construtor Rational (), um número racional de precisão arbitrária é retornado.
>>> Rational("3.65")A saída para o snippet de código acima é a seguinte -
$\frac{73}{20}$
O objeto Rational também pode ser obtido se dois argumentos numéricos forem passados. As partes do numerador e do denominador estão disponíveis como propriedades.
>>> a=Rational(3,5)
>>> print (a)
>>> print ("numerator:{}, denominator:{}".format(a.p, a.q))A saída para o snippet de código acima é a seguinte -
3/5
numerator:3, denominator:5
>>> aA saída para o snippet de código acima é a seguinte -
$\frac{3}{5}$
A classe inteira em SymPy representa um número inteiro de qualquer tamanho. O construtor pode aceitar um número Float ou Rational, mas a parte fracionária é descartada
>>> Integer(10)A saída para o snippet de código acima é a seguinte -
10
>>> Integer(3.4)A saída para o snippet de código acima é a seguinte -
3
>>> Integer(2/7)A saída para o snippet de código acima é a seguinte -
0
SymPy tem um RealNumberclasse que atua como alias para Float. SymPy também define Zero e One como classes singleton acessíveis com S.Zero e S.One respectivamente, conforme mostrado abaixo -
>>> S.ZeroO resultado é o seguinte -
0
>>> S.OneO resultado é o seguinte -
1
Outros objetos de número Singleton predefinidos são Half, NaN, Infinity e ImaginaryUnit
>>> from sympy import S
>>> print (S.Half)O resultado é o seguinte -
½
>>> print (S.NaN)O resultado é o seguinte -
nan
O Infinity está disponível como um objeto de símbolo oo ou S.Infinity
>>> from sympy import oo
>>> ooA saída para o snippet de código acima é a seguinte -
$\infty$
>>> S.InfinityA saída para o snippet de código acima é a seguinte -
$\infty$
O número ImaginaryUnit pode ser importado como símbolo I ou acessado como S.ImaginaryUnit e representa a raiz quadrada de -1
>>> from sympy import I
>>> IAo executar o trecho de código acima, você obtém a seguinte saída -
i
>>> S.ImaginaryUnitA saída do snippet acima é a seguinte -
i
>>> from sympy import sqrt
>>> i=sqrt(-1)
>>> i*iAo executar o trecho de código acima, você obtém a seguinte saída -
-1
Symbolé a classe mais importante na biblioteca SymPy. Conforme mencionado anteriormente, os cálculos simbólicos são feitos com símbolos. Variáveis SymPy são objetos da classe Symbols.
O argumento da função Symbol () é uma string contendo um símbolo que pode ser atribuído a uma variável.
>>> from sympy import Symbol
>>> x=Symbol('x')
>>> y=Symbol('y')
>>> expr=x**2+y**2
>>> exprO trecho de código acima fornece uma saída equivalente à expressão abaixo -
$x^2 + y^2$
Um símbolo pode ter mais de um alfabeto.
>>> s=Symbol('side')
>>> s**3O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$side^3$
SymPy também tem um Symbols()função que pode definir vários símbolos de uma vez. String contém nomes de variáveis separados por vírgula ou espaço.
>>> from sympy import symbols
>>> x,y,z=symbols("x,y,z")No módulo abc do SymPy, todos os alfabetos latino e grego são definidos como símbolos. Portanto, em vez de instanciar o objeto Symbol, esse método é conveniente.
>>> from sympy.abc import x,y,zNo entanto, os nomes C, O, S, I, N, E e Qsão símbolos predefinidos. Além disso, os símbolos com mais de um alfabeto não são definidos no módulo abc, para o qual você deve usar o objeto Symbol como acima. O módulo abc define nomes especiais que podem detectar definições no namespace SymPy padrão. clash1 contém letras únicas e clash2 tem símbolos conflitantes de várias letras
>>> from sympy.abc import _clash1, _clash2
>>> _clash1A saída do snippet acima é a seguinte -
{'C': C, 'O': O, 'Q': Q, 'N': N, 'I': I, 'E': E, 'S': S}
>>> _clash2A saída do snippet acima é a seguinte -
{'beta': beta, 'zeta': zeta, 'gamma': gamma, 'pi': pi}
Os símbolos indexados podem ser definidos usando uma sintaxe semelhante à função range (). Os intervalos são indicados por dois pontos. O tipo de intervalo é determinado pelo caractere à direita dos dois pontos. Se itr for um dígito, todos os dígitos contíguos à esquerda são considerados o valor inicial não negativo. Todos os dígitos contíguos à direita são considerados como 1 maior que o valor final.
>>> from sympy import symbols
>>> symbols('a:5')A saída do snippet acima é a seguinte -
(a0, a1, a2, a3, a4)
>>> symbols('mark(1:4)')A saída do snippet acima é a seguinte -
(mark1, mark2, mark3)
Uma das operações mais básicas a serem realizadas em uma expressão matemática é a substituição. A função subs () no SymPy substitui todas as ocorrências do primeiro parâmetro pelo segundo.
>>> from sympy.abc import x,a
>>> expr=sin(x)*sin(x)+cos(x)*cos(x)
>>> exprO trecho de código acima fornece uma saída equivalente à expressão abaixo -
$\sin^2(x)+\cos^2(x)$
>>> expr.subs(x,a)O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$\sin^2(a)+\cos^2(a)$
Esta função é útil se quisermos avaliar uma determinada expressão. Por exemplo, queremos calcular os valores da expressão seguinte substituindo a por 5.
>>> expr=a*a+2*a+5
>>> exprO trecho de código acima fornece uma saída equivalente à expressão abaixo -
$a^2 + 2a + 5$
expr.subs(a,5)O trecho de código acima fornece a seguinte saída -
40
>>> from sympy.abc import x
>>> from sympy import sin, pi
>>> expr=sin(x)
>>> expr1=expr.subs(x,pi)
>>> expr1O trecho de código acima fornece a seguinte saída -
0
Esta função também é usada para substituir uma subexpressão por outra subexpressão. No exemplo a seguir, b é substituído por a + b.
>>> from sympy.abc import a,b
>>> expr=(a+b)**2
>>> expr1=expr.subs(b,a+b)
>>> expr1O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$(2a + b)^2$
A função sympify () é usada para converter qualquer expressão arbitrária de forma que possa ser usada como uma expressão SymPy. Objetos Python normais, como objetos inteiros, são convertidos em SymPy. Inteiros, etc., strings também são convertidos em expressões SymPy.
>>> expr="x**2+3*x+2"
>>> expr1=sympify(expr)
>>> expr1
>>> expr1.subs(x,2)O trecho de código acima fornece a seguinte saída -
12
Qualquer objeto Python pode ser convertido em objeto SymPy. No entanto, como a conversão usa a função eval () internamente, a expressão não higienizada não deve ser usada, caso contrário, SympifyError é gerado.
>>> sympify("x***2")
---------------------------------------------------------------------------SympifyError: Sympify da expressão 'não foi possível analisar' x *** 2 '' falhou, devido à exceção sendo levantada.
A função sympify () leva os seguintes argumentos: * strict: o padrão é False. Se definido como True, apenas os tipos para os quais uma conversão explícita foi definida são convertidos. Caso contrário, SympifyError é gerado. * avaliar: Se definido como False, a aritmética e os operadores serão convertidos em seus equivalentes SymPy sem avaliar a expressão.
>>> sympify("10/5+4/2")O trecho de código acima fornece a seguinte saída -
4
>>> sympify("10/5+4/2", evaluate=False)O trecho de código acima fornece a seguinte saída -
$\frac{10}{5}+\frac{4}{2}$
Esta função avalia uma determinada expressão numérica até uma determinada precisão de ponto flutuante de até 100 dígitos. A função também recebe subsparâmetro, um objeto de dicionário de valores numéricos para símbolos. Considere a seguinte expressão
>>> from sympy.abc import r
>>> expr=pi*r**2
>>> exprO trecho de código acima fornece uma saída equivalente à expressão abaixo -
$\Pi{r^2}$
Para avaliar a expressão acima usando a função evalf (), substituindo r por 5
>>> expr.evalf(subs={r:5})O trecho de código acima fornece a seguinte saída -
78.5398163397448
Por padrão, a precisão do ponto flutuante é de até 15 dígitos que podem ser substituídos por qualquer número até 100. A expressão a seguir é avaliada com até 20 dígitos de precisão.
>>> expr=a/b
>>> expr.evalf(20, subs={a:100, b:3})O trecho de código acima fornece a seguinte saída -
33.333333333333333333
A função lambdify traduz expressões SymPy em funções Python. Se uma expressão deve ser avaliada em um grande intervalo de valores, a função evalf () não é eficiente. lambdify atua como uma função lambda, exceto que converte os nomes SymPy para os nomes da biblioteca numérica fornecida, geralmente NumPy. Por padrão, lambdify em implementações na biblioteca padrão de matemática.
>>> expr=1/sin(x)
>>> f=lambdify(x, expr)
>>> f(3.14)O trecho de código acima fornece a seguinte saída -
627.8831939138764
A expressão pode ter mais de uma variável. Nesse caso, o primeiro argumento para a função lambdify () é uma lista de variáveis, seguida pela expressão a ser avaliada.
>>> expr=a**2+b**2
>>> f=lambdify([a,b],expr)
>>> f(2,3)O trecho de código acima fornece a seguinte saída -
13
No entanto, para aproveitar a biblioteca numpy como backend numérico, temos que definir o mesmo como um argumento para a função lambdify ().
>>> f=lambdify([a,b],expr, "numpy")Usamos duas matrizes numpy para dois argumentos aeb na função acima. O tempo de execução é consideravelmente rápido no caso de arrays entorpecidos.
>>> import numpy
>>> l1=numpy.arange(1,6)
>>> l2=numpy.arange(6,11)
>>> f(l1,l2)O trecho de código acima fornece a seguinte saída -
array([ 37, 53, 73, 97, 125], dtype=int32)
As funções booleanas são definidas em sympy.basic.booleanarg module. É possível construir expressões booleanas com os operadores python padrão & (And), | (Ou), ~ (Não), bem como com >> e <<. Expressões booleanas herdam da classe Basic definida no módulo principal do SymPy.
Função BooleanTrue
Esta função é equivalente a True como no núcleo do Python. Ele retorna um singleton que pode ser recuperado por S.true.
>>> from sympy import *
>>> x=sympify(true)
>>> x, S.trueO trecho de código acima fornece a seguinte saída -
(Verdade verdade)
Função BooleanFalse
Da mesma forma, esta função é equivalente a Boolean False em Python e pode ser acessada por S.false
>>> from sympy import *
>>> x=sympify(false)
>>> x, S.falseO trecho de código acima fornece a seguinte saída -
(Falso, Falso)
E função
Uma função lógica AND avalia seus dois argumentos e retorna False se algum deles for False. A função emula o operador &.
>>> from sympy import *
>>> from sympy.logic.boolalg import And
>>> x,y=symbols('x y')
>>> x=True
>>> y=True
>>> And(x,y), x"&"yO trecho de código acima fornece a seguinte saída -
(Verdade verdade)
>>> y=False
>>> And(x,y), x"&"yO trecho de código acima fornece a seguinte saída -
(Falso, Falso)
Ou função
Esta função avalia dois argumentos booleanos e retorna True se algum deles for True. O | operador convenientemente emula seu comportamento.
>>> from sympy import *
>>> from sympy.logic.boolalg import Or
>>> x,y=symbols('x y')
>>> x=True
>>> y=False
>>> Or(x,y), x|yO trecho de código acima fornece a seguinte saída -
(Verdade verdade)
>>> x=False
>>> y=False
>>> Or(x,y), x|yO trecho de código acima fornece a seguinte saída -
(Falso, Falso)
Não funciona
Uma função Logical Not resulta na negação do argumento booleano. Retorna True se seu argumento for False e retorna False se True. O operador ~ executa a operação semelhante à função Not. É mostrado no exemplo abaixo -
>>> from sympy import *
>>> from sympy.logic.boolalg import Or, And, Not
>>> x,y=symbols('x y')
>>> x=True
>>> y=False
>>> Not(x), Not(y)O trecho de código acima fornece a seguinte saída -
(Falso verdadeiro)
>>> Not(And(x,y)), Not(Or(x,y))O trecho de código acima fornece a seguinte saída -
(Verdadeiro falso)
Função Xor
A função Lógica XOR (OU exclusivo) retorna Verdadeiro se um número ímpar de argumentos for Verdadeiro e o resto for Falso e retorna Falso se um número par de argumentos for Verdadeiro e o resto for Falso. Operação semelhante é executada pelo operador ^.
>>> from sympy import *
>>> from sympy.logic.boolalg import Xor
>>> x,y=symbols('x y')
>>> x=True
>>> y=False
>>> Xor(x,y), x^yO trecho de código acima fornece a seguinte saída -
(Verdade verdade)
>>> a,b,c,d,e=symbols('a b c d e')
>>> a,b,c,d,e=(True, False, True, True, False)
>>> Xor(a,b,c,d,e)O trecho de código acima fornece a seguinte saída -
Verdadeiro
No caso acima, três (número ímpar) argumentos são Verdadeiros, portanto, Xor retorna verdadeiro. No entanto, se o número de argumentos True for par, resulta em False, conforme mostrado abaixo -
>>> a,b,c,d,e=(True, False, False, True, False)
>>> Xor(a,b,c,d,e)O trecho de código acima fornece a seguinte saída -
Falso
Função Nand
Esta função executa a operação lógica NAND. Ele avalia seus argumentos e retorna True se algum deles for False, e False se todos eles forem True.
>>> from sympy import *
>>> from sympy.logic.boolalg import Nand
>>> a,b,c=symbols('a b c')
>>> a,b,c=(True, False, True)
>>> Nand(a,b,c), Nand(a,c)O trecho de código acima fornece a seguinte saída -
(Verdadeiro falso)
Nem função
Esta função executa a operação NOR Lógica. Ele avalia seus argumentos e retorna False se algum deles for True, e True se todos eles forem False.
>>> from sympy import *
>>> from sympy.logic.boolalg import Nor
>>> a,b,c=symbols('a b c')
>>> a,b,c=(True, False, True)
>>> Nor(a,b,c), Nor(a,c)O trecho de código acima fornece a seguinte saída -
(Falso, Falso)
Observe que embora o SymPy forneça o operador ^ para Xor, ~ para Not, | para Or e & para funções And por conveniência, seu uso normal em Python é como operadores bit a bit. Portanto, se os operandos forem inteiros, os resultados serão diferentes.
Função equivalente
Esta função retorna relação de equivalência. Equivalente (A, B) é verdadeiro se e somente se A e B são ambos verdadeiros ou falsos. A função retorna True se todos os argumentos forem logicamente equivalentes. Caso contrário, retorna False.
>>> from sympy import *
>>> from sympy.logic.boolalg import Equivalent
>>> a,b,c=symbols('a b c')
>>> a,b,c=(True, False, True)
>>> Equivalent(a,b), Equivalent(a,c)O trecho de código acima fornece a seguinte saída -
(Falso verdadeiro)
Função ITE
Esta função atua como a cláusula If then else em uma linguagem de programação .ITE (A, B, C) avalia e retorna o resultado de B se A for verdadeiro, caso contrário, retorna o resultado de C. Todos os argumentos devem ser booleanos.
>>> from sympy import * >>> from sympy.logic.boolalg import ITE >>> a,b,c=symbols('a b c') >>> a,b,c=(True, False, True)
>>> ITE(a,b,c), ITE(a,c,b)O trecho de código acima fornece a seguinte saída -
(Falso verdadeiro)
O módulo de suposições no pacote SymPy contém ferramentas para extrair informações sobre expressões. O módulo define a função ask () para este propósito.
sympy.assumptions.ask(property)As propriedades a seguir fornecem informações úteis sobre uma expressão -
algebraic(x)
Para ser algébrico, um número deve ser a raiz de uma equação polinomial diferente de zero com coeficientes racionais. √2 porque √2 é uma solução para x2 - 2 = 0, então é algébrico.
complex(x)
Predicado de número complexo. É verdade se e somente se x pertencer ao conjunto de números complexos.
composite(x)
O predicado de número composto retornado por ask (Q.composite (x)) é verdadeiro se e somente se x for um inteiro positivo e tiver pelo menos um divisor positivo diferente de 1 e o próprio número.
even, odd
O ask () retorna verdadeiro de x está no conjunto de números pares e no conjunto de números ímpares, respectivamente.
imaginary
Esta propriedade representa o predicado do número imaginário. É verdade se x pode ser escrito como um número real multiplicado pela unidade imaginária I.
integer
Esta propriedade retornada por Q.integer (x) retorna verdadeiro de x pertencer ao conjunto de números pares.
rational, irrational
Q.irrational (x) é verdadeiro se e somente se x for qualquer número real que não pode ser expresso como uma proporção de inteiros. Por exemplo, pi é um número irracional.
positive, negative
Predicados para verificar se o número é positivo ou negativo
zero, nonzero
Predicados para verificar se um número é zero ou não
>>> from sympy import *
>>> x=Symbol('x')
>>> x=10
>>> ask(Q.algebraic(pi))
False
>>> ask(Q.complex(5-4*I)), ask( Q.complex(100))
(True, True)
>>> x,y=symbols("x y")
>>> x,y=5,10
>>> ask(Q.composite(x)), ask(Q.composite(y))
(False, True)
>>> ask(Q.even(x)), ask(Q.even(y))
(False, True)
>>> x,y= 2*I, 4+5*I
>>> ask(Q.imaginary(x)), ask(Q.imaginary(y))
(True, False)
>>> x,y=5,10
>>> ask(Q.even(x)), ask(Q.even(y)), ask(Q.odd(x)), ask(Q.odd(y))
(False, True, True, False)
>>> x,y=5,-5
>>> ask(Q.positive(x)), ask(Q.negative(y)), ask(Q.positive(x)), ask(Q.negative(y))
(True, True, True, True)
>>> ask(Q.rational(pi)), ask(Q.irrational(S(2)/3))
(False, False)
>>> ask(Q.zero(oo)), ask(Q.nonzero(I))
(False, False)Sympy tem uma capacidade poderosa de simplificar expressões matemáticas. Existem muitas funções no SymPy para realizar vários tipos de simplificação. Uma função geral chamada simplify () tenta chegar à forma mais simples de uma expressão.
simplificar
Esta função é definida no módulo sympy.simplify. simplify () tenta aplicar heurísticas inteligentes para tornar a expressão de entrada “mais simples”. O código a seguir mostra a expressão simplificada$sin^2(x)+cos^2(x)$.
>>> from sympy import *
>>> x=Symbol('x')
>>> expr=sin(x)**2 + cos(x)**2
>>> simplify(expr)O trecho de código acima fornece a seguinte saída -
1
expandir
O expand () é uma das funções de simplificação mais comuns no SymPy, usado na expansão de expressões polinomiais. Por exemplo -
>>> a,b=symbols('a b')
>>> expand((a+b)**2)O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$a^2 + 2ab + b^2$
>>> expand((a+b)*(a-b))O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$a^2 - b^2$
A função expand () torna as expressões maiores, não menores. Normalmente este é o caso, mas frequentemente uma expressão ficará menor ao chamar expand () nela.
>>> expand((x + 1)*(x - 2) - (x - 1)*x)O trecho de código acima fornece a seguinte saída -
-2
fator
Essa função pega um polinômio e o fatora em fatores irredutíveis sobre os números racionais.
>>> x,y,z=symbols('x y z')
>>> expr=(x**2*z + 4*x*y*z + 4*y**2*z)
>>> factor(expr)O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$z(x + 2y)^2$
>>> factor(x**2+2*x+1)O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$(x + 1)^2$
A função factor () é o oposto de expand (). Cada um dos fatores retornados por fator () é garantidamente irredutível. A função factor_list () retorna uma saída mais estruturada.
>>> expr=(x**2*z + 4*x*y*z + 4*y**2*z)
>>> factor_list(expr)O trecho de código acima fornece uma saída equivalente à expressão abaixo -
(1, [(z, 1), (x + 2*y, 2)])
recolher
Esta função coleta termos aditivos de uma expressão em relação a uma lista de expressões até potências com expoentes racionais.
>>> expr=x*y + x - 3 + 2*x**2 - z*x**2 + x**3
>>> exprO trecho de código acima fornece uma saída equivalente à expressão abaixo -
$x^3 + x^2z + 2x^2 + xy + x - 3$
A função collect () nesta expressão resulta da seguinte maneira -
>>> collect(expr,x)O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$x^3 + x^2(2 - z) + x(y + 1) - 3$
>>> expr=y**2*x + 4*x*y*z + 4*y**2*z+y**3+2*x*y
>>> collect(expr,y)O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$Y^3+Y^2(x+4z)+y(4xz+2x)$
cancelar
A função cancel () pegará qualquer função racional e a colocará na forma canônica padrão, p / q, onde peq são polinômios expandidos sem fatores comuns. Os coeficientes principais de peq não têm denominadores, ou seja, são inteiros.
>>> expr1=x**2+2*x+1
>>> expr2=x+1
>>> cancel(expr1/expr2)O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$x+1$
>>> expr = 1/x + (3*x/2 - 2)/(x - 4)
>>> exprO trecho de código acima fornece uma saída equivalente à expressão abaixo -
$\frac{\frac{3x}{2} - 2}{x - 4} + \frac{1}{x}$
>>> cancel(expr)O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$\frac{3x^2 - 2x - 8}{2x^2 - 8}$
>>> expr=1/sin(x)**2
>>> expr1=sin(x)
>>> cancel(expr1*expr)O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$\frac{1}{\sin(x)}$
trigsimp
Esta função é usada para simplificar identidades trigonométricas. Pode-se notar que as convenções de nomenclatura para funções trigonométricas inversas são anexar um a à frente do nome da função. Por exemplo, o cosseno inverso, ou arco cosseno, é chamado acos ().
>>> from sympy import trigsimp, sin, cos
>>> from sympy.abc import x, y
>>> expr = 2*sin(x)**2 + 2*cos(x)**2
>>> trigsimp(expr)2
A função trigsimp usa heurísticas para aplicar a identidade trigonométrica mais adequada.
powerimp
Esta função reduz a expressão dada combinando potências com bases e expoentes semelhantes.
>>> expr=x**y*x**z*y**z
>>> exprO trecho de código acima fornece uma saída equivalente à expressão abaixo -
$x^y x^z y^z$
>>> powsimp(expr)O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$x^{y+z} y^z$
Você pode fazer powsimp () combinar apenas bases ou apenas combinar expoentes mudando combine = 'base' ou combine = 'exp'. Por padrão, combine = 'all', que faz as duas coisas. Se force for True, as bases serão combinadas sem verificar as suposições.
>>> powsimp(expr, combine='base', force=True)O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$x^y(xy)^z$
pente
Expressões combinatórias envolvendo fatoriais e binômios podem ser simplificadas usando a função combsimp (). SymPy fornece uma função fatorial ()
>>> expr=factorial(x)/factorial(x - 3)
>>> exprO trecho de código acima fornece uma saída equivalente à expressão abaixo -
$\frac{x!}{(x - 3)!}$
Para simplificar a expressão combinatória acima, usamos a função combsimp () como segue -
>>> combsimp(expr)O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$x(x-2)(x-1)$
O binômio (x, y) é o número de maneiras de escolher y itens de um conjunto de x itens distintos. Também é freqüentemente escrito como xCy.
>>> binomial(x,y)O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$(\frac{x}{y})$
>>> combsimp(binomial(x+1, y+1)/binomial(x, y))O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$\frac{x + 1}{y + 1}$
logcombine
Esta função pega logaritmos e os combina usando as seguintes regras -
- log (x) + log (y) == log (x * y) se ambos forem positivos
- a * log (x) == log (x ** a) se x for positivo e a for real
>>> logcombine(a*log(x) + log(y) - log(z))O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$a\log(x) + \log(y) - \log(z)$
Se o parâmetro de força desta função for definido como Verdadeiro, então as suposições acima serão consideradas válidas se não houver nenhuma suposição já estabelecida sobre uma quantidade.
>>> logcombine(a*log(x) + log(y) - log(z), force=True)O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$\log\frac{x^a y}{z}$
A derivada de uma função é sua taxa instantânea de mudança em relação a uma de suas variáveis. Isso é equivalente a encontrar a inclinação da linha tangente à função em um ponto. Podemos encontrar a diferenciação de expressões matemáticas na forma de variáveis usando a função diff () no pacote SymPy.
diff(expr, variable)
>>> from sympy import diff, sin, exp
>>> from sympy.abc import x,y
>>> expr=x*sin(x*x)+1 >>> exprO trecho de código acima fornece uma saída equivalente à expressão abaixo -
$x\sin(x^2) + 1$
>>> diff(expr,x)O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$2x^2\cos(x^2) + \sin(x^2)$
>>> diff(exp(x**2),x)O trecho de código acima fornece uma saída equivalente à expressão abaixo -
2xex2
Para obter várias derivadas, passe a variável quantas vezes você deseja diferenciar ou passe um número após a variável.
>>> diff(x**4,x,3)O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$24x$
>>> for i in range(1,4): print (diff(x**4,x,i))O trecho de código acima fornece a expressão abaixo -
4*x**3
12*x**2
24*x
Também é possível chamar o método diff () de uma expressão. Funciona de forma semelhante à função diff ().
>>> expr=x*sin(x*x)+1
>>> expr.diff(x)O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$2x^2\cos(x^2) + \sin(x^2)$
Uma derivada não avaliada é criada usando a classe Derivada. Tem a mesma sintaxe da função diff (). Para avaliar uma derivada não avaliada, use o método doit.
>>> from sympy import Derivative
>>> d=Derivative(expr)
>>> dO trecho de código acima fornece uma saída equivalente à expressão abaixo -
$\frac{d}{dx}(x\sin(x^2)+1)$
>>> d.doit()O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$2x^2\cos(x^2) + \sin(x^2)$
O pacote SymPy contém módulo de integrais. Ele implementa métodos para calcular integrais definidas e indefinidas de expressões. O método integrate () é usado para calcular integrais definidos e indefinidos. Para calcular uma integral indefinida ou primitiva, basta passar a variável após a expressão.
Por exemplo -
integrate(f, x)Para calcular uma integral definida, passe o argumento da seguinte forma -
(integration_variable, lower_limit, upper_limit)>>> from sympy import *
>>> x,y = symbols('x y')
>>> expr=x**2 + x + 1
>>> integrate(expr, x)O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$\frac{x^3}{3} + \frac{x^2}{2} + x$
>>> expr=sin(x)*tan(x)
>>> expr
>>> integrate(expr,x)O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$-\frac{\log(\sin(x) - 1)}{2} + \frac{\log(\sin(x) + 1)}{2} - \sin(x)$
O exemplo de integral definida é dado abaixo -
>>> expr=exp(-x**2)
>>> integrate(expr,(x,0,oo) )O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$\frac{\sqrt\pi}{2}$
Você pode passar várias tuplas de limite para realizar uma integral múltipla. Um exemplo é dado abaixo -
>>> expr=exp(-x**2 - y**2)
>>> integrate(expr,(x,0,oo),(y,0,oo))O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$\frac{\pi}{4}$
Você pode criar integrais não avaliados usando o objeto Integral, que pode ser avaliado chamando o método doit ().
>>> expr = Integral(log(x)**2, x)
>>> exprO trecho de código acima fornece uma saída equivalente à expressão abaixo -
$\int \mathrm\log(x)^2 \mathrm{d}x$
>>> expr.doit()O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$x\log(x)^2 - 2xlog(x) + 2x$
Transformadas Integrais
SymPy suporta vários tipos de transformações integrais da seguinte maneira -
- laplace_transform
- fourier_transform
- sine_transform
- cosine_transform
- hankel_transform
Essas funções são definidas no módulo sympy.integrals.transforms. Os exemplos a seguir calculam a transformada de Fourier e a transformada de Laplace, respectivamente.
Example 1
>>> from sympy import fourier_transform, exp
>>> from sympy.abc import x, k
>>> expr=exp(-x**2)
>>> fourier_transform(expr, x, k)Ao executar o comando acima no shell python, a seguinte saída será gerada -
sqrt(pi)*exp(-pi**2*k**2)O que é equivalente a -
$\sqrt\pi * e^{\pi^2k^2}$
Example 2
>>> from sympy.integrals import laplace_transform
>>> from sympy.abc import t, s, a
>>> laplace_transform(t**a, t, s)Ao executar o comando acima no shell python, a seguinte saída será gerada -
(s**(-a)*gamma(a + 1)/s, 0, re(a) > -1)Em matemática, uma matriz é uma matriz bidimensional de números, símbolos ou expressões. A teoria da manipulação de matrizes trata da execução de operações aritméticas em objetos de matrizes, sujeita a certas regras.
A transformação linear é uma das aplicações importantes de matrizes. Muitas áreas científicas, especialmente relacionadas à Física, utilizam aplicações relacionadas a matrizes.
O pacote SymPy possui módulo de matrizes que trata do manuseio de matrizes. Inclui a classe Matrix cujo objeto representa uma matriz.
Note: If you want to execute all the snippets in this chapter individually, you need to import the matrix module as shown below −
>>> from sympy.matrices import MatrixExample
>>> from sympy.matrices import Matrix
>>> m=Matrix([[1,2,3],[2,3,1]])
>>> m
$\displaystyle \left[\begin{matrix}1 & 2 & 3\\2 & 3 & 1\end{matrix}\right]$Ao executar o comando acima no shell python, a seguinte saída será gerada -
[1 2 3 2 3 1]
Matrix é criada a partir de objetos List de tamanho apropriado. Você também pode obter uma matriz distribuindo itens de lista em um número especificado de linhas e colunas.
>>> M=Matrix(2,3,[10,40,30,2,6,9])
>>> M
$\displaystyle \left[\begin{matrix}10 & 40 & 30\\2 & 6 & 9\end{matrix}\right]$Ao executar o comando acima no shell python, a seguinte saída será gerada -
[10 40 30 2 6 9]
Matrix é um objeto mutável. O módulo de matrizes também fornece a classe ImmutableMatrix para a obtenção de matrizes imutáveis.
Manipulação básica
o shape propriedade do objeto Matrix retorna seu tamanho.
>>> M.shapeA saída para o código acima é a seguinte -
(2,3)
Os métodos row () e col () retornam respectivamente a linha ou coluna do número especificado.
>>> M.row(0)
$\displaystyle \left[\begin{matrix}10 & 40 & 30\end{matrix}\right]$A saída para o código acima é a seguinte -
[10 40 30]
>>> M.col(1)
$\displaystyle \left[\begin{matrix}40\\6\end{matrix}\right]$A saída para o código acima é a seguinte -
[40 6]
Use o operador slice do Python para buscar um ou mais itens pertencentes a linha ou coluna.
>>> M.row(1)[1:3]
[6, 9]A classe Matrix tem os métodos row_del () e col_del () que deleta a linha / coluna especificada da matriz dada -
>>> M=Matrix(2,3,[10,40,30,2,6,9])
>>> M.col_del(1)
>>> MAo executar o comando acima no shell python, a seguinte saída será gerada -
Matrix([[10, 30],[ 2, 9]])Você pode aplicar estilo à saída usando o seguinte comando -
$\displaystyle \left[\begin{matrix}10 & 30\\2 & 9\end{matrix}\right]$Você obtém a seguinte saída após executar o trecho de código acima -
[10 30 2 9]
>>> M.row_del(0)
>>> M
$\displaystyle \left[\begin{matrix}2 & 9\end{matrix}\right]$Você obtém a seguinte saída após executar o trecho de código acima -
[2 9]
Da mesma forma, os métodos row_insert () e col_insert () adicionam linhas ou colunas na linha especificada ou índice de coluna
>>> M1=Matrix([[10,30]])
>>> M=M.row_insert(0,M1)
>>> M
$\displaystyle \left[\begin{matrix}10 & 30\\2 & 9\end{matrix}\right]$Você obtém a seguinte saída após executar o trecho de código acima -
[10 40 30 2 9]
>>> M2=Matrix([40,6])
>>> M=M.col_insert(1,M2)
>>> M
$\displaystyle \left[\begin{matrix}10 & 40 & 30\\2 & 6 & 9\end{matrix}\right]$Você obtém a seguinte saída após executar o trecho de código acima -
[10 40 30 6 9]
Operaçoes aritimeticas
Operadores usuais +, - e * são definidos para realizar adição, subtração e multiplicação.
>>> M1=Matrix([[1,2,3],[3,2,1]])
>>> M2=Matrix([[4,5,6],[6,5,4]])
>>> M1+M2
$\displaystyle \left[\begin{matrix}5 & 7 & 9\\9 & 7 & 5\end{matrix}\right]$Você obtém a seguinte saída após executar o trecho de código acima -
[5 7 9 9 7 5]
>>> M1-M2
$\displaystyle \left[\begin{matrix}-3 & -3 & -3\\-3 & -3 & -3\end{matrix}\right]$Você obtém a seguinte saída após executar o trecho de código acima -
[- 3 -3 -3 -3 -3 -3]
A multiplicação da matriz só é possível se - O número de colunas da 1ª matriz deve ser igual ao número de linhas da 2ª matriz. - E o resultado terá o mesmo número de linhas da 1ª matriz e o mesmo número de colunas da 2ª matriz.
>>> M1=Matrix([[1,2,3],[3,2,1]])
>>> M2=Matrix([[4,5],[6,6],[5,4]])
>>> M1*M2
$\displaystyle \left[\begin{matrix}31 & 29\\29 & 31\end{matrix}\right]$A saída para o código acima é a seguinte -
[31 29 29 31]
>>> M1.T
$\displaystyle \left[\begin{matrix}1 & 3\\2 & 2\\3 & 1\end{matrix}\right]$A seguinte saída é obtida após a execução do código -
[1 3 2 2 3 1]
Para calcular um determinante da matriz, use o método det (). Um determinante é um valor escalar que pode ser calculado a partir dos elementos de uma matriz quadrada.0
>>> M=Matrix(3,3,[10,20,30,5,8,12,9,6,15])
>>> M
$\displaystyle \left[\begin{matrix}10 & 20 & 30\\5 & 8 & 12\\9 & 6 & 15\end{matrix}\right]$A saída para o código acima é a seguinte -
[10 20 30 5 8 12 9 6 15]
>>> M.det()A saída para o código acima é a seguinte -
-120
Construtores de matriz
SymPy fornece muitos tipos especiais de classes de matriz. Por exemplo, matriz de identidade, matriz de todos os zeros e uns, etc. Essas classes são nomeadas como olho, zeros e uns, respectivamente. A matriz de identidade é uma matriz quadrada com elementos que caem na diagonal são definidos como 1, o restante dos elementos são 0.
Example
from sympy.matrices import eye eye(3)Output
Matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]])$\displaystyle \left[\begin{matrix}1 & 0 & 0\\0 & 1 & 0\\0 & 0 & 1\end{matrix}\right]$A saída para o código acima é a seguinte -
[1 0 0 0 1 0 0 0 1]
Na matriz de diag, os elementos na diagonal são inicializados de acordo com os argumentos fornecidos.
>>> from sympy.matrices import diag
>>> diag(1,2,3)
$\displaystyle \left[\begin{matrix}1 & 0 & 0\\0 & 2 & 0\\0 & 0 & 3\end{matrix}\right]$A saída para o código acima é a seguinte -
[1 0 0 0 2 0 0 0 3]
Todos os elementos na matriz de zeros são inicializados com 0.
>>> from sympy.matrices import zeros
>>> zeros(2,3)
$\displaystyle \left[\begin{matrix}0 & 0 & 0\\0 & 0 & 0\end{matrix}\right]$A saída para o código acima é a seguinte -
[0 0 0 0 0 0]
Da mesma forma, uns é uma matriz com todos os elementos definidos como 1.
>>> from sympy.matrices import ones
>>> ones(2,3)
$\displaystyle \left[\begin{matrix}1 & 1 & 1\\1 & 1 & 1\end{matrix}\right]$A saída para o código acima é a seguinte -
[1 1 1 1 1 1]
O pacote Sympy possui a classe Function, que é definida no módulo sympy.core.function. É uma classe base para todas as funções matemáticas aplicadas, como também um construtor para classes de funções indefinidas.
As seguintes categorias de funções são herdadas da classe Function -
- Funções para número complexo
- Funções trigonométricas
- Funções para número inteiro
- Funções combinatórias
- Outras funções diversas
Funções para número complexo
Este conjunto de funções é definido em sympy.functions.elementary.complexes módulo.
re
Esta função retorna parte real de uma expressão -
>>> from sympy import *
>>> re(5+3*I)A saída para o snippet de código acima é fornecida abaixo -
5
>>> re(I)A saída para o snippet de código acima é -
0
Im
Esta função retorna parte imaginária de uma expressão -
>>> im(5+3*I)A saída para o snippet de código acima é fornecida abaixo -
3
>>> im(I)A saída para o snippet de código acima é fornecida abaixo -
1
sign
Esta função retorna o sinal complexo de uma expressão.
Para uma expressão real, o sinal será -
- 1 se a expressão for positiva
- 0 se a expressão for igual a zero
- -1 se a expressão for negativa
Se a expressão for imaginária, o sinal retornado é -
- I se im (expressão) é positivo
- -I se im (expressão) for negativo
>>> sign(1.55), sign(-1), sign(S.Zero)A saída para o snippet de código acima é fornecida abaixo -
(1, -1, 0)
>>> sign (-3*I), sign(I*2)A saída para o snippet de código acima é fornecida abaixo -
(-I, I)
Abs
Esta função retorna o valor absoluto de um número complexo. É definida como a distância entre a origem (0,0) e o ponto (a, b) no plano complexo. Esta função é uma extensão da função interna abs () para aceitar valores simbólicos.
>>> Abs(2+3*I)A saída para o snippet de código acima é fornecida abaixo -
$\sqrt13$
conjugate
Esta função retorna o conjugado de um número complexo. Para encontrar o conjugado complexo, mudamos o sinal da parte imaginária.
>>> conjugate(4+7*I)Você obtém a seguinte saída após executar o trecho de código acima -
4 - 7i
Funções trigonométricas
SymPy tem definições para todas as razões trigonométricas - sen cos, tan etc, bem como suas contrapartes inversas, como asin, acos, atan etc. Essas funções calculam os respectivos valores para um determinado ângulo expresso em radianos.
>>> sin(pi/2), cos(pi/4), tan(pi/6)A saída para o snippet de código acima é fornecida abaixo -
(1, sqrt(2)/2, sqrt(3)/3)
>>> asin(1), acos(sqrt(2)/2), atan(sqrt(3)/3)A saída para o snippet de código acima é fornecida abaixo -
(pi/2, pi/4, pi/6)
Funções em número inteiro
Este é um conjunto de funções para realizar várias operações em números inteiros.
ceiling
Esta é uma função univariada que retorna o menor valor inteiro não menor que seu argumento. No caso de números complexos, teto das partes real e imaginária separadamente.
>>> ceiling(pi), ceiling(Rational(20,3)), ceiling(2.6+3.3*I)A saída para o snippet de código acima é fornecida abaixo -
(4, 7, 3 + 4*I)
floor
Esta função retorna o maior valor inteiro, não maior que seu argumento. No caso de números complexos, esta função também ocupa o chão das partes real e imaginária separadamente.
>>> floor(pi), floor(Rational(100,6)), floor(6.3-5.9*I)A saída para o snippet de código acima é fornecida abaixo -
(3, 16, 6 - 6*I)
frac
Esta função representa a parte fracionária de x.
>>> frac(3.99), frac(Rational(10,3)), frac(10)A saída para o snippet de código acima é fornecida abaixo -
(0.990000000000000, 1/3, 0)
Funções combinatórias
Combinatória é um campo da matemática preocupado com problemas de seleção, arranjo e operação dentro de um sistema finito ou discreto.
factorial
O fatorial é muito importante em combinatória, onde fornece o número de maneiras pelas quais n objetos podem ser permutados. É simbolicamente representado como ð ?? '¥! Esta função é a implementação da função fatorial sobre inteiros não negativos, o fatorial de um inteiro negativo é infinito complexo.
>>> x=Symbol('x')
>>> factorial(x)A saída para o snippet de código acima é fornecida abaixo -
x!
>>> factorial(5)A saída para o snippet de código acima é fornecida abaixo -
120
>>> factorial(-1)A saída para o snippet de código acima é fornecida abaixo -
$\infty\backsim$
binômio
Esta função representa o número de maneiras pelas quais podemos escolher k elementos de um conjunto de n elementos.
>>> x,y=symbols('x y')
>>> binomial(x,y)A saída para o snippet de código acima é fornecida abaixo -
$(\frac{x}{y})$
>>> binomial(4,2)A saída para o snippet de código acima é fornecida abaixo -
6
Linhas do triângulo de Pascal podem ser geradas com a função binomial.
>>> for i in range(5): print ([binomial(i,j) for j in range(i+1)])Você obtém a seguinte saída após executar o trecho de código acima -
[1]
[1, 1]
[1, 2, 1]
[1, 3, 3, 1]
[1, 4, 6, 4, 1]
fibonacci
Os números de Fibonacci são a sequência inteira definida pelos termos iniciais F0 = 0, F1 = 1 e a relação de recorrência de dois termos Fn = Fnâˆ'1 + Fnâˆ'2.
>>> [fibonacci(x) for x in range(10)]A seguinte saída é obtida após a execução do trecho de código acima -
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
tribonacci
Os números de Tribonacci são a sequência inteira definida pelos termos iniciais F0 = 0, F1 = 1, F2 = 1 e a relação de recorrência de três termos Fn = Fn-1 + Fn-2 + Fn-3.
>>> tribonacci(5, Symbol('x'))O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$x^8 + 3x^5 + 3x^2$
>>> [tribonacci(x) for x in range(10)]A seguinte saída é obtida após a execução do trecho de código acima -
[0, 1, 1, 2, 4, 7, 13, 24, 44, 81]
Funções Diversas
A seguir está uma lista de algumas funções usadas com frequência -
Min- Retorna o valor mínimo da lista. É denominado Min para evitar conflitos com a função incorporada min.
Max- Retorna o valor máximo da lista. É denominado Max para evitar conflitos com a função embutida max.
root - Retorna enésima raiz de x.
sqrt - Retorna a raiz quadrada principal de x.
cbrt - Esta função calcula a raiz cúbica principal de x, (atalho para x ++ Rational (1,3)).
A seguir estão os exemplos das funções diversas acima e suas respectivas saídas -
>>> Min(pi,E)e
>>> Max(5, Rational(11,2))$\frac{11}{2}$
>>> root(7,Rational(1,2))49
>>> sqrt(2)$\sqrt2$
>>> cbrt(1000)10
Em matemática, o sistema numérico do quaternion é uma extensão dos números complexos. Cada objeto Quaternion contém quatro variáveis escalares e quatro dimensões, uma dimensão real e três dimensões imaginárias.
Quaternion é representado pela seguinte expressão -
q = a + bi + cj + dk
Onde a, b, c e d são números reais e i, j, k são unidades de quatérnio tais que, i2 == j2 == k2 == ijk
o sympy.algebras.quaternion módulo tem classe Quaternion.
>>> from sympy.algebras.quaternion import Quaternion
>>> q=Quaternion(2,3,1,4)
>>> qO trecho de código acima fornece uma saída equivalente à expressão abaixo -
$2 + 3i + 1j + 4k$
Quaternions são usados em matemática pura, bem como em matemática aplicada, computação gráfica, visão computacional, etc.
>>> from sympy import *
>>> x=Symbol('x')
>>> q1=Quaternion(x**2, x**3, x) >>> q1O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$x^2 + x^3i + xj + 0k$
Objeto de quaternion também pode ter coeficientes imaginários
>>> q2=Quaternion(2,(3+2*I), x**2, 3.5*I)
>>> q2O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$2 + (3 + 2i)i + x2j + 3.5ik$
adicionar()
Este método disponível na classe Quaternion realiza a adição de dois objetos Quaternion.
>>> q1=Quaternion(1,2,3,4)
>>> q2=Quaternion(4,3,2,1)
>>> q1.add(q2)O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$5 + 5i + 5j + 5k$
É possível adicionar um número ou símbolo em um objeto Quaternion.
>>> q1+2A seguinte saída é obtida após a execução do trecho de código acima -
$3 + 2i + 3j + 4k$
>>> q1+xA seguinte saída é obtida após a execução do trecho de código acima -
$(x + 1) + 2i + 3j + 4k$
mul ()
Este método realiza a multiplicação de dois objetos de quatérnio.
>>> q1=Quaternion(1,2,1,2)
>>> q2=Quaternion(2,4,3,1)
>>> q1.mul(q2)O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$(-11) + 3i + 11j + 7k$
inverso()
Este método retorna o inverso de um objeto quatérnio.
>>> q1.inverse()O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$\frac{1}{10} + (-\frac{1}{5})i + (-\frac{1}{10})j + (-\frac{1}{5})k$
Pancada()
Este método retorna a potência de um objeto quaternion.
>>> q1.pow(2)A seguinte saída é obtida após a execução do trecho de código acima -
$(-8) + 4i + 2j + 4k$
exp ()
Este método calcula exponencial de um objeto Quaternion, ou seja, eq
>>> q=Quaternion(1,2,4,3)
>>> q.exp()A seguinte saída é obtida após a execução do trecho de código acima -
$e\cos(\sqrt29) + \frac{2\sqrt29e\sin(\sqrt29)}{29}i + \frac{4\sqrt29e\sin(\sqrt29)}{29}j + \frac{3\sqrt29e\sin}{29}k$
Visto que os símbolos = e == são definidos como operadores de atribuição e igualdade em Python, eles não podem ser usados para formular equações simbólicas. SymPy fornece a função Eq () para configurar uma equação.
>>> from sympy import *
>>> x,y=symbols('x y')
>>> Eq(x,y)O trecho de código acima fornece uma saída equivalente à expressão abaixo -
x = y
Uma vez que x = y é possível se e somente se xy = 0, a equação acima pode ser escrita como -
>>> Eq(x-y,0)O trecho de código acima fornece uma saída equivalente à expressão abaixo -
x − y = 0
O módulo solver no SymPy fornece a função soveset () cujo protótipo é o seguinte -
solveset(equation, variable, domain)O domínio é, por padrão, S.Complexes. Usando a função solveset (), podemos resolver uma equação algébrica da seguinte maneira -
>>> solveset(Eq(x**2-9,0), x)A seguinte saída é obtida -
{−3, 3}
>>> solveset(Eq(x**2-3*x, -2),x)A seguinte saída é obtida após a execução do trecho de código acima -
{1,2}
A saída de solveset é um FiniteSet das soluções. Se não houver soluções, um EmptySet é retornado
>>> solveset(exp(x),x)A seguinte saída é obtida após a execução do trecho de código acima -
$\varnothing$
Equação linear
Temos que usar a função linsolve () para resolver equações lineares.
Por exemplo, as equações são as seguintes -
xy = 4
x + y = 1
>>> from sympy import *
>>> x,y=symbols('x y')
>>> linsolve([Eq(x-y,4),Eq( x + y ,1) ], (x, y))A seguinte saída é obtida após a execução do trecho de código acima -
$\lbrace(\frac{5}{2},-\frac{3}{2})\rbrace$
A função linsolve () também pode resolver equações lineares expressas em forma de matriz.
>>> a,b=symbols('a b')
>>> a=Matrix([[1,-1],[1,1]])
>>> b=Matrix([4,1])
>>> linsolve([a,b], (x,y))Obteremos a seguinte saída se executarmos o trecho de código acima -
$\lbrace(\frac{5}{2},-\frac{3}{2})\rbrace$
Equação não linear
Para este propósito, usamos a função nonlinsolve (). Equações para este exemplo -
a 2 + a = 0 ab = 0
>>> a,b=symbols('a b')
>>> nonlinsolve([a**2 + a, a - b], [a, b])Obteremos a seguinte saída se executarmos o trecho de código acima -
$\lbrace(-1, -1),(0,0)\rbrace$
equação diferencial
Primeiro, crie uma função indefinida passando cls = Function para a função de símbolos. Para resolver equações diferenciais, use dsolve.
>>> x=Symbol('x')
>>> f=symbols('f', cls=Function)
>>> f(x)A seguinte saída é obtida após a execução do trecho de código acima -
f(x)
Aqui f (x) é uma função não avaliada. Sua derivada é a seguinte -
>>> f(x).diff(x)O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$\frac{d}{dx}f(x)$
Primeiro criamos o objeto Eq correspondente à seguinte equação diferencial
>>> eqn=Eq(f(x).diff(x)-f(x), sin(x))
>>> eqnO trecho de código acima fornece uma saída equivalente à expressão abaixo -
$-f(x) + \frac{d}{dx}f(x)= \sin(x)$
>>> dsolve(eqn, f(x))O trecho de código acima fornece uma saída equivalente à expressão abaixo -
$f(x)=(c^1-\frac{e^-xsin(x)}{2}-\frac{e^-xcos(x)}{2})e^x$
SymPy usa a biblioteca Matplotlib como backend para renderizar gráficos 2-D e 3-D de funções matemáticas. Certifique-se de que o Matplotlib esteja disponível na instalação atual do Python. Caso contrário, instale o mesmo usando o seguinte comando -
pip install matplotlibO suporte à plotagem é definido no módulo sympy.plotting. As seguintes funções estão presentes no módulo de plotagem -
plot - gráficos de linha 2D
plot3d - gráficos de linha 3D
plot_parametric - gráficos paramétricos 2D
plot3d_parametric - Gráficos paramétricos 3D
A função plot () retorna uma instância da classe Plot. Uma figura do gráfico pode ter uma ou mais expressões SymPy. Embora seja capaz de usar Matplotlib como back-end, outros back-ends, como texplot, pyglet ou API de gráficos do Google também podem ser usados.
plot(expr, range, kwargs)onde expr é qualquer expressão SymPy válida. Se não for mencionado, o intervalo usa o padrão como (-10, 10).
O exemplo a seguir plota valores de x2 para cada valor no intervalo (-10,10) -
>>> from sympy.plotting import plot
>>> from sympy import *
>>> x=Symbol('x')
>>> plot(x**2, line_color='red')
Para desenhar vários gráficos para o mesmo intervalo, forneça várias expressões antes da tupla de intervalo.
>>> plot( sin(x),cos(x), (x, -pi, pi))
Você também pode especificar um intervalo separado para cada expressão.
plot((expr1, range1), (expr2, range2))A figura a seguir plota sin (x) e cos (x) em intervalos diferentes.
>>> plot( (sin(x),(x, -2*pi, 2*pi)),(cos(x), (x, -pi, pi)))
Os seguintes argumentos opcionais de palavra-chave podem ser especificados na função plot ().
line_color - especifica a cor da linha do gráfico.
title - uma string a ser exibida como título
xlabel - uma string a ser exibida como rótulo para o eixo X
ylabel - uma string a ser exibida como rótulo para o eixo y
>>> plot( (sin(x),(x, -2*pi, 2*pi)),(cos(x), (x, -pi, pi)), line_color='red', title='SymPy plot example')
A função plot3d () renderiza um gráfico tridimensional.
plot3d(expr, xrange, yrange, kwargs)O exemplo a seguir desenha um gráfico de superfície 3D -
>>> from sympy.plotting import plot3d
>>> x,y=symbols('x y')
>>> plot3d(x*y, (x, -10,10), (y, -10,10))
Como no gráfico 2D, um gráfico tridimensional também pode ter vários gráficos, cada um com um intervalo diferente.
>>> plot3d(x*y, x/y, (x, -5, 5), (y, -5, 5))
A função plot3d_parametric_line () renderiza um gráfico de linha paramétrica tridimensional.
>>> from sympy.plotting import plot3d_parametric_line
>>> plot3d_parametric_line(cos(x), sin(x), x, (x, -5, 5))
Para desenhar um gráfico de superfície paramétrico, use a função plot3d_parametric_surface ().
plot3d_parametric_surface(xexpr, yexpr, zexpr, rangex, rangey, kwargs)
>>> from sympy.plotting import plot3d_parametric_surface
>>> plot3d_parametric_surface(cos(x+y), sin(x-y), x-y, (x, -5, 5), (y, -5, 5))
O módulo de geometria no SymPy permite a criação de entidades bidimensionais, como linha, círculo, etc. Podemos então obter informações sobre eles, como verificar colinearidade ou encontrar interseção.
Ponto
A classe Point representa um ponto no espaço euclidiano. O exemplo a seguir verifica a colinearidade de pontos -
>>> from sympy.geometry import Point
>>> from sympy import *
>>> x=Point(0,0)
>>> y=Point(2,2)
>>> z=Point(4,4)
>>> Point.is_collinear(x,y,z)Output
True
>>> a=Point(2,3)
>>> Point.is_collinear(x,y,a)Output
False
O método distance () da classe Point calcula a distância entre dois pontos
>>> x.distance(y)Output
$2\sqrt2$
A distância também pode ser representada em termos de símbolos.
Linha
A entidade Line é obtida a partir de dois objetos Point. O método intersection () retorna o ponto de intersecção se duas linhas se cruzarem.
>>> from sympy.geometry import Point, Line
>>> p1, p2=Point(0,5), Point(5,0)
>>> l1=Line(p1,p2)
>>> l2=Line(Point(0,0), Point(5,5))
>>> l1.intersection(l2)Output
[Point2D(5/2, 5/2)]
>>> l1.intersection(Line(Point(0,0), Point(2,2)))Output
[Point2D(5/2, 5/2)]
>>> x,y=symbols('x y')
>>> p=Point(x,y)
>>> p.distance(Point(0,0))Output
$\sqrt{x^2 + y^2}$
Triângulo
Esta função constrói uma entidade triangular a partir de três objetos pontuais.
Triangle(a,b,c)
>>> t=Triangle(Point(0,0),Point(0,5), Point(5,0))
>>> t.areaOutput
$-\frac{25}{2}$
Elipse
Uma entidade de geometria elíptica é construída passando um objeto Point correspondente ao centro e dois números para cada raio horizontal e vertical.
ellipse(center, hradius, vradius)
>>> from sympy.geometry import Ellipse, Line
>>> e=Ellipse(Point(0,0),8,3)
>>> e.areaOutput
$24\pi$
O vradius pode ser indiretamente fornecido usando o parâmetro de excentricidade.
>>> e1=Ellipse(Point(2,2), hradius=5, eccentricity=Rational(3,4))
>>> e1.vradiusOutput
$\frac{5\sqrt7}{4}$
o apoapsis da elipse é a maior distância entre o foco e o contorno.
>>> e1.apoapsisOutput
$\frac{35}{4}$
A declaração a seguir calcula a circunferência da elipse -
>>> e1.circumferenceOutput
$20E(\frac{9}{16})$
o equation método da elipse retorna a equação da elipse.
>>> e1.equation(x,y)Output
$(\frac{x}{5}-\frac{2}{5})^2 + \frac{16(y-2)2}{175} - 1$
Em matemática, um conjunto é uma coleção bem definida de objetos distintos que podem ser números, pessoas, letras do alfabeto ou mesmo outros conjuntos. Set também é um dos tipos embutidos em Python. SymPy fornece módulo de conjuntos. Ele contém definições de diferentes tipos de conjunto e tem funcionalidade para realizar operações de conjunto, como interseção, união, etc.
Set é uma classe base para qualquer outro tipo de conjunto no SymPy. Observe que é diferente do tipo de dados de conjunto integrado do Python. A classe de intervalo representa intervalos reais e sua propriedade de limite retorna umFiniteSet objeto.
>>> from sympy import Interval
>>> s=Interval(1,10).boundary
>>> type(s)sympy.sets.sets.FiniteSet
FiniteSet é uma coleção de números discretos. Pode ser obtido de qualquer objeto de sequência, como lista ou string.
>>> from sympy import FiniteSet
>>> FiniteSet(range(5))Output
$\lbrace\lbrace0,1,...,4\rbrace\rbrace$
>>> numbers=[1,3,5,2,8]
>>> FiniteSet(*numbers)Output
$\lbrace1,2,3,5,8\rbrace$
>>> s="HelloWorld"
>>> FiniteSet(*s)Output
{H,W,d,e,l,o,r}
Observe que, como no conjunto integrado, o Conjunto do SymPy também é uma coleção de objetos distintos.
ConditionSet é um conjunto de elementos que satisfazem uma determinada condição
>>> from sympy import ConditionSet, Eq, Symbol
>>> x=Symbol('x')
>>> s=ConditionSet(x, Eq(x**2-2*x,0), Interval(1,10)) >>> sOutput
$\lbrace x\mid x\in[1,10]∧x^2 - 2x =0\rbrace$
Unioné um conjunto composto. Inclui todos os elementos em dois conjuntos. Observe que os elementos encontrados em ambos aparecerão apenas uma vez na União.
>>> from sympy import Union
>>> l1=[3,1,5,7]
>>> l2=[9,7,2,1]
>>> a=FiniteSet(*l1)
>>> b=FiniteSet(*l2)
>>> Union(a,b)Intersection por outro lado, contém apenas os elementos que estão presentes em ambos.
>>> from sympy import Intersection
>>> Intersection(a,b)ProductSet objeto representa o produto cartesiano de elementos em ambos os conjuntos.
>>> from sympy import ProductSet
>>> l1=[1,2]
>>> l2=[2,3]
>>> a=FiniteSet(*l1)
>>> b=FiniteSet(*l2)
>>> set(ProductSet(a,b))Complement(a,b) retém elementos em a excluindo elementos que são comuns com b conjunto.
>>> from sympy import Complement
>>> l1=[3,1,5,7]
>>> l2=[9,7,2,1]
>>> a=FiniteSet(*l1)
>>> b=FiniteSet(*l2)
>>> Complement(a,b), Complement(b,a)SymmetricDifference conjunto contém apenas elementos incomuns em ambos os conjuntos.
>>> from sympy import SymmetricDifference
>>> l1=[3,1,5,7]
>>> l2=[9,7,2,1]
>>> a=FiniteSet(*l1)
>>> b=FiniteSet(*l2)
>>> SymmetricDifference(a,b)Output
{2,3,5,9}
Existem várias impressoras disponíveis no SymPy. A seguir está uma lista parcial -
- str
- srepr
- Linda impressora ASCII
- Linda impressora Unicode
- LaTeX
- MathML
- Dot
Os objetos SymPy também podem ser enviados como saída para código de várias linguagens, como C, Fortran, Javascript, Theano e Python.
SymPy usa caracteres Unicode para renderizar a saída na forma de impressão bonita. Se você estiver usando o console Python para executar a sessão SymPy, o ambiente de impressão mais bonito é ativado chamando a função init_session ().
>>> from sympy import init_session
>>> init_session()Console IPython para SymPy 1.5.1 (Python 3.7.4-64 bits) (tipos de solo: python).
Esses comandos foram executados -
>>> from __future__ import division
>>> from sympy import *
>>> x, y, z, t = symbols('x y z t')
>>> k, m, n = symbols('k m n', integer=True)
>>> f, g, h = symbols('f g h', cls=Function)
>>> init_printing()A documentação pode ser encontrada em https://docs.sympy.org/1.5.1/.
>>> Integral(sqrt(1/x),x)$\int \sqrt\frac{1}{x} dx$
Se o LATEX não estiver instalado, mas o Matplotlib estiver instalado, ele usará o mecanismo de renderização Matplotlib. Se Matplotlib não estiver instalado, ele usa a impressora bonita Unicode. No entanto, o notebook Jupyter usa MathJax para renderizar LATEX.
Em um terminal que não oferece suporte a Unicode, a impressora bonita ASCII é usada.
Para usar a impressora ASCII, use a função pprint () com a propriedade use_unicode definida como False
>>> pprint(Integral(sqrt(1/x),x),use_unicode=False)
A impressora bonita Unicode também é acessada em pprint () e pretty (). Se o terminal suportar Unicode, ele será usado automaticamente. Se pprint () não for capaz de detectar que o terminal suporta unicode, você pode passar use_unicode = True para forçá-lo a usar Unicode.
Para obter a forma LATEX de uma expressão, use a função latex ().
>>> print(latex(Integral(sqrt(1/x),x)))\int \sqrt{\frac{1}{x}}\, dx
Você também pode usar a impressora mathml. para isso, importe a função print_mathml. Uma versão string é obtida pela função mathml ().
>>> from sympy.printing.mathml import print_mathml
>>> print_mathml(Integral(sqrt(1/x),x))<apply>
<int/>
<bvar>
<ci>x</ci>
</bvar>
<apply>
<root/>
<apply>
<power/>
<ci>x</ci>
<cn>-1</cn>
</apply>
</apply>
</apply>
>>>mathml(Integral(sqrt(1/x),x))'<apply><int/><bvar><ci>x</ci></bvar><apply><root/><apply><power/><ci>x</ci><cn>-1</cn></apply></apply></apply>'