def progFecthAnnot(arm, cart):
# The variables:
A_a, A_b, A_c = sp.symbols('A_a, A_b, A_c')
C_x, C_y, C_theta = sp.symbols('C_x, C_y, C_theta')
return {
"A0":
sp.true,
"A1":
sp.true,
"A2":
sp.true,
"C0":
sp.And(sp.Eq(C_x, 0), sp.Eq(C_y, 0), sp.Eq(C_theta, 0)),
"C1":
sp.And(sp.Eq(A_a, arm.maxAngleAB), sp.Eq(A_b, arm.minAngleAB),
sp.Eq(A_c, 0), C_x >= 0, C_x <= 2, sp.Eq(C_y, 0)),
"C2":
sp.And(sp.Eq(A_a, arm.maxAngleAB), sp.Eq(A_b, arm.minAngleAB),
sp.Eq(A_c, 0), sp.Eq(C_x, 2), sp.Eq(C_y, 0)),
"C3":
sp.And(sp.Eq(C_x, 2), sp.Eq(C_y, 0)),
"C4":
sp.And(sp.Eq(A_a, arm.maxAngleAB), sp.Eq(A_b, arm.minAngleAB),
sp.Eq(A_c, 0), C_x >= 0, C_x <= 2, sp.Eq(C_y, 0))
}
def update_I(kb, kb_symbols, data_q, undefined, possible_states):
del_I = []
for place in kb:
i, j, n, s = place.split(sep='_')
if s == 'I':
i, j, n = int(i), int(j), int(n)
pattern = '{}_{}_*'.format(i, j)
for state in undefined:
if re.match(pattern, state):
i_s, j_s, n_s = state.split(sep='_')
if int(n_s) > n:
del_I.append(state)
new_symbol = state + '_I'
data_q.append(new_symbol)
kb.append(new_symbol)
new_symbol = sympy.symbols(new_symbol)
kb_symbols = sympy.And(kb_symbols, new_symbol)
for p in possible_states:
if p != 'I':
not_symbol = state + '_' + p
data_q.append('~' + not_symbol)
not_symbol = sympy.symbols(not_symbol)
kb_symbols = sympy.And(kb_symbols, ~not_symbol)
undefined = [ele for ele in undefined if ele not in del_I]
return kb_symbols, undefined
def spreader(kb_symbols, undefined, kb, row_num, col_num, data_q, possible_states, police_num):
undefined_sort = sorted(undefined)
for u in range(len(undefined_sort)-1):
i, j, n = undefined_sort[u].split(sep='_')
i, j, n = int(i), int(j), int(n)
pattern = '{}_{}_{}'.format(i, j, n+1)
if undefined_sort[u+1] == pattern:
infected_by_u = False
if i > 0:
infected_by_u = neigh_by_neigh(kb, i-1, j, n + 1, 'down', police_num, row_num, col_num, undefined)
if not infected_by_u and i < row_num - 1:
infected_by_u = neigh_by_neigh(kb, i+1, j, n + 1, 'up', police_num, row_num, col_num, undefined)
if not infected_by_u and j > 0:
infected_by_u = neigh_by_neigh(kb, i, j-1, n + 1, 'left', police_num, row_num, col_num, undefined)
if not infected_by_u and j < col_num - 1:
infected_by_u = neigh_by_neigh(kb, i, j + 1, n + 1, 'right', police_num, row_num, col_num, undefined)
if infected_by_u:
symbol = undefined_sort[u] + '_S'
undefined.remove(undefined_sort[u])
data_q.append(symbol)
kb.append(symbol)
symbol = sympy.symbols(symbol)
kb_symbols = sympy.And(kb_symbols, symbol)
if police_num > 0:
notq = undefined_sort[u+1] + '_Q'
data_q.append('~' + notq)
notq = sympy.symbols(notq)
kb_symbols = sympy.And(kb_symbols, ~notq)
for p in possible_states:
if p != 'S':
not_symbol = undefined_sort[u] + '_' + p
data_q.append('~' + not_symbol)
not_symbol = sympy.symbols(not_symbol)
kb_symbols = sympy.And(kb_symbols, ~not_symbol)
return kb_symbols
def set_dtbs_error(model):
"""Dynamic transform both sides"""
theta_as_stdev(model)
set_weighted_error_model(model)
stats, y, f = _preparations(model)
tbs_lambda = Parameter('tbs_lambda', 1)
tbs_zeta = Parameter('tbs_zeta', 0.001)
model.parameters.append(tbs_lambda)
model.parameters.append(tbs_zeta)
lam = tbs_lambda.symbol
zeta = tbs_zeta.symbol
for i, s in enumerate(stats):
if isinstance(s, Assignment) and s.symbol == sympy.Symbol('W'):
break
stats.insert(i + 1, Assignment('W', (f ** zeta) * sympy.Symbol('W')))
ipred = sympy.Piecewise(
((f ** lam - 1) / lam, sympy.And(sympy.Ne(lam, 0), sympy.Ne(f, 0))),
(sympy.log(f), sympy.And(sympy.Eq(lam, 0), sympy.Ne(f, 0))),
(-1 / lam, sympy.And(sympy.Eq(lam, 0), sympy.Eq(f, 0))),
(-1000000000, True),
)
stats.insert(i + 2, Assignment('IPRED', ipred))
yexpr = stats.find_assignment(y.name)
yexpr.subs({f: sympy.Symbol('IPRED')})
obs = sympy.Piecewise(
(sympy.log(y), sympy.Eq(lam, 0)), ((y ** lam - 1) / lam, sympy.Ne(lam, 0))
)
model.observation_transformation = obs
return model
def _interpolation_indices(self, variables, offset=0):
"""
Generate interpolation indices for the DiscreteFunctions in ``variables``.
"""
index_matrix, points = self._index_matrix(offset)
idx_subs = []
for i, idx in enumerate(index_matrix):
# Introduce ConditionalDimension so that we don't go OOB
mapper = {}
for j, d in zip(idx, self.grid.dimensions):
p = points[j]
lb = sympy.And(p >= d.symbolic_min - self._radius, evaluate=False)
ub = sympy.And(p <= d.symbolic_max + self._radius, evaluate=False)
condition = sympy.And(lb, ub, evaluate=False)
mapper[d] = ConditionalDimension(p.name, self._sparse_dim,
condition=condition, indirect=True)
# Track Indexed substitutions
idx_subs.append(OrderedDict([(v, v.subs(mapper)) for v in variables
if v.function is not self]))
# Equations for the indirection dimensions
eqns = [Eq(v, k) for k, v in points.items()]
# Equations (temporaries) for the coefficients
eqns.extend([Eq(p, c) for p, c in
zip(self._point_symbols, self._coordinate_bases)])
return idx_subs, eqns
def KB(observations,possible_states):
# kb : list of strings defining states in observations
kb = []
kb_not = []
# undefined : list of unknown states defined by strings of row_col_obsNum
undefined = []
# U : list of tuples (row,col) where there is U, at any observation
U = []
for item in enumerate(observations):
obsNum = item[0]
obs = item[1]
for i in range(len(obs)):
for j in range(len(obs[0])):
state = obs[i][j]
if state == '?':
undefined.append('{}_{}_{}'.format(i, j, obsNum))
else:
kb.append('{}_{}_{}_{}'.format(i, j, obsNum, state))
for s in possible_states:
if s != state:
kb_not.append('~{}_{}_{}_{}'.format(i, j, obsNum, s))
if state == 'U':
U.append((i, j))
kb_symbols = 1
# transform strings to symbols
# kb_symbols : expression of all strings in KB with & operator between them
for symbol in kb:
symbol = sympy.symbols(symbol)
kb_symbols = sympy.And(kb_symbols, symbol)
for symbol_n in kb_not:
symbol_n = symbol_n[1:]
symbol_n = sympy.symbols(symbol_n)
kb_symbols = sympy.And(kb_symbols, ~symbol_n)
return kb_symbols, undefined, U, kb, kb_not
def pde_model_disc(N, dx):
if dx < 0:
raise ValueError("dx must be non-negative")
if N < 1:
raise ValueError("N must be positive")
x = sympy.Symbol('x')
r = sympy.Symbol('r')
cl = sympy.Symbol('cl')
L = sympy.Symbol('L')
i = sympy.Idx('i')
c = sympy.IndexedBase('c')
m = model.Model()
m.name = 'laplace discretised'
m.parameters = {cl, L}
m.solution_variables = {c[i]}
m.bounds = sympy.And(i >= 0, i <= N)
m.eqs = {
(sympy.And(i > 0, i < N), sympy.Eq((c[i+1] - 2*c[i] - c[i-1])/(dx**2), 0)),
(sympy.Eq(i, 0), sympy.Eq(c[i], cl)),
(sympy.Eq(i, N), sympy.Eq((c[i] - c[i-1])/dx, 0))
}
return m
def trig_substitution_rule(integral):
integrand, symbol = integral
A = sympy.Wild('a', exclude=[0, symbol])
B = sympy.Wild('b', exclude=[0, symbol])
theta = sympy.Dummy("theta")
target_pattern = A + B*symbol**2
matches = integrand.find(target_pattern)
for expr in matches:
match = expr.match(target_pattern)
a = match.get(A, ZERO)
b = match.get(B, ZERO)
a_positive = ((a.is_number and a > 0) or a.is_positive)
b_positive = ((b.is_number and b > 0) or b.is_positive)
a_negative = ((a.is_number and a < 0) or a.is_negative)
b_negative = ((b.is_number and b < 0) or b.is_negative)
x_func = None
if a_positive and b_positive:
# a**2 + b*x**2. Assume sec(theta) > 0, -pi/2 < theta < pi/2
x_func = (sympy.sqrt(a)/sympy.sqrt(b)) * sympy.tan(theta)
# Do not restrict the domain: tan(theta) takes on any real
# value on the interval -pi/2 < theta < pi/2 so x takes on
# any value
restriction = True
elif a_positive and b_negative:
# a**2 - b*x**2. Assume cos(theta) > 0, -pi/2 < theta < pi/2
constant = sympy.sqrt(a)/sympy.sqrt(-b)
x_func = constant * sympy.sin(theta)
restriction = sympy.And(symbol > -constant, symbol < constant)
elif a_negative and b_positive:
# b*x**2 - a**2. Assume sin(theta) > 0, 0 < theta < pi
constant = sympy.sqrt(-a)/sympy.sqrt(b)
x_func = constant * sympy.sec(theta)
restriction = sympy.And(symbol > -constant, symbol < constant)
if x_func:
# Manually simplify sqrt(trig(theta)**2) to trig(theta)
# Valid due to assumed domain restriction
substitutions = {}
for f in [sympy.sin, sympy.cos, sympy.tan,
sympy.sec, sympy.csc, sympy.cot]:
substitutions[sympy.sqrt(f(theta)**2)] = f(theta)
substitutions[sympy.sqrt(f(theta)**(-2))] = 1/f(theta)
replaced = integrand.subs(symbol, x_func).trigsimp()
replaced = replaced.subs(substitutions)
if not replaced.has(symbol):
replaced *= manual_diff(x_func, theta)
replaced = replaced.trigsimp()
secants = replaced.find(1/sympy.cos(theta))
if secants:
replaced = replaced.xreplace({
1/sympy.cos(theta): sympy.sec(theta)
})
substep = integral_steps(replaced, theta)
if not contains_dont_know(substep):
return TrigSubstitutionRule(
theta, x_func, replaced, substep, restriction,
integrand, symbol)
def to_automaton(f) -> SymbolicDFA: # noqa: C901
"""Translate to automaton."""
f = f.to_nnf()
initial_state = frozenset({frozenset({PLAtomic(f)})})
states = {initial_state}
final_states = set()
transition_function = {} # type: Dict
all_labels = f.find_labels()
alphabet = powerset(all_labels)
if f.delta({}, epsilon=True) == PLTrue():
final_states.add(initial_state)
visited = set() # type: Set
to_be_visited = {initial_state}
while len(to_be_visited) != 0:
for q in list(to_be_visited):
to_be_visited.remove(q)
for actions_set in alphabet:
new_state = _make_transition(
q, {label: True
for label in actions_set})
if new_state not in states:
states.add(new_state)
to_be_visited.add(new_state)
transition_function.setdefault(q, {})[actions_set] = new_state
if new_state not in visited:
visited.add(new_state)
if _is_true(new_state):
final_states.add(new_state)
automaton = SymbolicAutomaton()
state2idx = {}
for state in states:
state_idx = automaton.create_state()
state2idx[state] = state_idx
if state == initial_state:
automaton.set_initial_state(state_idx)
if state in final_states:
automaton.set_accepting_state(state_idx, True)
for source in transition_function:
for symbol, destination in transition_function[source].items():
source_idx = state2idx[source]
dest_idx = state2idx[destination]
pos_expr = sympy.And(*map(sympy.Symbol, symbol))
neg_expr = sympy.And(*map(lambda x: sympy.Not(sympy.Symbol(x)),
all_labels.difference(symbol)))
automaton.add_transition(
(source_idx, sympy.And(pos_expr, neg_expr), dest_idx))
determinized = automaton.determinize()
minimized = determinized.minimize()
return minimized
def check(cond__):
false_cond = simplify_and(sympy.And(sympy.Not(cond__),
extra_condition))
if false_cond == sympy.sympify(False):
return True
true_cond = simplify_and(sympy.And(cond__, extra_condition))
if true_cond == sympy.sympify(False):
return False
return None
def _parse_expression_list(self, is_conjunction: bool) -> sympy.Basic:
"""<expression_list> ::= <expression> <expression_list> | empty_string"""
exp = sympy.And() if is_conjunction else sympy.Or()
self._source_code.consume_leading_spaces()
while self._source_code.current_char != (self.CONJUNCTION_END if is_conjunction else self.DISJUNCTION_END):
exp = (sympy.And(exp, self._parse_expression()) if is_conjunction
else sympy.Or(exp, self._parse_expression()))
self._source_code.consume_leading_spaces()
return exp
def _execute_controller(self):
rate = rospy.Rate(10)
P, I = sp.var('p i')
min_linear_vel = sp.var("minLinearVel")
min_angular_vel = sp.var("minAngularVel")
distErr, distVerticalErr, vertDiff, lastLinearOut = sp.var(
'distErr distVerticalErr vertDiff lastLinearOut')
anglErr, lastAngularOut, anglDiff = sp.var(
'anglErr lastAngularOut anglDiff')
self.linear_eq = sp.Piecewise(
(sp.Max(P * distErr + I * lastLinearOut, min_linear_vel),
sp.And(sp.Abs(anglErr) < anglDiff, distErr >= 0)),
(sp.Min(P * distErr + I * lastLinearOut, -min_linear_vel),
sp.And(sp.Abs(anglErr) < anglDiff, distErr < 0)),
(0, sp.Abs(anglErr) >= anglDiff))
self.linear_vertical_eq = sp.Piecewise(
(sp.Max(P * distVerticalErr + I * lastLinearOut,
min_linear_vel), distVerticalErr > vertDiff), (0, True))
angular_eq_temp = P * anglErr + I * lastAngularOut
self.angular_eq = sp.Piecewise(
(sp.Min(angular_eq_temp, -min_angular_vel), angular_eq_temp < 0),
(sp.Max(angular_eq_temp, min_angular_vel), angular_eq_temp >= 0))
constansts = {
P: self.current_config["p"],
I: self.current_config["i"],
min_linear_vel: self.current_config["min_linear_vel"],
min_angular_vel: self.current_config["min_angular_vel"],
anglDiff: self.current_config["angular_diff"],
vertDiff: self.current_config["vertical_diff"]
}
variables = [
distErr, distVerticalErr, lastLinearOut, anglErr, lastAngularOut
]
self.linear_eq = self.linear_eq.subs(constansts)
self.linear_vertical_eq = self.linear_vertical_eq.subs(constansts)
self.angular_eq = self.angular_eq.subs(constansts)
while not rospy.is_shutdown():
if self._goal != None and self._enabled:
self._command_to(self._goal, variables)
self._reach_publisher.publish(Bool(self._reach))
rate.sleep()
def guard(self, expr=None, offset=0):
"""
Generate guarded expressions, that is expressions that are evaluated
by an Operator only if certain conditions are met. The introduced
condition, here, is that all grid points in the support of a sparse
value must fall within the grid domain (i.e., *not* on the halo).
Parameters
----------
expr : expr-like, optional
Input expression, from which the guarded expression is derived.
If not specified, defaults to ``self``.
offset : int, optional
Relax the guard condition by introducing a tolerance offset.
"""
_, points = self._index_matrix(offset)
# Guard through ConditionalDimension
conditions = {}
for d, idx in zip(self.grid.dimensions, self._coordinate_indices):
p = points[idx]
lb = sympy.And(p >= d.symbolic_min - offset, evaluate=False)
ub = sympy.And(p <= d.symbolic_max + offset, evaluate=False)
conditions[p] = sympy.And(lb, ub, evaluate=False)
condition = sympy.And(*conditions.values(), evaluate=False)
cd = ConditionalDimension("%s_g" % self._sparse_dim,
self._sparse_dim,
condition=condition)
if expr is None:
out = self.indexify().xreplace({self._sparse_dim: cd})
else:
functions = {
f
for f in retrieve_function_carriers(expr)
if f.is_SparseFunction
}
out = indexify(expr).xreplace(
{f._sparse_dim: cd
for f in functions})
# Temporaries for the position
temps = [
Eq(v, k, implicit_dims=self.dimensions)
for k, v in self._position_map.items()
]
# Temporaries for the indirection dimensions
temps.extend([
Eq(v, k.subs(self._position_map), implicit_dims=self.dimensions)
for k, v in points.items() if v in conditions
])
return out, temps
def vaccine(kb, kb_symbols, data_q, undefined, medic_num, num_of_observations, possible_states):
I_changes = [0] * num_of_observations # for each obs count the number on new I
H_to_undefined = {k: [] for k in range(num_of_observations)} # for each obs count the number of h to undrfinrd
H_count = [0] * num_of_observations
undefined_count = [0] * num_of_observations
undefined_current = {k: [] for k in range(num_of_observations)}
for item in kb:
row, col, obsNum, state = item.split(sep='_')
obsNum = int(obsNum)
if state == 'I' and '{}_{}_{}_H'.format(row, col, obsNum - 1) in kb:
I_changes[obsNum] += 1
if state == 'H':
H_count[obsNum] += 1
if '{}_{}_{}'.format(row, col, obsNum + 1) in undefined:
H_to_undefined[obsNum + 1].append((row, col))
for item1 in undefined:
row, col, obsNum = item1.split(sep='_')
obsNum = int(obsNum)
undefined_current[obsNum].append((row,col))
if '{}_{}_{}'.format(row, col, obsNum + 1) in undefined:
undefined_count[obsNum + 1] += 1
for i in range(1,num_of_observations):
if len(H_to_undefined[i]) + undefined_count[i] <= (medic_num - I_changes[i]):
for row, col in H_to_undefined[i]:
symbol = '{}_{}_{}_I'.format(row, col, i)
data_q.append(symbol)
kb.append(symbol)
undefined.remove('{}_{}_{}'.format(row, col, i))
symbol = sympy.symbols(symbol)
kb_symbols = sympy.And(kb_symbols, symbol)
for p in possible_states:
if p != 'I':
not_symbol = '{}_{}_{}_{}'.format(row, col, i, p)
data_q.append('~' + not_symbol)
not_symbol = sympy.symbols(not_symbol)
kb_symbols = sympy.And(kb_symbols,~not_symbol)
for i in range(num_of_observations):
if H_count[i] + len((undefined_current[i])) <= medic_num:
if i < num_of_observations - 1:
for row, col in undefined_current[i+1]:
new_H = '{}_{}_{}_H'.format(row, col, i+1)
data_q.append('~' + new_H)
new_H = sympy.symbols(new_H)
kb_symbols = sympy.And(kb_symbols, ~new_H)
if I_changes[i] == medic_num:
for row, col in undefined_current[i]:
new_I = '{}_{}_{}_I'.format(row, col, i)
data_q.append('~' + new_I)
new_I = sympy.symbols(new_I)
kb_symbols = sympy.And(kb_symbols, ~new_I)
return kb_symbols
def set_valve_resistances(self, p_v_l_, p_v_l_d_, p_v_r_, p_v_r_d_,
p_at_l_d_, p_at_r_d_, p_ar_sys_, p_ar_pul_):
if self.valvelaw == 'pwlin_pres':
R_vin_l_ = sp.Piecewise((self.R_vin_l_min, p_v_l_ < p_at_l_d_),
(self.R_vin_l_max, p_v_l_ >= p_at_l_d_))
R_vin_r_ = sp.Piecewise((self.R_vin_r_min, p_v_r_ < p_at_r_d_),
(self.R_vin_r_max, p_v_r_ >= p_at_r_d_))
R_vout_l_ = sp.Piecewise(
(self.R_vout_l_max, p_v_l_d_ < p_ar_sys_),
(self.R_vout_l_min, p_v_l_d_ >= p_ar_sys_))
R_vout_r_ = sp.Piecewise(
(self.R_vout_r_max, p_v_r_d_ < p_ar_pul_),
(self.R_vout_r_min, p_v_r_d_ >= p_ar_pul_))
elif self.valvelaw == 'pwlin_time':
R_vin_l_ = sp.Piecewise(
(self.R_vin_l_min,
sp.Or(self.t_ < self.t_ed, self.t_ >= self.t_es)),
(self.R_vin_l_max,
sp.And(self.t_ >= self.t_ed, self.t_ < self.t_es)))
R_vin_r_ = sp.Piecewise(
(self.R_vin_r_min,
sp.Or(self.t_ < self.t_ed, self.t_ >= self.t_es)),
(self.R_vin_r_max,
sp.And(self.t_ >= self.t_ed, self.t_ < self.t_es)))
R_vout_l_ = sp.Piecewise(
(self.R_vout_l_max,
sp.Or(self.t_ < self.t_ed, self.t_ >= self.t_es)),
(self.R_vout_l_min,
sp.And(self.t_ >= self.t_ed, self.t_ < self.t_es)))
R_vout_r_ = sp.Piecewise(
(self.R_vout_r_max,
sp.Or(self.t_ < self.t_ed, self.t_ >= self.t_es)),
(self.R_vout_r_min,
sp.And(self.t_ >= self.t_ed, self.t_ < self.t_es)))
elif self.valvelaw == 'smooth_pres':
R_vin_l_ = 0.5 * (self.R_vin_l_max - self.R_vin_l_min) * (sp.tanh(
(p_v_l_ - p_at_l_d_) / self.epsvalve) + 1.) + self.R_vin_l_min
R_vin_r_ = 0.5 * (self.R_vin_r_max - self.R_vin_r_min) * (sp.tanh(
(p_v_r_ - p_at_r_d_) / self.epsvalve) + 1.) + self.R_vin_r_min
R_vout_l_ = 0.5 * (self.R_vout_l_max -
self.R_vout_l_min) * (sp.tanh(
(p_ar_sys_ - p_v_l_d_) / self.epsvalve) +
1.) + self.R_vout_l_min
R_vout_r_ = 0.5 * (self.R_vout_r_max -
self.R_vout_r_min) * (sp.tanh(
(p_ar_pul_ - p_v_r_d_) / self.epsvalve) +
1.) + self.R_vout_r_min
else:
raise NameError("Unknown valve law!")
return R_vin_l_, R_vin_r_, R_vout_l_, R_vout_r_
def test_PiecewiseTPolyMassAction__sympy():
import sympy as sp
tp1 = TPoly([0, 10, 0.1])
tp2 = TPoly([273.15, 37.315, -0.1])
pwp = PiecewiseTPolyMassAction.from_polynomials([(0, 273.15),
(273.15, 373.15)],
[tp1, tp2])
T = sp.Symbol('T')
Reaction({'A': 2, 'B': 1}, {'C': 1}, pwp, {'B': 1})
res1 = pwp({'A': 11, 'B': 13, 'temperature': T}, backend=sp)
ref1 = 11**2 * 13 * sp.Piecewise(
(10 + 0.1 * T, sp.And(0 <= T, T <= 273.15)),
(37.315 - 0.1 * (T - 273.15), sp.And(273.15 <= T, T <= 373.15)))
assert res1 == ref1
def VOF(j: ps.field.Field, v: ps.field.Field, ρ: ps.field.Field):
"""Volume-of-fluid discretization of advection
Args:
j: the staggered field to write the fluxes to. Should have a D2Q9/D3Q27 stencil. Other stencils work too, but
incur a small error (D2Q5/D3Q7: v^2, D3Q19: v^3).
v: the flow velocity field
ρ: the quantity to advect
"""
assert ps.FieldType.is_staggered(j)
fluxes = [[] for i in range(j.index_shape[0])]
v0 = v.center_vector
for d, neighbor in enumerate(j.staggered_stencil):
c = ps.stencil.direction_string_to_offset(neighbor)
v1 = v.neighbor_vector(c)
# going out
cond = sp.And(
*[sp.Or(c[i] * v0[i] > 0, c[i] == 0) for i in range(len(v0))])
overlap1 = [1 - sp.Abs(v0[i]) for i in range(len(v0))]
overlap2 = [c[i] * v0[i] for i in range(len(v0))]
overlap = sp.Mul(*[(overlap1[i] if c[i] == 0 else overlap2[i])
for i in range(len(v0))])
fluxes[d].append(ρ.center_vector * overlap * sp.Piecewise((1, cond),
(0, True)))
# coming in
cond = sp.And(
*[sp.Or(c[i] * v1[i] < 0, c[i] == 0) for i in range(len(v1))])
overlap1 = [1 - sp.Abs(v1[i]) for i in range(len(v1))]
overlap2 = [v1[i] for i in range(len(v1))]
overlap = sp.Mul(*[(overlap1[i] if c[i] == 0 else overlap2[i])
for i in range(len(v1))])
sign = (c == 1).sum() % 2 * 2 - 1
fluxes[d].append(sign * ρ.neighbor_vector(c) * overlap * sp.Piecewise(
(1, cond), (0, True)))
for i, ff in enumerate(fluxes):
fluxes[i] = ff[0]
for f in ff[1:]:
fluxes[i] += f
assignments = []
for i, d in enumerate(j.staggered_stencil):
for lhs, rhs in zip(
j.staggered_vector_access(d).values(), fluxes[i].values()):
assignments.append(ps.Assignment(lhs, rhs))
return assignments
def test_PiecewiseTPolyMassAction__sympy():
import sympy as sp
tp1 = TPoly([10, 0.1])
tp2 = ShiftedTPoly([273.15, 37.315, -0.1])
pwp = MassAction(TPiecewise([0, tp1, 273.15, tp2, 373.15]))
T = sp.Symbol('T')
r = Reaction({'A': 2, 'B': 1}, {'C': 1}, inact_reac={'B': 1})
res1 = pwp({'A': 11, 'B': 13, 'temperature': T}, backend=sp, reaction=r)
ref1 = 11**2 * 13 * sp.Piecewise(
(10+0.1*T, sp.And(0 <= T, T <= 273.15)),
(37.315 - 0.1*(T-273.15), sp.And(273.15 <= T, T <= 373.15)),
(sp.Symbol('NAN'), True)
)
assert res1 == ref1
def expr_defined_by_limit(func, row_num, col_num, state, obsNum_finite, expr, row, col, NOT, SECOND=False, state2='A', NOT2=False, obsNum_finite2 = 0):
if row > 0:
c = '{}_{}_{}_{}'.format(row - 1, col, obsNum_finite, state)
c = sympy.symbols(c)
if NOT:
c = ~c
if SECOND:
c2 = '{}_{}_{}_{}'.format(row - 1, col, obsNum_finite2, state2)
c2 = sympy.symbols(c2)
if NOT2:
c2 = ~c2
c = sympy.And(c,c2)
expr = func(expr, c)
if row < row_num - 1:
c = '{}_{}_{}_{}'.format(row + 1, col, obsNum_finite, state)
c = sympy.symbols(c)
if NOT:
c = ~c
if SECOND:
c2 = '{}_{}_{}_{}'.format(row + 1, col, obsNum_finite2, state2)
c2 = sympy.symbols(c2)
if NOT2:
c2 = ~c2
c = sympy.And(c,c2)
expr = func(expr, c)
if col > 0:
c = '{}_{}_{}_{}'.format(row, col - 1, obsNum_finite, state)
c = sympy.symbols(c)
if NOT:
c = ~c
if SECOND:
c2 = '{}_{}_{}_{}'.format(row, col - 1, obsNum_finite2, state2)
c2 = sympy.symbols(c2)
if NOT2:
c2 = ~c2
c = sympy.And(c,c2)
expr = func(expr, c)
if col < col_num - 1:
c = '{}_{}_{}_{}'.format(row, col + 1, obsNum_finite, state)
c = sympy.symbols(c)
if NOT:
c = ~c
if SECOND:
c2 = '{}_{}_{}_{}'.format(row, col + 1, obsNum_finite2, state2)
c2 = sympy.symbols(c2)
if NOT2:
c2 = ~c2
c = sympy.And(c, c2)
expr = func(expr, c)
return expr
def valvelaw(self, p, popen, Rmin, Rmax, vparams, topen, tclose):
if vparams[
0] == 'pwlin_pres': # piecewise linear with resistance depending on pressure difference
R = sp.Piecewise((Rmax, p < popen), (Rmin, p >= popen))
vl = (popen - p) / R
elif vparams[
0] == 'pwlin_time': # piecewise linear with resistance depending on timing
if topen > tclose:
R = sp.Piecewise(
(Rmax, sp.And(self.t_ < topen, self.t_ >= tclose)),
(Rmin, sp.Or(self.t_ >= topen, self.t_ < tclose)))
else:
R = sp.Piecewise(
(Rmax, sp.Or(self.t_ < topen, self.t_ >= tclose)),
(Rmin, sp.And(self.t_ >= topen, self.t_ < tclose)))
vl = (popen - p) / R
elif vparams[0] == 'smooth_pres_resistance': # smooth resistance value
R = 0.5 * (Rmax - Rmin) * (sp.tanh(
(popen - p) / vparams[-1]) + 1.) + Rmin
vl = (popen - p) / R
elif vparams[0] == 'smooth_pres_momentum': # smooth q(p) relationship
# interpolation by cubic spline in epsilon interval
p0 = (popen - vparams[-1] / 2. - popen) / Rmax
p1 = (popen + vparams[-1] / 2. - popen) / Rmin
m0 = 1. / Rmax
m1 = 1. / Rmin
s = (p - (popen - vparams[-1] / 2.)) / vparams[-1]
# spline ansatz functions
h00 = 2. * s**3. - 3 * s**2. + 1.
h01 = -2. * s**3. + 3 * s**2.
h10 = s**3. - 2. * s**2. + s
h11 = s**3. - s**2.
# spline
c = h00 * p0 + h10 * m0 * vparams[
-1] + h01 * p1 + h11 * m1 * vparams[-1]
vl = sp.Piecewise(
((popen - p) / Rmax, p < popen - vparams[-1] / 2),
(-c,
sp.And(p >= popen - vparams[-1] / 2.,
p < popen + vparams[-1] / 2.)),
((popen - p) / Rmin, p >= popen + vparams[-1] / 2.))
elif vparams[0] == 'pw_pres_regurg':
vl = sp.Piecewise(
(vparams[1] * vparams[2] * sp.sqrt(popen - p), p < popen),
((popen - p) / Rmin, p >= popen))
else:
raise NameError("Unknown valve law %s!" % (vparams[0]))
return vl, 1. / sp.diff(vl, popen)
def test_create_Piecewise__nan_fallback__sympy():
import sympy as sp
TPw = create_Piecewise("Tmpr", nan_fallback=True)
pw = TPw([0, 42, 10, 43, 20])
x = sp.Symbol("x")
res = pw({"Tmpr": x}, backend=sp)
assert isinstance(res, sp.Piecewise)
assert res.args[0][0] == 42
assert res.args[0][1] == sp.And(0 <= x, x <= 10)
assert res.args[1][0] == 43
assert res.args[1][1] == sp.And(10 <= x, x <= 20)
assert res.args[2][0].name.lower() == "nan"
assert res.args[2][1] == True # noqa
def _encode_leaf_to_z(self, leaves, inputs, attributions):
"""Each leaf entails one and only one feature usage mask."""
n_inputs = inputs.shape[0]
formulas = []
for leaf in leaves:
relevant = {i for i, _ in leaf.conds}
cond = sympy.And(*[inputs[i, value] for i, value in leaf.conds])
mask = sympy.And(*[
attributions[i, 1 if i in relevant else 0]
for i in range(n_inputs)
])
formulas.append(cond & mask)
return to_cnf(sympy.Or(*formulas))
def quadratic_denom_rule(integral):
integrand, symbol = integral
a = sympy.Wild('a', exclude=[symbol])
b = sympy.Wild('b', exclude=[symbol])
c = sympy.Wild('c', exclude=[symbol])
match = integrand.match(a / (b * symbol ** 2 + c))
if not match:
return
a, b, c = match[a], match[b], match[c]
return PiecewiseRule([(ArctanRule(a, b, c, integrand, symbol), sympy.Gt(c / b, 0)),
(ArccothRule(a, b, c, integrand, symbol), sympy.And(sympy.Gt(symbol ** 2, -c / b), sympy.Lt(c / b, 0))),
(ArctanhRule(a, b, c, integrand, symbol), sympy.And(sympy.Lt(symbol ** 2, -c / b), sympy.Lt(c / b, 0))),
], integrand, symbol)
def test_create_Piecewise_Poly__sympy():
import sympy as sp
Poly = create_Poly('Tmpr')
p1 = Poly([1, 0.1])
p2 = Poly([3, -.1])
TPw = create_Piecewise('Tmpr')
pw = TPw([0, p1, 10, p2, 20])
x = sp.Symbol('x')
res = pw({'Tmpr': x}, backend=sp)
assert isinstance(res, sp.Piecewise)
assert res.args[0][0] == 1 + 0.1 * x
assert res.args[0][1] == sp.And(0 <= x, x <= 10)
assert res.args[1][0] == 3 - 0.1 * x
assert res.args[1][1] == sp.And(10 <= x, x <= 20)
def test_PiecewiseTPolyMassAction__sympy():
import sympy as sp
tp1 = TPoly([10, 0.1])
tp2 = ShiftedTPoly([273.15, 37.315, -0.1])
pwp = MassAction(TPiecewise([0, tp1, 273.15, tp2, 373.15]))
T = sp.Symbol("T")
r = Reaction({"A": 2, "B": 1}, {"C": 1}, inact_reac={"B": 1})
res1 = pwp({"A": 11, "B": 13, "temperature": T}, backend=sp, reaction=r)
ref1 = (11**2 * 13 * sp.Piecewise(
(10 + 0.1 * T, sp.And(0 <= T, T <= 273.15)),
(37.315 - 0.1 * (T - 273.15), sp.And(273.15 <= T, T <= 373.15)),
(sp.Symbol("NAN"), True),
))
assert res1 == ref1
def is_H(undefined_state, row_num, col_num, police_num, medic_num, num_of_observations):
row, col, obsNum = undefined_state.split(sep='_')
row, col, obsNum = int(row), int(col), int(obsNum)
if obsNum == 0:
expr = '{}_{}_{}_H'.format(row, col, obsNum + 1)
expr = sympy.symbols(expr)
if medic_num > 0:
temp = '{}_{}_{}_I'.format(row, col, obsNum + 1)
temp = sympy.symbols(temp)
expr = sympy.Or(expr, temp)
return expr
else:
expr1, expr2, expr3, expr4, expr5 = 0, 0, 0, 0, 0
if obsNum >= 3:
expr1 = '{}_{}_{}_S'.format(row, col, obsNum - 3)
expr1 = sympy.symbols(expr1)
temp = '{}_{}_{}_S'.format(row, col, obsNum - 2)
temp = sympy.symbols(temp)
expr1 = sympy.And(expr1, temp)
temp1 = '{}_{}_{}_S'.format(row, col, obsNum - 1)
temp1 = sympy.symbols(temp1)
expr1 = sympy.And(expr1, temp1)
if medic_num > 0 and obsNum + 1 < num_of_observations:
expr2 = '{}_{}_{}_I'.format(row, col, obsNum + 1)
expr2 = sympy.symbols(expr2)
temp = '{}_{}_{}_S'.format(row, col, obsNum - 1)
temp = sympy.symbols(temp)
if police_num > 0:
temp1 = '{}_{}_{}_Q'.format(row, col, obsNum - 1)
temp1 = sympy.symbols(temp1)
temp = sympy.Or(temp, temp1)
expr2 = sympy.And(expr2, temp)
if medic_num == 0:
expr3 = '{}_{}_{}_H'.format(row, col, obsNum - 1)
expr3 = sympy.symbols(expr3)
expr3 = expr_defined_by_limit(sympy.And, row_num, col_num, 'S', obsNum - 1, expr3, row, col, True)
if police_num > 0:
if obsNum > 2:
expr4 = '{}_{}_{}_Q'.format(row, col, obsNum - 1)
expr4 = sympy.symbols(expr4)
temp = '{}_{}_{}_Q'.format(row, col, obsNum - 2)
temp = sympy.symbols(temp)
expr4 = sympy.And(expr4, temp)
expr5 = '{}_{}_{}_Q'.format(row, col, obsNum - 3)
expr5 = sympy.symbols(expr5)
expr5 = sympy.And(~expr5, temp)
expr = sympy.Or(expr5, expr4, expr3, expr2, expr1)
return expr
def guard(clusters):
"""
Split Clusters containing conditional expressions into separate Clusters.
"""
processed = []
for c in clusters:
# Group together consecutive expressions with same ConditionalDimensions
for cds, g in groupby(c.exprs, key=lambda e: e.conditionals):
if not cds:
processed.append(c.rebuild(exprs=list(g)))
continue
# Create a guarded Cluster
guards = {}
for cd in cds:
condition = guards.setdefault(cd.parent, [])
if cd.condition is None:
condition.append(CondEq(cd.parent % cd.factor, 0))
else:
condition.append(cd.condition)
guards = {
k: sympy.And(*v, evaluate=False)
for k, v in guards.items()
}
processed.append(c.rebuild(exprs=list(g), guards=guards))
return processed
def guard(clusters):
"""
Split Clusters containing conditional expressions into separate Clusters.
"""
processed = []
for c in clusters:
# Group together consecutive expressions with same ConditionalDimensions
for cds, g in groupby(c.exprs, key=lambda e: tuple(e.conditionals)):
exprs = list(g)
if not cds:
processed.append(c.rebuild(exprs=exprs))
continue
# Chain together all conditions from all expressions in `c`
guards = {}
for cd in cds:
condition = guards.setdefault(cd.parent, [])
for e in exprs:
try:
condition.append(e.conditionals[cd])
break
except KeyError:
pass
guards = {
d: sympy.And(*v, evaluate=False)
for d, v in guards.items()
}
# Construct a guarded Cluster
processed.append(c.rebuild(exprs=exprs, guards=guards))
return ClusterGroup(processed)
def border_conditions(direction, field, ghost_layers=1):
abs_direction = tuple(-e if e < 0 else e for e in direction)
assert sum(abs_direction) == 1
idx = abs_direction.index(1)
val = direction[idx]
loop_ctrs = [
LoopOverCoordinate.get_loop_counter_symbol(i)
for i in range(len(direction))
]
loop_ctr = loop_ctrs[idx]
gl = ghost_layers
border_condition = sp.Eq(loop_ctr,
gl if val < 0 else field.shape[idx] - gl - 1)
if ghost_layers == 0:
return type_all_numbers(border_condition, loop_ctr.dtype)
else:
other_min = [sp.Ge(c, gl) for c in loop_ctrs if c != loop_ctr]
other_max = [
sp.Lt(c, field.shape[i] - gl) for i, c in enumerate(loop_ctrs)
if c != loop_ctr
]
result = sp.And(border_condition, *other_min, *other_max)
return type_all_numbers(result, loop_ctr.dtype)
def test_nested_relational(self):
expr = Expression(
sympy.And(
sympy.Or(sympy.Eq(self.a, self.b), sympy.Eq(self.c, self.d)),
sympy.Or(sympy.Eq(self.e, self.f), sympy.Lt(self.g, self.f))))
self.assertEqual(expr.rhs_cstr,
'(a == b || c == d) && (e == f || g < f)')
