home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 13 / 13.iso / p / p024 / 12.img / ADS1.LIB / CALSTDF.C < prev    next >
Encoding:
C/C++ Source or Header  |  1993-02-17  |  47.4 KB  |  2,059 lines
  1. /*****************************************************************************
  2.       CALSTDF.C
  3.       (C) ¬⌐┼v 1988-1992  Autodesk ñ╜Ñq
  4.  
  5.       Ñ╗╡{ªíñwÑ╤ Autodesk ñ╜Ñq╡∙ÑU¬⌐┼v, ╢╚⌐≤ñU¡z▒í¬pñUÑi▒┬╗P▒zíu│\ÑiívíC
  6.       ╗╒ñUñú▒oÑHÑ⌠ª≤º╬ªí╡oªµ⌐╬ÑX¬⌐ª╣╡{ªí¬║íu¡∞⌐l╜Xív; ª²ñ╣│\▒zªb»S⌐w¡lÑ═
  7.       ¬║ñuº@ñW╡▓ªXª╣╡{ªí¬║íuÑ╪¬║╜Xív¿╧Ñ╬íCª│├÷│o├■¡lÑ═ñuº@¬║▒°Ñ≤ªpñU:
  8.  
  9.       ( i)  │]¡pñW╗Pñuº@ñW¼╥»┬║Θ░w╣∩ Autodesk ñ╜Ñq¬║▓ú½~íC
  10.       (ii)  ╕ⁿª│íu¬⌐┼v  (C) 1988-1992  Autodesk ñ╜Ñqív¬║¬⌐┼v│qºiíC
  11.  
  12.  
  13.  
  14.       AUTODESKñ╜Ñq┤ú¿╤ª╣╡{ªí╢╚¿╤º@íu├■ªⁿív¬║░╤ª╥, ª╙ÑBñú▒╞░úª│Ñ⌠ª≤┐∙╗~¬║
  15.       Ñi»αíCAUTODESKñ╜Ñq»Sª╣º_╗{Ñ⌠ª≤»S⌐wÑ╬│~ñº╛A║┘⌐╩, ÑHñ╬░╙╖~╛P░Γ⌐╥┴⌠ºt
  16.       ÑX¿π¬║½O├╥íCAUTODESKñ╜ÑqªP«╔ÑτñúÑX¿πª╣╡{ªí░⌡ªµ«╔ñ@⌐wñú╖|íuññ┬_ív⌐╬
  17.       íuº╣Ñ■╡L╗~ív¬║½O├╥íC
  18.  
  19.  
  20.   Description: Standard calculator functions.
  21.  
  22. *****************************************************************************/
  23.  
  24.  
  25. /****************************************************************************/
  26. /*  INCLUDES                                                                */
  27. /****************************************************************************/
  28.  
  29. #include "cal.h"
  30.  
  31.  
  32. /****************************************************************************/
  33. /*.doc sets_lastpoint(internal)*/
  34. /*+
  35.   Sets the value of the LASTPOINT AutoCAD variable.
  36. -*/
  37. /****************************************************************************/
  38.  
  39.  
  40. static void
  41. /*FCN*/set_lastpoint(p)
  42.  
  43.   ads_point p;
  44. {
  45.     struct resbuf rb;
  46.  
  47.     rb.restype = RT3DPOINT;
  48.     CPY_PNT(rb.resval.rpoint, p);
  49.     ads_setvar("LASTPOINT", &rb);
  50. } /*set_lastpoint*/
  51.  
  52.  
  53. /****************************************************************************/
  54. /*.doc cal_rXof_func(internal)*/
  55. /*+
  56.   Calculator 'rXof()' function.
  57. -*/
  58. /****************************************************************************/
  59.  
  60.  
  61. static void
  62. /*FCN*/cal_rXof_func()
  63. {
  64.     if (no_of_params != 1) {
  65.         error(4, "rXof");
  66.         return;
  67.     }
  68.     if (!IS_VECTOR(0)) {
  69.         error(11, "rXof");
  70.         return;
  71.     }
  72.  
  73.     result.type = real_type;
  74.     result.r    = params[0].v[X];
  75. } /*cal_rXof_func*/
  76.  
  77.  
  78. /****************************************************************************/
  79. /*.doc cal_rYof_func(internal)*/
  80. /*+
  81.   Calculator 'rYof()' function.
  82. -*/
  83. /****************************************************************************/
  84.  
  85.  
  86. static void
  87. /*FCN*/cal_rYof_func()
  88. {
  89.     if (no_of_params != 1) {
  90.         error(4, "rYof");
  91.         return;
  92.     }
  93.     if (!IS_VECTOR(0)) {
  94.         error(11, "rYof");
  95.         return;
  96.     }
  97.  
  98.     result.type = real_type;
  99.     result.r    = params[0].v[Y];
  100. } /*cal_rYof_func*/
  101.  
  102.  
  103. /****************************************************************************/
  104. /*.doc cal_rZof_func(internal)*/
  105. /*+
  106.   Calculator 'rZof()' function.
  107. -*/
  108. /****************************************************************************/
  109.  
  110.  
  111. static void
  112. /*FCN*/cal_rZof_func()
  113. {
  114.     if (no_of_params != 1) {
  115.         error(4, "rZof");
  116.         return;
  117.     }
  118.     if (!IS_VECTOR(0)) {
  119.         error(11, "rZof");
  120.         return;
  121.     }
  122.  
  123.     result.type = real_type;
  124.     result.r    = params[0].v[Z];
  125. } /*cal_rZof_func*/
  126.  
  127.  
  128. /****************************************************************************/
  129. /*.doc cal_Xof_func(internal)*/
  130. /*+
  131.   Calculator 'Xof()' function.
  132. -*/
  133. /****************************************************************************/
  134.  
  135.  
  136. static void
  137. /*FCN*/cal_Xof_func()
  138. {
  139.     if (no_of_params != 1) {
  140.         error(4, "Xof");
  141.         return;
  142.     }
  143.  
  144.     result.type = vector_type;
  145.     result.v[X] = result.v[Y] = result.v[Z] = 0.0;
  146.  
  147.     if (params[0].type == vector_type) {
  148.         result.v[X] = params[0].v[X];
  149.     } else {
  150.         result.v[X] = params[0].r;
  151.     }
  152. } /*cal_Xof_func*/
  153.  
  154.  
  155. /****************************************************************************/
  156. /*.doc cal_Yof_func(internal)*/
  157. /*+
  158.   Calculator 'Yof()' function.
  159. -*/
  160. /****************************************************************************/
  161.  
  162.  
  163. static void
  164. /*FCN*/cal_Yof_func()
  165. {
  166.     if (no_of_params != 1) {
  167.         error(4, "Yof");
  168.         return;
  169.     }
  170.  
  171.     result.type = vector_type;
  172.     result.v[X] = result.v[Y] = result.v[Z] = 0.0;
  173.  
  174.     if (params[0].type == vector_type) {
  175.         result.v[Y] = params[0].v[Y];
  176.     } else {
  177.         result.v[Y] = params[0].r;
  178.     }
  179. } /*cal_Yof_func*/
  180.  
  181.  
  182. /****************************************************************************/
  183. /*.doc cal_Zof_func(internal)*/
  184. /*+
  185.   Calculator 'Zof()' function.
  186. -*/
  187. /****************************************************************************/
  188.  
  189.  
  190. static void
  191. /*FCN*/cal_Zof_func()
  192. {
  193.     if (no_of_params != 1) {
  194.         error(4, "Zof");
  195.         return;
  196.     }
  197.  
  198.     result.type = vector_type;
  199.     result.v[X] = result.v[Y] = result.v[Z] = 0.0;
  200.  
  201.     if (params[0].type == vector_type) {
  202.         result.v[Z] = params[0].v[Z];
  203.     } else {
  204.         result.v[Z] = params[0].r;
  205.     }
  206. } /*cal_Zof_func*/
  207.  
  208.  
  209. /****************************************************************************/
  210. /*.doc cal_XYof_func(internal)*/
  211. /*+
  212.   Calculator 'XYof()' function.
  213. -*/
  214. /****************************************************************************/
  215.  
  216.  
  217. static void
  218. /*FCN*/cal_XYof_func()
  219. {
  220.     if (no_of_params != 1) {
  221.         error(4, "XYof");
  222.         return;
  223.     }
  224.     if (!IS_VECTOR(0)) {
  225.         error(11, "XYof");
  226.         return;
  227.     }
  228.  
  229.     result = params[0];
  230.     result.v[Z] = 0.0;
  231. } /*cal_XYof_func*/
  232.  
  233.  
  234. /****************************************************************************/
  235. /*.doc cal_YZof_func(internal)*/
  236. /*+
  237.   Calculator 'YZof()' function.
  238. -*/
  239. /****************************************************************************/
  240.  
  241.  
  242. static void
  243. /*FCN*/cal_YZof_func()
  244. {
  245.     if (no_of_params != 1) {
  246.         error(4, "YZof");
  247.         return;
  248.     }
  249.     if (!IS_VECTOR(0)) {
  250.         error(11, "YZof");
  251.         return;
  252.     }
  253.  
  254.     result = params[0];
  255.     result.v[X] = 0.0;
  256. } /*cal_YZof_func*/
  257.  
  258.  
  259. /****************************************************************************/
  260. /*.doc cal_XZof_func(internal)*/
  261. /*+
  262.   Calculator 'XZof()' function.
  263. -*/
  264. /****************************************************************************/
  265.  
  266.  
  267. static void
  268. /*FCN*/cal_XZof_func()
  269. {
  270.     if (no_of_params != 1) {
  271.         error(4, "XZof");
  272.         return;
  273.     }
  274.     if (!IS_VECTOR(0)) {
  275.         error(11, "XZof");
  276.         return;
  277.     }
  278.  
  279.     result = params[0];
  280.     result.v[Y] = 0.0;
  281. } /*cal_XZof_func*/
  282.  
  283.  
  284. /****************************************************************************/
  285. /*.doc cal_ABS_func(internal)*/
  286. /*+
  287.   Calculator 'ABS()' function.
  288. -*/
  289. /****************************************************************************/
  290.  
  291.  
  292. static void
  293. /*FCN*/cal_ABS_func()
  294. {
  295.     if (no_of_params != 1) {
  296.         error(4, "ABS");
  297.         return;
  298.     }
  299.  
  300.     result.type = real_type;
  301.     if (params[0].type == vector_type) {
  302.         result.r = LENGTH(params[0].v);
  303.     } else {
  304.         result.r = fabs(params[0].r);
  305.     }
  306. } /*cal_ABS_func*/
  307.  
  308.  
  309. /****************************************************************************/
  310. /*.doc cal_ASIN_func(internal)*/
  311. /*+
  312.   Calculator 'ASIN()' function.
  313. -*/
  314. /****************************************************************************/
  315.  
  316.  
  317. static void
  318. /*FCN*/cal_ASIN_func()
  319. {
  320.     double a;
  321.  
  322.     if (no_of_params != 1) {
  323.         error(4, "ASIN");
  324.         return;
  325.     }
  326.     if (!IS_REAL(0)) {
  327.         error(12, "ASIN");
  328.         return;
  329.     }
  330.  
  331.     a = params[0].r;
  332.     result.type = real_type;
  333.  
  334.     if (fabs(a) > 1.1) {
  335.         error(13, "ASIN");
  336.         return;
  337.     }
  338.  
  339.     if (a >  1.0) {
  340.         a =  1.0;
  341.     } else if (a < -1.0) {
  342.         a = -1.0;
  343.     }
  344.  
  345.     result.r = asin(a) / DEGRAD;
  346. } /*cal_ASIN_func*/
  347.  
  348.  
  349. /****************************************************************************/
  350. /*.doc cal_ACOS_func(internal)*/
  351. /*+
  352.   Calculator 'ACOS()' function.
  353. -*/
  354. /****************************************************************************/
  355.  
  356.  
  357. static void
  358. /*FCN*/cal_ACOS_func()
  359. {
  360.     double a;
  361.  
  362.     if (no_of_params != 1) {
  363.         error(4, "ACOS");
  364.         return;
  365.     }
  366.     if (!IS_REAL(0)) {
  367.         error(12, "ACOS");
  368.         return;
  369.     }
  370.  
  371.     a = params[0].r;
  372.     result.type = real_type;
  373.  
  374.     if (fabs(a) > 1.1) {
  375.         error(13, "ACOS");
  376.         return;
  377.     }
  378.  
  379.     if (a >  1.0) {
  380.         a =  1.0;
  381.     } else if (a < -1.0) {
  382.         a = -1.0;
  383.     }
  384.  
  385.     result.r = acos(a) / DEGRAD;
  386. } /*cal_ACOS_func*/
  387.  
  388.  
  389. /****************************************************************************/
  390. /*.doc cal_ATAN_func(internal)*/
  391. /*+
  392.   Calculator 'ATAN()' function.
  393. -*/
  394. /****************************************************************************/
  395.  
  396.  
  397. static void
  398. /*FCN*/cal_ATAN_func()
  399. {
  400.     if (no_of_params != 1) {
  401.         error(4, "ATAN");
  402.         return;
  403.     }
  404.     if (!IS_REAL(0)) {
  405.         error(12, "ATAN");
  406.         return;
  407.     }
  408.  
  409.     result.type = real_type;
  410.     result.r    = atan(params[0].r) / DEGRAD;
  411. } /*cal_ATAN_func*/
  412.  
  413.  
  414. /****************************************************************************/
  415. /*.doc cal_SIN_func(internal)*/
  416. /*+
  417.   Calculator 'SIN()' function.
  418. -*/
  419. /****************************************************************************/
  420.  
  421.  
  422. static void
  423. /*FCN*/cal_SIN_func()
  424. {
  425.     if (no_of_params != 1) {
  426.         error(4, "SIN");
  427.         return;
  428.     }
  429.     if (!IS_REAL(0)) {
  430.         error(12, "SIN");
  431.         return;
  432.     }
  433.  
  434.     result.type = real_type;
  435.     result.r    = sin(DEGRAD * params[0].r);
  436. } /*cal_SIN_func*/
  437.  
  438.  
  439. /****************************************************************************/
  440. /*.doc cal_COS_func(internal)*/
  441. /*+
  442.   Calculator 'COS()' function.
  443. -*/
  444. /****************************************************************************/
  445.  
  446.  
  447. static void
  448. /*FCN*/cal_COS_func()
  449. {
  450.     if (no_of_params != 1) {
  451.         error(4, "COS");
  452.         return;
  453.     }
  454.     if (!IS_REAL(0)) {
  455.         error(12, "COS");
  456.         return;
  457.     }
  458.  
  459.     result.type = real_type;
  460.     result.r    = cos(DEGRAD * params[0].r);
  461. } /*cal_COS_func*/
  462.  
  463.  
  464. /****************************************************************************/
  465. /*.doc cal_TANG_func(internal)*/
  466. /*+
  467.   Calculator 'TANG()' function.
  468. -*/
  469. /****************************************************************************/
  470.  
  471.  
  472. static void
  473. /*FCN*/cal_TANG_func()
  474. {
  475.     if (no_of_params != 1) {
  476.         error(4, "TANG");
  477.         return;
  478.     }
  479.     if (!IS_REAL(0)) {
  480.         error(12, "TANG");
  481.         return;
  482.     }
  483.     if (fabs(fmod(fabs(params[0].r), 180.0) - 90.0) < EPS) {
  484.         error(24, NULL);
  485.         return;
  486.     }
  487.  
  488.     result.type = real_type;
  489.     result.r    = tan(DEGRAD * params[0].r);
  490. } /*cal_TANG_func*/
  491.  
  492.  
  493. /****************************************************************************/
  494. /*.doc cal_ROUND_func(internal)*/
  495. /*+
  496.   Calculator 'ROUND()' function.
  497. -*/
  498. /****************************************************************************/
  499.  
  500.  
  501. static void
  502. /*FCN*/cal_ROUND_func()
  503. {
  504.     double r;
  505.  
  506.     if (no_of_params != 1) {
  507.         error(4, "ROUND");
  508.         return;
  509.     }
  510.     if (!IS_REAL(0)) {
  511.         error(12, "ROUND");
  512.         return;
  513.     }
  514.  
  515.     r = floor(params[0].r + 0.5);
  516.  
  517.     if ((r > 32767) || (r < -32768)) {
  518.         error(14, NULL);
  519.         return;
  520.     }
  521.  
  522.     result.type = int_type;
  523.     result.r    = r;
  524. } /*cal_ROUND_func*/
  525.  
  526.  
  527. /****************************************************************************/
  528. /*.doc cal_TRUNC_func(internal)*/
  529. /*+
  530.   Calculator 'TRUNC()' function.
  531. -*/
  532. /****************************************************************************/
  533.  
  534.  
  535. static void
  536. /*FCN*/cal_TRUNC_func()
  537. {
  538.     double r;
  539.  
  540.     if (no_of_params != 1) {
  541.         error(4, "TRUNC");
  542.         return;
  543.     }
  544.     if (!IS_REAL(0)) {
  545.         error(12, "TRUNC");
  546.         return;
  547.     }
  548.  
  549.     r = params[0].r;
  550.  
  551.     if ((r > 32767) || (r < -32768)) {
  552.         error(14, NULL);
  553.         return;
  554.     }
  555.  
  556.     result.type = int_type;
  557.     result.r    = (int)(r);
  558. } /*cal_TRUNC_func*/
  559.  
  560.  
  561. /****************************************************************************/
  562. /*.doc cal_SQR_func(internal)*/
  563. /*+
  564.   Calculator 'SQR()' function.
  565. -*/
  566. /****************************************************************************/
  567.  
  568.  
  569. static void
  570. /*FCN*/cal_SQR_func()
  571. {
  572.     if (no_of_params != 1) {
  573.         error(4, "SQR");
  574.         return;
  575.     }
  576.     if (!IS_REAL(0)) {
  577.         error(12, "SQR");
  578.         return;
  579.     }
  580.  
  581.     result.type = real_type;
  582.     result.r    = SQR(params[0].r);
  583. } /*cal_SQR_func*/
  584.  
  585.  
  586. /****************************************************************************/
  587. /*.doc cal_SQRT_func(internal)*/
  588. /*+
  589.   Calculator 'SQRT()' function.
  590. -*/
  591. /****************************************************************************/
  592.  
  593.  
  594. static void
  595. /*FCN*/cal_SQRT_func()
  596. {
  597.     double r;
  598.  
  599.     if (no_of_params != 1) {
  600.         error(4, "SQRT");
  601.         return;
  602.     }
  603.     if (!IS_REAL(0)) {
  604.         error(12, "SQRT");
  605.         return;
  606.     }
  607.  
  608.     r = params[0].r;
  609.  
  610.     if (r < -EPS) {
  611.         error(15, NULL);
  612.         return;
  613.     }
  614.     if (r < 0.0) {
  615.         r = 0.0;
  616.     }
  617.  
  618.     result.type = real_type;
  619.     result.r    = sqrt(r);
  620. } /*cal_SQRT_func*/
  621.  
  622.  
  623. /****************************************************************************/
  624. /*.doc cal_R2Dfunc(internal)*/
  625. /*+
  626.   Calculator 'R2D()' function.
  627. -*/
  628. /****************************************************************************/
  629.  
  630.  
  631. static void
  632. /*FCN*/cal_R2D_func()
  633. {
  634.     if (no_of_params != 1) {
  635.         error(4, "R2D");
  636.         return;
  637.     }
  638.     if (!IS_REAL(0)) {
  639.         error(12, "R2D");
  640.         return;
  641.     }
  642.  
  643.     result.type = real_type;
  644.     result.r    = params[0].r / DEGRAD;
  645. } /*cal_R2D_func*/
  646.  
  647.  
  648. /****************************************************************************/
  649. /*.doc cal_D2R_func(internal)*/
  650. /*+
  651.   Calculator 'D2R()' function.
  652. -*/
  653. /****************************************************************************/
  654.  
  655.  
  656. static void
  657. /*FCN*/cal_D2R_func()
  658. {
  659.     if (no_of_params != 1) {
  660.         error(4, "D2R");
  661.         return;
  662.     }
  663.     if (!IS_REAL(0)) {
  664.         error(12, "D2R");
  665.         return;
  666.     }
  667.  
  668.     result.type = real_type;
  669.     result.r    = params[0].r * DEGRAD;
  670. } /*cal_D2R_func*/
  671.  
  672.  
  673. /****************************************************************************/
  674. /*.doc cal_LN_func(internal)*/
  675. /*+
  676.   Calculator 'LN()' function.
  677. -*/
  678. /****************************************************************************/
  679.  
  680.  
  681. static void
  682. /*FCN*/cal_LN_func()
  683. {
  684.     if (no_of_params != 1) {
  685.         error(4, "LN");
  686.         return;
  687.     }
  688.     if (!IS_REAL(0)) {
  689.         error(12, "LN");
  690.         return;
  691.     }
  692.     if (params[0].r <= 0.0) {
  693.         error(38, "LN");
  694.         return;
  695.     }
  696.  
  697.     result.type = real_type;
  698.     result.r    = log(params[0].r);
  699. } /*cal_LN_func*/
  700.  
  701.  
  702. /****************************************************************************/
  703. /*.doc cal_LOG_func(internal)*/
  704. /*+
  705.   Calculator 'LOG()' function.
  706. -*/
  707. /****************************************************************************/
  708.  
  709.  
  710. static void
  711. /*FCN*/cal_LOG_func()
  712. {
  713.     if (no_of_params != 1) {
  714.         error(4, "LOG");
  715.         return;
  716.     }
  717.     if (!IS_REAL(0)) {
  718.         error(12, "LOG");
  719.         return;
  720.     }
  721.     if (params[0].r <= 0.0) {
  722.         error(38, "LOG");
  723.         return;
  724.     }
  725.  
  726.     result.type = real_type;
  727.     result.r    = log10(params[0].r);
  728. } /*cal_LOG_func*/
  729.  
  730.  
  731. /****************************************************************************/
  732. /*.doc cal_EXP_func(internal)*/
  733. /*+
  734.   Calculator 'EXP()' function.
  735. -*/
  736. /****************************************************************************/
  737.  
  738.  
  739. static void
  740. /*FCN*/cal_EXP_func()
  741. {
  742.     if (no_of_params != 1) {
  743.         error(4, "EXP");
  744.         return;
  745.     }
  746.     if (!IS_REAL(0)) {
  747.         error(12, "EXP");
  748.         return;
  749.     }
  750.  
  751.     result.type = real_type;
  752.     result.r    = exp(params[0].r);
  753. } /*cal_EXP_func*/
  754.  
  755.  
  756. /****************************************************************************/
  757. /*.doc cal_EXP10_func(internal)*/
  758. /*+
  759.   Calculator 'EXP10()' function.
  760. -*/
  761. /****************************************************************************/
  762.  
  763.  
  764. static void
  765. /*FCN*/cal_EXP10_func()
  766. {
  767.     if (no_of_params != 1) {
  768.         error(4, "EXP10");
  769.         return;
  770.     }
  771.     if (!IS_REAL(0)) {
  772.         error(12, "EXP10");
  773.         return;
  774.     }
  775.  
  776.     result.type = real_type;
  777.     result.r    = exp(log(10.0) * params[0].r);
  778. } /*cal_EXP10_func*/
  779.  
  780.  
  781. /****************************************************************************/
  782. /*.doc cal_U2W_func(internal)*/
  783. /*+
  784.   Calculator 'U2W()' function.
  785. -*/
  786. /****************************************************************************/
  787.  
  788.  
  789. static void
  790. /*FCN*/cal_U2W_func()
  791. {
  792.     if (no_of_params != 1) {
  793.         error(4, "U2W");
  794.         return;
  795.     }
  796.     if (!IS_VECTOR(0)) {
  797.         error(11, "U2W");
  798.         return;
  799.     }
  800.  
  801.     result.type = vector_type;
  802.     sa_u2w(params[0].v, result.v);
  803. } /*cal_U2W_func*/
  804.  
  805.  
  806. /****************************************************************************/
  807. /*.doc cal_W2U_func(internal)*/
  808. /*+
  809.   Calculator 'W2U()' function.
  810. -*/
  811. /****************************************************************************/
  812.  
  813.  
  814. static void
  815. /*FCN*/cal_W2U_func()
  816. {
  817.     if (no_of_params != 1) {
  818.         error(4, "W2U");
  819.         return;
  820.     }
  821.     if (!IS_VECTOR(0)) {
  822.         error(11, "W2U");
  823.         return;
  824.     }
  825.  
  826.     result.type = vector_type;
  827.     sa_w2u(params[0].v, result.v);
  828. } /*cal_W2U_func*/
  829.  
  830.  
  831. /****************************************************************************/
  832. /*.doc cal_ANG_func(internal)*/
  833. /*+
  834.   Calculator 'ANG()' function.
  835. -*/
  836. /****************************************************************************/
  837.  
  838.  
  839. static void
  840. /*FCN*/cal_ANG_func()
  841. {
  842.     double    ang;
  843.     ads_point p0, p1, p2, p3, origin;
  844.     int       i, success;
  845.     int       all_vectors = TRUE;
  846.  
  847.     for (i = 0; i < no_of_params; i++) {
  848.         if (!IS_VECTOR(i)) {
  849.             all_vectors = FALSE;
  850.             break;
  851.         }
  852.     }
  853.  
  854.     if (!all_vectors || (no_of_params < 1) || (no_of_params > 4)) {
  855.         error(26, "ANG(v), ANG(p1,p2), ANG(apex,p1,p2), ANG(apex,p1,p2,p)");
  856.         return;
  857.     }
  858.  
  859.     CPY_PNT(p0, params[0].v);
  860.     CPY_PNT(p1, params[1].v);
  861.     CPY_PNT(p2, params[2].v);
  862.     CPY_PNT(p3, params[3].v);
  863.     origin[X] = origin[Y] = origin[Z] = 0.0;
  864.  
  865.     if (no_of_params == 1) {
  866.         p0[Z] = 0.0;
  867.         if (LENGTH(p0) < EPS) {
  868.             error(56, NULL);
  869.             return;
  870.         }
  871.         ang = ads_angle(origin, p0);
  872.  
  873.     } else if (no_of_params == 2) {
  874.         p0[Z] = p1[Z] = 0.0;
  875.         if (DISTANCE(p0, p1) < EPS) {
  876.             error(39, NULL);
  877.             return;
  878.         }
  879.         ang = ads_angle(p0, p1);
  880.  
  881.     } else if (no_of_params == 3) {
  882.         p0[Z] = p1[Z] = p2[Z] = 0.0;
  883.  
  884.         if ((DISTANCE(p0, p1) < EPS) ||
  885.             (DISTANCE(p0, p2) < EPS) ||
  886.             (DISTANCE(p1, p2) < EPS)) {
  887.             error(57, NULL);
  888.             return;
  889.         }
  890.         ang = ads_angle(p0, p2) - ads_angle(p0, p1);
  891.  
  892.     } else {                          /*no_of_params == 4*/
  893.  
  894.         ads_point normal, v1, v2;
  895.         double    d, dist;
  896.  
  897.         if ((DISTANCE(p0, p1) < EPS) || (DISTANCE(p0, p2) < EPS) ||
  898.             (DISTANCE(p0, p3) < EPS) || (DISTANCE(p1, p2) < EPS) ||
  899.             (DISTANCE(p1, p3) < EPS) || (DISTANCE(p2, p3) < EPS))  {
  900.             error(37, NULL);
  901.             return;
  902.         }
  903.  
  904.         success = sa_plane_equation(TRUE, p0, p1, p2, normal, &d);
  905.         if (success == RTNORM) {
  906.             dist = DOTPROD(normal, p3) + d;
  907.             if (fabs(dist) < EPS) {
  908.                 error(36, NULL);
  909.                 return;
  910.             }
  911.             if (dist > 0.0) {
  912.                 ADD_PNT(p3, p0, normal);
  913.             } else {
  914.                 SUB_PNT(p3, p0, normal);
  915.             }
  916.             ang = sa_angle_around_axis(p0, p3, p1, p2);
  917.         } else {
  918.             SUB_PNT(v1, p1, p0);
  919.             SUB_PNT(v2, p2, p0);
  920.             if (DOTPROD(v1, v2) > 0.0) {
  921.                 ang = 0.0;
  922.             } else {
  923.                 ang = PI;
  924.             }
  925.         }
  926.     }
  927.  
  928.     sa_normalize_angle(&ang);
  929.     result.type = real_type;
  930.     result.r    = ang / DEGRAD;
  931. } /*cal_ANG_func*/
  932.  
  933.  
  934. /****************************************************************************/
  935. /*.doc cal_RAD_func(internal)*/
  936. /*+
  937.   Calcualtor 'RAD' function.
  938. -*/
  939. /****************************************************************************/
  940.  
  941.  
  942. static void
  943. /*FCN*/cal_RAD_func()
  944. {
  945.     int    success;
  946.     double rad;
  947.  
  948.     if (no_of_params != 0) {
  949.         error(25, "RAD");
  950.         return;
  951.     }
  952.  
  953.     success = sa_get_radius_of_picked_entity(
  954. ">> ┐∩╛▄└└ѵÑIíuRAD Ñ\134»α¿τªíívñºíu╢ΩívíBíu⌐╖ív⌐╬íu╗EªX╜uív▓╒¼q:\n",
  955.                                              &rad);
  956.     if (success != RTNORM) {
  957.         error(0, NULL);
  958.         return;
  959.     }
  960.  
  961.     result.type = real_type;
  962.     result.r    = rad;
  963. } /*cal_RAD_func*/
  964.  
  965.  
  966. /****************************************************************************/
  967. /*.doc cal_NOR_func(internal)*/
  968. /*+
  969.   Claculator 'NOR()' function.
  970. -*/
  971. /****************************************************************************/
  972.  
  973.  
  974. static void
  975. /*FCN*/cal_NOR_func()
  976. {
  977.     int        i, success;
  978.     ads_point  nor;
  979.     double     len;
  980.     int        all_vectors = TRUE;
  981.  
  982.     for (i = 0; i < no_of_params; i++) {
  983.         if (!IS_VECTOR(i)) {
  984.             all_vectors = FALSE;
  985.             break;
  986.         }
  987.     }
  988.  
  989.     if (!all_vectors || (no_of_params > 3)) {
  990.         error(26, "NOR, NOR(v), NOR(p1,p2), NOR(p1,p2,p3)");
  991.         return;
  992.     }
  993.  
  994.     if (no_of_params == 0) {          /*3D normal to picked entity*/
  995.         ads_point origin, xaxis, yaxis, zaxis;
  996.  
  997.         success = sa_get_cs_of_picked_entity(
  998. ">> ┐∩╛▄└└ѵÑIíuNOR Ñ\134»α¿τ╝╞ívñºíu╢ΩívíBíu⌐╖ív⌐╬íu╗EªX╜uív▓╒¼q:\n",
  999. FALSE, origin,
  1000. xaxis, yaxis, zaxis);
  1001.         if (success != RTNORM) {
  1002.             error(0, NULL);
  1003.             return;
  1004.         }
  1005.  
  1006.         SUB_PNT(nor, zaxis, origin);
  1007.         sa_normalize(nor);
  1008.  
  1009.     } else if (no_of_params == 1) {   /*2D normal to vector*/
  1010.  
  1011.         nor[X] = -params[0].v[Y];
  1012.         nor[Y] =  params[0].v[X];
  1013.         nor[Z] = 0.0;
  1014.  
  1015.         len = LENGTH(nor);
  1016.         if (len < EPS) {
  1017.             error(30, NULL);
  1018.             return;
  1019.         }
  1020.  
  1021.         nor[X] /= len;
  1022.         nor[Y] /= len;
  1023.  
  1024.     } else if (no_of_params == 2) {   /*2D normal to line*/
  1025.  
  1026.         nor[X] = params[0].v[Y] - params[1].v[Y];
  1027.         nor[Y] = params[1].v[X] - params[0].v[X];
  1028.         nor[Z] = 0.0;
  1029.  
  1030.         len = LENGTH(nor);
  1031.         if (len < EPS) {
  1032.             error(61, "NOR(p1,p2)");
  1033.             return;
  1034.         }
  1035.  
  1036.         nor[X] /= len;
  1037.         nor[Y] /= len;
  1038.  
  1039.     } else {                          /*3D normal to plane by 3 points*/
  1040.         double d;
  1041.  
  1042.         if (!IS_VECTOR(0) || !IS_VECTOR(1) || !IS_VECTOR(2)) {
  1043.             error(26, "NOR, NOR(v), NOR(p1,p2), NOR(p1,p2,p3)");
  1044.             return;
  1045.         }
  1046.         success = sa_plane_equation(TRUE, params[0].v, params[1].v,
  1047.                                     params[2].v,
  1048.                                     nor, &d);
  1049.         if (success != RTNORM) {
  1050.             error(51, NULL);
  1051.             return;
  1052.         }
  1053.     }
  1054.  
  1055.     result.type = vector_type;
  1056.     CPY_PNT(result.v, nor);
  1057. } /*cal_NOR_func*/
  1058.  
  1059.  
  1060. /****************************************************************************/
  1061. /*.doc cal_ILL_func(internal)*/
  1062. /*+
  1063.     Calculator 'ILL()' function.
  1064. -*/
  1065. /****************************************************************************/
  1066.  
  1067.  
  1068. static void
  1069. /*FCN*/cal_ILL_func()
  1070. {
  1071.     int success;
  1072.  
  1073.     if ((no_of_params != 4) ||
  1074.         !IS_VECTOR(0) || !IS_VECTOR(1) || !IS_VECTOR(2) || !IS_VECTOR(3)) {
  1075.         error(26, "ILL(p1,p2,p3,p4)");
  1076.         return;
  1077.     }
  1078.  
  1079.     if ((DISTANCE(params[0].v, params[1].v) < EPS) ||
  1080.         (DISTANCE(params[2].v, params[3].v) < EPS)) {
  1081.         error(40, "ILL");
  1082.         return;
  1083.     }
  1084.  
  1085.     result.type = vector_type;
  1086.     success = ads_inters(params[0].v, params[1].v,
  1087.                          params[2].v, params[3].v, 0, result.v);
  1088.  
  1089.     if (success != RTNORM) {
  1090.         error(54, "ILL");
  1091.         return;
  1092.     }
  1093. } /*cal_ILL_func*/
  1094.  
  1095.  
  1096. /****************************************************************************/
  1097. /*.doc cal_ILP_func(internal)*/
  1098. /*+
  1099.     Calculator 'ILP()' function.
  1100. -*/
  1101. /****************************************************************************/
  1102.  
  1103.  
  1104. static void
  1105. /*FCN*/cal_ILP_func()
  1106. {
  1107.     ads_point p, v, n;
  1108.     double    d, t, denom;
  1109.     int       success;
  1110.  
  1111.     if ((no_of_params != 5)            ||
  1112.         !IS_VECTOR(0) || !IS_VECTOR(1) ||
  1113.         !IS_VECTOR(2) || !IS_VECTOR(3) || !IS_VECTOR(4)) {
  1114.  
  1115.         error(26, "ILP(p1,p2,p3,p4,p5)");
  1116.         return;
  1117.     }
  1118.  
  1119.     CPY_PNT(p, params[0].v);
  1120.     SUB_PNT(v, params[1].v, params[0].v);
  1121.  
  1122.     if (LENGTH(v) < EPS) {
  1123.         error(40, "ILP");
  1124.         return;
  1125.     }
  1126.  
  1127.     success = sa_plane_equation(TRUE, params[2].v, params[3].v,
  1128.                                 params[4].v,
  1129.                                 n, &d);
  1130.     if (success != RTNORM) {
  1131.         error(59, NULL);
  1132.         return;
  1133.     }
  1134.  
  1135.     denom = DOTPROD(n, v);
  1136.     if (fabs(denom) < EPS) {
  1137.         if (fabs(DOTPROD(p, n) + d) < EPS)
  1138.             error(62, NULL);
  1139.         else
  1140.             error(55, NULL);
  1141.         return;
  1142.     }
  1143.     t = -(d + DOTPROD(n, p)) / denom;
  1144.  
  1145.     result.type = vector_type;
  1146.     result.v[X] = p[X] + t * v[X];
  1147.     result.v[Y] = p[Y] + t * v[Y];
  1148.     result.v[Z] = p[Z] + t * v[Z];
  1149.  
  1150. } /*cal_ILP_func*/
  1151.  
  1152.  
  1153. /****************************************************************************/
  1154. /*.doc cal_DPL_func(internal)*/
  1155. /*+
  1156.     Calculator 'DPL()' function.
  1157. -*/
  1158. /****************************************************************************/
  1159.  
  1160.  
  1161. static void
  1162. /*FCN*/cal_DPL_func()
  1163. {
  1164.     ads_point q, p, v, qp, a;
  1165.     double    len, t;
  1166.  
  1167.     if ((no_of_params != 3) ||
  1168.         !IS_VECTOR(0) || !IS_VECTOR(1) || !IS_VECTOR(2)) {
  1169.  
  1170.         error(26, "DPL(p,p1,p2)");
  1171.         return;
  1172.     }
  1173.  
  1174.     CPY_PNT(q, params[0].v);
  1175.     CPY_PNT(p, params[1].v);
  1176.     SUB_PNT(v, params[2].v, params[1].v);
  1177.  
  1178.     len = LENGTH(v);
  1179.     if (len < EPS) {
  1180.         error(40, "DPL");
  1181.         return;
  1182.     }
  1183.  
  1184.     v[X] /= len;
  1185.     v[Y] /= len;
  1186.     v[Z] /= len;
  1187.  
  1188.     SUB_PNT(qp, q, p);
  1189.     t = DOTPROD(v, qp);
  1190.     a[X] = p[X] + t * v[X];
  1191.     a[Y] = p[Y] + t * v[Y];
  1192.     a[Z] = p[Z] + t * v[Z];
  1193.  
  1194.     result.type = real_type;
  1195.     result.r    = DISTANCE(q, a);
  1196.  
  1197. } /*cal_DPL_func*/
  1198.  
  1199.  
  1200. /****************************************************************************/
  1201. /*.doc cal_DPP_func(internal)*/
  1202. /*+
  1203.     Calculator 'DPP()' function.
  1204. -*/
  1205. /****************************************************************************/
  1206.  
  1207.  
  1208. static void
  1209. /*FCN*/cal_DPP_func()
  1210. {
  1211.     ads_point n;
  1212.     double    d;
  1213.     int       success;
  1214.  
  1215.     if ((no_of_params != 4) ||
  1216.         !IS_VECTOR(0) || !IS_VECTOR(1) || !IS_VECTOR(2) || !IS_VECTOR(3)) {
  1217.  
  1218.         error(26, "DPP(p,p1,p2,p3)");
  1219.         return;
  1220.     }
  1221.  
  1222.     success = sa_plane_equation(TRUE, params[1].v, params[2].v,
  1223.                                 params[3].v,
  1224.                                 n,&d);
  1225.     if (success != RTNORM) {
  1226.         error(59, NULL);
  1227.         return;
  1228.     }
  1229.  
  1230.     result.type = real_type;
  1231.     result.r    = fabs(DOTPROD(n, params[0].v)+d);
  1232. } /*cal_DPP_func*/
  1233.  
  1234.  
  1235. /****************************************************************************/
  1236. /*.doc cal_PLT_func(internal)*/
  1237. /*+
  1238.     Calculator 'PLT()' function.
  1239. -*/
  1240. /****************************************************************************/
  1241.  
  1242.  
  1243. static void
  1244. /*FCN*/cal_PLT_func()
  1245. {
  1246.     double t1, t2;
  1247.  
  1248.     if ((no_of_params != 3) ||
  1249.         !IS_VECTOR(0) || !IS_VECTOR(1) || !IS_REAL(2)) {
  1250.         error(26, "PLT(p1,p2,t)");
  1251.         return;
  1252.     }
  1253.  
  1254.     t2 = params[2].r;
  1255.     t1 = 1.0 - t2;
  1256.  
  1257.     result.type = vector_type;
  1258.     result.v[X] = t1 * params[0].v[X] + t2 * params[1].v[X];
  1259.     result.v[Y] = t1 * params[0].v[Y] + t2 * params[1].v[Y];
  1260.     result.v[Z] = t1 * params[0].v[Z] + t2 * params[1].v[Z];
  1261.  
  1262. } /*cal_PLT_func*/
  1263.  
  1264.  
  1265. /****************************************************************************/
  1266. /*.doc cal_PLD_func(internal)*/
  1267. /*+
  1268.     Calculator 'PLD()' function.
  1269. -*/
  1270. /****************************************************************************/
  1271.  
  1272.  
  1273. static void
  1274. /*FCN*/cal_PLD_func()
  1275. {
  1276.     double d, d12, t1, t2;
  1277.  
  1278.     if ((no_of_params != 3) ||
  1279.         !IS_VECTOR(0) || !IS_VECTOR(1) || !IS_REAL(2)) {
  1280.         error(26, "PLD(p1,p2,dist)");
  1281.         return;
  1282.     }
  1283.  
  1284.     d = params[2].r;
  1285.     d12 = DISTANCE(params[0].v, params[1].v);
  1286.  
  1287.     if (d12 < EPS) {
  1288.         error(58, NULL);
  1289.         return;
  1290.     }
  1291.  
  1292.     t2 = d / d12;
  1293.     t1 = 1.0 - t2;
  1294.  
  1295.     result.type = vector_type;
  1296.     result.v[X] = t1 * params[0].v[X] + t2 * params[1].v[X];
  1297.     result.v[Y] = t1 * params[0].v[Y] + t2 * params[1].v[Y];
  1298.     result.v[Z] = t1 * params[0].v[Z] + t2 * params[1].v[Z];
  1299.  
  1300. } /*cal_PLD_func*/
  1301.  
  1302.  
  1303. /****************************************************************************/
  1304. /*.doc pick_end_end(internal) */
  1305. /*+
  1306.     Prompts the user to pick two entities by cursor and returns coordinates
  1307.     of their endpoints in 'p1' and 'p2'.
  1308.  
  1309.     Function returns one of the standard ADS result codes.
  1310. -*/
  1311. /****************************************************************************/
  1312.  
  1313.  
  1314. static int
  1315. /*FCN*/pick_end_end(p1, p2, fcn_name)
  1316.  
  1317.   ads_point p1, p2;                   /* Returned endpoints */
  1318.   char      fcn_name[];               /* Prompt             */
  1319. {
  1320.     int  success;
  1321.     char prompt[100];
  1322.     int  ok = TRUE;
  1323.  
  1324.     do {
  1325.         strcpy(prompt, ">> ┐∩╛▄ñ@íu║▌┬Iíví╨ ");
  1326.         strcat(prompt, fcn_name);
  1327.         strcat(prompt, ":\n");
  1328.  
  1329.         success = sa_snap(prompt, "_END", p1);
  1330.         if (success != RTNORM)
  1331.             return(success);
  1332.  
  1333.         strcpy(prompt, ">> ┐∩╛▄Ñtñ@íu║▌┬Iíví╨ ");
  1334.         strcat(prompt, fcn_name);
  1335.         strcat(prompt, ":\n");
  1336.  
  1337.         success = sa_snap(prompt, "_END", p2);
  1338.         if (success != RTNORM)
  1339.             return(success);
  1340.  
  1341.         if (DISTANCE(p1, p2) < EPS) {
  1342.             ads_printf("\n¼D┐∩¬║¿Γ║▌┬IÑ▓╢╖íuñúªPívíC\n\n");
  1343.             ok = FALSE;
  1344.         } else {
  1345.             ok = TRUE;
  1346.         }
  1347.     } while (!ok);
  1348.  
  1349.     return(RTNORM);
  1350. } /*pick_end_end*/
  1351.  
  1352.  
  1353. /****************************************************************************/
  1354. /*.doc cal_MEE_func(internal)*/
  1355. /*+
  1356.     Calculator 'MEE' function.
  1357. -*/
  1358. /****************************************************************************/
  1359.  
  1360.  
  1361. static void
  1362. /*FCN*/cal_MEE_func()
  1363. {
  1364.     ads_point p1, p2;
  1365.     int       success;
  1366.  
  1367.     if (no_of_params != 0) {
  1368.         error(25, "MEE");
  1369.         return;
  1370.     }
  1371.  
  1372.     success = pick_end_end(p1, p2, "MEE");
  1373.     if (success != RTNORM) {
  1374.         error(0, NULL);
  1375.         return;
  1376.     }
  1377.  
  1378.     result.type = vector_type;
  1379.     result.v[X] = (p1[X] + p2[X]) / 2;
  1380.     result.v[Y] = (p1[Y] + p2[Y]) / 2;
  1381.     result.v[Z] = (p1[Z] + p2[Z]) / 2;
  1382.  
  1383. } /*cal_MEE_func*/
  1384.  
  1385.  
  1386. /****************************************************************************/
  1387. /*.doc cal_DEE_func(internal)*/
  1388. /*+
  1389.     calculator 'DEE' function.
  1390. -*/
  1391. /****************************************************************************/
  1392.  
  1393.  
  1394. static void
  1395. /*FCN*/cal_DEE_func()
  1396. {
  1397.     ads_point p1, p2;
  1398.     int       success;
  1399.  
  1400.     if (no_of_params != 0) {
  1401.         error(25, "DEE");
  1402.         return;
  1403.     }
  1404.  
  1405.     success = pick_end_end(p1, p2, "DEE");
  1406.     if (success != RTNORM) {
  1407.         error(0, NULL);
  1408.         return;
  1409.     }
  1410.  
  1411.     result.type = real_type;
  1412.     result.r    = DISTANCE(p1, p2);
  1413.  
  1414. } /*cal_DEE_func*/
  1415.  
  1416.  
  1417. /****************************************************************************/
  1418. /*.doc cal_NEE_func(internal)*/
  1419. /*+
  1420.     Calculator 'NEE' function.
  1421. -*/
  1422. /****************************************************************************/
  1423.  
  1424.  
  1425. static void
  1426. /*FCN*/cal_NEE_func()
  1427. {
  1428.     ads_point p1, p2;
  1429.     ads_point n;
  1430.     double    len;
  1431.     int       success;
  1432.  
  1433.     if (no_of_params != 0) {
  1434.         error(25, "NEE");
  1435.         return;
  1436.     }
  1437.  
  1438.     success = pick_end_end(p1, p2, "NEE");
  1439.     if (success != RTNORM)  {
  1440.         error(61, "NEE");
  1441.         return;
  1442.     }
  1443.  
  1444.     n[X] = p1[Y] - p2[Y];
  1445.     n[Y] = p2[X] - p1[X];
  1446.     n[Z] = 0.0;
  1447.  
  1448.     len = LENGTH(n);
  1449.     if (len < EPS) {
  1450.         error(61, "NEE");
  1451.         return;
  1452.     }
  1453.  
  1454.     result.type = vector_type;
  1455.     result.v[X] = n[X] / len;
  1456.     result.v[Y] = n[Y] / len;
  1457.     result.v[Z] = 0.0;
  1458. } /*cal_NEE_func*/
  1459.  
  1460.  
  1461. /****************************************************************************/
  1462. /*.doc cal_VEE_func(internal)*/
  1463. /*+
  1464.     Calculator 'VEE' function.
  1465. -*/
  1466. /****************************************************************************/
  1467.  
  1468.  
  1469. static void
  1470. /*FCN*/cal_VEE_func()
  1471. {
  1472.     ads_point p1, p2;
  1473.     int       success;
  1474.  
  1475.     if (no_of_params != 0) {
  1476.         error(25, "VEE");
  1477.         return;
  1478.     }
  1479.  
  1480.     success = pick_end_end(p1, p2, "VEE");
  1481.     if (success != RTNORM) {
  1482.         error(0, NULL);
  1483.         return;
  1484.     }
  1485.  
  1486.     result.type = vector_type;
  1487.     SUB_PNT(result.v, p2, p1);
  1488. } /*cal_VEE_func*/
  1489.  
  1490.  
  1491. /****************************************************************************/
  1492. /*.doc cal_VEE1_func(internal)*/
  1493. /*+
  1494.     Calculator 'VEE1' function.
  1495. -*/
  1496. /****************************************************************************/
  1497.  
  1498.  
  1499. static void
  1500. /*FCN*/cal_VEE1_func()
  1501. {
  1502.     ads_point p1, p2;
  1503.     int       success;
  1504.  
  1505.     if (no_of_params != 0) {
  1506.         error(25, "VEE1");
  1507.         return;
  1508.     }
  1509.  
  1510.     success = pick_end_end(p1, p2, "VEE1");
  1511.     if (success != RTNORM) {
  1512.         error(0, NULL);
  1513.         return;
  1514.     }
  1515.  
  1516.     result.type = vector_type;
  1517.     SUB_PNT(result.v, p2, p1);
  1518.     sa_normalize(result.v);
  1519. } /*cal_VEE1_func*/
  1520.  
  1521.  
  1522. /****************************************************************************/
  1523. /*.doc cal_PLTEE_func(internal)*/
  1524. /*+
  1525.     Calculator 'PLTEE()' function.
  1526. -*/
  1527. /****************************************************************************/
  1528.  
  1529.  
  1530. static void
  1531. /*FCN*/cal_PLTEE_func()
  1532. {
  1533.     double    t1, t2;
  1534.     int       success;
  1535.     ads_point p1, p2;
  1536.  
  1537.     if ((no_of_params != 1) || !IS_REAL(0)) {
  1538.         error(26, "PLTEE(t)");
  1539.         return;
  1540.     }
  1541.  
  1542.     success = pick_end_end(p1, p2, "PLTEE");
  1543.     if (success != RTNORM) {
  1544.         error(0, NULL);
  1545.         return;
  1546.     }
  1547.  
  1548.     t2 = params[0].r;
  1549.     t1 = 1.0 - t2;
  1550.  
  1551.     result.type = vector_type;
  1552.     result.v[X] = t1 * p1[X] + t2 * p2[X];
  1553.     result.v[Y] = t1 * p1[Y] + t2 * p2[Y];
  1554.     result.v[Z] = t1 * p1[Z] + t2 * p2[Z];
  1555.  
  1556. } /*cal_PLTEE_func*/
  1557.  
  1558.  
  1559. /****************************************************************************/
  1560. /*.doc cal_PLDEE_func(internal)*/
  1561. /*+
  1562.     Calculator 'PLDEE()' function.
  1563. -*/
  1564. /****************************************************************************/
  1565.  
  1566.  
  1567. static void
  1568. /*FCN*/cal_PLDEE_func()
  1569. {
  1570.     double    d, d12, t1, t2;
  1571.     ads_point p1, p2;
  1572.     int       success;
  1573.  
  1574.     if ((no_of_params != 1) || !IS_REAL(0)) {
  1575.         error(26, "PLDEE(dist)");
  1576.         return;
  1577.     }
  1578.  
  1579.     success = pick_end_end(p1, p2, "PLDEE");
  1580.     if (success != RTNORM) {
  1581.         error(0, NULL);
  1582.         return;
  1583.     }
  1584.  
  1585.     d = params[0].r;
  1586.     d12 = DISTANCE(p1, p2);
  1587.  
  1588.     t2 = d / d12;
  1589.     t1 = 1.0 - t2;
  1590.  
  1591.     result.type = vector_type;
  1592.     result.v[X] = t1 * p1[X] + t2 * p2[X];
  1593.     result.v[Y] = t1 * p1[Y] + t2 * p2[Y];
  1594.     result.v[Z] = t1 * p1[Z] + t2 * p2[Z];
  1595.  
  1596. } /*cal_PLDEE_func*/
  1597.  
  1598.  
  1599. /****************************************************************************/
  1600. /*.doc cal_ILLE_func(internal)*/
  1601. /*+
  1602.     Calculator 'ILLE()' function.
  1603. -*/
  1604. /****************************************************************************/
  1605.  
  1606.  
  1607. static void
  1608. /*FCN*/cal_ILLE_func()
  1609. {
  1610.     int       success;
  1611.     ads_point p1, p2, p3, p4;
  1612.  
  1613.     if (no_of_params != 0) {
  1614.         error(25, "ILLE");
  1615.         return;
  1616.     }
  1617.  
  1618.     success = pick_end_end(p1, p2, "ILLE:▓─ñ@▒°╜u");
  1619.     if (success != RTNORM) {
  1620.         error(0, NULL);
  1621.         return;
  1622.     }
  1623.  
  1624.     success = pick_end_end(p3, p4, "ILLE:▓─ñG▒°╜u");
  1625.     if (success != RTNORM) {
  1626.         error(0, NULL);
  1627.         return;
  1628.     }
  1629.  
  1630.     result.type = vector_type;
  1631.     success = ads_inters(p1, p2, p3, p4, 0, result.v);
  1632.     if (success != RTNORM) {
  1633.         error(54, "ILLE");
  1634.         return;
  1635.     }
  1636.  
  1637. } /*cal_ILLE_func*/
  1638.  
  1639.  
  1640. /****************************************************************************/
  1641. /*.doc cal_DISP_func(internal)*/
  1642. /*+
  1643.     Calculator 'DIST()' function.
  1644. -*/
  1645. /****************************************************************************/
  1646.  
  1647.  
  1648. static void
  1649. /*FCN*/cal_DIST_func()
  1650. {
  1651.     if ((no_of_params != 2) || !IS_VECTOR(0) || !IS_VECTOR(1)) {
  1652.         error(26, "DIST(p1,p2)");
  1653.         return;
  1654.     }
  1655.  
  1656.     result.type = real_type;
  1657.     result.r    = DISTANCE(params[0].v, params[1].v);
  1658. } /*cal_DIST_func*/
  1659.  
  1660.  
  1661. /****************************************************************************/
  1662. /*.doc cal_VEC_func(internal)*/
  1663. /*+
  1664.     Calculator 'VEC()' function.
  1665. -*/
  1666. /****************************************************************************/
  1667.  
  1668.  
  1669. static void
  1670. /*FCN*/cal_VEC_func()
  1671. {
  1672.     if ((no_of_params != 2) || !IS_VECTOR(0) || !IS_VECTOR(1)) {
  1673.         error(26, "VEC(FromPt,ToPt)");
  1674.         return;
  1675.     }
  1676.  
  1677.     result.type = vector_type;
  1678.     SUB_PNT(result.v, params[1].v, params[0].v);
  1679. } /*cal_VEC_func*/
  1680.  
  1681.  
  1682. /****************************************************************************/
  1683. /*.doc cal_VEC1_func(internal)*/
  1684. /*+
  1685.     Calculator 'VEC1()' function.
  1686. -*/
  1687. /****************************************************************************/
  1688.  
  1689.  
  1690. static void
  1691. /*FCN*/cal_VEC1_func()
  1692. {
  1693.     if ((no_of_params != 2) || !IS_VECTOR(0) || !IS_VECTOR(1)) {
  1694.         error(26, "VEC1(FromPt,ToPt)");
  1695.         return;
  1696.     }
  1697.  
  1698.     result.type = vector_type;
  1699.     SUB_PNT(result.v, params[1].v, params[0].v);
  1700.     sa_normalize(result.v);
  1701. } /*cal_VEC1_func*/
  1702.  
  1703.  
  1704. /****************************************************************************/
  1705. /*.doc cal_ROT_func(internal)*/
  1706. /*+
  1707.     Calculator 'ROT()' function.
  1708. -*/
  1709. /****************************************************************************/
  1710.  
  1711.  
  1712. static void
  1713. /*FCN*/cal_ROT_func()
  1714. {
  1715.     ads_point p, p1, p2;
  1716.     double    angle;
  1717.     int       success, given_3_points, given_4_points;
  1718.  
  1719.     given_3_points = ((no_of_params == 3) &&
  1720.                       IS_VECTOR(0) && IS_VECTOR(1) && IS_REAL(2));
  1721.     given_4_points = ((no_of_params == 4) &&
  1722.                       IS_VECTOR(0) && IS_VECTOR(1) &&
  1723.                       IS_VECTOR(2) && IS_REAL(3));
  1724.  
  1725.     if (!given_3_points && !given_4_points) {
  1726.         error(26, "ROT(p,origin,angle) or ROT(p,p1ax,p2ax,angle)");
  1727.         return;
  1728.     }
  1729.  
  1730.     CPY_PNT(p,  params[0].v);
  1731.     CPY_PNT(p1, params[1].v);
  1732.  
  1733.     if (given_3_points) {
  1734.         CPY_PNT(p2, p1);
  1735.         p2[Z] += 1.0;
  1736.         angle = params[2].r;
  1737.     } else {
  1738.         CPY_PNT(p2, params[2].v);
  1739.         angle = params[3].r;
  1740.     }
  1741.  
  1742.     if (DISTANCE(p1, p2) < EPS) {
  1743.         error(53, NULL);
  1744.         return;
  1745.     }
  1746.  
  1747.     success = sa_rotate_point_around_axis(p, (angle * DEGRAD), p1, p2);
  1748.     if (success != RTNORM) {
  1749.         error(48, NULL);
  1750.         return;
  1751.     }
  1752.  
  1753.     result.type = vector_type;
  1754.     CPY_PNT(result.v, p);
  1755. } /*cal_ROT_func*/
  1756.  
  1757.  
  1758. /****************************************************************************/
  1759. /*.doc cal_CUR_func(internal)*/
  1760. /*+
  1761.     Calculator 'CUR' function.
  1762. -*/
  1763. /****************************************************************************/
  1764.  
  1765.  
  1766. static void
  1767. /*FCN*/cal_CUR_func()
  1768. {
  1769.     int success;
  1770.  
  1771.     if (no_of_params != 0) {
  1772.         error(25, "CUR");
  1773.         return;
  1774.     }
  1775.  
  1776.     result.type = vector_type;
  1777.     ads_initget(1+8, NULL);
  1778.  
  1779.     success = ads_getpoint(NULL, ">> ┐ΘñJñ@┬I:\n", result.v);
  1780.  
  1781.     if (success != RTNORM) {
  1782.         error(0, NULL);
  1783.         return;
  1784.     }
  1785.     set_lastpoint(result.v);
  1786. } /*cal_CUR_func*/
  1787.  
  1788.  
  1789. /****************************************************************************/
  1790. /*.doc cal_snap(internal)*/
  1791. /*+
  1792.    Local snap function.
  1793. -*/
  1794. /****************************************************************************/
  1795.  
  1796.  
  1797. static void
  1798. /*FCN*/cal_snap(snap_mode)
  1799.  
  1800.   char snap_mode[];                   /* String "END", "MID", "CEN", etc. */
  1801. {
  1802.     char prompt[40];
  1803.     int  success;
  1804.  
  1805.     if (no_of_params != 0) {
  1806.         error(25, snap_mode);
  1807.         return;
  1808.     }
  1809.  
  1810.     strcpy(prompt, ">> ┐∩╛▄íu╣╧ñ╕ívÑH╢iªµíu");
  1811.     strcat(prompt, snap_mode);
  1812.     strcat(prompt, "ív┬Ω┬I:\n");
  1813.  
  1814.     result.type = vector_type;
  1815.     success = sa_snap(prompt, snap_mode, result.v);
  1816.  
  1817.     if (success != RTNORM) {
  1818.         error(0, NULL);
  1819.     }
  1820.     set_lastpoint(result.v);
  1821. } /*cal_snap*/
  1822.  
  1823.  
  1824. /****************************************************************************/
  1825. /*.doc cal_END_func(internal)*/
  1826. /*+
  1827.     Calculator 'END' snap function.
  1828. -*/
  1829. /****************************************************************************/
  1830.  
  1831.  
  1832. static void
  1833. /*FCN*/cal_END_func()
  1834. {
  1835.     cal_snap("_END");
  1836. } /*cal_END_func*/
  1837.  
  1838.  
  1839. /****************************************************************************/
  1840. /*.doc cal_MID_func(internal)*/
  1841. /*+
  1842.     Calculator 'MID' snap function.
  1843. -*/
  1844. /****************************************************************************/
  1845.  
  1846.  
  1847. static void
  1848. /*FCN*/cal_MID_func()
  1849. {
  1850.     cal_snap("_MID");
  1851. } /*cal_MID_func*/
  1852.  
  1853.  
  1854. /****************************************************************************/
  1855. /*.doc cal_CEN_func(internal)*/
  1856. /*+
  1857.     Calculator 'CEN' snap function.
  1858. -*/
  1859. /****************************************************************************/
  1860.  
  1861.  
  1862. static void
  1863. /*FCN*/cal_CEN_func()
  1864. {
  1865.     cal_snap("_CEN");
  1866. } /*cal_CEN_func*/
  1867.  
  1868.  
  1869. /****************************************************************************/
  1870. /*.doc cal_INT_func(internal)*/
  1871. /*+
  1872.     Calculator 'INT' snap function.
  1873. -*/
  1874. /****************************************************************************/
  1875.  
  1876.  
  1877. static void
  1878. /*FCN*/cal_INT_func()
  1879. {
  1880.     cal_snap("_INT");
  1881. } /*cal_INT_func*/
  1882.  
  1883.  
  1884. /****************************************************************************/
  1885. /*.doc cal_NEA_func(internal)*/
  1886. /*+
  1887.     Calculator 'NEA' snap function.
  1888. -*/
  1889. /****************************************************************************/
  1890.  
  1891.  
  1892. static void
  1893. /*FCN*/cal_NEA_func()
  1894. {
  1895.     cal_snap("_NEA");
  1896. } /*cal_NEA_func*/
  1897.  
  1898.  
  1899. /****************************************************************************/
  1900. /*.doc cal_NOD_func(internal)*/
  1901. /*+
  1902.     Calculator 'NOD' snap function.
  1903. -*/
  1904. /****************************************************************************/
  1905.  
  1906.  
  1907. static void
  1908. /*FCN*/cal_NOD_func()
  1909. {
  1910.     cal_snap("_NOD");
  1911. } /*cal_NOD_func*/
  1912.  
  1913.  
  1914. /****************************************************************************/
  1915. /*.doc cal_QUA_func(internal)*/
  1916. /*+
  1917.     Calculator 'QUA' snap function.
  1918. -*/
  1919. /****************************************************************************/
  1920.  
  1921.  
  1922. static void
  1923. /*FCN*/cal_QUA_func()
  1924. {
  1925.     cal_snap("_QUA");
  1926. } /*cal_QUA_func*/
  1927.  
  1928.  
  1929. /****************************************************************************/
  1930. /*.doc cal_PER_func(internal)*/
  1931. /*+
  1932.     Calculator 'PER' snap function.
  1933. -*/
  1934. /****************************************************************************/
  1935.  
  1936.  
  1937. static void
  1938. /*FCN*/cal_PER_func()
  1939. {
  1940.     cal_snap("_PER");
  1941. } /*cal_PER_func*/
  1942.  
  1943.  
  1944. /****************************************************************************/
  1945. /*.doc cal_TAN_func(internal)*/
  1946. /*+
  1947.     Calculator 'TAN' snap function.
  1948. -*/
  1949. /****************************************************************************/
  1950.  
  1951.  
  1952. static void
  1953. /*FCN*/cal_TAN_func()
  1954. {
  1955.     cal_snap("_TAN");
  1956. } /*cal_TAN_func*/
  1957.  
  1958.  
  1959. /****************************************************************************/
  1960. /*.doc cal_INS_func(internal)*/
  1961. /*+
  1962.     Calculator 'INS' snap function.
  1963. -*/
  1964. /****************************************************************************/
  1965.  
  1966.  
  1967. static void
  1968. /*FCN*/cal_INS_func()
  1969. {
  1970.     cal_snap("_INS");
  1971. } /*cal_INS_func*/
  1972.  
  1973.  
  1974. /****************************************************************************/
  1975. /*.doc cal_register_standard_functions(external)*/
  1976. /*+
  1977.   Registers the standard calculator functions in this file. This function
  1978.   is called only once during the phase of loading the calculator.
  1979. -*/
  1980. /****************************************************************************/
  1981.  
  1982.  
  1983. void
  1984. /*FCN*/cal_register_standard_functions()
  1985. {
  1986.     cal_register_function("END",     cal_END_func  );
  1987.     cal_register_function("MID",     cal_MID_func  );
  1988.     cal_register_function("CEN",     cal_CEN_func  );
  1989.     cal_register_function("INT",     cal_INT_func  );
  1990.     cal_register_function("NEA",     cal_NEA_func  );
  1991.     cal_register_function("NOD",     cal_NOD_func  );
  1992.     cal_register_function("QUA",     cal_QUA_func  );
  1993.     cal_register_function("PER",     cal_PER_func  );
  1994.     cal_register_function("TAN",     cal_TAN_func  );
  1995.     cal_register_function("INS",     cal_INS_func  );
  1996.  
  1997.     cal_register_function("ANG",     cal_ANG_func  );
  1998.     cal_register_function("RAD",     cal_RAD_func  );
  1999.     cal_register_function("NOR",     cal_NOR_func  );
  2000.  
  2001.     cal_register_function("SIN",     cal_SIN_func  );
  2002.     cal_register_function("COS",     cal_COS_func  );
  2003.     cal_register_function("TANG",    cal_TANG_func );
  2004.     cal_register_function("ASIN",    cal_ASIN_func );
  2005.     cal_register_function("ACOS",    cal_ACOS_func );
  2006.     cal_register_function("ATAN",    cal_ATAN_func );
  2007.  
  2008.     cal_register_function("ABS",     cal_ABS_func  );
  2009.     cal_register_function("LN",      cal_LN_func   );
  2010.     cal_register_function("LOG",     cal_LOG_func  );
  2011.     cal_register_function("EXP",     cal_EXP_func  );
  2012.     cal_register_function("EXP10",   cal_EXP10_func);
  2013.     cal_register_function("SQR",     cal_SQR_func  );
  2014.     cal_register_function("SQRT",    cal_SQRT_func );
  2015.  
  2016.     cal_register_function("XOF",     cal_Xof_func  );
  2017.     cal_register_function("YOF",     cal_Yof_func  );
  2018.     cal_register_function("ZOF",     cal_Zof_func  );
  2019.     cal_register_function("RXOF",    cal_rXof_func );
  2020.     cal_register_function("RYOF",    cal_rYof_func );
  2021.     cal_register_function("RZOF",    cal_rZof_func );
  2022.     cal_register_function("XYOF",    cal_XYof_func );
  2023.     cal_register_function("YZOF",    cal_YZof_func );
  2024.     cal_register_function("XZOF",    cal_XZof_func );
  2025.  
  2026.     cal_register_function("R2D",     cal_R2D_func  );
  2027.     cal_register_function("D2R",     cal_D2R_func  );
  2028.     cal_register_function("ROUND",   cal_ROUND_func);
  2029.     cal_register_function("TRUNC",   cal_TRUNC_func);
  2030.  
  2031.     cal_register_function("U2W",     cal_U2W_func  );
  2032.     cal_register_function("W2U",     cal_W2U_func  );
  2033.  
  2034.     cal_register_function("ILL",     cal_ILL_func  );
  2035.     cal_register_function("ILP",     cal_ILP_func  );
  2036.     cal_register_function("DPL",     cal_DPL_func  );
  2037.     cal_register_function("DPP",     cal_DPP_func  );
  2038.     cal_register_function("PLT",     cal_PLT_func  );
  2039.     cal_register_function("PLD",     cal_PLD_func  );
  2040.  
  2041.     cal_register_function("MEE",     cal_MEE_func  );
  2042.     cal_register_function("DEE",     cal_DEE_func  );
  2043.     cal_register_function("NEE",     cal_NEE_func  );
  2044.     cal_register_function("VEE",     cal_VEE_func  );
  2045.     cal_register_function("VEE1",    cal_VEE1_func );
  2046.     cal_register_function("PLTEE",   cal_PLTEE_func);
  2047.     cal_register_function("PLDEE",   cal_PLDEE_func);
  2048.     cal_register_function("ILLE",    cal_ILLE_func );
  2049.  
  2050.     cal_register_function("DIST",    cal_DIST_func );
  2051.     cal_register_function("VEC",     cal_VEC_func  );
  2052.     cal_register_function("VEC1",    cal_VEC1_func );
  2053.     cal_register_function("ROT",     cal_ROT_func  );
  2054.     cal_register_function("CUR",     cal_CUR_func  );
  2055.  
  2056. } /*cal_register_standard_functions*/
  2057.  
  2058.  
  2059.