import sympy
import Basics
import stl_importer
import mesh
import scipy as sp
sympy.init_session()
def planeConvert(bp):
#Converts a Basics.plane object, bp, to a sympy function representing that plane.
x,y,z=sympy.symbols('x y z')
nor = bp.normal
pos = bp.origin
return sympy.Eq(nor[0]*(x-pos[0]) + nor[1]*(y-pos[1]) + nor[2]*(z-pos[2]),0)
from sympy import init_printing init_printing() # doctest: +SKIP from sympy import init_session init_session() # doctest: +SKIP
# Compute rho=-div(A*grad(phi))+c*phi in curvilinear coordinates
# How to run the script:
# >> ipython3 qtconsole
# >> run quasi_neutrality_curvilinear.py circle
import sys
import h5py
import numpy as np
import sympy as sp
from sympy import *
sp.init_session()
sp.init_printing()
mapping = sys.argv[1]
s = sp.symbols('s', real=True, positive=True)
t = sp.symbols('theta', real=True, positive=True)
if (mapping == 'circle'):
x = s * sp.cos(t)
y = s * sp.sin(t)
elif (mapping == 'target'):
k = sp.symbols('kappa', real=True, positive=True)
d = sp.symbols('Delta', real=True, positive=True)
xp = 0.0
yp = 0.0
x = xp + s * sp.cos(t) - k * s * sp.cos(t) - d * s**2
y = yp + s * sp.sin(t) + k * s * sp.sin(t)
elif (mapping == 'czarny'):
print('Not implemented')
# SymPy es una biblioteca de Python para matematica simbolica. Apunta a convertirse en un sistema de algebra computacional (CAS) con todas sus prestaciones, manteniendo el codigo tan simple como sea posible para manterlo comprensible y facilmente extensible.
# Esta escrito totalmente en Python y no requiere bibliotecas adicionales. Este proyecto comenzo en 2005, fue lanzado al publico en 2007 y a el han contribuido durante estos años cientos de personas.
# https://www.sympy.org/en/index.html
from sympy import init_session # Se encarga de importar todas las funciones básicas y preparar las salidas gráficas.
init_session(
use_latex=True
) # 'init_session lleva' a cabo algunas acciones por el usuario: Gracias a 'use_latex=True' se obtiene la salida en LATTEX
from sympy import init_printing
init_printing()
# Importar funciones utiles necesarias
from sympy import (symbols, pi, I, E, cos, sin, exp, tan, simplify, expand,
factor, collect, apart, cancel, expand_trig, diff,
Derivative, Function, integrate, limit, series, Eq, solve,
dsolve, Matrix, N)
# Importar todo, pero se debe usar con cuidado:
#from sympy import *
a = symbols('a')
# Consola: 'a'
# Consola: '(a + pi) ** 2'
# Consola: 'E'
print(type(a))
b = 2 * a
# Consola: 'b'
print(type(b))
# -*- coding: utf-8 -*-
"""
Created on Thu Mar 28 15:57:09 2019
@author: javie
"""
# SymPy Imports
from sympy import init_session
init_session()
gini = 0.7
pLambda = (1 + gini) / (2 * gini)
population = 4000
thetaMin = 0.1
cParam = 0.01
gamma = 2
delta = 0.5
cFijo = 0
discountQ = 0.7
probRichest = 0.99
p, q, th = symbols('p q th', real=True)
dem = symbols('dem', integer=True)
from sympy.stats import P, E, variance, Binomial, cdf, density, Pareto
pa = Pareto("pa", thetaMin, pLambda)
bi = Binomial("bi", population, 1-cdf(pa)(th))
Created on Thu May 28 21:28:44 2020
@author: Emmanuel Torres Molina
"""
"""
Script con una Introducción y los primeros pasos de la Computación Simbólica a
través del Paquete Sympy de Python.
"""
# ----------------------------------------------------------------------------
# ----------------------------------------------------------------------------
# Importo todos los módulos que voy a utilizar:
from sympy import init_session
init_session(use_latex=True) # Activo las Impresiones con Latex
from sympy import *
# ----------------------------------------------------------------------------
# Si quiero una Variable como "Símbolo" primero debo crearla como tal.
# Las Variables de tipo "Symbols" actúan como contenedores en lo que no sabemos
# que hay (un real, un complejo, una lista, etc.)
# Hay que tener en cuenta que una cosa es el nombre de la variable y otra el
# símbolo con el que se representa.
# NOTA: Las Operaciones con Símbolos devuelven Símbolos y/o Expresiones.
# Creo 2 Variables Simbólicas
a, b = symbols('a, b')
# c no es una Variable Simbólica sino que es un variable del tipo "potencia"
c = (a + b)**2
from string import *
import math
from math import *
import itertools
from itertools import *
import functools
from functools import *
import collections
from collections import *
import operator
from operator import *
pow = __builtins__.pow
import mpmath
import scipy
import numpy as np
from sympy import init_session
init_session()
###END
with open(__file__, "r") as setupfile:
print("".join(
map(">>> {}".format, takewhile(lambda ln: ln != "###END\n",
setupfile))))
print("running on {}".format(sys.executable))
print(
"reminder from your friendly neighbourhood spiderman to use sage instead")
#!/usr/bin/env python2
# -*- coding: utf-8 -*-
"""
Created on Tue Oct 23 13:18:03 2018
@author: xsxsz
"""
import sympy as sy
import matplotlib.pyplot as plt
sy.init_session(use_latex=True)
sy.init_printing(use_latex=True)
print sy.sqrt(8)
x = sy.symbols('x')
print '--------'
print x
print '--------'
y = sy.Function('y')
y1 = 2 * x
print y1
print '--------'
y2 = sy.diff(x * 2)
print y2
print '--------'
y3 = sy.diff(sy.exp(x) * sy.sin(x))
print y3
print '--------'
print sy.latex(y3)
print '--------'
# -*- coding: utf-8 -*-
"""
Created on Wed May 5 15:01:40 2021
@author: danaukes
"""
import sympy
sympy.init_session(use_latex=False, quiet=True)
# from math import pi
from sympy import pi
from sympy import sin, cos, acos, atan
arctan = lambda x: atan(x)
arccos = lambda x: acos(x)
# from numpy import sin,cos,arccos,arctan
# import numpy.arccos as acos
import matplotlib.pyplot as plt
x = sympy.Symbol('x')
d = sympy.Symbol('d')
trg = 1 - 2 * arccos((1 - d) * sin(2 * pi * x)) / pi
sqr = 2 * arctan(sin(2 * pi * x) / d) / pi
f_trg = lambda x, d: (1 - 2 * arccos((1 - d) * sin(2 * pi * x)) / pi)
f_sqr = lambda x, d: (2 * arctan(sin(2 * pi * x) / d) / pi)
swt = ((1 + f_trg((2 * x - 1) / 4, d) * f_sqr(x / 2, d)) / 2)
f_swt = lambda x, d: ((1 + f_trg((2 * x - 1) / 4, d) * f_sqr(x / 2, d)) / 2)
if __name__ == '__main__':
import numpy
# EJERCICIOS
from sympy import init_session
init_session(use_latex=True)
from sympy import init_printing
init_printing()
from sympy import (symbols, sin, expand, expand_trig)
#%% 1.-
print('1.-')
x, y = symbols('x y') # Consola: 'expr1'
expr1 = (x**3 + 3 * y + 2)**2
sol1 = expr1.expand() # Consola: 'sol1'
#%% 2.-
print('2.-')
expr2 = (3 * x**2 - 2 * x + 1) / (x - 1)**2 # Consola: 'expr2'
sol2 = expr2.apart() # Consola: 'sol2'
#%% 3.-
print('3.-')
expr3 = x**3 + 9 * x**2 + 27 * x + 27 # Consola: 'expr3'
sol3 = expr3.factor() # Consola: 'sol3'
#%% 4.-
print('4.-')
import sympy
import Basics
import stl_importer
import mesh
import scipy as sp
sympy.init_session()
def planeConvert(bp):
#Converts a Basics.plane object, bp, to a sympy function representing that plane.
x, y, z = sympy.symbols('x y z')
nor = bp.normal
pos = bp.origin
return sympy.Eq(
nor[0] * (x - pos[0]) + nor[1] * (y - pos[1]) + nor[2] * (z - pos[2]),
0)
" Sympy"
" Aprovechamiento del potencial de Python para el uso de álgebra simbólica"
"2007 Año de lanzamiento y desde entonces ha crecido ya que es un open source"
from sympy import *
from sympy import init_session
init_session(use_latex=True) " Importa todo y activa la impresión de expresiones en LaTeX"
" Podemos manejar variables diferente a solo las numéricas"
a=symbols("a") " Definimos símbolos"
a
a+b
b=1
a+b
b=pi
c=a*b
type(c) " Tipo multiplicación, podemos sobreescribir ya que estamos trabajando sobre Python"
alpha, beta= symbols("alpha beta")
(alpha + beta)
alpha.assumptions0 " Por defecto trabajará en los complejos (.assumptions0 brindará las propiedades)"
x, y, z, t = symbols('x y z t')
x.assumptions0
x=symbols("x", real=True, positive=True) "Para especificar un campo, tendrá que ser desde la hipótesis"
x.assumptions0
cos(z)**2+sin(z)**2
simplify(_) " Simplifica la expresión, en este caso, usando identidades trigonométricas"
sqrt(z**2)
simplify(_) " Como z por defecto es un complejo, no podrá hacer nada simplify"
y=symbols("y",real=True)
sqrt(y**2)
simplify(_) " Nos dará el valor absoluto ya que no sabemos si y es negativo o postivo"
.subs( , ) " Por cada aparación del primer argumento lo sustuirá por el segundo argumento"
(cos(z)**2+sin(z)**2)
from sympy import sympify
def non_commutative_sympify(expr_string):
parsed_expr = sympy.parsing.sympy_parser.parse_expr(expr_string,
evaluate=False)
new_locals = {
sym.name: sympy.Symbol(sym.name, commutative=False)
for sym in parsed_expr.atoms(sympy.Symbol)
}
return sympy.sympify(expr_string, locals=new_locals)
init_session(quiet=True)
init_printing(use_unicode=False,
wrap_line=False,
no_global=True,
use_latex=True)
Nz = 5
dz, bmz, cmz, delta, dt, n, np1, np1ov2, np3ov2, nm1, al, bl, cl, Co, wl, bz, az = sym(
"Δ_z,b_mz, c_mz,δ, Δ_t,n, n+1, n+1/2, n+3/2, n-1, a_L, b_L, c_L, Co, omega_L, b_z, a_z"
)
# bz, az from cpml update
#al, bl, cl lorentz polarisation
sigmaE, sigmaH, De, K, Kt, Du, Ex, Hy, Je, P, Psi_exy, Psi_hxy = sym(
"σ_E, σ_H, D_E, K, K^t, D_μ, Ex, Hy, J_e, P, ψ_(exy), ψ_(hxy)",
commutative=False)
Exnp1 = Ex**np1
#!/usr/bin/env python3
#from EE import *
#from numpy import *
#from matplotlib.pyplot import *
from sympy import init_session
from sympy.external import import_module
def import_all_from(module_name):
print('Importing everything from "{}"'.format(module_name))
print(' NOTE: This is currently broken. Type "from EE import *" manually')
mod = import_module(module_name,
warn_not_installed=True,
__import__kwargs={'globals':globals(), 'locals':locals(), 'fromlist':['*']})
if not mod:
print('shit failed')
return
for k in dir(mod):
locals()[k] = getattr(mod, k)
if __name__ == '__main__':
import_all_from('EE')
init_session(quiet=True, ipython=True, pretty_print=True, auto_symbols=True)
