DEMO.DESIGN FAQ


следующий фpагмент (2)- [169] Demo/intro making and discussion (2:5030/84) ------------- DEMO.DESIGN -
 Msg  : 459 of 462                                                              
 From : Oleg Homenko                        2:461/318.50    13 Sep 95  18:26:00 
 To   : All                                                                     
 Subj : Sine generator - again                                                  
--------------------------------------------------------------------------------
Мое почтение, Mr(s). All!

Поскольку все молчат, как рыбы об лед :) кидаю то, что у меня получилось с
использованием намеков, услышанных на IRC


; sine & cosine generator by Karl/Nooon (40 byte version? Never seen one)
; optimized to 41 bytes by Beeblebrox/TMA
; 256 degrees, 8.24 fixed point
.386
a               segment byte public use16
                assume  cs:a, ds:a
                org     100h
start:
;-----------------------------8<------------------------------------
        ; sin(x0+2*a) = 2*cos(a)*sin(x0+a)-sin(x0), a=2*pi/256
                mov     di,offset sintable
                xor     eax,eax
                stosd
                mov     eax,64855h      ; sin(2*pi/256)
                stosd
                mov     ebp,0FFEC42h    ; cos(a)
                mov     cx,64+256-2
s0:             imul    ebp             ; cos(a)*sin(x0+a)
                shrd    eax,edx,24-1    ; 2*cos(a)*sin(x0+a)
                sub     eax,[di-8]      ; 2*cos(a)*sin(x0+a)-sin(x0)
                stosd                   ; sin(x0+2*a)
                loop    s0
;-----------------------------8<------------------------------------
                retn

sintable        dd      64 dup(?)
costable        dd      256 dup(?)

a               ends
                end     start

Сразу говорю, что младшие 16 бит не обязательно точные - хотите отбрасывайте
их, а нет - и так сойдет

      C U l@er!
                  Oleg

следующий фpагмент (3)|пpедыдущий фpагмент (1)- Usenet echoes (21:200/1) ----------------------------- COMP.SYS.IBM.PC.DEMOS -
 Msg  : 30 of 34                                                                
 From : fbecker@sol.UVic.CA                 2:5030/144.99   16 Apr 94  06:56:56 
 To   : All                                                 17 Apr 94  23:03:28 
 Subj : That sine table thing again...                                          
--------------------------------------------------------------------------------
Organization: University of Victoria, Victoria B.C. CANADA

Ok, since Phil asked so nicely here is the 'fixed' version.
In order to get the correct sin values between pi/4 and pi/2
I calc cos between 0 and pi/4 (and then flip.)
This sucker is of course twice as long as the previous version,
but at least it's shorter than having the table sitting around.
Note that this is somewhat of a quick hack. You could probably
shave a few bytes off, which is left as an exercise
to the reader (dont you hate when someone says that...)

If you have any questions on how this works, just ask...

Frank.

PS: Ehemmm..., I haven't actually used this proc, so maybe it's
still screwy - hahahahahaha!

;--------------------------------------------------

ITERATIONS              EQU 4

sinrez      dd  0aaaaaabh    ; 1/(2*3)
      dd  03333333h    ; 1/(4*5)
      dd  01861862h    ; 1/(6*7)
      dd  00e38e39h    ; 1/(8*9)

cosrez      dd  20000000h    ; 1/(1*2)
      dd  05555555h    ; 1/(3*4)
      dd  02222222h    ; 1/(5*6)
      dd  01249249h    ; 1/(7*8)

sinx        dd 0
cosx        dd 0
xx          dd 0

SinTable        PROC  SINTABLEPTR       :DWORD

  push    edi
  push    esi
  push    ebx
  push    ecx

  xor     edi,edi
  les     di,SINTABLEPTR    ;table should be 1024 DWORDS long
  xor     ecx,ecx

next_entry:
  push    ecx
  mov     si,4*(ITERATIONS-1)
  mov     cs:sinx,040000000h
  mov     cs:cosx,040000000h

  mov     eax,cs:xx
  mov     ebx,eax
  imul    cs:xx
  shrd    eax,edx,30              ;eax is NUM^2
  mov     ebx,eax
sinHP1:
  mov     eax,ebx
  mov     ecx,cs:sinrez[si]          ;2^30/const = 1.000/const
  imul    ecx
  shrd    eax,edx,30
  imul    dword ptr cs:sinx
  shrd    eax,edx,30
  neg     eax
  add     eax,040000000h          ;add 1.0
  mov     cs:sinx,eax

  mov     eax,ebx
  mov     ecx,cs:cosrez[si]          ;2^30/const = 1.000/const
  imul    ecx
  shrd    eax,edx,30
  imul    dword ptr cs:cosx
  shrd    eax,edx,30
  neg     eax
  add     eax,040000000h          ;add 1.0
  mov     cs:cosx,eax

  sub     si,4
  jae     sinHP1
  sar     eax,14
  push    eax
  mov     eax,cs:sinx
  imul    cs:xx
  sar     edx,12
  pop     eax

  pop     ecx
  push    cx
  shl     cx,2
  add     di,cx
  mov     es:[di],edx
  mov     es:[di+256*4],eax
  sub     di,cx
  sub     di,cx
  mov     es:[di+512*4],edx
  mov     es:[di+256*4],eax
  neg     eax
  neg     edx
  mov     es:[di+1024*4],edx
  mov     es:[di+768*4],eax
  add     di,cx
  add     di,cx
  mov     es:[di+512*4],edx
  mov     es:[di+768*4],eax
  sub     di,cx
  pop     cx

  add     cs:xx,006487edh      ;(pi/4)/128 in 2.30
  inc     cx
  cmp     cx,128
  jle     next_entry

  pop     ecx
  pop     ebx
  pop     esi
  pop     edi

  ret

SinTable          ENDP
;--------------------------------------------------

следующий фpагмент (4)|пpедыдущий фpагмент (2)- Usenet echoes (21:200/1) -------------------------- COMP.GRAPHICS.ALGORITHMS -
 Msg  : 17 of 31                                                                
 From : eyal@fir.canberra.edu.au            2:5030/144.99   18 Apr 94  13:20:30 
 To   : All                                                 21 Apr 94  00:21:30 
 Subj : Re: Fast atan2(y/x) ?                                                   
--------------------------------------------------------------------------------

In <2oc7j5$chn@tuegate.tue.nl> jeanpaul@blade.stack.urc.tue.nl (Jean-Paul
Smeets) writes:

>In article <2obpf5$8n8@hermes.louisville.edu>,
>Joe Muller <jamull01@romulus.spd.louisville.edu> wrote:
>>
>>  With all this talk about a fast square root algorithm I was wondering
>>if anyone has a reasonably fast atan2 ?  I have seen some approximations
>>that return values from 0 to 255 but since I am already using floating point
>>I need something that returns values from -PI to PI, or 0 to 360.
>>  I also need accuracy within +- 2 degrees, not -+ 5 or 10, so I was
>>thinking along the lines of a power series with maybe a dozen or so iterations
>>
>I use a 10 bit fixed point atan2 in my real time code. It uses one division
>and a table for one quadrant. The precision can be adapted by changing the
>size of the lookup table.

>Jean-Paul

If we are into table lookup integer trigs, here is what I use often. It
uses 16 bit ints and gets good accuracy by carefully spliting the
ranges.

I have here sin (and cos) arcsin and atan2


