def tustin(tf, sRate):
s = getMapping(tf)['s']
T = 1/sRate
poles = sympy.roots(sympy.denom(tf), s, multiple=True)
centroid = np.mean(np.abs(poles))
invz = sympy.Symbol('invz', real=True)
# normalized center frequency derived from poles of filter SISO transfer function
w0 = 2*np.pi*centroid/(sRate*2*np.pi)
# modified bilinear transform w/ frequency warping
bt = w0/sympy.tan(w0*T/2) * ((1-invz)/(1+invz))
dt = sympy.simplify(tf.subs({s: bt}))
b = sympy.Poly(sympy.numer(dt)).all_coeffs()[::-1]
a = sympy.Poly(sympy.denom(dt)).all_coeffs()[::-1]
normalize = lambda x: float(x/a[0])
return (map(normalize, b), map(normalize, a))
def poles(G):
'''
Return the poles of a multivariable transfer function system. Applies
Theorem 4.4 (p135).
Parameters
----------
G : numpy matrix (n x n)
The transfer function G(s) of the system.
Returns
-------
zero : array
List of zeros.
Example
-------
>>> def G(s):
... return 1 / (s + 2) * numpy.matrix([[s - 1, 4],
... [4.5, 2 * (s - 1)]])
>>> poles(G)
[-2.00000000000000]
Note
----
Not applicable for a non-squared plant, yet.
'''
s = sympy.Symbol('s')
G = sympy.Matrix(G(s)) # convert to sympy matrix object
det = sympy.simplify(G.det())
pole = sympy.solve(sympy.denom(det))
return pole
def find_simple_recurrence_vector(l):
"""
This function is used internally by other functions from the
sympy.concrete.guess module. While most users may want to rather use the
function find_simple_recurrence when looking for recurrence relations
among rational numbers, the current function may still be useful when
some post-processing has to be done.
The function returns a vector of length n when a recurrence relation of
order n is detected in the sequence of rational numbers v.
If the returned vector has a length 1, then the returned value is always
the list [0], which means that no relation has been found.
While the functions is intended to be used with rational numbers, it should
work for other kinds of real numbers except for some cases involving
quadratic numbers; for that reason it should be used with some caution when
the argument is not a list of rational numbers.
Examples
========
>>> from sympy.concrete.guess import find_simple_recurrence_vector
>>> from sympy import fibonacci
>>> find_simple_recurrence_vector([fibonacci(k) for k in range(12)])
[1, -1, -1]
See also
========
See the function sympy.concrete.guess.find_simple_recurrence which is more
user-friendly.
"""
q1 = [0]
q2 = [Integer(1)]
b, z = 0, len(l) >> 1
while len(q2) <= z:
while l[b]==0:
b += 1
if b == len(l):
c = 1
for x in q2:
c = lcm(c, denom(x))
if q2[0]*c < 0: c = -c
for k in range(len(q2)):
q2[k] = int(q2[k]*c)
return q2
a = Integer(1)/l[b]
m = [a]
for k in range(b+1, len(l)):
m.append(-sum(l[j+1]*m[b-j-1] for j in range(b, k))*a)
l, m = m, [0] * max(len(q2), b+len(q1))
for k in range(len(q2)):
m[k] = a*q2[k]
for k in range(b, b+len(q1)):
m[k] += q1[k-b]
while m[-1]==0: m.pop() # because trailing zeros can occur
q1, q2, b = q2, m, 1
return [0]
def e2nd(expression): """ basic helper function that accepts a sympy expression, expands it, attempts to simplify it, and returns a numerator and denomenator pair for the instantiation of a scipy LTI system object. """ expression = expression.expand() expression = expression.cancel() n = sympy.Poly(sympy.numer(expression), s).all_coeffs() d = sympy.Poly(sympy.denom(expression), s).all_coeffs() n = map(float, n) d = map(float, d) return (n, d)
def e2nd(expression):
""" basic helper function that accepts a sympy expression, expands it,
attempts to simplify it, and returns a numerator and denomenator pair for the instantiation of a scipy
LTI system object. """
expression = expression.expand()
expression = expression.cancel()
n = sympy.Poly(sympy.numer(expression), s).all_coeffs()
d = sympy.Poly(sympy.denom(expression), s).all_coeffs()
n = map(float, n)
d = map(float, d)
return (n, d)
def _conversion_fraction(context, is_train):
"""E.g., "How many grams are in three quarters of a kg?"."""
dimension = random.choice(DIMENSIONS)
# Limit probability of giving zero answer.
allow_zero = random.random() < 0.2
# Repeat until we find a pair with an integral answer. (Avoids ambiguity with
# decimals.)
while True:
base_unit, target_unit = random.sample(list(dimension.keys()), 2)
base_value = number.non_integer_rational(2, signed=False)
if train_test_split.is_train(base_value) != is_train:
continue
answer = (base_value * sympy.Rational(dimension[base_unit])
/ sympy.Rational(dimension[target_unit]))
if (abs(answer) <= 100000
and sympy.denom(answer) == 1
and (allow_zero or answer != 0)):
break
template, case = random.choice([
('Сколько {target_name_skolko} в {base_value} {base_name_fraction}?', 'v'),
('Переведите {base_value} {base_name_fraction} в {target_name}?', 'perevedi'),
])
if sympy.denom(base_value) > 20 or random.choice([False, True]):
base_value_string = base_value # Will be represented as e.g., 2/3.
else:
base_value_string = display.StringNumber(base_value, case=case, gender='fem') # e.g., two thirds
# тут всегда единственное у меры
question = example.question(
context, template,
base_name=base_unit.name,
base_name_fraction=base_unit.name_perevedi[1],
base_value=base_value_string,
target_name=target_unit.name,
target_name_skolko=target_unit.name_skolko)
return example.Problem(question=question, answer=answer)
def __new__(cls, b, e, evaluate=True):
from sympy.functions.elementary.exponential import exp_polar
from sympy.functions import log
# don't optimize "if e==0; return 1" here; it's better to handle that
# in the calling routine so this doesn't get called
b = _sympify(b)
e = _sympify(e)
if evaluate:
if e is S.Zero:
return S.One
elif e is S.One:
return b
elif S.NaN in (b, e):
if b is S.One: # already handled e == 0 above
return S.One
return S.NaN
else:
if e.func == log:
if len(e.args) == 2:
lbase = e.args[1]
else:
lbase = S.Exp1
if lbase == b:
return e.args[0]
if e is Mul and e.args[1].func == log:
if len(e.args[1].args) == 2:
lbase = e.args[1].args[1]
else:
lbase = S.Exp1
if lbase == b:
return e.args[1].args[0] ** e.args[0]
# recognize base as E
if not e.is_Atom and b is not S.Exp1 and b.func is not exp_polar:
from sympy import numer, denom, log, sign, im, factor_terms
c, ex = factor_terms(e, sign=False).as_coeff_Mul()
den = denom(ex)
if den.func is log and den.args[0] == b:
return S.Exp1**(c*numer(ex))
elif den.is_Add:
s = sign(im(b))
if s.is_Number and s and den == \
log(-factor_terms(b, sign=False)) + s*S.ImaginaryUnit*S.Pi:
return S.Exp1**(c*numer(ex))
obj = b._eval_power(e)
if obj is not None:
return obj
obj = Expr.__new__(cls, b, e)
obj.is_commutative = (b.is_commutative and e.is_commutative)
return obj
def sympy_to_tf(G, data):
"""convert a discrete transfer function in sympy to a contorl.tf"""
z = sympy.symbols('z')
Gs = G.subs(data)
try:
num = np.array(sympy.Poly(sympy.numer(Gs), z).all_coeffs(),
dtype=float)
den = np.array(sympy.Poly(sympy.denom(Gs), z).all_coeffs(),
dtype=float)
except Exception:
raise TypeError('failed to convert expression to float polynomials: ',
Gs)
return control.tf(num, den, 1.0 / data['f_s'])
def _conversion_fraction(context, is_train):
"""E.g., "How many grams are in three quarters of a kg?"."""
dimension = random.choice(DIMENSIONS)
# Limit probability of giving zero answer.
allow_zero = random.random() < 0.2
# Repeat until we find a pair with an integral answer. (Avoids ambiguity with
# decimals.)
while True:
base_unit, target_unit = random.sample(list(dimension.keys()), 2)
base_value = number.non_integer_rational(2, signed=False)
if train_test_split.is_train(base_value) != is_train:
continue
answer = (base_value * sympy.Rational(dimension[base_unit]) /
sympy.Rational(dimension[target_unit]))
if (abs(answer) <= 100000 and sympy.denom(answer) == 1
and (allow_zero or answer != 0)):
break
template = random.choice([
'Ada berapa {target_name} di {base_value} dari sebuah {base_name}?',
'Berapa {base_value} dari {base_name} di {target_name}?',
])
if sympy.denom(base_value) > 20 or random.choice([False, True]):
base_value_string = base_value # Will be represented as e.g., 2/3.
else:
base_value_string = display.StringNumber(
base_value) # e.g., two thirds
question = example.question(context,
template,
base_name=base_unit.name,
base_value=base_value_string,
target_name=target_unit.name)
return example.Problem(question=question, answer=answer)
def entropy_of_value(value):
"""Returns "min entropy" that would give probability of getting this value."""
if isinstance(value, display.Decimal):
return entropy_of_value(sympy.numer(value))
if is_non_integer_rational(value):
numer = sympy.numer(value)
denom = sympy.denom(value)
return entropy_of_value(numer) + entropy_of_value(denom)
elif not is_integer(value):
raise ValueError('Unhandled value: {}'.format(value))
# Note: we sample integers in a range of size approx 10**entropy about zero,
# so assume that `abs(value)` is about half of the upper range.
return math.log10(5 * abs(value) + 1)
def Pow(expr, assumptions):
"""
Imaginary**integer/odd -> Imaginary
Imaginary**integer/even -> Real if integer % 2 == 0
b**Imaginary -> !Imaginary if exponent is an integer multiple of I*pi/log(b)
Imaginary**Real -> ?
Negative**even root -> Imaginary
Negative**odd root -> Real
Negative**Real -> Imaginary
Real**Integer -> Real
Real**Positive -> Real
"""
if expr.is_number:
return AskImaginaryHandler._number(expr, assumptions)
if expr.base.func == C.exp:
if ask(Q.imaginary(expr.base.args[0]), assumptions):
if ask(Q.imaginary(expr.exp), assumptions):
return False
i = expr.base.args[0] / I / pi
if ask(Q.integer(2 * i), assumptions):
return ask(Q.imaginary(((-1)**i)**expr.exp), assumptions)
if ask(Q.imaginary(expr.base), assumptions):
if ask(Q.integer(expr.exp), assumptions):
odd = ask(Q.odd(expr.exp), assumptions)
if odd is not None:
return odd
return
if ask(Q.imaginary(expr.exp), assumptions):
imlog = ask(Q.imaginary(C.log(expr.base)), assumptions)
if imlog is not None:
return False # I**i -> real; (2*I)**i -> complex ==> not imaginary
if ask(Q.real(expr.base), assumptions):
if ask(Q.real(expr.exp), assumptions):
if ask(
Q.rational(expr.exp) & Q.even(denom(expr.exp)),
assumptions):
return ask(Q.negative(expr.base), assumptions)
elif ask(Q.integer(expr.exp), assumptions):
return False
elif ask(Q.positive(expr.base), assumptions):
return False
elif ask(Q.negative(expr.base), assumptions):
return True
def _div_op(value, sample_args, rationals_allowed):
"""Returns sampled args for `ops.Div`."""
assert rationals_allowed # should be True if this function gets invoked
entropy, sample_args = sample_args.peel()
numer = sympy.numer(value)
denom = sympy.denom(value)
if sample_args.count == 1:
mult = number.integer(entropy, signed=True, min_abs=1)
op_args = [numer * mult, denom * mult]
elif sample_args.count == 2:
if numer == 0 or random.choice([False, True]):
x = number.integer(entropy,
signed=True,
min_abs=1,
coprime_to=denom)
op_args = [sympy.Rational(x * numer, denom), x]
else:
x = number.integer(entropy,
signed=True,
min_abs=1,
coprime_to=numer)
op_args = [x, sympy.Rational(x * denom, numer)]
else:
assert sample_args.count >= 3
p2, p1 = _split_factors(numer)
q1, q2 = _split_factors(denom)
entropy -= _entropy_of_factor_split(numer) + _entropy_of_factor_split(
denom)
entropy_r = random.uniform(0, entropy)
entropy_s = entropy - entropy_r
r = number.integer(entropy_r,
signed=True,
min_abs=1,
coprime_to=q1 * p2)
s = number.integer(entropy_s,
signed=False,
min_abs=1,
coprime_to=p1 * q2)
op_args = [
sympy.Rational(r * p1, s * q1),
sympy.Rational(r * q2, s * p2)
]
return ops.Div, op_args, sample_args
def Pow(expr, assumptions):
"""
Imaginary**integer/odd -> Imaginary
Imaginary**integer/even -> Real if integer % 2 == 0
b**Imaginary -> !Imaginary if exponent is an integer multiple of I*pi/log(b)
Imaginary**Real -> ?
Negative**even root -> Imaginary
Negative**odd root -> Real
Negative**Real -> Imaginary
Real**Integer -> Real
Real**Positive -> Real
"""
if expr.is_number:
return AskImaginaryHandler._number(expr, assumptions)
if expr.base.func == C.exp:
if ask(Q.imaginary(expr.base.args[0]), assumptions):
if ask(Q.imaginary(expr.exp), assumptions):
return False
i = expr.base.args[0]/I/pi
if ask(Q.integer(2*i), assumptions):
return ask(Q.imaginary(((-1)**i)**expr.exp), assumptions)
if ask(Q.imaginary(expr.base), assumptions):
if ask(Q.integer(expr.exp), assumptions):
odd = ask(Q.odd(expr.exp), assumptions)
if odd is not None:
return odd
return
if ask(Q.imaginary(expr.exp), assumptions):
imlog = ask(Q.imaginary(C.log(expr.base)), assumptions)
if imlog is not None:
return False # I**i -> real; (2*I)**i -> complex ==> not imaginary
if ask(Q.real(expr.base), assumptions):
if ask(Q.real(expr.exp), assumptions):
if ask(Q.rational(expr.exp) & Q.even(denom(expr.exp)), assumptions):
return ask(Q.negative(expr.base), assumptions)
elif ask(Q.integer(expr.exp), assumptions):
return False
elif ask(Q.positive(expr.base), assumptions):
return False
elif ask(Q.negative(expr.base), assumptions):
return True
def __new__(cls, b, e, evaluate=None):
if evaluate is None:
evaluate = global_evaluate[0]
from sympy.functions.elementary.exponential import exp_polar
b = _sympify(b)
e = _sympify(e)
if evaluate:
if e is S.Zero:
return S.One
elif e is S.One:
return b
elif e.is_integer and _coeff_isneg(b):
if e.is_even:
b = -b
elif e.is_odd:
return -Pow(-b, e)
if b is S.One:
if e in (S.NaN, S.Infinity, -S.Infinity):
return S.NaN
return S.One
elif S.NaN in (
b,
e): # XXX S.NaN**x -> S.NaN under assumption that x != 0
return S.NaN
else:
# recognize base as E
if not e.is_Atom and b is not S.Exp1 and b.func is not exp_polar:
from sympy import numer, denom, log, sign, im, factor_terms
c, ex = factor_terms(e, sign=False).as_coeff_Mul()
den = denom(ex)
if den.func is log and den.args[0] == b:
return S.Exp1**(c * numer(ex))
elif den.is_Add:
s = sign(im(b))
if s.is_Number and s and den == \
log(-factor_terms(b, sign=False)) + s*S.ImaginaryUnit*S.Pi:
return S.Exp1**(c * numer(ex))
obj = b._eval_power(e)
if obj is not None:
return obj
obj = Expr.__new__(cls, b, e)
obj.is_commutative = (b.is_commutative and e.is_commutative)
return obj
def mutate_rat(value, *, keep_sign=True, mutate_up=None):
'''Mutate rational number'''
r = random.random()
numer, denom = sp.numer(value), sp.denom(value)
# swap numerator and denominator
if r < 0.20:
numer, denom = (mutate_int(denom, mutate_up=mutate_up, keep_sign=keep_sign),
mutate_int(numer, mutate_up=mutate_up))
# mutate numerator
elif r < 0.65:
numer = mutate_int(numer, mutate_up=mutate_up, keep_sign=keep_sign)
# mutate denominator
else:
denom = mutate_int(denom, mutate_up=mutate_up, keep_sign=keep_sign)
return sp.Rational(numer, denom or 1)
def pk_parameters(self, seed=None):
statements = self.model.statements
odes = statements.ode_system
central = odes.find_central()
output = odes.find_output()
depot = odes.find_depot(statements)
peripherals = odes.find_peripherals()
elimination_rate = odes.get_flow(central, output)
expressions = [] # Eq(name, expr)
# FO abs + 1comp + FO elimination
if len(odes) == 3 and depot and odes.t not in elimination_rate.free_symbols:
ode_list, ics = odes.to_explicit_odes(skip_output=True)
sols = sympy.dsolve(ode_list, ics=ics)
expr = sols[1].rhs
d = sympy.diff(expr, odes.t)
tmax_closed_form = sympy.solve(d, odes.t)[0]
expressions.append(sympy.Eq(sympy.Symbol('t_max'), tmax_closed_form))
e2 = sympy.simplify(expr / depot.dose.amount / sympy.denom(elimination_rate))
cmax_dose_closed_form = sympy.simplify(e2.subs({odes.t: tmax_closed_form}))
expressions.append(sympy.Eq(sympy.Symbol('C_max_dose'), cmax_dose_closed_form))
# Any abs + 1comp + FO elimination
if not peripherals and odes.t not in elimination_rate.free_symbols:
elimination_system = statements.copy().ode_system
# keep central and output
for name in elimination_system.names:
if name not in [central.name, output.name]:
elimination_system.remove_compartment(elimination_system.find_compartment(name))
ode_list, ics = elimination_system.to_explicit_odes(skip_output=True)
A0 = sympy.Symbol('A0')
ic = ics.popitem()
ics = {ic[0]: A0}
sols = sympy.dsolve(ode_list[0], ics=ics)
eq = sympy.Eq(sympy.Rational(1, 2) * A0, sols.rhs)
thalf_elim = sympy.solve(eq, odes.t)[0]
expressions.append(sympy.Eq(sympy.Symbol('t_half_elim'), thalf_elim))
# Any abs + any comp + FO elimination
if odes.t not in elimination_rate.free_symbols:
expressions.append(sympy.Eq(sympy.Symbol('k_e'), elimination_rate))
df = self.individual_parameter_statistics(expressions, seed=seed)
return df
def __new__(cls, b, e, evaluate=None):
if evaluate is None:
evaluate = global_evaluate[0]
from sympy.functions.elementary.exponential import exp_polar
b = _sympify(b)
e = _sympify(e)
if evaluate:
if e is S.Zero:
return S.One
elif e is S.One:
return b
elif e.is_integer and _coeff_isneg(b):
if e.is_even:
b = -b
elif e.is_odd:
return -Pow(-b, e)
if b is S.One:
if e in (S.NaN, S.Infinity, -S.Infinity):
return S.NaN
return S.One
elif S.NaN in (b, e): # XXX S.NaN**x -> S.NaN under assumption that x != 0
return S.NaN
else:
# recognize base as E
if not e.is_Atom and b is not S.Exp1 and b.func is not exp_polar:
from sympy import numer, denom, log, sign, im, factor_terms
c, ex = factor_terms(e, sign=False).as_coeff_Mul()
den = denom(ex)
if den.func is log and den.args[0] == b:
return S.Exp1**(c*numer(ex))
elif den.is_Add:
s = sign(im(b))
if s.is_Number and s and den == \
log(-factor_terms(b, sign=False)) + s*S.ImaginaryUnit*S.Pi:
return S.Exp1**(c*numer(ex))
obj = b._eval_power(e)
if obj is not None:
return obj
obj = Expr.__new__(cls, b, e)
obj.is_commutative = (b.is_commutative and e.is_commutative)
return obj
def _rational_to_string(self, rational):
"""Converts a rational to words, e.g., "two thirds"."""
numer = sympy.numer(rational)
denom = sympy.denom(rational)
numer_words = self._to_string(numer)
if denom == 1:
return numer_words
if denom <= 0 or denom >= len(_PLURAL_DENOMINATORS):
raise ValueError('Unsupported denominator {}.'.format(denom))
if numer == 1:
denom_word = _SINGULAR_DENOMINATORS[denom]
else:
denom_word = _PLURAL_DENOMINATORS[denom]
return '{} {}'.format(numer_words, denom_word)
def __init__(self, value):
"""Initializes a `Decimal`.
Args:
value: (Sympy) value to display as a decimal.
Raises:
ValueError: If `value` cannot be represented as a non-terminating decimal.
"""
self._value = sympy.Rational(value)
numer = int(sympy.numer(self._value))
denom = int(sympy.denom(self._value))
denom_factors = list(sympy.factorint(denom).keys())
for factor in denom_factors:
if factor not in [2, 5]:
raise ValueError('Cannot represent {} as a non-recurring decimal.'
.format(value))
self._decimal = decimal.Decimal(numer) / decimal.Decimal(denom)
def __new__(cls, b, e, evaluate=None):
if evaluate is None:
evaluate = global_evaluate[0]
from sympy.functions.elementary.exponential import exp_polar
# don't optimize "if e==0; return 1" here; it's better to handle that
# in the calling routine so this doesn't get called
b = _sympify(b)
e = _sympify(e)
if evaluate:
if e is S.Zero:
return S.One
elif e is S.One:
return b
elif b is S.One:
if e in (S.NaN, S.Infinity, -S.Infinity):
return S.NaN
return S.One
elif S.NaN in (b, e):
return S.NaN
else:
# recognize base as E
if not e.is_Atom and b is not S.Exp1 and b.func is not exp_polar:
from sympy import numer, denom, log, sign, im, factor_terms
c, ex = factor_terms(e, sign=False).as_coeff_Mul()
den = denom(ex)
if den.func is log and den.args[0] == b:
return S.Exp1**(c * numer(ex))
elif den.is_Add:
s = sign(im(b))
if s.is_Number and s and den == \
log(-factor_terms(b, sign=False)) + s*S.ImaginaryUnit*S.Pi:
return S.Exp1**(c * numer(ex))
obj = b._eval_power(e)
if obj is not None:
return obj
obj = Expr.__new__(cls, b, e)
obj.is_commutative = (b.is_commutative and e.is_commutative)
return obj
def separate_imaginary(eqn, model_type):
"""
Separates the real and imaginary components of symbolic equations. <br/>
Needs - sympy equation, string model type ('short', 'open', etc.)
#**Example:**
```
>> calc_magnitude(OpenModel(complex=True).s_parameters()[0])
```
"""
# TODO - this doesn't really work for S12/S21
from sympy import symbols, expand, simplify, conjugate, denom, I
l0, l1, l2, c0, c1, c2, x = symbols('l0 l1 l2 c0 c1 c2 x')
L = symbols('L', real=True)
eqn = eqn.subs(math.pi, sympy.pi)
eqn = eqn.subs(f**2*l2 + f*l1 + l0, L) if model_type == 'short' else eqn.subs(1 / (c0+c1*f+c2*f**2), L)
conj = denom(conjugate(eqn))
eqn = simplify(expand(simplify(eqn)*conj))
eqn = simplify(eqn*1/conj)
# eqn = eqn.subs(L, l0 + l1*f + l2*f**2) if model_type == 'short' else eqn.subs(L, 1 / (c0+c1*f+c2*f**2))
return np.array(['real', simplify(eqn.subs(I, 0)),
'imag', simplify(expand(eqn) - eqn.subs(sympy.I, 0)).subs(I, 1)])
def _mul_op(value, sample_args, rationals_allowed):
"""Returns sampled args for `ops.Mul`."""
if sample_args.count >= 3:
_, op_args, sample_args = _div_op(value, sample_args, rationals_allowed)
op_args = [op_args[0], sympy.Integer(1) / op_args[1]]
elif sample_args.count == 1:
entropy, sample_args = sample_args.peel()
assert _entropy_of_factor_split(value) >= entropy
op_args = _split_factors(value)
else:
assert sample_args.count == 2
entropy, sample_args = sample_args.peel()
numer = sympy.numer(value)
denom = sympy.denom(value)
p1, p2 = _split_factors(numer)
entropy -= _entropy_of_factor_split(numer)
mult = number.integer(entropy, signed=True, min_abs=1, coprime_to=p1)
op_args = [p1 / (mult * denom), p2 * mult]
if random.choice([False, True]):
op_args = list(reversed(op_args))
return ops.Mul, op_args, sample_args
tf = ahkabHelpers.reduceTF(tf, mycircuit)
sRate = 44.1e3
fs = lambda x: sympy.N(abs(tf.subs({s:sympy.I*x})))
ws = np.logspace(1, np.log10(sRate), 5e2)
mags = map(fs,ws)
print tf
(b, a) = ahkabHelpers.tustin(tf, sRate)
print b,a
pylab.semilogx(ws, map(fs, ws), 'v', label="from transfer function")
pylab.semilogx(r['ac']['w'][::10], np.abs(r['ac']['VU1o'][::10]), '-', label='from AC simulation')
pylab.vlines(np.abs(sympy.roots(sympy.denom(tf), s, multiple=True)), 0, 1, 'r')
# build white noise input vector, normalized to \pm 1.0
x = list(2*np.random.random(sRate)-1.0)
# allocate output vector for y[n-2] indexing to work
y = [0.0]*len(x)
# Direct Form I
for n in range(len(x)):
y[n] = b[0]*x[n] + b[1]*x[n-1] + b[2]*x[n-2] - a[1]*y[n-1] - a[2]*y[n-2]
# frequencies to radians
freqs = (np.fft.fftfreq(len(y), 1/sRate))[0:len(y)/2] * (2*np.pi)
mags = (np.abs(np.fft.fft(np.array(y))))[0:len(y)/2]
# normalize magnitude to 1.0
def ac_analysis(param_d, param_l, instance, file_sufix):
""" Performs ac analysis
param_d: substitutions for symbols, or named parameters for plot
param_l: expresions to plot
format is:
.ac expresion0 [expresion1 expresion2 ...] sweep = parameter_to_sweep [symmbol_or_option0 = value0
symmbol_or_option1 = value1 ...]
expresions are on positiona parameters list can hold expresions containing parameters or functions of nodal
voltages [v(node)] and element and port currents [i(element) isub(port)]
named parameters (param_d) can contain options for analysis or substitutions for symbols, substituions will be
done as they are without any parsing, be aware of symbol and option names clashes.
Config options:
fstart: first value of frequency for AC analysis [float]
fstop: last value of frequency for AC analysis [float]
fscale: scale for frequency points [linear | log]
npoints: numbers of points for ac analysis [integer]
yscale: scale for y-axis to being displayed on [linear or log]
hold: hold plot for next analysis and don't save it to file [yes | no]
show_poles: show poles of function on plot [yes | no]
show_zeroes: show zeros of function on plot [yes | no]
title: display title above ac plot [string]
show_legend: show legend on plot [yes | no]
xkcd: style plot to be xkcd like scetch
"""
warnings.filterwarnings('ignore') # Just getting rid of those fake casting from complex warnings
s, w = sympy.symbols(('s', 'w'))
config = {'fstart': 1,
'fstop': 1e6,
'fscale': 'log',
'npoints': 100,
'yscale': 'log',
'type': 'amp',
'hold': 'no',
'show_poles': 'yes',
'show_zeros': 'yes',
'title': None,
'show_legend': 'no',
'xkcd': 'no'}
for config_name in config.keys():
if config_name in param_d:
config.update({config_name: param_d[config_name]})
param_d.pop(config_name)
subst = []
for symbol, value in param_d.iteritems():
tokens = scs_parser.parse_param_expresion(value)
try:
value = float(sympy.sympify(scs_parser.params2values(tokens, instance.paramsd),sympy.abc._clash))
except ValueError:
raise scs_errors.ScsAnalysisError("Passed subsitution for %s is not a number")
subst.append((symbol, value))
if config['fscale'] == 'log':
fs = np.logspace(np.log10(float(config['fstart'])), np.log10(float(config['fstop'])), int(config['npoints']))
elif config['fscale'] == 'linear':
fs = np.linspace(float(config['fstart']), float(config['fstop']), int(config['npoints']))
else:
raise scs_errors.ScsAnalysisError(("Option %s for fscale invalid!" % config['yscale']))
if config['yscale'] != 'log' and config['yscale'] != 'linear':
raise scs_errors.ScsAnalysisError(("Option %s for yscale invalid!" % config['fscale']))
filename = "%s.results" % file_sufix
with open(filename, 'a') as fil:
if config['xkcd'] == 'yes':
plt.xkcd()
plt.hold(True)
for expresion in param_l:
fil.write("%s: %s \n---------------------\n" % ('AC analysis of', expresion))
tokens = scs_parser.parse_analysis_expresion(expresion)
value0 = sympy.factor(sympy.sympify(scs_parser.results2values(tokens, instance),sympy.abc._clash), s).simplify()
fil.write("%s = %s \n\n" % (expresion, str(value0)))
denominator = sympy.denom(value0)
numerator = sympy.numer(value0)
poles = sympy.solve(denominator, s)
zeros = sympy.solve(numerator, s)
poles_r = sympy.roots(denominator, s)
zeros_r = sympy.roots(numerator, s)
gdc = str(value0.subs(s, 0).simplify())
fil.write('G_DC = %s\n\n' % gdc)
p = 0
titled = 1
for pole, degree in poles_r.iteritems():
if pole == 0:
titled *= s ** degree
else:
titled *= (s / sympy.symbols("\\omega_p%d" % p) + 1)
p += 1
z = 0
titlen = 1
for zero, degree in zeros_r.iteritems():
if zero == 0:
titlen *= s ** degree
else:
titlen *= (s / sympy.symbols("\\omega_z%d" % z) + 1)
z += 1
# title = sympy.symbols("G_DC") * (titlen / titled)
value = value0.subs(subst)
f = sympy.symbols('f', real=True)
value = value.subs(s, sympy.sympify('2*pi*I').evalf() * f)
tf = sympy.lambdify(f, abs(sympy.numer(value)) / abs(sympy.denom(value)))
phf = sympy.lambdify(f, sympy.arg(value))
if config['type'] == 'amp':
zf = tf
ylabel = '|T(f)|'
elif config['type'] == 'phase':
zf = phf
ylabel = 'ph(T(f))'
else:
raise scs_errors.ScsAnalysisError("Option %s for type invalid!" % config['type'])
try:
ys = [float(zf(f)) for f in fs]
except (ValueError, TypeError):
raise scs_errors.ScsAnalysisError(
"Numeric error while evaluating expresions: %s. Not all values where subsituted?" % value0)
plt.plot(fs, ys, label=expresion)
plt.title(r'$%s$' % config['title'] if config['title'] else ' ', y=1.05)
try:
plt.xscale(config['fscale'])
plt.yscale(config['yscale'])
except ValueError, e:
raise scs_errors.ScsAnalysisError(e)
plt.xlabel('f [Hz]')
plt.ylabel(ylabel)
if len(poles):
fil.write('Poles: \n')
p = 0
for pole in poles:
try:
pole_value = pole.subs(subst)
pole_value_f = abs(np.float64(-abs(pole_value) / sympy.sympify('2*pi').evalf()))
pole_s = (-pole).simplify()
polestr = str(pole_s)
fil.write('wp_%d = %s\n\n' % (p, polestr))
p += 1
if pole_value_f > float(config['fstop']) \
or pole_value_f < float(config['fstart']) \
or np.isnan(zf(pole_value_f)):
continue
if config['show_poles'] == 'yes':
pole_label = r'$\omega_{p%d} $' % (p - 1)
plt.plot(pole_value_f, zf(pole_value_f), 'o', label=pole_label)
plt.text(pole_value_f, zf(pole_value_f), pole_label)
plt.axvline(pole_value_f, linestyle='dashed')
except:
pass
z = 0
for zero in zeros:
try:
zero_value = zero.subs(subst)
zero_value_f = abs(np.float64(-abs(zero_value) / sympy.sympify('2*pi').evalf()))
zero_s = (-zero).simplify()
zerostr = str(zero_s)
fil.write('wz_%d = %s\n\n' % (z, zerostr))
z += 1
if zero_value_f > float(config['fstop']) \
or zero_value_f < float(config['fstart']) \
or np.isnan(zf(zero_value_f)):
continue
if config['show_zeros'] == 'yes':
zero_label = r'$\omega_{z%d} $' % (z - 1)
plt.plot(zero_value_f, zf(zero_value_f), '*', label=zero_label)
plt.axvline(zero_value_f, linestyle='dashed')
plt.text(zero_value_f, zf(zero_value_f), zero_label)
except:
pass
if config['show_legend'] == 'yes':
plt.legend()
if config['hold'] == 'no':
plt.hold(False)
plt.savefig('%s_%d.png' % (file_sufix, PlotNumber.plot_num))
plt.clf()
PlotNumber.plot_num += 1
def ALGO4(As,Bs,Cs,Ds,do_test):
#-------------------STEP 1------------------------------
if not is_row_proper(As):
Us,Ast=row_proper(As)
else:
Us,Ast=eye(As.rows),As
Bst=Us*Bs
Bst=expand(Bst)
r=Ast.cols
#-------------------STEP 2------------------------------
K=simplify(Ast.inv()*Bst) #very important
Ys=zeros(K.shape)
for i,j in product(range(K.rows),range(K.cols)):
Ys[i,j],q=div(numer(K[i,j]),denom(K[i,j]))
B_hat=Bst-Ast*Ys
#-------------------END STEP 2------------------------------
#-------------------STEP 3------------------------------
Psi=diag(*[[s**( mc.row_degrees(Ast,s)[j] -i -1) for i in range( mc.row_degrees(Ast,s)[j])] for j in range(r)]).T
S=diag(*[s**(rho) for rho in mc.row_degrees(Ast,s)])
Ahr=mc.highest_row_degree_matrix(Ast,s)
Help=Ast-S*Ahr
SOL={}
numvar=Psi.rows*Psi.cols
alr=symbols('a0:%d'%numvar)
Alr=Matrix(Psi.cols,Psi.rows,alr)
RHS=Psi*Alr
for i,j in product(range(Help.rows),range(Help.cols)): #diagonal explain later
SOL.update(solve_undetermined_coeffs(Eq(Help[i,j],RHS[i,j]),alr,s))
Alr=Alr.subs(SOL) #substitute(SOL)
Aoc=Matrix(BlockDiagMatrix(*[Matrix(rho, rho, lambda i,j: KroneckerDelta(i+1,j))for rho in mc.row_degrees(Ast,s)]))
Boc=eye(sum(mc.row_degrees(Ast,s)))
Coc=Matrix(BlockDiagMatrix(*[SparseMatrix(1,rho,{(x,0):1 if x==0 else 0 for x in range(rho)}) for rho in mc.row_degrees(Ast,s)]))
A0=Aoc-Alr*Ahr.inv()*Matrix(Coc)
C0=Ahr.inv()*Coc
SOL={}
numvar=Psi.cols*Bst.cols
b0=symbols('b0:%d'%numvar)
B0=Matrix(Psi.cols,Bst.cols,b0)
RHS=Psi*B0
for i,j in product(range(B_hat.rows),range(B_hat.cols)): #diagonal explain later
SOL.update(solve_undetermined_coeffs(Eq(B_hat[i,j],RHS[i,j]),b0,s))
B0=B0.subs(SOL) #substitute(SOL)
LHS_matrix=simplify(Cs*C0) #left hand side of the equation (1)
sI_A=s*eye(A0.cols)- A0
max_degree=mc.find_degree(LHS_matrix,s) #get the degree of the matrix at the LHS
#which is also the maximum degree for the coefficients of Λ(s)
#---------------------------Creating Matrices Λ(s) and C -------------------------------------
Lamda=[]
numvar=((max_degree))*A0.cols
a=symbols('a0:%d'%numvar)
for i in range(A0.cols): # paratirisi den douleuei to prin giat;i otra oxi diagonios
p=sum(a[n +i*(max_degree)]*s**n for n in range(max_degree)) # we want variables one degree lower because we are multiplying by first order monomials
Lamda.append(p)
Lamda=Matrix(Cs.rows,A0.cols,Lamda) #convert the list to Matrix
c=symbols('c0:%d'%(Lamda.rows*Lamda.cols))
C=Matrix(Lamda.rows,Lamda.cols,c)
#-----------------------------------------
RHS_matrix=Lamda*sI_A +C #right hand side of the equation (1)
'''
-----------Converting equation (1) to a system of linear -----------
-----------equations, comparing the coefficients of the -----------
-----------polynomials in both sides of the equation (1) -----------
'''
EQ=[Eq(LHS_matrix[i,j],expand(RHS_matrix[i,j])) for i,j in product(range(LHS_matrix.rows),range(LHS_matrix.cols)) ]
# This is the standard form for the second order system transfer function # In[7]: G = K / (tau**2 * s**2 + 2 * tau * zeta * s + 1) G # In[8]: invL(G) # The characteristic equation is the denominator of the transfer function # In[5]: ce = sympy.Eq(sympy.denom(G), 0) ce # In[6]: roots = sympy.roots(ce, s) roots # The shape of the inverse Laplace depends on the nature of the roots, which depends on the value of $\zeta$ # Overdamped: $\zeta>1$. Two distinct real roots # In[3]: G
def prep_geodesic_eqns(self, parameters: Dict = None):
r"""
Define geodesic equations.
Args:
parameters:
dictionary of model parameter values to be used for
equation substitutions
Attributes:
gstar_ij_tanbeta_mat (`Matrix`_):
:math:`\dots`
g_ij_tanbeta_mat (`Matrix`_):
:math:`\dots`
tanbeta_poly_eqn (:class:`~sympy.core.relational.Equality`):
:math:`\dots` where :math:`a := \tan\alpha`
tanbeta_eqn (:class:`~sympy.core.relational.Equality`):
:math:`\tan{\left(\beta \right)} = \dots` where
:math:`a := \tan\alpha`
gstar_ij_tanalpha_mat (`Matrix`_):
a symmetric tensor with components (using shorthand
:math:`a := \tan\alpha`)
:math:`g^*[1,1] = \dots`
:math:`g^*[1,2] = g^*[2,1] = \dots`
:math:`g^*[2,2] = \dots`
gstar_ij_mat (`Matrix`_):
a symmetric tensor with components
(using shorthand :math:`a := \tan\alpha`, and with a
particular choice of model parameters)
:math:`g^*[1,1] = \dots`
:math:`g^*[1,2] = g^*[2,1] = \dots`
:math:`g^*[2,2] = \dots`
g_ij_tanalpha_mat (`Matrix`_):
a symmetric tensor with components (using shorthand
:math:`a := \tan\alpha`)
:math:`g[1,1] = \dots`
:math:`g[1,2] = g[2,1] = \dots`
:math:`g[2,2] = \dots`
g_ij_mat (`Matrix`_):
a symmetric tensor with components
(using shorthand :math:`a := \tan\alpha`, and with a
particular choice of model parameters)
:math:`g[1,1] =\dots`
:math:`g[1,2] = g[2,1] = \dots`
:math:`g[2,2] = \dots`
g_ij_mat_lambdified (function) :
lambdified version of `g_ij_mat`
gstar_ij_mat_lambdified (function) :
lambdified version of `gstar_ij_mat`
"""
logging.info("gme.core.geodesic.prep_geodesic_eqns")
self.gstar_ij_tanbeta_mat = None
self.g_ij_tanbeta_mat = None
self.tanbeta_poly_eqn = None
self.tanbeta_eqn = None
self.gstar_ij_tanalpha_mat = None
self.gstar_ij_mat = None
self.g_ij_tanalpha_mat = None
self.g_ij_mat = None
self.g_ij_mat_lambdified = None
self.gstar_ij_mat_lambdified = None
mu_eta_sub = {mu: self.mu_, eta: self.eta_}
# if parameters is None: return
H_ = self.H_eqn.rhs.subs(mu_eta_sub)
# Assume indexing here ranges in [1,2]
def p_i_lambda(i):
return [px, pz][i - 1]
# r_i_lambda = lambda i: [rx, rz][i-1]
# rdot_i_lambda = lambda i: [rdotx, rdotz][i-1]
def gstar_ij_lambda(i, j):
return simplify(
Rational(2, 2) * diff(diff(H_, p_i_lambda(i)), p_i_lambda(j)))
gstar_ij_mat = Matrix([
[gstar_ij_lambda(1, 1),
gstar_ij_lambda(2, 1)],
[gstar_ij_lambda(1, 2),
gstar_ij_lambda(2, 2)],
])
gstar_ij_pxpz_mat = gstar_ij_mat.subs({varphi_r(rvec): varphi})
g_ij_pxpz_mat = gstar_ij_mat.inv().subs({varphi_r(rvec): varphi})
cosbeta_eqn = Eq(cos(beta), 1 / sqrt(1 + tan(beta)**2))
sinbeta_eqn = Eq(sin(beta), sqrt(1 - 1 / (1 + tan(beta)**2)))
sintwobeta_eqn = Eq(sin(2 * beta), cos(beta)**2 - sin(beta)**2)
self.gstar_ij_tanbeta_mat = expand_trig(
simplify(gstar_ij_pxpz_mat.subs(e2d(
self.px_pz_tanbeta_eqn)))).subs(e2d(cosbeta_eqn))
self.g_ij_tanbeta_mat = expand_trig(
simplify(g_ij_pxpz_mat.subs(e2d(self.px_pz_tanbeta_eqn)))).subs(
e2d(cosbeta_eqn))
tanalpha_beta_eqn = self.tanalpha_beta_eqn.subs(mu_eta_sub)
tanbeta_poly_eqn = Eq(
numer(tanalpha_beta_eqn.rhs) -
tanalpha_beta_eqn.lhs * denom(tanalpha_beta_eqn.rhs),
0,
).subs({tan(alpha): ta})
tanbeta_eqn = Eq(tan(beta), solve(tanbeta_poly_eqn, tan(beta))[0])
self.tanbeta_poly_eqn = tanbeta_poly_eqn
self.tanbeta_eqn = tanbeta_eqn
# Replace all refs to beta with refs to alpha
self.gstar_ij_tanalpha_mat = (self.gstar_ij_tanbeta_mat.subs(
e2d(sintwobeta_eqn)).subs(e2d(sinbeta_eqn)).subs(
e2d(cosbeta_eqn)).subs(e2d(tanbeta_eqn))).subs(mu_eta_sub)
self.gstar_ij_mat = (self.gstar_ij_tanalpha_mat.subs({
ta: tan(alpha)
}).subs(e2d(self.tanalpha_rdot_eqn)).subs(
e2d(self.varphi_rx_eqn.subs(
{varphi_r(rvec): varphi}))).subs(parameters)).subs(mu_eta_sub)
self.g_ij_tanalpha_mat = (expand_trig(self.g_ij_tanbeta_mat).subs(
e2d(sintwobeta_eqn)).subs(e2d(sinbeta_eqn)).subs(
e2d(cosbeta_eqn)).subs(e2d(tanbeta_eqn))).subs(mu_eta_sub)
self.g_ij_mat = (self.g_ij_tanalpha_mat.subs({
ta: rdotz / rdotx
}).subs(e2d(self.varphi_rx_eqn.subs(
{varphi_r(rvec): varphi}))).subs(parameters)).subs(mu_eta_sub)
self.g_ij_mat_lambdified = lambdify((rx, rdotx, rdotz, varepsilon),
self.g_ij_mat, "numpy")
self.gstar_ij_mat_lambdified = lambdify((rx, rdotx, rdotz, varepsilon),
self.gstar_ij_mat, "numpy")
m2_2 = G[:,[0,2]]
m2 = m2_1.row_join(m2_2)
m2_3 = G[:,[0,1]]
m2 = m2.row_join(m2_3)
print(m2_1)
print(m2_2)
print(m2_3)
# combine order one and two minors
print('---All poles---')
m1count = np.shape(m1)[0]
#find out how many roots there are in total between all 1st order minors
n1Roots = 0
for m in range(m1count):
n1Roots = n1Roots + sp.degree(sp.denom(m1[m]),s)
#find out how many roots there are in total between all 2nd order minors
n2Roots = 0
r,c = np.shape(m2)
for i in range(r):
for j in range(c):
n2Roots = n2Roots + sp.degree(sp.denom(m2[i,j]),s)
print(n2Roots)
# calculate and find common roots
roots_denom = [None]*(n1Roots + n2Roots)
n = 0
for m in range(m1count):
denom_roots = sp.solve(sp.denom(m1[m]))
for i in range(len(denom_roots)):
def round(self, ndigits=0): """Returns a new `Decimal` rounded to this many decimal places.""" scale = sympy.Integer(10 ** ndigits) numer = sympy.numer(self.value) * scale denom = sympy.denom(self.value) return Decimal(int(round(numer / denom)) / scale)
def parametric_differentiation(f,
g,
dependent_variable,
n,
simplification_method='None'):
'''
Performs differentiation on two parametric equations.
Parameters
----------
f: Sympy Mul
A Sympy Mul object containing the first parametric equation.
g: Sympy Mul
A Sympy Mul object containing the second parametric equation.
dependent_variable: Sympy Symbol
Dependent variable.
n: integer
Order of differentiation.
simplification_method: str (or list if method is 'collect'), optional
Simplification method to be applied to the final answer.
Example
-------
>> t = sym.symbols('t')
>> x = t ** 3 - 3 * t ** 2
>> y = t ** 4 - 8 * t ** 2
>> parametric_differentiation(f = x, g = y,
dependent_variable = t, n = 3)
>> t = sym.symbols('t')
>> x = sin(t)
>> y = cos(t)
>> parametric_differentiation(f = x, g = y,
dependent_variable = t, n = 2,
simplification_method = 'simplify')
'''
t = dependent_variable
# check that a positive integer
if np.mod(n, 1) != 0 or n < 0:
raise ValueError('n must be a positive integer')
else:
if n == 1:
para_derivative = sym.diff(g, t) / sym.diff(f, t)
else:
# perform the normal differentiation recurssively
para_derivative = sym.diff(
parametric_differentiation(g, f, t, n - 1), t) / sym.diff(
f, t)
numerator, denominator = sym.numer(para_derivative), sym.denom(
para_derivative)
# perform simplification according to the simplification method specfied
if simplification_method == 'None':
result = sym.factor(numerator) / sym.factor(denominator)
elif simplification_method == 'simplify':
result = sym.simplify(numerator) / sym.simplify(denominator)
elif simplification_method == 'factor':
result = sym.factor(numerator) / sym.factor(denominator)
elif simplification_method == 'expand':
result = sym.expand(numerator) / sym.expand(denominator)
elif 'collect' in simplification_method:
# stop and return an error if simplification method is not a list
if not isinstance(simplification_method, list):
raise ValueError(
'Specifiy the simplification_method argument as a list.')
result = sym.collect(numerator,
simplification_method[1]) / sym.collect(
denominator, simplification_method[1])
elif simplification_method == 'together':
result = sym.together(numerator) / sym.together(denominator)
elif simplification_method == 'cancel':
result = sym.cancel(numerator) / sym.cancel(denominator)
else:
raise ValueError(
"%s is an invalid value for the argument 'simplification_method'" %
(simplification_method))
return result
def simplify(self): self._tuple = tuple(sympy.factor(ex) for ex in self._tuple) m = functools.reduce(lambda x, y: x * sympy.denom(y), self._tuple, 1) self._tuple = tuple(ex * m for ex in self._tuple) d = functools.reduce(sympy.gcd, self._tuple) self._tuple = tuple(sympy.factor(ex / d) for ex in self._tuple)
def define_px_poly_eqn(
self, eta_choice: Rational = None, do_ndim: bool = False
) -> None:
r"""
Define :math:`p_x` polynomial.
TODO: remove ref to xiv_0
Define polynomial form of function combining normal-slowness
covector components :math:`(p_x,p_z)`
(where the latter is given in terms of the vertical erosion rate
:math:`\xi^{\downarrow} = -\dfrac{1}{p_z}`)
and the erosion model flow component :math:`\varphi(\mathbf{r})`
Args:
eta_choice (:class:`~sympy.core.numbers.Rational`):
value of :math:`\eta` to use instead value given at
instantiation; otherwise the latter value is used
Attributes:
poly_px_xiv_varphi_eqn (:class:`~sympy.polys.polytools.Poly`):
:math:`\operatorname{Poly}{\left(
\left(\xi^{\downarrow}\right)^{4}
\varphi^{4}{\left(\mathbf{r} \right)} p_{x}^{6}
- \left(\xi^{\downarrow}\right)^{4} p_{x}^{2}
- \left(\xi^{\downarrow}\right)^{2}, p_{x},
domain=\mathbb{Z}\left[\varphi{\left(\mathbf{r} \right)},
\xi^{\downarrow}\right] \right)}`
poly_px_xiv_eqn (:class:`~sympy.core.relational.Equality`):
:math:`\varphi_0^{4}
\left(\xi^{\downarrow{0}}\right)^{4} p_{x}^{6}
\left(\varepsilon
+ \left(\frac{x_{1} - {r}^x}{x_{1}}\right)^{2 \mu}\right)^{4}
- \left(\xi^{\downarrow{0}}\right)^{4} p_{x}^{2}
- \left(\xi^{\downarrow{0}}\right)^{2} = 0`
"""
logging.info(f"gme.core.pxpoly.define_px_poly_eqn (ndim={do_ndim})")
if do_ndim:
# Non-dimensionalized version
varphi0_solns = solve(
self.sinCi_xih0_eqn.subs({eta: eta_choice}), varphi_0
)
varphi0_eqn = Eq(varphi_0, varphi0_solns[0])
if eta_choice is not None and eta_choice <= 1:
tmp_eqn = separatevars(
simplify(
self.px_xiv_varphi_eqn.subs({eta: eta_choice})
.subs({varphi_r(rvec): self.varphi_rxhat_eqn.rhs})
.subs(e2d(self.px_pxhat_eqn))
.subs(e2d(varphi0_eqn))
)
)
self.poly_pxhat_xiv_eqn = simplify(
Eq(
(
numer(tmp_eqn.lhs)
- denom(tmp_eqn.lhs) * (tmp_eqn.rhs)
)
/ xiv ** 2,
0,
)
)
self.poly_pxhat_xiv0_eqn = self.poly_pxhat_xiv_eqn.subs(
{xiv: xiv_0}
).subs(e2d(self.xiv0_xih0_Ci_eqn))
else:
tmp_eqn = separatevars(
simplify(
self.px_xiv_varphi_eqn.subs({eta: eta_choice})
.subs({varphi_r(rvec): self.varphi_rxhat_eqn.rhs})
.subs(e2d(self.px_pxhat_eqn))
.subs(e2d(varphi0_eqn))
)
)
self.poly_pxhat_xiv_eqn = simplify(
Eq(
(
numer(tmp_eqn.lhs)
- denom(tmp_eqn.lhs) * (tmp_eqn.rhs)
)
/ xiv ** 2,
0,
)
)
self.poly_pxhat_xiv0_eqn = simplify(
Eq(
self.poly_pxhat_xiv_eqn.lhs.subs({xiv: xiv_0}).subs(
e2d(self.xiv0_xih0_Ci_eqn)
)
/ xih_0 ** 2,
0,
)
)
else:
# Dimensioned version
tmp_eqn = simplify(self.px_xiv_varphi_eqn.subs({eta: eta_choice}))
if eta_choice is not None and eta_choice <= 1:
self.poly_px_xiv_varphi_eqn = poly(tmp_eqn.lhs, px)
else:
self.poly_px_xiv_varphi_eqn = poly(
numer(tmp_eqn.lhs) - denom(tmp_eqn.lhs) * (tmp_eqn.rhs), px
)
self.poly_px_xiv_eqn = Eq(
self.poly_px_xiv_varphi_eqn.subs(e2d(self.varphi_rx_eqn)), 0
)
if G[r, c] != 0:
m1.append(G[r, c])
print G[r, c]
print '---Minors of order 2---'
m2_1 = G[:,[1,2]]
m2_2 = G[:,[0,2]]
m2_3 = G[:,[0,1]]
print m2_1
print m2_2
print m2_3
print '---All poles---'
m1count = np.shape(m1)[0]
for m in range(0, m1count):
print sp.solve(sp.denom(m1[m]))
def M21(s):
return G[:,[1,2]]
def M12(s):
return G[:,[0,1]]
def M13(s):
return G[:,[0,1]]
print poles(M21)
print poles(M12)
print poles(M13)
print 'Therefore the poles are -1, 1 and -2'
##Usefull Sage example
def apart_fact(Fs):
S=0
Ls = apart(Fs).as_ordered_terms()
for l in Ls:
S += numer(l)/factor(denom(l))
return expand_mul(S)
def export(self, x):
return float(sp.numer(x)) / sp.denom(x)
def differential_constants(model, p1, p2, p3):
"""
Description:
This function calculates the differential constants u and q necessary to calculate the tip sample interaction
force.
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Parameters:
:param model: string
Model name, e.g. 'Gen. Kelvin Voigt', 'Gen. Maxwell'
:param p1: float
Either Ge or Jg
:param p2: array of floats
Either G or J
:param pe: array of floats
tau - charactersitic times
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Return, function output:
retrun: u: array of floats
differential constants u0, u1, ... un
q: array of floats
differential constants q0, q1, ... qn
"""
s = sym.symbols('s')
if model == 'Gen. Kelvin-Voigt':
if len(p2) == len(p3): # checks J and tau are same lenght
U = p1 + sum(p2[:] / (1.0 + p3[:] * s))
U_n = (U).normal() # writes retardance with common denominator
u_n = sym.numer(U_n) # selects the numerator
u_n = sym.expand(u_n) # expands each term
u_n = sym.collect(
u_n, s) # collect the terms with the same exponent of s
q_n = sym.denom(U_n) # selects the denominator
q_n = sym.expand(q_n) # expands each term
q_n = sym.collect(
q_n, s) # collect the terms with the same exponent of s
q_arr = np.zeros(
len(p2) +
1) # initializes array with lenght J, tau + 1 to store q
u_arr = np.zeros(
len(p2) +
1) # initializes array with lenght J, tau + 1 to store u
for i in range(len(p2) + 1):
q_arr[i] = q_n.coeff(
s, i
) # selects the terms multiplied by s^n which are synonymus for q0, .., qn
u_arr[i] = u_n.coeff(
s, i
) # selects the terms multiplied by s^n which are synonymus for u0, .., un
else:
print('input arrays have unequal length')
if model == 'Gen. Maxwell':
if len(p2) == len(p3):
Q = p1 + sum((p2[:] * p3[:]) / (1.0 + p3[:] * s))
Q_n = (Q).normal() # writes retardance with common denominator
u_n = sym.denom(Q_n) # selects the denominator
u_n = sym.expand(u_n) # expands each term
u_n = sym.collect(
u_n, s) # collect the terms with the same exponent of s
q_n = sym.numer(Q_n) # selects the numerator
q_n = sym.expand(q_n) # expands each term
q_n = sym.collect(
q_n, s) # collect the terms with the same exponent of s
q_arr = np.zeros(
len(p2) +
1) # initializes array with lenght J, tau + 1 to store q
u_arr = np.zeros(
len(p2) +
1) # initializes array with lenght J, tau + 1 to store u
for i in range(len(p2) + 1):
q_arr[i] = q_n.coeff(
s, i
) # selects the terms multiplied by s^n which are synonymus for q0, .., qn
u_arr[i] = u_n.coeff(
s, i
) # selects the terms multiplied by s^n which are synonymus for u0, .., un
else:
print('input arrays have unequal length')
return u_arr, q_arr
def symmetryDetection(allVariables,
diffEquations,
observables,
obsFunctions,
initFunctions,
predictions,
predFunctions,
ansatz='uni',
pMax=2,
inputs=[],
fixed=[],
parallel=1,
allTrafos=False,
timeTrans=False,
pretty=True,
suffix=''):
n = len(allVariables)
m = len(diffEquations)
h = len(observables)
###########################################################################################
############################# prepare equations ####################################
###########################################################################################
sys.stdout.write('Preparing equations...')
sys.stdout.flush()
# make infinitesimal ansatz
infis, diffInfis, rs = makeAnsatz(ansatz, allVariables, m, len(inputs),
pMax, fixed)
# get infinitesimals of time transformation
if timeTrans:
rs.append(spy.var('r_T_1'))
diffInfiT = rs[-1]
allVariables += [T]
else:
diffInfiT = None
# and convert to polynomial
infis, diffInfis = transformInfisToPoly(infis, diffInfis, allVariables, rs,
parallel, ansatz)
diffInfiT = Apoly(diffInfiT, allVariables, rs)
### extract numerator and denominator of equations
#differential equations
numerators = [0] * m
denominators = [0] * m
for k in range(m):
rational = spy.together(diffEquations[k])
numerators[k] = Apoly(spy.numer(rational), allVariables, None)
denominators[k] = Apoly(spy.denom(rational), allVariables, None)
#observation functions
obsNumerators = [0] * h
obsDenominatros = [0] * h
for k in range(h):
rational = spy.together(obsFunctions[k])
obsNumerators[k] = Apoly(spy.numer(rational), allVariables, None)
obsDenominatros[k] = Apoly(spy.denom(rational), allVariables, None)
#initial functions
if len(initFunctions) != 0:
initNumerators = [0] * m
initDenominatros = [0] * m
for k in range(m):
rational = spy.together(initFunctions[k])
initNumerators[k] = Apoly(spy.numer(rational), allVariables, None)
initDenominatros[k] = Apoly(spy.denom(rational), allVariables,
None)
else:
initNumerators = []
initDenominatros = []
### calculate numerator of derivatives of equations
#differential equatioins
derivativesNum = [0] * m
for i in range(m):
derivativesNum[i] = [0] * n
for k in range(m):
for l in range(n):
derivativesNum[k][l] = Apoly(None, allVariables, None)
derivativesNum[k][l].add(numerators[k].diff(l).mul(
denominators[k]))
derivativesNum[k][l].sub(numerators[k].mul(
denominators[k].diff(l)))
#observation functions
obsDerivativesNum = [0] * h
for i in range(h):
obsDerivativesNum[i] = [0] * n
for k in range(h):
for l in range(n):
obsDerivativesNum[k][l] = Apoly(None, allVariables, None)
obsDerivativesNum[k][l].add(obsNumerators[k].diff(l).mul(
obsDenominatros[k]))
obsDerivativesNum[k][l].sub(obsNumerators[k].mul(
obsDenominatros[k].diff(l)))
#initial functions
if len(initFunctions) != 0:
initDerivativesNum = [0] * len(initFunctions)
for i in range(m):
initDerivativesNum[i] = [0] * n
for k in range(m):
for l in range(n):
initDerivativesNum[k][l] = Apoly(None, allVariables, None)
initDerivativesNum[k][l].add(initNumerators[k].diff(l).mul(
initDenominatros[k]))
initDerivativesNum[k][l].sub(initNumerators[k].mul(
initDenominatros[k].diff(l)))
else:
initDerivativesNum = []
sys.stdout.write('\rPreparing equations...done\n')
sys.stdout.flush()
###########################################################################################
############################ build linear system ###################################
###########################################################################################
sys.stdout.write('\nBuilding system...')
sys.stdout.flush()
rSystem = buildSystem(numerators, denominators, derivativesNum,
obsDerivativesNum, initDenominatros,
initDerivativesNum, initFunctions, infis, diffInfis,
diffInfiT, allVariables, rs, parallel, ansatz)
sys.stdout.write('done\n')
sys.stdout.flush()
###########################################################################################
############################## solve system ########################################
###########################################################################################
sys.stdout.write('\nSolving system of size ' + str(rSystem.shape[0]) + 'x' +\
str(rSystem.shape[1]) + '...')
sys.stdout.flush()
#get LU decomposition from scipy
rSystem = scipy.linalg.lu(rSystem, permute_l=True)[1]
#calculate reduced row echelon form
rSystem, pivots = getrref(rSystem)
sys.stdout.write('done\n')
sys.stdout.flush()
###########################################################################################
############################# process results ######################################
###########################################################################################
sys.stdout.write('\nProcessing results...')
sys.stdout.flush()
# calculate solution space
sys.stdout.write('\n calculating solution space')
sys.stdout.flush()
baseMatrix = nullSpace(rSystem, pivots)
#substitute solutions into infinitesimals
#(and remove the ones with common parameter factors)
sys.stdout.write('\n substituting solutions')
sys.stdout.flush()
infisAll = []
for l in range(baseMatrix.shape[1]):
infisTmp = [0] * n
for i in range(len(infis)):
infisTmp[i] = infis[i].getCopy()
infisTmp[i].rs = baseMatrix[:, l]
infisTmp[i] = infisTmp[i].as_expr()
if timeTrans:
infisTmp.append(baseMatrix[-1, l] * T)
if allTrafos:
infisAll.append(infisTmp)
else:
if not checkForCommonFactor(infisTmp, allVariables, m):
infisAll.append(infisTmp)
print('')
sys.stdout.write('done\n')
sys.stdout.flush()
# print transformations
print('\n\n')
if len(infisAll) != 0:
printTransformations(infisAll, allVariables, pretty, suffix)
###########################################################################################
############################ check predictions #####################################
###########################################################################################
if predictions != False:
checkPredictions(predictions, predFunctions, infisAll, allVariables)
print(
time.strftime('\nTotal time: %Hh:%Mm:%Ss',
time.gmtime(time.time() - t0)))
def gen_lobatto(max_order):
assert max_order > 2
x = sm.symbols('x')
lobs = [0, 1]
lobs[0] = (1 - x) / 2
lobs[1] = (1 + x) / 2
dlobs = [lob.diff('x') for lob in lobs]
legs = [sm.legendre(0, 'y')]
clegs = [sm.ccode(legs[0])]
dlegs = [sm.legendre(0, 'y').diff('y')]
cdlegs = [sm.ccode(dlegs[0])]
clobs = [sm.ccode(lob) for lob in lobs]
cdlobs = [sm.ccode(dlob) for dlob in dlobs]
denoms = [] # for lobs.
for ii in range(2, max_order + 1):
coef = sm.sympify('sqrt(2 * (2 * %s - 1)) / 2' % ii)
leg = sm.legendre(ii - 1, 'y')
pleg = leg.as_poly()
coefs = pleg.all_coeffs()
denom = max(sm.denom(val) for val in coefs)
cleg = sm.ccode(sm.horner(leg*denom)/denom)
dleg = leg.diff('y')
cdleg = sm.ccode(sm.horner(dleg*denom)/denom)
lob = sm.simplify(coef * sm.integrate(leg, ('y', -1, x)))
lobnc = sm.simplify(sm.integrate(leg, ('y', -1, x)))
plobnc = lobnc.as_poly()
coefs = plobnc.all_coeffs()
denom = sm.denom(coef) * max(sm.denom(val) for val in coefs)
clob = sm.ccode(sm.horner(lob*denom)/denom)
dlob = lob.diff('x')
cdlob = sm.ccode(sm.horner(dlob*denom)/denom)
legs.append(leg)
clegs.append(cleg)
dlegs.append(dleg)
cdlegs.append(cdleg)
lobs.append(lob)
clobs.append(clob)
dlobs.append(dlob)
cdlobs.append(cdlob)
denoms.append(denom)
coef = sm.sympify('sqrt(2 * (2 * %s - 1)) / 2' % (max_order + 1))
leg = sm.legendre(max_order, 'y')
pleg = leg.as_poly()
coefs = pleg.all_coeffs()
denom = max(sm.denom(val) for val in coefs)
cleg = sm.ccode(sm.horner(leg*denom)/denom)
dleg = leg.diff('y')
cdleg = sm.ccode(sm.horner(dleg*denom)/denom)
legs.append(leg)
clegs.append(cleg)
dlegs.append(dleg)
cdlegs.append(cdleg)
kerns = []
ckerns = []
dkerns = []
cdkerns = []
for ii, lob in enumerate(lobs[2:]):
kern = sm.simplify(lob / (lobs[0] * lobs[1]))
dkern = kern.diff('x')
denom = denoms[ii] / 4
ckern = sm.ccode(sm.horner(kern*denom)/denom)
cdkern = sm.ccode(sm.horner(dkern*denom)/denom)
kerns.append(kern)
ckerns.append(ckern)
dkerns.append(dkern)
cdkerns.append(cdkern)
return (legs, clegs, dlegs, cdlegs,
lobs, clobs, dlobs, cdlobs,
kerns, ckerns, dkerns, cdkerns,
denoms)
def approximants(l, X=Symbol('x'), simplify=False):
"""
Return a generator for consecutive Pade approximants for a series.
It can also be used for computing the rational generating function of a
series when possible, since the last approximant returned by the generator
will be the generating function (if any).
The input list can contain more complex expressions than integer or rational
numbers; symbols may also be involved in the computation. An example below
show how to compute the generating function of the whole Pascal triangle.
The generator can be asked to apply the sympy.simplify function on each
generated term, which will make the computation slower; however it may be
useful when symbols are involved in the expressions.
Examples
========
>>> from sympy.series import approximants
>>> from sympy import lucas, fibonacci, symbols, binomial
>>> g = [lucas(k) for k in range(16)]
>>> [e for e in approximants(g)]
[2, -4/(x - 2), (5*x - 2)/(3*x - 1), (x - 2)/(x**2 + x - 1)]
>>> h = [fibonacci(k) for k in range(16)]
>>> [e for e in approximants(h)]
[x, -x/(x - 1), (x**2 - x)/(2*x - 1), -x/(x**2 + x - 1)]
>>> x, t = symbols("x,t")
>>> p=[sum(binomial(k,i)*x**i for i in range(k+1)) for k in range(16)]
>>> y = approximants(p, t)
>>> for k in range(3): print(next(y))
1
(x + 1)/((-x - 1)*(t*(x + 1) + (x + 1)/(-x - 1)))
nan
>>> y = approximants(p, t, simplify=True)
>>> for k in range(3): print(next(y))
1
-1/(t*(x + 1) - 1)
nan
See Also
========
See function sympy.concrete.guess.guess_generating_function_rational and
function mpmath.pade
"""
p1, q1 = [Integer(1)], [Integer(0)]
p2, q2 = [Integer(0)], [Integer(1)]
while len(l):
b = 0
while l[b] == 0:
b += 1
if b == len(l):
return
m = [Integer(1) / l[b]]
for k in range(b + 1, len(l)):
s = 0
for j in range(b, k):
s -= l[j + 1] * m[b - j - 1]
m.append(s / l[b])
l = m
a, l[0] = l[0], 0
p = [0] * max(len(p2), b + len(p1))
q = [0] * max(len(q2), b + len(q1))
for k in range(len(p2)):
p[k] = a * p2[k]
for k in range(b, b + len(p1)):
p[k] += p1[k - b]
for k in range(len(q2)):
q[k] = a * q2[k]
for k in range(b, b + len(q1)):
q[k] += q1[k - b]
while p[-1] == 0:
p.pop()
while q[-1] == 0:
q.pop()
p1, p2 = p2, p
q1, q2 = q2, q
# yield result
from sympy import denom, lcm, simplify as simp
c = 1
for x in p:
c = lcm(c, denom(x))
for x in q:
c = lcm(c, denom(x))
out = (sum(c * e * X**k
for k, e in enumerate(p)) / sum(c * e * X**k
for k, e in enumerate(q)))
if simplify: yield (simp(out))
else: yield out
return
def gen_lobatto(max_order):
assert max_order > 2
x = sm.symbols('x')
lobs = [0, 1]
lobs[0] = (1 - x) / 2
lobs[1] = (1 + x) / 2
dlobs = [lob.diff('x') for lob in lobs]
legs = [sm.legendre(0, 'y')]
clegs = [sm.ccode(legs[0])]
dlegs = [sm.legendre(0, 'y').diff('y')]
cdlegs = [sm.ccode(dlegs[0])]
clobs = [sm.ccode(lob) for lob in lobs]
cdlobs = [sm.ccode(dlob) for dlob in dlobs]
denoms = [] # for lobs.
for ii in range(2, max_order + 1):
coef = sm.sympify('sqrt(2 * (2 * %s - 1)) / 2' % ii)
leg = sm.legendre(ii - 1, 'y')
pleg = leg.as_poly()
coefs = pleg.all_coeffs()
denom = max(sm.denom(val) for val in coefs)
cleg = sm.ccode(sm.horner(leg * denom) / denom)
dleg = leg.diff('y')
cdleg = sm.ccode(sm.horner(dleg * denom) / denom)
lob = sm.simplify(coef * sm.integrate(leg, ('y', -1, x)))
lobnc = sm.simplify(sm.integrate(leg, ('y', -1, x)))
plobnc = lobnc.as_poly()
coefs = plobnc.all_coeffs()
denom = sm.denom(coef) * max(sm.denom(val) for val in coefs)
clob = sm.ccode(sm.horner(lob * denom) / denom)
dlob = lob.diff('x')
cdlob = sm.ccode(sm.horner(dlob * denom) / denom)
legs.append(leg)
clegs.append(cleg)
dlegs.append(dleg)
cdlegs.append(cdleg)
lobs.append(lob)
clobs.append(clob)
dlobs.append(dlob)
cdlobs.append(cdlob)
denoms.append(denom)
coef = sm.sympify('sqrt(2 * (2 * %s - 1)) / 2' % (max_order + 1))
leg = sm.legendre(max_order, 'y')
pleg = leg.as_poly()
coefs = pleg.all_coeffs()
denom = max(sm.denom(val) for val in coefs)
cleg = sm.ccode(sm.horner(leg * denom) / denom)
dleg = leg.diff('y')
cdleg = sm.ccode(sm.horner(dleg * denom) / denom)
legs.append(leg)
clegs.append(cleg)
dlegs.append(dleg)
cdlegs.append(cdleg)
kerns = []
ckerns = []
dkerns = []
cdkerns = []
for ii, lob in enumerate(lobs[2:]):
kern = sm.simplify(lob / (lobs[0] * lobs[1]))
dkern = kern.diff('x')
denom = denoms[ii] / 4
ckern = sm.ccode(sm.horner(kern * denom) / denom)
cdkern = sm.ccode(sm.horner(dkern * denom) / denom)
kerns.append(kern)
ckerns.append(ckern)
dkerns.append(dkern)
cdkerns.append(cdkern)
return (legs, clegs, dlegs, cdlegs, lobs, clobs, dlobs, cdlobs, kerns,
ckerns, dkerns, cdkerns, denoms)
def guess(l, all=False, evaluate=True, niter=2, variables=None):
"""
This function is adapted from the Rate.m package for Mathematica
written by Christian Krattenthaler.
It tries to guess a formula from a given sequence of rational numbers.
In order to speed up the process, the 'all' variable is set to False by
default, stopping the computation as some results are returned during an
iteration; the variable can be set to True if more iterations are needed
(other formulas may be found; however they may be equivalent to the first
ones).
Another option is the 'evaluate' variable (default is True); setting it
to False will leave the involved products unevaluated.
By default, the number of iterations is set to 2 but a greater value (up
to len(l)-1) can be specified with the optional 'niter' variable.
More and more convoluted results are found when the order of the
iteration gets higher:
* first iteration returns polynomial or rational functions;
* second iteration returns products of rising factorials and their
inverses;
* third iteration returns products of products of rising factorials
and their inverses;
* etc.
The returned formulas contain symbols i0, i1, i2, ... where the main
variables is i0 (and auxiliary variables are i1, i2, ...). A list of
other symbols can be provided in the 'variables' option; the length of
the least should be the value of 'niter' (more is acceptable but only
the first symbols will be used); in this case, the main variable will be
the first symbol in the list.
>>> from sympy.concrete.guess import guess
>>> guess([1,2,6,24,120], evaluate=False)
[Product(i1 + 1, (i1, 1, i0 - 1))]
>>> from sympy import symbols
>>> r = guess([1,2,7,42,429,7436,218348,10850216], niter=4)
>>> i0 = symbols("i0")
>>> [r[0].subs(i0,n).doit() for n in range(1,10)]
[1, 2, 7, 42, 429, 7436, 218348, 10850216, 911835460]
"""
if any(a==0 for a in l[:-1]):
return []
N = len(l)
niter = min(N-1, niter)
myprod = product if evaluate else Product
g = []
res = []
if variables == None:
symb = symbols('i:'+str(niter))
else:
symb = variables
for k, s in enumerate(symb):
g.append(l)
n, r = len(l), []
for i in range(n-2-1, -1, -1):
ri = rinterp(enumerate(g[k][:-1], start=1), i, X=s)
if ((denom(ri).subs({s:n}) != 0)
and (ri.subs({s:n}) - g[k][-1] == 0)
and ri not in r):
r.append(ri)
if r:
for i in range(k-1, -1, -1):
r = list(map(lambda v: g[i][0]
* myprod(v, (symb[i+1], 1, symb[i]-1)), r))
if not all: return r
res += r
l = [Rational(l[i+1], l[i]) for i in range(N-k-1)]
return res
# In[7]: G = K/(tau**2*s**2 + 2*tau*zeta*s + 1) G # In[8]: invL(G) # The characteristic equation is the denominator of the transfer function # In[5]: ce = sympy.Eq(sympy.denom(G), 0) ce # In[6]: roots = sympy.roots(ce, s) roots # The shape of the inverse Laplace depends on the nature of the roots, which depends on the value of $\zeta$ # Overdamped: $\zeta>1$. Two distinct real roots # In[3]:
def find_simple_recurrence_vector(l):
"""
This function is used internally by other functions from the
sympy.concrete.guess module. While most users may want to rather use the
function find_simple_recurrence when looking for recurrence relations
among rational numbers, the current function may still be useful when
some post-processing has to be done.
The function returns a vector of length n when a recurrence relation of
order n is detected in the sequence of rational numbers v.
If the returned vector has a length 1, then the returned value is always
the list [0], which means that no relation has been found.
While the functions is intended to be used with rational numbers, it should
work for other kinds of real numbers except for some cases involving
quadratic numbers; for that reason it should be used with some caution when
the argument is not a list of rational numbers.
Examples
========
>>> from sympy.concrete.guess import find_simple_recurrence_vector
>>> from sympy import fibonacci
>>> find_simple_recurrence_vector([fibonacci(k) for k in range(12)])
[1, -1, -1]
See also
========
See the function sympy.concrete.guess.find_simple_recurrence which is more
user-friendly.
"""
q1 = [0]
q2 = [Integer(1)]
z = len(l) >> 1
while len(q2) <= z:
b = 0
while l[b] == 0:
b += 1
if b == len(l):
c = 1
for x in q2:
c = lcm(c, denom(x))
if q2[0] * c < 0: c = -c
for k in range(len(q2)):
q2[k] = int(q2[k] * c)
return q2
m = [Integer(1) / l[b]]
for k in range(b + 1, len(l)):
s = 0
for j in range(b, k):
s -= l[j + 1] * m[b - j - 1]
m.append(s / l[b])
l = m
a, l[0] = l[0], 0
q = [0] * max(len(q2), b + len(q1))
for k in range(len(q2)):
q[k] = a * q2[k]
for k in range(b, b + len(q1)):
q[k] += q1[k - b]
while q[-1] == 0:
q.pop() # because trailing zeros can occur
q1, q2 = q2, q
return [0]
def approximants(l, X=Symbol('x'), simplify=False):
"""
Return a generator for consecutive Pade approximants for a series.
It can also be used for computing the rational generating function of a
series when possible, since the last approximant returned by the generator
will be the generating function (if any).
The input list can contain more complex expressions than integer or rational
numbers; symbols may also be involved in the computation. An example below
show how to compute the generating function of the whole Pascal triangle.
The generator can be asked to apply the sympy.simplify function on each
generated term, which will make the computation slower; however it may be
useful when symbols are involved in the expressions.
Examples
========
>>> from sympy.series import approximants
>>> from sympy import lucas, fibonacci, symbols, binomial
>>> g = [lucas(k) for k in range(16)]
>>> [e for e in approximants(g)]
[2, -4/(x - 2), (5*x - 2)/(3*x - 1), (x - 2)/(x**2 + x - 1)]
>>> h = [fibonacci(k) for k in range(16)]
>>> [e for e in approximants(h)]
[x, -x/(x - 1), (x**2 - x)/(2*x - 1), -x/(x**2 + x - 1)]
>>> x, t = symbols("x,t")
>>> p=[sum(binomial(k,i)*x**i for i in range(k+1)) for k in range(16)]
>>> y = approximants(p, t)
>>> for k in range(3): print(next(y))
1
(x + 1)/((-x - 1)*(t*(x + 1) + (x + 1)/(-x - 1)))
nan
>>> y = approximants(p, t, simplify=True)
>>> for k in range(3): print(next(y))
1
-1/(t*(x + 1) - 1)
nan
See also
========
See function sympy.concrete.guess.guess_generating_function_rational and
function mpmath.pade
"""
p1, q1 = [Integer(1)], [Integer(0)]
p2, q2 = [Integer(0)], [Integer(1)]
while len(l):
b = 0
while l[b]==0:
b += 1
if b == len(l):
return
m = [Integer(1)/l[b]]
for k in range(b+1, len(l)):
s = 0
for j in range(b, k):
s -= l[j+1] * m[b-j-1]
m.append(s/l[b])
l = m
a, l[0] = l[0], 0
p = [0] * max(len(p2), b+len(p1))
q = [0] * max(len(q2), b+len(q1))
for k in range(len(p2)):
p[k] = a*p2[k]
for k in range(b, b+len(p1)):
p[k] += p1[k-b]
for k in range(len(q2)):
q[k] = a*q2[k]
for k in range(b, b+len(q1)):
q[k] += q1[k-b]
while p[-1]==0: p.pop()
while q[-1]==0: q.pop()
p1, p2 = p2, p
q1, q2 = q2, q
# yield result
from sympy import denom, lcm, simplify as simp
c = 1
for x in p:
c = lcm(c, denom(x))
for x in q:
c = lcm(c, denom(x))
out = ( sum(c*e*X**k for k, e in enumerate(p))
/ sum(c*e*X**k for k, e in enumerate(q)) )
if simplify: yield(simp(out))
else: yield out
return
def test_issue_5933():
from sympy import Polygon, RegularPolygon, denom
x = Polygon(*RegularPolygon((0, 0), 1, 5).vertices).centroid.x
assert abs(denom(x).n()) > 1e-12
assert abs(denom(radsimp(x))) > 1e-12 # in case simplify didn't handle it
def guess(l, all=False, evaluate=True, niter=2, variables=None):
"""
This function is adapted from the Rate.m package for Mathematica
written by Christian Krattenthaler.
It tries to guess a formula from a given sequence of rational numbers.
In order to speed up the process, the 'all' variable is set to False by
default, stopping the computation as some results are returned during an
iteration; the variable can be set to True if more iterations are needed
(other formulas may be found; however they may be equivalent to the first
ones).
Another option is the 'evaluate' variable (default is True); setting it
to False will leave the involved products unevaluated.
By default, the number of iterations is set to 2 but a greater value (up
to len(l)-1) can be specified with the optional 'niter' variable.
More and more convoluted results are found when the order of the
iteration gets higher:
* first iteration returns polynomial or rational functions;
* second iteration returns products of rising factorials and their
inverses;
* third iteration returns products of products of rising factorials
and their inverses;
* etc.
The returned formulas contain symbols i0, i1, i2, ... where the main
variables is i0 (and auxiliary variables are i1, i2, ...). A list of
other symbols can be provided in the 'variables' option; the length of
the least should be the value of 'niter' (more is acceptable but only
the first symbols will be used); in this case, the main variable will be
the first symbol in the list.
Examples
========
>>> from sympy.concrete.guess import guess
>>> guess([1,2,6,24,120], evaluate=False)
[Product(i1 + 1, (i1, 1, i0 - 1))]
>>> from sympy import symbols
>>> r = guess([1,2,7,42,429,7436,218348,10850216], niter=4)
>>> i0 = symbols("i0")
>>> [r[0].subs(i0,n).doit() for n in range(1,10)]
[1, 2, 7, 42, 429, 7436, 218348, 10850216, 911835460]
"""
if any(a == 0 for a in l[:-1]):
return []
N = len(l)
niter = min(N - 1, niter)
myprod = product if evaluate else Product
g = []
res = []
if variables is None:
symb = symbols('i:' + str(niter))
else:
symb = variables
for k, s in enumerate(symb):
g.append(l)
n, r = len(l), []
for i in range(n - 2 - 1, -1, -1):
ri = rinterp(enumerate(g[k][:-1], start=1), i, X=s)
if ((denom(ri).subs({s: n}) != 0)
and (ri.subs({s: n}) - g[k][-1] == 0) and ri not in r):
r.append(ri)
if r:
for i in range(k - 1, -1, -1):
r = list(
map(
lambda v: g[i][0] * myprod(v, (symb[i + 1], 1, symb[i]
- 1)), r))
if not all: return r
res += r
l = [Rational(l[i + 1], l[i]) for i in range(N - k - 1)]
return res
def _split_value_equally(delta, count): """Splits an integer or rational into roughly equal parts.""" numer = sympy.numer(delta) denom = sympy.denom(delta) return [int(math.floor((numer + i) / count)) / denom for i in range(count)]
hf_lp = lambdify(s, Vo_lp, 'numpy')
bode_output_lp = hf_lp(ss)
plt.loglog(ww, abs(bode_output_lp), lw=2)
plt.title("bode plot of lowpass filter")
plt.xlabel('frequency')
plt.ylabel('H(jw)')
plt.grid(True)
plt.show()
numerator_lp = [
float(numer(Vo_lp.simplify()).coeff(s, 2)),
float(numer(Vo_lp.simplify()).coeff(s, 1)),
float(numer(Vo_lp.simplify()).coeff(s, 0))
]
denominator_lp = [
float(denom(Vo_lp.simplify()).coeff(s, 2)),
float(denom(Vo_lp.simplify()).coeff(s, 1)),
float(denom(Vo_lp.simplify()).coeff(s, 0))
]
#1
v, t = sp.step([numerator_lp, denominator_lp], None, np.arange(0, 1e-3, 1e-6))
plt.plot(v, t)
plt.title("Step response of lowpass filter")
plt.grid(True)
plt.xlabel('t')
plt.ylabel('Vo')
plt.show()
#2
t1 = np.arange(0, 1e-2, 1e-6)
def symmetryDetection(allVariables, diffEquations, observables, obsFunctions, initFunctions,
predictions, predFunctions, ansatz = 'uni', pMax = 2, inputs = [],
fixed = [], parallel = 1, allTrafos = False, timeTrans = False,
pretty = True, suffix=''):
n = len(allVariables)
m = len(diffEquations)
h = len(observables)
###########################################################################################
############################# prepare equations ####################################
###########################################################################################
sys.stdout.write('Preparing equations...')
sys.stdout.flush()
# make infinitesimal ansatz
infis, diffInfis, rs = makeAnsatz(ansatz, allVariables, m, len(inputs), pMax, fixed)
# get infinitesimals of time transformation
if timeTrans:
rs.append(spy.var('r_T_1'))
diffInfiT = rs[-1]
allVariables += [T]
else:
diffInfiT = None
# and convert to polynomial
infis, diffInfis = transformInfisToPoly(infis, diffInfis, allVariables, rs, parallel, ansatz)
diffInfiT = Apoly(diffInfiT, allVariables, rs)
### extract numerator and denominator of equations
#differential equations
numerators = [0]*m
denominators = [0]*m
for k in range(m):
rational = spy.together(diffEquations[k])
numerators[k] = Apoly(spy.numer(rational), allVariables, None)
denominators[k] = Apoly(spy.denom(rational), allVariables, None)
#observation functions
obsNumerators = [0]*h
obsDenominatros = [0]*h
for k in range(h):
rational = spy.together(obsFunctions[k])
obsNumerators[k] = Apoly(spy.numer(rational), allVariables, None)
obsDenominatros[k] = Apoly(spy.denom(rational), allVariables, None)
#initial functions
if len(initFunctions) != 0:
initNumerators = [0]*m
initDenominatros = [0]*m
for k in range(m):
rational = spy.together(initFunctions[k])
initNumerators[k] = Apoly(spy.numer(rational), allVariables, None)
initDenominatros[k] = Apoly(spy.denom(rational), allVariables, None)
else:
initNumerators = []
initDenominatros = []
### calculate numerator of derivatives of equations
#differential equatioins
derivativesNum = [0]*m
for i in range(m):
derivativesNum[i] = [0]*n
for k in range(m):
for l in range(n):
derivativesNum[k][l] = Apoly(None, allVariables, None)
derivativesNum[k][l].add(numerators[k].diff(l).mul(denominators[k]))
derivativesNum[k][l].sub(numerators[k].mul(denominators[k].diff(l)))
#observation functions
obsDerivativesNum = [0]*h
for i in range(h):
obsDerivativesNum[i] = [0]*n
for k in range(h):
for l in range(n):
obsDerivativesNum[k][l] = Apoly(None, allVariables, None)
obsDerivativesNum[k][l].add(obsNumerators[k].diff(l).mul(obsDenominatros[k]))
obsDerivativesNum[k][l].sub(obsNumerators[k].mul(obsDenominatros[k].diff(l)))
#initial functions
if len(initFunctions) != 0:
initDerivativesNum = [0]*len(initFunctions)
for i in range(m):
initDerivativesNum[i] = [0]*n
for k in range(m):
for l in range(n):
initDerivativesNum[k][l] = Apoly(None, allVariables, None)
initDerivativesNum[k][l].add(initNumerators[k].diff(l).mul(initDenominatros[k]))
initDerivativesNum[k][l].sub(initNumerators[k].mul(initDenominatros[k].diff(l)))
else:
initDerivativesNum = []
sys.stdout.write('\rPreparing equations...done\n')
sys.stdout.flush()
###########################################################################################
############################ build linear system ###################################
###########################################################################################
sys.stdout.write('\nBuilding system...')
sys.stdout.flush()
rSystem = buildSystem(numerators, denominators, derivativesNum, obsDerivativesNum,
initDenominatros, initDerivativesNum, initFunctions,
infis, diffInfis, diffInfiT, allVariables, rs, parallel, ansatz)
sys.stdout.write('done\n')
sys.stdout.flush()
###########################################################################################
############################## solve system ########################################
###########################################################################################
sys.stdout.write('\nSolving system of size ' + str(rSystem.shape[0]) + 'x' +\
str(rSystem.shape[1]) + '...')
sys.stdout.flush()
#get LU decomposition from scipy
rSystem = scipy.linalg.lu(rSystem, permute_l=True)[1]
#calculate reduced row echelon form
rSystem, pivots = getrref(rSystem)
sys.stdout.write('done\n')
sys.stdout.flush()
###########################################################################################
############################# process results ######################################
###########################################################################################
sys.stdout.write('\nProcessing results...')
sys.stdout.flush()
# calculate solution space
sys.stdout.write('\n calculating solution space')
sys.stdout.flush()
baseMatrix = nullSpace(rSystem, pivots)
#substitute solutions into infinitesimals
#(and remove the ones with common parameter factors)
sys.stdout.write('\n substituting solutions')
sys.stdout.flush()
infisAll = []
for l in range(baseMatrix.shape[1]):
infisTmp = [0]*n
for i in range(len(infis)):
infisTmp[i] = infis[i].getCopy()
infisTmp[i].rs = baseMatrix[:,l]
infisTmp[i] = infisTmp[i].as_expr()
if timeTrans:
infisTmp.append(baseMatrix[-1,l] * T)
if allTrafos:
infisAll.append(infisTmp)
else:
if not checkForCommonFactor(infisTmp, allVariables, m):
infisAll.append(infisTmp)
print('')
sys.stdout.write('done\n')
sys.stdout.flush()
# print transformations
print('\n\n')
if len(infisAll) != 0: printTransformations(infisAll, allVariables, pretty,suffix)
###########################################################################################
############################ check predictions #####################################
###########################################################################################
if predictions != False:
checkPredictions(predictions, predFunctions, infisAll, allVariables)
print(time.strftime('\nTotal time: %Hh:%Mm:%Ss', time.gmtime(time.time()-t0)))
if G[r, c] != 0:
m1.append(G[r, c])
print G[r, c]
print '---Minors of order 2---'
m2_1 = G[:, [1, 2]]
m2_2 = G[:, [0, 2]]
m2_3 = G[:, [0, 1]]
print m2_1
print m2_2
print m2_3
print '---All poles---'
m1count = np.shape(m1)[0]
for m in range(0, m1count):
print sp.solve(sp.denom(m1[m]))
def M21(s):
return G[:, [1, 2]]
def M12(s):
return G[:, [0, 1]]
def M13(s):
return G[:, [0, 1]]
print poles(M21)