def transform_rec(expr):
op = expr.operator()
operands = expr.operands()
if op:
new_op = []
for operand in operands:
new_op.append(transform_rec(operand))
if str(op)=='<built-in function pow>':
return function('pow')(*new_op)
else:
return op(*new_op)
else:
return expr
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():
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))
assert LambertW(x1) == LambertW(x)
assert LambertW(x1)._sage_() == sage.lambert_w(x)
assert KroneckerDelta(x1, y1) == KroneckerDelta(x, y)
assert KroneckerDelta(x1, y1)._sage_() == sage.kronecker_delta(x, y)
assert erf(x1) == erf(x)
assert erf(x1)._sage_() == sage.erf(x)
assert lowergamma(x1, y1) == lowergamma(x, y)
assert lowergamma(x1, y1)._sage_() == sage.gamma_inc_lower(x, y)
assert uppergamma(x1, y1) == uppergamma(x, y)
assert uppergamma(x1, y1)._sage_() == sage.gamma_inc(x, y)
assert loggamma(x1) == loggamma(x)
assert loggamma(x1)._sage_() == sage.log_gamma(x)
assert beta(x1, y1) == beta(x, y)
assert beta(x1, y1)._sage_() == sage.beta(x, y)
assert floor(x1) == floor(x)
assert floor(x1)._sage_() == sage.floor(x)
assert ceiling(x1) == ceiling(x)
assert ceiling(x1)._sage_() == sage.ceil(x)
assert conjugate(x1) == conjugate(x)
assert conjugate(x1)._sage_() == sage.conjugate(x)
# For the following test, sage needs to be modified
# assert sage.sin(x) == sage.sin(x1)
# Constants and Booleans
assert pi._sage_() == sage.pi
assert E._sage_() == sage.e
assert I._sage_() == sage.I
assert GoldenRatio._sage_() == sage.golden_ratio
assert Catalan._sage_() == sage.catalan
assert EulerGamma._sage_() == sage.euler_gamma
assert oo._sage_() == sage.oo
assert zoo._sage_() == sage.unsigned_infinity
assert nan._sage_() == sage.NaN
assert true._sage_() == True
assert false._sage_() == False
assert pi == sympify(sage.pi)
assert E == sympify(sage.e)
assert GoldenRatio == sympify(sage.golden_ratio)
assert Catalan == sympify(sage.catalan)
assert EulerGamma == sympify(sage.euler_gamma)
assert oo == sympify(sage.oo)
assert zoo == sympify(sage.unsigned_infinity)
assert nan == sympify(sage.NaN)
# 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
assert str(a) == str(b)
# 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_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 _gensymbols(self, usefricdyn=True) :
self.t = var('t',domain=RR)
self.q = matrix(SR,self.dof,1 )
self.dq = matrix(SR,self.dof,1 )
self.ddq = matrix(SR,self.dof,1 )
for i in range(1 ,self.dof+1 ):
self.q[i-1 ] = var('q'+str(i),domain=RR)
self.dq[i-1 ] = var('dq'+str(i),latex_name=r'\dot{q}_'+str(i),domain=RR)
self.ddq[i-1 ] = var('ddq'+str(i),latex_name=r'\ddot{q}_'+str(i),domain=RR)
self.qt = matrix(SR,self.dof,1 )
for i in range(1 ,self.dof+1 ):
self.qt[i-1 ,0 ] = function('q'+str(i)+'t',t,latex_name=r'q_'+str(i))
self.LoP_trig_f2v = []
for i in range(1 ,self.dof+1 ):
self.LoP_trig_f2v.append( ( cos(self.q[i-1 ,0 ]) , var('c'+str(i),domain=RR) ) )
self.LoP_trig_f2v.append( ( sin(self.q[i-1 ,0 ]) , var('s'+str(i),domain=RR) ) )
self.LoP_trig_v2f = zip(zip(*self.LoP_trig_f2v)[1],zip(*self.LoP_trig_f2v)[0])
self.D_q_v2f={} ; self.D_q_f2v={}
for i in range(0 ,self.dof):
self.D_q_v2f.update( { self.q[i,0 ]:self.qt[i,0 ], self.dq[i,0 ]:self.qt[i,0 ].derivative(t), self.ddq[i,0 ]:self.qt[i,0 ].derivative(t,2 ) } )
self.D_q_f2v.update( { self.qt[i,0 ]:self.q[i,0 ], self.qt[i,0 ].derivative(t):self.dq[i,0 ], self.qt[i,0 ].derivative(t,2 ):self.ddq[i,0 ] } )
self.mi = range(0 ,self.dof+1 )
self.li = range(0 ,self.dof+1 )
self.fvi = range(0 ,self.dof+1 )
self.fci = range(0 ,self.dof+1 )
self.Ici = range(0 ,self.dof+1 )
self.Ifi = range(0 ,self.dof+1 )
self.Ici_from_Ifi = range(0 ,self.dof+1 )
self.Ifi_from_Ici = range(0 ,self.dof+1 )
self.LoP_Ii_c2f = []
self.LoP_Ii_f2c = []
self.mli = range(0 ,self.dof+1 )
self.mli_e = range(0 ,self.dof+1 )
self.LoP_mli_v2e = []
self.D_mli_v2e = {}
for i in range(1 ,self.dof+1 ):
self.mi[i] = var('m'+str(i),domain=RR)
self.fvi[i] = var('fv'+str(i),latex_name=r'{fv}_{'+str(i)+'}',domain=RR)
self.fci[i] = var('fc'+str(i),latex_name=r'{fc}_{'+str(i)+'}',domain=RR)
aux1 = var('l_'+str(i)+'x',latex_name=r'l_{'+str(i)+',x}',domain=RR)
aux2 = var('l_'+str(i)+'y',latex_name=r'l_{'+str(i)+',y}',domain=RR)
aux3 = var('l_'+str(i)+'z',latex_name=r'l_{'+str(i)+',z}',domain=RR)
self.li[i] = matrix([[aux1],[aux2],[aux3]])
aux1 = var('ml_'+str(i)+'x',latex_name=r'\widehat{m_'+str(i)+'l_{'+str(i)+',x}}',domain=RR)
aux2 = var('ml_'+str(i)+'y',latex_name=r'\widehat{m_'+str(i)+'l_{'+str(i)+',y}}',domain=RR)
aux3 = var('ml_'+str(i)+'z',latex_name=r'\widehat{m_'+str(i)+'l_{'+str(i)+',z}}',domain=RR)
self.mli[i] = matrix([[aux1],[aux2],[aux3]])
self.mli_e[i] = self.mi[i] * self.li[i]
self.LoP_mli_v2e.append( ( self.mli[i][0 ,0 ] , self.mli_e[i][0 ,0 ] ) )
self.LoP_mli_v2e.append( ( self.mli[i][1 ,0 ] , self.mli_e[i][1 ,0 ] ) )
self.LoP_mli_v2e.append( ( self.mli[i][2 ,0 ] , self.mli_e[i][2 ,0 ] ) )
auxIcxx = var('I_'+str(i)+'xx',latex_name=r'I_{'+str(i)+',xx}',domain=RR)
auxIcyy = var('I_'+str(i)+'yy',latex_name=r'I_{'+str(i)+',yy}',domain=RR)
auxIczz = var('I_'+str(i)+'zz',latex_name=r'I_{'+str(i)+',zz}',domain=RR)
auxIcxy = var('I_'+str(i)+'xy',latex_name=r'I_{'+str(i)+',xy}',domain=RR)
auxIcxz = var('I_'+str(i)+'xz',latex_name=r'I_{'+str(i)+',xz}',domain=RR)
auxIcyz = var('I_'+str(i)+'yz',latex_name=r'I_{'+str(i)+',yz}',domain=RR)
self.Ici[i] = matrix([[auxIcxx,auxIcxy,auxIcxz],[auxIcxy,auxIcyy,auxIcyz],[auxIcxz,auxIcyz,auxIczz]])
auxIfxx = var('If_'+str(i)+'xx',latex_name=r'\hat{I}_{'+str(i)+',xx}',domain=RR)
auxIfyy = var('If_'+str(i)+'yy',latex_name=r'\hat{I}_{'+str(i)+',yy}',domain=RR)
auxIfzz = var('If_'+str(i)+'zz',latex_name=r'\hat{I}_{'+str(i)+',zz}',domain=RR)
auxIfxy = var('If_'+str(i)+'xy',latex_name=r'\hat{I}_{'+str(i)+',xy}',domain=RR)
auxIfxz = var('If_'+str(i)+'xz',latex_name=r'\hat{I}_{'+str(i)+',xz}',domain=RR)
auxIfyz = var('If_'+str(i)+'yz',latex_name=r'\hat{I}_{'+str(i)+',yz}',domain=RR)
self.Ifi[i] = matrix([[auxIfxx,auxIfxy,auxIfxz],[auxIfxy,auxIfyy,auxIfyz],[auxIfxz,auxIfyz,auxIfzz]])
self.Ifi_from_Ici[i] = self.Ici[i] + self.mi[i] * utils.skew(self.li[i]).transpose() * utils.skew(self.li[i])
self.Ici_from_Ifi[i] = self.Ifi[i] - self.mi[i] * utils.skew(self.li[i]).transpose() * utils.skew(self.li[i])
for e in [(a,b) for a in range(3) for b in range (3)]:
self.LoP_Ii_f2c.append( ( self.Ifi[i][e] , self.Ifi_from_Ici[i][e] ) )
self.LoP_Ii_c2f.append( ( self.Ici[i][e] , self.Ici_from_Ifi[i][e] ) )
self.D_mli_v2e = utils.LoP_to_D( self.LoP_mli_v2e )
self.D_Ii_f2c = utils.LoP_to_D( self.LoP_Ii_f2c )
self.D_Ii_c2f = utils.LoP_to_D( self.LoP_Ii_c2f )
self.D_parm_lin2elem = utils.LoP_to_D( self.LoP_mli_v2e + self.LoP_Ii_f2c )
Pi = [ matrix([ self.mi[i], self.mli[i][0,0], self.mli[i][1,0], self.mli[i][2,0], self.Ifi[i][0,0], self.Ifi[i][0,1], self.Ifi[i][0,2], self.Ifi[i][1,1], self.Ifi[i][1,2], self.Ifi[i][2,2] ] ).transpose() for i in range(1,self.dof+1) ]
return self