/* sincos.c
 *
 * From Eyal Lebedinsky, eyal@ise.canberra.edu.au
 * 8 Jan 94.
 *
 * fractions kept such that 1.0 is 16*1024, so the range is [-2.0,2.0)
 * angles kept such that -180 degrees is 0x8000, so the range is [-180,180)
 *
 * You must call set_tring() first. I actually dump the tables and then
 * use them as initialized static arrays, no need to initialize. Floating
 * point is used ONLY during the initialization phase, <math.h> only used
 * then.
 *
 * to compile, try:
 * gcc -o sincos sincos.c -lm
*/

#include <stdio.h>
#include <math.h>

#define NEAR
#define FAR
#define FASTCALL
#define ANGLE     short

#define FSCALE    14   /* fraction bits in sine/cos etc. */
#define FONE   (1<<FSCALE)
#define   FnDIV(n,x,y) ((int)(((long)(x) << (n)) / (y)))
#define   fdiv(x,y)   FnDIV (FSCALE, (x), (y))
#define D90    0x4000
#define D180   0x8000
#define DEG(x)    ((ANGLE)((x)*(long)D90/90))

/* The following belongs in your application header to provide access to these
 * functions.
*/

#define   SIN(a)   my_sin (a)
#define   COS(a)   my_sin ((ANGLE)((a)+D90))
#define   ASIN(i)     my_asin(i)      /* [-90...+90] */
#define   ACOS(i)     ((ANGLE)(D90-my_asin(i)))   /* [0...180] */
#define   ATAN(x,y)   my_atan((x),(y))

extern short  FAR FASTCALL my_sin (ANGLE angle);
extern ANGLE  FAR FASTCALL my_asin (int sin);
extern ANGLE  FAR FASTCALL my_atan (int y, int x);


/* This is part of my ifuncs.c module.
*/

/* angles are stored such that -pi..0..pi radians is 0x8000..0..0x7fff
*/

#define   P3_4 ((1024/4)*3)

static short  NEAR sin_tab[1024+1] = {0};     /* 0..90 */
static ANGLE  NEAR asin_tab0[1024+1] = {0};    /* 0......1/4 */
static ANGLE  NEAR asin_tab1[P3_4+1] = {0};    /* 0......3/4 */
static ANGLE  NEAR asin_tab2[P3_4+1] = {0};    /* 3/4....15/16 */
static ANGLE  NEAR asin_tab3[1024+1] = {0};    /* 15/16..1 */
static ANGLE  NEAR atan_tab1[P3_4+1] = {0};    /* 0......3/4 */
static ANGLE  NEAR atan_tab2[P3_4+1] = {0};    /* 3/4....15/16 */
static ANGLE  NEAR atan_tab3[1024+1] = {0};    /* 15/16..1 */

static short FAR
my_round (double f)
{
  return ((short)((f<0) ? f-0.5 : f+0.5));
}

/* Fill in the trig tables.
*/
static void FAR
set_trig (void)
{
  double  s, c, t, d, sd, cd, pi;
  int  i;

  pi = atan(1.0)*4;
  d = pi/2048;     /* 0...pi */
  sd = sin (d);
  cd = cos (d);
  s = 0.0;
  c = 1.0*FONE;

  for (i = 0; i <= 1024; ++i) {
   sin_tab[i] = my_round (s);
   t = c*sd+s*cd;
   c = c*cd-s*sd;
   s = t;
  }

  for (i = 0; i <= 1024; ++i)
   asin_tab0[i] = (ANGLE)my_round (asin (i/16.0/1024.0)
       *0x08000/pi);
  for (i = 0; i <= P3_4; ++i)
   asin_tab1[i] = (ANGLE)my_round (asin (i*3.0/4.0/P3_4)
       *0x08000/pi);
  for (i = 0; i <= P3_4; ++i)
   asin_tab2[i] = (ANGLE)my_round (asin (
          3.0/4.0+i*(15.0/16.0-3.0/4.0)/P3_4)
          *0x08000/pi);
  for (i = 0; i <= 1024; ++i)
   asin_tab3[i] = (ANGLE)my_round (asin (
          15.0/16.0+i*(1.0-15.0/16.0)/1024)
          *0x08000/pi);

  for (i = 0; i <= P3_4; ++i)
   atan_tab1[i] = (ANGLE)my_round (atan (i*3.0/4.0/P3_4)
       *0x08000/pi);
  for (i = 0; i <= P3_4; ++i)
   atan_tab2[i] = (ANGLE)my_round (atan (
          3.0/4.0+i*(15.0/16.0-3.0/4.0)/P3_4)
          *0x08000/pi);
  for (i = 0; i <= 1024; ++i)
   atan_tab3[i] = (ANGLE)my_round (atan (
          15.0/16.0+i*(1.0-15.0/16.0)/1024)
          *0x08000/pi);
}

#undef P3_4

extern short FAR FASTCALL
my_sin (register ANGLE d)
{
  register int ind, f, l, h;

  if (d < 0) {
   d = -d;
   if (d < 0)     /* -180 degrees! */
      return (0);
   ind = 1;
  } else
   ind = 0;
  if (d > D90)
   d = D180 - d;

  f = d&15;       /* d%16 */
  d >>= 4;     /* d/16 */
  l = sin_tab[d];
  h = sin_tab[d+1] - l;
  if (h < 0)
   l -= (8-h*f)>>4;   /* (8-h*f)/16; */
  else
   l += (8+h*f)>>4;   /* (8+h*f)/16; */

  return ((short)(ind ? -l : l));
}

extern ANGLE FAR FASTCALL
my_asin (int d)
{
  register int ind, f;
  register ANGLE  l, h;

  if (d < 0) {
   d = -d;
   ind = 1;
  } else
   ind = 0;

  if (d < FONE/16) {   /* 0..1/16 */
   l = asin_tab0[d];
  } else if (d < (FONE/4)*3) { /* 1/16..3/4 */
   f = d&15;
   d = d>>4;
   l = asin_tab1[d];
   h = asin_tab1[d+1] - l;
   if (h < 0)
      l -= (8-h*f)>>4;
   else
      l += (8+h*f)>>4;
  } else if (d < (FONE/16)*15) {  /* 3/4..15/16 */
   d -= (FONE/4)*3;   /* 0..1/4 */
   f = d&3;
   d = d>>2;
   l = asin_tab2[d];
   h = asin_tab2[d+1] - l;
   if (h < 0)
      l -= (2-h*f)/4;
   else
      l += (2+h*f)/4;
  } else {     /* 15/16..1 */
   if (d > FONE)
      d = FONE;
   d -= (FONE/16)*15;  /* 0..1/16 */
   l = asin_tab3[d];
  }
  return (ind ? -l : l);
}

extern ANGLE FAR FASTCALL
my_atan (int y, int x)
{
  int  neg, f, i, d;
  ANGLE   l, h;

  if (y < 0) {
   y = -y;
   neg = 1;
  } else
   neg = 0;

  if (x < 0) {
   x = -x;
   neg += 2;
  }

  if (y > x) {
   d = y;
   y = x;
   x = d;
   neg += 4;
  }

  if (x == 0)
   return (0);

  d = fdiv (y, x);    /* temp */

  if (d < (FONE/4)*3) {    /* 0..3/4 */
   f = d&15;
   i = d>>4;
   l = atan_tab1[i];
   h = atan_tab1[i+1] - l;
   if (h < 0)
      l -= (8-h*f)>>4;
   else
      l += (8+h*f)>>4;
  } else if (d < (FONE/16)*15) {  /* 3/4..15/16 */
   d -= (FONE/4)*3;
   f = d&3;
   i = d>>2;
   l = atan_tab2[i];
   h = atan_tab2[i+1] - l;
   if (h < 0)
      l -= (2-h*f)>>2;
   else
      l += (2+h*f)>>2;
  } else {     /* 15/16..1 */
   if (d > FONE)
      d = FONE;
   d -= (FONE/16)*15;
   l = atan_tab3[d];
  }

  switch (neg) {
  case 0:         /* ++ */
   return (l);
  case 1:         /* -+ */
   return (-l);
  case 2:         /* +- */
   return (D180-l);
  case 3:         /* -- */
   return (D180+l);
  case 4:         /* ++ rev */
   return (D90-l);
  case 5:         /* -+ rev */
   return (-D90+l);
  case 6:         /* +- rev */
   return (D90+l);
  case 7:         /* -- rev */
   return (-D90-l);
  }
  return (0);      /* never reached */
}

