home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / octave-1.1.1p1-src.tgz / tar.out / fsf / octave / liboctave / mx-inlines.cc < prev    next >
C/C++ Source or Header  |  1996-09-28  |  15KB  |  835 lines
  1. // Helper functions for matrix classes.                 -*- C++ -*-
  2. /*
  3.  
  4. Copyright (C) 1992, 1993, 1994, 1995 John W. Eaton
  5.  
  6. This file is part of Octave.
  7.  
  8. Octave is free software; you can redistribute it and/or modify it
  9. under the terms of the GNU General Public License as published by the
  10. Free Software Foundation; either version 2, or (at your option) any
  11. later version.
  12.  
  13. Octave is distributed in the hope that it will be useful, but WITHOUT
  14. ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15. FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16. for more details.
  17.  
  18. You should have received a copy of the GNU General Public License
  19. along with Octave; see the file COPYING.  If not, write to the Free
  20. Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  
  22. */
  23.  
  24. #include <Complex.h>
  25.  
  26. // But first, some helper functions...
  27.  
  28. static inline double *
  29. add (const double *d, int len, double s)
  30. {
  31.   double *result = 0;
  32.   if (len > 0)
  33.     {
  34.       result = new double [len];
  35.       for (int i = 0; i < len; i++)
  36.     result[i] = d[i] + s;
  37.     }
  38.   return result;
  39. }
  40.  
  41. static inline double *
  42. subtract (const double *d, int len, double s)
  43. {
  44.   double *result = 0;
  45.   if (len > 0)
  46.     {
  47.       result = new double [len];
  48.       for (int i = 0; i < len; i++)
  49.     result[i] = d[i] - s;
  50.     }
  51.   return result;
  52. }
  53.  
  54. static inline double *
  55. subtract (double s, const double *d, int len)
  56. {
  57.   double *result = 0;
  58.   if (len > 0)
  59.     {
  60.       result = new double [len];
  61.       for (int i = 0; i < len; i++)
  62.     result[i] = s - d[i];
  63.     }
  64.   return result;
  65. }
  66.  
  67. static inline double *
  68. multiply (const double *d, int len, double s)
  69. {
  70.   double *result = 0;
  71.   if (len > 0)
  72.     {
  73.       result = new double [len];
  74.       for (int i = 0; i < len; i++)
  75.     result[i] = d[i] * s;
  76.     }
  77.   return result;
  78. }
  79.  
  80. static inline double *
  81. divide (const double *d, int len, double s)
  82. {
  83.   double *result = 0;
  84.   if (len > 0)
  85.     {
  86.       result = new double [len];
  87.       for (int i = 0; i < len; i++)
  88.     result[i] = d[i] / s;
  89.     }
  90.   return result;
  91. }
  92.  
  93. static inline double *
  94. divide (double s, const double *d, int len)
  95. {
  96.   double *result = 0;
  97.   if (len > 0)
  98.     {
  99.       result = new double [len];
  100.       for (int i = 0; i < len; i++)
  101.     result[i] = s / d[i];
  102.     }
  103.   return result;
  104. }
  105.  
  106. static inline double *
  107. add (const double *x, const double *y, int len)
  108. {
  109.   double *result = 0;
  110.   if (len > 0)
  111.     {
  112.       result = new double [len];
  113.       for (int i = 0; i < len; i++)
  114.     result[i] = x[i] + y[i];
  115.     }
  116.   return result;
  117. }
  118.  
  119. static inline double *
  120. subtract (const double *x, const double *y, int len)
  121. {
  122.   double *result = 0;
  123.   if (len > 0)
  124.     {
  125.       result = new double [len];
  126.       for (int i = 0; i < len; i++)
  127.     result[i] = x[i] - y[i];
  128.     }
  129.   return result;
  130. }
  131.  
  132. static inline double *
  133. multiply (const double *x, const double *y, int len)
  134. {
  135.   double *result = 0;
  136.   if (len > 0)
  137.     {
  138.       result = new double [len];
  139.       for (int i = 0; i < len; i++)
  140.     result[i] = x[i] * y[i];
  141.     }
  142.   return result;
  143. }
  144.  
  145. static inline double *
  146. divide (const double *x, const double *y, int len)
  147. {
  148.   double *result = 0;
  149.   if (len > 0)
  150.     {
  151.       result = new double [len];
  152.       for (int i = 0; i < len; i++)
  153.     result[i] = x[i] / y[i];
  154.     }
  155.   return result;
  156. }
  157.  
  158. static inline double *
  159. add2 (double *x, const double *y, int len)
  160. {
  161.   for (int i = 0; i < len; i++)
  162.     x[i] += y[i];
  163.   return x;
  164. }
  165.  
  166. static inline double *
  167. subtract2 (double *x, const double *y, int len)
  168. {
  169.   for (int i = 0; i < len; i++)
  170.     x[i] -= y[i];
  171.   return x;
  172. }
  173.  
  174. static inline double *
  175. negate (const double *d, int len)
  176. {
  177.   double *result = 0;
  178.   if (len > 0)
  179.     {
  180.       result = new double [len];
  181.       for (int i = 0; i < len; i++)
  182.     result[i] = -d[i];
  183.     }
  184.   return result;
  185. }
  186.  
  187. static inline void
  188. copy (double *d, int len, double s)
  189. {
  190.   for (int i = 0; i < len; i++)
  191.     d[i] = s;
  192. }
  193.  
  194. static inline void
  195. copy (double *x, const double *y, int len)
  196. {
  197.   for (int i = 0; i < len; i++)
  198.     x[i] = y[i];
  199. }
  200.  
  201. static inline double *
  202. dup (const double *x, int len)
  203. {
  204.   double *retval = 0;
  205.   if (len > 0)
  206.     {
  207.       retval = new double [len];
  208.       for (int i = 0; i < len; i++)
  209.     retval[i] = x[i];
  210.     }
  211.   return retval;
  212. }
  213.  
  214. static inline int
  215. equal (const double *x, const double *y, int len)
  216. {
  217.   for (int i = 0; i < len; i++)
  218.     if (x[i] != y[i])
  219.       return 0;
  220.   return 1;
  221. }
  222.  
  223. // And some for Complex too...
  224.  
  225. static inline Complex *
  226. add (const Complex *d, int len, Complex s)
  227. {
  228.   Complex *result = 0;
  229.   if (len > 0)
  230.     {
  231.       result = new Complex [len];
  232.       for (int i = 0; i < len; i++)
  233.     result[i] = d[i] + s;
  234.     }
  235.   return result;
  236. }
  237.  
  238. static inline Complex *
  239. add (Complex s, const Complex *d, int len)
  240. {
  241.   Complex *result = 0;
  242.   if (len > 0)
  243.     {
  244.       result = new Complex [len];
  245.       for (int i = 0; i < len; i++)
  246.     result[i] = s + d[i];
  247.     }
  248.   return result;
  249. }
  250.  
  251. static inline Complex *
  252. subtract (const Complex *d, int len, Complex s)
  253. {
  254.   Complex *result = 0;
  255.   if (len > 0)
  256.     {
  257.       result = new Complex [len];
  258.       for (int i = 0; i < len; i++)
  259.     result[i] = d[i] - s;
  260.     }
  261.   return result;
  262. }
  263.  
  264. static inline Complex *
  265. subtract (Complex s, const Complex *d, int len)
  266. {
  267.   Complex *result = 0;
  268.   if (len > 0)
  269.     {
  270.       result = new Complex [len];
  271.       for (int i = 0; i < len; i++)
  272.     result[i] = s - d[i];
  273.     }
  274.   return result;
  275. }
  276.  
  277. static inline Complex *
  278. multiply (const Complex *d, int len, Complex s)
  279. {
  280.   Complex *result = 0;
  281.   if (len > 0)
  282.     {
  283.       result = new Complex [len];
  284.       for (int i = 0; i < len; i++)
  285.     result[i] = d[i] * s;
  286.     }
  287.   return result;
  288. }
  289.  
  290. static inline Complex *
  291. multiply (Complex s, const Complex *d, int len)
  292. {
  293.   Complex *result = 0;
  294.   if (len > 0)
  295.     {
  296.       result = new Complex [len];
  297.       for (int i = 0; i < len; i++)
  298.     result[i] = s * d[i];
  299.     }
  300.   return result;
  301. }
  302.  
  303. static inline Complex *
  304. divide (const Complex *d, int len, Complex s)
  305. {
  306.   Complex *result = 0;
  307.   if (len > 0)
  308.     {
  309.       result = new Complex [len];
  310.       for (int i = 0; i < len; i++)
  311.     result[i] = d[i] / s;
  312.     }
  313.   return result;
  314. }
  315.  
  316. static inline Complex *
  317. divide (Complex s, const Complex *d, int len)
  318. {
  319.   Complex *result = 0;
  320.   if (len > 0)
  321.     {
  322.       result = new Complex [len];
  323.       for (int i = 0; i < len; i++)
  324.     result[i] = s / d[i];
  325.     }
  326.   return result;
  327. }
  328.  
  329. static inline Complex *
  330. add (const Complex *x, const Complex *y, int len)
  331. {
  332.   Complex *result = 0;
  333.   if (len > 0)
  334.     {
  335.       result = new Complex [len];
  336.       for (int i = 0; i < len; i++)
  337.     result[i] = x[i] + y[i];
  338.     }
  339.   return result;
  340. }
  341.  
  342. static inline Complex *
  343. subtract (const Complex *x, const Complex *y, int len)
  344. {
  345.   Complex *result = 0;
  346.   if (len > 0)
  347.     {
  348.       result = new Complex [len];
  349.       for (int i = 0; i < len; i++)
  350.     result[i] = x[i] - y[i];
  351.     }
  352.   return result;
  353. }
  354.  
  355. static inline Complex *
  356. multiply (const Complex *x, const Complex *y, int len)
  357. {
  358.   Complex *result = 0;
  359.   if (len > 0)
  360.     {
  361.       result = new Complex [len];
  362.       for (int i = 0; i < len; i++)
  363.     result[i] = x[i] * y[i];
  364.     }
  365.   return result;
  366. }
  367.  
  368. static inline Complex *
  369. divide (const Complex *x, const Complex *y, int len)
  370. {
  371.   Complex *result = 0;
  372.   if (len > 0)
  373.     {
  374.       result = new Complex [len];
  375.       for (int i = 0; i < len; i++)
  376.     result[i] = x[i] / y[i];
  377.     }
  378.   return result;
  379. }
  380.  
  381. static inline Complex *
  382. add2 (Complex *x, const Complex *y, int len)
  383. {
  384.   for (int i = 0; i < len; i++)
  385.     x[i] += y[i];
  386.   return x;
  387. }
  388.  
  389. static inline Complex *
  390. subtract2 (Complex *x, const Complex *y, int len)
  391. {
  392.   for (int i = 0; i < len; i++)
  393.     x[i] -= y[i];
  394.   return x;
  395. }
  396.  
  397. static inline Complex *
  398. negate (const Complex *d, int len)
  399. {
  400.   Complex *result = 0;
  401.   if (len > 0)
  402.     {
  403.       result = new Complex [len];
  404.       for (int i = 0; i < len; i++)
  405.     result[i] = -d[i];
  406.     }
  407.   return result;
  408. }
  409.  
  410. static inline double *
  411. not (const Complex *d, int len)
  412. {
  413.   double *result = 0;
  414.   if (len > 0)
  415.     {
  416.       result = new double [len];
  417.       for (int i = 0; i < len; i++)
  418.     result[i] = (d[i] == 0.0);
  419.     }
  420.   return result;
  421. }
  422.  
  423. static inline void
  424. copy (Complex *d, int len, Complex s)
  425. {
  426.   for (int i = 0; i < len; i++)
  427.     d[i] = s;
  428. }
  429.  
  430. static inline void
  431. copy (Complex *x, const Complex *y, int len)
  432. {
  433.   for (int i = 0; i < len; i++)
  434.     x[i] = y[i];
  435. }
  436.  
  437. static inline Complex *
  438. dup (const Complex *x, int len)
  439. {
  440.   Complex *retval = 0;
  441.   if (len > 0)
  442.     {
  443.       retval = new Complex [len];
  444.       for (int i = 0; i < len; i++)
  445.     retval[i] = x[i];
  446.     }
  447.   return retval;
  448. }
  449.  
  450. static inline Complex *
  451. make_complex (const double *x, int len)
  452. {
  453.   Complex *retval = 0;
  454.   if (len > 0)
  455.     {
  456.       retval = new Complex [len];
  457.       for (int i = 0; i < len; i++)
  458.     retval[i] = x[i];
  459.     }
  460.   return retval;
  461. }
  462.  
  463. static inline Complex *
  464. conj_dup (const Complex *x, int len)
  465. {
  466.   Complex *retval = 0;
  467.   if (len > 0)
  468.     {
  469.       retval = new Complex [len];
  470.       for (int i = 0; i < len; i++)
  471.     retval[i] = conj (x[i]);
  472.     }
  473.   return retval;
  474. }
  475.  
  476. static inline double *
  477. real_dup (const Complex *x, int len)
  478. {
  479.   double *retval = 0;
  480.   if (len > 0)
  481.     {
  482.       retval = new double [len];
  483.       for (int i = 0; i < len; i++)
  484.     retval[i] = real (x[i]);
  485.     }
  486.   return retval;
  487. }
  488.  
  489. static inline double *
  490. imag_dup (const Complex *x, int len)
  491. {
  492.   double *retval = 0;
  493.   if (len > 0)
  494.     {
  495.       retval = new double [len];
  496.       for (int i = 0; i < len; i++)
  497.     retval[i] = imag (x[i]);
  498.     }
  499.   return retval;
  500. }
  501.  
  502. static inline int
  503. equal (const Complex *x, const Complex *y, int len)
  504. {
  505.   for (int i = 0; i < len; i++)
  506.     if (x[i] != y[i])
  507.       return 0;
  508.   return 1;
  509. }
  510.  
  511. // And still some more for mixed Complex/double operations...
  512.  
  513. static inline Complex *
  514. add (const Complex *d, int len, double s)
  515. {
  516.   Complex *result = 0;
  517.   if (len > 0)
  518.     {
  519.       result = new Complex [len];
  520.       for (int i = 0; i < len; i++)
  521.     result[i] = d[i] + s;
  522.     }
  523.   return result;
  524. }
  525.  
  526. static inline Complex *
  527. add (const double *d, int len, Complex s)
  528. {
  529.   Complex *result = 0;
  530.   if (len > 0)
  531.     {
  532.       result = new Complex [len];
  533.       for (int i = 0; i < len; i++)
  534.     result[i] = d[i] + s;
  535.     }
  536.   return result;
  537. }
  538.  
  539. static inline Complex *
  540. add (double s, const Complex *d, int len)
  541. {
  542.   Complex *result = 0;
  543.   if (len > 0)
  544.     {
  545.       result = new Complex [len];
  546.       for (int i = 0; i < len; i++)
  547.     result[i] = s + d[i];
  548.     }
  549.   return result;
  550. }
  551.  
  552. static inline Complex *
  553. add (Complex s, const double *d, int len)
  554. {
  555.   Complex *result = 0;
  556.   if (len > 0)
  557.     {
  558.       result = new Complex [len];
  559.       for (int i = 0; i < len; i++)
  560.     result[i] = s + d[i];
  561.     }
  562.   return result;
  563. }
  564.  
  565. static inline Complex *
  566. subtract (const Complex *d, int len, double s)
  567. {
  568.   Complex *result = 0;
  569.   if (len > 0)
  570.     {
  571.       result = new Complex [len];
  572.       for (int i = 0; i < len; i++)
  573.     result[i] = d[i] - s;
  574.     }
  575.   return result;
  576. }
  577.  
  578. static inline Complex *
  579. subtract (const double *d, int len, Complex s)
  580. {
  581.   Complex *result = 0;
  582.   if (len > 0)
  583.     {
  584.       result = new Complex [len];
  585.       for (int i = 0; i < len; i++)
  586.     result[i] = d[i] - s;
  587.     }
  588.   return result;
  589. }
  590.  
  591. static inline Complex *
  592. subtract (double s, const Complex *d, int len)
  593. {
  594.   Complex *result = 0;
  595.   if (len > 0)
  596.     {
  597.       result = new Complex [len];
  598.       for (int i = 0; i < len; i++)
  599.     result[i] = s - d[i];
  600.     }
  601.   return result;
  602. }
  603.  
  604. static inline Complex *
  605. subtract (Complex s, const double *d, int len)
  606. {
  607.   Complex *result = 0;
  608.   if (len > 0)
  609.     {
  610.       result = new Complex [len];
  611.       for (int i = 0; i < len; i++)
  612.     result[i] = s - d[i];
  613.     }
  614.   return result;
  615. }
  616.  
  617. static inline Complex *
  618. multiply (const Complex *d, int len, double s)
  619. {
  620.   Complex *result = 0;
  621.   if (len > 0)
  622.     {
  623.       result = new Complex [len];
  624.       for (int i = 0; i < len; i++)
  625.     result[i] = d[i] * s;
  626.     }
  627.   return result;
  628. }
  629.  
  630. static inline Complex *
  631. multiply (const double *d, int len, Complex s)
  632. {
  633.   Complex *result = 0;
  634.   if (len > 0)
  635.     {
  636.       result = new Complex [len];
  637.       for (int i = 0; i < len; i++)
  638.     result[i] = d[i] * s;
  639.     }
  640.   return result;
  641. }
  642.  
  643. static inline Complex *
  644. divide (const Complex *d, int len, double s)
  645. {
  646.   Complex *result = 0;
  647.   if (len > 0)
  648.     {
  649.       result = new Complex [len];
  650.       for (int i = 0; i < len; i++)
  651.     result[i] = d[i] / s;
  652.     }
  653.   return result;
  654. }
  655.  
  656. static inline Complex *
  657. divide (const double *d, int len, Complex s)
  658. {
  659.   Complex *result = 0;
  660.   if (len > 0)
  661.     {
  662.       result = new Complex [len];
  663.       for (int i = 0; i < len; i++)
  664.     result[i] = d[i] / s;
  665.     }
  666.   return result;
  667. }
  668.  
  669. static inline Complex *
  670. divide (double s, const Complex *d, int len)
  671. {
  672.   Complex *result = 0;
  673.   if (len > 0)
  674.     {
  675.       result = new Complex [len];
  676.       for (int i = 0; i < len; i++)
  677.     result[i] = s / d[i];
  678.     }
  679.   return result;
  680. }
  681.  
  682. static inline Complex *
  683. divide (Complex s, const double *d, int len)
  684. {
  685.   Complex *result = 0;
  686.   if (len > 0)
  687.     {
  688.       result = new Complex [len];
  689.       for (int i = 0; i < len; i++)
  690.     result[i] = s / d[i];
  691.     }
  692.   return result;
  693. }
  694.  
  695. static inline Complex *
  696. add (const Complex *x, const double *y, int len)
  697. {
  698.   Complex *result = 0;
  699.   if (len > 0)
  700.     {
  701.       result = new Complex [len];
  702.       for (int i = 0; i < len; i++)
  703.     result[i] = x[i] + y[i];
  704.     }
  705.   return result;
  706. }
  707.  
  708. static inline Complex *
  709. add (const double *x, const Complex *y, int len)
  710. {
  711.   Complex *result = 0;
  712.   if (len > 0)
  713.     {
  714.       result = new Complex [len];
  715.       for (int i = 0; i < len; i++)
  716.     result[i] = x[i] + y[i];
  717.     }
  718.   return result;
  719. }
  720.  
  721. static inline Complex *
  722. subtract (const Complex *x, const double *y, int len)
  723. {
  724.   Complex *result = 0;
  725.   if (len > 0)
  726.     {
  727.       result = new Complex [len];
  728.       for (int i = 0; i < len; i++)
  729.     result[i] = x[i] - y[i];
  730.     }
  731.   return result;
  732. }
  733.  
  734. static inline Complex *
  735. subtract (const double *x, const Complex *y, int len)
  736. {
  737.   Complex *result = 0;
  738.   if (len > 0)
  739.     {
  740.       result = new Complex [len];
  741.       for (int i = 0; i < len; i++)
  742.     result[i] = x[i] - y[i];
  743.     }
  744.   return result;
  745. }
  746.  
  747. static inline Complex *
  748. multiply (const Complex *x, const double *y, int len)
  749. {
  750.   Complex *result = 0;
  751.   if (len > 0)
  752.     {
  753.       result = new Complex [len];
  754.       for (int i = 0; i < len; i++)
  755.     result[i] = x[i] * y[i];
  756.     }
  757.   return result;
  758. }
  759.  
  760. static inline Complex *
  761. multiply (const double *x, const Complex *y, int len)
  762. {
  763.   Complex *result = 0;
  764.   if (len > 0)
  765.     {
  766.       result = new Complex [len];
  767.       for (int i = 0; i < len; i++)
  768.     result[i] = x[i] * y[i];
  769.     }
  770.   return result;
  771. }
  772.  
  773. static inline Complex *
  774. divide (const Complex *x, const double *y, int len)
  775. {
  776.   Complex *result = 0;
  777.   if (len > 0)
  778.     {
  779.       result = new Complex [len];
  780.       for (int i = 0; i < len; i++)
  781.     result[i] = x[i] / y[i];
  782.     }
  783.   return result;
  784. }
  785.  
  786. static inline Complex *
  787. divide (const double *x, const Complex *y, int len)
  788. {
  789.   Complex *result = 0;
  790.   if (len > 0)
  791.     {
  792.       result = new Complex [len];
  793.       for (int i = 0; i < len; i++)
  794.     result[i] = x[i] / y[i];
  795.     }
  796.   return result;
  797. }
  798.  
  799. static inline Complex *
  800. add2 (Complex *x, const double *y, int len)
  801. {
  802.   for (int i = 0; i < len; i++)
  803.     x[i] += y[i];
  804.   return x;
  805. }
  806.  
  807. static inline Complex *
  808. subtract2 (Complex *x, const double *y, int len)
  809. {
  810.   for (int i = 0; i < len; i++)
  811.     x[i] -= y[i];
  812.   return x;
  813. }
  814.  
  815. static inline void
  816. copy (Complex *d, int len, double s)
  817. {
  818.   for (int i = 0; i < len; i++)
  819.     d[i] = s;
  820. }
  821.  
  822. static inline void
  823. copy (Complex *x, const double *y, int len)
  824. {
  825.   for (int i = 0; i < len; i++)
  826.     x[i] = y[i];
  827. }
  828.  
  829. /*
  830. ;;; Local Variables: ***
  831. ;;; mode: C++ ***
  832. ;;; page-delimiter: "^/\\*" ***
  833. ;;; End: ***
  834. */
  835.