#define Bignum Double ‘ implement your bignum maths for these variables

Function Cosine(Byval x As Bignum) As Bignum
‘ start with bignum in x
Dim As Bignum mxs, term, sigma, last_sigma, divisor
Dim As Integer n
mxs = x * x ‘ precompute
mxs = – mxs ‘ minus x squared
term = 1.00
sigma = 1.00
n = 0 ‘ the only freebasic integer used
Do
n = n + 2 ‘ very fast integer math
divisor = (n * (n-1)) ‘ use str(n * (n-1)) to convert integer to bignumber
last_sigma = sigma ‘ keep a copy of the last sigma
term = term * mxs
term = term / divisor
sigma = sigma + term
Loop Until last_sigma = sigma ‘ test if no change to sigma
Return sigma
End Function

Function Sine(Byval x As Bignum) As Bignum
‘ start with bignum in x
Dim As Bignum mxs, term, sigma, last_sigma, divisor
Dim As Integer n
mxs = x * x ‘ precompute
mxs = – mxs ‘ minus x squared
term = 1.00
sigma = 1.00
n = 1 ‘ the only freebasic integer used
Do
n = n + 2 ‘ very fast integer math
divisor = (n * (n-1)) ‘ use str(n * (n-1)) to convert integer to bignumber
last_sigma = sigma ‘ keep a copy of the last sigma
term = term * mxs
term = term / divisor
sigma = sigma + term
Loop Until last_sigma = sigma ‘ test if no change to sigma
sigma = x/ (1/sigma)
Return sigma
End Function

‘work functions
dim as double deg,c,s
for deg = 0 to 360
dim as double rad = atn(1)/45
c = Cosine(deg*rad)
s = Sine(deg*rad)
print deg ;” – ” ; s ; ” – ” ; c ; ” – ” ; atan2(s,c)/rad
next deg

sleep

‘attempt to duplicate
‘ tangent * half tangent
‘ to figure the hypotenuse “C” of the angle

dim as double rad = atn(1)/45
dim as double y1,y2,y3,formula
dim as double deg
print “deg hypotenuse my formula error level”
for deg = 0 to 45 step 1

y1=tan(deg*rad)
y2=tan(deg/2*rad)

y3 = 1+ (y1*y2) ‘ y1*y2 = hypot length between circle and square of 1

formula = 1+1/(( 1 / ((deg*rad) *(deg/2*rad)) ) – (sqr(.69999)-.00019088303*deg))

print deg ; ” – ” ; y3 ;” – ” ; formula ; ” – ” ; formula – y3

next deg

sleep
‘Where tan(deg*rad) * tan(deg/2*rad) + 1 = hypotenuse of tangent

atn(1)/ ( atn(1)/ (deg*( atn(1)/45) ) – ((1 – atn(1))/45*deg) )

For deg = 0 To 90 Step 1

if deg <=45 then
sine =( (deg*1.5) / (90+(deg/8) ) )
cosine = sqr(1-s*s)
else
cosine = ( ((90-deg)*1.5) / (90+((90-deg)/8)) )
sine = sqr(1-c*c)
end if

x=radius*c
y=radius*s

line(xctr,yctr)-(x, y),14

next deg

Albert, I appreciate what you’re trying to do here, but your approach to the subject could use some work. Your expressions are way too complicated, and using more or less random angular units. This makes it very hard to see what they actually say. Also, you’re not stating the reasons behind the coefficients, nor doing proper error analysis; with the exception of Richard’s, the expressions are worse than the ones in the article.

First, here are the expressions again, but compressed to their essentials. I will use the coordinate transformation z[=]x/(½π), because having the boundaries at 0.0 and 1.0 makes things much easier to analyse. Note how much smaller they are.

The first thing to remember when analyzing mathematical expressions is to disregard the numbers. The actual numbers don’t really matter. You can always move and scale the window you’re working on to a simpler interval, like between 0 and 1. Not only do 0 and 1 often cancel in expressions, but have the benefit of not being approximations. What really matters are the order of the expressions and the operations; read through the numbers until it’s time for the final implementation.

S_a1, S_a2 and S_a3 are all parabola with different coefficients. Notice how much smaller and easier to read S_a1 is compared to the original of comment #9. I actually messed up the earlier rewrite because the original form is so awkward with all theparentheses and divisions. Always try to simplify the expressions before you post them. I also managed to figure out that the coefficients of S_a1 actually involve π and √2, something that was very non-obvious from the original expression. I’d very much like to know where these came from.

S_a2 is actually the same as S₂ from eq 1, only written in terms of z instead of x. This was essentially the first of the exercises. The coefficients from S_a3 seem of come out of thin air, and do not seem to work as well as the other parabola (more on that later).

S_a3 is … interesting, but in the end it’s just another third order polynomial, much like S₃. The thing is that S_a1 is more complicated and not as accurate as S₃, and doesn’t even properly match up at the z[=]1 boundary. By the way, the reason I used (1−z) terms in the equation is because it’s actually more of a cosine approximation than one for sines. To turn in into a cosine, change the (1−z) into a simple z.

S_a4 is a basic fifth order polynomial, like discussed in section 2.1, and it in fact more accurate than S₅ and even S_5o. However, no mention was made on where the coefficients came from and in fact there are more accurate coefficients. For example, using the Solver to minimize the RMSD under the condition S(z=1)[=]1 gives (a,b,c) ≈ (1.57033, 0.64209, 0.07176), for an RMDS of 58e-6, whereas the coefficients of S_a4 result in RMSD=88e-6.You can also use something called
Chebyshev polynomials, which may look kinda funky but includes a method for finding very good coefficients.

