83214 packages online


No screenshot available
Short:Very fast trigonom. funcs for 040/060.
Author:astegema at (Achim Stegemann)
Uploader:astegema ix urz uni-heidelberg de (Achim Stegemann)
Download: - View contents
This is an updated version compared to last Aminet upload.

* The fastsin and fastcos functions speed as been improved.
* Time of table-initialization has been almost halved.
* The cycle timing has been corrected.
* I beg your pardon, but... the polynoms are of degree 2 and not 3 as stated in
  the last version.

*** History ***

When I was programming my first version of Digital Almanac (Aminet:misc/sci),
I saw, that using trigonometric functions take a long time to calculate.
So I thought that there must be a way to be fast but also to be precise.
Using short tables would burst the speed, but wouldnt be precise enough.
Using Taylor series are only fast for values near zero, but would enlengthen
time for values that are closer to 1 or more, but would use no memory.

As today everybody has enough RAM in his/hers Amiga, memory consuption is no
more a problem. So I decided to write these functions and make them public.

*** Copyright ***

There is no copyright on my idea. Use them as you like it, even if you write
a commercial program. I dont care.
If you have any idea, how to improve speed, tell me !!
Any idea is welcome !!

*** Contents ***

This archive contains assembler source codes for PhxAss that shows, how to
program very fast trigonometric functions (sin,cos,asin,acos,atan2) on a
040/060 CPU.
The source contains interfaces for C, C++ and Assembler stubs.
I myself use PhxAss and StormC V3.

*** Background ***

As you know, the 040/060 CPU does not contain those functions. They have to be
emulated by the 680x0.library. This emulation is very time consuming and not
very multi-tasking friendly.
So StormC offers special algorithms to calculate values from those functions
just by using internal FPU commands. To be 100% compatible to FPU, these
functions need to calculate values with an accuracy of 16 digits.
In every-day-purpose a programmer usually does not need that amount of digits.
10 digits would suffice for their purpose.
This is where my functions join the game.

All fast functions offer an accuracy of about 10 to 13 digits (depending on the
initial value.

*** Speed comparison on a 68060/50 ***

This table shows a speed comparison of the corresponding FPU commands
on my 68060/50. The times are measured in cycles and might vary by
some cycles.
FF=Fast functions

Command                  68060.library    StormC    FF (from C)  FF (from Asm)

fsin.x fpx                   333           284          83           61
fcos.x fpx                   329           281          82           60
fsincos.x fpx,fpc:fps        416           ---          90          ---
fasin.x fpx                  444           404          98           74
facos.x fpx                  434           391          97           74
atan2(y,x)                   ---           320         211          211

As you can see, the fast functions are up to 5 times faster than the
original commands.

The tan command is not listed here, because tan=sin/cos !!

*** How is it done ? ***

Interpolation of sin, cos, asin and acos is realized by using square polynoms.
Starting your program, at first stage tables are filled with polynomial
When you want to receive the value of an input, the program simply evaluates
the corresponding array entry that belongs to your value.

E.g. sin(x) = (p[0]*x+p[1])*x+p[2]
where p is the double-pointer to the array of coefficients.

*** Memory consumption ***

The sin and cos use a table of 506 kB size.
The asin and acos use a table of each 234 kB size.
The atan2 is transformed into a acos, so its table will be used.
( atan2(y,x)=acos(x/sqrt(x*x+y+y)) )

The initialization of the tables will need about one to two seconds on a 060.

*** Register trashing ***

All functions follow the rules for trashing registers (D0/D1,A0/A1,FP0/FP1).
The assembler functions also restore the FP1 register, so only FP0 is filled
the desired return value.

The C/C++ functions also restore the D0 and A0 registers (D1 and A1 are
throughout the code.

*** C includes ***

The prototypes of the functions are easy.

double fastsin(double);
double fastcos(double);
void   fastsincos(double,double &s,double &c); // (C++)
double fastasin(double);
double fastacos(double);
double fastatan2(double y,double x);

I myself have put them into the math.h include.

Contents of dev/asm/fastsincos.lha
---------- ----------- ------- ------- ------ ---------- ------------ -------------
[generic]                  776    2001  38.8% -lh5- a257 Apr 12  2000 fastsincos/fastacos.asm
[generic]                  765    1984  38.6% -lh5- 590a Apr 12  2000 fastsincos/fastasin.asm
[generic]                  294     946  31.1% -lh5- 99be Apr 12  2000 fastsincos/fastatan2.asm
[generic]                 1064    4420  24.1% -lh5- 3517 May 11  2000 fastsincos/fastsincos.asm
[generic]                 2051    4612  44.5% -lh5- 96c0 Apr 17  2000 fastsincos/fastsincos.readme
[generic]                  103     143  72.0% -lh5- 96f4 Apr 12  2000 fastsincos/math.i
[generic]                 2547   12045  21.1% -lh5- 84a4 Apr 12  2000 fastsincos/PhxMacros.i
---------- ----------- ------- ------- ------ ---------- ------------ -------------
 Total         7 files    7600   26151  29.1%            May 12  2000

Aminet © 1992-2020 Urban Müller and the Aminet team. Aminet contact address: <aminetaminet net>