SymPy - SymPy

SymPy
Logotipo de Sympy.
Desarrollador (es) Equipo de desarrollo de SymPy
Versión inicial 2007 ; hace 14 años ( 2007 )
Lanzamiento estable
1.8 / 10 de abril de 2021 ; hace 4 meses ( 04/10/2021 )
Repositorio
Escrito en Pitón
Sistema operativo Multiplataforma
Escribe Sistema de álgebra informática
Licencia Nueva licencia BSD
Sitio web www .sympy .org Edita esto en Wikidata

SymPy es una biblioteca de Python de código abierto para el cálculo simbólico . Proporciona capacidades de álgebra informática como una aplicación independiente, como una biblioteca para otras aplicaciones o en vivo en la web como SymPy Live o SymPy Gamma. SymPy es fácil de instalar e inspeccionar porque está escrito completamente en Python con pocas dependencias. Esta facilidad de acceso combinada con una base de código simple y extensible en un lenguaje bien conocido hacen de SymPy un sistema de álgebra computacional con una barrera de entrada relativamente baja.

SymPy incluye características que van desde aritmética simbólica básica hasta cálculo , álgebra , matemáticas discretas y física cuántica . Es capaz de formatear el resultado de los cálculos como código LaTeX .

SymPy es un software gratuito y tiene la licencia New BSD . Los desarrolladores principales son Ondřej Čertík y Aaron Meurer. Fue iniciado en 2005 por Ondřej Čertík.

Características

La biblioteca SymPy se divide en un núcleo con muchos módulos opcionales.

Actualmente, el núcleo de SymPy tiene alrededor de 260.000 líneas de código (también incluye un conjunto completo de autopruebas: más de 100.000 líneas en 350 archivos a partir de la versión 0.7.5), y sus capacidades incluyen:

Capacidades básicas

Polinomios

Cálculo

Resolver ecuaciones

Matemáticas discretas

Matrices

Geometría

Graficado

Tenga en cuenta que el trazado requiere el módulo externo matplotlib o Pyglet.

  • Coordinar modelos
  • Trazado de entidades geométricas
  • 2D y 3D
  • Interfaz interactiva
  • Colores
  • Animaciones

Física

Estadísticas

Combinatoria

Impresión

Proyectos relacionados

  • SageMath : una alternativa de código abierto a Mathematica , Maple , MATLAB y Magma (SymPy está incluido en Sage)
  • SymEngine: una reescritura del núcleo de SymPy en C ++, para aumentar su rendimiento. Actualmente se está trabajando para hacer de SymEngine el motor subyacente de Sage también.
  • mpmath: una biblioteca de Python para aritmética de punto flotante de precisión arbitraria
  • SympyCore: otro sistema de álgebra informática de Python
  • SfePy: Software para la resolución de sistemas de ecuaciones diferenciales parciales acopladas (PDE) por el método de elementos finitos en 1D, 2D y 3D.
  • GAlgebra: Módulo de álgebra geométrica (anteriormente sympy.galgebra).
  • Quameon: Quantum Monte Carlo en Python.
  • Lcapy: paquete Python experimental para la enseñanza del análisis de circuitos lineales .
  • Proyecto Expresión LaTeX: Fácil composición tipográfica LaTeX de expresiones algebraicas en forma simbólica con sustitución automática y cálculo de resultados.
  • Modelado estadístico simbólico: adición de operaciones estadísticas a modelos físicos complejos.
  • Diofant: un fork de SymPy, iniciado por Sergey B Kirpichev

Dependencias

Desde la versión 1.0, SymPy tiene el paquete mpmath como dependencia.

Hay varias dependencias opcionales que pueden mejorar sus capacidades:

  • gmpy : Si gmpy está instalado, el módulo polinomial de SymPy lo usará automáticamente para tipos de terreno más rápidos. Esto puede aumentar varias veces el rendimiento de determinadas operaciones.
  • matplotlib : si matplotlib está instalado, SymPy puede usarlo para trazar.
  • Pyglet : paquete de trazado alternativo.

Ejemplos de uso

Bonita impresión

Sympy permite formatear las salidas en un formato más atractivo a través de la pprintfunción. Alternativamente, el init_printing()método permitirá la impresión bonita, por lo pprintque no es necesario llamarlo. Pretty-Printing utilizará símbolos Unicode cuando estén disponibles en el entorno actual; de lo contrario, recurrirá a caracteres ASCII .

>>> from sympy import pprint, init_printing, Symbol, sin, cos, exp, sqrt, series, Integral, Function
>>>
>>> x = Symbol("x")
>>> y = Symbol("y")
>>> f = Function('f')
>>> # pprint will default to unicode if available
>>> pprint( x**exp(x) )
 ⎛ x⎞
 ⎝ℯ ⎠
x   
>>> # An output without unicode
>>> pprint(Integral(f(x), x), use_unicode=False)
  /       
 |        
 | f(x) dx
 |        
/        
>>> # Compare with same expression but this time unicode is enabled
>>> pprint(Integral(f(x), x), use_unicode=True)

⎮ f(x) dx

>>> # Alternatively, you can call init_printing() once and pretty-print without the pprint function.
>>> init_printing()
>>> sqrt(sqrt(exp(x)))
   ____
4 ╱  x 
╲╱  ℯ  
>>> (1/cos(x)).series(x, 0, 10)
     2      4       6        8         
    x    5⋅x    61⋅x    277⋅x     ⎛ 10⎞
