home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / snipps97.zip / TRIGLIB.C < prev    next >
C/C++ Source or Header  |  1997-07-04  |  9KB  |  390 lines
  1. /* +++Date last modified: 05-Jul-1997 */
  2.  
  3. /******************************************************/
  4. /* Filespec  :  triglib.c triglib.h                   */
  5. /* Date      :  February 21 1997                      */
  6. /* Time      :  14:11                                 */
  7. /* Revision  :  1.0C                                  */
  8. /* Update    :                                        */
  9. /******************************************************/
  10. /* Programmer:  Nigel Traves                          */
  11. /* Address   :  5 Breamer Road, Collingham, Newark,   */
  12. /*           :  Notts, U.K.                           */
  13. /* Post Code :  NG23 7PN                              */
  14. /******************************************************/
  15. /* Released to the Public Domain                      */
  16. /******************************************************/
  17.  
  18. #include <math.h>
  19. #include "triglib.h"
  20.  
  21. #undef  PI
  22. #define PI              3.14159265358979323846
  23. #define PI_Times2       6.28318530717958647692        /* PI * 2 */
  24. #define PI_Divided_By2  1.57079632679489661923;       /* PI / 2 */
  25.  
  26. double asinh(double x)
  27. {
  28.       return (log(x + sqrt(x * x + 1.0)));
  29. }
  30.  
  31. double acosh(double x)
  32. {
  33.       return (log(x + sqrt(x * x - 1.0)));
  34. }
  35.  
  36. double atanh(double x)
  37. {
  38.       return (log((1.0 + x) / (1.0 - x)) / 2.0);
  39. }
  40.  
  41. void normalize_radians(double *radians)
  42. {
  43.       while (*radians > PI)
  44.             *radians -= PI_Times2;
  45.       while (*radians < -PI)
  46.             *radians += PI_Times2;
  47. }
  48.  
  49. void normalize_degrees(double *degrees)
  50. {
  51.       while (*degrees > 180.0)
  52.             *degrees -= 360.0;
  53.       while (*degrees < -180.0)
  54.             *degrees += 360.0;
  55. }
  56.  
  57. void normalize_grade(double *grade)
  58. {
  59.       while (*grade > 200.0)
  60.             *grade -= 400.0;
  61.       while (*grade < -200.0)
  62.             *grade += 400.0;
  63. }
  64.  
  65. double radians_to_degrees(double radians)
  66. {
  67.       normalize_radians(&radians);
  68.       return (radians * (180.0 / PI));
  69. }
  70.  
  71. double radians_to_grade(double radians)
  72. {
  73.       normalize_radians(&radians);
  74.       return (radians * (200.0 / PI));
  75. }
  76.  
  77. double degrees_to_radians(double degrees)
  78. {
  79.       normalize_degrees(°rees);
  80.       return (degrees * (PI / 180.0));
  81. }
  82.  
  83. double degrees_to_grade(double degrees)
  84. {
  85.       normalize_degrees(°rees);
  86.       return (degrees * 1.11111111111111111111);
  87. }
  88.  
  89. double grade_to_radians(double grade)
  90. {
  91.       normalize_grade(&grade);
  92.       return (grade * (PI / 200.0));
  93. }
  94.  
  95. double grade_to_degrees(double grade)
  96. {
  97.       normalize_grade(&grade);
  98.       return (grade * 0.9);
  99. }
  100.  
  101. double sine(double angle, enum angle_type atype)
  102. {
  103.       switch (atype)
  104.       {
  105.       case RAD:
  106.             normalize_radians(&angle);
  107.             return sin(angle);
  108.             break;
  109.  
  110.       case DEG:
  111.             return sin(degrees_to_radians(angle));
  112.             break;
  113.  
  114.       case GRAD:
  115.             return sin(grade_to_radians(angle));
  116.       }
  117. }
  118.  
  119. double cosine(double angle, enum angle_type atype)
  120. {
  121.       switch (atype)
  122.       {
  123.       case RAD:
  124.             normalize_radians(&angle);
  125.             return cos(angle);
  126.             break;
  127.  
  128.       case DEG:
  129.             return cos(degrees_to_radians(angle));
  130.             break;
  131.  
  132.       case GRAD:
  133.             return cos(grade_to_radians(angle));
  134.       }
  135. }
  136.  
  137. double tangent(double angle, enum angle_type atype)
  138. {
  139.       switch (atype)
  140.       {
  141.       case RAD:
  142.             normalize_radians(&angle);
  143.             return tan(angle);
  144.             break;
  145.  
  146.       case DEG:
  147.             return tan(degrees_to_radians(angle));
  148.             break;
  149.  
  150.       case GRAD:
  151.             return tan(grade_to_radians(angle));
  152.       }
  153. }
  154.  
  155. double secant(double angle, enum angle_type atype)
  156. {
  157.       return (1.0 / cosine(angle, atype));
  158. }
  159.  
  160. double cosecant(double angle, enum angle_type atype)
  161. {
  162.       return (1.0 / sine(angle, atype));
  163. }
  164.  
  165. double cotangent(double angle, enum angle_type atype)
  166. {
  167.       return (1.0 / tangent(angle, atype));
  168. }
  169.  
  170. double arc_sine(double x, enum angle_type out_type)
  171. {
  172.       switch (out_type)
  173.       {
  174.       case RAD:
  175.             return asin(x);
  176.             break;
  177.  
  178.       case DEG:
  179.             return radians_to_degrees(asin(x));
  180.             break;
  181.  
  182.       case GRAD:
  183.             return radians_to_grade(asin(x));
  184.       }
  185. }
  186.  
  187. double arc_cosine(double x, enum angle_type out_type)
  188. {
  189.       switch (out_type)
  190.       {
  191.       case RAD:
  192.             return acos(x);
  193.             break;
  194.  
  195.       case DEG:
  196.             return radians_to_degrees(acos(x));
  197.             break;
  198.  
  199.       case GRAD:
  200.             return radians_to_grade(acos(x));
  201.       }
  202. }
  203.  
  204. double arc_tangent(double x, enum angle_type out_type)
  205. {
  206.       switch (out_type)
  207.       {
  208.       case RAD:
  209.             return atan(x);
  210.             break;
  211.  
  212.       case DEG:
  213.             return radians_to_degrees(atan(x));
  214.             break;
  215.  
  216.       case GRAD:
  217.             return radians_to_grade(atan(x));
  218.       }
  219. }
  220.  
  221. double arc_secant(double x, enum angle_type out_type)
  222. {
  223.       return arc_cosine((1.0 / x), out_type);
  224. }
  225.  
  226. double arc_cosecant(double x, enum angle_type out_type)
  227. {
  228.       return arc_sine((1.0 / x), out_type);
  229. }
  230.  
  231. double arc_cotangent(double x, enum angle_type out_type)
  232. {
  233.       return arc_tangent((1.0 / x), out_type);
  234. }
  235.  
  236. double hyperbolic_sine(double angle, enum angle_type atype)
  237. {
  238.       switch (atype)
  239.       {
  240.       case RAD:
  241.             normalize_radians(&angle);
  242.             return sinh(angle);
  243.             break;
  244.  
  245.       case DEG:
  246.             return sinh(degrees_to_radians(angle));
  247.             break;
  248.  
  249.       case GRAD:
  250.             return sinh(grade_to_radians(angle));
  251.       }
  252. }
  253.  
  254. double hyperbolic_cosine(double angle, enum angle_type atype)
  255. {
  256.       switch (atype)
  257.       {
  258.       case RAD:
  259.             normalize_radians(&angle);
  260.             return cosh(angle);
  261.             break;
  262.  
  263.       case DEG:
  264.             return cosh(degrees_to_radians(angle));
  265.             break;
  266.  
  267.       case GRAD:
  268.             return cosh(grade_to_radians(angle));
  269.       }
  270. }
  271.  
  272. double hyperbolic_tangent(double angle, enum angle_type atype)
  273. {
  274.       switch (atype)
  275.       {
  276.       case RAD:
  277.             normalize_radians(&angle);
  278.             return tanh(angle);
  279.             break;
  280.  
  281.       case DEG:
  282.             return tanh(degrees_to_radians(angle));
  283.             break;
  284.  
  285.       case GRAD:
  286.             return tanh(grade_to_radians(angle));
  287.       }
  288. }
  289.  
  290. double hyperbolic_secant(double angle, enum angle_type atype)
  291. {
  292.       return (1.0 / hyperbolic_cosine(angle, atype));
  293. }
  294.  
  295. double hyperbolic_cosecant(double angle, enum angle_type atype)
  296. {
  297.       return (1.0 / hyperbolic_sine(angle, atype));
  298. }
  299.  
  300. double hyperbolic_cotangent(double angle, enum angle_type atype)
  301. {
  302.       return (1.0 / hyperbolic_tangent(angle, atype));
  303. }
  304.  
  305. double hyperbolic_arc_sine(double x, enum angle_type out_type)
  306. {
  307.       switch (out_type)
  308.       {
  309.       case RAD:
  310.             return asinh(x);
  311.             break;
  312.  
  313.       case DEG:
  314.             return radians_to_degrees(asinh(x));
  315.             break;
  316.  
  317.       case GRAD:
  318.             return radians_to_grade(asinh(x));
  319.       }
  320. }
  321.  
  322. double hyperbolic_arc_cosine(double x, enum angle_type out_type)
  323. {
  324.       switch (out_type)
  325.       {
  326.       case RAD:
  327.             return acosh(x);
  328.             break;
  329.  
  330.       case DEG:
  331.             return radians_to_degrees(acosh(x));
  332.             break;
  333.  
  334.       case GRAD:
  335.             return radians_to_grade(acosh(x));
  336.       }
  337. }
  338.  
  339. double hyperbolic_arc_tangent(double x, enum angle_type out_type)
  340. {
  341.       switch (out_type)
  342.       {
  343.       case RAD:
  344.             return atanh(x);
  345.             break;
  346.  
  347.       case DEG:
  348.             return radians_to_degrees(atanh(x));
  349.             break;
  350.  
  351.       case GRAD:
  352.             return radians_to_grade(atanh(x));
  353.       }
  354. }
  355.  
  356. double hyperbolic_arc_secant(double x, enum angle_type out_type)
  357. {
  358.       return hyperbolic_arc_cosine((1.0 / x), out_type);
  359. }
  360.  
  361. double hyperbolic_arc_cosecant(double x, enum angle_type out_type)
  362. {
  363.       return hyperbolic_arc_sine((1.0 / x), out_type);
  364. }
  365.  
  366. double hyperbolic_arc_cotangent(double x, enum angle_type out_type)
  367. {
  368.       return hyperbolic_arc_tangent((1.0 / x), out_type);
  369. }
  370.  
  371. double sech(double x)
  372. {
  373.       return (2.0 / (exp(x) + exp(-x)));
  374. }
  375.  
  376. double csch(double x)
  377. {
  378.       return (2.0 / (exp(x) - exp(-x)));
  379. }
  380.  
  381. double coth(double x)
  382. {
  383.       return (exp(-x) / (exp(x) - exp(-x)) * 2.0 + 1.0);
  384. }
  385.  
  386. double acoth(double x)
  387. {
  388.       return (log((x + 1.0) / (x - 1.0)) / 2.0);
  389. }
  390.