# Uso de simpy

## Conceptos basico: definición de simbolos y operaciones

**Para representar valores se puede usar:**




```python
# Salida Latex automatica
from sympy import Symbol
x = Symbol("x")
x**2+2*x+1

```


```python
#Salida comun
from sympy import Symbol, pprint
x = Symbol("x")
ec = x**2+2*x+1
print(ec)
```

    x**2 + 2*x + 1



```python
#Salida usando pprint
import sympy as sp

x = Symbol("x")
ec = x**2+2*x+1
sp.pprint(ec)
```

               2
    1 + 2⋅x + x 



```python
#Salida tipo Latex
"""Configuracion inicial"""
from sympy.interactive import printing
printing.init_printing(use_latex=True)

"""modulo necesario"""
import sympy as sp

x = sp.Symbol("x")
ecuacion = x**2 +2*x +1

print("Ecuacion")
display(ecuacion)


```

### Definiendo ecuaciones


```python
"""Configuracion incial"""
from sympy.interactive import printing
printing.init_printing(use_latex=True)

"""modulos necesarios"""
import sympy as sp

#Declaracion de un simbolo
x = sp.Symbol("x")

#Declaracion de multiples simbolos
y,z = sp.symbols("y,z")

ecuacion = x**2 +2*y*z**2 +2*y**2*z +z**2

print("La ecuacion definida es:")
display(ecuacion)
```

### Sustituyendo expresiones
**_Uso del metodo subs()_**


```python
from sympy.interactive import printing
printing.init_printing(use_latex=True)

import sympy as sp

x,y = sp.symbols("x,y")
expresion = x*x +x*y +x*y +y*y

print("Expresion: ", end="\n")
display(expresion)

print("\nSustituyendo valores y=2, x=1")
est_valor = expresion.subs({x:1, y:2})
display(est_valor)

print("\n\nSegunda sustitucion x = 1-y\n")
est_valor = expresion.subs({x:y**2+2})
display(est_valor)

```

### Factorizacion de expresiones 

```markdown
    Uso de 
    * factor()
    * expand()


```


```python
# Factorizacion simple
from sympy.interactive import printing
printing.init_printing(use_latex=True)

import sympy as sp

x,y = sp.symbols("x,y")
expresion = x**3 +3*x**2*y +3*x*y**2 +y**3
display(sp.factor(expresion))


```


```python
from sympy.interactive import printing
printing.init_printing(use_latex=True)

import sympy as sp

x,y = sp.symbols("x,y")

# Estableciendo la ecuacion con la que vamos a trabajar
diff_cuadrados = x**2 - y**2
print("Diferencia de cuadrados")
display(diff_cuadrados)

print()

# Uso de factor
ec_factor = sp.factor(diff_cuadrados)
print("Expresion factorizada")
display(ec_factor)

print()

# Uso de expand
print("Expresion regresada a su forma original")
display(sp.expand(ec_factor))
```

### Uso de sympify()

**LECTURA DE ECUACIONES INGRESADAS POR EL USUARIO**

Usada para convertir un string en algo con lo que pueda trabajar la biblioteca sympy


```python
# Definiendo expresiones desde teclado

from sympy.interactive import printing
printing.init_printing(use_latex=True)

from sympy import sympify
from sympy.core.sympify import SympifyError
import sympy as sp

expresion =  input("Ingrese su expresion matematica: ")
try:
    expresion = sp.sympify(expresion)
    print("La expresion multiplicada por dos es:")
    display(expresion * 2)
except SympifyError:
    print("Valor invalido")
```


```python
# Multiplicacion de expresiones
from sympy.interactive import printing
printing.init_printing(use_latex=True)

from sympy.core.sympify import SympifyError
import sympy as sp

def producto(expre1, expre2):
    print("\nProducto de:")
    prod =(expre1 * expre2)
    display(prod)
    display(prod.expand())
    
    
print("MULTIPLICACION DE ECUACIONES")

expre1 = input("Ingrese su primera ecuacion")
expre2 = input("Ingrese su segunda ecuacion")

try:
    expre1 = sp.sympify(expre1)
    expre2 = sp.sympify(expre2)
except SympifyError:
    print("Valor invalido")
else:
    producto(expre1, expre2)

```

# Resolviendo ecuaciones

## Uso de solve()

Usado para encontrar la solucionde a la ecuacion, la funcion resulve las expresiones entendiendo que son igual a cero


```python
from sympy.interactive import printing
printing.init_printing(use_latex=True)

import sympy as sp

x = sp.Symbol("x")

ecuacion = x -10 -7
# Devuelve una lista con el valor que hace cero a la ecuacion.

display(sp.solve(ecuacion))
display(sp.solve(ecuacion, dict=True))

```


```python
# Resolucion de ecuaciones cuadraticas

from sympy.interactive import printing
printing.init_printing(use_latex=True)

from sympy.core.sympify import SympifyError
import sympy as sp

ecuacion = input("ingrese la ecuacion a resolver")

try:
    ecuacion = sp.sympify(ecuacion)
    print("Ecuacion\t")
    display(ecuacion)
except SympifyError:
    print("Valor invalido")
else:
    print("Soluciones:\t",end="")
    display(sp.solve(ecuacion, dict=True))

```