main ()
{
  ANGLE   a;
  int  c, s;

  set_trig ();

  a = DEG (30);
  s = SIN (a);
  c = COS (a);

#define FFONE  ((float)FONE)  /* just for nice printing */
#define FD90  (90.0/FONE)

  printf ("sin(30)=%g cos(30)=%g\n", s/FFONE, c/FFONE);
  printf ("asin(s)=%g acos(c)=%g\n", ASIN(s)*FD90, ACOS(c)*FD90);
  printf ("atan(s/c)=%g\n", ATAN(s, c)*FD90);
  printf ("atan(c/s)=%g\n", ATAN(c, s)*FD90);
  printf ("atan(1/1)=%g\n", ATAN(1, 1)*FD90);

  exit (0);
}
--
Regards
  Eyal Lebedinsky     eyal@ise.canberra.edu.au

следующий фpагмент (5)|пpедыдущий фpагмент (3)
- Usenet echoes (21:200/1) -------------------------- COMP.GRAPHICS.ALGORITHMS -
 Msg  : 56 of 63                                                                
 From : steve@hn.ocbbs.gen.nz               2:5030/315      24 Jan 96  06:06:02 
 To   : All                                                 26 Jan 96  02:08:38 
 Subj : Re: Help with sin, cos floating pts                                     
--------------------------------------------------------------------------------

Timothy Norris (tnorris@oucsace.cs.ohiou.edu) wrote:
:  I am working on rotating a complex 3d wireframe and I need to use
:  angles such as 44.2 50.7 ...and so on.  The angles need to have one
:  decimal place but the calculation of these angles takes too long.
:  Also I cannot hard code the angles in because they are always diff-
:  erent.  If you have any ideas, i would greatly appreciate it.

:     e-mail:  tnorris@oucsace.cs.ohiou.edu
I have the same problem as you, the way that I've solved it is to
precalculate, sin, cos values of 1 degree intervals into an array.

The way it works is as follows:

 sin of 25 degrees = 0.4226
now since you only need the first three decimal places for a good
accurate result you then multiple the result by 10, 100, 100 ...
depending upon the accuracy you need.

I usually use three decimal places, so I store my result in an long
dimensioned array:
long sin[360] =  {0, ... , 422, ...};

How you use these precalculated values is and fast, to calculate a point of
a circle fast use the follow formula.

xPos = sin[x] * radius / 1000
yPos = cos[x] * radius / 1000

x      = angle (i.e. 25)
radius = 10

so (10 * 422) = 4220
then shift the decimal point three place to the left, with the result
of 4.22.

I use this method to quickly calculate 3D cordinates, it's simple and above
all, fast.

Steve.

P.S. the following program can be used to generate such precalculated data.

// Program written by Steven De Toni 1995.
//
// usage : mksincos > circ.h
//
//
// Generate sin, cos values for integer calculation of a circle!
// slow down is due to pixel ploting instead of float point calculations

#include <math.h>
#include <stdio.h>

#define size 1000.0       // accuracy to 3 decimal places

void GenerateCode (int mode, double step, double angleRange)
{
    double angle, value;
    int lfCount = 0;

    printf ("\nlong ");
    switch (mode)
    {
        case (1):
             printf ("sin ");
             break;

        case (2):
             printf ("cos ");
             break;
    }
    printf ("[MAXITEMS] =\n{\n    ");

    angle = step;

    while (angle <= angleRange)
    {
        // sin returns values in radians, convert angle first !
        switch (mode)
        {
            case (1):
                 value = sin (angle / 57.29577951); // convert radians to
degrees = angle / (180 / 3.1415..)
                 break;
            case (2):
                 value = cos (angle / 57.29577951); // convert radians to
degrees = angle / (180 / 3.1415..)
                 break;
        }

        value *= size;
        if ((value > -1.0) && (value <= 0.0))
            printf ("0");
        else
            printf ("%0.0lf", value);

        lfCount++;
        if ((lfCount >= 10) && (angle <= (angleRange - step)))
        {
           printf (",\n    ");
           lfCount = 0;
        }
        else if ((angle <= (angleRange - step)))
                printf (", ");
        angle += step;
    }
    printf ("\n};\n\n");
}


int main (void)
{
    double step;
    double angleRange;

    fprintf (stderr, "\nEnter Increase Sin / Cos Step Rate ? (e.g. 0.5): ");
    scanf ("%lf", &step);
    fprintf (stderr, "\nEnter Angle Range (e.g 90, 180, 360): ");
    scanf ("%lf", &angleRange);

    printf ("/* Integer Sine, And CoSine Construction By Steven De Toni.
*/\n");
    printf ("#define MAXITEMS %0.0f\n", (float) ((angleRange / (float)
step) + fmod (angleRange, step))); // **** ((90/step) * 4)
    printf ("#define INTSIZE  %0.0lf\n", size);
    printf ("/* plot circle: */\n");
    printf ("/* xPos = sin[x] * radius / INTSIZE */\n");
    printf ("/* yPos = cos[x] * radius / INTSIZE */\n");

    GenerateCode (1, step, angleRange);
    GenerateCode (2, step, angleRange);
}


-----------------------------------------------------------------------------


  Here's some  explanation about the  sinus table generator in the
  ACE BBS advert.
  The method used is a recursive sinus sythesis.  It's possible to
  compute all sinus values with only the two previous ones and the
  value  of  cos(2у/N) , where  n  is the number of values for one
  period.

  It's as follow:

  Sin(K)=2.Cos(2у/N).Sin(K-1)-Sin(K-2)

  or

  Cos(K)=2.Cos(2у/N).Cos(K-1)-Cos(K-2)

  The last one is easiest to use , because the two first values of
  the cos table are 1 & cos(2у/n) and with this two values you are
  able to build all the following...

  Some simple code:

  the cos table has 1024 values & ranges from -2^24 to 2^24


  build_table:          lea    DI,cos_table
                        mov    CX,1022
                        mov    EBX,cos_table[4]
                        mov    EAX,EBX
  @@calc:
                        imul   EBX
                        shrd   EAX,EDX,23
                        sub    EAX,[DI-8]
                        stosd
                        loop   @@calc


  cos_table             dd     16777216     ; 2^24
                        dd     16776900     ; 2 ^24*cos(2у/1024)
                        dd     1022 dup (?)




                               Enjoy  KarL/NoooN

следующий фpагмент (6)|пpедыдущий фpагмент (4)
- Various nice sources (2:5030/84) ----------------------------- NICE.SOURCES -
 Msg  : 4927 of 4932
 From : Alexander Zinchenko                 2:5020/1061.16  01 Sep 97  11:55:00
 To   : Sasha Alexeenko                                     02 Sep 97  23:39:53
 Subj : Sin & Cos.
-------------------------------------------------------------------------------
  Привет Sasha!
-----------

 SA> Пожалуйста напишите мне на асме процедуры для БЫСТРОГО вычисления
 SA> сабжа.

Eсть два алгоритма вычисления sin:
1) По формуле: sin(x) = 3,14x + 0,02x^2 - 5,325x^3 + 0,54x^4 + 1,8x^5
   Для первого квадранта (0 - п/2)
