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