```python
# Resolucion de una variable en terminos de otra
## Ejemplo de la ecuacion cuadratica


from sympy.interactive import printing
printing.init_printing(use_latex=True)

import sympy as sp

x,a,b,c = sp.symbols("x,a,b,c")
exprecion = a*x**2 + b*x +c

print("Las soluciones de una ecuacion cuadratica son: ")
display(sp.solve(exprecion, x, dict=True))
```

### Resolucion de sistema de ecuaciones lineales



```python
# Configuracion inicial
from sympy.interactive import printing
printing.init_printing(use_latex=True)

# Importamos los paquetes que vamos a usar
import sympy as sp

x,y = sp.symbols("x,y")
ecuacion_1 = 2*x + 3*y -6
ecuacion_2 = 3*x + 2*y -12

# llamada a solve con los dos elementos en una tupla

print("Sistema de ecuaciones lineales")
display(ecuacion_1, ecuacion_2)

print("\nSolucion")
display(sp.solve((ecuacion_1, ecuacion_2), dict=True))

print("\nComprando solucion")

soluciones = sp.solve((ecuacion_1, ecuacion_2), dict= True)
print("El valor devuelto es una lista",soluciones)
soluciones = soluciones[0]
display(ecuacion_1.subs({x: soluciones[x], y: soluciones[y]}))
display(ecuacion_2.subs({x: soluciones[x], y: soluciones[y]}))


```

## Trabajando con series




```python
from sympy.interactive import printing
printing.init_printing(use_latex=True)

import sympy as sp


def imprimir_serie(n):
    printing.init_printing(order="rev-lex") #Establece el orden de la impresion

    x = sp.Symbol("x")
    serie = x
    for i in range(2, n+1):
        serie = serie+((x**i)/i)
    display(serie)
    print()
    sp.pprint(serie)
    
        
n = int(input("Ingrese el numero de terminos que quiere en la serie: "))
imprimir_serie(n)
```

## Graficas usando sympy



```python
# Graficando una funcion lineal
from sympy.interactive import printing
printing.init_printing(use_latex=True)

import sympy as sp

x = sp.Symbol("x")
print("Graficando la funcion y=2x+3")
display(sp.plot(2*x+3))
```


```python
# Graficando delimintando valores de x
# Estableciendo el titulo de los ejes
# Graficando una funcion lineal
from sympy.interactive import printing
printing.init_printing(use_latex=True)

import sympy as sp

x = sp.Symbol("x")
print("Graficando la funcion y=2x+3")
display(
    sp.plot(2*x+3,x+1,(x, -5, 5),
    title="Grafico A", 
    xlabel = "x ", 
    ylabel="y=2*x+3")
)
```

### Graficando expresiones ingresadas por el usuario




```python
from sympy.interactive import printing
printing.init_printing(use_latex=True)
import sympy as sp


# Como se devuelve una lista, tenemos que "sacar" la expresion de ella

def graficar_expresion(expresion):
    y=sp.Symbol("y")
    soluciones=sp.solve(expresion, y)
    # Como se devuelve una lista, tenemos que "sacar" la expresion de ella
    y = soluciones[0]
    sp.plot(y)
    
    
def main():
    # Se convierte la expresion en terminos de x
    expresion = input("ingrese su ecuacion igualando a cero")
    try:
        expresion = sp.sympify(expresion)
    except sp.SympifyError:
        print("Entrada invalida")
    else:
        print("Expresion a graficar")
        display(expresion)
        graficar_expresion(expresion)
        

    
main()





```

# Aplicaciones


```python
# Encontrar el factor de una expresion 

from sympy.interactive import printing
printing.init_printing(use_latex=True)

import sympy as sp

def factorizar(expresion):
    factores=sp.factor(expresion)
    display(factores)
    
def inicio():
    expresion = input("Ingrese la a expresion a factorizar")
    try:
        expresion = sp.simplify(expresion)
    except sp.SympifyError:
        print("Entrada no valida")
    else:
        print("Factores de la expresion")
        display(expresion)
        factorizar(expresion)
        
inicio()
```


```python
# Gaficador de ecuaciones

from sympy.interactive import printing
printing.init_printing(use_latex=True)
import sympy as sp


def graficar():
    y=sp.Symbol("y")
    soluciones=sp.solve(expresion, y)
    # Como se devuelve una lista, tenemos que "sacar" la expresion de ella
    y = soluciones[0]
    sp.plot(y)
    
    

def inicio():
    expre1, expre2 =(input("Ingrese expresion igualando a cero: ") for_ in range(2))
    try:
        expre1 = sp.sympify(expre1)
        expre2 = sp.sympify(expre2)
    except sp.SympifyError:
        print("Entrada invalida")
    else:
        
        

```


```python

```

922d0a328a445b0cf23bd062903327a59ae60af5
ipynb
Jupyter Notebook
E-0 Uso de sympy.ipynb
MkCst/Python-numerico
7dd8b57b8161e5432f9b6d535228bad840e883f7
CC0-1.0
E-0 Uso de sympy.ipynb
MkCst/Python-numerico
7dd8b57b8161e5432f9b6d535228bad840e883f7
CC0-1.0
E-0 Uso de sympy.ipynb
MkCst/Python-numerico
7dd8b57b8161e5432f9b6d535228bad840e883f7
CC0-1.0
Qwen/Qwen-72B
1. YES
2. YES