home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic Source Code / Visual Basic Source Code.iso / vbsource / optivc32 / mcestd.h < prev    next >
Encoding:
C/C++ Source or Header  |  1999-03-06  |  35.9 KB  |  714 lines
  1. /*  MCEstd.h
  2.  
  3.   matrix management functions:
  4.   manipulations on matrices of data type "eComplex"
  5.   (extended-precision complex numbers)
  6.  
  7.   Copyright (c) 1996-1999 by Martin Sander
  8.   All Rights Reserved.
  9. */
  10.  
  11. #if !defined( __MATLIB_H )
  12.    #include <MatLib.h>
  13. #endif
  14. #if !defined( __VCESTD_H )
  15.    #include <VCEstd.h>
  16. #endif
  17.  
  18. #ifdef __BORLANDC__
  19.        /* the following ca. 550 lines are only for Borland C++,
  20.           as neither Visual C++ nor Optima++ support 80-bit reals */
  21. #ifdef __cplusplus
  22. extern "C" {
  23. #endif
  24.  
  25. /*************   Dynamic Generation of Matrices   ************************/
  26.  
  27. ceMatrix __vf  MCE_matrix(  unsigned ht, unsigned len );
  28. ceMatrix __vf  MCE_matrix0( unsigned ht, unsigned len );
  29.     /*  Notice that, in the memory model HUGE,
  30.         neither len nor ht may exceed 1637            */
  31.  
  32. /***************************************************************************
  33.  *  The following definitions ensure compatibility between dynamically     *
  34.  *  and statically allocated matrices. The definitions are somewhat        *
  35.  *  cumbersome, but the result for you is that you need not care about     *
  36.  *  the differences between the two types.                                 *
  37.  *  (Internally, the address of the first element of any matrix is needed; *
  38.  *  the expression "MA[0]" is evaluated in a different way for both types, *
  39.  *  but yields in either case the correct address to be passed to the      *
  40.  *  function you wish to call.)                                            *
  41.  *  Only in the rare case that you need to pass the address of one of      *
  42.  *  these functions as an argument to another function, you have to use    *
  43.  *  the actual run-time functions defined further below. Be careful with   *
  44.  *  this: future development of compilers may allow us to avoid this un-   *
  45.  *  handy scheme of macros. So future versions of MatrixLib may no longer  *
  46.  *  use these run-time names.                                              *
  47.  ***************************************************************************/
  48.  
  49.  
  50. /***  Addressing single elements of dynamically allocated matrices: ******
  51.      These two functions are for compatibility with Pascal
  52.      (where elements of dynamically allocated matrices are not directly
  53.      accessible), and for getting around the pointer arithmetics bug in
  54.      some versions of Borland C++.                                     */
  55.  
  56. #define MCE_Pelement( MA, ht, len, m, n ) MCEPelement( MA[0], ht, len, m, n )
  57.                      /* returns a pointer to MA[m][n]. */
  58. #define MCE_element( MA, ht, len, m, n ) *MCEPelement( MA[0], ht, len, m, n )
  59.                      /* dereferenced pointer */
  60.  
  61.  /****************  Initialization  ***************************************
  62.  
  63.     To initialize all elements of a matrix with the same value,
  64.     or to perform arithmetic operations on all elements simultaneously,
  65.     refer to the functions of VectorLib, declared in <VCEstd.h>, <VCEmath.h>.
  66.     In order to use the VectorLib functions, utilize the feature that
  67.     the whole matrix occupies one contiguous area in memory: pass the
  68.     address of the first row to the desired vector function, the size
  69.     of the "vector" being len * ht.
  70.     For example, initialize all elements of the matrix MA with {1.0, 0.0}
  71.     (this is *NOT* the identity matrix)  by calling
  72.         VCE_equ1( MA[0], len * ht );
  73. */
  74.  
  75. #define MCE_equ1( MA, len )                MCEequ1( MA[0], len )
  76.                        /* this is the identity matrix */
  77. #define MCE_outerprod( MA, X, Y, ht, len ) MCEouterprod( MA[0], X, Y, ht, len )
  78.                        /* sizX=ht, sizY=len */
  79. #define MCE_Row_equC( MA, ht, len, iRow, C ) \
  80.                                         MCERow_equC( MA[0], ht, len, iRow, C )
  81. #define MCE_Col_equC( MA, ht, len, iCol, C ) \
  82.                                         MCECol_equC( MA[0], ht, len, iCol, C )
  83. #define MCE_Dia_equC( MA, len, C )      MCEDia_equC( MA[0], len, C )
  84.  
  85. #define MCE_Row_equV( MA, ht, len, iRow, X ) \
  86.                                         MCERow_equV( MA[0], ht, len, iRow, X )
  87. #define MCE_Col_equV( MA, ht, len, iCol, X ) \
  88.                                         MCECol_equV( MA[0], ht, len, iCol, X )
  89. #define MCE_Dia_equV( MA, len, X )      MCEDia_equV( MA[0], len, X )
  90.  
  91. #define MCE_equM( MB, MA, ht, len )  VCE_equV( MB[0], MA[0], ((ui)(len))*(ht) )
  92.  
  93. #define MCE_UequL( MA, len ) MCEUequL( MA[0], len )
  94. #define MCE_LequU( MA, len ) MCELequU( MA[0], len )
  95.          /* copy lower-diagonal elements into upper-diagonal
  96.            (or vice versa) by index-reflection, so as to
  97.            get a symmetric matrix    */
  98.  
  99.             /* data-type conversions:  */
  100. #define M_CEtoCF( MCF, MCE, ht, len ) V_CEtoCF( MCF[0], MCE[0], ((ui)ht)*len )
  101. #define M_CFtoCE( MCE, MCF, ht, len ) V_CFtoCE( MCE[0], MCF[0], ((ui)ht)*len )
  102. #define M_CEtoCD( MCD, MCE, ht, len ) V_CEtoCD( MCD[0], MCE[0], ((ui)ht)*len )
  103. #define M_CDtoCE( MCE, MCD, ht, len ) V_CDtoCE( MCE[0], MCD[0], ((ui)ht)*len )
  104.  
  105. /********  Extracting a submatrix and copying a submatrix back  *********/
  106.  
  107. #define MCE_submatrix( MSub, subHt, subLen, \
  108.                        MSrce, srceHt, srceLen, \
  109.                        firstRowInCol, sampInCol, firstColInRow, sampInRow ) \
  110.                MCEsubmatrix(  MSub[0], subHt, subLen, \
  111.                               MSrce[0], srceHt, srceLen, \
  112.                               firstRowInCol, sampInCol, firstColInRow, sampInRow )
  113.  
  114. #define MCE_submatrix_equM( MDest, destHt, destLen, \
  115.                             firstRowInCol, sampInCol, firstColInRow, sampInRow, \
  116.                             MSrce, srceHt, srceLen ) \
  117.                MCEsubmatrix_equM(  MDest[0], destHt, destLen, \
  118.                              firstRowInCol, sampInCol, firstColInRow, sampInRow, \
  119.                              MSrce[0], srceHt, srceLen )
  120.  
  121. /*****   Extracting a single row or a single column or the diagonal  ******
  122.  *       and storing it into a vector                                     */
  123.  
  124. #define MCE_Row_extract( Y, MA, ht, len, iRow ) \
  125.                                      MCERow_extract( Y, MA[0], ht, len, iRow )
  126. #define MCE_Col_extract( Y, MA, ht, len, iCol ) \
  127.                                      MCECol_extract( Y, MA[0], ht, len, iCol )
  128. #define MCE_Dia_extract( Y, MA, len ) MCEDia_extract( Y, MA[0], len )
  129.  
  130.  
  131. /*****************    Basic arithmetic operations *********************
  132.                       performed on one single row,
  133.                       or one single column of any matrix,
  134.                       or on the diagonal of a square matrix
  135.  
  136.     Note: In contrast to the analogous VectorLib functions, the operations
  137.     are performed in-place, i.e. the input matrix itself is changed  */
  138.  
  139. #define MCE_Row_addC( MA, ht, len, iRow, C ) \
  140.                                      MCERow_addC( MA[0], ht, len, iRow, C )
  141. #define MCE_Col_addC( MA, ht, len, iCol, C ) \
  142.                                      MCECol_addC( MA[0], ht, len, iCol, C )
  143. #define MCE_Dia_addC( MA, len, C )   MCEDia_addC( MA[0], len, C )
  144.  
  145. #define MCE_Row_addV( MA, ht, len, iRow, X ) \
  146.                                      MCERow_addV( MA[0], ht, len, iRow, X )
  147. #define MCE_Col_addV( MA, ht, len, iCol, X ) \
  148.                                      MCECol_addV( MA[0], ht, len, iCol, X )
  149. #define MCE_Dia_addV( MA, len, X )   MCEDia_addV( MA[0], len, X )
  150.  
  151. #define MCE_Row_subC( MA, ht, len, iRow, C ) \
  152.                                      MCERow_addC( MA[0], ht, len, iRow, (-C) )
  153. #define MCE_Col_subC( MA, ht, len, iCol, C ) \
  154.                                      MCECol_addC( MA[0], ht, len, iCol, (-C) )
  155. #define MCE_Dia_subC( MA, len, C )   MCEDia_addC( MA[0], len, (-C) )
  156.  
  157. #define MCE_Row_subV( MA, ht, len, iRow, X ) \
  158.                                      MCERow_subV( MA[0], ht, len, iRow, X )
  159. #define MCE_Col_subV( MA, ht, len, iCol, X ) \
  160.                                      MCECol_subV( MA[0], ht, len, iCol, X )
  161. #define MCE_Dia_subV( MA, len, X )   MCEDia_subV( MA[0], len, X )
  162.  
  163. #define MCE_Row_subrC( MA, ht, len, iRow, C ) \
  164.                                      MCERow_subrC( MA[0], ht, len, iRow, C )
  165. #define MCE_Col_subrC( MA, ht, len, iCol, C ) \
  166.                                      MCECol_subrC( MA[0], ht, len, iCol, C )
  167. #define MCE_Dia_subrC( MA, len, C )  MCEDia_subrC( MA[0], len, C )
  168.  
  169. #define MCE_Row_subrV( MA, ht, len, iRow, X ) \
  170.                                      MCERow_subrV( MA[0], ht, len, iRow, X )
  171. #define MCE_Col_subrV( MA, ht, len, iCol, X ) \
  172.                                      MCECol_subrV( MA[0], ht, len, iCol, X )
  173. #define MCE_Dia_subrV( MA, len, X )  MCEDia_subrV( MA[0], len, X )
  174.  
  175. #define MCE_Row_mulC( MA, ht, len, iRow, C ) \
  176.                                      MCERow_mulC( MA[0], ht, len, iRow, C )
  177. #define MCE_Col_mulC( MA, ht, len, iCol, C ) \
  178.                                      MCECol_mulC( MA[0], ht, len, iCol, C )
  179. #define MCE_Dia_mulC( MA, len, C )   MCEDia_mulC( MA[0], len, C )
  180.  
  181. #define MCE_Row_mulV( MA, ht, len, iRow, X ) \
  182.                                      MCERow_mulV( MA[0], ht, len, iRow, X )
  183. #define MCE_Col_mulV( MA, ht, len, iCol, X ) \
  184.                                      MCECol_mulV( MA[0], ht, len, iCol, X )
  185. #define MCE_Dia_mulV( MA, len, X )   MCEDia_mulV( MA[0], len, X )
  186.  
  187. #define MCE_Row_divC( MA, ht, len, iRow, C ) \
  188.                                      MCERow_divC( MA[0], ht, len, iRow, C )
  189. #define MCE_Col_divC( MA, ht, len, iCol, C ) \
  190.                                      MCECol_divC( MA[0], ht, len, iCol, C )
  191. #define MCE_Dia_divC( MA, len, C )   MCEDia_divC( MA[0], len, C )
  192.  
  193. #define MCE_Row_divV( MA, ht, len, iRow, X ) \
  194.                                       MCERow_divV( MA[0], ht, len, iRow, X )
  195. #define MCE_Col_divV( MA, ht, len, iCol, X ) \
  196.                                       MCECol_divV( MA[0], ht, len, iCol, X )
  197. #define MCE_Dia_divV( MA, len, X )    MCEDia_divV( MA[0], len, X )
  198.  
  199. #define MCE_Row_divrC( MA, ht, len, iRow, C ) \
  200.                                       MCERow_divrC( MA[0], ht, len, iRow, C )
  201. #define MCE_Col_divrC( MA, ht, len, iCol, C ) \
  202.                                       MCECol_divrC( MA[0], ht, len, iCol, C )
  203. #define MCE_Dia_divrC( MA, len, C )   MCEDia_divrC( MA[0], len, C )
  204.  
  205. #define MCE_Row_divrV( MA, ht, len, iRow, X ) \
  206.                                       MCERow_divrV( MA[0], ht, len, iRow, X )
  207. #define MCE_Col_divrV( MA, ht, len, iCol, X ) \
  208.                                       MCECol_divrV( MA[0], ht, len, iCol, X )
  209. #define MCE_Dia_divrV( MA, len, X )   MCEDia_divrV( MA[0], len, X )
  210.  
  211.  
  212. /******  One-dimensional vector operations **********************
  213.          performed along all rows or all columns simultaneously,
  214.          or along the diagonal of a square matrix                */
  215.  
  216. #define MCE_Rows_absmax( Y, MA, ht, len )  MCERows_absmax( Y, MA[0], ht, len )
  217. #define MCE_Cols_absmax( Y, MA, ht, len )  MCECols_absmax( Y, MA[0], ht, len )
  218. #define MCE_Dia_absmax( MA, len )          MCEDia_absmax( MA[0], len )
  219. #define MCE_Rows_absmin( Y, MA, ht, len )  MCERows_absmin( Y, MA[0], ht, len )
  220. #define MCE_Cols_absmin( Y, MA, ht, len )  MCECols_absmin( Y, MA[0], ht, len )
  221. #define MCE_Dia_absmin( MA, len )          MCEDia_absmin( MA[0], len )
  222.  
  223. #define MCE_Rows_maxReIm( Y, MA, ht, len ) MCERows_maxReIm( Y, MA[0], ht, len )
  224. #define MCE_Cols_maxReIm( Y, MA, ht, len ) MCECols_maxReIm( Y, MA[0], ht, len )
  225. #define MCE_Dia_maxReIm( MA, len )         MCEDia_maxReIm( MA[0], len )
  226. #define MCE_Rows_minReIm( Y, MA, ht, len ) MCERows_minReIm( Y, MA[0], ht, len )
  227. #define MCE_Cols_minReIm( Y, MA, ht, len ) MCECols_minReIm( Y, MA[0], ht, len )
  228. #define MCE_Dia_minReIm( MA, len )         MCEDia_minReIm( MA[0], len )
  229.  
  230. #define MCE_Rows_absmaxReIm( Y, MA, ht, len ) MCERows_absmaxReIm( Y, MA[0], ht, len )
  231. #define MCE_Cols_absmaxReIm( Y, MA, ht, len ) MCECols_absmaxReIm( Y, MA[0], ht, len )
  232. #define MCE_Dia_absmaxReIm( MA, len )         MCEDia_absmaxReIm( MA[0], len )
  233. #define MCE_Rows_absminReIm( Y, MA, ht, len ) MCERows_absminReIm( Y, MA[0], ht, len )
  234. #define MCE_Cols_absminReIm( Y, MA, ht, len ) MCECols_absminReIm( Y, MA[0], ht, len )
  235. #define MCE_Dia_absminReIm( MA, len )         MCEDia_absminReIm( MA[0], len )
  236.  
  237. #define MCE_Rows_sum( Y, MA, ht, len )     MCERows_sum( Y, MA[0], ht, len )
  238. #define MCE_Cols_sum( Y, MA, ht, len )     MCECols_sum( Y, MA[0], ht, len )
  239. #define MCE_Dia_sum(  MA, len )            MCEDia_sum( MA[0], len )
  240. #define MCE_Rows_prod( Y, MA, ht, len )    MCERows_prod( Y, MA[0], ht, len )
  241. #define MCE_Cols_prod( Y, MA, ht, len )    MCECols_prod( Y, MA[0], ht, len )
  242. #define MCE_Dia_prod(  MA, len )           MCEDia_prod( MA[0], len )
  243.  
  244. #define MCE_Rows_runsum( MA, ht, len )     MCERows_runsum( MA[0], ht, len )
  245. #define MCE_Cols_runsum( MA, ht, len )     MCECols_runsum( MA[0], ht, len )
  246. #define MCE_Rows_runprod( MA, ht, len )    MCERows_runprod( MA[0], ht, len )
  247. #define MCE_Cols_runprod( MA, ht, len )    MCECols_runprod( MA[0], ht, len )
  248.  
  249. #define MCE_Rows_rotate( MA, ht, len, pos) MCERows_rotate( MA[0], ht, len, pos )
  250. #define MCE_Cols_rotate( MA, ht, len, pos) MCECols_rotate( MA[0], ht, len, pos )
  251.  
  252. /********  Operations involving two rows or two colums of one matrix  *****/
  253.  
  254. #define MCE_Rows_exchange( MA, ht, len, row1, row2 ) \
  255.                              MCERows_exchange( MA[0], ht, len, row1, row2 )
  256. #define MCE_Cols_exchange( MA, ht, len, col1, col2 ) \
  257.                              MCECols_exchange( MA[0], ht, len, col1, col2 )
  258.  
  259. #define MCE_Rows_add( MA, ht, len, destRow, srceRow ) \
  260.                              MCERows_add( MA[0], ht, len, destRow, srceRow )
  261. #define MCE_Cols_add( MA, ht, len, destCol, srceCol ) \
  262.                              MCECols_add( MA[0], ht, len, destCol, srceCol )
  263.                          /* dest[i] += source[i]  */
  264.  
  265. #define MCE_Rows_sub( MA, ht, len, destRow, srceRow ) \
  266.                              MCERows_sub( MA[0], ht, len, destRow, srceRow )
  267. #define MCE_Cols_sub( MA, ht, len, destCol, srceCol ) \
  268.                              MCECols_sub( MA[0], ht, len, destCol, srceCol )
  269.                          /* dest[i] -= source[i]  */
  270.  
  271. #define MCE_Rows_Cadd( MA, ht, len, destRow, srceRow, C ) \
  272.                           MCERows_Cadd( MA[0], ht, len, destRow, srceRow, C )
  273. #define MCE_Cols_Cadd( MA, ht, len, destCol, srceCol, C ) \
  274.                           MCECols_Cadd( MA[0], ht, len, destCol, srceCol, C )
  275.                          /* dest[i] += C * source[i]  */
  276.  
  277. #define MCE_Rows_lincomb( MA, ht, len, destRow, destC, srceRow, srceC ) \
  278.             MCERows_lincomb( MA[0], ht, len, destRow, destC, srceRow, srceC )
  279. #define MCE_Cols_lincomb( MA, ht, len, destCol, destC, srceCol, srceC ) \
  280.             MCECols_lincomb( MA[0], ht, len, destCol, destC, srceCol, srceC )
  281.   /*  linear combination: dest[i] = destC * dest[i] + sourceC * source[i] */
  282.  
  283.  
  284. /*************************  Transposing a matrix **********************/
  285.  
  286. #define MCE_transpose( MTr, MA, htTr, lenTr ) \
  287.              MCEtranspose( MTr[0], MA[0], htTr, lenTr )
  288.        /*  the dimensions htTr, lenTr are those of the transposed matrix,
  289.            not of the original!                */
  290.  
  291.  
  292. /************************ Matrix Multiplication *************************/
  293.  
  294. #define MCE_mulV( Y, MA, X, htA, lenA ) \
  295.                     MCEmulV( Y, MA[0], X, htA, lenA )
  296.                           /*  Y = MA * X.  sizX=lenA, sizY=htA
  297.                               both X and Y are column-vectors    */
  298. #define VCE_mulM( Y, X, MA, sizX, lenA ) \
  299.                     VCEmulM( Y, X, MA[0], 1, sizX, lenA )
  300.                          /*  Y = X * MA.  htA=sizX, sizY=lenA
  301.                              both X and Y are row-vectors.
  302.                              Mind the prefix: VCE_ (not MCE_)    */
  303. #define MCE_mulM( MC, MA, MB, htA, lenA, lenB ) \
  304.                     MCEmulM( MC[0], MA[0], MB[0], htA, lenA, lenB )
  305.                          /*  MC = MA * MB.  htB=lenA, htC=htA, lenC=lenB */
  306.  
  307. /***************** Two-Dimensional Fourier-Transform Methods ************/
  308.  
  309. #define MCEl_FFT( MY, MX, ht, len, dir )     MCElFFT( MY[0], MX[0], ht, len, dir )
  310. #define MCEl_filter( MY, MX, MFlt, ht, len ) MCElfilter( MY[0], MX[0], MFlt[0], ht, len )
  311.  
  312. #define MCEs_FFT( MY, MX, ht, len, dir )     MCEsFFT( MY[0], MX[0], ht, len, dir )
  313. #define MCEs_filter( MY, MX, MFlt, ht, len ) MCEsfilter( MY[0], MX[0], MFlt[0], ht, len )
  314.  
  315. #if defined( __LARGE__ ) || defined( __COMPACT__ ) || defined ( __HUGE__ )
  316.    #define MCE_FFT         MCEl_FFT
  317.    #define MCE_filter      MCEl_filter
  318. #else
  319.    #define MCE_FFT         MCEs_FFT
  320.    #define MCE_filter      MCEs_filter
  321. #endif
  322.  
  323.  
  324. /**************************  Input and Output  **************************/
  325.  
  326. #define MCE_fprint( stream, MA, ht, len, linewidth ) \
  327.                     MCEfprint( stream, MA[0], ht, len, linewidth )
  328. #define MCE_print( MA, ht, len )  MCEfprint( stdout, MA[0], ht, len, 80 )
  329. #define MCE_cprint( MA, ht, len ) MCEcprint( MA[0], ht, len )
  330.   /*  MCE_print, MCE_cprint usable only for DOS, EasyWin, and Win32 console applications! */
  331.  
  332. #define MCE_write( str, MA, ht, len )   MCEwrite( str, MA[0], ht, len )
  333. #define MCE_read( MA, ht, len, str )    MCEread( MA[0], ht, len, str )
  334. #define MCE_setWriteFormat              VCE_setWriteFormat
  335. #define MCE_setWriteSeparate            VCE_setNWriteSeparate
  336.                                    /* write and read in ascii format */
  337. #define MCE_store( str, MA, ht, len ) \
  338.                            VCE_store( str, MA[0], ((ui)(len))*(ht) );
  339. #define MCE_recall( MA, ht, len, str) \
  340.                            VCE_recall( MA[0], ((ui)(len))*(ht), str);
  341.                                   /* store and recall in binary format */
  342.  
  343.  
  344. /*************************************************************************
  345.  * Here are now the actual declarations of the functions used internally.*
  346.  * These declarations may change in future versions of MatrixLib!        *
  347.  * You should not care too much about them, except in the case you need  *
  348.  * the actual address of a run-time function (see above). Under all      *
  349.  * "normal" circumstances, use only the names defined above in the       *
  350.  * macro section!                                                        *
  351.  *************************************************************************/
  352.  
  353. eComplex _VFAR * MCEPelement( cePMatrix X, unsigned ht, unsigned len,
  354.                          unsigned m, unsigned n );
  355.                   /* pointer is normalized in memory model HUGE */
  356.  
  357. void   __vf  MCEequ1( cePMatrix MA, unsigned len );  /* identity matrix */
  358. void   __vf  MCEouterprod( cePMatrix MA, ceVector X,  ceVector Y,
  359.                            unsigned ht, unsigned len );
  360.  
  361. void   __vf  MCERow_equC( cePMatrix MA, unsigned ht, unsigned len,
  362.                          unsigned iRow, eComplex C );
  363. void   __vf  MCECol_equC( cePMatrix MA, unsigned ht, unsigned len,
  364.                          unsigned iCol, eComplex C );
  365. void   __vf  MCEDia_equC( cePMatrix MA, unsigned len, eComplex C );
  366.  
  367. void   __vf  MCERow_equV( cePMatrix MA, unsigned ht, unsigned len,
  368.                          unsigned iRow, ceVector X );
  369. void   __vf  MCECol_equV( cePMatrix MA, unsigned ht, unsigned len,
  370.                          unsigned iCol, ceVector X );
  371. void   __vf  MCEDia_equV( cePMatrix MA, unsigned len, ceVector X );
  372.  
  373. void   __vf  MCEUequL( cePMatrix MA, unsigned len );
  374. void   __vf  MCELequU( cePMatrix MA, unsigned len );
  375.  
  376. /********  Extracting a submatrix and copying a submatrix back  *********/
  377.  
  378. void  __vf  MCEsubmatrix( cePMatrix MSub,
  379.                           unsigned subHt,  unsigned subLen,
  380.                           cePMatrix MSrce,
  381.                           unsigned srceHt,  unsigned srceLen,
  382.                           unsigned firstRowInCol,  unsigned sampInCol,
  383.                           unsigned firstColInRow,  unsigned sampInRow );
  384.  
  385. void  __vf  MCEsubmatrix_equM( cePMatrix MDest,
  386.                                unsigned destHt,     unsigned destLen,
  387.                                unsigned firstRowInCol,  unsigned sampInCol,
  388.                                unsigned firstColInRow,  unsigned sampInRow,
  389.                                cePMatrix MSrce,
  390.                                unsigned srceHt,     unsigned srceLen );
  391.  
  392.  
  393. /*****   Extracting a single row or a single column or the diagonal  *****
  394.  *       and storing it into a vector                                    */
  395.  
  396. void __vf MCERow_extract( ceVector Y, cePMatrix MA, unsigned ht, unsigned len,
  397.                            unsigned iRow );
  398. void __vf MCECol_extract( ceVector Y, cePMatrix MA, unsigned ht, unsigned len,
  399.                            unsigned iCol );
  400. void __vf MCEDia_extract( ceVector Y, cePMatrix MA, unsigned len );
  401.  
  402.  
  403. /*****************    Basic arithmetic operations ***********************
  404.      performed on one single row,  or one single column of any matrix,
  405.      or on the diagonal of a square matrix                              */
  406.  
  407. void   __vf  MCERow_addC( cePMatrix MA, unsigned ht, unsigned len,
  408.                          unsigned iRow, eComplex C );
  409. void   __vf  MCECol_addC( cePMatrix MA, unsigned ht, unsigned len,
  410.                          unsigned iCol, eComplex C );
  411. void   __vf  MCEDia_addC( cePMatrix MA, unsigned len, eComplex C );
  412.  
  413. void   __vf  MCERow_subC( cePMatrix MA, unsigned ht, unsigned len,
  414.                          unsigned iRow, eComplex C );
  415. void   __vf  MCECol_subC( cePMatrix MA, unsigned ht, unsigned len,
  416.                          unsigned iCol, eComplex C );
  417. void   __vf  MCEDia_subC( cePMatrix MA, unsigned len, eComplex C );
  418.  
  419. void   __vf  MCERow_addV( cePMatrix MA, unsigned ht, unsigned len,
  420.                          unsigned iRow, ceVector X );
  421. void   __vf  MCECol_addV( cePMatrix MA, unsigned ht, unsigned len,
  422.                          unsigned iCol, ceVector X );
  423. void   __vf  MCEDia_addV( cePMatrix MA, unsigned len, ceVector X );
  424.  
  425. void   __vf  MCERow_subV( cePMatrix MA, unsigned ht, unsigned len,
  426.                          unsigned iRow, ceVector X );
  427. void   __vf  MCECol_subV( cePMatrix MA, unsigned ht, unsigned len,
  428.                          unsigned iCol, ceVector X );
  429. void   __vf  MCEDia_subV( cePMatrix MA, unsigned len, ceVector X );
  430.  
  431. void   __vf  MCERow_subrC( cePMatrix MA, unsigned ht, unsigned len,
  432.                          unsigned iRow, eComplex C );
  433. void   __vf  MCECol_subrC( cePMatrix MA, unsigned ht, unsigned len,
  434.                          unsigned iCol, eComplex C );
  435. void   __vf  MCEDia_subrC( cePMatrix MA, unsigned len, eComplex C );
  436.  
  437. void   __vf  MCERow_subrV( cePMatrix MA, unsigned ht, unsigned len,
  438.                          unsigned iRow, ceVector X );
  439. void   __vf  MCECol_subrV( cePMatrix MA, unsigned ht, unsigned len,
  440.                          unsigned iCol, ceVector X );
  441. void   __vf  MCEDia_subrV( cePMatrix MA, unsigned len, ceVector X );
  442.  
  443. void   __vf  MCERow_mulC( cePMatrix MA, unsigned ht, unsigned len,
  444.                          unsigned iRow, eComplex C );
  445. void   __vf  MCECol_mulC( cePMatrix MA, unsigned ht, unsigned len,
  446.                          unsigned iCol, eComplex C );
  447. void   __vf  MCEDia_mulC( cePMatrix MA, unsigned len, eComplex C );
  448.  
  449. void   __vf  MCERow_mulV( cePMatrix MA, unsigned ht, unsigned len,
  450.                          unsigned iRow, ceVector X );
  451. void   __vf  MCECol_mulV( cePMatrix MA, unsigned ht, unsigned len,
  452.                          unsigned iCol, ceVector X );
  453. void   __vf  MCEDia_mulV( cePMatrix MA, unsigned len, ceVector X );
  454.  
  455. void   __vf  MCERow_divC( cePMatrix MA, unsigned ht, unsigned len,
  456.                          unsigned iRow, eComplex C );
  457. void   __vf  MCECol_divC( cePMatrix MA, unsigned ht, unsigned len,
  458.                          unsigned iCol, eComplex C );
  459. void   __vf  MCEDia_divC( cePMatrix MA, unsigned len, eComplex C );
  460.  
  461. void   __vf  MCERow_divV( cePMatrix MA, unsigned ht, unsigned len,
  462.                          unsigned iRow, ceVector X );
  463. void   __vf  MCECol_divV( cePMatrix MA, unsigned ht, unsigned len,
  464.                          unsigned iCol, ceVector X );
  465. void   __vf  MCEDia_divV( cePMatrix MA, unsigned len, ceVector X );
  466.  
  467. void   __vf  MCERow_divrC( cePMatrix MA, unsigned ht, unsigned len,
  468.                          unsigned iRow, eComplex C );
  469. void   __vf  MCECol_divrC( cePMatrix MA, unsigned ht, unsigned len,
  470.                          unsigned iCol, eComplex C );
  471. void   __vf  MCEDia_divrC( cePMatrix MA, unsigned len, eComplex C );
  472.  
  473. void   __vf  MCERow_divrV( cePMatrix MA, unsigned ht, unsigned len,
  474.                          unsigned iRow, ceVector X );
  475. void   __vf  MCECol_divrV( cePMatrix MA, unsigned ht, unsigned len,
  476.                          unsigned iCol, ceVector X );
  477. void   __vf  MCEDia_divrV( cePMatrix MA, unsigned len, ceVector X );
  478.  
  479.  
  480. /******  One-dimensional vector operations **********************
  481.          performed along all rows or all columns simultaneously,
  482.          or along the diagonal of a square matrix                */
  483.  
  484. void     __vf  MCERows_absmax( eVector Y, cePMatrix MA, unsigned ht, unsigned len );
  485. void     __vf  MCECols_absmax( eVector Y, cePMatrix MA, unsigned ht, unsigned len );
  486. extended __vf  MCEDia_absmax(  cePMatrix MA, unsigned len );
  487. void     __vf  MCERows_absmin( eVector Y, cePMatrix MA, unsigned ht, unsigned len );
  488. void     __vf  MCECols_absmin( eVector Y, cePMatrix MA, unsigned ht, unsigned len );
  489. extended __vf  MCEDia_absmin(  cePMatrix MA, unsigned len );
  490.  
  491. void     __vf  MCERows_maxReIm( ceVector Y, cePMatrix MA, unsigned ht, unsigned len );
  492. void     __vf  MCECols_maxReIm( ceVector Y, cePMatrix MA, unsigned ht, unsigned len );
  493. void     __vf  MCERows_minReIm( ceVector Y, cePMatrix MA, unsigned ht, unsigned len );
  494. void     __vf  MCECols_minReIm( ceVector Y, cePMatrix MA, unsigned ht, unsigned len );
  495.  
  496. void     __vf  MCERows_absmaxReIm( ceVector Y, cePMatrix MA, unsigned ht, unsigned len );
  497. void     __vf  MCECols_absmaxReIm( ceVector Y, cePMatrix MA, unsigned ht, unsigned len );
  498. void     __vf  MCERows_absminReIm( ceVector Y, cePMatrix MA, unsigned ht, unsigned len );
  499. void     __vf  MCECols_absminReIm( ceVector Y, cePMatrix MA, unsigned ht, unsigned len );
  500.  
  501. void     __vf  MCERows_sum( ceVector Y, cePMatrix MA, unsigned ht, unsigned len );
  502. void     __vf  MCECols_sum( ceVector Y, cePMatrix MA, unsigned ht, unsigned len );
  503. void     __vf  MCERows_prod(ceVector Y, cePMatrix MA, unsigned ht, unsigned len );
  504. void     __vf  MCECols_prod(ceVector Y, cePMatrix MA, unsigned ht, unsigned len );
  505. #if defined __cplusplus && defined _CMATH_CLASSDEFS
  506. } // the following functions cannot be extern "C", if eComplex is a class
  507. #endif
  508. eComplex __vf  MCEDia_maxReIm(  cePMatrix MA, unsigned len );
  509. eComplex __vf  MCEDia_minReIm(  cePMatrix MA, unsigned len );
  510. eComplex __vf  MCEDia_absmaxReIm(  cePMatrix MA, unsigned len );
  511. eComplex __vf  MCEDia_absminReIm(  cePMatrix MA, unsigned len );
  512. eComplex __vf  MCEDia_sum(  cePMatrix MA, unsigned len );
  513. eComplex __vf  MCEDia_prod( cePMatrix MA, unsigned len );
  514. #if defined __cplusplus && defined _CMATH_CLASSDEFS
  515. extern "C" { 
  516. #endif
  517. void  __vf  MCERows_runsum( cePMatrix MA, unsigned ht, unsigned len );
  518. void  __vf  MCECols_runsum( cePMatrix MA, unsigned ht, unsigned len );
  519. void  __vf  MCERows_runprod( cePMatrix MA, unsigned ht, unsigned len );
  520. void  __vf  MCECols_runprod( cePMatrix MA, unsigned ht, unsigned len );
  521.  
  522. void  __vf  MCERows_rotate( cePMatrix MA, unsigned ht, unsigned len, int pos );
  523. void  __vf  MCECols_rotate( cePMatrix MA, unsigned ht, unsigned len, int pos );
  524.  
  525. /********  Operations involving two rows or two colums of one matrix  *****/
  526.  
  527. void   __vf  MCERows_exchange( cePMatrix MA, unsigned ht, unsigned len,
  528.                               unsigned i1, unsigned i2 );
  529. void   __vf  MCECols_exchange( cePMatrix MA, unsigned ht, unsigned len,
  530.                               unsigned i1, unsigned i2 );
  531.  
  532. void   __vf  MCERows_add( cePMatrix MA, unsigned ht, unsigned len,
  533.                           unsigned destRow, unsigned sourceRow );
  534. void   __vf  MCECols_add( cePMatrix MA, unsigned ht, unsigned len,
  535.                           unsigned destCol, unsigned sourceCol );
  536.  
  537. void   __vf  MCERows_sub( cePMatrix MA, unsigned ht, unsigned len,
  538.                           unsigned destRow, unsigned sourceRow );
  539. void   __vf  MCECols_sub( cePMatrix MA, unsigned ht, unsigned len,
  540.                           unsigned destCol, unsigned sourceCol );
  541.  
  542. void   __vf  MCERows_Cadd( cePMatrix MA, unsigned ht, unsigned len,
  543.                            unsigned destRow, unsigned sourceRow, eComplex C );
  544. void   __vf  MCECols_Cadd( cePMatrix MA, unsigned ht, unsigned len,
  545.                            unsigned destCol, unsigned sourceCol, eComplex C );
  546.  
  547. void   __vf  MCERows_lincomb( cePMatrix MA, unsigned ht, unsigned len,
  548.                               unsigned destRow,  eComplex  destC,
  549.                               unsigned srceRow,  eComplex  srceC );
  550. void   __vf  MCECols_lincomb( cePMatrix MA, unsigned ht, unsigned len,
  551.                               unsigned destCol,  eComplex  destC,
  552.                               unsigned srceCol,  eComplex  srceC );
  553.  
  554.  
  555. /*************************  Transposing a matrix **********************/
  556.  
  557. void  __vf  MCEtranspose( cePMatrix MTr, cePMatrix MA,
  558.                           unsigned htTr, unsigned lenTr );
  559.  
  560.  
  561. /************************ Matrix Multiplication *************************/
  562.  
  563. void  __vf  MCEmulV( ceVector Y, cePMatrix MA, ceVector X,
  564.                      unsigned htA, unsigned lenA );
  565. void  __vf  VCEmulM( ceVector Y, ceVector X, cePMatrix MA,
  566.                      unsigned sizX, unsigned lenA );
  567. void  __vf  MCEmulM( cePMatrix MC, cePMatrix MA, cePMatrix MB,
  568.                      unsigned htA, unsigned lenA, unsigned lenB );
  569.  
  570. /*************  Two-Dimensional Fourier-Transform Methods *****************/
  571.  
  572. void  __vf   MCElFFT( cePMatrix MY, cePMatrix MX,
  573.                       unsigned ht, unsigned len, int dir );
  574. void  __vf   MCElfilter( cePMatrix MY, cePMatrix MX, cePMatrix MFlt,
  575.                          unsigned ht, unsigned len );
  576. void  __vf   MCEsFFT( cePMatrix MY, cePMatrix MX,
  577.                       unsigned ht, unsigned len, int dir );
  578. void  __vf   MCEsfilter( cePMatrix MY, cePMatrix MX, cePMatrix MFlt,
  579.                          unsigned ht, unsigned len );
  580.  
  581.       /*************  Input and Output  ****************/
  582.  
  583. void __vf MCEfprint( FILE _VFAR *stream, cePMatrix MA, unsigned ht,
  584.                     unsigned len, unsigned linewidth );
  585. void __vf MCEcprint( cePMatrix MA, unsigned ht, unsigned len );
  586. void  __vf    MCEwrite( FILE _VFAR *stream, cePMatrix X, unsigned ht, unsigned len  );
  587. void  __vf    MCEread( cePMatrix X, unsigned ht, unsigned len, FILE _VFAR *stream );
  588.  
  589. #ifdef __cplusplus
  590. }
  591. #endif
  592.  
  593. #else  /*  MSVC, Optima++:  MCE_ functions are identical to MCD_ */
  594. #define MCE_matrix     MCD_matrix
  595. #define MCE_matrix0    MCD_matrix0
  596. #define MCE_Pelement   MCD_Pelement 
  597. #define MCE_element    MCD_element
  598. #define MCE_equ1       MCD_equ1 
  599. #define MCE_outerprod  MCD_outerprod
  600. #define MCE_Row_equC   MCD_Row_equC
  601. #define MCE_Col_equC   MCD_Col_equC
  602. #define MCE_Dia_equC   MCD_Dia_equC
  603. #define MCE_Row_equV   MCD_Row_equV
  604. #define MCE_Col_equV   MCD_Col_equV
  605. #define MCE_Dia_equV   MCD_Dia_equV
  606. #define MCE_equM       MCD_equM
  607. #define MCE_UequL      MCD_UequL
  608. #define MCE_LequU      MCD_LequU
  609. #define M_CEtoCF( MCF, MCE, ht, len ) V_CEtoCF( MCF[0], MCE[0], ((ui)ht)*len )
  610. #define M_CFtoCE( MCE, MCF, ht, len ) V_CFtoCE( MCE[0], MCF[0], ((ui)ht)*len )
  611. #define M_CEtoCD( MCD, MCE, ht, len ) V_CEtoCD( MCD[0], MCE[0], ((ui)ht)*len )
  612. #define M_CDtoCE( MCE, MCD, ht, len ) V_CDtoCE( MCE[0], MCD[0], ((ui)ht)*len )
  613. #define MCE_submatrix           MCD_submatrix
  614. #define MCE_submatrix_equM      MCD_submatrix_equM
  615. #define MCE_Row_extract         MCD_Row_extract 
  616. #define MCE_Col_extract         MCD_Col_extract
  617. #define MCE_Dia_extract         MCD_Dia_extract
  618. #define MCE_Row_addC            MCD_Row_addC
  619. #define MCE_Col_addC            MCD_Col_addC 
  620. #define MCE_Dia_addC            MCD_Dia_addC 
  621. #define MCE_Row_addV            MCD_Row_addV
  622. #define MCE_Col_addV            MCD_Col_addV 
  623. #define MCE_Dia_addV            MCD_Dia_addV
  624. #define MCE_Row_subC            MCD_Row_subC 
  625. #define MCE_Col_subC            MCD_Col_subC
  626. #define MCE_Dia_subC            MCD_Dia_subC
  627. #define MCE_Row_subV            MCD_Row_subV 
  628. #define MCE_Col_subV            MCD_Col_subV
  629. #define MCE_Dia_subV            MCD_Dia_subV
  630. #define MCE_Row_subrC           MCD_Row_subrC
  631. #define MCE_Col_subrC           MCD_Col_subrC
  632. #define MCE_Dia_subrC           MCD_Dia_subrC 
  633. #define MCE_Row_subrV           MCD_Row_subrV 
  634. #define MCE_Col_subrV           MCD_Col_subrV
  635. #define MCE_Dia_subrV           MCD_Dia_subrV  
  636. #define MCE_Row_mulC            MCD_Row_mulC 
  637. #define MCE_Col_mulC            MCD_Col_mulC
  638. #define MCE_Dia_mulC            MCD_Dia_mulC 
  639. #define MCE_Row_mulV            MCD_Row_mulV
  640. #define MCE_Col_mulV            MCD_Col_mulV
  641. #define MCE_Dia_mulV            MCD_Dia_mulV
  642. #define MCE_Row_divC            MCD_Row_divC 
  643. #define MCE_Col_divC            MCD_Col_divC   
  644. #define MCE_Dia_divC            MCD_Dia_divC 
  645. #define MCE_Row_divV            MCD_Row_divV 
  646. #define MCE_Col_divV            MCD_Col_divV
  647. #define MCE_Dia_divV            MCD_Dia_divV
  648. #define MCE_Row_divrC           MCD_Row_divrC  
  649. #define MCE_Col_divrC           MCD_Col_divrC 
  650. #define MCE_Dia_divrC           MCD_Dia_divrC 
  651. #define MCE_Row_divrV           MCD_Row_divrV
  652. #define MCE_Col_divrV           MCD_Col_divrV 
  653. #define MCE_Dia_divrV           MCD_Dia_divrV
  654. #define MCE_Rows_absmax         MCD_Rows_absmax
  655. #define MCE_Cols_absmax         MCD_Cols_absmax  
  656. #define MCE_Dia_absmax          MCD_Dia_absmax
  657. #define MCE_Rows_absmin         MCD_Rows_absmin 
  658. #define MCE_Cols_absmin         MCD_Cols_absmin
  659. #define MCE_Dia_absmin          MCD_Dia_absmin 
  660. #define MCE_Rows_maxReIm        MCD_Rows_maxReIm
  661. #define MCE_Cols_maxReIm        MCD_Cols_maxReIm
  662. #define MCE_Dia_maxReIm         MCD_Dia_maxReIm
  663. #define MCE_Rows_minReIm        MCD_Rows_minReIm
  664. #define MCE_Cols_minReIm        MCD_Cols_minReIm
  665. #define MCE_Dia_minReIm         MCD_Dia_minReIm
  666. #define MCE_Rows_absmaxReIm     MCD_Rows_absmaxReIm 
  667. #define MCE_Cols_absmaxReIm     MCD_Cols_absmaxReIm
  668. #define MCE_Dia_absmaxReIm      MCD_Dia_absmaxReIm
  669. #define MCE_Rows_absminReIm     MCD_Rows_absminReIm
  670. #define MCE_Cols_absminReIm     MCD_Cols_absminReIm  
  671. #define MCE_Dia_absminReIm      MCD_Dia_absminReIm
  672. #define MCE_Rows_sum            MCD_Rows_sum
  673. #define MCE_Cols_sum            MCD_Cols_sum
  674. #define MCE_Dia_sum             MCD_Dia_sum
  675. #define MCE_Rows_prod           MCD_Rows_prod 
  676. #define MCE_Cols_prod           MCD_Cols_prod 
  677. #define MCE_Dia_prod            MCD_Dia_prod 
  678. #define MCE_Rows_runsum         MCD_Rows_runsum
  679. #define MCE_Cols_runsum         MCD_Cols_runsum
  680. #define MCE_Rows_runprod        MCD_Rows_runprod
  681. #define MCE_Cols_runprod        MCD_Cols_runprod
  682. #define MCE_Rows_rotate         MCD_Rows_rotate
  683. #define MCE_Cols_rotate         MCD_Cols_rotate
  684. #define MCE_Rows_exchange       MCD_Rows_exchange
  685. #define MCE_Cols_exchange       MCD_Cols_exchange
  686. #define MCE_Rows_add            MCD_Rows_add 
  687. #define MCE_Cols_add            MCD_Cols_add
  688. #define MCE_Rows_sub            MCD_Rows_sub 
  689. #define MCE_Cols_sub            MCD_Cols_sub 
  690. #define MCE_Rows_Cadd           MCD_Rows_Cadd
  691. #define MCE_Cols_Cadd           MCD_Cols_Cadd 
  692. #define MCE_Rows_lincomb        MCD_Rows_lincomb
  693. #define MCE_Cols_lincomb        MCD_Cols_lincomb  
  694. #define MCE_transpose           MCD_transpose 
  695. #define MCE_mulV                MCD_mulV 
  696. #define VCE_mulM                VCD_mulM
  697. #define MCE_mulM                MCD_mulM
  698. #define MCEl_FFT                MCDl_FFT
  699. #define MCEl_filter             MCDl_filter
  700. #define MCEs_FFT                MCDs_FFT  
  701. #define MCEs_filter             MCDs_filter
  702. #define MCE_FFT                 MCD_FFT 
  703. #define MCE_filter              MCD_filter
  704. #define MCE_fprint              MCD_fprint
  705. #define MCE_print               MCD_print
  706. #define MCE_cprint              MCD_cprint 
  707. #define MCE_write               MCD_write 
  708. #define MCE_read                MCD_read
  709. #define MCE_setWriteFormat      VCE_setWriteFormat
  710. #define MCE_setWriteSeparate    VCE_setNWriteSeparate
  711. #define MCE_store               MCD_store
  712. #define MCE_recall              MCD_recall
  713.  
  714. #endif  /*  Borland, Microsoft, Powersoft */