Taylor's series
A well-behaved function can be expanded into a power series. This means that for all non-negative integers there are real numbers such that
Let us calculate the first four derivatives using :
Setting equal to zero, we obtain
Let us write for the -th derivative of We also write — think of as the "zeroth derivative" of We thus arrive at the general result where the factorial is defined as equal to 1 for and and as the product of all natural numbers for Expressing the coefficients in terms of the derivatives of at we obtain
This is the Taylor series for
A remarkable result: if you know the value of a well-behaved function and the values of all of its derivatives at the single point then you know at all points Besides, there is nothing special about so is also determined by its value and the values of its derivatives at any other point :
Examples
editcos(x)
edit
Some basic checking:
|
arctan(x)
edit
Second derivative y″
edit
|
Third derivative y¹¹¹
edit
|
(continued)
editIf you continue to calculate derivatives, you will produce the following sequence:
Some basic checking:
Also, Show that or that
If abs |
In the diagram to the right, is the Taylor series representing for close to In the box above the proof that is an accurate representation of is valid for abs When abs the diagram vividly illustrates that the series rapidly diverges. To be accurate, the line should be rad or meaning radians. In theoretical work a value such as is understood to be radians or meaning degrees. |
In practice
edit
The expansion of above is theoretically valid for However, if is close to the calculation of will take forever. This section uses so that is small enough to make time of calculation acceptable.
Using the half-angle formula calculate and
If the code below is accurate to places of decimals.
where where where where and so on.
then and:
A faster versionedit
|
arcsin(x)
edit
Simple differential equations eliminate the square root and make calculations so much easier.
Let
Then where and
Differentiating both sides:
Let
Then
Differentiating both sides:
Let
Then
When Calculation of more derivatives yields:
and so on.
As programming algorithm:
edit
As implemented in Python:
editfrom decimal import * # Default precision is 28.
π = ("3.14159265358979323846264338327950288419716939937510582097494459230781")
π = Decimal(π)
x = Decimal(2).sqrt()/2 # Expecting result of π/4
xSQ = x*x
X = x*xSQ
top = Decimal(1)
bottom = Decimal(2)
bottom1 = bottom*3
sum = x + X*top / bottom1
status = 1
for n in range(5,200,2) :
X = X*xSQ
top = top*(n-2)
bottom = bottom*(n-1)
bottom1 = bottom*n
added = X*top/bottom1
if (added < 1e-29) :
status = 0
break
sum += added
if status :
print ('error. count expired.')
else :
print (x, sum==π/4, n)
0.707106781186547524400844362 True 171
In practice
editIf is close to the calculation of will take forever.
If you limit to then
and each term is guaranteed to be less than half the preceding term.
If let
Then
Integral of expression
editAccording to the reference "this expression cannot be integrated..." However, if we convert the expression to a Taylor series, the integral of the series is quite easily calculated.
Let
When and the following sequence can be produced.
where
and so on.
Taylor series of for close to
where
For python code produces the following:
c02 = -0.6931471805599453094172321215 c04 = 0.2402265069591007123335512632 c06 = -0.05550410866482157995314226378 c08 = 0.009618129107628477161979071575 c10 = -0.001333355814642844342341222199 c12 = 0.0001540353039338160995443709734 c14 = -0.00001525273380405984028002543902 c16 = 0.000001321548679014430948840375823 c18 = -1.017808600923969972749000760E-7 c20 = 7.054911620801123329875392184E-9 c22 = -4.445538271870811497596408561E-10 c24 = 2.567843599348820514199480240E-11 c26 = -1.369148885390412888089195400E-12 c28 = 6.778726354822545633449104318E-14 c30 = -3.132436707088428621634944443E-15 c32 = 1.357024794875514719311296624E-16 c34 = -5.533046532458242043485546100E-18 c36 = 2.130675335489117996020398479E-19 c38 = -7.773008428857356419088997166E-21 c40 = 2.693919438465583416972861154E-22 c42 = -8.891822206800239171648619811E-24
For close to or close to the Taylor series is a quite accurate representation of the original expression. When abs the abs(maximum difference) between expression and Taylor series is
For greater accuracy, greater precision may be specified in python or more terms after may be added.
The integral
where
In figure to right, separating from to illustrate shapes of curves. The correct value of . When and . To 24 places of decimals _ _ _ _ _ . |
If it were important to calculate the area under from to returns accurate to about 26 places of decimals. |
sin(x) using (x - x0)
edit
Let
Let
Then
where is the Taylor series representing for values of close to or
If , then containing powers of through is sufficient to keep the error to
Gallery
edit-
Graph of representing with powers of limited to .
-
Graph of representing with powers of limited to .
-
Graph of representing with powers of limited to .
Almost a sine curve
edit
Graph to right was produced by Grapher on a Mac. A python script produced the following data: ( (2^(0.5))/2 )( 1 +(x-.785398163397448) -((x-.785398163397448)^2)/2 -((x-.785398163397448)^3)/(2(3)) +((x-.785398163397448)^4)/(24) +((x-.785398163397448)^5)/(120) -((x-.785398163397448)^6)/(720) -((x-.785398163397448)^7)/(5040) +((x-.785398163397448)^8)/(40320) +((x-.785398163397448)^9)/(362880) -((x-.785398163397448)^10)/(3628800) -((x-.785398163397448)^11)/(39916800) +((x-.785398163397448)^12)/(479001600) +((x-.785398163397448)^13)/(6227020800) -((x-.785398163397448)^14)/(87178291200) -((x-.785398163397448)^15)/(1307674368000) +((x-.785398163397448)^16)/(20922789888000) +((x-.785398163397448)^17)/(355687428096000) -((x-.785398163397448)^18)/(6402373705728000) -((x-.785398163397448)^19)/(121645100408832000) +((x-.785398163397448)^20)/(2432902008176640000) +((x-.785398163397448)^21)/(51090942171709440000) -((x-.785398163397448)^22)/(1124000727777607680000) -((x-.785398163397448)^23)/(25852016738884976640000) +((x-.785398163397448)^24)/(620448401733239439360000) +((x-.785398163397448)^25)/(15511210043330985984000000) -((x-.785398163397448)^26)/(403291461126605635584000000) -((x-.785398163397448)^27)/(10888869450418352160768000000) +((x-.785398163397448)^28)/(304888344611713860501504000000) +((x-.785398163397448)^29)/(8841761993739701954543616000000) ) I highlighted the data, copied it with command C and pasted it into the input area of Grapher. Well done! Grapher. |
Integral of 1/x
editThe Taylor series for for close to is:
The integral of this series is:
The integral of
Therefore but what is the value of
Without when should be
Therefore, for close to
where
But what is the value of
Without when should be
Therefore or
For close to
where
y = 0.693147180559945 + ((1/(2^1))/1)(x - 2)^1 - ((1/(2^2))/2)(x - 2)^2 + ((1/(2^3))/3)(x - 2)^3 - ((1/(2^4))/4)(x - 2)^4 + ((1/(2^5))/5)(x - 2)^5 - ((1/(2^6))/6)(x - 2)^6 + ((1/(2^7))/7)(x - 2)^7 ........................... ........................... - ((1/(2^42))/42)(x - 2)^42 + ((1/(2^43))/43)(x - 2)^43 - ((1/(2^44))/44)(x - 2)^44 + ((1/(2^45))/45)(x - 2)^45 - ((1/(2^46))/46)(x - 2)^46 + ((1/(2^47))/47)(x - 2)^47 - ((1/(2^48))/48)(x - 2)^48 + ((1/(2^49))/49)(x - 2)^49
|
Calculating ln(x)
editThis section presents a system for calculating for knowing only that
# python code
L1 = [1, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.2, 2.4, 2.6, 2.8,
3.0, 3.3, 3.6, 3.9, 4.2, 4.6, 5.0, 5.5, 6.0, 6.6, 7.2, 7.9, 8.6, 9.3, 10.0]
where L1
is a list containing values of in which each
value after the first is % more than the preceding value.
# python code
from decimal import *
getcontext().prec=53 # Preparing for values containing 50 places of decimals.
almostZero = Decimal('1e-' + str( getcontext().prec ))
L1 = [ Decimal(str(v)) for v in L1 ]
def ln_x (x, x0, C=0) :
'''
return ln(x) for x close to x0.
ln_x_ = ln_x (x, x0, C)
C is the constant of integration. Usually C = ln(x0).
'''
x, x0, C = [ Decimal(str(v)) for v in (x,x0,C) ]
x_minus_x0 = x-x0;
# print ('x,x0,x_minus_x0 =',x,x0,x_minus_x0)
sum = 0
progressiveValue = 1
status = 1 ; limit = 4*getcontext().prec
multiplier = x_minus_x0/x0
for p in range (1, limit, 2) :
progressiveValue *= multiplier
added = progressiveValue / p
sum += added
progressiveValue *= multiplier
added = progressiveValue / (p+1)
if (abs(added) < almostZero) :
status = 0
break
sum -= added
if (status) :
print ('ln_x error: count expired, p =',p)
exit (95)
return sum+C
The performance of the above code is better than logarithmic to base . This means, for example, if contains 60 significant decimal digits, the above code produces a result with fewer than 30 passes through the loop because each iteration of the lop performs two operations.
L1
is designed so that multiplier
is always
When is very close to time to calculate
is greatly reduced.
y = ln(7.9) + ((1/((7.9)^(1)))/(1))((x - 7.9)^(1)) - ((1/((7.9)^(2)))/(2))((x - 7.9)^(2)) + ((1/((7.9)^(3)))/(3))((x - 7.9)^(3)) - ((1/((7.9)^(4)))/(4))((x - 7.9)^(4)) + ((1/((7.9)^(5)))/(5))((x - 7.9)^(5)) - ((1/((7.9)^(6)))/(6))((x - 7.9)^(6)) + ((1/((7.9)^(7)))/(7))((x - 7.9)^(7)) - ((1/((7.9)^(8)))/(8))((x - 7.9)^(8)) + ((1/((7.9)^(9)))/(9))((x - 7.9)^(9)) ..................... ..................... - ((1/((7.9)^(22)))/(22))((x - 7.9)^(22)) + ((1/((7.9)^(23)))/(23))((x - 7.9)^(23)) - ((1/((7.9)^(24)))/(24))((x - 7.9)^(24)) + ((1/((7.9)^(25)))/(25))((x - 7.9)^(25)) - ((1/((7.9)^(26)))/(26))((x - 7.9)^(26)) + ((1/((7.9)^(27)))/(27))((x - 7.9)^(27)) - ((1/((7.9)^(28)))/(28))((x - 7.9)^(28)) + ((1/((7.9)^(29)))/(29))((x - 7.9)^(29))
|
The next piece of code progressively calculates and puts the calculated values in dictionary dict2.
dict2 = dict()
dict2[Decimal('1.0')] = Decimal(0)
for p in range(1, len(L1)) :
x = L1[p]
x0 = L1[p-1]
C = dict2[x0]
# print ('L1[{}]={}'.format(p,L1[p]))
ln = ln_x (x, x0, C)
dict2[x] = ln
print ('dict2 = {')
for x0 in dict2 :
print ("Decimal('{}'): +Decimal('{}'),".format( (' '+str(x0))[-4:], dict2[x0]) )
print ('}')
dict2 = { Decimal(' 1.0'): +Decimal('0'), Decimal(' 1.1'): +Decimal('0.095310179804324860043952123280765092220605365308644199'), Decimal(' 1.2'): +Decimal('0.18232155679395462621171802515451463319738933791448698'), Decimal(' 1.3'): +Decimal('0.26236426446749105203549598688095439720416645613143414'), Decimal(' 1.4'): +Decimal('0.33647223662121293050459341021699209011148337531334347'), Decimal(' 1.5'): +Decimal('0.40546510810816438197801311546434913657199042346249420'), Decimal(' 1.6'): +Decimal('0.47000362924573555365093703114834206470089904881224805'), Decimal(' 1.7'): +Decimal('0.53062825106217039623154316318876232798710152395697182'), Decimal(' 1.8'): +Decimal('0.58778666490211900818973114061886376976937976137698120'), Decimal(' 1.9'): +Decimal('0.64185388617239477599103597720348932963627777267035586'), Decimal(' 2.0'): +Decimal('0.69314718055994530941723212145817656807550013436025527'), Decimal(' 2.2'): +Decimal('0.78845736036427016946118424473894166029610549966889947'), Decimal(' 2.4'): +Decimal('0.87546873735389993562895014661269120127288947227474225'), Decimal(' 2.6'): +Decimal('0.95551144502743636145272810833913096527966659049168941'), Decimal(' 2.8'): +Decimal('1.0296194171811582399218255316751686581869835096735987'), Decimal(' 3.0'): +Decimal('1.0986122886681096913952452369225257046474905578227494'), Decimal(' 3.3'): +Decimal('1.1939224684724345514391973602032907968680959231313936'), Decimal(' 3.6'): +Decimal('1.2809338454620643176069632620770403378448798957372364'), Decimal(' 3.9'): +Decimal('1.3609765531356007434307412238034801018516570139541836'), Decimal(' 4.2'): +Decimal('1.4350845252893226218998386471395177947589739331360929'), Decimal(' 4.6'): +Decimal('1.5260563034950493162059934985840084789167789605719180'), Decimal(' 5.0'): +Decimal('1.6094379124341003746007593332261876395256013542685177'), Decimal(' 5.5'): +Decimal('1.7047480922384252346447114565069527317462067195771619'), Decimal(' 6.0'): +Decimal('1.7917594692280550008124773583807022727229906921830047'), Decimal(' 6.6'): +Decimal('1.8870696490323798608564294816614673649435960574916489'), Decimal(' 7.2'): +Decimal('1.9740810260220096270241953835352169059203800300974917'), Decimal(' 7.9'): +Decimal('2.0668627594729758101549540867970467145724397357938367'), Decimal(' 8.6'): +Decimal('2.1517622032594620488720831801196593960335348306130377'), Decimal(' 9.3'): +Decimal('2.2300144001592102533064181067805187074963279996745685'), Decimal('10.0'): +Decimal('2.3025850929940456840179914546843642076011014886287730'), }
A quick check: ln(2.2) - (ln(1.1) + ln(2.0)) = 0E-50 ln(2.4) - (ln(1.2) + ln(2.0)) = 0E-50 ln(2.6) - (ln(1.3) + ln(2.0)) = 0E-50 ln(2.8) - (ln(1.4) + ln(2.0)) = 0E-50 ln(3.0) - (ln(1.5) + ln(2.0)) = -0E-50 ln(3.3) - (ln(1.1) + ln(3.0)) = 0E-50 ln(3.6) - (ln(1.2) + ln(3.0)) = 0E-50 ln(3.6) - (ln(1.8) + ln(2.0)) = -0E-50 ln(3.9) - (ln(1.3) + ln(3.0)) = 0E-50 ln(4.2) - (ln(1.4) + ln(3.0)) = 0E-50 ln(5.5) - (ln(1.1) + ln(5.0)) = 0E-50 ln(6.0) - (ln(1.2) + ln(5.0)) = 0E-50 ln(6.0) - (ln(2.0) + ln(3.0)) = 0E-50 ln(6.6) - (ln(1.1) + ln(6.0)) = 0E-50 ln(6.6) - (ln(2.2) + ln(3.0)) = 0E-50 ln(6.6) - (ln(3.3) + ln(2.0)) = 0E-50 ln(7.2) - (ln(1.2) + ln(6.0)) = 0E-50 ln(7.2) - (ln(2.4) + ln(3.0)) = 0E-50 ln(10.0) - (ln(5.0) + ln(2.0)) = 0E-50
|
Put the data from dict2
into 2 tuples Tx0, Tln_x0
Tx0 = tuple(L1)
Tln_x0 = tuple([ dict2[v] for v in Tx0 ])
Calculate the decision points.
L1 = []
for p in range (0, len(Tx0)-1) :
a,b = Tx0[p], Tx0[p+1]
dp = 2*a*b/(a+b)
L1 += [ dp ]
Tdp = tuple(L1)
Display the three tuples.
for T in ('Tx0', 'Tln_x0', 'Tdp') :
t = eval(T)
print (T, '= (')
for v in t :
print ("""+Decimal('{}'),""".format(v))
print (')')
print ()
Previous code was used to produce three tuples. Operational code follows:
Values of
Tx0 = (
Decimal('1'),
Decimal('1.1'),
Decimal('1.2'),
Decimal('1.3'),
Decimal('1.4'),
Decimal('1.5'),
Decimal('1.6'),
Decimal('1.7'),
Decimal('1.8'),
Decimal('1.9'),
Decimal('2.0'),
Decimal('2.2'),
Decimal('2.4'),
Decimal('2.6'),
Decimal('2.8'),
Decimal('3.0'),
Decimal('3.3'),
Decimal('3.6'),
Decimal('3.9'),
Decimal('4.2'),
Decimal('4.6'),
Decimal('5.0'),
Decimal('5.5'),
Decimal('6.0'),
Decimal('6.6'),
Decimal('7.2'),
Decimal('7.9'),
Decimal('8.6'),
Decimal('9.3'),
Decimal('10.0'),
)
Values of
Tln_x0 = (
+Decimal('0'),
+Decimal('0.095310179804324860043952123280765092220605365308644199'),
+Decimal('0.18232155679395462621171802515451463319738933791448698'),
+Decimal('0.26236426446749105203549598688095439720416645613143414'),
+Decimal('0.33647223662121293050459341021699209011148337531334347'),
+Decimal('0.40546510810816438197801311546434913657199042346249420'),
+Decimal('0.47000362924573555365093703114834206470089904881224805'),
+Decimal('0.53062825106217039623154316318876232798710152395697182'),
+Decimal('0.58778666490211900818973114061886376976937976137698120'),
+Decimal('0.64185388617239477599103597720348932963627777267035586'),
+Decimal('0.69314718055994530941723212145817656807550013436025527'),
+Decimal('0.78845736036427016946118424473894166029610549966889947'),
+Decimal('0.87546873735389993562895014661269120127288947227474225'),
+Decimal('0.95551144502743636145272810833913096527966659049168941'),
+Decimal('1.0296194171811582399218255316751686581869835096735987'),
+Decimal('1.0986122886681096913952452369225257046474905578227494'),
+Decimal('1.1939224684724345514391973602032907968680959231313936'),
+Decimal('1.2809338454620643176069632620770403378448798957372364'),
+Decimal('1.3609765531356007434307412238034801018516570139541836'),
+Decimal('1.4350845252893226218998386471395177947589739331360929'),
+Decimal('1.5260563034950493162059934985840084789167789605719180'),
+Decimal('1.6094379124341003746007593332261876395256013542685177'),
+Decimal('1.7047480922384252346447114565069527317462067195771619'),
+Decimal('1.7917594692280550008124773583807022727229906921830047'),
+Decimal('1.8870696490323798608564294816614673649435960574916489'),
+Decimal('1.9740810260220096270241953835352169059203800300974917'),
+Decimal('2.0668627594729758101549540867970467145724397357938367'),
+Decimal('2.1517622032594620488720831801196593960335348306130377'),
+Decimal('2.2300144001592102533064181067805187074963279996745685'),
+Decimal('2.3025850929940456840179914546843642076011014886287730'),
)
Decision points:
Tdp = (
+Decimal('1.0476190476190476190476190476190476190476190476190476'),
+Decimal('1.1478260869565217391304347826086956521739130434782609'),
+Decimal('1.248'),
+Decimal('1.3481481481481481481481481481481481481481481481481481'),
+Decimal('1.4482758620689655172413793103448275862068965517241379'),
+Decimal('1.5483870967741935483870967741935483870967741935483871'),
+Decimal('1.6484848484848484848484848484848484848484848484848485'),
+Decimal('1.7485714285714285714285714285714285714285714285714286'),
+Decimal('1.8486486486486486486486486486486486486486486486486486'),
+Decimal('1.9487179487179487179487179487179487179487179487179487'),
+Decimal('2.0952380952380952380952380952380952380952380952380952'),
+Decimal('2.2956521739130434782608695652173913043478260869565217'),
+Decimal('2.496'),
+Decimal('2.6962962962962962962962962962962962962962962962962963'),
+Decimal('2.8965517241379310344827586206896551724137931034482759'),
+Decimal('3.1428571428571428571428571428571428571428571428571429'),
+Decimal('3.4434782608695652173913043478260869565217391304347826'),
+Decimal('3.744'),
+Decimal('4.0444444444444444444444444444444444444444444444444444'),
+Decimal('4.3909090909090909090909090909090909090909090909090909'),
+Decimal('4.7916666666666666666666666666666666666666666666666667'),
+Decimal('5.2380952380952380952380952380952380952380952380952381'),
+Decimal('5.7391304347826086956521739130434782608695652173913043'),
+Decimal('6.2857142857142857142857142857142857142857142857142857'),
+Decimal('6.8869565217391304347826086956521739130434782608695652'),
+Decimal('7.5337748344370860927152317880794701986754966887417219'),
+Decimal('8.2351515151515151515151515151515151515151515151515152'),
+Decimal('8.9363128491620111731843575418994413407821229050279330'),
+Decimal('9.6373056994818652849740932642487046632124352331606218'),
)
At each decision point is assigned to the next low value or the next high value of For example, if is between the decision point is This means that the ratio and the maximum value of abs
During creation of Tln_x0
the maximum value of
During normal operations after creation of Tln_x0,
maximum value of
abs between
Choose a suitable value of x0
with the value of its natural log.
def choose_x0_C (x) :
'''
(x0, C) = choose_x0_C (x)
'''
if (10 >= x >= 1) : pass
else: exit (93)
for p in range (len(Tx0)-2, -1, -1):
if (x >= Tx0[p]) :
if (x >= Tdp[p]) : return (Tx0[p+1], Tln_x0[p+1])
return (Tx0[p], Tln_x0[p])
exit(92)
Ready to calculate, for example,
x = Decimal('3.456789')
(x0, C) = choose_x0_C (x)
ln_x_ = ln_x (x, x0, C)
print ('ln({}) = {}'.format(x, ln_x_.quantize(Decimal('1e-50'))))
ln(3.456789) = 1.24034_01234_96758_02986_53847_82231_30004_00340_53893_89110 # displayed with 50 places of decimals.
Testing ln(x)
editChoose random numbers so that
Produce values
Calculate product
Produce value
If and
Verify that
# python code
import random
ln_10 = Tln_x0[-1]
fiftyPlacesOfDecimals = Decimal('1e-50')
def randomNumber() :
s1 = str(random.getrandbits(getcontext().prec * 4))
d1 = Decimal(s1[0] + '.' + s1[1:])
if (d1 == 0) : d1 = randomNumber()
while (d1 < 1) : d1 *= 10
return d1
d1 = randomNumber()
d2 = randomNumber()
(x0, C) = choose_x0_C (d1)
ln_d1_ = ln_x (d1, x0, C)
(x0, C) = choose_x0_C (d2)
ln_d2_ = ln_x (d2, x0, C)
product = d1*d2
add_ln10 = 0
if (product > 10) :
product /= 10
add_ln10 += 1
(x0, C) = choose_x0_C (product)
ln_product_ = ln_x (product, x0, C)
if (add_ln10) : ln_product_ += ln_10
difference = (ln_product_ - ( ln_d1_ + ln_d2_ )).quantize(fiftyPlacesOfDecimals)
print ('''
d1 = {}
ln_d1_ = {}
d2 = {}
ln_d2_ = {}
ln_product_ = {}
'''.format(
d1,ln_d1_ ,
d2,ln_d2_ ,
ln_product_ ,
))
if difference : print ('''
difference = {} ****
'''.format(
difference,
))
For example: During testing, successive invocations of the above code produced:
d1 = 3.300463847393627263496303126765085976697315885228780009201595937 ln_d1_ = 1.1940630184110798505583266934968432937656468440595029 d2 = 4.727915623201914684885711302927600487326893972103794963997766615 ln_d2_ = 1.5534844337520634527664958773360448454701186698422347 ln_product_ = 2.7475474521631433033248225708328881392357655139017377
d1 = 6.56429212435850275252301147228535243835226966080458915176241218 ln_d1_ = 1.8816446762531860392218213681767770852191644273705970 d2 = 8.15468991518212749204100104755219361919087392341006662123706307 ln_d2_ = 2.0985932114606734087366302984138612677420896519457258 ln_product_ = 3.9802378877138594479584516665906383529612540793163228