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)