def equilibrium_stability_check(equilibrium_points, input_matrix):
s = sp.symbols('s')
t = sp.symbols('t')
x = deltax_deltat(s, t, input_matrix)
y = deltay_deltat(s, t, input_matrix)
dx_ds = sp.Lambda([s, t], sp.diff(x, s))
dy_ds = sp.Lambda([s, t], sp.diff(y, s))
dx_dt = sp.Lambda([s, t], sp.diff(x, t))
dy_dt = sp.Lambda([s, t], sp.diff(y, t))
stable_list = []
for i in equilibrium_points:
s = i[0]
t = i[1]
J00 = float(dx_ds(s, t))
J01 = float(dx_dt(s, t))
J10 = float(dy_ds(s, t))
J11 = float(dy_dt(s, t))
Jacobian_matrix = np.matrix([[J00, J01], [J10, J11]])
print(Jacobian_matrix)
Jacobian_eigvals, Jacobian_eigvecs = np.linalg.eig(Jacobian_matrix)
Jacobian_real_eig = np.real(Jacobian_eigvals)
stable = True
for j in Jacobian_real_eig:
if j > 0:
stable = False
break
stable_list.append(stable)
return stable_list
def Rot_AngAx(n, theta):
"""
Rotation matrix
Rodrigues formula
angle-axis parametrization
INPUT: n - vector [nx,ny,nz]
0 <= theta <= pi
OUTPUT: Rot - matrix(3x3)
nx,ny,nz = symbols('nx,ny,nz')
n = [nx,ny,nz]
"""
dimens = 3
"""
R = sp.MatrixSymbol('R', dimens, dimens)
"""
i, j = sp.symbols('i,j')
R = sp.FunctionMatrix(dimens, dimens,
sp.Lambda((i, j),
cos(theta) * KroneckerDelta(i, j)))
for k in range(dimens):
R -= sp.FunctionMatrix(
dimens, dimens, sp.Lambda((i, j),
sin(theta) * Eijk(i, j, k) * n[k]))
Rot = sp.Matrix(R)
R2 = sp.zeros(dimens)
for i in range(dimens):
R2.row_op(i, lambda v, j: (1 - cos(theta)) * n[i] * n[j])
Rot += R2
Rot = sp.N(Rot, 4)
#Rot = sp.matrix2numpy(Rot)
return Rot
def transform_set(x, expr, sympy_set):
""" Transform a sympy_set by an expression
>>> x = sympy.Symbol('x')
>>> domain = sympy.Interval(-sympy.pi / 4, -sympy.pi / 6, False, True) | sympy.Interval(sympy.pi / 6, sympy.pi / 4, True, False)
>>> transform_set(x, -2 * x, domain)
[-pi/2, -pi/3) U (pi/3, pi/2]
"""
if isinstance(sympy_set, sympy.Union):
return sympy.Union(
transform_set(x, expr, arg) for arg in sympy_set.args)
if isinstance(sympy_set, sympy.Intersection):
return sympy.Intersection(
transform_set(x, expr, arg) for arg in sympy_set.args)
f = sympy.Lambda(x, expr)
if isinstance(sympy_set, sympy.Interval):
left, right = f(sympy_set.left), f(sympy_set.right)
if left < right:
new_left_open = sympy_set.left_open
new_right_open = sympy_set.right_open
else:
new_left_open = sympy_set.right_open
new_right_open = sympy_set.left_open
return sympy.Interval(sympy.Min(left, right), sympy.Max(left, right),
new_left_open, new_right_open)
if isinstance(sympy_set, sympy.FiniteSet):
return sympy.FiniteSet(list(map(f, sympy_set)))
def make_float_function(x):
""" Returns a sympy Function that constructs a Float.
Args:
x: Float
Returns:
sympy Function
"""
return sy.Lambda((), x)
def exact_diff(self, xn, f):
f = sp.Lambda(x, f)
f1 = sp.Lambda(x, sp.diff(f(x), x))
nxt_x = xn - (f(xn) / f1(xn))
if nxt_x < xn:
diff = (xn + abs(nxt_x - xn))
if diff > 20:
diff = 20
else:
diff = (xn - abs(nxt_x - xn))
if diff < 0:
diff = 0
tangent = f1(xn) * diff + f(xn) - (f1(xn) * xn)
self.l.append([nxt_x, tangent, diff, f(xn)])
return self.l
def _get_initial_equality(node_object):
if isinstance(node_object, sm.MatrixSymbol):
return sm.Eq(node_object,
sm.zeros(*node_object.shape),
evaluate=False)
elif isinstance(node_object, sm.Symbol):
return sm.Eq(node_object, 1.0, evaluate=False)
elif issubclass(node_object, sm.Function):
t = sm.symbols('t')
return sm.Eq(node_object, sm.Lambda(t, 0.0), evaluate=False)
def diff_func(self, xn, f, dp):
f = sp.Lambda(x, f)
f1 = sp.Lambda(
x, sp.differentiate_finite(f(x), x, points=[x - dp, x + dp]))
nxt_x = xn - (f(xn) / f1(xn))
if nxt_x < xn:
diff = (xn + abs(nxt_x - xn))
if diff > 20:
diff = 20
else:
diff = (xn - abs(nxt_x - xn))
if diff < 0:
diff = 0
b = f(xn) - f1(xn) * xn
tangent = f1(xn) * diff + b
func = f(xn)
self.l.append([nxt_x, tangent, diff, func])
#print(self.l[0])
return self.l
def __init__(self, expr):
# преобразования для парсера sympy
transformations = standard_transformations + (implicit_multiplication, # умножение без знака умножения
implicit_application, # применение скалярных ф-ий без скобок
convert_xor) # каретка как символ возведения в степень
# замены для парсера
replacers = {'e' : e,
'tg' : sympy.functions.tan,
'ctg' : sympy.functions.cot,
'lg' : sympy.Lambda(x, sympy.functions.log(x) / sympy.functions.log(10))}
expr = expr.lower()
self.fun = parse_expr(expr,
transformations = transformations,
local_dict=replacers)
if self.fun.free_symbols - {x} != set():
raise ValueError('Выражение содержит переменные кроме x')
def __init__(self, y_shift: float = 0):
"""
This Class is representing the a dummy potential.
It returns a constant value equalling the y_shift parameter.
:param y_shift: This will be the constant return value, defaults to 0
:type y_shift: float, optional
"""
self.V_orig = sp.Lambda(self.position, self.y_shift)
self.constants = {self.y_shift: y_shift}
self.V = self.V_orig.subs(self.constants)
self.dVdpos = sp.diff(self.V, self.position)
super().__init__()
self._calculate_energies = lambda positions: np.squeeze(
np.full(len(positions), y_shift))
self.dVdpos = self._calculate_dVdpos = lambda positions: np.squeeze(
np.zeros(len(positions)))
def testToCalchas(self):
x_ = sympy.symbols('x')
f = sympy.symbols('f', cls=sympy.Function)
test_list = [(sympy.Symbol('a'), Id('a')), (sympy.pi, pi), (1, Int(1)),
(sympy.Rational(47, 10), Float(4.7)), (6, Int(6)),
(30, Int(30)), (15, Int(15)),
(f(12, 18), Call(Id('f'), [Int(12), Int(18)])),
({
2: 1,
3: 2
}, DictFunctionExpression({
Int(2): Int(1),
Int(3): Int(2)
})), (18, Int(18)), (sympy.pi, pi),
(sympy.Lambda(x_, x_), Fun(Id('x'), Id('x')))]
for (tree, res) in test_list:
builder = Translator()
calchas_tree = builder.to_calchas_tree(tree)
self.assertEqual(calchas_tree, res)
def testToSympy(self):
_x = sympy.symbols('x_')
f = sympy.symbols('f', cls=sympy.Function)
test_list = [(Id('a'), sympy.Symbol('a')),
(Id('pi'), sympy.Symbol('pi')), (pi, sympy.pi),
(Int(1), 1), (Float(4.7), sympy.Rational(47, 10)),
(Gcd([Int(12), Int(18)]), 6), (Sum([Int(12),
Int(18)]), 30),
(Sum([Int(12), Int(1), Int(2)]), 15),
(Call(Id('f'), [Int(12), Int(18)]), f(12, 18)),
(FactorInt([Int(18)]), {
2: 1,
3: 2
}), (Gcd([Sum([Int(18), Int(18)]),
Int(18)]), 18), (pi, sympy.pi),
(Fun(Id('x'), Id('x')), sympy.Lambda(_x, _x))]
for (tree, res) in test_list:
builder = Translator()
sympy_tree = builder.to_sympy_tree(tree)
self.assertEqual(sympy_tree, res)
def _process_funcxy(args, testx, testy):
isdy = False
f = args.pop()
if isinstance(
f, (sp.Tuple, tuple, list)
): # if (f1 (x, y), f2 (x, y)) functions or expressions present in args they are individual u and v functions
c1, c2 = callable(f[0]), callable(f[1])
if c1 and c2: # two Lambdas
f = __fxfy2fxy(f[0], f[1])
elif not (c1 or c2): # two expressions
vars = tuple(
sorted(sp.Tuple(f[0], f[1]).free_symbols,
key=lambda s: s.name))
if len(vars) != 2:
raise ValueError(
'expression must have exactly two free variables')
return args, __fxfy2fxy(sp.Lambda(vars, f[0]),
sp.Lambda(vars, f[1])), False
else:
raise ValueError(
'field must be specified by two lambdas or two expressions, not a mix'
)
# one function or expression
if not callable(f): # convert expression to function
if len(f.free_symbols) != 2:
raise ValueError('expression must have exactly two free variables')
f = sp.Lambda(tuple(sorted(f.free_symbols, key=lambda s: s.name)), f)
for y in testy: # check if returns 1 dy or 2 u and v values
for x in testx:
try:
v = f(x, y)
except (ValueError, ZeroDivisionError, FloatingPointError):
continue
try:
_, _ = v
f = __fxy2fxy(f)
break
except:
f = __fdy2fxy(f)
isdy = True
break
else:
continue
break
return args, f, isdy
def plotf(*args, fs=None, res=12, style=None, **kw):
"""Plot function(s), point(s) and / or line(s).
plotf ([+,] [limits,] *args, fs = None, res = 12, **kw)
limits = set absolute axis bounds: (default x is (0, 1), y is automatic)
x -> (-x, x, y auto)
x0, x1 -> (x0, x1, y auto)
x, y0, y1 -> (-x, x, y0, y1)
x0, x1, y0, y1 -> (x0, x1, y0, y1)
fs = set figure figsize if present: (default is (6.4, 4.8))
x -> (x, x * 3 / 4)
-x -> (x, x)
(x, y) -> (x, y)
res = minimum target resolution points per 50 x pixels (more or less 1 figsize x unit),
may be raised a little to align with grid
style = optional matplotlib plot style
*args = functions and their formatting: (func, ['fmt',] [{kw},] func, ['fmt',] [{kw},] ...)
func -> callable function takes x and returns y
(x, y) -> point at x, y
(x0, y0, x1, y1, ...) -> connected lines from x0, y1 to x1, y1 to etc...
((x0, y0), (x1, y1), ...) -> same thing
fmt = 'fmt[#color][=label]'
"""
if not _SPLOT:
return None
obj = plt
legend = False
args, xmin, xmax, ymin, ymax, kw = _process_head(obj,
args,
fs,
style,
ret_xrng=True,
kw=kw)
while args:
arg = args.pop()
if isinstance(arg, (sp.Tuple, tuple, list)): # list of x, y coords
if isinstance(arg[0], (sp.Tuple, tuple, list)):
arg = list(it.chain.from_iterable(arg))
pargs = [arg[0::2], arg[1::2]]
else: # y = function (x)
if not callable(arg):
if len(arg.free_symbols) != 1:
raise ValueError(
'expression must have exactly one free variable')
arg = sp.Lambda(arg.free_symbols.pop(), arg)
win = _FIGURE.axes[-1].get_window_extent()
xrs = (
win.x1 - win.x0
) // 50 # scale resolution to roughly 'res' points every 50 pixels
rng = res * xrs
dx = dx2 = xmax - xmin
while dx2 < (
res * xrs
) / 2: # align sampling grid on integers and fractions of integers while rng stays small enough
rng = int(rng + (dx2 - (rng % dx2)) % dx2)
dx2 = dx2 * 2
xs = [xmin + dx * i / rng for i in range(rng + 1)]
ys = [None] * len(xs)
for i in range(len(xs)):
try:
ys[i] = _cast_num(arg(xs[i]))
except (ValueError, ZeroDivisionError, FloatingPointError):
pass
# remove lines crossing graph vertically due to poles (more or less)
if ymin is not None:
for i in range(1, len(xs)):
if ys[i] is not None and ys[i - 1] is not None:
if ys[i] < ymin and ys[i - 1] > ymax:
ys[i] = None
elif ys[i] > ymax and ys[i - 1] < ymin:
ys[i] = None
pargs = [xs, ys]
args, fargs, kwf = _process_fmt(args, kw)
legend = legend or ('label' in kwf)
obj.plot(*(pargs + fargs), **kwf)
if legend or 'label' in kw:
obj.legend()
return _figure_to_image()
'''
函数
'''
import sympy
sympy.init_printing()
from sympy import I, pi, oo
x, y, z = sympy.symbols("x, y, z")
# 创建函数符号
f = sympy.Function('f')
fx = f(x)
print(fx)
g = sympy.Function('g')(x,y,z)
print(g)
print(g.free_symbols)
# 常用函数符号
sinx = sympy.sin(x)
print(sinx)
# 函数简单计算
print(sympy.sin(1.5 * pi))
# 指定函数变量的数据类型
n = sympy.Symbol('n',integer=True)
print(sympy.sin(n * pi))
# Lambda
h = sympy.Lambda(x, x**2)
print(h)
print(h(5))
print(h(1 + x))
def _visit_fun(self, tree: FunctionExpression, *args) -> sympy.Expr:
if isinstance(tree, FormulaFunctionExpression):
return sympy.Lambda(self.visit(tree.var, *args),
self.visit(tree.expr, *args))
def __eval_bind(self):
parser = Parser.get_instance()
xyz = parser.get_symbols(self.__raw_args, Parser.FILTER_XYZ)
tuv = parser.get_symbols(self.__raw_args, Parser.FILTER_TUV)
if len(xyz) > 0 and len(tuv) > 0:
raise ParsingError("Parsed.eval_bind",
"(x, y, z) and (t, u, v) shouldn't be mixed.")
if self.__is_parametric:
if len(self.__raw_args) == 2:
if len(tuv) == 0:
raise ParsingError("Parsed.eval_bind",
"Too few parametric variables.")
elif len(tuv) < 2:
self.__bind(tuple(tuv), tuple(self.__raw_args),
PlotType.PARAMETRIC_2D)
else:
raise ParsingError("Parsed.eval_bind",
"Too many parametric variables.")
elif len(self.__raw_args) == 3:
if len(tuv) == 0:
raise ParsingError("Parsed.eval_bind",
"Too few parametric variables.")
elif len(tuv) < 2:
self.__bind(tuple(tuv), tuple(self.__raw_args),
PlotType.PARAMETRIC_3D)
elif len(tuv) == 2:
self.__bind(tuple(tuv), tuple(self.__raw_args),
PlotType.PARAMETRIC_SURFACE)
else:
raise ParsingError("Parsed.eval_bind",
"Too many parametric variables.")
else:
raise ParsingError("Parsed.eval_bind",
"Unexpected parametric size.")
elif len(self.__raw_args) == 1:
arg = self.__raw_args[0]
if len(xyz) == 0:
self.__bind(Parser.Y, arg.evalf(), PlotType.LINE_2D)
elif len(xyz) == 1:
if Parser.X in xyz:
self.__bind(Parser.Y, arg, PlotType.LINE_2D)
else:
raise ParsingError(
"Parsed.eval_bind",
"Couldn't evaluate univariate statement.")
elif len(xyz) == 2:
if not Parser.Z in xyz:
self.__bind(Parser.Z, arg, PlotType.SURFACE)
else:
raise ParsingError(
"Parsed.eval_bind",
"Couldn't evaluate bivariate statement.")
elif len(self.__raw_args) == 2:
larg = self.__raw_args[0]
rarg = self.__raw_args[1]
larg_name = getattr(larg, 'name', None)
if self.__raw_relation in Parser.LT + Parser.GT:
if Parser.Z in xyz:
raise ParsingError("Parsed.eval_bind",
"3D implicit plots are not supported.")
else:
self.__bind(None, self.__raw_relation(larg, rarg),
PlotType.IMPLICIT_2D)
elif isinstance(larg, Parser.FUNC_TYPES):
if larg_name is None or parser.is_defined(larg_name):
raise ParsingError(
"Parsed.eval_bind",
"Function name already defined or reserved.")
args = larg.args
if any([not isinstance(a, Parser.VAR_TYPES) for a in args]):
raise ParsingError("Parsed.eval_bind",
"Function arguments must be symbols.")
elif len(args) != len(set(args)):
raise ParsingError("Parsed.eval_bind",
"Duplicate parameters.")
func = sy.Lambda(args, rarg)
self.__bind(sy.Function(larg_name), func, None)
elif isinstance(larg,
Parser.VAR_TYPES) and not parser.is_reserved(larg):
if parser.is_defined(larg_name):
raise ParsingError("Parsed.eval_bind",
"Variable name already defined.")
if len(parser.get_symbols(rarg, Parser.FILTER_RESERVED)) > 0:
raise ParsingError("Parsed.eval_bind",
"Cannot map to reserved variables.")
self.__bind(larg, rarg, None)
elif Parser.Z in xyz:
sol = sy.solve(sy.Eq(larg, rarg), Parser.Z, domain=sy.S.Reals)
if isinstance(sol, (list, tuple, Tuple)):
if len(sol) == 0:
raise ParsingError("Parsed.eval_bind", "No solutions.")
elif len(sol) == 1:
self.__bind(Parser.Z, sol[0], PlotType.SURFACE)
else:
self.__bind(Parser.Z, sol, PlotType.SURFACE)
else:
self.__bind(Parser.Z, sol, PlotType.SURFACE)
elif Parser.Y in xyz:
sol = sy.solve(sy.Eq(larg, rarg), Parser.Y, domain=sy.S.Reals)
if isinstance(sol, (list, tuple, Tuple)):
if len(sol) == 1:
self.__bind(Parser.Y, sol[0], PlotType.LINE_2D)
else:
self.__bind(None, sy.Eq(larg, rarg),
PlotType.IMPLICIT_2D)
else:
self.__bind(Parser.Y, sol, PlotType.LINE_2D)
elif Parser.X in xyz:
self.__bind(Parser.X,
parser.solve_for(Parser.X, sy.Eq(larg, rarg)),
None)
else:
self.__bind(None, sy.Eq(larg, rarg), None)
else:
raise ParsingError("Parsed.eval_bind",
"Unexpected argument structure.")
import sympy as sy
sy.init_printing()
x, y = sy.var('x, y')
# declaração de função
f = sy.Lambda(x, (x**2))
g = sy.Lambda(x, (x**3 - 3 * x + 2) * sy.exp(-x / 4) - 1)
# resultado derivada
result1 = sy.diff(f(x), x)
sy.print_rcode(result1)
# Para avaliar a derivada em um ponto, por exemplo, para calcular f′(1) , digitamos:
result2 = sy.diff(g(x), x).subs(x, 1)
sy.print_rcode(result2)
## Reta Tangente
fl = sy.Lambda(x, sy.diff(f(x), x))
x0 = -1 / 2
r = sy.Lambda(x, fl(x0) * (x - x0) + f(x0))
r
# sy.plot(f(x), (x,-2,2))
while (True):
validando = False
print(
"\nInforme os dados necessarios para realizacao dos metodos iterativos, sendo ele a funcao, intervalo [a, b] e sua precisao."
)
print("\nExemplo:",
"(2*ln(x**2))/(sqrt(x)-5*e^(-x))",
"a:3",
"b:5",
"precisao: 0.0005\n",
sep="\n")
f = (input("Digite a sua funcao: "))
f = f.replace("e", "2.718281828")
print(f)
f = sympy.Lambda(x, sympy.sympify(f))
a = int(input("Digite a: "))
b = int(input("Digite b: "))
precisao = float(input("Digite precisao: "))
if (teorema.bolzano(f, a, b) == False):
print(
"\nNao e possivel afirma a existencia de uma solucao no intervalo [{},{}], pois pois f({})*f({}) > 0."
.format(a, b, a, b))
else:
print(
"\nIntervalo contem pelo menos uma solucao, pois f({})*f({}) < 0.".
format(a, b))
validando = True
if (validando == True):
# coding: utf-8
#---- ch08/import
import numpy as np
from scipy.optimize import fsolve
import matplotlib.pyplot as plt
import sympy as sp
sp.init_printing()
#---- ch08/define-symbols
k1, k0, c1, c0, g, n = sp.symbols("k1 k0 c1 c0 g n")
alpha, beta, delta, theta = sp.symbols("alpha beta delta theta")
#---- ch08/production
f = sp.Lambda(k0, k0**alpha)
f(k0)
#---- ch08/dynamics-k
EK = k1 - (f(k0) - c0 + (1 - delta) * k0) / (1 + g) / (1 + n)
EK
#---- ch08/dynamics-c
EC = c1 - c0 * (beta * (f(k0).diff(k0) + 1 - delta))**(1 / theta) / (1 + g)
EC
#---- ch08/steady-state
E = sp.Matrix([EK, EC]).subs({k1: k0, c1: c0})
E
#---- ch08/parameters
def _update_namespace(self, name, vars, expr):
self.logger.debug('Adding to namespace {!r}: {}'.format(name, expr))
func = sp.Lambda(sp.symbols(vars), expr)
self._sympy_ns[name] = func
w = [sy.symbols("w_%d" % i) for i in range(len(x))] # pesos
# In[10]:
q = sum([w[i] * f(x[i]) for i in range(len(x))])
q
# Para calcular valores aproximados dos pesos $w_i$, escolhemos a base polinomial
#
# $$\{ \phi_n(x) = x^n \}_{n=0}^2$$
#
# para a interpolação de $f(x)$ e um objeto simbólico para representar cada uma dessas funções.
# In[11]:
phi = [sy.Lambda(X, X**n) for n in range(len(x))]
phi
# Agora temos que descobrir os valores dos pesos. A integral $\int_a^b \phi_n(x) \, dx$ pode ser calculada analiticamente para cada função de base. Isto nos ajuda a resolver o seguinte sistema:
#
# $$\sum\limits_{i=0}^2 w_i \phi_n(x_i) = \int_a^b \phi_n(x) \, dx$$
# O sistema pode ser construído no `sympy` da seguinte forma:
# In[12]:
eqs = [
q.subs(f, phi[n]) - sy.integrate(phi[n](X), (X, a, b))
for n in range(len(phi))
]
eqs
# Xs
C1 = sp.Symbol('C1')
C2 = sp.Symbol('C2')
C0 = sp.Symbol('C0')
# Ys
N1 = sp.Symbol('N1')
N2 = sp.Symbol('N2')
x_i = [C1, C2, C0]
y_i = [N1, N2]
# define functions
mu1 = sp.Lambda((C0, C1), mu1_max * C0 * C1 / ((K_10 + C0) * (K_11 + C1)))
mu2 = sp.Lambda((C0, C2), mu2_max * C0 * C2 / ((K_20 + C0) * (K_22 + C2)))
func_dict = {'mu1': mu1, 'mu2': mu2}
# define differential equations
dN1 = sp.sympify('N1*(mu1(C0, C1) + a_11*N1 + a_12*N2 - q)', locals=func_dict)
dN2 = sp.sympify('N2*(mu2(C0, C2) + a_21*N1 + a_22*N2 - q)', locals=func_dict)
dC1 = sp.sympify('q*(C_1i - C1) - 1/y_11 * mu1(C0, C1) * N1', locals=func_dict)
dC2 = sp.sympify('q*(C_2i - C2) - 1/y_22 * mu2(C0, C2) * N2', locals=func_dict)
dC0 = sp.sympify(
'q*(C_0i - C0) - 1/y_10*mu1(C0, C1)*N1 - 1/y_20*mu2(C0, C2)*N2',
locals=func_dict)
equs = [dN1, dN2, dC1, dC2, dC0]
def test_prob():
def emit(name, iname, cdf, args, no_small=False):
V = []
for arg in sorted(args):
y = cdf(*arg)
if isinstance(y, mpf):
e = sp.nsimplify(y, rational=True)
if e.is_Rational and e.q <= 1000 and \
mp.almosteq(mp.mpf(e), y, 1e-25):
y = e
else:
y = N(y)
V.append(arg + (y, ))
for v in V:
if name:
test(name, *v)
for v in V:
if iname and (not no_small or 1 / 1000 <= v[-1] <= 999 / 1000):
test(iname, *(v[:-2] + v[:-3:-1]))
x = sp.Symbol("x")
emit("ncdf", "nicdf", sp.Lambda(x,
st.cdf(st.Normal("X", 0, 1))(x)),
zip(exparg))
# using cdf() for anything more complex is too slow
df = FiniteSet(1, S(3) / 2, 2, S(5) / 2, 5, 25)
emit("c2cdf",
"c2icdf",
lambda k, x: sp.lowergamma(k / 2, x / 2) / sp.gamma(k / 2),
ProductSet(df, posarg),
no_small=True)
dfint = df & sp.fancysets.Naturals()
def cdf(k, x):
k, x = map(mpf, (k, x))
return .5 + .5 * mp.sign(x) * mp.betainc(
k / 2, .5, x1=1 / (1 + x**2 / k), regularized=True)
emit("stcdf", "sticdf", cdf, ProductSet(dfint, exparg))
def cdf(d1, d2, x):
d1, d2, x = map(mpf, (d1, d2, x))
return mp.betainc(d1 / 2,
d2 / 2,
x2=x / (x + d2 / d1),
regularized=True)
emit("fcdf", "ficdf", cdf, ProductSet(dfint, dfint, posarg))
kth = ProductSet(sp.ImageSet(lambda x: x / 5, df), posarg - FiniteSet(0))
emit("gcdf",
"gicdf",
lambda k, th, x: sp.lowergamma(k, x / th) / sp.gamma(k),
ProductSet(kth, posarg),
no_small=True)
karg = FiniteSet(0, 1, 2, 5, 10, 15, 40)
knparg = [(k, n, p)
for k, n, p in ProductSet(karg, karg, posarg
& Interval(0, 1, True, True))
if k <= n and n > 0]
def cdf(k, n, p):
return st.P(st.Binomial("X", n, p) <= k)
emit("bncdf", "bnicdf", cdf, knparg, no_small=True)
def cdf(k, lamda):
return sp.uppergamma(k + 1, lamda) / sp.gamma(k + 1)
emit("pscdf",
"psicdf",
cdf,
ProductSet(karg, posarg + karg - FiniteSet(0)),
no_small=True)
x, i = sp.symbols("x i")
def smcdf(n, e):
return 1 - sp.Sum(
sp.binomial(n, i) * e * (e + i / n)**(i - 1) *
(1 - e - i / n)**(n - i), (i, 0, sp.floor(n * (1 - e)))).doit()
kcdf = sp.Lambda(
x,
sp.sqrt(2 * pi) / x *
sp.Sum(sp.exp(-pi**2 / 8 * (2 * i - 1)**2 / x**2), (i, 1, oo)))
smarg = ProductSet(karg - FiniteSet(0),
posarg & Interval(0, 1, True, True))
karg = FiniteSet(S(1) / 100,
S(1) / 10) + (posarg & Interval(S(1) / 4, oo, True))
for n, e in sorted(smarg):
test("smcdf", n, e, N(smcdf(n, e)))
prec("1e-10")
for x in sorted(karg):
test("kcdf", x, N(kcdf(x)))
prec("1e-9")
for n, e in sorted(smarg):
p = smcdf(n, e)
if p < S(9) / 10:
test("smicdf", n, N(p), e)
prec("1e-6")
for x in sorted(karg):
p = kcdf(x)
if N(p) > S(10)**-8:
test("kicdf", N(p), x)
from itertools import cycle, repeat, count, imap
from math import sin, cos
from constraint_solver import pywrapcp as cp
x, y, z, r, s, t = sym.symbols('x y z r s t')
m, n, i, j, k = sym.symbols('m n i j k', integer=True)
f, g, h = sym.symbols('f g h', cls=sym.Function)
solver = cp.Solver('Counterpoint')
# <codecell>
# motive definition
shk = sym.Lambda((x, y), x + y) #schenkerian
size= 6
motif_xp = [(shk, 0), (shk, 3), (shk, 5), (shk, -1)]
rhythm_xp = [(shk, 0), (shk, 3), (shk, 5), (shk, -1)]
# Same Motif for notes and rhythms for a Fractal Result
motif1 = [(shk, 0), (shk, 3), (shk, 0), (shk, 1), (shk, 0), (shk, 3), (shk, 5), (shk, -1), (shk, 0), (shk, -1), (shk, 5), (shk, -1)] * size
rhythm1 = [(shk, 0), (shk, 3), (shk, 0), (shk, 1), (shk, 0), (shk, 3), (shk, 5), (shk, -1), (shk, 0), (shk, -1), (shk, 5), (shk, -1)] * size
motif2 = [(shk, 0), (shk, 1), (shk, 0), (shk, 3), (shk, 5), (shk, -1), (shk, 0), (shk, -1)] * size
rhythm2 = [(shk, 0), (shk, 1), (shk, 0), (shk, 3), (shk, 5), (shk, -1), (shk, 0), (shk, -1)] * size
motif3 = [(shk, 0), (shk, 3), (shk, 5), (shk, -1)] * size
## Functions
x, y, z = sy.symbols("x, y, z")
#>>> symbols('x:10')
# (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)
#>>> symbols('x(:c)')
# (xa, xb, xc)
#>>> symbols('f,g,h', cls=Function)
# (f, g, h)
f = sy.Function('f')(x)
g = sy.Function("g")(x, y, z)
g.free_symbols #returns a set of unique symbols contained in a given expression
#l = sy.Function("l")(x)
#m = sy.function("m")(l)
h = sy.Lambda(x, x**2)
# h: x ↦ x²
# h(5) = 25
# h(1+x): x ↦ (x+1)²
# h(sy.sin(x)) x ↦ sin²(x)
## Expressions
expr = 1 + 2 * x + 2 * x**2
# expr = 2x² + 2x + 1
print expr.args # (1, 2*x, 2*x**2)
print expr.args[1].args[1] # x
print expr.args[-1].args[1] # x**2
#### Voir Numerical Python Robert Johansson books
polr = sy.apart(1 / (x**2 + 3 * x + 2),
x = deltax_deltat(t, input_matrix)
# The variable coeffs_list stores the coefficients of the polynomial of
# variable x.
coeffs_list = sp.poly(x)
# This command is to ensure that all roots of x are included in variable
# coeffs_list.
coeffs_list = coeffs_list.all_coeffs()
# The variable roots_list stores the roots of polynomial of x.
roots_list = np.roots(coeffs_list)
# The second step is to evaluate the stability of the equilibrium point by
# evaluating the first derivative of the function.
# This assigns dx_dt as a function of the first derivative of x with
# respect to t.
dx_dt = sp.Lambda([t], sp.diff(x))
# This list stores the stability of the equilibrium in roots_list, in the
# order of the latter list.
stable_list = []
for i in roots_list:
if dx_dt(i) > 0: # If the first derivative of x at i is positive
# The equilibrium point is unstable, hence append 0.
stable_list.append(0)
# Else if the first derivative of x at i is negative
elif dx_dt(i) < 0:
stable_list.append(1) # The equilibrium is stable, hence append 1.
# The final step is to plot the equilibrium points using pyplot library,
# along with the function x.
# This sets t as a set of values between 0 and 1.
import sympy as sy
##from sympy.printing import print_rcode
##from sympy.functions import sin, cos, Abs, sqrt
##from sympy import Lambda
## from sympy.abc import x
sy.init_printing()
## criando variavel simbolica
x = sy.var('x')
## definindo uma função
f = sy.Lambda(x, 2 - sy.sqrt(x**2 - 1))
## f de 1
sy.print_rcode(f(1))
## imprimindo o grafico da função f
sy.plot(f(x))
import sympy as sy
sy.init_printing()
x, y = sy.var('x y')
## declaração de função
f = sy.Lambda(x, (x**3 - 3 * x + 2) * sy.exp(x / 4) - 1)
## limite da função com f(x), com o x tendendo a 1
ponto = 1
limit = sy.limit(f(x), x, ponto)
## print limit
sy.print_rcode(limit)
## limites laterais
z = sy.var('z')
g = sy.Lambda(z, (abs(z)) / z)
limiteDireita = sy.limit(g(z), z, 0, '+')
esquerda = sy.limit(g(z), z, 0, '-')
sy.print_rcode(limiteDireita)
sy.print_rcode(esquerda)
## limites ao infinito
## limit(f(x), x, oo)
