Cosine

[Qfwfq]

I just thought you had meant straightedge-and-compass constructions and not others (such as marked straightedge).

 

I’ve a faint recollection of straightedge-and-compass constructions of an arc of a circle with length equal a given line segment, and vice versa

[Qfwfq]

The problem’s less obvious as "solve for [math]x[/math] in terms of [math]a[/math]"

[LATEX]x=e^{\frac{x}a}[/LATEX], where [LATEX]a \ge e[/LATEX],

or even more generally [LATEX]x=b^{\frac{x}a}[/LATEX], where [LATEX]a \ge b[/LATEX],

First, the simplest: we can cast away b at no loss of generality, because it's like dividing a by ln b so it's just a different value of a. Now:

 

[LATEX]x=e^{\frac{x}e}[/LATEX]

 

is just the [LATEX]\norm\alpha = e[/LATEX] case of:

 

[LATEX]x=e^{\frac{x}\alpha}[/LATEX]

 

with [LATEX]\norm\alpha[/LATEX] being a continuous parameter. Hence if we imagine starting from the case of known solution, we take the differential of f(x) to calculate it's variation, constraining it to equal the variation of x ([LATEX]\norm df(x, \alpha) = dx[/LATEX]), we get the following differential equation that can be integrated from the known case (the boundary condition) to [LATEX]\norm\alpha = a[/LATEX]:

 

[LATEX]dx=(\frac{dx}{\alpha} - \frac{x\,d\alpha}{a^2})e^{\frac{x}{\alpha}}[/LATEX]

 

Of course, I reasoned in a manner which can be applied to another [LATEX]\norm f(x, \alpha)[/LATEX] such that there's a known solution for some value of the parameter. Ron's equation with the cosine and mine with the arc of circumference are just the cases for [LATEX]\norm\alpha[/LATEX] equal to 0 and 1 of:

 

[LATEX]f(x, \alpha) = \cos(\alpha(\arcsin x - x) + x) = x[/LATEX]

[max4236]

n=16
x=0
for j=1 to 20
 s=sqr(2*(1-x))
 for i=1 to n
   s=sqr(2*(1-sqr(1-(s^2)/4)))   <-no trig functions :hyper:
 next
 c=s*(2^n) 'arc length
 e=(c-x)/2  
 x=x+e 'new x
next

 

x_____________________approx. arc length____________cos(x)-x

0.000000000000000 1.570796326662672 1.000000000000000

0.785398185253143 0.667457180761072 -.078291419520906

0.726427681744099 0.757686802121122 0.021124231354572

0.742057241499424 0.734662190992278 -.004977417554213

0.738359716255218 0.740161404309376 0.001213872043187

0.739260560309049 0.738824668649598 -.000293608266518

0.739042614484788 0.739148251516641 0.000071159190534

0.739095433000330 0.739069842638293 -.000017237883560

0.739082637819592 0.739088837878121 0.000004176321739

0.739085737848882 0.739084235679726 -.000001011922404

0.739084986764283 0.739085350555388 0.000000245101943

0.739085168659841 0.739085080578588 -.000000059320644

0.739085124619216 0.739085146103888 0.000000014386277

0.739085135361552 0.739085130037589 -.000000003592226

0.739085132699570 0.739085134132920 0.000000000862898

0.739085133416245 0.739085132872818 -.000000000336537

0.739085133144532 0.739085133502869 0.000000000118205

0.739085133323701 0.739085133187844 -.000000000181654

0.739085133255772 0.739085133187844 -.000000000067968

0.739085133221808 0.739085133187844 -.000000000011125

 

[Qfwfq]

Gosh Max, it took me a few coffee breaks to decrypt your geometry! :) The root of 2*(1-x) had me stumped.

 

I don't know what platform you're using but I translated it into C, using type double, my values don't converge the same way. They end up in a loop. :)

 

void main(){
int i, j, n=16;
double c, e, s, x=0;
for(j=0; j<40; j++){
  s=sqrt(2*(1-x));
  for(i=0; i<n;i++){
	s=sqrt(2*(1-sqrt(1-(s*s)/4)));
  }
  c=s;//*(2^n) 'arc length
  for(i=0; i<n; i++)c *= 2;
  e=(c-x)/2; 
  x=x+e;
  printf("%.15f %.15fn", x, c);
}
}