2) Заносить в память значения синуса для первого квадранта для углов с
   заданным шагом. При вычислении синуса просто выбирать значения из
   памяти.
Для вычисления cos или углов <0 или >90 пользуются формулами приведения.
Первый вариант требует меньше памяти, второй быстрее работает.

    С уважением, Alexander.

следующий фpагмент (7)|пpедыдущий фpагмент (5)
- Various nice sources (2:5030/84) ----------------------------- NICE.SOURCES -
 Msg  : 4931 of 4932
 From : Andrey Savilov                      2:5020/609.31   02 Sep 97  10:44:56
 To   : Sasha Alexeenko                                     02 Sep 97  23:45:59
 Subj : Re: Sin & Cos.
-------------------------------------------------------------------------------
Пpиветствую вас, Sasha!

 1-го сентябpя 1997 в 01:40, Sasha Alexeenko написал для Andrey Tretjakov:

 AT>> а косинус можно взять из синуса по смещению в pi/2.
 SA>
 SA> Все равно нету места, даже на одну таблицу для Sin'уса.

[sorry что вмешиваюсь]
Я тут для DSP недавно пpоги писал. Сначала тоже pезеpвиpовал кучу памяти для
таблицы, затем пеpешел на аппpоксимацию. Hа ADSP-2181 она выполняется за 25
тактов (1 такт = 30 нсек). Вот фоpмула веpная для всех x от 0 до 90 гpадусов:
sin(x)=3.140625x+0.02026367(x^2)-5.325196(x^3)+0.05446778(x^4)+1.800293(x^5)
Hадо инвеpтиpовать знак если число попадает в 2,4-й квадpанты. К сожалению,
pеализации оной функции для IBM PC у меня нет. Hо если ее написать на асме,
IMHO, быстpо будет.


С наилучшими пожеланиями,
       Andrey S.

следующий фpагмент (8)|пpедыдущий фpагмент (6)
David Eberly wrote:
> 
> In article <3326e521.68829234@192.168.0.2>,
> Kyle Lussier <lussier@inside.net> wrote:
> >On 6 Mar 1997 00:03:27 -0500, eberly@cs.unc.edu (David Eberly) wrote:
> >
> >computing those functions.  This was with Visual C++ 4.2.  So, I think
> >that Taylor Series expansions (because they are easy) do have a very
> >significant usefullness in computational applications.
> 
> I stand corrected.  Your original posting did not seem to indicate
> the "if" statement.  But I still think you can avoid the trig and
> hyperbolic trig functions with polynomial approximations which reduce
> number of cycles :)
> 

Polynomial approximations perform especially well when the functions are 
odd or even (like sin and cos), because it halves the number of terms (ie 
multiplies and adds) needed.

However, Taylor expansion is *not* the right way to do this: Taylor 
series provide an approximation which asymptotically converges, but for 
some given order (ie degree of the polynomial), the truncated taylor 
series is far from the best approximating polynomial.

A much better approximation is given by Chebyshev polynomials (you can 
find references on how to find these in numerical analysis books, 
especially Numerical Recipes in C, 2nd Ed, by W. Press, published by 
Cambridge University Press). I did some experiments on the cos() function 
a while ago (can send you the results if you wish), which showed 
Chebyshev approximants "saved" 2 degrees, as compared to Taylor : degree 
4 Chebyshev was as reliable as degree 6 Taylor...

Here is an implementation, which provides "single float" (23 bit 
mantissa) precision. On my 486 DX, it runs about 20% faster than the 
library cos() (which uses the asm call), and over 40% better if I suppose 
the argument is always between -PI/2 and PI/2.

Regards, 
Francois


/* float precision cosine : calculated through an order 8 tchebitcheff 
   polynomial : precision is in fact around 5e-8, a little better than
   float precision, angle should be in radians */
inline float mycos(float f)
{
/* internal calculations are done in doubles to avoid truncation errors:
   Tchebitcheff polynomial coeffs are very sensitive to this */
double x2,x,co;
int i;
/* cosine is even : eliminate the sign */
x=fabs(f);  
/* reduce the range to [0,PI/2], i is a multiple of 2, if it is a 
multiple 
   of 4, then the cosine is positive, else it is negative */
if(x<MYPI_S2) i=0;
else if(x<MYPI_S2+MYPI)
  {
  x-=MYPI;
  i=2;
  }
else if(x<MYPI_S2+MY2PI)
  {
  x-=MY2PI;
  i=0;
  }
else 
  {  
  i=(int)(x*MYIPI_S2); 
  if(i&1) i++;
  x-=i*MYPI_S2;
  } 
/* now calculate the tchebitcheff polynomial */
x2 = x * x;
co = 0.9999999530275124141540100 + x2 * (-0.4999990477779211276235238 
+ x2 * (0.0416635731601879678431127 + x2 * (-0.0013853629536173002387549 
+ x2 * 0.0000231524166599385268798 )));
/* done, return the value */
return ((i&2)?(float)-co:(float)co);
}
следующий фpагмент (9)|пpедыдущий фpагмент (7)

- [20] Demo/intro making and discussion (2:5030/84) -------------- DEMO.DESIGN -
 Msg  : 741 of 741                                                              
 From : Dmitry Koolyashov                   2:50/362.3      14 Jul 95  13:16:00 
 To   : Oleg Homenko                                                            
 Subj : PATAN                                                                   
--------------------------------------------------------------------------------
Бью чeлoм, Oleg!
Помнится мне Oleg Homenko писал к Yuri Tolsky:

 OH>> А кто-нибудь обладает алгоpитмом вычиcления чаcтичного
 OH>> аpктангенcа c фикcиpованной точкой? (cопp иcпользовать нельзя!)

 OH> В pезультате: y -> arctg(b/a) пpи i уже поpядка 10

Мне нужен был subj, чтобы найти угол от оси до вектора заданного
двумя точками (0..255,0..255)
Если тебе еще нужно то вот моя функция для этого:
 d:=ATN(y*256 div x);
 d получается в диапазоне 128..192, то есть угол в 90 градусов
 соответствует 64 единицам (мне так было удобнее)

function ATN(w:word):byte; assembler;
asm
       mov      cx,W
       cmp      cx,27*256
       jc       @@Cont
       mov      ax,191
       cmp      cx,81*256
       jc       @@Exit
       inc      ax
       jmp      @@Exit
@@Cont:
       cmp      cx,3
       jnc      @@1
       add      cx,3
@@1:
       mov      ax,cx
       mov      dx,198
       mul      dx
       mov      al,ah
       mov      ah,dl
       add      ax,445
       mov      cx,ax
       mov      dx,192
       xor      ax,ax
       div      cx
       xor      dx,dx
       div      cx
       xor      ah,ah
       mov      cx,190
       sub      cx,ax
       mov      ax,cx
@@Exit:
end;

Конечно получается с небольшой погрешностью, все-таки аппроксимация,
но мне хватило.

  Замирая в глубоком пардоне. Dmitry aka Crazy Coder.

следующий фpагмент (10)|пpедыдущий фpагмент (8)
- [22] Usenet echoes (21:200/1) --------------------- COMP.GRAPHICS.ALGORITHMS -
 Msg  : 7 of 31                                                                 
 From : hbaker@netcom.com                   2:5030/144.99   12 Apr 94  04:29:00 
 To   : All                                                                     
 Subj : Re: Fast atan2(y/x) ?                                                   
--------------------------------------------------------------------------------

