I'm in need for a fast replacement for the cos-function in the
range from -pi/2 to pi/2. Accuracy is not so importrant, as long as
the error is less than 1% and the curve is smooth. I figured out
that a representation of the form
  1 - a * x**2 + b * x**4
is good.

Now I need a fast implementation for the above, usable with borland
pascal where x is single and no numeric coprocessor is required.

--
=============================================================================
Dipl. Phys. Hans L. Trautenberg                       Universitaet Regensburg
                           Institut fuer Experimentelle und Angewandte Physik
phone (49) 941 943 2466                                         Polymerphysik
fax   (49) 941 943 3196                                    D-93040 Regensburg
e-mail  hans.trautenb...@physik.uni-regensburg.de                     Germany

The problem with the look-up table is that the resulting curve
is not smooth, and smoothness is very important.

In article <41rtq3$...@rrzs3.uni-regensburg.de>, c4140@rphs45 (Hans Trautenberg t2466) writes:

cos (x) ~ 0.995 - 0.4995 x^2 + 0.0367 x^4

If you program that straightforward

function MyCos (x:real):real;
begin
   x:= sqr(x);
   MyCos := 0.995 + x*(-0.4995 + 0.0367 * x)
end;

you achieve a speedup of a factor 3 with respect to the library cosine.
(if you DONT use the 80x87, otherwise its only a factor 2)
If you do not need that accuracy (you say 1%, but I suppose you mean +/- 0.01)
then you can do better than that by dividing the interval between
[0,1] and [1,\pi/2] (I'll assume x positive)

function MyFastCos (x:real) : real;
begin
   if (x>1) then
       MyFastCos := 0.955 * (pi/2 - x)
   else
       MyFastCos := 0.995 - 0.46 * x * x;
end;

This gets you another speedup factor of two. (Accuracy drops to 0.01 though)
Maybe there's somewhat more to be gained by using integer arithmetic.

: Using your form one can obtain an accuracy of 0.0007 across the interval
: [-pi/2, pi/2] with

: cos (x) ~ 0.995 - 0.4995 x^2 + 0.0367 x^4

: If you program that straightforward

: function MyCos (x:real):real;
: begin
:    x:= sqr(x);
:    MyCos := 0.995 + x*(-0.4995 + 0.0367 * x)
: end;

: you achieve a speedup of a factor 3 with respect to the library cosine.
: (if you DONT use the 80x87, otherwise its only a factor 2)

: Maybe there's somewhat more to be gained by using integer arithmetic.

I store my arguments of the cosine as longints with
  2^32  =  pi,
     0  =  0,
-(2^32) = -pi

So what would be the best implementation of the function above with
this representation of the argument?

Thanks in advance for any help.

--
=============================================================================
Dipl. Phys. Hans L. Trautenberg                       Universitaet Regensburg
                           Institut fuer Experimentelle und Angewandte Physik
phone (49) 941 943 2466                                         Polymerphysik
fax   (49) 941 943 3196                                    D-93040 Regensburg
e-mail  hans.trautenb...@physik.uni-regensburg.de                     Germany

:  A look up table is as smooth as you want, as long as you pre-calculate
: enough values. Correct?

If you pre-calculate enough values you need a lot of memmory, and memmory
is limited in real mode. And I have to use real mode.

The  Trunc() or Round() operations needed to index into the lookup table were
just as slow as computing the Cosine (under emulation).

Anyone know a QUICK method of generating an integer from a real ?

In article <41v6u7$...@sparky.midwest.net> rwp...@ldd.net (R W Pick) writes:

If you need more hints, ask me!

Joerg.

You'll need to init arCos, eg:
procedure InitFastCos;
  var
    cCos: Integer;
  begin
    for cCos := -314 to 314 do
      arCos[cCos] := Cos(cCos / 100);
    end;

arCos takes about 3K of your datasegment. Since you allow a 1% error,
you can consider creating an array of ShortInts, and dividing the result by
127:

var
  arCos: array [-314..314] of ShortInt;
function RealFastCos(Omega: Real): Real;
  begin
    FastCos := arCos[100 * Round(Omega)] / 127;
  end;

arCos will now take 629 bytes.
BTW you can win some extra clockcycles by changing the 100 to 128, and
changing the arraybounds accordingly. BP multiplies Integers faster when
the multiplier is a power of 2.