.....................................................
0.739085298877358 0.739085571703172
0.739085112704231 0.739084926531105
0.739085342203702 0.739085571703172
0.739085134367403 0.739084926531105
0.739085030449254 0.739084926531105
0.739085301076213 0.739085571703172
0.739085113803659 0.739084926531105
0.739085342753415 0.739085571703172
0.739085134642260 0.739084926531105
0.739085030586682 0.739084926531105
0.739085301144927 0.739085571703172
0.739085113838016 0.739084926531105
0.739085342770594 0.739085571703172
0.739085134650849 0.739084926531105
0.739085030590977 0.739084926531105
0.739085301147074 0.739085571703172
0.739085113839089 0.739084926531105
0.739085342771131 0.739085571703172
0.739085134651118 0.739084926531105
0.739085030591111 0.739084926531105
0.739085301147142 0.739085571703172
0.739085113839123 0.739084926531105
0.739085342771148 0.739085571703172
0.739085134651126 0.739084926531105
0.739085030591115 0.739084926531105
0.739085301147144 0.739085571703172
0.739085113839124 0.739084926531105
0.739085342771148 0.739085571703172
0.739085134651126 0.739084926531105
0.739085030591115 0.739084926531105

Actually c is superfluous, since the value of s isn't used again.

[CraigD]

Impressive, Max!

 

I must confess to being the dullest mind in the thread at present, since, after more than a few coffee breaks, I still don’t understand how the arc length approximation works. I tried something similar using a more straightforward technique like this (translated from MUMPS to BASIC, so may not actually work):

p=10000 ‘lots of steps
x=0
for j=1 to 15
 s=0
 i=(1-x)/p
 for xi=xi+i to 1 step i
   s=s+sqr((sqr(1-(xi-i)^2)-sqr(1-xi^2))^2+i^2)
 next
 'trickery to handle xi<1 here, unless extra-precision math used
 x=x+(s-x)/2
next

and got a much poorer approximation of x, 0.73908512483787916150 from much more calculating :)

 

Could someone point me to an explanation of the “s*2^n” arc length approximating technique? :)

I don't know what platform you're using but I translated it into C, using type double, my values don't converge the same way. They end up in a loop. :)

I had similar issues using the intrinsic calculator in MUMPS (which the language standard defines as having a minimum precision of 16 decimal digits, but most implementation slightly exceed with something roughly equivalent to 64 bits). The best precision I could manage without using an high-precision math module was N=16:

s N=16,X=0 f J=1:1 s S=1-X*2**.5,C=1 x "f I=1:1:N s S=S*S/4,S=1-S**.5,S=1-S*2**.5,C=C*2" s C=C*S,P=X,X=C-X/2+X q:P=X  w J," ",X," ",C,!

1 .785398163172777521 1.570796326345555042
2 .7264276889531387869 .6674572147335000529
...
49 .739085133254013297 .739085133254013297

Reducing N until X converges to a single value appears to fix limited precision problems without changing only the values precision, not skewing it:

s N=8,X=0 f J=1:1 s S=1-X*2**.5,C=1 x "f I=1:1:N s S=S*S/4,S=1-S**.5,S=1-S*2**.5,C=C*2" s C=C*S,P=X,X=C-X/2+X q:P=X  w J," ",X," ",C,!
1 .78539693131928277 1.57079386263856554
2 .7264279743774660964 .6674590174356494228
…
38 .7390850299039340385 .7390850299039340385

Though for some Ns, X doesn’t converge to a single value.

[Qfwfq]

I still don’t understand how the arc length approximation works.

Well, it was easy to guess that each cycle of the inner loop takes the value of s from the length of a chord to that for half the angle. Now it's clear enough that the root of 1-(s^2)/4 gives the apothem which of course is the cosine of half the angle (no trig functions, eh?) and 1 minus that is the sagitta from which we can get the new chord. However I kept making a hash of the algebra as well as confusing the hypotenuse (new chord) with the long cathetus (old semichord), due to the well-known skinny triangle effect. :) When you get it straight, you can understand the reason for the root of 2*(1 - x) too.