Using a different set of conditions or miniziming for some other target error will give different sets of coefficients, all of which will be ‘best’ for those conditions. And this is something you will have to remember: there is no single ‘best’ approximation or set of coefficients ; the ‘best’ depends on what criteria you use. Not specifying your conditions means other people won’t know where your coefficients come from. Since their uses may differ from yours, this can lead them up a blind alley.

That covers the forms of the expressions, now for the error analysis. You mentioned ‘degree spacing’, but I’m not really sure what that means. If you’re talking about that if you evaluate the approximation at some point x, the position of its ‘real’ value can be found at, say,|Δx| < 0.01°, that’s not what I’m seeing. But even if that’s not what you mean, a more useful error measurement is in the y-direction: ε[=]approx − real sine. That you can analyse for the items from Table 2, 3 and 4: the minimum, maximum and average error, and the average squared-distance, RMSD.

What you should not do is plot a circle and see if it looks circlish. This is problematic for several reasons. First, above some radius you will get gaps because you will use less angle-iterations then there are pixels for the circumference. This is unavoidable. You’d want something that is sure to cover everything, like Bresenham’s
Midpoint circle algorithm. Second, just plotting the points from the approximation means that you have nothing to compare it to, so you couldn’t tell what is correct and what isn’t. Added to that is the fact that you’re limited to the size of the pixels: With a radius of 100, you can visualise 1% accuracy at best.

Below is a table of relative error statistics, comparable to Table 4. I should probably point out that, even though it’s a parabolic approximation, S_a1 gives good results because use the sine-approx for the first octant and √(1-s²) for the second. Splitting it into sine and cosine parts for the first quadrant is a really neat idea, though I’m not sure if it’s ultimately better than simply using a higher-order approximation.

If you’re still looking for suitable approximations, keep these points in mind.

• Keep the expressions simple! The correctness of an approximation is mostly determined by the order of the polynomial. No matter how clunky you make an expression, it makes no difference if, at the end of the day, it amounts to a simple parabola. Those are gonna suck no matter what (relative to higher-order, I mean).

• Stay away from raw numbers as much as possible. Raw numbers do not translate well to other situations (see the Gimli glider incident linked in the article), and will almost always only be approximations. Either use ‘natural’ dimensionless units like radians or scale the situation to a [0, 1] domain or range.

• Before you do anything, decide what ’sufficiently good’ means for your situation. Consider things like accuracy at the boundaries, smoothness of the function, calculation time and min/max/overall errors. When showing your work to others, include how you got to your conclusions. Graphs also help, though I understand that’s a little hard to put in a comment.

• Above all, make sure it’s actually an improvement over what is already available. The idea to divide into octants instead of quadrants is a great idea, but most of the actual approximations you provided was either the equal or worse than what was already
  presented.

If you’re interested, I’ve uploaded the Excel file I used for the analysis here. I’ve condensed it for size, but the essentials are there. The main sheet contains a sizable amount of approximations and their errors. The extra sheet shows an example of how you can calculate coefficients from a set of conditions, in this case for eq 24 and comment #6.

dim as double sarc,carc,sgrad2,cgrad2
dim as double deg = atn(1)/100
For grad = 0 To 100 Step 10

sgrad2 = grad * 2
cgrad2 = 200 – (grad*2)

sarc = deg * (grad*2)
carc = deg * (200-(grad*2))

s = sarc * ((100- ((sgrad2 * .0009)*sgrad2)) / 100) *.99
c = carc * ((100- ((cgrad2 * .0009)*cgrad2)) / 100) *.99

x = radius * c
y = radius * s

Pset (xctr + x, yctr – y), 9
Next

‘ Richards version using radians
Const As Double Pion2 = 2 * Atn(1)
For t = 0 To Pion2 Step pion2/100 ””’divided pion2 by required degrees.
tt = t * t
s = t * ( 1 + tt * ( -0.166 + tt * 7.589986441271250e-3)) ‘ odd function
c = ( 1 + tt * ( -0.496 + tt * 3.676551227144884e-2)) ‘ even function

x = radius * c
y = radius * s
Pset (xctr + x, yctr – y), 13
Pset (xctr + x, yctr + y), 13
Pset (xctr – x, yctr – y), 13
Pset (xctr – x, yctr + y), 13
Next t

dim as double deg,sine,cosine
dim as double xctr,yctr,radius,x,y,holdx

screen 19

xctr = 305
yctr = 305
radius = 300

circle(xctr,yctr),radius+1,9
x = radius
y = 0
for deg = 0 to 100 step .5

sine = (10000 – ((100-deg) * (100-deg))) *.0001 *(.8 + (.00208*deg))
cosine = (10000 – (deg*deg)) *.0001 *(.999 – (.0005*deg))
holdx = x
x = radius * cosine
y = radius * sine

line(xctr,yctr)-(xctr+ x,yctr+ -y),14
line(xctr,yctr)-(xctr+ x,yctr+ y),14
line(xctr,yctr)-(xctr+ -x,yctr+-y),14
line(xctr,yctr)-(xctr+ -x,yctr+ y),14

next

sleep

I’ve tested it and it does work well. It’s about twice as accurate as the third-order approximation, S₃(x). However, there are two problems with it.

First, it uses a square root, which is not a simple operation. If it’s not in the instruction set of the processor you’re working with, it will probably cost at least as much as calculating a sine.

Second, even if you have a fast square root and assuming it’s as fast as a multiplication (which is a big assumption), you’d have to spend 4 MULs worth of cycles. Since the fifth order function also uses 4 multiplications and is considerably more accurate, you’d be better off using that.

cosine = sqr(1- sine * sine)

here is an arc formula that i believe plots a parabola. if i’m not mistaken.

y = (180-deg)*(deg/180) * .0222

it deviates from a true sine curve on the sides by about 5 degrees wider than the sine curve.