rom/mathffp/spadd.c

   1 /*
   2     Copyright © 1995-2004, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include "mathffp_intern.h"
   7
   8 /*
   9     FUNCTION
  10         Calculate the sum of two ffp numbers
  11
  12     RESULT
  13         sum of fnum1 and fnum2.
  14
  15         Flags:
  16         <description>
  17         <li><item>zero</item>result is zero</li>
  18         <li><item>negative</item>result is negative</li>
  19         <li><item>overflow</item>result is too large or too small for ffp format</li>
  20         </description>
  21
  22     NOTES
  23
  24     EXAMPLE
  25
  26     BUGS
  27
  28     SEE ALSO
  29
  30
  31     INTERNALS
  32         <p>Adapt the exponent of the ffp-number with the smaller
  33         exponent to the ffp-number with the larger exponent.
  34         Therefore rotate the mantisse of the ffp-number with the
  35         smaller exponents by n bits, where n is the absolute value
  36         of the difference of the exponents.</p>
  37
  38         <p>The exponent of the target ffp-number is set to the larger
  39         exponent plus 1.</p>
  40
  41         <p>Additionally rotate both numbers by one bit to the right so
  42         you can catch a result &gt; 1 in the MSB.</p>
  43
  44         <p>If the signs of the two numbers are equal then simply add
  45         the two mantisses. The result of the mantisses will be
  46         [0.5 .. 2[. Check the MSB. If zero, then the result is &lt; 1
  47         and therefore subtract 1 from the exponent. Normalize the
  48         mantisse of the result by rotating it one bit to the left.
  49         Check the mantisse for 0.</p>
  50
  51         <p>If the signs of the two numbers are different then subtract
  52         the ffp-number with the neagtive sign from the other one.
  53         The result of the mantisse will be [-1..1[. If the MSB of
  54         the result is set, then the result is below zero and therefore
  55         you have to calculate the absolute value of the mantisse.
  56         Check the mantisse for zero. Normalize the mantisse by
  57         rotating it to the left and decreasing the exponent for every
  58         rotation.</p>
  59
  60         <p>Test the exponent of the result for an overflow.
  61         That`s it!</p>
  62
  63     HISTORY
  64 */
  65
  66 AROS_LH2(float, SPAdd,
  67     AROS_LHA(float, fnum1, D1),
  68     AROS_LHA(float, fnum2, D0),
  69     struct LibHeader *, MathBase, 11, Mathffp
  70 )
  71 {
  72     AROS_LIBFUNC_INIT
  73
  74     LONG Res;
  75     ULONG Mant1, Mant2;
  76     char Shift;
  77     char Exponent;
  78
  79     SetSR(0, Zero_Bit | Overflow_Bit | Negative_Bit );
  80
  81     Mant1 = fnum1 & FFPMantisse_Mask;
  82     Mant2 = fnum2 & FFPMantisse_Mask;
  83     Shift = ((char)fnum1 & FFPExponent_Mask) -
  84           ((char)fnum2 & FFPExponent_Mask);
  85
  86     if (Shift > 0)
  87     {
  88         if (Shift >= 31)
  89         {
  90             Mant2 = 0;
  91         }
  92         else
  93         {
  94             Mant2 >>= (Shift + 1);
  95         }
  96         Mant1 >>= 1;
  97         Exponent = (fnum1 & FFPExponent_Mask) + 1;
  98     }
  99     else
 100     {
 101         if (Shift <= -31)
 102         {
 103             Mant1 = 0;
 104         }
 105         else
 106         {
 107             Mant1 >>= (-Shift + 1);
 108         }
 109         Mant2 >>= 1;
 110         Exponent = (fnum2 & FFPExponent_Mask) + 1;
 111     }
 112
 113     /* sign(fnum1) == sign(fnum2)
 114     ** simple addition
 115     ** 0.5 <= res < 2
 116     */
 117     if ( ((BYTE) fnum1 & FFPSign_Mask) - ((BYTE) fnum2 & FFPSign_Mask) == 0)
 118     {
 119         Res = fnum1 & FFPSign_Mask;
 120         Mant1 += Mant2;
 121         if ((LONG) Mant1 > 0)
 122         {
 123             Exponent --;
 124             Mant1 +=Mant1;
 125         }
 126
 127         if (0 == Mant1)
 128         {
 129             SetSR(Zero_Bit, Zero_Bit | Negative_Bit | Overflow_Bit);
 130             return 0;
 131         }
 132     }
 133     /* second case: sign(fnum1) != sign(fnum2)
 134     ** -1 <= res < 1
 135     */
 136     else
 137     {
 138         if ((char) fnum1 < 0)
 139         {
 140             Mant1 = Mant2 - Mant1;
 141         }
 142         else /* fnum2 < 0 */
 143         {
 144             Mant1 = Mant1 - Mant2;
 145         }
 146         /* if the result is below zero */
 147         if ((LONG) Mant1 < 0)
 148         {
 149             Res = FFPSign_Mask;
 150             Mant1 =-Mant1;
 151             SetSR(Negative_Bit, Zero_Bit | Negative_Bit | Overflow_Bit);
 152         }
 153         else
 154         {
 155             Res = 0;
 156         }
 157         /* test the result for zero, has to be done before normalizing
 158         ** the mantisse
 159         */
 160         if (0 == Mant1)
 161         {
 162             SetSR(Zero_Bit, Zero_Bit | Overflow_Bit | Negative_Bit);
 163             return 0;
 164         }
 165         /* normalize the mantisse */
 166         while ((LONG) Mant1 > 0)
 167         {
 168             Mant1 += Mant1;  /* one bit to the left. */
 169             Exponent--;
 170         }
 171     } /* else */
 172
 173     if ((char) Exponent < 0)
 174     {
 175         SetSR(Overflow_Bit, Zero_Bit | Overflow_Bit);
 176         /* do NOT change Negative_Bit! */
 177         return (Res | (FFPMantisse_Mask | FFPExponent_Mask));
 178     }
 179
 180     Res |= (Mant1 & FFPMantisse_Mask) | Exponent;
 181
 182     kprintf("SPAdd(%x,%x)=%x\n",fnum1,fnum2,Res);
 183
 184     return Res;
 185
 186     AROS_LIBFUNC_EXIT
 187 }