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
:
|
.
See
.
If you continue to calculate derivatives, you will produce the following sequence:
Some basic checking:
Also,
Show that
or that
If abs
|
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.
Let To calculate
Using the half-angle formula
calculate and
This value was chosen for because
is close to For approx.
If the code below is accurate to
places of decimals.
This section uses the whole sequence of derivatives:
where
where
where
where
and so on.
Using
then and:
The calculation of above is suitable as input to application grapher.
The following python code has precision set to
If it is desired to calculate for one value of the following
python code is much faster than the code supplied to grapher above.
data = '''
0.641408500107916119519456357419567
0.642007672351961308722194845349589
-0.307784813093926647718267596858344
0.0593488181385222989480915882567083
0.0561214921656187370934563384765525
-0.0659097533448882821311588570897649
0.0286426911533663404678396477942956
0.00668482448938922740475019519860028
-0.0193999695469386388307782988276083
0.0131962921095527373607946721380589
-0.00142363533752891809783467677853379
-0.00569081731450817066412759667853352
0.00576341629406082560985217113222417
-0.00200953040304101268575767827219472
-0.00138241310354647511896352626325379
0.00235523537942597536210668729668636
-0.00134052593544293120653813909608214
-0.000124472012041684625103492011289663
0.000877718485310658054963862962235904
-0.000725780248549220293079370291315901
0.000153946002651081672732427784261987
0.000281002093489218044668996986822804
-0.000347033077495896376046600902527326
0.000153557047587153171615262184995174
0.0000631326094505423737466139726989411
-0.000148809498659804128090655494778209
0.0000997799319170460620050372271284211
-0.00000366756177968522484138187499300975
-0.0000560928643292255048420965789718678
0.0000541205773846002851156650754617952
-0.0000165509024241990403901897952115479
-0.0000171467417823198598606760175136922
0.0000258885580286696864110764494276036
-0.0000137290969049302627955313384274982
-0.00000286640686420803377244711837064614
0.0000109803604865810554310928802164877
-0.00000849771791124436153228043859514619
0.00000125914643600127456024329626150593
0.00000399293970401995517700352660353714
-0.00000449726868310084877916993424187367
0.00000176894518824413723563652493847337
0.00000109170674908376885093776045369610
-0.00000210342391231037589357119537437086
0.00000130161708299603955561297199526169
6.93796790980872151538233731691180E-8
-8.63552561198933240294736649885292E-7
7.67385763113287917587459691270367E-7
-1.89314055344153668337714983394592E-7
-2.94403306828973215629670453652457E-7
3.93099106151287980463564320621599E-7
-1.87924142642173789971818089630347E-7
'''
from decimal import *
getcontext().prec=33
listOfMultipliers = [ Decimal(v) for v in data.split() ]
def arctan (x) :
x = Decimal(str(x))
if 1.05 >= x >= 0.45 : pass
else : print ('\narctan(x): input is outside recommended range.',end='')
y = Decimal(0)
x0 = Decimal('0.746735417783721671737500140715213') # tan36.75
x_minus_x0 = x - x0
X = Decimal(1)
status = 1
for p in range(0,51) :
toBeAdded = listOfMultipliers[p] * X
if abs(toBeAdded) < Decimal('1e-31') :
status = 0
break
y += toBeAdded
X *= x_minus_x0
if status :
print ('\narctan(x): count expired.', end='')
str1 = '''
arctan({}) = {}, count = {}
'''.format(x,y,p)
print (str1.rstrip())
return y
|
x = Decimal('0.75')
arctan(x)
|
arctan(0.75) = 0.643501108793284386802809228717315, count = 12
|
When is close to result is achieved with only 12 passes through loop.
|
Check results using known combinations of and
For and other exact values of see
Exact Values for Common Angles.
π = "3.14159265358979323846264338327950288419716939937510582097494459230781"
π = Decimal(π)
rt3 = Decimal(3).sqrt()
rt5 = Decimal(5).sqrt()
rt15 = Decimal(15).sqrt()
tan27 = rt5 - 1 - (5 - 2*rt5).sqrt()
tan30 = 1/rt3
v1 = 2 - (2-rt3)*(3+rt5) ; v2 = 2+ (2*(5-rt5)).sqrt()
tan33 = v1*v2/4
tan36 = (5-2*rt5).sqrt()
v1 = (2-rt3)*(3-rt5)-2 ; v2 = 2 - (2*(5+rt5)).sqrt()
tan39 = v1*v2/4
tan42 = ( rt15 + rt3 - (10 + 2*rt5).sqrt() )/2
tan45 = Decimal(1)
values = (
( 9*π/60, tan27, 27),
(10*π/60, tan30, 30),
(11*π/60, tan33, 33),
(12*π/60, tan36, 36),
(13*π/60, tan39, 39),
(14*π/60, tan42, 42),
( π/ 4, tan45, 45),
)
for value in values :
angleInRadians, tan, angleInDegrees = value
y = arctan(tan)
print ('for', angleInDegrees, 'degrees, difference =', angleInRadians-y)
|
arctan(0.509525449494428810513706911250666) = 0.471238898038468985769396507491970, count = 41
for 27 degrees, difference = -4.5E-32
arctan(0.577350269189625764509148780501958) = 0.523598775598298873077107230546614, count = 34
for 30 degrees, difference = -3.1E-32
arctan(0.649407593197510576982062911311432) = 0.575958653158128760384817953601229, count = 27
for 33 degrees, difference = 1.3E-32
arctan(0.726542528005360885895466757480614) = 0.628318530717958647692528676655896, count = 17
for 36 degrees, difference = 4E-33
arctan(0.809784033195007148036991374235772) = 0.680678408277788535000239399710521, count = 23
for 39 degrees, difference = 3.7E-32
arctan(0.90040404429783994512047720388537) = 0.733038285837618422307950122765236, count = 33
for 42 degrees, difference = -1.9E-32
arctan(1) = 0.785398163397448309615660845819846, count = 43
for 45 degrees, difference = 3.0E-32
|
|
tan24 = ( (50+22*rt5).sqrt() - 3*rt3 - rt15 ) / 2
tan46_5 = Decimal('1.05378012528096218058753672331544') # tan(46.5)
values = (
(24*π/180, tan24, 24),
(93*π/360, tan46_5, 46.5),
)
for value in values :
angleInRadians, tan, angleInDegrees = value
y = arctan(tan)
print ('for x =', float(tan), 'difference =', angleInRadians-y)
|
arctan(x): input is outside recommended range.
arctan(0.44522868530853616392236703064567) = 0.418879020478639098461685784437249, count = 47
for x = 0.44522868530853615 difference = 1.8E-32
arctan(x): input is outside recommended range.
arctan(1.05378012528096218058753672331544) = 0.811578102177363253269516207347250, count = 48
for x = 1.0537801252809622 difference = -4.4E-32
|
For the above calculation of is accurate to more than 30 places of decimals.
|
If input is outside recommended limits, this does not necessarily mean that result is invalid.
If result is accurate to precision of python floats, 15 places of decimals.
|
|
|
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.
from 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
If
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

According 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
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
-
Graph of
representing
with powers of
limited to
.
-
Graph of
representing
with powers of
limited to
.
-
Graph of
representing
with powers of
limited to
.
The 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
Generally, for
close to
This 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.
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.
Choose 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
Mathematics resources |
---|
Activities | |
---|
Articles | |
---|
Categories | |
---|
Courses | |
---|
Glossaries | |
---|
Lectures | |
---|
Lessons | |
---|
Lists | |
---|
Portals | |
---|
Problem sets | |
---|
Projects | |
---|
Quizzes | |
---|
Schools | |
---|