1 + ── + ──── + ───── + ────── + O⎝x  ⎠
    2     24     720     8064

Expansión

>>> from sympy import init_printing, Symbol, expand
>>> init_printing()
>>>
>>> a = Symbol('a')
>>> b = Symbol('b')
>>> e = (a + b)**3
>>> e
(a + b)³
>>> e.expand()
a³ + 3⋅a²⋅b + 3⋅a⋅b²  + b³

Ejemplo de precisión arbitraria

>>> from sympy import Rational, pprint
>>> e = 2**50 / Rational(10)**50
>>> pprint(e)
1/88817841970012523233890533447265625

Diferenciación

>>> from sympy import init_printing, symbols, ln, diff
>>> init_printing()
>>> x, y = symbols('x y')
>>> f = x**2 / y + 2 * x - ln(y)
>>> diff(f, x)
 2⋅x    
 ─── + 2
  y 
>>> diff(f, y)
    2    
   x    1
 - ── - ─
    2   y
   y
>>> diff(diff(f, x), y)
 -2⋅x
 ────
   2 
  y

Graficado

Salida del ejemplo de trazado
>>> from sympy import symbols, cos
>>> from sympy.plotting import plot3d
>>> x, y = symbols('x y')
>>> plot3d(cos(x*3)*cos(y*5)-y, (x, -1, 1), (y, -1, 1))
<sympy.plotting.plot.Plot object at 0x3b6d0d0>

Limites

>>> from sympy import init_printing, Symbol, limit, sqrt, oo
>>> init_printing()
>>> 
>>> x = Symbol('x')
>>> limit(sqrt(x**2 - 5*x + 6) - x, x, oo)
-5/2
>>> limit(x*(sqrt(x**2 + 1) - x), x, oo)
1/2
>>> limit(1/x**2, x, 0)

>>> limit(((x - 1)/(x + 1))**x, x, oo)
 -2

Ecuaciones diferenciales

>>> from sympy import init_printing, Symbol, Function, Eq, dsolve, sin, diff
>>> init_printing()
>>>
>>> x = Symbol("x")
>>> f = Function("f")
>>>
>>> eq = Eq(f(x).diff(x), f(x))
>>> eq
d              
──(f(x)) = f(x)
dx         
>>>    
>>> dsolve(eq, f(x))
           x
f(x) = C₁⋅ℯ

>>>
>>> eq = Eq(x**2*f(x).diff(x), -3*x*f(x) + sin(x)/x)
>>> eq
 2 d                      sin(x)
x ⋅──(f(x)) = -3⋅x⋅f(x) + ──────
   dx                       x   
>>>
>>> dsolve(eq, f(x))
       C₁ - cos(x)
f(x) = ───────────   

Integración

>>> from sympy import init_printing, integrate, Symbol, exp, cos, erf
>>> init_printing()
>>> x = Symbol('x')
>>> # Polynomial Function
>>> f = x**2 + x + 1
>>> f
 2        
x  + x + 1
>>> integrate(f,x)
 3    2    
x    x     
── + ── + x
3    2     
>>> # Rational Function
>>> f = x/(x**2+2*x+1)
>>> f
     x      
────────────
 2          
x  + 2⋅x + 1

>>> integrate(f, x)
               1  
log(x + 1) + ─────
             x + 1
>>> # Exponential-polynomial functions
>>> f = x**2 * exp(x) * cos(x)
>>> f
 2  x       
x ⋅ℯ ⋅cos(x)
>>> integrate(f, x)
 2  x           2  x                         x           x       
x ⋅ℯ ⋅sin(x)   x ⋅ℯ ⋅cos(x)      x          ℯ ⋅sin(x)   ℯ ⋅cos(x)
──────────── + ──────────── - x⋅ℯ ⋅sin(x) + ───────── - ─────────
     2              2                           2           2    
>>> # A non-elementary integral
>>> f = exp(-x**2) * erf(x)
>>> f
   2       
 -x        
ℯ   ⋅erf(x)
>>> integrate(f, x)

  ___    2   
╲╱ π ⋅erf (x)
─────────────
      4

Serie

>>> from sympy import Symbol, cos, sin, pprint
>>> x = Symbol('x')
>>> e = 1/cos(x)
>>> pprint(e)
  1   
──────
cos(x)
>>> pprint(e.series(x, 0, 10))
     2      4       6        8         
    x    5⋅x    61⋅x    277⋅x     ⎛ 10⎞
1 + ── + ──── + ───── + ────── + O⎝x  ⎠
    2     24     720     8064          
>>> e = 1/sin(x)
>>> pprint(e)
  1   
──────
sin(x)
>>> pprint(e.series(x, 0, 4))
           3        
1   x   7⋅x     ⎛ 4⎞
─ + ─ + ──── + O⎝x ⎠
x   6   360

Razonamiento logico

Ejemplo 1

>>> from sympy import *
>>> x = Symbol('x')
>>> y = Symbol('y')
>>> facts = Q.positive(x), Q.positive(y)
>>> with assuming(*facts):
...     print(ask(Q.positive(2 * x + y)))
True

Ejemplo 2

>>> from sympy import *
>>> x = Symbol('x')
>>> # Assumption about x
>>> fact = [Q.prime(x)]
>>> with assuming(*fact):
...     print(ask(Q.rational(1 / x)))
True

Ver también

Referencias

enlaces externos