home *** CD-ROM | disk | FTP | other *** search
/ Meeting Pearls 3 / Meeting_Pearls_III.iso / Pearls / texmf / source / TeX / tex / arith.c next >
C/C++ Source or Header  |  1993-11-01  |  5KB  |  245 lines
  1. /* Use new ANSI Standard Lib functions to speed up arithmetic */
  2.  
  3. #include <stdlib.h>    /* for `div_t' and `ldiv_t' structs */
  4.  
  5. #define EXTERN extern
  6. #include "texd.h"
  7.  
  8. /*
  9.  *   Fuer Amiga und andere:
  10.  *
  11.  * ldiv ist eine Division zweier `long'-Werte
  12.  *
  13.  
  14. ldiv_t ldiv(long numer, long denom)
  15. {
  16.   ldiv_t res;
  17.  
  18.   res.quot = numer / denom;
  19.   res.rem = numer - res.quot * denom;
  20.   return res;
  21. }
  22.  
  23.  *
  24.  * ist fuer Amiga im File `ldiv.asm' bzw. ist in der C-Library.
  25.  *
  26.  */
  27.  
  28.  
  29.  
  30. integer half ( integer x )
  31. {
  32.      /* define odd(x)  ((x) % 2)   in "extra.c" */
  33.     /* simpler: odd(x)  ((x) & 1)   is ok for x<0 */
  34.   if ( x & 1 )        /* if ( odd ( x ) ) */
  35.     return ( x + 1 ) / 2;
  36.   else
  37.     return x / 2;
  38. }
  39.  
  40. #if 0
  41. scaled rounddecimals ( smallnumber k )
  42. { integer a;
  43.  
  44.   a = 0 ; 
  45.   while ( k > 0 ) {
  46.     decr ( k ) ; 
  47.     a = ( a + dig [ k ] * two ) / 10 ; 
  48.   } 
  49.   return ( a + 1 ) / 2 ; 
  50. }
  51. #endif
  52.  
  53. void printscaled ( scaled s )
  54. { printscaled_regmem 
  55.   scaled delta;
  56.  
  57.   if ( s < 0 ) {
  58.     printchar ( 45 ) ; 
  59.     s = - (integer) s ; 
  60.   }
  61.  
  62.   printint ( s / unity ) ; 
  63.   printchar ( 46 ) ; 
  64.   s = TEN_MULT( s % unity ) + 5 ; 
  65.   delta = 10 ; 
  66.   do {
  67.     if ( delta > unity ) 
  68.       s = s - 17232 ; 
  69.     printchar ( 48 + ( s / unity ) ) ; 
  70.     s = TEN_MULT( s % unity ) ; 
  71.     delta = TEN_MULT(delta) ; 
  72.   } while ( s > delta ) ; 
  73. }
  74.  
  75. scaled multandadd ( integer n, scaled x, scaled y, scaled maxanswer )
  76. { multandadd_regmem 
  77.  
  78.   if ( n < 0 ) {
  79.     x = - (integer) x;
  80.     n = - (integer) n;
  81.   }
  82.   if ( n == 0 ) 
  83.     return y;
  84.  
  85.   if ( ( x <= (maxanswer-y)/n ) && ( - (integer) x <= (maxanswer+y)/n ) )
  86.     return ( n * x + y );
  87.  
  88.   aritherror = true ; 
  89.   return 0;
  90. } 
  91.  
  92.  
  93. scaled xovern ( scaled x, integer n )
  94. { register int negative = false;    /* was "boolean" */
  95.   ldiv_t r;
  96.  
  97.   if ( n == 0 ) {
  98.     aritherror = true ;
  99.     remainder = x ;
  100.     return 0 ;
  101.   }
  102.  
  103.   if ( n < 0 ) {
  104.       x = - (integer) x ; 
  105.       n = - (integer) n ; 
  106.       negative = true ; 
  107.   }
  108.   if ( x >= 0 ) {
  109.       r = ldiv(x, n);
  110.       if( negative )
  111.     r.rem = - r.rem;
  112.       remainder = (integer) r.rem;
  113.       return( (integer) r.quot );
  114.   } else {
  115.       x = - (integer) x;
  116.       r = ldiv(x, n);
  117.       if( ! negative )
  118.     r.rem = - r.rem;
  119.       remainder = (integer) r.rem;
  120.       return( - (integer) r.quot );
  121.   }
  122. }
  123.  
  124.  
  125. scaled xnoverd ( scaled xs, integer int_n, integer int_d )
  126. { xnoverd_regmem
  127.   register unsigned long n = int_n;    /* GCC is better with this */
  128.   register unsigned long d = int_d;
  129.   register int positive;    /* was "boolean" */
  130.   nonnegativeinteger t, u, v;
  131.   unsigned long x;
  132.   ldiv_t r;
  133.  
  134.   if ( xs >= 0 )
  135.     positive = true;
  136.   else {
  137.     xs = - (integer) xs;
  138.     positive = false;
  139.   }
  140.  
  141.   /* GCC is better with this ... */
  142.   x = (unsigned long) xs;
  143.  
  144.   /* x is unsigned long,  x%(2^15) is unsigned short, n dto. */
  145.   t = ( x % 32768L ) * n;
  146.   u = ( x / 32768L ) * n + ( t / 32768L );
  147.  
  148.   r = ldiv(u, d);
  149.   v = ( r.rem ) * 32768L + ( t % 32768L );
  150.   if ( r.quot >= 32768L )
  151.     aritherror = true ; 
  152.   else
  153.     u = 32768L * ( r.quot );     /* + ( v / d ) */
  154.  
  155.   r = ldiv(v, d);
  156.   if ( positive ) {
  157.     remainder = r.rem;
  158.     return( (integer) u + r.quot );    /* here is +(v/d) */
  159.   } else {
  160.     remainder = - r.rem;
  161.     return( - ((integer) u + r.quot) );    /* here is +(v/d) */ 
  162.   }
  163. }
  164.  
  165.  
  166. #ifdef atarist
  167. /* GCC 1.37.1 for 68000 is (censored) with  moveq #16,d0  asll d0,d1
  168.  * instead of a simple clrw and swap of the register, so ...
  169.  */
  170. #define SWAP(a)  __asm__ volatile("swap %0" : "=d" (a) : "0" (a) )
  171. #define CLRW(a)  __asm__ volatile ("clrw %0" : "=d" (a) : "0" (a) )
  172. #define EXTL(a)  __asm__ volatile ("extl %0" : "=d" (a) : "0" (a) )
  173. #if 0
  174. #define MULU(a,b) ((b) = (a) * (b))
  175. #else
  176. #define MULU(a,b) \
  177.   __asm__ volatile ("mulu %2,%0" : "=d" (b) : "0" (b), "d,i" (a))
  178. #endif
  179. #endif
  180.  
  181.  
  182. long_halfword badness ( scaled t, scaled s )
  183. { integer r;
  184.   scaled t1;
  185.  
  186.   if ( t == 0 )
  187.     return 0;
  188.  
  189.   if ( s <= 0 ) 
  190.     return infbad;
  191.  
  192.   if ( t <= 7230584L ) {
  193. #ifdef atarist
  194.     /* r = (((unsigned short)(t >> 16)) * 297) << 16;  */
  195.     t1 = t;  SWAP(t1);
  196.     /* r = ((unsigned short) t1 ) * (unsigned short)297; */
  197.     MULU(297,t1); r = t1;
  198.     SWAP(r);  CLRW(r);
  199.  
  200.     /* r += ((unsigned short)(t & 0xffff)) * (unsigned short)297; */
  201.     MULU(297,t); r += t;
  202.     r /= s;
  203. #else
  204.     r = ( t * 297 ) / s ;
  205. #endif
  206.   } else {
  207.     if ( s >= 1663497L ) {
  208.     r = t / ( s / 297 ) ; 
  209.     } else
  210.         /* ==>> (t > 7.230.584  && s < 1.663.497) */
  211.     /* r = t ; */
  212.     return infbad;
  213.   }
  214.  
  215.   if ( r > 1290 ) 
  216.     return infbad;
  217.  
  218. #ifndef atarist
  219.   /* we know: r <= 1290 */
  220.   return( ( ((short)r) * ((short)r) * ((short)r) + 131072L ) / 262144L );
  221. #else
  222.   { unsigned long r1 /* = ((unsigned short) r) * ((unsigned short) r) */ ;
  223.     unsigned long res;
  224.     r1 = r; MULU(r, r1);
  225.  
  226.     /* res = (((unsigned short)(r1 >> 16)) * (unsigned short) r) << 16; */
  227.     res = r1;  SWAP(res);
  228.     /* res = ((unsigned short) res) * ((unsigned short) r); */
  229.     MULU(r, res);
  230.     SWAP(res);  CLRW(res);
  231.  
  232.     /* res += ((unsigned short)(r1 & 0xffff)) * ((unsigned short) r); */
  233.     MULU(r, r1); res += r1;
  234.  
  235. # if 0
  236.     return( ( res + 131072L ) / 262144L );
  237. # else
  238.     res += 131072L;  CLRW(res);  SWAP(res);  return( res >> 2 );
  239. # endif
  240.   }
  241. #endif
  242. } 
  243.  
  244. /* -- end -- */
  245.