Solving a mathematical equation recursively in Python - python
I want to solve an equation which I am supposed to solve it recursively, I uploaded the picture of formula (Sorry! I did not know how to write mathematical formulas here!)
I wrote the code in Python as below:
import math
alambda = 1.0
rho = 0.8
c = 1.0
b = rho * c / alambda
P0 = (1 - (alambda*b))
P1 = (1-(alambda*b))*(math.exp(alambda*b) - 1)
def a(n):
a_n = math.exp(-alambda*b) * ((alambda*b)**n) / math.factorial(n)
return a_n
def P(n):
P(n) = (P0+P1)*a(n) + sigma(n)
def sigma(n):
j = 2
result = 0
while j <= n+1:
result = result + P(j)*a(n+1-j)
j += 1
return result
It is obvious that I could not finish P function. So please help me with this.
when n=1 I should extract P2, when n=2 I should extract P3.
By the way, P0 and P1 are as written in line 6 and 7.
When I call P(5) I want to see P(0), P(1), P(2), P(3), P(4), P(5), P(6) at the output.
You need to reorganize the formula so that you don't have to calculate P(3) to calculate P(2). This is pretty easy to do, by bringing the last term of the summation, P(n+1)a(0), to the left side of the equation and dividing through by a(0). Then you have a formula for P(n+1) in terms of P(m) where m <= n, which is solvable by recursion.
As Bruce mentions, it's best to cache your intermediate results for P(n) by keeping them in a dict so that a) you don't have to recalculate P(2) etc everytime you need it, and b) after you get the value of P(n), you can just print the dict to see all the values of P(m) where m <= n.
import math
a_lambda = 1.0
rho = 0.8
c = 1.0
b = rho * c / a_lambda
p0 = (1 - (a_lambda*b))
p1 = (1-(a_lambda*b))*(math.exp(a_lambda*b) - 1)
p_dict = {0: p0, 1: p1}
def a(n):
return math.exp(-a_lambda*b) * ((a_lambda*b)**n) / math.factorial(n)
def get_nth_p(n, p_dict):
# return pre-calculated value if p(n) is already known
if n in p_dict:
return p_dict[n]
# Calculate p(n) using modified formula
p_n = ((get_nth_p(n-1, p_dict)
- (get_nth_p(0, p_dict) + get_nth_p(1, p_dict)) * a(n - 1)
- sum(get_nth_p(j, p_dict) * a(n + 1 - j) for j in xrange(2, n)))
/ a(0))
# Save computed value into the dict
p_dict[n] = p_n
return p_n
get_nth_p(6, p_dict)
print p_dict
Edit 2
Some cosmetic updates to the code - shortening the name and making p_dict a mutable default argument (something I try to use only sparingly) really makes the code much more readable:
import math
# Customary to distinguish variables that are unchanging by making them ALLCAP
A_LAMBDA = 1.0
RHO = 0.8
C = 1.0
B = RHO * C / A_LAMBDA
P0 = (1 - (A_LAMBDA*B))
P1 = (1-(A_LAMBDA*B))*(math.exp(A_LAMBDA*B) - 1)
p_value_cache = {0: P0, 1: P1}
def a(n):
return math.exp(-A_LAMBDA*B) * ((A_LAMBDA*B)**n) / math.factorial(n)
def p(n, p_dict=p_value_cache):
# return pre-calculated value if p(n) is already known
if n in p_dict:
return p_dict[n]
# Calculate p(n) using modified formula
p_n = ((p(n-1)
- (p(0) + p(1)) * a(n - 1)
- sum(p(j) * a(n + 1 - j) for j in xrange(2, n)))
/ a(0))
# Save computed value into the dict
p_dict[n] = p_n
return p_n
p(6)
print p_value_cache
You could fix if that way:
import math
alambda = 1.0
rho = 0.8
c = 1.0
b = rho * c / alambda
def a(n):
# you might want to cache a as well
a_n = math.exp(-alambda*b) * ((alambda*b)**n) / math.factorial(n)
return a_n
PCache={0:(1 - (alambda*b)),1:(1-(alambda*b))*(math.exp(alambda*b) - 1)}
def P(n):
if n in PCache:
return PCache[n]
ret= (P(0)+P(1))*a(n) + sigma(n)
PCache[n]=ret
return ret
def sigma(n):
# caching this seems smart as well
j = 2
result = 0
while j <= n+1:
result = result + P(j)*a(n+1-j)
j += 1
return result
void displayP(n):
P(n) # fill cache :-)
for x in range(n):
print ("%u -> %d\n" % (x,PCache[x]))
Instead of managing the cache manually, you might want to use a memoize decorator (see http://www.python-course.eu/python3_memoization.php )
Notes:
not tested, but you should get the idea behind it
your recurrence won't work P(n) depends on P(n+1) on your equation... This will never end
It looks like I misunderstood P0 and P1 as being Both constants (big numbers) and results (small numbers, indices)... Notation is not the best choice I guess...
Related
A root of a "saw-like" function
Say, we have f(t) = v * t + A * sin(w * t). I call such functions "saw-like": I want to solve saw(t) = C, that is, find a root of saw(t) - C (still "saw-like"). I tried writing down a ternary search for function abs(saw(t) - C) to find its minima. If we are lucky (or crafty), it would be the root. Unfortunately, my code does not always work: sometimes we get stuck in those places: My code (python3): def calculate(fun): eps = 0.000000001 eps_l = 0.1 x = terns(fun, 0, 100000000000000) t = terns(fun, 0, x) cnt = 0 while fun(x) > eps: t = x x = terns(fun, 0, t) if abs(t - x) < eps_l: cnt += 1 # A sorry attempt pass some wrong value as a right one. # Gets us out of an infinite loop at least. if cnt == 10: break return t def terns(f, l, r): eps = 0.00000000001 while r - l > eps: x_1 = l + (r - l) / 3 x_2 = r - (r - l) / 3 if f(x_1) < f(x_2): r = x_2 else: l = x_1 return (l + r) / 2 So, how is it done? Is using ternary search the right way? My other idea was somehow sending the equation over to the net, passing it to Wolfram Alpha and fetching the answers. Yet, I don't how it's done, as I am not quite fluent at python. How could this be done?
Solving system of nonlinear equations with Python, Euler's formula
I am working on solving and analyzing a system of differential equations in Python. First did I solve it with help of scipy.integrate dopri5 and scopes Odeint. Which worked out fine. Then I tried to solve the equations with use of the Euler's method. The equations and code is as followed, dj = -mu*(J**3 - (C - C0)*J - F) dc = J + C*F + a*J**2 df = J*F - C T = 100 dt = 0.001 t = np.linspace(0, T, int(T/dt)+1) j = np.zeros(len(t)) c = np.zeros(len(t)) f = np.zeros(len(t)) # Initial condition j[0] = 0.1 c[0] = -0.5 f[0] = 0.1 a = 0.3025 C0 = 0.5 mu = 50 for i in range(len(t)): j[i+1] = j[i] + (-mu * (j[i]**3 - (c[i] - C0)*j[i] - f[i]))*dt c[i+1] = c[i] + (j[i] + c[i] * f[i] + (a * j[i])**2)*dt f[i+1] = f[i] + (j[i] * f[i] - c[i])*dt Is there any reason why the Euler's method should not work when both the other two are?
In the first iteration, i is 0, and your first line of the loop essentially is: j[0] = j[-1] + (-mu * (j[-1]**3 - (c[-1] - C0)*j[-1] - f[-1]))*dt j[-1] is the last element of j, just like c[-1] is the last element of c, etc. Initially they are all zeros, so j[0] becomes a 0, too, which overwrites the initial conditions. To fix this problem, change range(len(t)) to range(1,len(t)). (The model diverges after the first 9200 steps, anyway.)
As DYZ says, your calculation is incorrect on the first loop iteration because j[-1] is the last element of j, which you've initialised to zero.
However, your code wastes a lot of RAM. I assume you just want arrays containing T results, plus the initial values, rather than the results calculated on every step. The code below achieves that via a double for loop. We aren't really getting any benefit from Numpy in this code, so I don't bother importing it.
Note that Euler integration is not very accurate, and you generally need to use a much smaller step size than what's required by more sophisticated integration algorithms. As DYZ mentions, with your current step size the calculation diverges before the loop finishes.
Here's a modified version of your code using a smaller step size.
T = 100
dt = 0.00001
steps = int(T / dt)
substeps = int(steps / T)
# Recalculate `dt` to compensate for possible truncation
# in the `steps` and `substeps` calculations
dt = 1.0 / substeps
print('steps, substeps, dt:', steps, substeps, dt)
a = 0.3025
C0 = 0.5
mu = 50
#dj = -mu*(J**3 - (C - C0)*J - F)
#dc = J + C*F + a*J**2
#df = J*F - C
# Initial condition
j = 0.1
c = -0.5
f = 0.1
jlst, clst, flst = [j], [c], [f]
for i in range(T):
for _ in range(substeps):
j1 = j + (-mu * (j**3 - (c - C0)*j - f))*dt
c1 = c + (j + c * f + (a * j)**2)*dt
f1 = f + (j * f - c)*dt
j, c, f = j1, c1, f1
jlst.append(j)
clst.append(c)
flst.append(f)
def round_seq(seq, places=6):
return [round(u, places) for u in seq]
print('j:', round_seq(jlst), end='\n\n')
print('c:', round_seq(clst), end='\n\n')
print('f:', round_seq(flst), end='\n\n')
output
steps, substeps, dt: 10000000 100000 1e-05
j: [0.1, 0.585459, 1.26718, 3.557956, -1.311867, -0.647698, -0.133683, 0.395812, 0.964856, 3.009683, -2.025674, -1.047722, -0.48872, 0.044296, 0.581284, 1.245423, 14.725407, -1.715456, -0.907364, -0.372118, 0.167733, 0.705257, 1.511711, -3.588555, -1.476817, -0.778593, -0.253874, 0.289294, 0.837128, 1.985792, -2.652462, -1.28088, -0.657113, -0.132971, 0.409071, 0.983504, 3.229393, -2.1809, -1.113977, -0.539586, -0.009829, 0.528546, 1.156086, 8.23469, -1.838582, -0.967078, -0.423261, 0.113883, 0.650319, 1.381138, 12.045565, -1.575015, -0.833861, -0.305952, 0.23632, 0.778052, 1.734888, -2.925769, -1.362437, -0.709641, -0.186249, 0.356775, 0.917051, 2.507782, -2.367126, -1.184147, -0.590753, -0.063942, 0.476121, 1.07614, 5.085211, -1.976542, -1.029395, -0.474206, 0.059772, 0.596505, 1.273214, 17.083466, -1.682855, -0.890842, -0.357555, 0.182944, 0.721096, 1.554496, -3.331861, -1.450497, -0.763182, -0.239007, 0.30425, 0.85435, 2.076595, -2.584081, -1.258788, -0.642362, -0.117774, 0.423883, 1.003181, 3.521072, -2.132709, -1.094792, -0.525123]
c: [-0.5, -0.302644, 0.847742, 12.886781, 0.177404, -0.423405, -0.569541, -0.521669, -0.130084, 7.97828, -0.109606, -0.363033, -0.538874, -0.61005, -0.506872, 0.05076, 216.678959, -0.198445, -0.408569, -0.566869, -0.603713, -0.451729, 0.58959, 2.252504, -0.246645, -0.451, -0.588697, -0.587898, -0.375758, 2.152898, -0.087229, -0.295185, -0.49006, -0.603411, -0.562389, -0.263696, 8.901196, -0.132332, -0.342969, -0.525087, -0.609991, -0.526417, -0.077251, 67.082608, -0.177771, -0.389092, -0.555341, -0.607658, -0.47794, 0.293664, 147.817033, -0.225425, -0.432796, -0.579951, -0.595996, -0.412269, 1.235928, -0.037058, -0.273963, -0.473412, -0.597912, -0.574782, -0.318837, 4.581828, -0.113301, -0.3222, -0.51029, -0.608168, -0.543547, -0.172371, 24.718184, -0.157526, -0.369151, -0.542732, -0.609811, -0.500922, 0.09504, 291.915024, -0.204371, -0.414, -0.56993, -0.602265, -0.443622, 0.700005, 0.740665, -0.25268, -0.456048, -0.590933, -0.585265, -0.36427, 2.528225, -0.093699, -0.301181, -0.494644, -0.60469, -0.558516, -0.245806, 10.941068, -0.137816, -0.348805, -0.52912]
f: [0.1, 0.68085, 1.615135, 1.01107, -2.660947, -0.859348, -0.134789, 0.476782, 1.520241, 4.892319, -9.514924, -2.041217, -0.61413, 0.060247, 0.792463, 2.510586, 11.393914, -6.222736, -1.559576, -0.438133, 0.200729, 1.033274, 3.348756, -39.664752, -4.304545, -1.201378, -0.282146, 0.349631, 1.331995, 4.609547, -20.169056, -3.104072, -0.923759, -0.138225, 0.513633, 1.716341, 6.739864, -11.717002, -2.307614, -0.699883, 7.4e-05, 0.700823, 2.22957, 11.017447, -7.434886, -1.751919, -0.512171, 0.138566, 0.922012, 2.9434, -30.549886, -5.028825, -1.346261, -0.348547, 0.282981, 1.19254, 3.987366, -26.554232, -3.566328, -1.0374, -0.200198, 0.439487, 1.535198, 5.645421, -14.674838, -2.619369, -0.792589, -0.060175, 0.615387, 1.985246, 8.779969, -8.991742, -1.972575, -0.590788, 0.077534, 0.820118, 2.599728, 8.879606, -5.928246, -1.509453, -0.417854, 0.218635, 1.066761, 3.477148, -36.053938, -4.124934, -1.163178, -0.263755, 0.369033, 1.37438, 4.811848, -18.741635, -2.987496, -0.893457, -0.120864, 0.535433, 1.771958, 7.117055, -11.027021, -2.227847, -0.674889]
That takes about 75 seconds on my old 2GHz machine.
Using dt = 0.000005 (which takes almost 2 minutes on this machine) the final values of j, c, and f are -0.524774, -0.529217, -0.674293, respectively, so it looks like we're beginning to get convergence.
Thanks to LutzL for pointing out that dt may need adjusting because of the rounding in the steps and substeps calculations.
Writing a while loop for error function erf(x)?
I understand there is a erf (Wikipedia) function in python. But in this assignment we are specifically asked to write the error function as if it was not already implemented in python while using a while loop. erf (x) is simplified already as : (2/ (sqrt(pi)) (x - x^3/3 + x^5/10 - x^7/42...) Terms in the series must be added until the absolute total is less than 10^-20.
First of all - SO is not the place when people code for you, here people help you to solve particular problem not the whole task Any way: It's not too hard to implement wikipedia algorithm: import math def erf(x): n = 1 res = 0 res1 = (2 / math.sqrt(math.pi)) * x diff = 1 s = x while diff > math.pow(10, -20): dividend = math.pow((-1), n) * math.pow(x, 2 * n + 1) divider = math.factorial(n) * (2 * n + 1) s += dividend / divider res = ((2 / math.sqrt(math.pi)) * s) diff = abs(res1 - res) res1 = res n += 1 return res print(erf(1)) Please read the source code carefully and post all questions that you don't understand. Also you may check python sources and see how erf is implemented
FFT unexpected frequency shift after window function application
I got this python code for FFT calculation of a sound signal: from math import * from cmath import exp, pi def fft(x): N = len(x) if N <= 1: return x even = fft(x[0::2]) odd = fft(x[1::2]) return ([even[k] + exp(-2j * pi * k / N) * odd[k] for k in xrange(N / 2)] + [even[k] - exp(-2j * pi * k / N) * odd[k] for k in xrange(N / 2)]) N = 64 res = [sin(k) for k in xrange(N)] # Window function a = 2*pi/(N-1) for k in xrange(N): z = a * res[k] res[k] = 0.42659 - 0.49656*cos(z) + 0.076849*cos(2*z) res = fft(res) for k in xrange(N/2): # get the amplitude... sqr = sqrt(res[k].real * res[k].real + res[k].imag * res[k].imag) if sqr > 0: print 20 * log10(sqr) # ...in decibels else: print "-INF" I got the following results: WITHOUT window function (commented-out): -20.3017238269 -16.9192604108 -12.5089302395 -8.97999530657 -5.96033201086 -3.12975820108 -0.242090896634 2.97021879504 6.95134203457 12.8752188937 29.5096108632 <-- PEAK 17.1668404562 10.6485650284 7.24321329787 4.98448122464 3.3242079033 2.03154022635 0.987966110459 0.124898554197 -0.600705355004 -1.21748302238 -1.74534177237 -2.1985940834 -2.5878009699 -2.92091067118 -3.20399051424 -3.44171254421 -3.63768393032 -3.79467588076 -3.91478386211 -3.99953964778 -4.04998822971 WITH window function: -6.55943077129 -65.8567720414 -65.7987645827 -65.7012678903 -65.5625673034 -65.380788761 -65.1529344157 -64.8750852394 -64.5420675211 -64.1470597764 -63.6810080181 -63.131731575 -62.4825087571 -61.7097419947 -60.7788888801 -59.6368610687 -58.1964601495 -56.3001921054 -53.6185951634 -49.2554491173 -38.3322646561 <-- PEAK -43.3318138698 -52.0838904305 -56.7277347745 -60.2038755771 -62.9772322874 -65.442363488 -67.7550361967 -70.0212827894 -72.3056579688 -74.5822818952 -76.5522909937 The peak appears shifted for some reason. It is a 2x frequency shift! To check the results, I tried this Java applet: http://www.random-science-tools.com/maths/FFT.htm And it appears that the results WITHOUT any window function are the correct ones (peak at 1 third of the spectrum). Instead, if I apply the window function in my python script the peak shows at 2/3 of the spectrum. Is this supposed to happen? How do I fix it?
Ok, In the meanwhile I realized what was wrong. The window function as I wrote it in the question was totally meaningless. This is the correct one: a = 2*pi/(N-1) for k in xrange(N): z = a * k res[k] *= 0.42659 - 0.49656*cos(z) + 0.076849*cos(2*z) # Blackman Results: -63.8888312044 -62.1859660802 -59.4560808775 -57.5235455007 -57.0010514385 -59.4284419437 -66.6535724743 -46.1441434426 -2.31562840406 16.0873761957 22.4136439765 <-- PEAK 19.5784749467 6.43274013629 -28.3842042716 -55.5273291654 -68.8982705127 -53.3843989911 -49.731974213 -48.3131204305 -47.6953570892 -47.4386151256 -47.361972079 -47.3787962267 -47.4434419084 -47.530228024 -47.6240076874 -47.7155325706 -47.799012933 -47.870764286 -47.9284264139 -47.9705003855 -47.9960714351 The peak is now exactly where it is supposed to be. Some other windows you may want to try: res[k] *= 0.355768 - 0.487396*cos(z) + 0.144232*cos(2*z) - 0.012604*cos(3*z) res[k] *= 1 - 1.93*cos(z) + 1.29*cos(2*z) - 0.388*cos(3*z) + 0.028*cos(4*z) res[k] *= 1 - 1.985844164102*cos(z) + 1.791176438506*cos(2*z) - 1.282075284005*cos(3*z) + 0.667777530266*cos(4*z) - 0.240160796576*cos(5*z) + 0.056656381764*cos(6*z) - 0.008134974479*cos(7*z) + 0.000624544650*cos(8*z) - 0.000019808998*cos(9*z) + 0.000000132974*cos(10*z) In order: Nuttall, FTSRS, HFT248D. https://holometer.fnal.gov/GH_FFT.pdf
Fastest possible method for the arcsin function on small, arbitrary floating-point values
I need to calculate the arcsine function of small values that are under the form of mpmath's "mpf" floating-point bignums. What I call a "small" value is for example e/4/(10**7) = 0.000000067957045711476130884... Here is a result of a test on my machine with mpmath's built-in asin function: import gmpy2 from mpmath import * from time import time mp.dps = 10**6 val=e/4/(10**7) print "ready" start=time() temp=asin(val) print "mpmath asin: "+str(time()-start)+" seconds" >>> 155.108999968 seconds This is a particular case: I work with somewhat small numbers, so I'm asking myself if there is a way to calculate it in python that actually beats mpmath for this particular case (= for small values). Taylor series are actually a good choice here because they converge very fast for small arguments. But I still need to accelerate the calculations further somehow. Actually there are some problems: 1) Binary splitting is ineffective here because it shines only when you can write the argument as a small fraction. A full-precision float is given here. 2) arcsin is a non-alternating series, thus Van Wijngaarden or sumalt transformations are ineffective too (unless there is a way I'm not aware of to generalize them to non-alternating series). https://en.wikipedia.org/wiki/Van_Wijngaarden_transformation The only acceleration left I can think of is Chebyshev polynomials. Can Chebyshev polynomials be applied on the arcsin function? How to?
Can you use the mpfr type that is included in gmpy2? >>> import gmpy2 >>> gmpy2.get_context().precision = 3100000 >>> val = gmpy2.exp(1)/4/10**7 >>> from time import time >>> start=time();r=gmpy2.asin(val);print time()-start 3.36188197136 In addition to supporting the GMP library, gmpy2 also supports the MPFR and MPC multiple-precision libraries. Disclaimer: I maintain gmpy2.
Actually binary splitting does work very well, if combined with iterated argument reduction to balance the number of terms against the size of the numerators and denominators (this is known as the bit-burst algorithm). Here is a binary splitting implementation for mpmath based on repeated application of the formula atan(t) = atan(p/2^q) + atan((t*2^q-p) / (2^q+p*t)). This formula was suggested recently by Richard Brent (in fact mpmath's atan already uses a single invocation of this formula at low precision, in order to look up atan(p/2^q) from a cache). If I remember correctly, MPFR also uses the bit-burst algorithm to evaluate atan, but it uses a slightly different formula, which possibly is more efficient (instead of evaluating several different arctangent values, it does analytic continuation using the arctangent differential equation). from mpmath.libmp import MPZ, bitcount from mpmath import mp def bsplit(p, q, a, b): if b - a == 1: if a == 0: P = p Q = q else: P = p * p Q = q * 2 B = MPZ(1 + 2 * a) if a % 2 == 1: B = -B T = P return P, Q, B, T else: m = a + (b - a) // 2 P1, Q1, B1, T1 = bsplit(p, q, a, m) P2, Q2, B2, T2 = bsplit(p, q, m, b) T = ((T1 * B2) << Q2) + T2 * B1 * P1 P = P1 * P2 B = B1 * B2 Q = Q1 + Q2 return P, Q, B, T def atan_bsplit(p, q, prec): """computes atan(p/2^q) as a fixed-point number""" if p == 0: return MPZ(0) # FIXME nterms = (-prec / (bitcount(p) - q) - 1) * 0.5 nterms = int(nterms) + 1 if nterms < 1: return MPZ(0) P, Q, B, T = bsplit(p, q, 0, nterms) if prec >= Q: return (T << (prec - Q)) // B else: return T // (B << (Q - prec)) def atan_fixed(x, prec): t = MPZ(x) s = MPZ(0) q = 1 while t: q = min(q, prec) p = t >> (prec - q) if p: s += atan_bsplit(p, q, prec) u = (t << q) - (p << prec) v = (MPZ(1) << (q + prec)) + p * t t = (u << prec) // v q *= 2 return s def atan1(x): prec = mp.prec man = x.to_fixed(prec) return mp.mpf((atan_fixed(man, prec), -prec)) def asin1(x): x = mpf(x) return atan1(x/sqrt(1-x**2)) With this code, I get: >>> from mpmath import * >>> mp.dps = 1000000 >>> val=e/4/(10**7) >>> from time import time >>> start = time(); y1 = asin(x); print time() - start 58.8485069275 >>> start = time(); y2 = asin1(x); print time() - start 8.26498985291 >>> nprint(y2 - y1) -2.31674e-1000000 Warning: atan1 assumes 0 <= x < 1/2, and the determination of the number of terms might not be optimal or correct (fixing these issues is left as an exercise to the reader).
A fast way is to use a pre-calculated look-up table. But if you look at e.g. a Taylor series for asin; def asin(x): rv = (x + 1/3.0*x**3 + 7/30.0*x**5 + 64/315.0*x**7 + 4477/22680.0*x**9 + 28447/138600.0*x**11 + 23029/102960.0*x**13 + 17905882/70945875.0*x**15 + 1158176431/3958416000.0*x**17 + 9149187845813/26398676304000.0*x**19) return rv You'll see that for small values of x, asin(x) ≈ x. In [19]: asin(1e-7) Out[19]: 1.0000000000000033e-07 In [20]: asin(1e-9) Out[20]: 1e-09 In [21]: asin(1e-11) Out[21]: 1e-11 In [22]: asin(1e-12) Out[22]: 1e-12 E.g. for the value us used: In [23]: asin(0.000000067957045711476130884) Out[23]: 6.795704571147624e-08 In [24]: asin(0.000000067957045711476130884)/0.000000067957045711476130884 Out[24]: 1.0000000000000016 Of course it depends on whether this difference is relevant to you.