def test_conv7(): x = Symbol("x") y = Symbol("y") assert sin(x/3) == sin(sympy.Symbol("x") / 3) assert cos(x/3) == cos(sympy.Symbol("x") / 3) assert tan(x/3) == tan(sympy.Symbol("x") / 3) assert cot(x/3) == cot(sympy.Symbol("x") / 3) assert csc(x/3) == csc(sympy.Symbol("x") / 3) assert sec(x/3) == sec(sympy.Symbol("x") / 3) assert asin(x/3) == asin(sympy.Symbol("x") / 3) assert acos(x/3) == acos(sympy.Symbol("x") / 3) assert atan(x/3) == atan(sympy.Symbol("x") / 3) assert acot(x/3) == acot(sympy.Symbol("x") / 3) assert acsc(x/3) == acsc(sympy.Symbol("x") / 3) assert asec(x/3) == asec(sympy.Symbol("x") / 3) assert sin(x/3)._sympy_() == sympy.sin(sympy.Symbol("x") / 3) assert sin(x/3)._sympy_() != sympy.cos(sympy.Symbol("x") / 3) assert cos(x/3)._sympy_() == sympy.cos(sympy.Symbol("x") / 3) assert tan(x/3)._sympy_() == sympy.tan(sympy.Symbol("x") / 3) assert cot(x/3)._sympy_() == sympy.cot(sympy.Symbol("x") / 3) assert csc(x/3)._sympy_() == sympy.csc(sympy.Symbol("x") / 3) assert sec(x/3)._sympy_() == sympy.sec(sympy.Symbol("x") / 3) assert asin(x/3)._sympy_() == sympy.asin(sympy.Symbol("x") / 3) assert acos(x/3)._sympy_() == sympy.acos(sympy.Symbol("x") / 3) assert atan(x/3)._sympy_() == sympy.atan(sympy.Symbol("x") / 3) assert acot(x/3)._sympy_() == sympy.acot(sympy.Symbol("x") / 3) assert acsc(x/3)._sympy_() == sympy.acsc(sympy.Symbol("x") / 3) assert asec(x/3)._sympy_() == sympy.asec(sympy.Symbol("x") / 3)
def test_conv7(): x = Symbol("x") y = Symbol("y") assert sin(x / 3) == sin(sympy.Symbol("x") / 3) assert cos(x / 3) == cos(sympy.Symbol("x") / 3) assert tan(x / 3) == tan(sympy.Symbol("x") / 3) assert cot(x / 3) == cot(sympy.Symbol("x") / 3) assert csc(x / 3) == csc(sympy.Symbol("x") / 3) assert sec(x / 3) == sec(sympy.Symbol("x") / 3) assert asin(x / 3) == asin(sympy.Symbol("x") / 3) assert acos(x / 3) == acos(sympy.Symbol("x") / 3) assert atan(x / 3) == atan(sympy.Symbol("x") / 3) assert acot(x / 3) == acot(sympy.Symbol("x") / 3) assert acsc(x / 3) == acsc(sympy.Symbol("x") / 3) assert asec(x / 3) == asec(sympy.Symbol("x") / 3) assert sin(x / 3)._sympy_() == sympy.sin(sympy.Symbol("x") / 3) assert sin(x / 3)._sympy_() != sympy.cos(sympy.Symbol("x") / 3) assert cos(x / 3)._sympy_() == sympy.cos(sympy.Symbol("x") / 3) assert tan(x / 3)._sympy_() == sympy.tan(sympy.Symbol("x") / 3) assert cot(x / 3)._sympy_() == sympy.cot(sympy.Symbol("x") / 3) assert csc(x / 3)._sympy_() == sympy.csc(sympy.Symbol("x") / 3) assert sec(x / 3)._sympy_() == sympy.sec(sympy.Symbol("x") / 3) assert asin(x / 3)._sympy_() == sympy.asin(sympy.Symbol("x") / 3) assert acos(x / 3)._sympy_() == sympy.acos(sympy.Symbol("x") / 3) assert atan(x / 3)._sympy_() == sympy.atan(sympy.Symbol("x") / 3) assert acot(x / 3)._sympy_() == sympy.acot(sympy.Symbol("x") / 3) assert acsc(x / 3)._sympy_() == sympy.acsc(sympy.Symbol("x") / 3) assert asec(x / 3)._sympy_() == sympy.asec(sympy.Symbol("x") / 3)
def quaternion_from_rpy(roll, pitch, yaw): """ :type roll: Union[float, Symbol] :type pitch: Union[float, Symbol] :type yaw: Union[float, Symbol] :return: 4x1 Matrix :type: Matrix """ roll_half = roll / 2.0 pitch_half = pitch / 2.0 yaw_half = yaw / 2.0 c_roll = se.cos(roll_half) s_roll = se.sin(roll_half) c_pitch = se.cos(pitch_half) s_pitch = se.sin(pitch_half) c_yaw = se.cos(yaw_half) s_yaw = se.sin(yaw_half) cc = c_roll * c_yaw cs = c_roll * s_yaw sc = s_roll * c_yaw ss = s_roll * s_yaw x = c_pitch * sc - s_pitch * cs y = c_pitch * ss + s_pitch * cc z = c_pitch * cs - s_pitch * sc w = c_pitch * cc + s_pitch * ss return se.Matrix([x, y, z, w])
def qubit_op_to_expr(qubit_op, angle_folds=0): qubit_op.compress() dict_op = qubit_op.terms expr = 0 for key in dict_op: term = dict_op[key] for var in key: num, char = var if char == 'X': term *= se.cos(se.Symbol('phi' + str(num))) * se.sin( se.Symbol('the' + str(num))) if angle_folds == 3: term *= se.Symbol('W' + str(num)) if char == 'Y': term *= se.sin(se.Symbol('phi' + str(num))) * se.sin( se.Symbol('the' + str(num))) if angle_folds > 1: term *= se.Symbol('Q' + str(num)) if char == 'Z': term *= se.cos(se.Symbol('the' + str(num))) if angle_folds > 0: term *= se.Symbol('Z' + str(num)) expr += term return expr
def cos(expr): """Cosine""" if type(expr) == GC: return GC( se.cos(expr.expr), {s: -se.sin(expr.expr) * d for s, d in expr.gradients.items()}) return se.cos(expr)
def test_sin(): x = Symbol("x") e = sin(x) assert e == sin(x) assert e != cos(x) assert sin(x).diff(x) == cos(x) assert cos(x).diff(x) == -sin(x) e = sqrt(x).diff(x).diff(x) f = sin(e) g = f.diff(x).diff(x) assert isinstance(g, Add)
def test_find_dependent_helpers(self): helpers = [ (q, p), (r, sin(q)), (s, 3 * p + r), (u, Integer(42)), ] control = [ (q, 1), (r, cos(q)), (s, 3 + cos(q)), ] dependent_helpers = find_dependent_helpers(helpers, p) # This check is overly restrictive due to depending on the order and exact form of the result: self.assertListEqual(dependent_helpers, control)
def test_integralKernelMinus(self): n = 10 m = 10 listn = np.zeros(n, dtype=object) vals = np.zeros((n, m), dtype=object) for i in range(n): Plus0 = np.array(CFS_Action.integralKernelMinus(i + 1)).reshape( 2, 2) print(Plus0) #Plus1 = np.array(CFS_Action.integralKernelMinus(i +1), dtype = object).reshape(2,2) listn[i] = si.lambdify(r[0], [ sy.simplify(-2 * si.cos(r[0] / 2) * CFS_Action.prefactor(i) * JacPol(si.Rational(1, 2), si.Rational(3, 2), i) + Plus0[0, 0] + Plus0[1, 1]) ], real=False) #print( sy.simplify(JacPol(1/2,3/2, i)),'=?=', sy.jacobi(i, 1/2,3/2, r[0])) #listn[i] =si.lambdify(r[0], [sy.simplify(JacPol(1/2,3/2, i)) - sy.jacobi(i, 1/2,3/2, r[0])]) for i in range(n): for j in range(m): vals[i, j] = listn[i](j) print(vals) np.testing.assert_almost_equal(vals, np.zeros((n, m)), 10)
def reproject_axis_gen2(X, Y, Z, axis, cal): #(phase_cal, tilt_cal, curve_cal, gibPhase_cal, gibMag_cal, ogeePhase_cal, ogeeMag_cal) = cal B = atan2(Z, X) Ydeg = cal.tilt + (-1 if axis else 1) * math.pi / 6. tanA = tan(Ydeg) normXZ = sqrt(X * X + Z * Z) asinArg = tanA * Y / normXZ sinYdeg = sin(Ydeg) cosYdeg = cos(Ydeg) sinPart = sin(B - asin(asinArg) + cal.ogeephase) * cal.ogeemag normXYZ = sqrt(X * X + Y * Y + Z * Z) modAsinArg = Y / normXYZ / cosYdeg asinOut = asin(modAsinArg) mod, acc = calc_cal_series(asinOut) BcalCurved = sinPart + cal.curve asinArg2 = asinArg + mod * BcalCurved / (cosYdeg - acc * BcalCurved * sinYdeg) asinOut2 = asin(asinArg2) sinOut2 = sin(B - asinOut2 + cal.gibpha) return B - asinOut2 + sinOut2 * cal.gibmag - cal.phase - math.pi / 2.
def integralKernelMinus(self, n): n = n - 1 lala1 = sy.jacobi(n, si.Rational(1, 2), si.Rational(3, 2), r[0]) lala2 = sy.jacobi(n, si.Rational(3, 2), si.Rational(1, 2), r[0]) return self.prefactor(n) * (si.cos(r[0] / 2) * lala1 * ident + I * si.sin(r[0] / 2) * lala2 * sigma3)
def test_integralKernelPlus(self): ''' The idea in this test is to use the fact, that i know that if i add the diagonal terms, the imaginary parts cancel each other out and the real terms add up. That's the idea for this and the following 3 tests. Also this test is the most updated version. Here i do not use lambdify, because of simplify, the terms really cancel to zero. Befor that i didn't use simplify, so i had to use lambdify. I'm keeping the other tests the way they are, so that i just can check how i did this. There were some problems, i had to figure out and in future i maybe need to look it up.:) ''' n = 10 m = 10 listn = np.zeros(n, dtype=object) vals = np.zeros((n, m), dtype=object) for i in range(n): Plus0 = np.array(CFS_Action.integralKernelPlus( i + 1)) #, dtype = object).reshape(2,2) print(Plus0) listn[i] = sy.simplify( -2 * si.cos(r[0] / 2) * CFS_Action.prefactor(i) * JacPol(si.Rational(1, 2), si.Rational(3, 2), i) + Plus0[0, 0] + Plus0[1, 1]) for i in range(n): vals[i] = listn[i] print(vals) np.testing.assert_array_equal(listn, np.zeros(n), 10)
def rotation_matrix_from_axis_angle(axis, angle): """ Conversion of unit axis and angle to 4x4 rotation matrix according to: http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToMatrix/index.htm :param axis: 3x1 Matrix :type axis: Matrix :type angle: Union[float, Symbol] :return: 4x4 Matrix :rtype: Matrix """ ct = se.cos(angle) st = se.sin(angle) vt = 1 - ct m_vt_0 = vt * axis[0] m_vt_1 = vt * axis[1] m_vt_2 = vt * axis[2] m_st_0 = axis[0] * st m_st_1 = axis[1] * st m_st_2 = axis[2] * st m_vt_0_1 = m_vt_0 * axis[1] m_vt_0_2 = m_vt_0 * axis[2] m_vt_1_2 = m_vt_1 * axis[2] return se.Matrix( [[ct + m_vt_0 * axis[0], -m_st_2 + m_vt_0_1, m_st_1 + m_vt_0_2, 0], [m_st_2 + m_vt_0_1, ct + m_vt_1 * axis[1], -m_st_0 + m_vt_1_2, 0], [-m_st_1 + m_vt_0_2, m_st_0 + m_vt_1_2, ct + m_vt_2 * axis[2], 0], [0, 0, 0, 1]])
def axisangle2quat(axis_angle): qi, qj, qk = axis_angle mag = axisanglemagnitude(axis_angle) v = [qi / mag, qj / mag, qk / mag] sn = sin(mag / 2.0) return quatnormalize([cos(mag / 2.0), sn * v[0], sn * v[1], sn * v[2]])
def test_eval_double1(): x = Symbol("x") y = Symbol("y") e = sin(x)**2 + cos(x)**2 e = e.subs(x, 7) assert abs(e.n(real=True) - 1) < 1e-9 assert abs(e.n() - 1) < 1e-9
def test_cse_gh174(): x = se.symbols('x') funcs = [se.cos(x)**i for i in range(5)] f_lmb = se.Lambdify([x], funcs) f_cse = se.Lambdify([x], funcs, cse=True) a = np.array([1, 2, 3]) assert np.allclose(f_lmb(a), f_cse(a))
def axisanglerotationmatrix(axis_angle): R = axisanglemagnitude(axis_angle) x = Piecewise((axis_angle[0] / R, R > 0), (1, True)) y = Piecewise((axis_angle[1] / R, R > 0), (0, True)) z = Piecewise((axis_angle[2] / R, R > 0), (0, True)) csr = sp.cos(R) one_minus_csr = (1 - csr) snr = sp.sin(R) return sp.Matrix([[ csr + x * x * (1 - csr), x * y * one_minus_csr - z * snr, x * z * one_minus_csr + y * snr ], [ y * x * one_minus_csr + z * snr, csr + y * y * one_minus_csr, y * z * one_minus_csr - x * snr ], [ z * x * one_minus_csr - y * snr, z * y * one_minus_csr + x * snr, csr + z * z * one_minus_csr ]])
def test_conv7b(): x = sympy.Symbol("x") y = sympy.Symbol("y") assert sympify(sympy.sin(x / 3)) == sin(Symbol("x") / 3) assert sympify(sympy.sin(x / 3)) != cos(Symbol("x") / 3) assert sympify(sympy.cos(x / 3)) == cos(Symbol("x") / 3) assert sympify(sympy.tan(x / 3)) == tan(Symbol("x") / 3) assert sympify(sympy.cot(x / 3)) == cot(Symbol("x") / 3) assert sympify(sympy.csc(x / 3)) == csc(Symbol("x") / 3) assert sympify(sympy.sec(x / 3)) == sec(Symbol("x") / 3) assert sympify(sympy.asin(x / 3)) == asin(Symbol("x") / 3) assert sympify(sympy.acos(x / 3)) == acos(Symbol("x") / 3) assert sympify(sympy.atan(x / 3)) == atan(Symbol("x") / 3) assert sympify(sympy.acot(x / 3)) == acot(Symbol("x") / 3) assert sympify(sympy.acsc(x / 3)) == acsc(Symbol("x") / 3) assert sympify(sympy.asec(x / 3)) == asec(Symbol("x") / 3)
def axisanglerotationmatrix(axis_angle): R = axisanglemagnitude(axis_angle) x = axis_angle[0] / R y = axis_angle[1] / R z = axis_angle[2] / R csr = sp.cos(R) one_minus_csr = (1 - csr) snr = sp.sin(R) return sp.Matrix([[ csr + x * x * (1 - csr), x * y * one_minus_csr - z * snr, x * z * one_minus_csr + y * snr ], [ y * x * one_minus_csr + z * snr, csr + y * y * one_minus_csr, y * z * one_minus_csr - x * snr ], [ z * x * one_minus_csr - y * snr, z * y * one_minus_csr + x * snr, csr + z * z * one_minus_csr ]])
def test_conv7b(): x = sympy.Symbol("x") y = sympy.Symbol("y") assert sympify(sympy.sin(x/3)) == sin(Symbol("x") / 3) assert sympify(sympy.sin(x/3)) != cos(Symbol("x") / 3) assert sympify(sympy.cos(x/3)) == cos(Symbol("x") / 3) assert sympify(sympy.tan(x/3)) == tan(Symbol("x") / 3) assert sympify(sympy.cot(x/3)) == cot(Symbol("x") / 3) assert sympify(sympy.csc(x/3)) == csc(Symbol("x") / 3) assert sympify(sympy.sec(x/3)) == sec(Symbol("x") / 3) assert sympify(sympy.asin(x/3)) == asin(Symbol("x") / 3) assert sympify(sympy.acos(x/3)) == acos(Symbol("x") / 3) assert sympify(sympy.atan(x/3)) == atan(Symbol("x") / 3) assert sympify(sympy.acot(x/3)) == acot(Symbol("x") / 3) assert sympify(sympy.acsc(x/3)) == acsc(Symbol("x") / 3) assert sympify(sympy.asec(x/3)) == asec(Symbol("x") / 3)
def axisangle2quat(axis_angle): mag = axisanglemagnitude(axis_angle) x = axis_angle[0] / mag y = axis_angle[1] / mag z = axis_angle[2] / mag sn = sin(mag / 2.0) return quatnormalize([cos(mag / 2.0), sn * x, sn * y, sn * z])
def test_sin(): x = Symbol("x") y = Symbol("y") e = sin(x) assert e.subs({x: y}) == sin(y) assert e.subs({x: y}) != sin(x) e = cos(x) assert e.subs({x: 0}) == 1 assert e.subs(x, 0) == 1
def axisanglecompose(axis_angle, axis_angle2): a = axisanglemagnitude(axis_angle) ah = axisanglenormalize(axis_angle) b = axisanglemagnitude(axis_angle2) bh = axisanglenormalize(axis_angle2) sina = sin(a / 2) asina = [ah[0] * sina, ah[1] * sina, ah[2] * sina] sinb = sin(b / 2) bsinb = [bh[0] * sinb, bh[1] * sinb, bh[2] * sinb] c = 2 * acos(cos(a / 2)*cos(b / 2) - dot3d(asina, bsinb)) d = axisanglenormalize(cos(a / 2) * sp.Matrix(bsinb) + cos(b / 2) * sp.Matrix(asina) + cross3d(asina, bsinb)) return sp.Matrix([ c * d[0], c * d[1], c * d[2] ])
def test_abs(): x = Symbol("x") e = abs(x) assert e == abs(x) assert e != cos(x) assert abs(5) == 5 assert abs(-5) == 5 assert abs(Integer(5)/3) == Integer(5)/3 assert abs(-Integer(5)/3) == Integer(5)/3 assert abs(Integer(5)/3+x) != Integer(5)/3 assert abs(Integer(5)/3+x) == abs(Integer(5)/3+x)
def test_abs(): x = Symbol("x") e = abs(x) assert e == abs(x) assert e != cos(x) assert abs(5) == 5 assert abs(-5) == 5 assert abs(Integer(5) / 3) == Integer(5) / 3 assert abs(-Integer(5) / 3) == Integer(5) / 3 assert abs(Integer(5) / 3 + x) != Integer(5) / 3 assert abs(Integer(5) / 3 + x) == abs(Integer(5) / 3 + x)
def rotation_matrix_from_rpy(roll, pitch, yaw): """ Conversion of roll, pitch, yaw to 4x4 rotation matrix according to: https://github.com/orocos/orocos_kinematics_dynamics/blob/master/orocos_kdl/src/frames.cpp#L167 :type roll: Union[float, Symbol] :type pitch: Union[float, Symbol] :type yaw: Union[float, Symbol] :return: 4x4 Matrix :rtype: Matrix """ # TODO don't split this into 3 matrices rx = se.Matrix([[1, 0, 0, 0], [0, se.cos(roll), -se.sin(roll), 0], [0, se.sin(roll), se.cos(roll), 0], [0, 0, 0, 1]]) ry = se.Matrix([[se.cos(pitch), 0, se.sin(pitch), 0], [0, 1, 0, 0], [-se.sin(pitch), 0, se.cos(pitch), 0], [0, 0, 0, 1]]) rz = se.Matrix([[se.cos(yaw), -se.sin(yaw), 0, 0], [se.sin(yaw), se.cos(yaw), 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]) return (rz * ry * rx)
def _HSIN_(node, S1, S2): f = node.children[0].f_expression errList1 = [node.f_expression] + \ [seng.Abs(Si*seng.cos(f)) for Si in S1] errList2 = [seng.Abs(Si.seng.cos(f)) for Si in S2] herr = seng.Abs( seng.sin(f + sum([seng.Abs(Si * pow(2, -53)) for Si in S1 + S2])) * sum([seng.Abs(Si * Sj) for Si in S1 + S2 for Sj in S1 + S2])) return _solve_(node, errList1, errList2, herr)
def quaternion_from_axis_angle(axis, angle): """ :param axis: 3x1 Matrix :type axis: Matrix :type angle: Union[float, Symbol] :return: 4x1 Matrix :rtype: Matrix """ half_angle = angle / 2 return se.Matrix([axis[0] * se.sin(half_angle), axis[1] * se.sin(half_angle), axis[2] * se.sin(half_angle), se.cos(half_angle)])
def test_comparison(self): interval = (-3, 10) t = symengine.Symbol("t") spline = CubicHermiteSpline(n=2) spline.from_function( [symengine.sin(t), symengine.cos(t)], times_of_interest=interval, max_anchors=100, ) times = np.linspace(*interval, 100) evaluation = spline.get_state(times) control = np.vstack((np.sin(times), np.cos(times))).T assert_allclose(evaluation, control, atol=0.01)
def test_Lagrangian(self): """ This Test only works for N = 1, Rho=1. """ n = 10 LagVals = np.zeros(n) for i in range(n): KK = si.Rational(i, 1) CFS_Action.K_Liste[0] = KK Lag = CFS_Action.lagrangian_without_bound_constr() delta = 1 - KK**2 + (1 + KK**2) * sy.cos(r[0]) Res = si.pi**(-8) * 8 * (1 + KK**2) * si.cos(r[0] / 2)**2 * delta LagVals[i] = sy.simplify(Res - Lag) np.testing.assert_array_equal(LagVals, np.zeros(n))
def rotation3_rpy(roll, pitch, yaw): """ Conversion of roll, pitch, yaw to 4x4 rotation matrix according to: https://github.com/orocos/orocos_kinematics_dynamics/blob/master/orocos_kdl/src/frames.cpp#L167 """ rx = sp.Matrix([[1, 0, 0, 0], [0, sp.cos(roll), -sp.sin(roll), 0], [0, sp.sin(roll), sp.cos(roll), 0], [0, 0, 0, 1]]) ry = sp.Matrix([[sp.cos(pitch), 0, sp.sin(pitch), 0], [0, 1, 0, 0], [-sp.sin(pitch), 0, sp.cos(pitch), 0], [0, 0, 0, 1]]) rz = sp.Matrix([[sp.cos(yaw), -sp.sin(yaw), 0, 0], [sp.sin(yaw), sp.cos(yaw), 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]) return (rz * ry * rx)
def rotation3_axis_angle(axis, angle): """ Conversion of unit axis and angle to 4x4 rotation matrix according to: http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToMatrix/index.htm """ ct = sp.cos(angle) st = sp.sin(angle) vt = 1 - ct m_vt_0 = vt * axis[0] m_vt_1 = vt * axis[1] m_vt_2 = vt * axis[2] m_st_0 = axis[0] * st m_st_1 = axis[1] * st m_st_2 = axis[2] * st m_vt_0_1 = m_vt_0 * axis[1] m_vt_0_2 = m_vt_0 * axis[2] m_vt_1_2 = m_vt_1 * axis[2] return sp.Matrix( [[ct + m_vt_0 * axis[0], -m_st_2 + m_vt_0_1, m_st_1 + m_vt_0_2, 0], [m_st_2 + m_vt_0_1, ct + m_vt_1 * axis[1], -m_st_0 + m_vt_1_2, 0], [-m_st_1 + m_vt_0_2, m_st_0 + m_vt_1_2, ct + m_vt_2 * axis[2], 0], [0, 0, 0, 1]])
def spherical_harmonics(lmax): """Symbolic real spherical harmonics up to order lmax. .. code-block:: python sh = spherical_harmonics(6) # Inclusive, so computes up to l = 6 sh[3][-3] # symbolic f-phi angular function Args: lmax (int): highest order angular momentum quantum number """ phase = {m: (-1)**m for m in range(lmax + 1)} facts = {n: fac(n) for n in range(2 * lmax + 1)} sh = OrderedDict() for L in range(lmax + 1): sh[L] = OrderedDict() rac = ((2 * L + 1) / (4 * np.pi))**0.5 der = (_x**2 - 1)**L den = 2**L * facts[L] for _ in range(L): der = der.diff(_x) for m in range(L + 1): pol = (1 - _x**2)**(m / 2) if m: der = der.diff(_x) leg = phase[m] / den * (pol * der).subs({_x: _z / _r}) if not m: sh[L][m] = rac * leg continue N = 2**0.5 * phase[m] facs = facts[L - m] / facts[L + m] norm = facs**0.5 phi = (m * _x).subs({_x: 'arctan2(_y, _x)'}) fun = cos(phi) sh[L][m] = N * rac * norm * leg * fun fun = sin(phi) sh[L][-m] = N * rac * norm * leg * fun return sh
def spherical_harmonics(lmax): """Symbolic real spherical harmonics up to order lmax. .. code-block:: python sh = spherical_harmonics(6) # Inclusive, so computes up to l = 6 sh[3][-3] # symbolic f-phi angular function Args: lmax (int): highest order angular momentum quantum number """ phase = {m: (-1) ** m for m in range(lmax + 1)} facts = {n: fac(n) for n in range(2 * lmax + 1)} sh = OrderedDict() for L in range(lmax + 1): sh[L] = OrderedDict() rac = ((2 * L + 1) / (4 * np.pi)) ** 0.5 der = (_x ** 2 - 1) ** L den = 2 ** L * facts[L] for _ in range(L): der = der.diff(_x) for m in range(L + 1): pol = (1 - _x ** 2) ** (m/2) if m: der = der.diff(_x) leg = phase[m] / den * (pol * der).subs({_x: _z / _r}) if not m: sh[L][m] = rac * leg continue N = 2 ** 0.5 * phase[m] facs = facts[L - m] / facts[L + m] norm = facs ** 0.5 phi = (m * _x).subs({_x: 'arctan2(_y, _x)'}) fun = cos(phi) sh[L][m] = N * rac * norm * leg * fun fun = sin(phi) sh[L][-m] = N * rac * norm * leg * fun return sh
def test_sage_conversions(): try: import sage.all as sage except ImportError: return x, y = sage.SR.var('x y') x1, y1 = symbols('x, y') # Symbol assert x1._sage_() == x assert x1 == sympify(x) # Integer assert Integer(12)._sage_() == sage.Integer(12) assert Integer(12) == sympify(sage.Integer(12)) # Rational assert (Integer(1) / 2)._sage_() == sage.Integer(1) / 2 assert Integer(1) / 2 == sympify(sage.Integer(1) / 2) # Operators assert x1 + y == x1 + y1 assert x1 * y == x1 * y1 assert x1 ** y == x1 ** y1 assert x1 - y == x1 - y1 assert x1 / y == x1 / y1 assert x + y1 == x + y assert x * y1 == x * y # Doesn't work in Sage 6.1.1ubuntu2 # assert x ** y1 == x ** y assert x - y1 == x - y assert x / y1 == x / y # Conversions assert (x1 + y1)._sage_() == x + y assert (x1 * y1)._sage_() == x * y assert (x1 ** y1)._sage_() == x ** y assert (x1 - y1)._sage_() == x - y assert (x1 / y1)._sage_() == x / y assert x1 + y1 == sympify(x + y) assert x1 * y1 == sympify(x * y) assert x1 ** y1 == sympify(x ** y) assert x1 - y1 == sympify(x - y) assert x1 / y1 == sympify(x / y) # Functions assert sin(x1) == sin(x) assert sin(x1)._sage_() == sage.sin(x) assert sin(x1) == sympify(sage.sin(x)) assert cos(x1) == cos(x) assert cos(x1)._sage_() == sage.cos(x) assert cos(x1) == sympify(sage.cos(x)) assert function_symbol('f', x1, y1)._sage_() == sage.function('f', x, y) assert function_symbol('f', 2 * x1, x1 + y1).diff(x1)._sage_() == sage.function('f', 2 * x, x + y).diff(x) # For the following test, sage needs to be modified # assert sage.sin(x) == sage.sin(x1) # Constants assert pi._sage_() == sage.pi assert E._sage_() == sage.e assert I._sage_() == sage.I assert pi == sympify(sage.pi) assert E == sympify(sage.e) # SympyConverter does not support converting the following # assert I == sympify(sage.I) # Matrix assert DenseMatrix(1, 2, [x1, y1])._sage_() == sage.matrix([[x, y]]) # SympyConverter does not support converting the following # assert DenseMatrix(1, 2, [x1, y1]) == sympify(sage.matrix([[x, y]])) # Sage Number a = sage.Mod(2, 7) b = PyNumber(a, sage_module) a = a + 8 b = b + 8 assert isinstance(b, PyNumber) assert b._sage_() == a a = a + x b = b + x assert isinstance(b, Add) assert b._sage_() == a # Sage Function e = x1 + wrap_sage_function(sage.log_gamma(x)) assert str(e) == "x + log_gamma(x)" assert isinstance(e, Add) assert e + wrap_sage_function(sage.log_gamma(x)) == x1 + 2*wrap_sage_function(sage.log_gamma(x)) f = e.subs({x1 : 10}) assert f == 10 + log(362880) f = e.subs({x1 : 2}) assert f == 2 f = e.subs({x1 : 100}); v = f.n(53, real=True); assert abs(float(v) - 459.13420537) < 1e-7 f = e.diff(x1)
def test_sage_conversions(): try: import sage.all as sage except ImportError: return x, y = sage.SR.var('x y') x1, y1 = symbols('x, y') # Symbol assert x1._sage_() == x assert x1 == sympify(x) # Integer assert Integer(12)._sage_() == sage.Integer(12) assert Integer(12) == sympify(sage.Integer(12)) # Rational assert (Integer(1) / 2)._sage_() == sage.Integer(1) / 2 assert Integer(1) / 2 == sympify(sage.Integer(1) / 2) # Operators assert x1 + y == x1 + y1 assert x1 * y == x1 * y1 assert x1**y == x1**y1 assert x1 - y == x1 - y1 assert x1 / y == x1 / y1 assert x + y1 == x + y assert x * y1 == x * y # Doesn't work in Sage 6.1.1ubuntu2 # assert x ** y1 == x ** y assert x - y1 == x - y assert x / y1 == x / y # Conversions assert (x1 + y1)._sage_() == x + y assert (x1 * y1)._sage_() == x * y assert (x1**y1)._sage_() == x**y assert (x1 - y1)._sage_() == x - y assert (x1 / y1)._sage_() == x / y assert x1 + y1 == sympify(x + y) assert x1 * y1 == sympify(x * y) assert x1**y1 == sympify(x**y) assert x1 - y1 == sympify(x - y) assert x1 / y1 == sympify(x / y) # Functions assert sin(x1) == sin(x) assert sin(x1)._sage_() == sage.sin(x) assert sin(x1) == sympify(sage.sin(x)) assert cos(x1) == cos(x) assert cos(x1)._sage_() == sage.cos(x) assert cos(x1) == sympify(sage.cos(x)) assert function_symbol('f', x1, y1)._sage_() == sage.function('f', x, y) assert function_symbol('f', 2 * x1, x1 + y1).diff(x1)._sage_() == sage.function( 'f', 2 * x, x + y).diff(x) # For the following test, sage needs to be modified # assert sage.sin(x) == sage.sin(x1) # Constants assert pi._sage_() == sage.pi assert E._sage_() == sage.e assert I._sage_() == sage.I assert pi == sympify(sage.pi) assert E == sympify(sage.e) # SympyConverter does not support converting the following # assert I == sympify(sage.I) # Matrix assert DenseMatrix(1, 2, [x1, y1])._sage_() == sage.matrix([[x, y]]) # SympyConverter does not support converting the following # assert DenseMatrix(1, 2, [x1, y1]) == sympify(sage.matrix([[x, y]])) # Sage Number a = sage.Mod(2, 7) b = PyNumber(a, sage_module) a = a + 8 b = b + 8 assert isinstance(b, PyNumber) assert b._sage_() == a a = a + x b = b + x assert isinstance(b, Add) assert b._sage_() == a # Sage Function e = x1 + wrap_sage_function(sage.log_gamma(x)) assert str(e) == "x + log_gamma(x)" assert isinstance(e, Add) assert e + wrap_sage_function( sage.log_gamma(x)) == x1 + 2 * wrap_sage_function(sage.log_gamma(x)) f = e.subs({x1: 10}) assert f == 10 + log(362880) f = e.subs({x1: 2}) assert f == 2 f = e.subs({x1: 100}) v = f.n(53, real=True) assert abs(float(v) - 459.13420537) < 1e-7 f = e.diff(x1)
def test_args(): x = Symbol("x") e = cos(x) raises(TypeError, lambda: e.subs(x, 0, 3))
def test_eval_double2(): x = Symbol("x") y = Symbol("y") e = sin(x)**2 + cos(x)**2 raises(RuntimeError, lambda: (abs(eval_double(e) - 1) < 1e-9))
def test_eval_double1(): x = Symbol("x") y = Symbol("y") e = sin(x)**2 + cos(x)**2 e = e.subs(x, 7) assert abs(eval_double(e) - 1) < 1e-9
def test_sage_conversions(): try: import sage.all as sage except ImportError: return x, y = sage.SR.var('x y') x1, y1 = symbols('x, y') # Symbol assert x1._sage_() == x assert x1 == sympify(x) # Integer assert Integer(12)._sage_() == sage.Integer(12) assert Integer(12) == sympify(sage.Integer(12)) # Rational assert (Integer(1) / 2)._sage_() == sage.Integer(1) / 2 assert Integer(1) / 2 == sympify(sage.Integer(1) / 2) # Operators assert x1 + y == x1 + y1 assert x1 * y == x1 * y1 assert x1 ** y == x1 ** y1 assert x1 - y == x1 - y1 assert x1 / y == x1 / y1 assert x + y1 == x + y assert x * y1 == x * y # Doesn't work in Sage 6.1.1ubuntu2 # assert x ** y1 == x ** y assert x - y1 == x - y assert x / y1 == x / y # Conversions assert (x1 + y1)._sage_() == x + y assert (x1 * y1)._sage_() == x * y assert (x1 ** y1)._sage_() == x ** y assert (x1 - y1)._sage_() == x - y assert (x1 / y1)._sage_() == x / y assert x1 + y1 == sympify(x + y) assert x1 * y1 == sympify(x * y) assert x1 ** y1 == sympify(x ** y) assert x1 - y1 == sympify(x - y) assert x1 / y1 == sympify(x / y) # Functions assert sin(x1) == sin(x) assert sin(x1)._sage_() == sage.sin(x) assert sin(x1) == sympify(sage.sin(x)) assert cos(x1) == cos(x) assert cos(x1)._sage_() == sage.cos(x) assert cos(x1) == sympify(sage.cos(x)) assert function_symbol('f', x1, y1)._sage_() == sage.function('f', x, y) assert function_symbol('f', 2 * x1, x1 + y1).diff(x1)._sage_() == sage.function('f', 2 * x, x + y).diff(x) # For the following test, sage needs to be modified # assert sage.sin(x) == sage.sin(x1) # Constants assert pi._sage_() == sage.pi assert E._sage_() == sage.e assert I._sage_() == sage.I assert pi == sympify(sage.pi) assert E == sympify(sage.e) # SympyConverter does not support converting the following # assert I == sympify(sage.I) # Matrix assert DenseMatrix(1, 2, [x1, y1])._sage_() == sage.matrix([[x, y]])
def test_xreplace(): x = Symbol("x") y = Symbol("y") f = sin(cos(x)) assert f.xreplace({x: y}) == sin(cos(y))
def test_conv7(): x = Symbol("x") y = Symbol("y") assert sin(x/3)._sympy_() == sympy.sin(sympy.Symbol("x") / 3) assert sin(x/3)._sympy_() != sympy.cos(sympy.Symbol("x") / 3) assert cos(x/3)._sympy_() == sympy.cos(sympy.Symbol("x") / 3)
def test_conv7b(): x = sympy.Symbol("x") y = sympy.Symbol("y") assert sympify(sympy.sin(x/3)) == sin(Symbol("x") / 3) assert sympify(sympy.sin(x/3)) != cos(Symbol("x") / 3) assert sympify(sympy.cos(x/3)) == cos(Symbol("x") / 3)