def _HEXP_(node, S1, S2):
f = node.children[0].f_expression
errList1 = [node.f_expression] + \
[seng.expand(Si*node.f_expression) for Si in S1]
errList2 = [seng.expand(Si * node.f_expression) for Si in S2]
ferr = sum([seng.Abs(Si * pow(2, -53))
for Si in S1 + S2]) + node.f_expression
herr = sum([
seng.Abs(Si * Sj * seng.exp(ferr)) for Si in S1 + S2 for Sj in S1 + S2
])
return _solve_(node, errList1, errList2, herr)
def run_benchmark(n):
a0 = symbols("a0")
a1 = symbols("a1")
e = a0 + a1
f = 0;
for i in range(2, n):
s = symbols("a%s" % i)
e = e + sin(s)
f = f + sin(s)
f = -f
t1 = clock()
e = expand(e**2)
e = e.xreplace({a0: f})
e = expand(e)
t2 = clock()
print("%s ms" % (1000 * (t2 - t1)))
def _HMUL_(node, S1, S2, T1, T2):
f = node.children[0].f_expression
g = node.children[1].f_expression
errList1 = [node.f_expression] + \
[seng.expand( g * Si) for Si in S1] + \
[seng.expand( f * Tj) for Tj in T1]
errList2 = [seng.expand( g * Si) for Si in S2] + \
[seng.expand( f * Tj) for Tj in T2]
herr = sum(
[seng.Abs(seng.expand(Si * Tj)) for Si in S1 + S2 for Tj in T1 + T2])
return _solve_(node, errList1, errList2, herr)
def _HDIV_(node, S1, S2, T1, T2):
[TerrList1, TerrList2] = _HINV_(node.children[1], T1, T2)
f = node.children[0].f_expression
g = (1 / node.children[1].f_expression)
errList1 = [node.f_expression] + \
[seng.expand(f * Ti) for Ti in TerrList1] + \
[seng.expand(g * Si) for Si in S1]
errList2 = [seng.expand(f * Ti) for Ti in TerrList2] + \
[seng.expand(g * Si) for Si in S2]
herr = sum(
[seng.Abs(Si * Tj) for Si in S1 + S2 for Tj in TerrList1 + TerrList2])
return _solve_(node, errList1, errList2, herr)
def run_benchmark(n):
a0 = symbols("a0")
a1 = symbols("a1")
e = a0 + a1
f = 0
for i in range(2, n):
s = symbols("a%s" % i)
e = e + sin(s)
f = f + sin(s)
f = -f
t1 = clock()
e = expand(e**2)
e = e.xreplace({a0: f})
e = expand(e)
t2 = clock()
print("%s ms" % (1000 * (t2 - t1)))
def run_benchmark(n):
x, y = symbols("x y")
e = (1 + sqrt(3) * x + sqrt(5) * y)**n
f = e * (e + sqrt(7))
t1 = clock()
f = expand(f)
t2 = clock()
print("%s ms" % (1000 * (t2 - t1)))
def run_benchmark(n):
x, y = symbols("x y")
e = (1 + sqrt(3) * x + sqrt(5) * y) ** n
f = e * (e + sqrt(7))
t1 = clock()
f = expand(f)
t2 = clock()
print("%s ms" % (1000 * (t2 - t1)))
def propagate_symbolic(self, node):
for outVar in self.bwdDeriv[node].keys():
expr_solve = (((\
(self.bwdDeriv[node][outVar]))*\
(node.get_noise(node))*(max(node.get_rounding(),outVar.get_rounding()) if node.rnd!=0.0 else node.get_rounding() ))\
).__abs__()
if seng.count_ops(self.Accumulator[outVar]) > 4000:
self.QworkList[outVar].append(self.Accumulator[outVar])
self.Accumulator[outVar] = seng.expand(expr_solve)
elif seng.count_ops(expr_solve) > 1000:
self.QworkList[outVar].append(expr_solve)
else:
self.Accumulator[outVar] += seng.expand(expr_solve)
if len(self.QworkList[outVar]) >= self.Qthreshold:
self.Accumulator[outVar] += utils.error_query_reduction(
self.QworkList[outVar])
self.QworkList[outVar].clear()
def __init__(self, expr: Union[str, int, "Polynomial"] = 0) -> None:
"""Construct a polynomial."""
if isinstance(expr, str):
p = symengine.sympify(expr.lstrip("+")) # symengine/symengine.py#331
self._raw = symengine.expand(p)
elif isinstance(expr, int):
self._raw = symengine.sympify(expr)
elif isinstance(expr, Polynomial):
self._raw = expr._raw
else:
raise ValueError(f"unexpected expr: {expr}")
def propagate_symbolic(self, node):
#print("@node depth = ", node.depth, type(node).__name__, node.f_expression)
#print([n.f_expression for n in node.parents])
#print(node.parents)
#print(self.parent_dict[node])
#print("--------------------------------------")
#print("Rounding: node-expr:", node.f_expression)
#print("Rounding:", node.get_rounding())
for outVar in self.bwdDeriv[node].keys():
expr_solve = (((\
(self.bwdDeriv[node][outVar]))*\
(node.get_noise(node))*(max(node.get_rounding(),outVar.get_rounding()) if node.rnd!=0.0 else node.get_rounding() ))\
).__abs__()
if seng.count_ops(self.Accumulator[outVar]) > 4000:
intv = max(utils.generate_signature(self.Accumulator[outVar]))
self.Accumulator[outVar] = seng.expand(expr_solve)
expr_solve = intv
elif seng.count_ops( expr_solve ) > 1000:
expr_solve = max(utils.generate_signature(expr_solve))
self.Accumulator[outVar] += seng.expand(expr_solve)
def simplify(lexpr):
#if not Globals.simplify or (seng.count_ops(lexpr) > 30000):
# return lexpr
#else:
# lexpr2 = seng.expand(lexpr)
# op1 = seng.count_ops(lexpr)
# op2 = seng.count_ops(lexpr2)
# if (op2 - op1 > 1000):
# Globals.simplify = False
# return lexpr2 if(seng.count_ops(lexpr2) < seng.count_ops(lexpr)) else lexpr
##else:
## lexpr2 = seng.expand(lexpr)
if (seng.count_ops(lexpr) > 30000):
return lexpr
else:
return seng.expand(lexpr)
return lexpr
def get_noise(obj):
return (seng.expand(
obj.f_expression)) if obj.f_expression is not None else 0
def minimize_expr(expr,
angle_folds,
amplitude_folds,
sampler,
max_cycles=5,
num_samples=1000,
strength=1e3,
verbose=False):
#get lists of continuous and discrete variables
try:
all_vars = list(expr.free_symbols)
except AttributeError:
return expr
disc_vars, cont_vars = sort_mixed_vars(all_vars)
cont_bounds = get_bounds(cont_vars,
angle_folds=angle_folds,
amplitude_folds=amplitude_folds)
disc_vals = np.random.choice([-1, 1], size=len(disc_vars))
cont_vals = np.random.uniform(low=cont_bounds.transpose()[0],
high=cont_bounds.transpose()[1],
size=len(cont_vars))
all_disc_vals, all_cont_vals = [], []
#minimize expression
min_energies, cycle = [], 0
for cycle in range(max_cycles):
#minimize continuous variables for fixed discrete variables
cont_expr = expr
for i in range(len(disc_vars)):
cont_expr = cont_expr.subs(disc_vars[i], disc_vals[i])
f = se.lambdify(cont_vars, (cont_expr, ))
def g(x):
return f(*x)
results = sci.optimize.minimize(g,
cont_vals,
method='L-BFGS-B',
bounds=cont_bounds)
cont_vals = results.x
#minimize discrete variables for fixed continuous variables
disc_expr = expr
for i in range(len(cont_vars)):
disc_expr = disc_expr.subs(cont_vars[i], cont_vals[i])
disc_expr = se.expand(disc_expr)
bqm = dimod.higherorder.utils.make_quadratic(expr_to_dict(disc_expr),
strength, dimod.SPIN)
qubo, constant = bqm.to_qubo()
#run sampler
response = sampler.sample_qubo(qubo, num_reads=num_samples)
solutions = pd.DataFrame(response.data())
minIndex = int(solutions[['energy']].idxmin())
minEnergy = round(solutions['energy'][minIndex], 12) + constant
unredSolution = solutions['sample'][minIndex]
for key in unredSolution:
try:
index = disc_vars.index(key)
except ValueError:
continue
disc_vals[index] = 2 * unredSolution[key] - 1
min_energies += [minEnergy]
all_disc_vals += [disc_vals]
all_cont_vals += [cont_vals]
if verbose:
print('Cycle:', cycle + 1, 'Energy:', minEnergy)
min_energy = min(min_energies)
index = min_energies.index(min_energy)
cont_dict = dict(zip(cont_vars, all_cont_vals[index]))
disc_dict = dict(zip(disc_vars, all_disc_vals[index]))
return min_energy, cont_dict, disc_dict
def __mul__(self, other: "Polynomial") -> "Polynomial":
"""Return ``self * other``."""
result = super().__new__(Polynomial)
result._raw = symengine.expand(self._raw * other._raw)
return result # type: ignore
def __neg__(self) -> "Polynomial":
"""Return ``- self``."""
result = super().__new__(Polynomial)
result._raw = symengine.expand(-self._raw)
return result # type: ignore