In article <2obpf5$8n8@hermes.louisville.edu>
jamull01@romulus.spd.louisville.edu (Joe Muller) writes:

>  With all this talk about a fast square root algorithm I was wondering
>if anyone has a reasonably fast atan2 ?  I have seen some approximations
>that return values from 0 to 255 but since I am already using floating point
>I need something that returns values from -PI to PI, or 0 to 360.
>  I also need accuracy within +- 2 degrees, not -+ 5 or 10, so I was
>thinking along the lines of a power series with maybe a dozen or so iterations
>would give it to me.

The usual Taylor series is x-x^3/3+x^5/5-x^7/7+x^9/9 etc.  It converges
incredibly slowly near x=1.

One of the prettiest results in all of mathematics is the continued
fraction approximation to atan(x), which can be truncated to give a
rational function approximation. (Wall, H.S.  Analytic Theory of
Continued Fractions.  Chelsea Publ., Bronx, NY, 1948.)

atan(x) = x/(1+x^2/(3+(2x)^2/(5+(3x)^2/(7+(4x)^2/(9+ ...

Unfortunately, it still takes lots of iterations to get 24 bits in the
worst case, and your machine needs to have either fast division, or
you need to do the equivalent of a bunch of degenerate 2x2 matrix
multiplies with one division at the end.

Table lookup with linear interpolation should work pretty well, since
atan is very smooth.

The identity atan(x) = 0.5 * atan2(2*x,1-x^2) may be useful in range
shifting, along with atan(1/x) = pi/2 - atan(x).

There's also the CORDIC algorithm, which gives you a bit per iteration
-- i.e., quite slow.

-----------------------------------------------------------------------------


	The following code is what I use. It's accurate enough for
computing texture map coordinates in my ray-tracer:

acos::
; input d0=cos output d0=acos(d0) 1 -> 0 0 > .25 -1 > .5
; trashes d1/d2,a0
	tst.w	d0
	bmi.s	negacos
posacos:	move	d0,d2
	and.w	#$001f,d2
	lsr	#5,d0
	add	d0,d0
	lea	acos_tbl(pc),a0
	move	2(a0,d0.w),d1
	move	0(a0,d0.w),d0
	sub	d0,d1
	muls	d2,d1
	asr.w	#5,d1
	add	d1,d0
	rts
negacos:	neg.w	d0
	bsr.s	posacos
	neg.w	d0
	add.w	#$7ffe,d0	 ; acos(-x) = .5-acos(x)
	rts
and here's the boring part:

acos_tbl:
	dc.w	$3fff
	dc.w	$3ff5
	dc.w	$3feb
	dc.w	$3fe1
	dc.w	$3fd7
	dc.w	$3fcd
	dc.w	$3fc2
	dc.w	$3fb8
	dc.w	$3fae
	dc.w	$3fa4
	dc.w	$3f9a
	dc.w	$3f8f
	dc.w	$3f85
	dc.w	$3f7b
	dc.w	$3f71
	dc.w	$3f67
	dc.w	$3f5d
	dc.w	$3f52
	dc.w	$3f48
	dc.w	$3f3e
	dc.w	$3f34
	dc.w	$3f2a
	dc.w	$3f1f
	dc.w	$3f15
	dc.w	$3f0b
	dc.w	$3f01
	dc.w	$3ef7
	dc.w	$3eec
	dc.w	$3ee2
	dc.w	$3ed8
	dc.w	$3ece
	dc.w	$3ec4
	dc.w	$3eb9
	dc.w	$3eaf
	dc.w	$3ea5
	dc.w	$3e9b
	dc.w	$3e91
	dc.w	$3e87
	dc.w	$3e7c
	dc.w	$3e72
	dc.w	$3e68
	dc.w	$3e5e
	dc.w	$3e54
	dc.w	$3e49
	dc.w	$3e3f
	dc.w	$3e35
	dc.w	$3e2b
	dc.w	$3e21
	dc.w	$3e16
	dc.w	$3e0c
	dc.w	$3e02
	dc.w	$3df8
	dc.w	$3dee
	dc.w	$3de3
	dc.w	$3dd9
	dc.w	$3dcf
	dc.w	$3dc5
	dc.w	$3dbb
	dc.w	$3db0
	dc.w	$3da6
	dc.w	$3d9c
	dc.w	$3d92
	dc.w	$3d88
	dc.w	$3d7d
	dc.w	$3d73
	dc.w	$3d69
	dc.w	$3d5f
	dc.w	$3d55
	dc.w	$3d4a
	dc.w	$3d40
	dc.w	$3d36
	dc.w	$3d2c
	dc.w	$3d22
	dc.w	$3d17
	dc.w	$3d0d
	dc.w	$3d03
	dc.w	$3cf9
	dc.w	$3cee
	dc.w	$3ce4
	dc.w	$3cda
	dc.w	$3cd0
	dc.w	$3cc6
	dc.w	$3cbb
	dc.w	$3cb1
	dc.w	$3ca7
	dc.w	$3c9d
	dc.w	$3c92
	dc.w	$3c88
	dc.w	$3c7e
	dc.w	$3c74
	dc.w	$3c6a
	dc.w	$3c5f
	dc.w	$3c55
	dc.w	$3c4b
	dc.w	$3c41
	dc.w	$3c36
	dc.w	$3c2c
	dc.w	$3c22
	dc.w	$3c18
	dc.w	$3c0e
	dc.w	$3c03
	dc.w	$3bf9
	dc.w	$3bef
	dc.w	$3be5
	dc.w	$3bda
	dc.w	$3bd0
	dc.w	$3bc6
	dc.w	$3bbc
	dc.w	$3bb1
	dc.w	$3ba7
	dc.w	$3b9d
	dc.w	$3b93
	dc.w	$3b88
	dc.w	$3b7e
	dc.w	$3b74
	dc.w	$3b6a
	dc.w	$3b5f
	dc.w	$3b55
	dc.w	$3b4b
	dc.w	$3b41
	dc.w	$3b36
	dc.w	$3b2c
	dc.w	$3b22
	dc.w	$3b18
	dc.w	$3b0d
	dc.w	$3b03
	dc.w	$3af9
	dc.w	$3aef
	dc.w	$3ae4
	dc.w	$3ada
	dc.w	$3ad0
	dc.w	$3ac5
	dc.w	$3abb
	dc.w	$3ab1
	dc.w	$3aa7
	dc.w	$3a9c
	dc.w	$3a92
	dc.w	$3a88
	dc.w	$3a7e
	dc.w	$3a73
	dc.w	$3a69
	dc.w	$3a5f
	dc.w	$3a54
	dc.w	$3a4a
	dc.w	$3a40
	dc.w	$3a36
	dc.w	$3a2b
	dc.w	$3a21
	dc.w	$3a17
	dc.w	$3a0c
	dc.w	$3a02
	dc.w	$39f8
	dc.w	$39ed
	dc.w	$39e3
	dc.w	$39d9
	dc.w	$39cf
	dc.w	$39c4
	dc.w	$39ba
	dc.w	$39b0
	dc.w	$39a5
	dc.w	$399b
	dc.w	$3991
	dc.w	$3986
	dc.w	$397c
	dc.w	$3972
	dc.w	$3967
	dc.w	$395d
	dc.w	$3953
	dc.w	$3948
	dc.w	$393e
	dc.w	$3934
	dc.w	$392a
	dc.w	$391f
	dc.w	$3915
	dc.w	$390b
	dc.w	$3900
	dc.w	$38f6
	dc.w	$38eb
	dc.w	$38e1
	dc.w	$38d7
	dc.w	$38cc
	dc.w	$38c2
	dc.w	$38b8
	dc.w	$38ad
	dc.w	$38a3
	dc.w	$3899
	dc.w	$388e
	dc.w	$3884
	dc.w	$387a
	dc.w	$386f
	dc.w	$3865
	dc.w	$385b
	dc.w	$3850
	dc.w	$3846
	dc.w	$383b
	dc.w	$3831
	dc.w	$3827
	dc.w	$381c
	dc.w	$3812
	dc.w	$3808
	dc.w	$37fd
	dc.w	$37f3
	dc.w	$37e8
	dc.w	$37de
	dc.w	$37d4
	dc.w	$37c9
	dc.w	$37bf
	dc.w	$37b4
	dc.w	$37aa
	dc.w	$37a0
	dc.w	$3795
	dc.w	$378b
	dc.w	$3780
	dc.w	$3776
	dc.w	$376c
	dc.w	$3761
	dc.w	$3757
	dc.w	$374c
	dc.w	$3742
	dc.w	$3737
	dc.w	$372d
	dc.w	$3723
	dc.w	$3718
	dc.w	$370e
	dc.w	$3703
	dc.w	$36f9
	dc.w	$36ee
	dc.w	$36e4
	dc.w	$36d9
	dc.w	$36cf
	dc.w	$36c5
	dc.w	$36ba
	dc.w	$36b0
	dc.w	$36a5
	dc.w	$369b
	dc.w	$3690
	dc.w	$3686
	dc.w	$367b
	dc.w	$3671
	dc.w	$3666
	dc.w	$365c
	dc.w	$3651
	dc.w	$3647
	dc.w	$363c
	dc.w	$3632
	dc.w	$3628
	dc.w	$361d
	dc.w	$3613
	dc.w	$3608
	dc.w	$35fe
	dc.w	$35f3
	dc.w	$35e9
	dc.w	$35de
	dc.w	$35d3
	dc.w	$35c9
	dc.w	$35be
	dc.w	$35b4
	dc.w	$35a9
	dc.w	$359f
	dc.w	$3594
	dc.w	$358a
	dc.w	$357f
	dc.w	$3575
	dc.w	$356a
	dc.w	$3560
	dc.w	$3555
	dc.w	$354b
	dc.w	$3540
	dc.w	$3536
	dc.w	$352b
	dc.w	$3520
	dc.w	$3516
	dc.w	$350b
	dc.w	$3501
	dc.w	$34f6
	dc.w	$34ec
	dc.w	$34e1
	dc.w	$34d6
	dc.w	$34cc
	dc.w	$34c1
	dc.w	$34b7
	dc.w	$34ac
	dc.w	$34a1
	dc.w	$3497
	dc.w	$348c
	dc.w	$3482
	dc.w	$3477
	dc.w	$346c
	dc.w	$3462
	dc.w	$3457
	dc.w	$344d
	dc.w	$3442
	dc.w	$3437
	dc.w	$342d
	dc.w	$3422
	dc.w	$3417
	dc.w	$340d
	dc.w	$3402
	dc.w	$33f8
	dc.w	$33ed
	dc.w	$33e2
	dc.w	$33d8
	dc.w	$33cd
	dc.w	$33c2
	dc.w	$33b8
	dc.w	$33ad
	dc.w	$33a2
	dc.w	$3398
	dc.w	$338d
	dc.w	$3382
	dc.w	$3378
	dc.w	$336d
	dc.w	$3362
	dc.w	$3357
	dc.w	$334d
	dc.w	$3342
	dc.w	$3337
	dc.w	$332d
	dc.w	$3322
	dc.w	$3317
	dc.w	$330c
	dc.w	$3302
	dc.w	$32f7
	dc.w	$32ec
	dc.w	$32e2
	dc.w	$32d7
	dc.w	$32cc
	dc.w	$32c1
	dc.w	$32b7
	dc.w	$32ac
	dc.w	$32a1
	dc.w	$3296
	dc.w	$328c
	dc.w	$3281
	dc.w	$3276
	dc.w	$326b
	dc.w	$3260
	dc.w	$3256
	dc.w	$324b
	dc.w	$3240
	dc.w	$3235
	dc.w	$322a
	dc.w	$3220
	dc.w	$3215
	dc.w	$320a
	dc.w	$31ff
	dc.w	$31f4
	dc.w	$31ea
	dc.w	$31df
	dc.w	$31d4
	dc.w	$31c9
	dc.w	$31be
	dc.w	$31b3
	dc.w	$31a9
	dc.w	$319e
	dc.w	$3193
	dc.w	$3188
	dc.w	$317d
	dc.w	$3172
	dc.w	$3167
	dc.w	$315c
	dc.w	$3152
	dc.w	$3147
	dc.w	$313c
	dc.w	$3131
	dc.w	$3126
	dc.w	$311b
	dc.w	$3110
	dc.w	$3105
	dc.w	$30fa
	dc.w	$30ef
	dc.w	$30e5
	dc.w	$30da
	dc.w	$30cf
	dc.w	$30c4
	dc.w	$30b9
	dc.w	$30ae
	dc.w	$30a3
	dc.w	$3098
	dc.w	$308d
	dc.w	$3082
	dc.w	$3077
	dc.w	$306c
	dc.w	$3061
	dc.w	$3056
	dc.w	$304b
	dc.w	$3040
	dc.w	$3035
	dc.w	$302a
	dc.w	$301f
	dc.w	$3014
	dc.w	$3009
	dc.w	$2ffe
	dc.w	$2ff3
	dc.w	$2fe8
	dc.w	$2fdd
	dc.w	$2fd2
	dc.w	$2fc7
	dc.w	$2fbc
	dc.w	$2fb1
	dc.w	$2fa6
	dc.w	$2f9b
	dc.w	$2f90
	dc.w	$2f84
	dc.w	$2f79
	dc.w	$2f6e
	dc.w	$2f63
	dc.w	$2f58
	dc.w	$2f4d
	dc.w	$2f42
	dc.w	$2f37
	dc.w	$2f2c
	dc.w	$2f21
	dc.w	$2f15
	dc.w	$2f0a
	dc.w	$2eff
	dc.w	$2ef4
	dc.w	$2ee9
	dc.w	$2ede
	dc.w	$2ed3
	dc.w	$2ec7
	dc.w	$2ebc
	dc.w	$2eb1
	dc.w	$2ea6
	dc.w	$2e9b
	dc.w	$2e8f
	dc.w	$2e84
	dc.w	$2e79
	dc.w	$2e6e
	dc.w	$2e63
	dc.w	$2e57
	dc.w	$2e4c
	dc.w	$2e41
	dc.w	$2e36
	dc.w	$2e2a
	dc.w	$2e1f
	dc.w	$2e14
	dc.w	$2e09
	dc.w	$2dfd
	dc.w	$2df2
	dc.w	$2de7
	dc.w	$2ddc
	dc.w	$2dd0
	dc.w	$2dc5
	dc.w	$2dba
	dc.w	$2dae
	dc.w	$2da3
	dc.w	$2d98
	dc.w	$2d8c
	dc.w	$2d81
	dc.w	$2d76
	dc.w	$2d6a
	dc.w	$2d5f
	dc.w	$2d54
	dc.w	$2d48
	dc.w	$2d3d
	dc.w	$2d32
	dc.w	$2d26
	dc.w	$2d1b
	dc.w	$2d0f
	dc.w	$2d04
	dc.w	$2cf9
	dc.w	$2ced
	dc.w	$2ce2
	dc.w	$2cd6
	dc.w	$2ccb
	dc.w	$2cc0
	dc.w	$2cb4
	dc.w	$2ca9
	dc.w	$2c9d
	dc.w	$2c92
	dc.w	$2c86
	dc.w	$2c7b
	dc.w	$2c6f
	dc.w	$2c64
	dc.w	$2c58
	dc.w	$2c4d
	dc.w	$2c41
	dc.w	$2c36
	dc.w	$2c2a
	dc.w	$2c1f
	dc.w	$2c13
	dc.w	$2c08
	dc.w	$2bfc
	dc.w	$2bf1
	dc.w	$2be5
	dc.w	$2bd9
	dc.w	$2bce
	dc.w	$2bc2
	dc.w	$2bb7
	dc.w	$2bab
	dc.w	$2ba0
	dc.w	$2b94
	dc.w	$2b88
	dc.w	$2b7d
	dc.w	$2b71
	dc.w	$2b65
	dc.w	$2b5a
	dc.w	$2b4e
	dc.w	$2b42
	dc.w	$2b37
	dc.w	$2b2b
	dc.w	$2b1f
	dc.w	$2b14
	dc.w	$2b08
	dc.w	$2afc
	dc.w	$2af1
	dc.w	$2ae5
	dc.w	$2ad9
	dc.w	$2acd
	dc.w	$2ac2
	dc.w	$2ab6
	dc.w	$2aaa
	dc.w	$2a9e
	dc.w	$2a93
	dc.w	$2a87
	dc.w	$2a7b
	dc.w	$2a6f
	dc.w	$2a63
	dc.w	$2a58
	dc.w	$2a4c
	dc.w	$2a40
	dc.w	$2a34
	dc.w	$2a28
	dc.w	$2a1c
	dc.w	$2a11
	dc.w	$2a05
	dc.w	$29f9
	dc.w	$29ed
	dc.w	$29e1
	dc.w	$29d5
	dc.w	$29c9
	dc.w	$29bd
	dc.w	$29b1
	dc.w	$29a6
	dc.w	$299a
	dc.w	$298e
	dc.w	$2982
	dc.w	$2976
	dc.w	$296a
	dc.w	$295e
	dc.w	$2952
	dc.w	$2946
	dc.w	$293a
	dc.w	$292e
	dc.w	$2922
	dc.w	$2916
	dc.w	$290a
	dc.w	$28fe
	dc.w	$28f1
	dc.w	$28e5
	dc.w	$28d9
	dc.w	$28cd
	dc.w	$28c1
	dc.w	$28b5
	dc.w	$28a9
	dc.w	$289d
	dc.w	$2891
	dc.w	$2885
	dc.w	$2878
	dc.w	$286c
	dc.w	$2860
	dc.w	$2854
	dc.w	$2848
	dc.w	$283b
	dc.w	$282f
	dc.w	$2823
	dc.w	$2817
	dc.w	$280b
	dc.w	$27fe
	dc.w	$27f2
	dc.w	$27e6
	dc.w	$27da
	dc.w	$27cd
	dc.w	$27c1
	dc.w	$27b5
	dc.w	$27a8
	dc.w	$279c
	dc.w	$2790
	dc.w	$2783
	dc.w	$2777
	dc.w	$276b
	dc.w	$275e
	dc.w	$2752
	dc.w	$2745
	dc.w	$2739
	dc.w	$272d
	dc.w	$2720
	dc.w	$2714
	dc.w	$2707
	dc.w	$26fb
	dc.w	$26ee
	dc.w	$26e2
	dc.w	$26d5
	dc.w	$26c9
	dc.w	$26bc
	dc.w	$26b0
	dc.w	$26a3
	dc.w	$2697
	dc.w	$268a
	dc.w	$267e
	dc.w	$2671
	dc.w	$2665
	dc.w	$2658
	dc.w	$264b
	dc.w	$263f
	dc.w	$2632
	dc.w	$2625
	dc.w	$2619
	dc.w	$260c
	dc.w	$25ff
	dc.w	$25f3
	dc.w	$25e6
	dc.w	$25d9
	dc.w	$25cd
	dc.w	$25c0
	dc.w	$25b3
	dc.w	$25a6
	dc.w	$259a
	dc.w	$258d
	dc.w	$2580
	dc.w	$2573
	dc.w	$2566
	dc.w	$255a
	dc.w	$254d
	dc.w	$2540
	dc.w	$2533
	dc.w	$2526
	dc.w	$2519
	dc.w	$250c
	dc.w	$24ff
	dc.w	$24f3
	dc.w	$24e6
	dc.w	$24d9
	dc.w	$24cc
	dc.w	$24bf
	dc.w	$24b2
	dc.w	$24a5
	dc.w	$2498
	dc.w	$248b
	dc.w	$247e
	dc.w	$2471
	dc.w	$2463
	dc.w	$2456
	dc.w	$2449
	dc.w	$243c
	dc.w	$242f
	dc.w	$2422
	dc.w	$2415
	dc.w	$2408
	dc.w	$23fa
	dc.w	$23ed
	dc.w	$23e0
	dc.w	$23d3
	dc.w	$23c6
	dc.w	$23b8
	dc.w	$23ab
	dc.w	$239e
	dc.w	$2391
	dc.w	$2383
	dc.w	$2376
	dc.w	$2369
	dc.w	$235b
	dc.w	$234e
	dc.w	$2341
	dc.w	$2333
	dc.w	$2326
	dc.w	$2318
	dc.w	$230b
	dc.w	$22fd
	dc.w	$22f0
	dc.w	$22e3
	dc.w	$22d5
	dc.w	$22c8
	dc.w	$22ba
	dc.w	$22ac
	dc.w	$229f
	dc.w	$2291
	dc.w	$2284
	dc.w	$2276
	dc.w	$2269
	dc.w	$225b
	dc.w	$224d
	dc.w	$2240
	dc.w	$2232
	dc.w	$2224
	dc.w	$2217
	dc.w	$2209
	dc.w	$21fb
	dc.w	$21ed
	dc.w	$21e0
	dc.w	$21d2
	dc.w	$21c4
	dc.w	$21b6
	dc.w	$21a8
	dc.w	$219a
	dc.w	$218c
	dc.w	$217f
	dc.w	$2171
	dc.w	$2163
	dc.w	$2155
	dc.w	$2147
	dc.w	$2139
	dc.w	$212b
	dc.w	$211d
	dc.w	$210f
	dc.w	$2101
	dc.w	$20f3
	dc.w	$20e5
	dc.w	$20d6
	dc.w	$20c8
	dc.w	$20ba
	dc.w	$20ac
	dc.w	$209e
	dc.w	$2090
	dc.w	$2081
	dc.w	$2073
	dc.w	$2065
	dc.w	$2057
	dc.w	$2048
	dc.w	$203a
	dc.w	$202c
	dc.w	$201d
	dc.w	$200f
	dc.w	$2001
	dc.w	$1ff2
	dc.w	$1fe4
	dc.w	$1fd5
	dc.w	$1fc7
	dc.w	$1fb8
	dc.w	$1faa
	dc.w	$1f9b
	dc.w	$1f8d
	dc.w	$1f7e
	dc.w	$1f70
	dc.w	$1f61
	dc.w	$1f52
	dc.w	$1f44
	dc.w	$1f35
	dc.w	$1f26
	dc.w	$1f18
	dc.w	$1f09
	dc.w	$1efa
	dc.w	$1eeb
	dc.w	$1edc
	dc.w	$1ece
	dc.w	$1ebf
	dc.w	$1eb0
	dc.w	$1ea1
	dc.w	$1e92
	dc.w	$1e83
	dc.w	$1e74
	dc.w	$1e65
	dc.w	$1e56
	dc.w	$1e47
	dc.w	$1e38
	dc.w	$1e29
	dc.w	$1e1a
	dc.w	$1e0b
	dc.w	$1dfb
	dc.w	$1dec
	dc.w	$1ddd
	dc.w	$1dce
	dc.w	$1dbf
	dc.w	$1daf
	dc.w	$1da0
	dc.w	$1d91
	dc.w	$1d81
	dc.w	$1d72
	dc.w	$1d62
	dc.w	$1d53
	dc.w	$1d44
	dc.w	$1d34
	dc.w	$1d25
	dc.w	$1d15
	dc.w	$1d05
	dc.w	$1cf6
	dc.w	$1ce6
	dc.w	$1cd7
	dc.w	$1cc7
	dc.w	$1cb7
	dc.w	$1ca7
	dc.w	$1c98
	dc.w	$1c88
	dc.w	$1c78
	dc.w	$1c68
	dc.w	$1c58
	dc.w	$1c48
	dc.w	$1c39
	dc.w	$1c29
	dc.w	$1c19
	dc.w	$1c09
	dc.w	$1bf8
	dc.w	$1be8
	dc.w	$1bd8
	dc.w	$1bc8
	dc.w	$1bb8
	dc.w	$1ba8
	dc.w	$1b98
	dc.w	$1b87
	dc.w	$1b77
	dc.w	$1b67
	dc.w	$1b56
	dc.w	$1b46
	dc.w	$1b35
	dc.w	$1b25
	dc.w	$1b14
	dc.w	$1b04
	dc.w	$1af3
	dc.w	$1ae3
	dc.w	$1ad2
	dc.w	$1ac1
	dc.w	$1ab1
	dc.w	$1aa0
	dc.w	$1a8f
	dc.w	$1a7e
	dc.w	$1a6e
	dc.w	$1a5d
	dc.w	$1a4c
	dc.w	$1a3b
	dc.w	$1a2a
	dc.w	$1a19
	dc.w	$1a08
	dc.w	$19f7
	dc.w	$19e6
	dc.w	$19d4
	dc.w	$19c3
	dc.w	$19b2
	dc.w	$19a1
	dc.w	$198f
	dc.w	$197e
	dc.w	$196c
	dc.w	$195b
	dc.w	$194a
	dc.w	$1938
	dc.w	$1926
	dc.w	$1915
	dc.w	$1903
	dc.w	$18f1
	dc.w	$18e0
	dc.w	$18ce
	dc.w	$18bc
	dc.w	$18aa
	dc.w	$1898
	dc.w	$1886
	dc.w	$1874
	dc.w	$1862
	dc.w	$1850
	dc.w	$183e
	dc.w	$182c
	dc.w	$181a
	dc.w	$1807
	dc.w	$17f5
	dc.w	$17e3
	dc.w	$17d0
	dc.w	$17be
	dc.w	$17ab
	dc.w	$1799
	dc.w	$1786
	dc.w	$1773
	dc.w	$1760
	dc.w	$174e
	dc.w	$173b
	dc.w	$1728
	dc.w	$1715
	dc.w	$1702
	dc.w	$16ef
	dc.w	$16dc
	dc.w	$16c9
	dc.w	$16b5
	dc.w	$16a2
	dc.w	$168f
	dc.w	$167b
	dc.w	$1668
	dc.w	$1654
	dc.w	$1641
	dc.w	$162d
	dc.w	$1619
	dc.w	$1606
	dc.w	$15f2
	dc.w	$15de
	dc.w	$15ca
	dc.w	$15b6
	dc.w	$15a2
	dc.w	$158e
	dc.w	$157a
	dc.w	$1565
	dc.w	$1551
	dc.w	$153d
	dc.w	$1528
	dc.w	$1513
	dc.w	$14ff
	dc.w	$14ea
	dc.w	$14d5
	dc.w	$14c1
	dc.w	$14ac
	dc.w	$1497
	dc.w	$1482
	dc.w	$146c
	dc.w	$1457
	dc.w	$1442
	dc.w	$142c
	dc.w	$1417
	dc.w	$1401
	dc.w	$13ec
	dc.w	$13d6
	dc.w	$13c0
	dc.w	$13aa
	dc.w	$1394
	dc.w	$137e
	dc.w	$1368
	dc.w	$1352
	dc.w	$133b
	dc.w	$1325
	dc.w	$130e
	dc.w	$12f8
	dc.w	$12e1
	dc.w	$12ca
	dc.w	$12b3
	dc.w	$129c
	dc.w	$1285
	dc.w	$126e
	dc.w	$1257
	dc.w	$123f
	dc.w	$1227
	dc.w	$1210
	dc.w	$11f8
	dc.w	$11e0
	dc.w	$11c8
	dc.w	$11b0
	dc.w	$1198
	dc.w	$117f
	dc.w	$1167
	dc.w	$114e
	dc.w	$1135
	dc.w	$111c
	dc.w	$1103
	dc.w	$10ea
	dc.w	$10d1
	dc.w	$10b7
	dc.w	$109e
	dc.w	$1084
	dc.w	$106a
	dc.w	$1050
	dc.w	$1036
	dc.w	$101b
	dc.w	$1001
	dc.w	$0fe6
	dc.w	$0fcb
	dc.w	$0fb0
	dc.w	$0f95
	dc.w	$0f7a
	dc.w	$0f5e
	dc.w	$0f42
	dc.w	$0f26
	dc.w	$0f0a
	dc.w	$0eee
	dc.w	$0ed2
	dc.w	$0eb5
	dc.w	$0e98
	dc.w	$0e7b
	dc.w	$0e5d
	dc.w	$0e40
	dc.w	$0e22
	dc.w	$0e04
	dc.w	$0de5
	dc.w	$0dc7
	dc.w	$0da8
	dc.w	$0d89
	dc.w	$0d6a
	dc.w	$0d4a
	dc.w	$0d2a
	dc.w	$0d0a
	dc.w	$0ce9
	dc.w	$0cc8
	dc.w	$0ca7
	dc.w	$0c86
	dc.w	$0c64
	dc.w	$0c42
	dc.w	$0c1f
	dc.w	$0bfc
	dc.w	$0bd9
	dc.w	$0bb5
	dc.w	$0b91
	dc.w	$0b6c
	dc.w	$0b47
	dc.w	$0b22
	dc.w	$0afc
	dc.w	$0ad5
	dc.w	$0aae
	dc.w	$0a87
	dc.w	$0a5f
	dc.w	$0a36
	dc.w	$0a0d
	dc.w	$09e2
	dc.w	$09b8
	dc.w	$098c
	dc.w	$0960
	dc.w	$0933
	dc.w	$0905
	dc.w	$08d6
	dc.w	$08a6
	dc.w	$0875
	dc.w	$0844
	dc.w	$0810
	dc.w	$07dc
	dc.w	$07a6
	dc.w	$076f
	dc.w	$0736
	dc.w	$06fb
	dc.w	$06be
	dc.w	$067f
	dc.w	$063e
	dc.w	$05fa
	dc.w	$05b2
	dc.w	$0567
	dc.w	$0518
	dc.w	$04c4
	dc.w	$0469
	dc.w	$0407
	dc.w	$039a
	dc.w	$031e
	dc.w	$028c
	dc.w	$01cc
	dc.w	$0000
-- 
Chris Green - Graphics Software Engineer   - chrisg@commodore.COM   





Всего 9 фpагмент(а/ов) |пpедыдущий фpагмент (9)

оглавление \| demo party в ex-СССР \| infused bytes e-mag \| новости от ib/news \| другие проекты \| письмо \|	win koi lat