Hide keyboard shortcuts

Hot-keys on this page

r m x p   toggle line displays

j k   next/prev highlighted chunk

0   (zero) top of page

1   (one) first highlighted chunk

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

# -*- coding: utf-8 -*- 

r""" 

A Sample Session using SymPy 

 

In this first part, we do all of the examples in the SymPy tutorial 

(https://github.com/sympy/sympy/wiki/Tutorial), but using Sage 

instead of SymPy. 

 

:: 

 

sage: a = Rational((1,2)) 

sage: a 

1/2 

sage: a*2 

1 

sage: Rational(2)^50 / Rational(10)^50 

1/88817841970012523233890533447265625 

sage: 1.0/2 

0.500000000000000 

sage: 1/2 

1/2 

sage: pi^2 

pi^2 

sage: float(pi) 

3.141592653589793 

sage: RealField(200)(pi) 

3.1415926535897932384626433832795028841971693993751058209749 

sage: float(pi + exp(1)) 

5.85987448204883... 

sage: oo != 2 

True 

 

:: 

 

sage: var('x y') 

(x, y) 

sage: x + y + x - y 

2*x 

sage: (x+y)^2 

(x + y)^2 

sage: ((x+y)^2).expand() 

x^2 + 2*x*y + y^2 

sage: ((x+y)^2).subs(x=1) 

(y + 1)^2 

sage: ((x+y)^2).subs(x=y) 

4*y^2 

 

:: 

 

sage: limit(sin(x)/x, x=0) 

1 

sage: limit(x, x=oo) 

+Infinity 

sage: limit((5^x + 3^x)^(1/x), x=oo) 

5 

 

:: 

 

sage: diff(sin(x), x) 

cos(x) 

sage: diff(sin(2*x), x) 

2*cos(2*x) 

sage: diff(tan(x), x) 

tan(x)^2 + 1 

sage: limit((tan(x+y) - tan(x))/y, y=0) 

cos(x)^(-2) 

sage: diff(sin(2*x), x, 1) 

2*cos(2*x) 

sage: diff(sin(2*x), x, 2) 

-4*sin(2*x) 

sage: diff(sin(2*x), x, 3) 

-8*cos(2*x) 

 

:: 

 

sage: cos(x).taylor(x,0,10) 

-1/3628800*x^10 + 1/40320*x^8 - 1/720*x^6 + 1/24*x^4 - 1/2*x^2 + 1 

sage: (1/cos(x)).taylor(x,0,10) 

50521/3628800*x^10 + 277/8064*x^8 + 61/720*x^6 + 5/24*x^4 + 1/2*x^2 + 1 

 

:: 

 

sage: matrix([[1,0], [0,1]]) 

[1 0] 

[0 1] 

sage: var('x y') 

(x, y) 

sage: A = matrix([[1,x], [y,1]]) 

sage: A 

[1 x] 

[y 1] 

sage: A^2 

[x*y + 1 2*x] 

[ 2*y x*y + 1] 

sage: R.<x,y> = QQ[] 

sage: A = matrix([[1,x], [y,1]]) 

sage: A^10 

[x^5*y^5 + 45*x^4*y^4 + 210*x^3*y^3 + 210*x^2*y^2 + 45*x*y + 1 10*x^5*y^4 + 120*x^4*y^3 + 252*x^3*y^2 + 120*x^2*y + 10*x] 

[ 10*x^4*y^5 + 120*x^3*y^4 + 252*x^2*y^3 + 120*x*y^2 + 10*y x^5*y^5 + 45*x^4*y^4 + 210*x^3*y^3 + 210*x^2*y^2 + 45*x*y + 1] 

sage: var('x y') 

(x, y) 

 

And here are some actual tests of sympy:: 

 

sage: from sympy import Symbol, cos, sympify, pprint 

sage: from sympy.abc import x 

 

:: 

 

sage: e = (1/cos(x)^3)._sympy_(); e 

cos(x)**(-3) 

sage: f = e.series(x, 0, 10); f 

1 + 3*x**2/2 + 11*x**4/8 + 241*x**6/240 + 8651*x**8/13440 + O(x**10) 

 

And the pretty-printer. Since unicode characters are not working on 

some architectures, we disable it:: 

 

sage: from sympy.printing import pprint_use_unicode 

sage: prev_use = pprint_use_unicode(False) 

sage: pprint(e) 

1 

------- 

3 

cos (x) 

 

sage: pprint(f) 

2 4 6 8 

3*x 11*x 241*x 8651*x / 10\ 

1 + ---- + ----- + ------ + ------- + O\x / 

2 8 240 13440 

sage: pprint_use_unicode(prev_use) 

False 

 

And the functionality to convert from sympy format to Sage format:: 

 

sage: e._sage_() 

cos(x)^(-3) 

sage: e._sage_().taylor(x._sage_(), 0, 8) 

8651/13440*x^8 + 241/240*x^6 + 11/8*x^4 + 3/2*x^2 + 1 

sage: f._sage_() 

8651/13440*x^8 + 241/240*x^6 + 11/8*x^4 + 3/2*x^2 + Order(x^10) + 1 

 

Mixing SymPy with Sage:: 

 

sage: import sympy 

sage: var("x")._sympy_() + var("y")._sympy_() 

x + y 

sage: o = var("omega") 

sage: s = sympy.Symbol("x") 

sage: t1 = s + o 

sage: t2 = o + s 

sage: type(t1) 

<class 'sympy.core.add.Add'> 

sage: type(t2) 

<type 'sage.symbolic.expression.Expression'> 

sage: t1, t2 

(omega + x, omega + x) 

sage: e=sympy.sin(var("y"))+sage.all.cos(sympy.Symbol("x")) 

sage: type(e) 

<class 'sympy.core.add.Add'> 

sage: e 

sin(y) + cos(x) 

sage: e=e._sage_() 

sage: type(e) 

<type 'sage.symbolic.expression.Expression'> 

sage: e 

cos(x) + sin(y) 

sage: e = sage.all.cos(var("y")**3)**4+var("x")**2 

sage: e = e._sympy_() 

sage: e 

x**2 + cos(y**3)**4 

 

:: 

 

sage: a = sympy.Matrix([1, 2, 3]) 

sage: a[1] 

2 

 

:: 

 

sage: sympify(1.5) 

1.50000000000000 

sage: sympify(2) 

2 

sage: sympify(-2) 

-2 

 

TESTS: 

 

This was fixed in Sympy, see :trac:`14437`:: 

 

sage: from sympy import Function, Symbol, rsolve 

sage: u = Function('u') 

sage: n = Symbol('n', integer=True) 

sage: f = u(n+2) - u(n+1) + u(n)/4 

sage: rsolve(f,u(n)) 

2**(-n)*(C0 + C1*n) 

 

"""