home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1995 March / macformat-022.iso / Shareware City / Developers / src / out-of-phase-102-c / OutOfPhase 1.02 Source / OutOfPhase Folder / Level 0 Macintosh 29Sep94 / FloatingPoint.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-23  |  3.7 KB  |  201 lines  |  [TEXT/KAHL]
  1. /* FloatingPoint.c */
  2. /*****************************************************************************/
  3. /*                                                                           */
  4. /*    System Dependency Library for Building Portable Software               */
  5. /*    Macintosh Version                                                      */
  6. /*    Written by Thomas R. Lawrence, 1993 - 1994.                            */
  7. /*                                                                           */
  8. /*    This file is Public Domain; it may be used for any purpose whatsoever  */
  9. /*    without restriction.                                                   */
  10. /*                                                                           */
  11. /*    This package is distributed in the hope that it will be useful,        */
  12. /*    but WITHOUT ANY WARRANTY; without even the implied warranty of         */
  13. /*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.                   */
  14. /*                                                                           */
  15. /*    Thomas R. Lawrence can be reached at tomlaw@world.std.com.             */
  16. /*                                                                           */
  17. /*****************************************************************************/
  18.  
  19. #include "MiscInfo.h"
  20. #include "Debug.h"
  21. #include "Audit.h"
  22. #include "Definitions.h"
  23.  
  24. #ifdef THINK_C
  25.     #pragma options(pack_enums)
  26. #endif
  27. #include <SANE.h>
  28. #ifdef THINK_C
  29.     #pragma options(!pack_enums)
  30. #endif
  31.  
  32. #include "FloatingPoint.h"
  33.  
  34.  
  35. #ifdef THINK_C
  36.     #if !__option(mc68881) && __option(native_fp)
  37.         /* native for no FPU = always 10-byte (no convertion necessary) */
  38.         #define x80tox96(X,Y) (*(Y) = *(X))
  39.         #define x96tox80(X,Y) (*(Y) = *(X))
  40.     #else
  41.         /* use normal definition */
  42.     #endif
  43. #endif
  44.  
  45.  
  46. long double                XGETPI(void)
  47.     {
  48.         extended            A;
  49.         long double        B;
  50.  
  51.         A = pi();
  52.         x80tox96(&A,&B);
  53.         return B;
  54.     }
  55.  
  56.  
  57. long double                XATAN(long double X)
  58.     {
  59.         extended            A;
  60.         long double        B;
  61.  
  62.         x96tox80(&X,&A);
  63.         A = atan(A);
  64.         x80tox96(&A,&B);
  65.         return B;
  66.     }
  67.  
  68.  
  69. long double                XCOS(long double X)
  70.     {
  71.         extended            A;
  72.         long double        B;
  73.  
  74.         x96tox80(&X,&A);
  75.         A = cos(A);
  76.         x80tox96(&A,&B);
  77.         return B;
  78.     }
  79.  
  80.  
  81. long double                XEXP(long double X)
  82.     {
  83.         extended            A;
  84.         long double        B;
  85.  
  86.         x96tox80(&X,&A);
  87.         A = exp(A);
  88.         x80tox96(&A,&B);
  89.         return B;
  90.     }
  91.  
  92.  
  93. long double                XFABS(long double X)
  94.     {
  95.         extended            A;
  96.         long double        B;
  97.  
  98.         x96tox80(&X,&A);
  99.         A = fabs(A);
  100.         x80tox96(&A,&B);
  101.         return B;
  102.     }
  103.  
  104.  
  105. long double                XLN(long double X)
  106.     {
  107.         extended            A;
  108.         long double        B;
  109.  
  110.         x96tox80(&X,&A);
  111.         A = log(A);
  112.         x80tox96(&A,&B);
  113.         return B;
  114.     }
  115.  
  116.  
  117. long double                XSIN(long double X)
  118.     {
  119.         extended            A;
  120.         long double        B;
  121.  
  122.         x96tox80(&X,&A);
  123.         A = sin(A);
  124.         x80tox96(&A,&B);
  125.         return B;
  126.     }
  127.  
  128.  
  129. long double                XSQRT(long double X)
  130.     {
  131.         extended            A;
  132.         long double        B;
  133.  
  134.         x96tox80(&X,&A);
  135.         A = sqrt(A);
  136.         x80tox96(&A,&B);
  137.         return B;
  138.     }
  139.  
  140.  
  141. long double                XTAN(long double X)
  142.     {
  143.         extended            A;
  144.         long double        B;
  145.  
  146.         x96tox80(&X,&A);
  147.         A = tan(A);
  148.         x80tox96(&A,&B);
  149.         return B;
  150.     }
  151.  
  152.  
  153. long double                XPOWER(long double X, long double Y)
  154.     {
  155.         extended            XX;
  156.         extended            YY;
  157.         extended            ZZ;
  158.         long double        Z;
  159.  
  160.         x96tox80(&X,&XX);
  161.         x96tox80(&Y,&YY);
  162.         ZZ = power(XX,YY);
  163.         x80tox96(&ZZ,&Z);
  164.         return Z;
  165.     }
  166.  
  167.  
  168. long double                XACOS(long double X)
  169.     {
  170.         return 2 * XATAN(XSQRT((1 - X) / (1 + X)));
  171.     }
  172.  
  173.  
  174. long double                XASIN(long double X)
  175.     {
  176.         long double        Y;
  177.  
  178.         Y = XFABS(X);
  179.         if (Y > 0.5)
  180.             {
  181.                 Y = 1 - Y;
  182.                 Y = 2 * Y - Y * Y;
  183.             }
  184.          else
  185.             {
  186.                 Y = 1 - Y * Y;
  187.             }
  188.         return XATAN(X / XSQRT(Y));
  189.     }
  190.  
  191.  
  192. MyBoolean                    ISNAN(long double X)
  193.     {
  194.         extended            XX;
  195.         numclass            Form;
  196.  
  197.         x96tox80(&X,&XX);
  198.         Form = classextended(XX);
  199.         return ((Form != NORMALNUM) && (Form != ZERONUM) && (Form != DENORMALNUM));
  200.     }
  201.