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
