def _print_Function(self, expr):
# All constant function args are evaluated as floats
prec = self._settings['precision']
args = [N(a, prec) for a in expr.args]
eval_expr = expr.func(*args)
if not isinstance(eval_expr, Function):
return self._print(eval_expr)
else:
return CodePrinter._print_Function(self, expr.func(*args))
def _eval(self, n, k):
# n.is_Number and k.is_Integer and k != 1 and n != k
from sympy.functions.elementary.exponential import log
from sympy.core import N
if k.is_Integer:
if n.is_Integer and n >= 0:
n, k = int(n), int(k)
if k > n:
return S.Zero
elif k > n // 2:
k = n - k
if HAS_GMPY:
from sympy.core.compatibility import gmpy
return Integer(gmpy.bincoef(n, k))
prime_count_estimate = N(n / log(n))
# if the number of primes less than n is less than k, use prime sieve method
# otherwise it is more memory efficient to compute factorials explicitly
if prime_count_estimate < k:
M, result = int(_sqrt(n)), 1
for prime in sieve.primerange(2, n + 1):
if prime > n - k:
result *= prime
elif prime > n // 2:
continue
elif prime > M:
if n % prime < k % prime:
result *= prime
else:
N, K = n, k
exp = a = 0
while N > 0:
a = int((N % prime) < (K % prime + a))
N, K = N // prime, K // prime
exp = a + exp
if exp > 0:
result *= prime**exp
else:
result = ff(n, k) / factorial(k)
return Integer(result)
else:
d = result = n - k + 1
for i in range(2, k + 1):
d += 1
result *= d
result /= i
return result
def pretty(self,item):
if self.mode==0: return str(item)
elif item.__class__ == Point2D:
return 'Point2D(' + self.pretty(item.x) + ", " + self.pretty(item.y) + ")"
elif item.__class__ == Line:
return 'Line(' + self.pretty(item.p1) + ", " + self.pretty(item.p2)+")"
elif item.__class__ == Circle:
return 'Circle(' + self.pretty(item.center) + ", " + self.pretty(item.radius) + ")"
elif item.__class__ == Triangle:
a,b,c = item.vertices
return 'Triangle(' + self.pretty(a) + ', ' + self.pretty(b) + ', ' + self.pretty(c) + ')'
else:
return self.removeZeros(str(N(item,n=7)))
def sketch(self):
self.lookup = {}
# spara först alla punkter
for key in self.defs:
obj = self.defs[key]
klassnamn = obj.__class__.__name__
if klassnamn=='Point2D':
print key + " = punkt("+"'"+key+"',"+str(N(obj.x,6))+","+str(N(obj.y,6))+")"
self.lookup[obj] = key
# därefter hanteras övriga objekt
for key in self.defs:
obj = self.defs[key]
klassnamn = obj.__class__.__name__
if klassnamn=='Line':
print 'linje("' + key +'",'+ self.findpoint(obj.p1) + "," + self.findpoint(obj.p2) + ')'
elif klassnamn=='Circle':
print 'cirkel(' + self.findpoint(obj.center) + ',' + str(N(obj.radius,6))+')'
elif klassnamn=='Triangle':
a,b,c = obj.vertices
print 'triangel(' + self.findpoint(a) + ',' + self.findpoint(b) + ',' + self.findpoint(c) + ')'
def test_issue_2993():
x = Symbol("x")
assert str((2.3 * x - 4)**0.3) == "1.5157165665104*(0.575*x - 1)**0.3"
assert str((2.3 * x + 4)**0.3) == "1.5157165665104*(0.575*x + 1)**0.3"
assert str((-2.3 * x + 4)**0.3) == "1.5157165665104*(1 - 0.575*x)**0.3"
assert str((-2.3 * x - 4)**0.3) == "1.5157165665104*(-0.575*x - 1)**0.3"
assert str(
(2.3 * x - 2)**0.3) == "1.28386201800527*(x - 0.869565217391304)**0.3"
assert (str((-2.3 * x -
2)**0.3) == "1.28386201800527*(-x - 0.869565217391304)**0.3")
assert str(
(-2.3 * x + 2)**0.3) == "1.28386201800527*(0.869565217391304 - x)**0.3"
assert str(
(2.3 * x + 2)**0.3) == "1.28386201800527*(x + 0.869565217391304)**0.3"
assert str((2.3 * x - 4)**Rational(1,
3)) == "2**(2/3)*(0.575*x - 1)**(1/3)"
eq = 2.3 * x + 4
assert eq**2 == 16 * (0.575 * x + 1)**2
assert (1 / eq).args == (eq, -1) # don't change trivial power
# issue 17735
q = 0.5 * exp(x) - 0.5 * exp(-x) + 0.1
assert int((q**2).subs(x, 1)) == 1
# issue 17756
y = Symbol("y")
assert (len(
sqrt(x / (x + y)**2 + Float("0.008", 30)).subs(
y, pi.n(25)).atoms(Float)) == 2)
# issue 17756
a, b, c, d, e, f, g = symbols("a:g")
expr = (sqrt(1 + a * (c**4 + g * d - 2 * g * e - f * (-g + d))**2 /
(c**3 * b**2 * (d - 3 * e + 2 * f)**2)) / 2)
r = [
(a, N("0.0170992456333788667034850458615", 30)),
(b, N("0.0966594956075474769169134801223", 30)),
(c, N("0.390911862903463913632151616184", 30)),
(d, N("0.152812084558656566271750185933", 30)),
(e, N("0.137562344465103337106561623432", 30)),
(f, N("0.174259178881496659302933610355", 30)),
(g, N("0.220745448491223779615401870086", 30)),
]
tru = expr.n(30, subs=dict(r))
seq = expr.subs(r)
# although `tru` is the right way to evaluate
# expr with numerical values, `seq` will have
# significant loss of precision if extraction of
# the largest coefficient of a power's base's terms
# is done improperly
assert seq == tru
#15
v = symbols('v')
# 1 # 15a
assert solve(1 - (S(1)/2**2 + x*x),x)[1] == sqrt(3)/2 # 15b
# 16
assert 1121*12*10 == 134520
ranta = 6.85/100 * 100000 / 12
assert str(ranta/1121) == '0.509217960155' # Svar 51 %
# 17 Svar: 1/6
lst = [abs(x-y) == 3 for x in range(6) for y in range(6)]
assert S(lst.count(True))/len(lst) == S(1)/6
# 18 Svar: 30 och 60 grader
assert str(N(asin(2/3.0) * 180 / pi)) == '41.8103148957786' # Svar: 41.8 grader
# 19
x = symbols('x')
assert str(solve(x ** 2 - 1.37,x)[1]) == '1.17046999107196' # Svar: 17.0%
assert str(1.37**(S(1)/2)) == '1.17046999107196'
# 20
n = 0
ok = false
while not ok:
n += 1
ok = true
for i in range(1,10):
if n%i != 0: ok = false
def __init__(self):
self.s, self.t, self.x, self.y, self.z = symbols('s,t,x,y,z')
self.stack = []
self.defs = {}
self.mode = 0
self.hist = [('', [])] # Innehåller en lista med (kommandorad, stack)
self.lastx = ''
self.clear = True
self.op0 = {
's': lambda: self.s,
't': lambda: self.t,
'x': lambda: self.x,
'y': lambda: self.y,
'z': lambda: self.z,
'oo': lambda: S('oo'),
'inf': lambda: S('oo'),
'infinity': lambda: S('oo'),
'?': lambda: self.help(),
'help': lambda: self.help(),
'hist': lambda: self.history(),
'history': lambda: self.history(),
'sketch': lambda: self.sketch(),
}
self.op1 = {
'radians':
lambda x: pi / 180 * x,
'sin':
lambda x: sin(x),
'cos':
lambda x: cos(x),
'tan':
lambda x: tan(x),
'sq':
lambda x: x**2,
'sqrt':
lambda x: sqrt(x),
'ln':
lambda x: ln(x),
'exp':
lambda x: exp(x),
'log':
lambda x: log(x),
'simplify':
lambda x: simplify(x),
'polynom':
lambda x: self.polynom(x),
'inv':
lambda x: 1 / x,
'chs':
lambda x: -x,
'center':
lambda x: x.center,
'radius':
lambda x: x.radius,
'expand':
lambda x: x.expand(),
'factor':
lambda x: x.factor(),
'incircle':
lambda x: x.incircle,
'circumcircle':
lambda x: x.circumcircle,
'xdiff':
lambda x: x.diff(self.x),
'ydiff':
lambda x: x.diff(self.y),
'xint':
lambda x: x.integrate(self.x),
'xsolve':
lambda x: solve(x, self.x),
'xapart':
lambda x: apart(x, self.x),
'xtogether':
lambda x: together(x, self.x),
'N':
lambda x: N(x),
'info':
lambda x:
[x.__class__.__name__, [m for m in dir(x) if m[0] != '_']],
}
self.op2 = {
'+': lambda x, y: y + x,
'-': lambda x, y: y - x,
'*': lambda x, y: y * x,
'/': lambda x, y: y / x,
'**': lambda x, y: y**x,
'item': lambda x, y: y[x],
'point': lambda x, y: Point(y, x),
'line': lambda x, y: Line(y, x),
'circle': lambda x, y: Circle(y, x),
'tangent_lines': lambda x, y: y.tangent_lines(x),
'intersection': lambda x, y: intersection(x, y),
'perpendicular_line': lambda x, y: y.perpendicular_line(x),
'diff': lambda x, y: y.diff(x),
'int': lambda x, y: y.integrate(x),
'solve': lambda x, y: solve(y, x),
'apart': lambda x, y: apart(y, x),
'together': lambda x, y: together(y, x),
'xeval': lambda x, y: y.subs(self.x, x),
}
self.op3 = {
'triangle': lambda x, y, z: Triangle(x, y, z),
'limit': lambda x, y, z: limit(
z, y, x), # limit(sin(x)/x,x,0) <=> x sin x / x 0 limit
'eval': lambda x, y, z: z.subs(y, x),
}
self.op4 = {
'sum': lambda x, y, z, t: Sum(t, (z, y, x)).doit(
) # Sum(1/x**2,(x,1,oo)).doit() <=> 1 x x * / x 1 oo sum
}
self.lastx = ''
def findpoint(self, point):
if point in self.lookup:
return self.lookup[point]
else:
return "punkt(''," + str(N(point.x, 6)) + "," + str(N(point.y,
6)) + ")"
assert 21**21 == 5842587018385982521381124421
assert 21**99 == 79379832590301779009332005145274596627014317515664334015779308064863477574777517458715860220591757446709567525956962506247921694381
###################### Bråktal
x = S(1) / 2
y = S(3) / 4
z = S(5) / 6
xx = S(2) / 4
zz = S(16) / 8
assert str(x) == '1/2'
assert str(y) == '3/4'
assert str(z) == '5/6'
assert str(N(z)) == '0.833333333333333'
assert str(xx) == '1/2'
assert str(x + y) == '5/4'
assert str(x + z) == '4/3'
assert str(y + z) == '19/12'
assert str(x + y + z) == '25/12'
assert str(x * y * z) == '5/16'
assert str(zz) == '2'
######################## ekvationer
x = Symbol('x')
assert solve(x**2 - 1, x) == [-1, 1]
assert solve(x**2 - 2, x) == [-sqrt(2), sqrt(2)]
assert 3106 * 0.2 == 621.2 # gram 21a
assert 106 / 0.2 == 530 # carat 21b
# 22
speed = (5500 - 1900) / 12.0
assert str(1900 / speed) == '6.33333333333' # dagar
# 23
assert 1.55 / 0.005 == 310 # månader
assert 310 / 12 == 25 # år
assert 310 % 12 == 10 # månader
# 24
h = 200 # m
S = sqrt(13 * h) # km
assert str(N(S)) == '50.9901951359278' # 24
# 25
tathet = 10.5 / 17 # milj per 1000 km2
assert str(450 * tathet) == '277.941176471' # milj # 25c
# 26
d = 1200.0 # m
t = 5 * 60.0 # s
speed = d / t
assert speed == 4.0 # meter per sekund 26a
r = symbols('r')
radie = solve(pi * r * r - 65 * 0.2, r)[1]
assert str(radie) == '2.03421447256411' # 26b
assert str(radie * 2) == '4.06842894512822'
h = symbols('h')
