def params(self, parameters): self._params = [] for single_param in parameters: # example: u2(pi/2, sin(pi/4)) if isinstance(single_param, (Parameter, sympy.Basic)): self._params.append(single_param) # example: OpenQASM parsed instruction elif isinstance(single_param, node.Node): self._params.append(single_param.sym()) # example: u3(0.1, 0.2, 0.3) elif isinstance(single_param, (int, float)): self._params.append(sympy.Number(single_param)) # example: Initialize([complex(0,1), complex(0,0)]) elif isinstance(single_param, complex): self._params.append(single_param.real + single_param.imag * sympy.I) # example: snapshot('label') elif isinstance(single_param, str): self._params.append(sympy.Symbol(single_param)) # example: numpy.array([[1, 0], [0, 1]]) elif isinstance(single_param, numpy.ndarray): self._params.append(single_param) # example: sympy.Matrix([[1, 0], [0, 1]]) elif isinstance(single_param, sympy.Matrix): self._params.append(single_param) elif isinstance(single_param, sympy.Expr): self._params.append(single_param) elif isinstance(single_param, numpy.number): self._params.append(sympy.Number(single_param.item())) else: raise QiskitError("invalid param type {0} in instruction " "{1}".format(type(single_param), self.name))
def __init__(self, *expr_factor_tuples): self.graded_dict = {} # create a copy of graded_dict # removing duplicate tuples of factors in the values for expr_factors in expr_factor_tuples: # each element of the sequence should have the form # (sympy, [factors]) or sympy or (sympy, factor) try: expr, factors = tuple(expr_factors) except TypeError: # not a sequence expr, factors = expr_factors, () if is_factor(factors): factors = [factors] factors = tuple(factors) self.graded_dict.setdefault(expr, {}).setdefault(len(factors), []).append(factors) # aliases for the intercept for s in ANCOVA.aliases_for_intercept: if s in self.graded_dict: for k in self.graded_dict[s].keys(): self.graded_dict.setdefault(sympy.Number(1), {}).setdefault(k, []).extend(self.graded_dict[s][k]) del(self.graded_dict[s]) if ANCOVA.add_intercept: self.graded_dict.setdefault(sympy.Number(1), {})[0] = [[]] if ANCOVA.add_main_effects: for expr in self.graded_dict: self.graded_dict[expr][0] = [[]]
def test_optimize_1q_gates_sympy_expressions(self): """optimizes single qubit gate sequences with sympy expressions. See: https://github.com/Qiskit/qiskit-terra/issues/172 """ qr = QuantumRegister(4) cr = ClassicalRegister(4) circ = QuantumCircuit(qr, cr) # unary circ.u1(-sympy.pi, qr[0]) circ.u1(-sympy.pi / 2, qr[0]) # binary circ.u1(0.2 * sympy.pi + 0.3 * sympy.pi, qr[1]) circ.u1(1.3 - 0.3, qr[1]) circ.u1(0.1 * sympy.pi / 2, qr[1]) # extern circ.u1(sympy.sin(0.2 + 0.3 - sympy.pi), qr[2]) # power circ.u1(sympy.pi, qr[3]) circ.u1(0.3 + (-sympy.pi) ** 2, qr[3]) dag = circuit_to_dag(circ) simplified_dag = Optimize1qGates().run(dag) params = set() for node in simplified_dag.named_nodes('u1'): params.add(node.op.params[0]) expected_params = {sympy.Number(-3 * np.pi / 2), sympy.Number(1.0 + 0.55 * np.pi), sympy.Number(-0.479425538604203), sympy.Number(0.3 + np.pi + np.pi ** 2)} self.assertEqual(params, expected_params)
def symbolic_size(self): try: return sympy.Number(self.modulo) except (TypeError, ValueError): pass try: return sympy.Number(self.incr) except (TypeError, ValueError): return self.incr
def _getterms(self): t = self._terms # The Rmode flag is meant to emulate R's implicit addition of an # intercept to every formula. It currently cannot be changed. Rmode = False if Rmode: if sympy.Number(1) not in self._terms: t = np.array(list(t) + [sympy.Number(1)]) return t
def __init__(self, *expr_factor_tuples, **keywords): # set intercept / main_effect behaviour add_main_effects = False if "add_main_effects" in keywords: add_main_effects = keywords['add_main_effects'] add_intercept = True if "add_intercept" in keywords: add_intercept = keywords['add_intercept'] self.default_contrast = 'drop_reference' if "default_contrast" in keywords: self.default_contrast = keywords['default_contrast'] self.graded_dict = {} # create a copy of graded_dict # removing duplicate tuples of factors in the values for expr_factors in expr_factor_tuples: # each element of the sequence should have the form # (sympy, [factors]) or sympy or (sympy, factor) if is_factor(expr_factors): expr_factors = (1, expr_factors) try: expr, factors = tuple(expr_factors) except TypeError: # not a sequence expr, factors = expr_factors, () if is_factor(factors): factors = [factors] factors = tuple(factors) l = self.graded_dict.setdefault(sympy.sympify(expr), {}).setdefault(len(factors), []) # ensure uniqueness if factors not in l: l.append(factors) # aliases for the intercept aliases_for_intercept = [1, 'constant', '(Intercept)'] for s in aliases_for_intercept: if s in self.graded_dict: for k in self.graded_dict[s].keys(): self.graded_dict.setdefault(sympy.Number(1), {}).setdefault(k, []).extend( self.graded_dict[s][k]) del (self.graded_dict[s]) if add_intercept: self.graded_dict.setdefault(sympy.Number(1), {})[0] = [()] if add_main_effects: for expr in self.graded_dict: self.graded_dict[expr][0] = [()]
def test_constants(): dort("PI * PI / 10", sympy.pi * sympy.pi / 10) dort("PI*PI/10", sympy.pi*sympy.pi/10) dort("PI^2", sympy.pi**2) dort("e / 3", sympy.E / 3) doit('0.0', 0) doit('.0', 0) doit('01', 1) doit('00', 0) doit('0.1', sympy.Number(1) / sympy.Number(10))
def is_division(function): """ check if function is g(x)/h(x) """ if function.func == sp.Mul: if function.args[0].func == sp.Pow: if function.args[0].args[1] == sp.Number(-1): return True if function.args[1].func == sp.Pow: if function.args[1].args[1] == sp.Number(-1): return True return False
def is_division(function): """ Проверяем, что наша функция - это дробь g(x)/h(x) """ if function.func == sp.Mul: if function.args[0].func == sp.Pow: if function.args[0].args[1] == sp.Number(-1): return True if function.args[1].func == sp.Pow: if function.args[1].args[1] == sp.Number(-1): return True return False
class SympyRing(CommutativeRing): """ The sympy ring. """ AI = sympy.Number(0) MI = sympy.Number(1) @classmethod def sum(cls, a, b): a = cls.validate(a) b = cls.validate(b) return sympy.Add(a, b) @classmethod def product(cls, a, b): a = cls.validate(a) b = cls.validate(b) return sympy.Mul(a, b) @staticmethod def validate(a): return sympy.sympify(a) @classmethod def inverse(cls, a): a = cls.validate(a) return sympy.Mul(-1, a) @classmethod def generic(cls, monomial=False): """ Return a generic polynomial in sympy variables. If cls.monomial_generic is True, then return a monomial. """ def _monomial(): s = sympy.Number(1) for v in sample(lowercase, random_integers(0, 3)): s *= sympy.Symbol(v)**random_integers(1, 3) return s if monomial: return _monomial() else: s = 1 for _ in range(random_integers(0, 4)): s += _monomial() return s
def debase(x, b=10): """Converts a number from a base to decimal.""" b = int(round(float(b))) i = str(x).lower() try: i = str(sympy.Number(i).evalf(BF_PREC)) except: pass print(i) try: ind = i.index(".") f = i[ind + 1:] i = i[:ind] except ValueError: f = "" temp = str(int(i, b)) + "." fp = sympy.Rational(0) m = 1 while f: m *= b fp += sympy.Rational(int(f[0], b)) / m f = f[1:] s = temp + str(fp.evalf(BF_PREC)).replace("0.", "") print(s) return rounder(sympy.Rational(s))
def is_elementary(function): """ Проверяем, что наша функция элементарная: exp(x), cos(x), ... или sqrt(x) """ return len( function.args) == 1 or (function.func == sp.Pow and function.args[1] == sp.Number('1/2'))
def floatify_numbers(e): if not len(e.args): if e.is_number: return sympy.Number(float(e)) return e newargs = tuple(floatify_numbers(a) for a in e.args) return e.new(*newargs)
def test_Rintercept(): x = F.Term('x') y = F.Term('x') xf = x.formula yf = y.formula newf = (xf + F.I) * (yf + F.I) assert_equal(set(newf.terms), set([x, y, x * y, sympy.Number(1)]))
def __init__( self, name=None, unit=None, value=None, expression=None, valueKnown=False, equals=None, nonnegative=True, ): if isinstance(name, str): # e.g. SymDim('a') self.name = name self.symbol = Symbol(self.name, nonnegative=nonnegative, parent=self) else: # e.g. SymDim(4) or SymDim(expression=a*b) self.name = '\mathrm{unnamed\,expr.}' try: self.symbol = sympy.Number(name) self.unit = u.dimensionless_unscaled except: self.symbol = None if isinstance(name, int) or isinstance(name, float): value = name unit = u.dimensionless_unscaled self.set_expression(expression) self.set_unit(unit, value) self.set_value(value, valueKnown) if equals is not None: self.equals(equals)
def symbolic_max(self): # Make sure we return a symbolic object as the provided max might # be for example a pure int try: return sympy.Number(self._max) except (TypeError, ValueError): return self._max
def __init__(self, name, param, qargs, cargs, circuit=None): """Create a new instruction. Args: name (str): instruction name param (list[sympy.Number or complex]): list of parameters qargs (list[(QuantumRegister, index)]): list of quantum args cargs (list[(ClassicalRegister, index)]): list of classical args circuit(QuantumCircuit or Instruction): where the instruction is attached Raises: QISKitError: when the register is not in the correct format. """ if not all( (type(i[0]), type(i[1])) == (QuantumRegister, int) for i in qargs): raise QISKitError("qarg not (QuantumRegister, int) tuple") if not all((type(i[0]), type(i[1])) == (ClassicalRegister, int) for i in cargs): raise QISKitError("carg not (ClassicalRegister, int) tuple") self.name = name self.param = [] for single_param in param: if not isinstance(single_param, (sympy.Basic, complex)): # If the item in param is not symbolic or complex (used # by InitializeGate), make it symbolic. self.param.append(sympy.Number(single_param)) else: self.param.append(single_param) self.qargs = qargs self.cargs = cargs self.control = None # tuple (ClassicalRegister, int) for "if" self.circuit = circuit
def __init__(self,name = None): super(Frame,self).__init__() self.connections_R = {} self.precomputed_R = {} self.connections_w = {} self.precomputed_w = {} self.reps = {} self.R_tree = TreeNode(self) self.w_tree = TreeNode(self) name = name or self.generate_name() self.name = name self.x = Vector() self.y = Vector() self.z = Vector() self.x_sym = sympy.Symbol(name+'.x') self.y_sym = sympy.Symbol(name+'.y') self.z_sym = sympy.Symbol(name+'.z') self.syms = sympy.Matrix([self.x_sym,self.y_sym,self.z_sym]) self.x.add_component(self,[1,0,0]) self.y.add_component(self,[0,1,0]) self.z.add_component(self,[0,0,1]) r = Rotation(self,self,sympy.Matrix.eye(3)) w = RotationalVelocity(self,self,sympy.Number(0)*self.x) self.add_rotation(r) self.add_w(w) pynamics.addself(self,name)
def convert_atom(atom): if atom.LETTER(): subscriptName = '' if atom.subexpr(): subscript = None if atom.subexpr().expr(): # subscript is expr subscript = convert_expr(atom.subexpr().expr()) else: # subscript is atom subscript = convert_atom(atom.subexpr().atom()) subscriptName = '_{' + StrPrinter().doprint(subscript) + '}' return sympy.Symbol(atom.LETTER().getText() + subscriptName) elif atom.SYMBOL(): s = atom.SYMBOL().getText()[1:] if s == "infty": return sympy.oo else: if atom.subexpr(): subscript = None if atom.subexpr().expr(): # subscript is expr subscript = convert_expr(atom.subexpr().expr()) else: # subscript is atom subscript = convert_atom(atom.subexpr().atom()) subscriptName = StrPrinter().doprint(subscript) s += '_{' + subscriptName + '}' return sympy.Symbol(s) elif atom.NUMBER(): s = atom.NUMBER().getText().replace(",", "") return sympy.Number(s) elif atom.DIFFERENTIAL(): var = get_differential_var(atom.DIFFERENTIAL()) return sympy.Symbol('d' + var.name) elif atom.mathit(): text = rule2text(atom.mathit().mathit_text()) return sympy.Symbol(text)
def is_elementary(function): """ check if function is exp(x), cos(x), ... or sqrt(x) """ return len( function.args) == 1 or (function.func == sp.Pow and function.args[1] == sp.Number('1/2'))
def frequencyVectors(graph): gamma = sympy.Symbol("y") sSize = graph.number_of_nodes() freqVector = [[] for i in range(sSize)] gammaAll = [gamma**i for i in range(sSize)] cycleDenominatorAll = [1 / (1 - gamma**i) for i in range(1, sSize + 1)] for currentNode in graph: localNodesVisited = [currentNode] localFreqVector = np.array([sympy.Number(0) for i in range(sSize)]) localFreqVector[currentNode] = sympy.Number(1) depth = 0 frequencyVectorsRecursionHelper(depth, localNodesVisited, localFreqVector, currentNode, gammaAll, cycleDenominatorAll, graph, freqVector) return freqVector
def wrapper(coord): coord = list(coord) for i, dim in enumerate(coord): if isinstance(dim, str): coord[i] = sympy.sympify(dim) #return tuple(sympy.sympify(str(x)) for x in results) elif isinstance(dim, int): coord[i] = sympy.Number(dim) return func(coord)
def symbolic_min(self): if self.modulo is not None: return self.offset % self.modulo # Make sure we return a symbolic object as this point `offset` may well # be a pure Python number try: return sympy.Number(self.offset) except (TypeError, ValueError): return self.offset
def symbolic_size(self): try: return sympy.Number(self._symbolic_size) except (TypeError, ValueError): pass if self._symbolic_size is None: return super().symbolic_size else: return self._symbolic_size
def params(self, parameters): self._params = [] for single_param in parameters: # example: u2(pi/2, sin(pi/4)) if isinstance(single_param, (ParameterExpression, sympy.Basic)): self._params.append(single_param) # example: OpenQASM parsed instruction elif isinstance(single_param, node.Node): warnings.warn( 'Using qasm ast node as a circuit.Instruction ' 'parameter is deprecated as of the 0.10.0, and ' 'will be removed no earlier than 3 months after ' 'that release date. You should convert the qasm ' 'node to a supported type int, float, complex, ' 'str, circuit.ParameterExpression, or ndarray ' 'before setting Instruction.parameters', DeprecationWarning, stacklevel=3) self._params.append(single_param.sym()) # example: u3(0.1, 0.2, 0.3) elif isinstance(single_param, (int, float)): self._params.append(sympy.Number(single_param)) # example: Initialize([complex(0,1), complex(0,0)]) elif isinstance(single_param, complex): self._params.append(single_param.real + single_param.imag * sympy.I) # example: snapshot('label') elif isinstance(single_param, str): self._params.append(sympy.Symbol(single_param)) # example: numpy.array([[1, 0], [0, 1]]) elif isinstance(single_param, numpy.ndarray): self._params.append(single_param) # example: sympy.Matrix([[1, 0], [0, 1]]) elif isinstance(single_param, sympy.Matrix): self._params.append(single_param) elif isinstance(single_param, sympy.Expr): self._params.append(single_param) elif isinstance(single_param, numpy.number): self._params.append(sympy.Number(single_param.item())) else: raise QiskitError("invalid param type {0} in instruction " "{1}".format(type(single_param), self.name))
def symbolic_min(self): if self._min is not None: # Make sure we return a symbolic object as the provided min might # be for example a pure int try: return sympy.Number(self._min) except (TypeError, ValueError): return self._min else: return self.parent.symbolic_min
def convert_number(x): x = x.lower() if x.endswith('i'): return sympy.I * convert_number(x[:-1]) if '.' in x and 'e' not in x: i, p = x.split('.') k = len(p) if k < 30: # Maybe increase this limit return sympy.Rational(int(i or '0') * 10**k + int(p or '0'), 10**k) return sympy.Number(x.lstrip('0') or '0')
def dot(self, other, frame='mid'): from pynamics.dyadic import Dyad, Dyadic result = sympy.Number(0) if isinstance(other, Dyad) or isinstance(other, Dyadic): return other.rdot(self) return self.product_simplest(other, result, 'dot', self.frame_dot, frame=frame)
def total_var_coeff(expr, var): q = sympy.Wild('q') total = sympy.Number(0) terms, _, _ = sympy.Add.flatten([expr]) for t in terms: m = t.match(q * var) if m and m[q].is_Number: total += m[q] return total
def symbolic_size(self): if self.size is not None: # Make sure we return a symbolic object as the provided size might # be for example a pure int try: return sympy.Number(self.size) except (TypeError, ValueError): return self._size else: # The size must be given as a function of the parent's symbols return self.symbolic_max - self.symbolic_min + 1