def __call__(self, f_out, f_in, dir_symbol, inv_dir, lb_method, index_field):
def remove_asymmetric_part_of_main_assignments(assignment_collection, degrees_of_freedom):
new_main_assignments = [Assignment(a.lhs, get_symmetric_part(a.rhs, degrees_of_freedom))
for a in assignment_collection.main_assignments]
return assignment_collection.copy(new_main_assignments)
cqc = lb_method.conserved_quantity_computation
velocity = cqc.defined_symbols()['velocity']
symmetric_eq = remove_asymmetric_part_of_main_assignments(lb_method.get_equilibrium(),
degrees_of_freedom=velocity)
substitutions = {sym: f_out(i) for i, sym in enumerate(lb_method.pre_collision_pdf_symbols)}
symmetric_eq = symmetric_eq.new_with_substitutions(substitutions)
simplification = create_simplification_strategy(lb_method)
symmetric_eq = simplification(symmetric_eq)
density_symbol = cqc.defined_symbols()['density']
density = self.density
equilibrium_input = cqc.equilibrium_input_equations_from_init_values(density=density)
equilibrium_input = equilibrium_input.new_without_subexpressions()
density_eq = equilibrium_input.main_assignments[0]
assert density_eq.lhs == density_symbol
transformed_density = density_eq.rhs
conditions = [(eq_i.rhs, sp.Equality(dir_symbol, i))
for i, eq_i in enumerate(symmetric_eq.main_assignments)] + [(0, True)]
eq_component = sp.Piecewise(*conditions)
subexpressions = [Assignment(eq.lhs, transformed_density if eq.lhs == density_symbol else eq.rhs)
for eq in symmetric_eq.subexpressions]
return subexpressions + [Assignment(f_in(inv_dir[dir_symbol]),
2 * eq_component - f_out(dir_symbol))]
def gen_fortran_module(module,
t,
x,
u,
f,
g_dict,
const,
project='PX4-SIL',
header=True):
x_ = sympy.MatrixSymbol('x', len(x), 1)
u_ = sympy.MatrixSymbol('u', len(u), 1)
ss_sub = {x[i]: x_[i, 0] for i in range(len(x))}
ss_sub.update({u[i]: u_[i, 0] for i in range(len(u))})
name_expr = [('f', f), ('A', f.jacobian(x)), ('B', f.jacobian(u))]
for key in g_dict.keys():
name = key
expr = g_dict[key]
name_expr.append((name, expr))
name_expr.append((name + '_H', expr.jacobian(x)))
routines = []
for name, expr in name_expr:
out = sympy.MatrixSymbol('out', expr.shape[0], expr.shape[1])
expr = expr.applyfunc(lambda e: e.simplify())
routines.append(
codegen.Routine('compute_' + name,
sympy.Equality(out, expr.subs(ss_sub)),
(out, t, x_, u_) + const))
fgen = codegen.FCodeGen(project)
s = StringIO.StringIO()
fgen.dump_f95(routines, s, module, header=header)
src = s.getvalue()
s.close()
return src
def main():
# Brendan Wood, MRocklin, Amelio Vazquez-Reina, Automatically populating matrix elements in SymPy,
# http://stackoverflow.com/questions/6877061/automatically-populating-matrix-elements-in-sympy, 2011 Aug 02,
# (accessed 2015 Dec 01)
L = sp.Matrix(3, 3, lambda i, j: sp.var('L_%d%d' % (i, j)))
# symmetric matrix
A = sp.Matrix(3, 3, lambda i, j: sp.var('A_%d%d' % tuple(sorted((i, j)))))
make_lower_triangle(L)
LLT = L * L.transpose()
print(L)
print(LLT)
print(A)
eq = sp.Equality(LLT, A)
print(eq)
solution = sp.solve(
eq,
reduce(lambda x, y: x + y,
[[L[i, j] for j in xrange(3)] for i in xrange(3)]))
simplified_solution = sp.simplify(solution)
print("solution")
pprint(solution)
print("simplified solution")
pprint(simplified_solution, width=60)
def test_integer_comparision():
f = ps.fields("f [2D]")
d = sp.Symbol("dir")
ur = ps.Assignment(f[0, 0], sp.Piecewise((0, sp.Equality(d, 1)), (f[0, 0], True)))
ast = ps.create_kernel(ur)
code = ps.get_code_str(ast)
assert "_data_f_00[_stride_f_1*ctr_1] = ((((dir) == (1))) ? (0.0): (_data_f_00[_stride_f_1*ctr_1]));" in code
def fixed_points_analysis():
""" Exercise 3a - Compute and analyse fixed points """
g, L, d, time = sp.symbols("g, L, d, t")
params = PendulumParameters(g=g, L=L, d=d, sin=sp.sin)
theta = sp.Function('theta')(time)
dt_sym = theta.diff(time)
d2t_sym = theta.diff(time, 2)
# System
sys_matrix = sp.Matrix(pendulum_system([theta, dt_sym], parameters=params))
sys = sp.Equality(sp.Matrix(np.array([[dt_sym], [d2t_sym]])), sys_matrix)
pylog.info(u"Pendulum system:\n{}".format(sp.pretty(sys)))
# Solve when dtheta = 0 and d2theta=0
dt = 0
d2t = 0
t_sol = sp.solveset(
sp.Equality(d2t, pendulum_equation(theta, dt, parameters=params)),
theta # Theta, the variable to be solved
)
sys_fixed = sp.Equality(sp.Matrix(np.array([[0], [0]])), sys_matrix)
pylog.info(u"Solution for fixed points:\n{}\n{}\n{}\n{}".format(
sp.pretty(sys_fixed), sp.pretty(sp.Equality(theta, t_sol)),
sp.pretty(sp.Equality(dt_sym, dt)),
sp.pretty(sp.Equality(d2t_sym, d2t))))
# Alternative way of solving
sol = sp.solve(sys_fixed, [theta, dt_sym])
pylog.info(u"Solution using an alternative way of solving:\n{}".format(
sp.pretty(sol)))
# Jacobian, eigenvalues and eigenvectors
jac = sys_matrix.jacobian(sp.Matrix([theta, dt_sym]))
eigenvals = jac.eigenvals()
eigenvects = jac.eigenvects()
pylog.info(u"Jacobian:\n{}\nEigenvalues:\n{}\nEigenvectors:\n{}".format(
sp.pretty(jac), sp.pretty(eigenvals), sp.pretty(eigenvects)))
# Stability analysis
for i, s in enumerate(sol):
pylog.info(u"Case {}:\n{}".format(
i + 1,
sp.pretty(sp.Equality(sp.Matrix([theta, dt_sym]), sp.Matrix(s)))))
res = [None for _ in eigenvals.keys()]
for j, e in enumerate(eigenvals.keys()):
res[j] = e.subs({theta: s[0], dt_sym: s[1], g: 9.81, L: 1, d: 0.1})
pylog.info(u"{}\n{}".format(
sp.pretty(sp.Equality(e, res[j])),
"{} {}".format(sp.re(res[j]),
"> 0" if sp.re(res[j]) > 0 else "< 0")))
fixed_point_type = None
if all([sp.re(r) < 0 for r in res]):
fixed_point_type = " stable point"
elif all([sp.re(r) > 0 for r in res]):
fixed_point_type = "n unstable point"
else:
fixed_point_type = " saddle point"
pylog.info("Fixed point is a{}".format(fixed_point_type))
def max_load_est(sigma=0.8, thrust_max=G.thrust_max):
if thrust_max:
load_max = thrust_max * 4 - G.g
pitch_max = np.arccos(float(G.W / (G.n_r * thrust_max)))
else:
I_m, U_m, M, N = sy.symbols('I_m U_m M N', positive=True)
# These equalities are the equations to be solved, the stuff inside the brackets is just 'left side' and 'right side'
Eq1 = sy.Equality(
G.f_sigma(I_m=I_m, U_m=U_m),
sigma) # First term ('left side') is duty cycle, assumed 0.8 here
Eq2 = sy.Equality(M, G.rho * G.D_p**5 * G.f_C_M() *
(N / 60)**2) # The equation for M, the motor torque
Eq3 = sy.Equality(U_m, G.f_U_m(
M=M, N=N)) # Equation for U_m, equivalent motor voltage
Eq4 = sy.Equality(I_m, G.f_I_m(
M=M, N=N)) # Equation for I_m, equivalent motor current
Eqs = [Eq1, Eq2, Eq3, Eq4]
sol = sy.solve(Eqs, [I_m, U_m, M, N])
I_m = sol[0][0]
U_m = sol[0][1]
M = sol[0][2]
N = sol[0][3]
I_e = G.f_I_e(sigma=sigma, I_m=I_m)
I_b = G.n_r * I_e + G.I_c
U_e = G.f_U_e(I_b=I_b)
eff = (2 * np.pi * G.n_r * M * N) / (G.U_b * I_b * 60)
T = G.f_C_T() * G.rho * (N / 60)**2 * G.D_p**4
# print(T)
T_b = G.f_T_b(I_b=I_b)
blah = (G.W / (G.n_r * T))
pitch_max = np.arccos(float(G.W / (G.n_r * T)))
load_max = G.n_r * T - G.W
return load_max, pitch_max
def get_coeffs(x, y, debug=False):
assert len(x) == len(y), "x and y not same length"
N = len(x)
d = [
sp.Add(*[
1/N * y[k] * sp.exp(- sp.I * j * x[k])
for k in range(N)
], evaluate=not(debug))
for j in range(N)
]
if debug:
for i, di in enumerate(d):
display(sp.Equality(sp.symbols(f"d_{i}"), di, evaluate=False))
return d
def van_der_walls_eos(density, gas_constant, temperature, a, b):
pressure = sp.Symbol("P")
vdw = sp.Equality((pressure + a * density ** 2) * (1 / density - b), gas_constant * temperature)
return sp.solve(vdw, pressure)[0]
def matches(n):
return (store.name == n.name
and is_true(sympy.Equality(store.index, n.index)))
def solve(*equalities):
if len(equalities) == 1:
return sympy.solve(equalities[0])
return sympy.solve_poly_system(equalities)
x = sympy.Symbol("x")
print('\nПроизводная: ')
expr = x**2 + sympy.log(x)
sympy.pprint(expr)
sympy.plot(expr)
print('\nПроизводная: ')
diff = sympy.diff(expr)
sympy.pprint(diff)
sympy.plot(diff)
print('\nПервообразная: ')
integr = sympy.integrate(expr)
sympy.pprint(integr)
sympy.plot(integr)
y = sympy.Symbol("y")
eq1 = sympy.Equality(x**2 - x * y, 3)
eq2 = sympy.Equality(y**2 - x * y, -2)
eq3 = sympy.Equality(x**2, -2)
sympy.pprint(solve(eq1, eq2))
sympy.pprint(solve(eq3))
def _class_resolver_dictionary() -> Dict[str, ObjectFactory]:
import cirq
from cirq.ops import raw_types
import pandas as pd
import numpy as np
from cirq.devices.noise_model import _NoNoiseModel
from cirq.experiments import CrossEntropyResult, CrossEntropyResultDict, GridInteractionLayer
from cirq.experiments.grid_parallel_two_qubit_xeb import GridParallelXEBMetadata
def _boolean_hamiltonian_gate_op(qubit_map, boolean_strs, theta):
return cirq.BooleanHamiltonianGate(parameter_names=list(
qubit_map.keys()),
boolean_strs=boolean_strs,
theta=theta).on(*qubit_map.values())
def _identity_operation_from_dict(qubits, **kwargs):
return cirq.identity_each(*qubits)
def single_qubit_matrix_gate(matrix):
if not isinstance(matrix, np.ndarray):
matrix = np.array(matrix, dtype=np.complex128)
return cirq.MatrixGate(matrix, qid_shape=(matrix.shape[0], ))
def two_qubit_matrix_gate(matrix):
if not isinstance(matrix, np.ndarray):
matrix = np.array(matrix, dtype=np.complex128)
return cirq.MatrixGate(matrix, qid_shape=(2, 2))
def _parallel_gate_op(gate, qubits):
return cirq.parallel_gate_op(gate, *qubits)
def _datetime(timestamp: float) -> datetime.datetime:
# As part of our serialization logic, we make sure we only serialize "aware"
# datetimes with the UTC timezone, so we implicitly add back in the UTC timezone here.
#
# Please note: even if the assumption is somehow violated, the fact that we use
# unix timestamps should mean that the deserialized datetime should refer to the
# same point in time but may not satisfy o = read_json(to_json(o)) because the actual
# timezones, and hour fields will not be identical.
return datetime.datetime.fromtimestamp(timestamp,
tz=datetime.timezone.utc)
def _symmetricalqidpair(qids):
return frozenset(qids)
import sympy
return {
'AmplitudeDampingChannel': cirq.AmplitudeDampingChannel,
'AnyIntegerPowerGateFamily': cirq.AnyIntegerPowerGateFamily,
'AnyUnitaryGateFamily': cirq.AnyUnitaryGateFamily,
'AsymmetricDepolarizingChannel': cirq.AsymmetricDepolarizingChannel,
'BitFlipChannel': cirq.BitFlipChannel,
'BitstringAccumulator': cirq.work.BitstringAccumulator,
'BooleanHamiltonianGate': cirq.BooleanHamiltonianGate,
'CCNotPowGate': cirq.CCNotPowGate,
'CCXPowGate': cirq.CCXPowGate,
'CCZPowGate': cirq.CCZPowGate,
'Circuit': cirq.Circuit,
'CircuitOperation': cirq.CircuitOperation,
'ClassicallyControlledOperation': cirq.ClassicallyControlledOperation,
'ClassicalDataDictionaryStore': cirq.ClassicalDataDictionaryStore,
'CliffordGate': cirq.CliffordGate,
'CliffordState': cirq.CliffordState,
'CliffordTableau': cirq.CliffordTableau,
'CNotPowGate': cirq.CNotPowGate,
'ConstantQubitNoiseModel': cirq.ConstantQubitNoiseModel,
'ControlledGate': cirq.ControlledGate,
'ControlledOperation': cirq.ControlledOperation,
'CrossEntropyResult': CrossEntropyResult,
'CrossEntropyResultDict': CrossEntropyResultDict,
'CSwapGate': cirq.CSwapGate,
'CXPowGate': cirq.CXPowGate,
'CZPowGate': cirq.CZPowGate,
'CZTargetGateset': cirq.CZTargetGateset,
'DiagonalGate': cirq.DiagonalGate,
'DensePauliString': cirq.DensePauliString,
'DepolarizingChannel': cirq.DepolarizingChannel,
'DeviceMetadata': cirq.DeviceMetadata,
'Duration': cirq.Duration,
'FrozenCircuit': cirq.FrozenCircuit,
'FSimGate': cirq.FSimGate,
'GateFamily': cirq.GateFamily,
'GateOperation': cirq.GateOperation,
'Gateset': cirq.Gateset,
'GeneralizedAmplitudeDampingChannel':
cirq.GeneralizedAmplitudeDampingChannel,
'GlobalPhaseGate': cirq.GlobalPhaseGate,
'GlobalPhaseOperation': cirq.GlobalPhaseOperation,
'GridDeviceMetadata': cirq.GridDeviceMetadata,
'GridInteractionLayer': GridInteractionLayer,
'GridParallelXEBMetadata': GridParallelXEBMetadata,
'GridQid': cirq.GridQid,
'GridQubit': cirq.GridQubit,
'HPowGate': cirq.HPowGate,
'ISwapPowGate': cirq.ISwapPowGate,
'IdentityGate': cirq.IdentityGate,
'InitObsSetting': cirq.work.InitObsSetting,
'KeyCondition': cirq.KeyCondition,
'KrausChannel': cirq.KrausChannel,
'LinearDict': cirq.LinearDict,
'LineQubit': cirq.LineQubit,
'LineQid': cirq.LineQid,
'LineTopology': cirq.LineTopology,
'MatrixGate': cirq.MatrixGate,
'MixedUnitaryChannel': cirq.MixedUnitaryChannel,
'MeasurementKey': cirq.MeasurementKey,
'MeasurementGate': cirq.MeasurementGate,
'MeasurementType': cirq.MeasurementType,
'_MeasurementSpec': cirq.work._MeasurementSpec,
'Moment': cirq.Moment,
'MutableDensePauliString': cirq.MutableDensePauliString,
'MutablePauliString': cirq.MutablePauliString,
'_NoNoiseModel': _NoNoiseModel,
'NamedQubit': cirq.NamedQubit,
'NamedQid': cirq.NamedQid,
'NoIdentifierQubit': cirq.testing.NoIdentifierQubit,
'ObservableMeasuredResult': cirq.work.ObservableMeasuredResult,
'OpIdentifier': cirq.OpIdentifier,
'ParamResolver': cirq.ParamResolver,
'ParallelGate': cirq.ParallelGate,
'ParallelGateFamily': cirq.ParallelGateFamily,
'PauliInteractionGate': cirq.PauliInteractionGate,
'PauliMeasurementGate': cirq.PauliMeasurementGate,
'PauliString': cirq.PauliString,
'PauliStringPhasor': cirq.PauliStringPhasor,
'PauliStringPhasorGate': cirq.PauliStringPhasorGate,
'PauliSum': cirq.PauliSum,
'_PauliX': cirq.ops.pauli_gates._PauliX,
'_PauliY': cirq.ops.pauli_gates._PauliY,
'_PauliZ': cirq.ops.pauli_gates._PauliZ,
'PhaseDampingChannel': cirq.PhaseDampingChannel,
'PhaseFlipChannel': cirq.PhaseFlipChannel,
'PhaseGradientGate': cirq.PhaseGradientGate,
'PhasedFSimGate': cirq.PhasedFSimGate,
'PhasedISwapPowGate': cirq.PhasedISwapPowGate,
'PhasedXPowGate': cirq.PhasedXPowGate,
'PhasedXZGate': cirq.PhasedXZGate,
'ProductState': cirq.ProductState,
'ProjectorString': cirq.ProjectorString,
'ProjectorSum': cirq.ProjectorSum,
'QasmUGate': cirq.circuits.qasm_output.QasmUGate,
'_QubitAsQid': raw_types._QubitAsQid,
'QuantumFourierTransformGate': cirq.QuantumFourierTransformGate,
'QubitPermutationGate': cirq.QubitPermutationGate,
'RandomGateChannel': cirq.RandomGateChannel,
'RepetitionsStoppingCriteria': cirq.work.RepetitionsStoppingCriteria,
'ResetChannel': cirq.ResetChannel,
'Result': cirq.ResultDict, # Keep support for Cirq < 0.14.
'ResultDict': cirq.ResultDict,
'Rx': cirq.Rx,
'Ry': cirq.Ry,
'Rz': cirq.Rz,
'SingleQubitCliffordGate': cirq.SingleQubitCliffordGate,
'SingleQubitPauliStringGateOperation':
cirq.SingleQubitPauliStringGateOperation,
'SingleQubitReadoutCalibrationResult':
cirq.experiments.SingleQubitReadoutCalibrationResult,
'SqrtIswapTargetGateset': cirq.SqrtIswapTargetGateset,
'StabilizerStateChForm': cirq.StabilizerStateChForm,
'StatePreparationChannel': cirq.StatePreparationChannel,
'SwapPowGate': cirq.SwapPowGate,
'SympyCondition': cirq.SympyCondition,
'TaggedOperation': cirq.TaggedOperation,
'TensoredConfusionMatrices': cirq.TensoredConfusionMatrices,
'TiltedSquareLattice': cirq.TiltedSquareLattice,
'ThreeQubitDiagonalGate': cirq.ThreeQubitDiagonalGate,
'TrialResult': cirq.ResultDict, # keep support for Cirq < 0.11.
'TwoQubitDiagonalGate': cirq.TwoQubitDiagonalGate,
'TwoQubitGateTabulation': cirq.TwoQubitGateTabulation,
'_UnconstrainedDevice':
cirq.devices.unconstrained_device._UnconstrainedDevice,
'VarianceStoppingCriteria': cirq.work.VarianceStoppingCriteria,
'VirtualTag': cirq.VirtualTag,
'WaitGate': cirq.WaitGate,
# The formatter keeps putting this back
# pylint: disable=line-too-long
'XEBPhasedFSimCharacterizationOptions':
cirq.experiments.XEBPhasedFSimCharacterizationOptions,
# pylint: enable=line-too-long
'_XEigenState': cirq.value.product_state._XEigenState, # type: ignore
'XPowGate': cirq.XPowGate,
'XXPowGate': cirq.XXPowGate,
'_YEigenState': cirq.value.product_state._YEigenState, # type: ignore
'YPowGate': cirq.YPowGate,
'YYPowGate': cirq.YYPowGate,
'_ZEigenState': cirq.value.product_state._ZEigenState, # type: ignore
'ZPowGate': cirq.ZPowGate,
'ZZPowGate': cirq.ZZPowGate,
# Old types, only supported for backwards-compatibility
'BooleanHamiltonian': _boolean_hamiltonian_gate_op, # Removed in v0.15
'IdentityOperation': _identity_operation_from_dict,
'ParallelGateOperation': _parallel_gate_op, # Removed in v0.14
'SingleQubitMatrixGate': single_qubit_matrix_gate,
'SymmetricalQidPair': _symmetricalqidpair, # Removed in v0.15
'TwoQubitMatrixGate': two_qubit_matrix_gate,
# not a cirq class, but treated as one:
'pandas.DataFrame': pd.DataFrame,
'pandas.Index': pd.Index,
'pandas.MultiIndex': pd.MultiIndex.from_tuples,
'sympy.Symbol': sympy.Symbol,
'sympy.Add': lambda args: sympy.Add(*args),
'sympy.Mul': lambda args: sympy.Mul(*args),
'sympy.Pow': lambda args: sympy.Pow(*args),
'sympy.GreaterThan': lambda args: sympy.GreaterThan(*args),
'sympy.StrictGreaterThan': lambda args: sympy.StrictGreaterThan(*args),
'sympy.LessThan': lambda args: sympy.LessThan(*args),
'sympy.StrictLessThan': lambda args: sympy.StrictLessThan(*args),
'sympy.Equality': lambda args: sympy.Equality(*args),
'sympy.Unequality': lambda args: sympy.Unequality(*args),
'sympy.Float': lambda approx: sympy.Float(approx),
'sympy.Integer': sympy.Integer,
'sympy.Rational': sympy.Rational,
'sympy.pi': lambda: sympy.pi,
'sympy.E': lambda: sympy.E,
'sympy.EulerGamma': lambda: sympy.EulerGamma,
'complex': complex,
'datetime.datetime': _datetime,
}
def test_rp_rq(self):
test = self.e.rp_implied_rq.subs({rp: self.e.rq_implied_rp})
for v in [sp.Rational(4,5), sp.Rational(1, 1), sp.Rational(6,5)]:
self.assertTrue(sp.Equality(test.subs({rq: v}), v))
import Governing_constants_and_functions as G
import numpy as np
import sympy as sy
I_m, U_m, M, N = sy.symbols('I_m U_m M N', positive=True)
# These equalities are the equations to be solved, the stuff inside the brackets is just 'left side' and 'right side'
Eq1 = sy.Equality(G.f_sigma(I_m=I_m, U_m=U_m), 1) # First term ('left side') is duty cycle, which is 1 for max thrust
Eq2 = sy.Equality(M, G.rho * G.D_p ** 5 * G.f_C_M() * (N/60) ** 2) # The equation for M, the motor torque
Eq3 = sy.Equality(U_m, G.f_U_m(M=M, N=N)) # Equation for U_m, equivalent motor voltage
Eq4 = sy.Equality(I_m, G.f_I_m(M=M, N=N)) # Equation for I_m, equivalent motor current
Eqs = [Eq1, Eq2, Eq3, Eq4]
sol = sy.solve(Eqs, [I_m, U_m, M, N])
I_m = sol[0][0]
U_m = sol[0][1]
M = sol[0][2]
N = sol[0][3]
I_e = G.f_I_e(sigma=1, I_m=I_m)
I_b = G.n_r * I_e + G.I_c
U_e = G.f_U_e(I_b=I_b)
eff = (2 * np.pi * G.n_r * M * N)/(G.U_b * I_b * 60)
T = G.f_C_T() * G.rho * (N/60) ** 2 * G.D_p ** 4
T_b = G.f_T_b(I_b=I_b)
print('Thrust is', T, 'N', G.f_C_M())
def solve(*equalities):
if len(equalities) == 1:
return sympy.solve(equalities[0])
return sympy.solve_poly_system(equalities)
x = sympy.Symbol("x")
print('\nПроизводная: ')
#expr = x ** 2 + sympy.log(x)
expr = x**2 * sympy.sin(1)
sympy.pprint(expr)
sympy.plot(expr)
print('\nПроизводная: ')
diff = sympy.diff(expr)
sympy.pprint(diff)
sympy.plot(diff)
print('\nПервообразная: ')
integr = sympy.integrate(expr)
sympy.pprint(integr)
sympy.plot(integr)
y = sympy.Symbol("y")
eq1 = sympy.Equality(3, x**2 - x * y)
eq2 = sympy.Equality(-2, y**2 - x * y)
eq3 = sympy.Equality(x**2, -2)
sympy.pprint(solve(eq1, eq2))
sympy.pprint(solve(eq3))
def _class_resolver_dictionary() -> Dict[str, ObjectFactory]:
import cirq
from cirq.ops import raw_types
import pandas as pd
import numpy as np
from cirq.devices.noise_model import _NoNoiseModel
from cirq.experiments import CrossEntropyResult, CrossEntropyResultDict, GridInteractionLayer
from cirq.experiments.grid_parallel_two_qubit_xeb import GridParallelXEBMetadata
def _identity_operation_from_dict(qubits, **kwargs):
return cirq.identity_each(*qubits)
def single_qubit_matrix_gate(matrix):
if not isinstance(matrix, np.ndarray):
matrix = np.array(matrix, dtype=np.complex128)
return cirq.MatrixGate(matrix, qid_shape=(matrix.shape[0], ))
def two_qubit_matrix_gate(matrix):
if not isinstance(matrix, np.ndarray):
matrix = np.array(matrix, dtype=np.complex128)
return cirq.MatrixGate(matrix, qid_shape=(2, 2))
def _parallel_gate_op(gate, qubits):
return cirq.parallel_gate_op(gate, *qubits)
import sympy
return {
'AmplitudeDampingChannel': cirq.AmplitudeDampingChannel,
'AnyIntegerPowerGateFamily': cirq.AnyIntegerPowerGateFamily,
'AnyUnitaryGateFamily': cirq.AnyUnitaryGateFamily,
'AsymmetricDepolarizingChannel': cirq.AsymmetricDepolarizingChannel,
'BitFlipChannel': cirq.BitFlipChannel,
'BitstringAccumulator': cirq.work.BitstringAccumulator,
'BooleanHamiltonian': cirq.BooleanHamiltonian,
'CCNotPowGate': cirq.CCNotPowGate,
'CCXPowGate': cirq.CCXPowGate,
'CCZPowGate': cirq.CCZPowGate,
'Circuit': cirq.Circuit,
'CircuitOperation': cirq.CircuitOperation,
'ClassicallyControlledOperation': cirq.ClassicallyControlledOperation,
'CliffordState': cirq.CliffordState,
'CliffordTableau': cirq.CliffordTableau,
'CNotPowGate': cirq.CNotPowGate,
'ConstantQubitNoiseModel': cirq.ConstantQubitNoiseModel,
'ControlledGate': cirq.ControlledGate,
'ControlledOperation': cirq.ControlledOperation,
'CrossEntropyResult': CrossEntropyResult,
'CrossEntropyResultDict': CrossEntropyResultDict,
'CSwapGate': cirq.CSwapGate,
'CXPowGate': cirq.CXPowGate,
'CZPowGate': cirq.CZPowGate,
'DensePauliString': cirq.DensePauliString,
'DepolarizingChannel': cirq.DepolarizingChannel,
'DeviceMetadata': cirq.DeviceMetadata,
'Duration': cirq.Duration,
'FrozenCircuit': cirq.FrozenCircuit,
'FSimGate': cirq.FSimGate,
'GateFamily': cirq.GateFamily,
'GateOperation': cirq.GateOperation,
'Gateset': cirq.Gateset,
'GeneralizedAmplitudeDampingChannel':
cirq.GeneralizedAmplitudeDampingChannel,
'GlobalPhaseGate': cirq.GlobalPhaseGate,
'GlobalPhaseOperation': cirq.GlobalPhaseOperation,
'GridDeviceMetadata': cirq.GridDeviceMetadata,
'GridInteractionLayer': GridInteractionLayer,
'GridParallelXEBMetadata': GridParallelXEBMetadata,
'GridQid': cirq.GridQid,
'GridQubit': cirq.GridQubit,
'HPowGate': cirq.HPowGate,
'ISwapPowGate': cirq.ISwapPowGate,
'IdentityGate': cirq.IdentityGate,
'InitObsSetting': cirq.work.InitObsSetting,
'KeyCondition': cirq.KeyCondition,
'KrausChannel': cirq.KrausChannel,
'LinearDict': cirq.LinearDict,
'LineQubit': cirq.LineQubit,
'LineQid': cirq.LineQid,
'LineTopology': cirq.LineTopology,
'MatrixGate': cirq.MatrixGate,
'MixedUnitaryChannel': cirq.MixedUnitaryChannel,
'MeasurementKey': cirq.MeasurementKey,
'MeasurementGate': cirq.MeasurementGate,
'_MeasurementSpec': cirq.work._MeasurementSpec,
'Moment': cirq.Moment,
'MutableDensePauliString': cirq.MutableDensePauliString,
'MutablePauliString': cirq.MutablePauliString,
'_NoNoiseModel': _NoNoiseModel,
'NamedQubit': cirq.NamedQubit,
'NamedQid': cirq.NamedQid,
'NoIdentifierQubit': cirq.testing.NoIdentifierQubit,
'ObservableMeasuredResult': cirq.work.ObservableMeasuredResult,
'OpIdentifier': cirq.OpIdentifier,
'ParamResolver': cirq.ParamResolver,
'ParallelGate': cirq.ParallelGate,
'ParallelGateFamily': cirq.ParallelGateFamily,
'PauliMeasurementGate': cirq.PauliMeasurementGate,
'PauliString': cirq.PauliString,
'PauliStringPhasor': cirq.PauliStringPhasor,
'PauliStringPhasorGate': cirq.PauliStringPhasorGate,
'_PauliX': cirq.ops.pauli_gates._PauliX,
'_PauliY': cirq.ops.pauli_gates._PauliY,
'_PauliZ': cirq.ops.pauli_gates._PauliZ,
'PhaseDampingChannel': cirq.PhaseDampingChannel,
'PhaseFlipChannel': cirq.PhaseFlipChannel,
'PhaseGradientGate': cirq.PhaseGradientGate,
'PhasedFSimGate': cirq.PhasedFSimGate,
'PhasedISwapPowGate': cirq.PhasedISwapPowGate,
'PhasedXPowGate': cirq.PhasedXPowGate,
'PhasedXZGate': cirq.PhasedXZGate,
'ProductState': cirq.ProductState,
'ProjectorString': cirq.ProjectorString,
'ProjectorSum': cirq.ProjectorSum,
'QasmUGate': cirq.circuits.qasm_output.QasmUGate,
'_QubitAsQid': raw_types._QubitAsQid,
'QuantumFourierTransformGate': cirq.QuantumFourierTransformGate,
'RandomGateChannel': cirq.RandomGateChannel,
'RepetitionsStoppingCriteria': cirq.work.RepetitionsStoppingCriteria,
'ResetChannel': cirq.ResetChannel,
'Result': cirq.Result,
'Rx': cirq.Rx,
'Ry': cirq.Ry,
'Rz': cirq.Rz,
'SingleQubitCliffordGate': cirq.SingleQubitCliffordGate,
'SingleQubitPauliStringGateOperation':
cirq.SingleQubitPauliStringGateOperation,
'SingleQubitReadoutCalibrationResult':
cirq.experiments.SingleQubitReadoutCalibrationResult,
'StabilizerStateChForm': cirq.StabilizerStateChForm,
'StatePreparationChannel': cirq.StatePreparationChannel,
'SwapPowGate': cirq.SwapPowGate,
'SymmetricalQidPair': cirq.SymmetricalQidPair,
'SympyCondition': cirq.SympyCondition,
'TaggedOperation': cirq.TaggedOperation,
'TiltedSquareLattice': cirq.TiltedSquareLattice,
'TrialResult': cirq.Result, # keep support for Cirq < 0.11.
'TwoQubitGateTabulation': cirq.TwoQubitGateTabulation,
'_UnconstrainedDevice':
cirq.devices.unconstrained_device._UnconstrainedDevice,
'VarianceStoppingCriteria': cirq.work.VarianceStoppingCriteria,
'VirtualTag': cirq.VirtualTag,
'WaitGate': cirq.WaitGate,
# The formatter keeps putting this back
# pylint: disable=line-too-long
'XEBPhasedFSimCharacterizationOptions':
cirq.experiments.XEBPhasedFSimCharacterizationOptions,
# pylint: enable=line-too-long
'_XEigenState': cirq.value.product_state._XEigenState, # type: ignore
'XPowGate': cirq.XPowGate,
'XXPowGate': cirq.XXPowGate,
'_YEigenState': cirq.value.product_state._YEigenState, # type: ignore
'YPowGate': cirq.YPowGate,
'YYPowGate': cirq.YYPowGate,
'_ZEigenState': cirq.value.product_state._ZEigenState, # type: ignore
'ZPowGate': cirq.ZPowGate,
'ZZPowGate': cirq.ZZPowGate,
# Old types, only supported for backwards-compatibility
'IdentityOperation': _identity_operation_from_dict,
'ParallelGateOperation': _parallel_gate_op, # Removed in v0.14
'SingleQubitMatrixGate': single_qubit_matrix_gate,
'TwoQubitMatrixGate': two_qubit_matrix_gate,
# not a cirq class, but treated as one:
'pandas.DataFrame': pd.DataFrame,
'pandas.Index': pd.Index,
'pandas.MultiIndex': pd.MultiIndex.from_tuples,
'sympy.Symbol': sympy.Symbol,
'sympy.Add': lambda args: sympy.Add(*args),
'sympy.Mul': lambda args: sympy.Mul(*args),
'sympy.Pow': lambda args: sympy.Pow(*args),
'sympy.GreaterThan': lambda args: sympy.GreaterThan(*args),
'sympy.StrictGreaterThan': lambda args: sympy.StrictGreaterThan(*args),
'sympy.LessThan': lambda args: sympy.LessThan(*args),
'sympy.StrictLessThan': lambda args: sympy.StrictLessThan(*args),
'sympy.Equality': lambda args: sympy.Equality(*args),
'sympy.Unequality': lambda args: sympy.Unequality(*args),
'sympy.Float': lambda approx: sympy.Float(approx),
'sympy.Integer': sympy.Integer,
'sympy.Rational': sympy.Rational,
'sympy.pi': lambda: sympy.pi,
'sympy.E': lambda: sympy.E,
'sympy.EulerGamma': lambda: sympy.EulerGamma,
'complex': complex,
}
