home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic Source Code / Visual Basic Source Code.iso / vbsource / optivc32 / mfstd.h < prev    next >
Encoding:
C/C++ Source or Header  |  1999-03-06  |  56.5 KB  |  1,079 lines
  1. /*  MFstd.h
  2.  
  3.   matrix management functions:
  4.   manipulations on matrices of data type "float"
  5.   (single-precision real numbers)
  6.  
  7.   Copyright (c) 1996-1999 by Martin Sander
  8.   All Rights Reserved.
  9. */
  10.  
  11. #if !defined( __MFSTD_H )
  12. #define __MFSTD_H
  13. #if !defined( __MATLIB_H )
  14. #include <MatLib.h>
  15. #endif
  16. #if !defined( __VFSTD_H )
  17. #include <VFstd.h>
  18. #endif
  19. #if !defined( __VFMATH_H )
  20. #include <VFmath.h>
  21. #endif
  22.  
  23. #ifdef __cplusplus
  24. extern "C" {
  25. #endif
  26.  
  27. /*************   Dynamic Generation of Matrices   ************************/
  28.  
  29. fMatrix __vf  MF_matrix(  unsigned ht, unsigned len );
  30. fMatrix __vf  MF_matrix0( unsigned ht, unsigned len );
  31.     /*  notice that, in the memory model HUGE,
  32.         neither len nor ht may exceed 8191            */
  33.  
  34. /***************************************************************************
  35.  *  The following definitions ensure compatibility between dynamically     *
  36.  *  and statically allocated matrices. The definitions are somewhat        *
  37.  *  cumbersome, but the result for you is that you need not care about     *
  38.  *  the differences between the two types.                                 *
  39.  *  (Internally, the address of the first element of any matrix is needed; *
  40.  *  the expression "MA[0]" is evaluated in a different way for both types, *
  41.  *  but yields in either case the correct address to be passed to the      *
  42.  *  function you wish to call.)                                            *
  43.  *  Only in the rare case that you need to pass the address of one of      *
  44.  *  these functions as an argument to another function, you have to use    *
  45.  *  the actual run-time functions defined further below. Be careful with   *
  46.  *  this: future development of compilers may allow us to avoid this un-   *
  47.  *  handy scheme of macros. So future versions of MatrixLib may no longer  *
  48.  *  use these run-time names.                                              *
  49.  ***************************************************************************/
  50.  
  51.  
  52. /***  Addressing single elements of dynamically allocated matrices: ******
  53.      These two functions are for compatibility with Pascal
  54.      (where elements of dynamically allocated matrices are not directly
  55.      accessible), and for getting around the pointer arithmetics bug in
  56.      some versions of Borland C++.                                         */
  57.  
  58. #define MF_Pelement( MA, ht, len, m, n ) MFPelement( MA[0], ht, len, m, n )
  59.                      /* returns a pointer to MA[m][n]. */
  60. #define MF_element( MA, ht, len, m, n ) (*MFPelement( MA[0], ht, len, m, n ))
  61.                      /* dereferenced pointer */
  62.  
  63.  /****************  Initialization  ***************************************
  64.  
  65.     To initialize all elements of a matrix with the same value,
  66.     or to perform arithmetic operations on all elements simultaneously,
  67.     refer to the functions of VectorLib, declared in <VFstd.h>, <VFmath.h>.
  68.     In order to use the VectorLib functions, utilize the feature that
  69.     the whole matrix occupies one contiguous area in memory: pass the
  70.     address of the first row to the desired vector function, the size
  71.     of the "vector" being ht * len.
  72.     For example, initialize all elements of the matrix MA with 1.0
  73.     (this is *NOT* the identity matrix)  by calling
  74.         VF_equ1( MA[0], ht * len );
  75. */
  76.  
  77. #define MF_equ0( MA, ht, len )            VF_equ0( MA[0], ((ui)ht)*len )
  78. #define MF_equ1( MA, len )                MFequ1( MA[0], len )
  79.                        /* this is the identity matrix */
  80. #define MF_outerprod( MA, X, Y, ht, len ) MFouterprod( MA[0], X, Y, ht, len )
  81.                        /* sizX=ht, sizY=len */
  82. #define MF_Row_equC( MA, ht, len, iRow, C ) \
  83.                                         MFRow_equC( MA[0], ht, len, iRow, C )
  84. #define MF_Col_equC( MA, ht, len, iCol, C ) \
  85.                                         MFCol_equC( MA[0], ht, len, iCol, C )
  86. #define MF_Dia_equC( MA, len, C )       MFDia_equC( MA[0], len, C )
  87.  
  88. #define MF_Row_equV( MA, ht, len, iRow, X ) \
  89.                                         MFRow_equV( MA[0], ht, len, iRow, X )
  90. #define MF_Col_equV( MA, ht, len, iCol, X ) \
  91.                                         MFCol_equV( MA[0], ht, len, iCol, X )
  92. #define MF_Dia_equV( MA, len, X )       MFDia_equV( MA[0], len, X )
  93.  
  94. #define MF_equM( MB, MA, ht, len )  VF_equV( MB[0], MA[0], (ui)(ht)*(len) )
  95.  
  96. #define MF_UequL( MA, len ) MFUequL( MA[0], len )
  97. #define MF_LequU( MA, len ) MFLequU( MA[0], len )
  98.          /* copy lower-diagonal elements into upper-diagonal
  99.            (or vice versa) by index-reflection, so as to
  100.            get a symmetric matrix    */
  101.  
  102.             /* data-type conversions:  */
  103. #define M_DtoF( MF, MD, ht, len ) V_DtoF( MF[0], MD[0], ((ui)ht)*len )
  104. #define M_EtoF( MF, ME, ht, len ) V_EtoF( MF[0], ME[0], ((ui)ht)*len )
  105. #define M_FtoD( MD, MF, ht, len ) V_FtoD( MD[0], MF[0], ((ui)ht)*len )
  106. #define M_FtoE( ME, MF, ht, len ) V_FtoE( ME[0], MF[0], ((ui)ht)*len )
  107.  
  108.             /* suitable windows for MF_spectrum: */
  109. #define MF_Hanning( MA, ht, len )  MFHanning( MA[0], ht, len )
  110. #define MF_Parzen( MA, ht, len )   MFParzen( MA[0], ht, len )
  111. #define MF_Welch( MA, ht, len )    MFWelch( MA[0], ht, len )
  112.  
  113. /********  Extracting a submatrix and copying a submatrix back  *********/
  114.  
  115. #define MF_submatrix( MSub, subHt, subLen, \
  116.                       MSrce, srceHt, srceLen, \
  117.                       firstRowInCol, sampInCol, firstColInRow, sampInRow ) \
  118.                MFsubmatrix(  MSub[0], subHt, subLen, \
  119.                              MSrce[0], srceHt, srceLen, \
  120.                              firstRowInCol, sampInCol, firstColInRow, sampInRow )
  121.  
  122. #define MF_submatrix_equM( MDest, destHt, destLen, \
  123.                            firstRowInCol, sampInCol, firstColInRow, sampInRow, \
  124.                            MSrce, srceHt, srceLen ) \
  125.                MFsubmatrix_equM(  MDest[0], destHt, destLen, \
  126.                              firstRowInCol, sampInCol, firstColInRow, sampInRow, \
  127.                              MSrce[0], srceHt, srceLen )
  128.  
  129. /*****   Extracting a single row or a single column or the diagonal  ******
  130.  *       and storing it into a vector                                     */
  131.  
  132. #define MF_Row_extract( Y, MA, ht, len, iRow ) \
  133.                                      MFRow_extract( Y, MA[0], ht, len, iRow )
  134. #define MF_Col_extract( Y, MA, ht, len, iCol ) \
  135.                                      MFCol_extract( Y, MA[0], ht, len, iCol )
  136. #define MF_Dia_extract( Y, MA, len ) MFDia_extract( Y, MA[0], len )
  137.  
  138.  
  139. /*****************    Basic arithmetic operations *********************
  140.                       performed on one single row,
  141.                       or one single column of any matrix,
  142.                       or on the diagonal of a square matrix
  143.  
  144.     Note: In contrast to the analogous VectorLib functions, the operations
  145.     are performed in-place, i.e. the input matrix itself is changed  */
  146.  
  147. #define MF_Row_addC( MA, ht, len, iRow, C ) \
  148.                                      MFRow_addC( MA[0], ht, len, iRow, C )
  149. #define MF_Col_addC( MA, ht, len, iCol, C ) \
  150.                                      MFCol_addC( MA[0], ht, len, iCol, C )
  151. #define MF_Dia_addC( MA, len, C )    MFDia_addC( MA[0], len, C )
  152.  
  153. #define MF_Row_addV( MA, ht, len, iRow, X ) \
  154.                                      MFRow_addV( MA[0], ht, len, iRow, X )
  155. #define MF_Col_addV( MA, ht, len, iCol, X ) \
  156.                                      MFCol_addV( MA[0], ht, len, iCol, X )
  157. #define MF_Dia_addV( MA, len, X )    MFDia_addV( MA[0], len, X )
  158.  
  159. #define MF_Row_subC( MA, ht, len, iRow, C ) \
  160.                                      MFRow_addC( MA[0], ht, len, iRow, (-C) )
  161. #define MF_Col_subC( MA, ht, len, iCol, C ) \
  162.                                      MFCol_addC( MA[0], ht, len, iCol, (-C) )
  163. #define MF_Dia_subC( MA, len, C )    MFDia_addC( MA[0], len, (-C) )
  164.  
  165. #define MF_Row_subV( MA, ht, len, iRow, X ) \
  166.                                      MFRow_subV( MA[0], ht, len, iRow, X )
  167. #define MF_Col_subV( MA, ht, len, iCol, X ) \
  168.                                      MFCol_subV( MA[0], ht, len, iCol, X )
  169. #define MF_Dia_subV( MA, len, X )    MFDia_subV( MA[0], len, X )
  170.  
  171. #define MF_Row_subrC( MA, ht, len, iRow, C ) \
  172.                                      MFRow_subrC( MA[0], ht, len, iRow, C )
  173. #define MF_Col_subrC( MA, ht, len, iCol, C ) \
  174.                                      MFCol_subrC( MA[0], ht, len, iCol, C )
  175. #define MF_Dia_subrC( MA, len, C )   MFDia_subrC( MA[0], len, C )
  176.  
  177. #define MF_Row_subrV( MA, ht, len, iRow, X ) \
  178.                                      MFRow_subrV( MA[0], ht, len, iRow, X )
  179. #define MF_Col_subrV( MA, ht, len, iCol, X ) \
  180.                                      MFCol_subrV( MA[0], ht, len, iCol, X )
  181. #define MF_Dia_subrV( MA, len, X )   MFDia_subrV( MA[0], len, X )
  182.  
  183. #define MF_Row_mulC( MA, ht, len, iRow, C ) \
  184.                                      MFRow_mulC( MA[0], ht, len, iRow, C )
  185. #define MF_Col_mulC( MA, ht, len, iCol, C ) \
  186.                                      MFCol_mulC( MA[0], ht, len, iCol, C )
  187. #define MF_Dia_mulC( MA, len, C )    MFDia_mulC( MA[0], len, C )
  188.  
  189. #define MF_Row_mulV( MA, ht, len, iRow, X ) \
  190.                                      MFRow_mulV( MA[0], ht, len, iRow, X )
  191. #define MF_Col_mulV( MA, ht, len, iCol, X ) \
  192.                                      MFCol_mulV( MA[0], ht, len, iCol, X )
  193. #define MF_Dia_mulV( MA, len, X )    MFDia_mulV( MA[0], len, X )
  194.  
  195. #define MF_Row_divC( MA, ht, len, iRow, C ) \
  196.                                      MFRow_divC( MA[0], ht, len, iRow, C )
  197. #define MF_Col_divC( MA, ht, len, iCol, C ) \
  198.                                      MFCol_divC( MA[0], ht, len, iCol, C )
  199. #define MF_Dia_divC( MA, len, C )    MFDia_divC( MA[0], len, C )
  200.  
  201. #define MF_Row_divV( MA, ht, len, iRow, X ) \
  202.                                       MFRow_divV( MA[0], ht, len, iRow, X )
  203. #define MF_Col_divV( MA, ht, len, iCol, X ) \
  204.                                       MFCol_divV( MA[0], ht, len, iCol, X )
  205. #define MF_Dia_divV( MA, len, X )     MFDia_divV( MA[0], len, X )
  206.  
  207. #define MF_Row_divrC( MA, ht, len, iRow, C ) \
  208.                                       MFRow_divrC( MA[0], ht, len, iRow, C )
  209. #define MF_Col_divrC( MA, ht, len, iCol, C ) \
  210.                                       MFCol_divrC( MA[0], ht, len, iCol, C )
  211. #define MF_Dia_divrC( MA, len, C )    MFDia_divrC( MA[0], len, C )
  212.  
  213. #define MF_Row_divrV( MA, ht, len, iRow, X ) \
  214.                                       MFRow_divrV( MA[0], ht, len, iRow, X )
  215. #define MF_Col_divrV( MA, ht, len, iCol, X ) \
  216.                                       MFCol_divrV( MA[0], ht, len, iCol, X )
  217. #define MF_Dia_divrV( MA, len, X )    MFDia_divrV( MA[0], len, X )
  218.  
  219.  
  220. /******  One-dimensional vector operations **********************
  221.          performed along all rows or all columns simultaneously,
  222.          or along the diagonal of a square matrix                */
  223.  
  224. #define MF_Rows_max( Y, MA, ht, len )     MFRows_max( Y, MA[0], ht, len )
  225. #define MF_Cols_max( Y, MA, ht, len )     MFCols_max( Y, MA[0], ht, len )
  226. #define MF_Dia_max(  MA, len )            MFDia_max(  MA[0], len )
  227. #define MF_Rows_min( Y, MA, ht, len )     MFRows_min( Y, MA[0], ht, len )
  228. #define MF_Cols_min( Y, MA, ht, len )     MFCols_min( Y, MA[0], ht, len )
  229. #define MF_Dia_min(  MA, len )            MFDia_min(  MA[0], len )
  230.  
  231. #define MF_Rows_absmax( Y, MA, ht, len )  MFRows_absmax( Y, MA[0], ht, len )
  232. #define MF_Cols_absmax( Y, MA, ht, len )  MFCols_absmax( Y, MA[0], ht, len )
  233. #define MF_Dia_absmax(  MA, len )         MFDia_absmax(  MA[0], len )
  234. #define MF_Rows_absmin( Y, MA, ht, len )  MFRows_absmin( Y, MA[0], ht, len )
  235. #define MF_Cols_absmin( Y, MA, ht, len )  MFCols_absmin( Y, MA[0], ht, len )
  236. #define MF_Dia_absmin(  MA, len )         MFDia_absmin(  MA[0], len )
  237.  
  238. #define MF_Rows_sum( Y, MA, ht, len )     MFRows_sum( Y, MA[0], ht, len )
  239. #define MF_Cols_sum( Y, MA, ht, len )     MFCols_sum( Y, MA[0], ht, len )
  240. #define MF_Dia_sum(  MA, len )            MFDia_sum(  MA[0], len )
  241. #define MF_Rows_prod( Y, MA, ht, len )    MFRows_prod( Y, MA[0], ht, len )
  242. #define MF_Cols_prod( Y, MA, ht, len )    MFCols_prod( Y, MA[0], ht, len )
  243. #define MF_Dia_prod(  MA, len )           MFDia_prod( MA[0], len )
  244.  
  245. #define MF_Rows_runsum( MA, ht, len )     MFRows_runsum( MA[0], ht, len )
  246. #define MF_Cols_runsum( MA, ht, len )     MFCols_runsum( MA[0], ht, len )
  247. #define MF_Rows_runprod( MA, ht, len )    MFRows_runprod( MA[0], ht, len )
  248. #define MF_Cols_runprod( MA, ht, len )    MFCols_runprod( MA[0], ht, len )
  249.  
  250. #define MF_Rows_rotate( MA, ht, len, pos) MFRows_rotate( MA[0], ht, len, pos )
  251. #define MF_Cols_rotate( MA, ht, len, pos) MFCols_rotate( MA[0], ht, len, pos )
  252. #define MF_Rows_reflect( MA, ht, len)     MFRows_reflect( MA[0], ht, len )
  253. #define MF_Cols_reflect( MA, ht, len)     MFCols_reflect( MA[0], ht, len )
  254.  
  255. /********  Operations involving two rows or two colums of one matrix  *****/
  256.  
  257. #define MF_Rows_exchange( MA, ht, len, row1, row2 ) \
  258.                              MFRows_exchange( MA[0], ht, len, row1, row2 )
  259. #define MF_Cols_exchange( MA, ht, len, col1, col2 ) \
  260.                              MFCols_exchange( MA[0], ht, len, col1, col2 )
  261.  
  262. #define MF_Rows_add( MA, ht, len, destRow, srceRow ) \
  263.                              MFRows_add( MA[0], ht, len, destRow, srceRow )
  264. #define MF_Cols_add( MA, ht, len, destCol, srceCol ) \
  265.                              MFCols_add( MA[0], ht, len, destCol, srceCol )
  266.                          /* dest[i] += source[i]  */
  267.  
  268. #define MF_Rows_sub( MA, ht, len, destRow, srceRow ) \
  269.                              MFRows_sub( MA[0], ht, len, destRow, srceRow )
  270. #define MF_Cols_sub( MA, ht, len, destCol, srceCol ) \
  271.                              MFCols_sub( MA[0], ht, len, destCol, srceCol )
  272.                          /* dest[i] -= source[i]  */
  273.  
  274. #define MF_Rows_Cadd( MA, ht, len, destRow, srceRow, C ) \
  275.                           MFRows_Cadd( MA[0], ht, len, destRow, srceRow, C )
  276. #define MF_Cols_Cadd( MA, ht, len, destCol, srceCol, C ) \
  277.                           MFCols_Cadd( MA[0], ht, len, destCol, srceCol, C )
  278.                          /* dest[i] += C * source[i]  */
  279.  
  280. #define MF_Rows_lincomb( MA, ht, len, destRow, destC, srceRow, srceC ) \
  281.             MFRows_lincomb( MA[0], ht, len, destRow, destC, srceRow, srceC )
  282. #define MF_Cols_lincomb( MA, ht, len, destCol, destC, srceCol, srceC ) \
  283.             MFCols_lincomb( MA[0], ht, len, destCol, destC, srceCol, srceC )
  284.   /*  linear combination: dest[i] = destC * dest[i] + sourceC * source[i] */
  285.  
  286.  
  287. /*************************  Transposing a matrix **********************/
  288.  
  289. #define MF_transpose( MTr, MA, htTr, lenTr ) \
  290.              MFtranspose( MTr[0], MA[0], htTr, lenTr )
  291.        /*  dimensions htTr, lenTr are those of the transposed matrix,
  292.            not of the original!                */
  293.  
  294.  
  295. /************************ Matrix Arithmetics *************************/
  296.  
  297. #define MF_addM( MC, MA, MB, htA, lenA ) \
  298.                  VF_addV( MC[0], MA[0], MB[0], ((ui)htA)*lenA )
  299. #define MF_subM( MC, MA, MB, htA, lenA ) \
  300.                  VF_subV( MC[0], MA[0], MB[0], ((ui)htA)*lenA )
  301. #define MF_mulC( MB, MA, htA, lenA, C ) \
  302.                  VF_mulC( MB[0], MA[0], ((ui)htA)*lenA, C )
  303. #define MF_divC( MB, MA, htA, lenA, C ) \
  304.                  VF_divC( MB[0], MA[0], ((ui)htA)*lenA, C )
  305. #define MFs_addM( MC, MA, MB, htA, lenA, C ) \
  306.                  VFs_addV( MC[0], MA[0], MB[0], ((ui)htA)*lenA, C )
  307. #define MFs_subM( MC, MA, MB, htA, lenA, C ) \
  308.                  VFs_subV( MC[0], MA[0], MB[0], ((ui)htA)*lenA, C )
  309. #define MF_lincomb( MC, MA, MB, htA, lenA, CA, CB ) \
  310.                  VF_lincomb( MC[0], MA[0], MB[0], ((ui)htA)*lenA, CA, CB )
  311.  
  312. #define MF_mulV( Y, MA, X, htA, lenA ) \
  313.                     MFmulV( Y, MA[0], X, htA, lenA )
  314.                           /*  Y = MA * X.  sizX=lenA, sizY=htA
  315.                               both X and Y are column-vectors    */
  316. #define VF_mulM( Y, X, MA, sizX, lenA ) \
  317.                     VFmulM( Y, X, MA[0], sizX, lenA )
  318.                          /*  Y = X * MA.  htA=sizX, sizY=lenA
  319.                              both X and Y are row-vectors.
  320.                              Mind the prefix: VF_ (not MF_)    */
  321. #define MF_mulM( MC, MA, MB, htA, lenA, lenB ) \
  322.                     MFmulM( MC[0], MA[0], MB[0], htA, lenA, lenB )
  323.                          /*  MC = MA * MB.  htB=lenA, htC=htA, lenC=lenB */
  324.  
  325.  
  326. /*************************  Linear Algebra    *****************************/
  327.  
  328.    /*  The standard treatment of linear systems is based
  329.        on LUD (matrix decomposition into Upper-triangular
  330.        and Lower-triangular components). The result of the
  331.        decomposition step is used for further operations.  */
  332.  
  333. #define MF_LUdecompose( MLU, Ind, MA, len ) \
  334.                     MFLUdecompose( MLU[0], Ind, MA[0], len )
  335.             /* returns "permut" = +-1 which is needed for MF_LUdet.
  336.                for singularities not cured by editing, permut is 0  */
  337. int     __vf MF_LUDresult( void );
  338.     /* returns 0, if MF_LUdecompose was successful;
  339.        returns 1, if MA was (nearly) singular in MF_LUdecompose.   */
  340. void    __vf MF_LUDsetEdit( float Thresh );
  341. float   __vf MF_LUDgetEdit( void );
  342.      /*  Editing threshold valid for MF_LUdecompose;
  343.          may be used to cure singularities           */
  344.  
  345. #define MF_LUsolve( X, MLU, B, Ind, len ) \
  346.                     MFLUsolve( X, MLU[0], B, Ind, len )
  347. #define MF_LUinv( MInv, MLU, Ind, len ) \
  348.                     MFLUinv( MInv[0], MLU[0], Ind, len )
  349. #define MF_LUdet( MLU, len, permut ) MFLUdet( MLU[0], len, permut )
  350. #define MF_LUimprove( X, B, MA, MLU, Ind, len ) \
  351.                       MFLUimprove( X, B, MA[0], MLU[0], Ind, len )
  352.  
  353.     /****  Special treatment of over- or under-determined
  354.            linear systems, i.e. of matrices with len != ht
  355.            and of singular matrices:
  356.            SVD (Singular Value Decomposition)       ****/
  357.  
  358. #define MF_SVdecompose( MU, MV, W, MA, htA, lenA ) \
  359.                     MFSVdecompose( MU[0], MV[0], W, MA[0], htA, lenA )
  360.             /*  sizB = htA,  sizX = sizW = htV = lenV = lenA  */
  361. #define MF_SVsolve( X, MU, MV, W, B, htU, lenU ) \
  362.                     MFSVsolve( X, MU[0], MV[0], W, B, htU, lenU )
  363.             /*  lenU = lenA,  htU = max( lenA, htA ) as fed into
  364.                 MD_SVdecompose   */
  365. #define MF_SVimprove( X, B, MA, MU, MV, W, htA, lenA ) \
  366.                     MFSVimprove( X, B, MA[0], MU[0], MV[0], W, htA, lenA )
  367. void    __vf MF_SVDsetEdit( float Thresh );
  368. float   __vf MF_SVDgetEdit( void );
  369.     /* Override of the standard values for editing threshholds
  370.        in MF_SVsolve. Calling MF_setEdit with Thresh=0.0 means
  371.        that you do the necessary editing of W yourself
  372.        before calling MD_SVsolve                           */
  373.  
  374.  /*****  "Easy-to-use" versions of the matrix functions
  375.           using LUD or SVD.
  376.           They allocate their own working space and rely
  377.           on your setting of the editing threshold. In
  378.           case of memory stress, you should better use the
  379.           two-step methods declared above.            ***/
  380. #define MF_solve( X, MA, B, len ) \
  381.                     MFsolve( X, MA[0], B, len )
  382. #define MF_inv( MInv, MA, len ) \
  383.                     MFinv( MInv[0], MA[0], len )
  384. #define MF_det(  MA, len ) \
  385.                     MFdet( MA[0], len )
  386. #define MF_solveBySVD( X, MA, B, ht, len ) \
  387.                     MFsolveBySVD( X, MA[0], B, ht, len )
  388.          /*  sizX = len,  sizB = ht  */
  389. #define MF_safeSolve( X, MA, B, len ) \
  390.                     MFsafeSolve( X, MA[0], B, len )
  391.         /* MF_safeSolve tries first LUD. If that fails, SVD is done.
  392.            X[i] will be 0.0 instead of INF for those i corresponding
  393.            to singularities. If even SVD fails, all X[i] are set to 0.0.
  394.            return value 0: success via LUD; 1: success via SVD; -1: failure */
  395.  
  396.       /*********  Eigenvalues and Eigenvectors  ********/
  397.       /*** only the most frequent case of symmetric real matrices
  398.            is covered here! *********/
  399.  
  400. #define MFsym_eigenvalues( EigV, EigM, MA, len, CalcEigenVec ) \
  401.                     MFs_eigenvalues( EigV, EigM[0], MA[0], len, CalcEigenVec )
  402.                         /*  Eigenvalues are returned in EigV.
  403.                             CalcEigenVec = 0 means that only eigenvalues
  404.                             are needed; CalcEigenVec != 0 means that
  405.                             also eigenvectors are calculated. If so,
  406.                             eigenvectors are returned as the columns of EigM.
  407.                             Even if eigenvectors are not desired, EigM is
  408.                             needed by the function as working-space. Then, on
  409.                             output, it will contain just rubbish.
  410.                             MA may be overwritten by EigM. */
  411.  
  412. /***************** Two-Dimensional Fourier-Transform Methods ************/
  413.  
  414. #if defined __cplusplus && defined _CMATH_CLASSDEFS
  415. } // following function cannot be extern "C"
  416. #endif
  417. fComplex  __vf   VF_getRspEdit( void );
  418. #if defined __cplusplus && defined _CMATH_CLASSDEFS
  419. extern "C" {
  420. #endif
  421. void      __vf   VF_setRspEdit( fComplex Trunc );
  422.            /* these are the same functions as used
  423.               in the one-dimensional case */
  424.  
  425. #define MFl_FFT( MY, MX, ht, len, dir )     MFlFFT( MY[0], MX[0], ht, len, dir )
  426. #define MFs_FFT( MY, MX, ht, len, dir )     MFsFFT( MY[0], MX[0], ht, len, dir )
  427. #define MFl_convolve( MY, MFlt, MX, MRsp, ht, len ) \
  428.                   MFlconvolve( MY[0], MFlt[0], MX[0], MRsp[0], ht, len )
  429. #define MFl_deconvolve( MY, MFlt, MX, MRsp, ht, len ) \
  430.                   MFldeconvolve( MY[0], MFlt[0], MX[0], MRsp[0], ht, len )
  431. #define MFl_filter( MY, MX, MFlt, ht, len ) MFlfilter( MY[0], MX[0], MFlt[0], ht, len )
  432. #define MFl_autocorr( MACorr, MX, ht, len ) MFlautocorr( MACorr[0], MX[0], ht, len )
  433. #define MFl_xcorr( MXCorr, MX, MY, ht, len) MFlxcorr( MXCorr[0], MX[0], MY[0], ht, len )
  434. #define MFl_spectrum( MSpec, htSpec, lenSpec, MX, htX, lenX, MWin ) \
  435.               MFlspectrum( MSpec[0], htSpec, lenSpec, MX[0], htX, lenX, MWin[0] )
  436.                   /* htSpec, lenSpec must be 2**n,
  437.                      MSpec must be a (htSpec+1)*(lenSpec+1) matrix!!
  438.                      htX >= n*htSpec,  lenX >= n*lenSpec,
  439.                      htWin = 2*htSpec, lenWin = 2*lenSpec */
  440.  
  441. #define MFs_convolve( MY, MFlt, MX, MRsp, ht, len ) \
  442.                   MFsconvolve( MY[0], MFlt[0], MX[0], MRsp[0], ht, len )
  443. #define MFs_deconvolve( MY, MFlt, MX, MRsp, ht, len ) \
  444.                   MFsdeconvolve( MY[0], MFlt[0], MX[0], MRsp[0], ht, len )
  445. #define MFs_filter( MY, MX, MFlt, ht, len ) MFsfilter( MY[0], MX[0], MFlt[0], ht, len )
  446. #define MFs_autocorr( MACorr, MX, ht, len ) MFsautocorr( MACorr[0], MX[0], ht, len )
  447. #define MFs_xcorr( MXCorr, MX, MY, ht, len) MFsxcorr( MXCorr[0], MX[0], MY[0], ht, len )
  448. #define MFs_spectrum( MSpec, htSpec, lenSpec, MX, htX, lenX, MWin ) \
  449.               MFsspectrum( MSpec[0], htSpec, lenSpec, MX[0], htX, lenX, MWin[0] )
  450.                 /*   htSpec, lenSpec must be 2**n,
  451.                      MSpec has [htSpec+1][lenSpec+1] elements (!)
  452.                      htX >= n*htSpec,  lenX >= n*lenSpec,
  453.                      htWin = 2*htSpec, lenWin = 2*lenSpec     */
  454.  
  455. #if defined( __LARGE__ ) || defined( __COMPACT__ ) || defined ( __HUGE__ )
  456.    #define MF_FFT         MFl_FFT
  457.    #define MF_convolve    MFl_convolve
  458.    #define MF_deconvolve  MFl_deconvolve
  459.    #define MF_filter      MFl_filter
  460.    #define MF_autocorr    MFl_autocorr
  461.    #define MF_xcorr       MFl_xcorr
  462.    #define MF_spectrum    MFl_spectrum
  463. #else
  464.    #define MF_FFT         MFs_FFT
  465.    #define MF_convolve    MFs_convolve
  466.    #define MF_deconvolve  MFs_deconvolve
  467.    #define MF_filter      MFs_filter
  468.    #define MF_autocorr    MFs_autocorr
  469.    #define MF_xcorr       MFs_xcorr
  470.    #define MF_spectrum    MFs_spectrum
  471. #endif
  472.  
  473.  
  474. /************************** Data Fitting *********************************
  475.  
  476.   Notice that some of these functions have the prefix VF_, others MF_.
  477.   This depends on the form in which the data to be fitted are recorded:
  478.   vectors are fitted by the VF_ functions, matrices by the MF_ functions.
  479.   All of these functions employ matrix methods internally. The weighted
  480.   versions return covariances in a matrix "Covar". So they are all
  481.   contained in MatrixLib and declared here.
  482. */
  483.  
  484. void __vf VF_polyfit( fVector A, unsigned deg, fVector X, fVector Y, ui sizex );
  485. #define   VF_polyfitwW( A, Covar, deg, X, Y, InvVar, sizex ) \
  486.           VFpolyfitwW( A, Covar[0], deg, X, Y, InvVar, sizex )
  487.        /* the size of A is deg+1 and Covar has [deg+1][deg+1] elements! */
  488.  
  489. void __vf VF_linfit( fVector A, iVector AStatus, unsigned npars,
  490.                      fVector X, fVector Y, ui sizex,
  491.                      void (*funcs)(fVector BasFuncs, float x, unsigned nfuncs) );
  492. #define   VF_linfitwW( A, Covar, AStatus, npars, X, Y, InvVar, sizex, funcs ) \
  493.           VFlinfitwW( A, Covar[0], AStatus, npars, X, Y, InvVar, sizex, funcs )
  494. #define   MF_linfit( A, AStatus, npars, X, Y, MZ, htZ, lenZ, funcs ) \
  495.           MFlinfit( A, AStatus, npars, X, Y, MZ[0], htZ, lenZ, funcs )
  496. #define   MF_linfitwW( A, Covar, AStatus, npars, X, Y, MZ, MInvVar, htZ, lenZ, funcs ) \
  497.           MFlinfitwW( A, Covar[0], AStatus, npars, X, Y, MZ[0], MInvVar[0], htZ, lenZ, funcs )
  498.  
  499. void  __vf VF_setLinfitNeglect( float Thresh );
  500.                    /* neglect A[i]=0, if significance smaller than Thresh */
  501. float __vf VF_getLinfitNeglect( void );
  502.  
  503. float __vf VF_nonlinfit( fVector A, iVector AStatus, unsigned npars,
  504.                          fVector X, fVector Y, ui sizex,
  505.                          void (*modelfunc)(fVector YModel, fVector XModel, ui size),
  506.                          void (*derivatives)(fVector dYdAi,fVector X, ui size, unsigned iPar) );
  507.             /* returns figure-of-merit of best A. If you don't know the partial
  508.                derivatives with respect to A, call with derivatives=NULL */
  509. #define   VF_nonlinfitwW( A, Covar, AStatus, npars, X, Y, InvVar, sizex, modelfunc, deriv ) \
  510.           VFnonlinfitwW( A, Covar[0], AStatus, npars, X, Y, InvVar, sizex, modelfunc, deriv )
  511. #define   MF_nonlinfit( A, AStatus, npars, X, Y, MZ, htZ, lenZ, modelfunc, deriv ) \
  512.           MFnonlinfit( A, AStatus, npars, X, Y, MZ[0], htZ, lenZ, modelfunc, deriv )
  513. #define   MF_nonlinfitwW( A, Covar, AStatus, npars, X, Y, MZ, MInvVar, htZ, lenZ, modelfunc, deriv ) \
  514.           MFnonlinfitwW( A, Covar[0], AStatus, npars, X, Y, MZ[0], MInvVar[0], htZ, lenZ, modelfunc, deriv )
  515.  
  516.         /* If you know some partial derivatives, you may call these functions
  517.            for those parameters for which you do not know them:           */
  518. void     __vf VF_nonlinfit_autoDeriv( fVector dYdAi, fVector X, ui size, unsigned ipar );
  519. void     __vf VF_nonlinfitwW_autoDeriv( fVector dYdAi, fVector X, ui size, unsigned ipar );
  520. void     __vf MF_nonlinfit_autoDeriv( fMatrix dZdAi, unsigned htZ, unsigned lenZ, fVector X, fVector Y, unsigned ipar );
  521. void     __vf MF_nonlinfitwW_autoDeriv( fMatrix dZdAi, unsigned htZ, unsigned lenZ, fVector X, fVector Y, unsigned ipar );
  522.        /* The following functions allow to monitor the progress of
  523.           a nonlinear fitting procedure or to manually stop it:     */
  524. float    __vf VF_nonlinfit_getChi2( void );
  525. float    __vf VF_nonlinfitwW_getChi2( void );
  526. float    __vf MF_nonlinfit_getChi2( void );
  527. float    __vf MF_nonlinfitwW_getChi2( void );
  528. void     __vf VF_nonlinfit_getBestA( fVector ABest );
  529. void     __vf VF_nonlinfitwW_getBestA( fVector ABest );
  530. void     __vf MF_nonlinfit_getBestA( fVector ABest );
  531. void     __vf MF_nonlinfitwW_getBestA( fVector ABest );
  532. unsigned __vf VF_nonlinfit_getTestRun( void );
  533. unsigned __vf VF_nonlinfitwW_getTestRun( void );
  534. unsigned __vf MF_nonlinfit_getTestRun( void );
  535. unsigned __vf MF_nonlinfitwW_getTestRun( void );
  536. unsigned __vf VF_nonlinfit_getTestPar( void );
  537. unsigned __vf VF_nonlinfitwW_getTestPar( void );
  538. unsigned __vf MF_nonlinfit_getTestPar( void );
  539. unsigned __vf MF_nonlinfitwW_getTestPar( void );
  540. int      __vf VF_nonlinfit_getTestDir( void );
  541. int      __vf VF_nonlinfitwW_getTestDir( void );
  542. int      __vf MF_nonlinfit_getTestDir( void );
  543. int      __vf MF_nonlinfitwW_getTestDir( void );
  544. void     __vf VF_nonlinfit_stop( void );
  545. void     __vf VF_nonlinfitwW_stop( void );
  546. void     __vf MF_nonlinfit_stop( void );
  547. void     __vf MF_nonlinfitwW_stop( void );
  548.  
  549. #ifdef __BORLANDC__
  550.     #pragma option -a-  /* avoid insertion of dummy bytes */
  551. #else   /* MS Visual C++ */
  552.     #pragma pack(push,1)
  553. #endif    /*  Borland or Microsoft */
  554. typedef struct VF_NONLINFITOPTIONS
  555. {
  556.       int        FigureOfMerit;  /*  0:least squares, 1:robust */
  557.              /* Convergence conditions: if the changes achieved
  558.                 in successive iterations are lower than any of the
  559.                 following values, this signals convergence. Set
  560.                 criteria to 0.0, if not applicable              */
  561.       float      AbsTolChi,  /* absolute change of chi */
  562.                  FracTolChi, /* fractional change of chi */
  563.                  AbsTolPar,  /* absolute change of all parameters */
  564.                  FracTolPar; /* fractional change of all parameters */
  565.       unsigned   HowOftenFulfill; /* how often fulfill the above conditions? */
  566.       unsigned   LevelOfMethod;  /* 1: Levenberg-Marquardt method,
  567.                                     2: Downhill Simplex (Nelder and Mead) method,
  568.                                     3: both methods alternating;
  569.                                        add 4 to this in order to try
  570.                                        breaking out of local minima;
  571.                                     0: no fit, calculate only chi2 (and Covar) */
  572.       unsigned   LevMarIterations; /* max.number of successful iterations of LevMar */
  573.       unsigned   LevMarStarts; /* number of starts per LevMar run */
  574.       float      LambdaStart,
  575.                  LambdaMin, LambdaMax,
  576.                  LambdaDiv, LambdaMul;    /* LevMar parameter lambda */
  577.       unsigned   DownhillIterations; /* max.number of successful iterations in Downhill */
  578.       float      DownhillReflection,  /* re-shaping of the simplex */
  579.                  DownhillContraction,
  580.                  DownhillExpansion;
  581.       unsigned   TotalStarts;  /* max. number of LevMar/Downhill pairs */
  582.       fVector    UpperLimits;  /* impose upper limits on parameters */
  583.       fVector    LowerLimits;  /* impose lower limits on parameters */
  584.       void       (*Restrictions)(void);  /* user-defined editing of parameters */
  585. }  VF_NONLINFITOPTIONS;
  586.  
  587. void __vf VF_setNonlinfitOptions( VF_NONLINFITOPTIONS _VFAR *Options );
  588. void __vf VF_getNonlinfitOptions( VF_NONLINFITOPTIONS _VFAR *Options );
  589.  
  590. typedef struct VF_EXPERIMENT
  591. {
  592.     fVector X, Y, InvVar;
  593.     ui      size;
  594.     float   WeightOfExperiment;
  595.      /* InvVar and WeightOfExperiment are needed only for the
  596.         weighted variants of the multifit functions */
  597. } VF_EXPERIMENT;
  598.  
  599. typedef struct MF_EXPERIMENT
  600. {
  601.     fVector   X, Y;
  602.     fMatrix   MZ, MInvVar;  /* here no compatibility with static matrices! */
  603.     unsigned  htZ, lenZ;
  604.     float     WeightOfExperiment;
  605.      /* MInvVar and WeightOfExperiment are needed only for the
  606.         weighted variants of the multifit functions */
  607. } MF_EXPERIMENT;
  608. #ifdef __BORLANDC__
  609.     #pragma option -a.   /* restore default data packing  */
  610. #else   /* MS Visual C++ */
  611.     #pragma pack(pop)
  612. #endif
  613.  
  614.  
  615. void __vf VF_multiLinfit( fVector A, iVector AStatus, unsigned ma,
  616.                 VF_EXPERIMENT _VFAR *ListOfExperiments, unsigned nexperiments,
  617.                 void (*funcs)(fVector BasFuncs, float x,
  618.                               unsigned nfuncs, unsigned iexperiment) );
  619. #define   VF_multiLinfitwW( A, Covar, AStatus, npars, ListOfEx, nexp, funcs ) \
  620.           VFmultiLinfitwW( A, Covar[0], AStatus, npars, ListOfEx, nexp, funcs )
  621. void __vf MF_multiLinfit( fVector A, iVector AStatus, unsigned ma,
  622.                 MF_EXPERIMENT _VFAR *ListOfExperiments, unsigned nexperiments,
  623.                 void (*funcs)(fVector BasFuncs, float x, float y,
  624.                               unsigned nfuncs, unsigned iexperiment) );
  625. #define   MF_multiLinfitwW( A, Covar, AStatus, npars, ListOfEx, nexp, funcs ) \
  626.           MFmultiLinfitwW( A, Covar[0], AStatus, npars, ListOfEx, nexp, funcs )
  627. float __vf VF_multiNonlinfit( fVector A, iVector AStatus, unsigned npars,
  628.                 VF_EXPERIMENT _VFAR *ListOfExperiments, unsigned nexperiments,
  629.                 void (*modelfunc)(fVector YModel, fVector XModel,
  630.                                   ui size, unsigned iexperiment),
  631.                 void (*derivatives)(fVector dYdAi,fVector X, ui size,
  632.                                   unsigned ipar, unsigned iexperiment) );
  633.             /* returns figure-of-merit of best A. If you don't know the
  634.                partial derivatives, set derivatives=NULL */
  635. #define   VF_multiNonlinfitwW( A, Covar, AStatus, npars, ListOfEx, nexp, modfunc, deriv ) \
  636.           VFmultiNonlinfitwW( A, Covar[0], AStatus, npars, ListOfEx, nexp, modfunc, deriv )
  637. float __vf MF_multiNonlinfit( fVector A, iVector AStatus, unsigned npars,
  638.                 MF_EXPERIMENT _VFAR *ListOfExperiments, unsigned nexperiments,
  639.                 void (*modelfunc)(fMatrix MZModel, unsigned htZ, unsigned lenZ,
  640.                                   fVector X, fVector Y, unsigned iexperiment),
  641.                 void (*derivatives)(fMatrix dZdAi, unsigned htZ, unsigned lenZ,
  642.                                     fVector X, fVector Y, unsigned ipar,
  643.                                     unsigned iexperiment) );
  644. #define   MF_multiNonlinfitwW( A, Covar, AStatus, npars, ListOfEx, nexp, modfunc, deriv ) \
  645.           MFmultiNonlinfitwW( A, Covar[0], AStatus, npars, ListOfEx, nexp, modfunc, deriv )
  646.  
  647. void  __vf VF_multiNonlinfit_autoDeriv( fVector dYdAi, fVector X, ui size,
  648.                                        unsigned iexperiment, unsigned ipar );
  649. void  __vf VF_multiNonlinfitwW_autoDeriv( fVector dYdAi, fVector X, ui size,
  650.                                        unsigned iexperiment, unsigned ipar );
  651. void  __vf MF_multiNonlinfit_autoDeriv( fMatrix dZdAi, unsigned htZ, unsigned lenZ,
  652.                                     fVector X, fVector Y,
  653.                                     unsigned ipar, unsigned iexperiment );
  654. void  __vf MF_multiNonlinfitwW_autoDeriv( fMatrix dZdAi, unsigned htZ, unsigned lenZ,
  655.                                     fVector X, fVector Y,
  656.                                     unsigned ipar, unsigned iexperiment );
  657. float    __vf VF_multiNonlinfit_getChi2( void );
  658. float    __vf VF_multiNonlinfitwW_getChi2( void );
  659. float    __vf MF_multiNonlinfit_getChi2( void );
  660. float    __vf MF_multiNonlinfitwW_getChi2( void );
  661. void     __vf VF_multiNonlinfit_getBestA( fVector ABest );
  662. void     __vf VF_multiNonlinfitwW_getBestA( fVector ABest );
  663. void     __vf MF_multiNonlinfit_getBestA( fVector ABest );
  664. void     __vf MF_multiNonlinfitwW_getBestA( fVector ABest );
  665. unsigned __vf VF_multiNonlinfit_getTestRun( void );
  666. unsigned __vf VF_multiNonlinfitwW_getTestRun( void );
  667. unsigned __vf MF_multiNonlinfit_getTestRun( void );
  668. unsigned __vf MF_multiNonlinfitwW_getTestRun( void );
  669. unsigned __vf VF_multiNonlinfit_getTestPar( void );
  670. unsigned __vf VF_multiNonlinfitwW_getTestPar( void );
  671. unsigned __vf MF_multiNonlinfit_getTestPar( void );
  672. unsigned __vf MF_multiNonlinfitwW_getTestPar( void );
  673. int      __vf VF_multiNonlinfit_getTestDir( void );
  674. int      __vf VF_multiNonlinfitwW_getTestDir( void );
  675. int      __vf MF_multiNonlinfit_getTestDir( void );
  676. int      __vf MF_multiNonlinfitwW_getTestDir( void );
  677. void     __vf VF_multiNonlinfit_stop( void );
  678. void     __vf VF_multiNonlinfitwW_stop( void );
  679. void     __vf MF_multiNonlinfit_stop( void );
  680. void     __vf MF_multiNonlinfitwW_stop( void );
  681.  
  682. /**************************  Input and Output  **************************/
  683.  
  684. #define MF_fprint( stream, MA, ht, len, linewidth ) \
  685.                     MFfprint( stream, MA[0], ht, len, linewidth )
  686. #define MF_print( MA, ht, len )  MFfprint( stdout, MA[0], ht, len, 80 )
  687. #define MF_cprint( MA, ht, len ) MFcprint( MA[0], ht, len )
  688.   /*  MF_print, MF_cprint usable only for DOS, EasyWin, and Win32 console applications! */
  689.  
  690. #define MF_write( str, MA, ht, len )   MFwrite( str, MA[0], ht, len )
  691. #define MF_read( MA, ht, len, str )    MFread( MA[0], ht, len, str )
  692. #define MF_setWriteFormat              VF_setWriteFormat
  693. #define MF_setWriteSeparate            VF_setNWriteSeparate
  694.                                    /* write and read in ascii format */
  695. #define MF_store( str, MA, ht, len ) \
  696.                            VF_store( str, MA[0], ((ui) (len))*(ht) );
  697. #define MF_recall( MA, ht, len, str) \
  698.                            VF_recall( MA[0], ((ui) (len))*(ht), str);
  699.                                   /* store and recall in binary format */
  700.  
  701.  
  702. /*************************************************************************
  703.  * Here are now the actual declarations of the functions used internally.*
  704.  * These declarations may change in future versions of MatrixLib!        *
  705.  * You should not care too much about them, except in the case you need  *
  706.  * the actual address of a run-time function (see above). Under all      *
  707.  * "normal" circumstances, use only the names defined above in the       *
  708.  * macro section!                                                        *
  709.  *************************************************************************/
  710.  
  711. float _VFAR * MFPelement( fPMatrix X, unsigned ht, unsigned len,
  712.                           unsigned m, unsigned n );
  713.                   /* pointer is normalized in memory model HUGE */
  714.  
  715. #define MFequ0( MA, ht, len )            VF_equ0( MA, ((ui)ht)*len )
  716. void   __vf  MFequ1( fPMatrix MA, unsigned len );  /* identity matrix */
  717. void   __vf  MFouterprod( fPMatrix MA, fVector X,  fVector Y,
  718.                           unsigned ht, unsigned len );
  719.  
  720. void   __vf  MFRow_equC( fPMatrix MA, unsigned ht, unsigned len,
  721.                          unsigned iRow, float C );
  722. void   __vf  MFCol_equC( fPMatrix MA, unsigned ht, unsigned len,
  723.                          unsigned iCol, float C );
  724. void   __vf  MFDia_equC( fPMatrix MA, unsigned len, float C );
  725.  
  726. void   __vf  MFRow_equV( fPMatrix MA, unsigned ht, unsigned len,
  727.                          unsigned iRow, fVector X );
  728. void   __vf  MFCol_equV( fPMatrix MA, unsigned ht, unsigned len,
  729.                          unsigned iCol, fVector X );
  730. void   __vf  MFDia_equV( fPMatrix MA, unsigned len, fVector X );
  731.  
  732. #define MFequM( MB, MA, ht, len )  VF_equV( MB, MA, (ui)(ht)*(len) )
  733. void   __vf  MFUequL( fPMatrix MA, unsigned len );
  734. void   __vf  MFLequU( fPMatrix MA, unsigned len );
  735.  
  736. void   __vf  MFHanning( fPMatrix MA, unsigned ht, unsigned len );
  737. void   __vf  MFParzen(  fPMatrix MA, unsigned ht, unsigned len );
  738. void   __vf  MFWelch(   fPMatrix MA, unsigned ht, unsigned len );
  739.  
  740. /********  Extracting a submatrix and copying a submatrix back  *********/
  741.  
  742. void  __vf  MFsubmatrix( fPMatrix MSub,
  743.                           unsigned subHt,  unsigned subLen,
  744.                           fPMatrix MSrce,
  745.                           unsigned srceHt,  unsigned srceLen,
  746.                           unsigned firstRowInCol,  unsigned sampInCol,
  747.                           unsigned firstColInRow,  unsigned sampInRow );
  748.  
  749. void  __vf  MFsubmatrix_equM( fPMatrix MDest,
  750.                                unsigned destHt,     unsigned destLen,
  751.                                unsigned firstRowInCol,  unsigned sampInCol,
  752.                                unsigned firstColInRow,  unsigned sampInRow,
  753.                                fPMatrix MSrce,
  754.                                unsigned srceHt,     unsigned srceLen );
  755.  
  756.  
  757. /*****   Extracting a single row or a single column or the diagonal  *****
  758.  *       and storing it into a vector                                    */
  759.  
  760. void __vf MFRow_extract( fVector Y, fPMatrix MA, unsigned ht, unsigned len,
  761.                            unsigned iRow );
  762. void __vf MFCol_extract( fVector Y, fPMatrix MA, unsigned ht, unsigned len,
  763.                            unsigned iCol );
  764. void __vf MFDia_extract( fVector Y, fPMatrix MA, unsigned len );
  765.  
  766.  
  767. /*****************    Basic arithmetic operations ***********************
  768.      performed on one single row,  or one single column of any matrix,
  769.      or on the diagonal of a square matrix                              */
  770.  
  771. void   __vf  MFRow_addC( fPMatrix MA, unsigned ht, unsigned len,
  772.                          unsigned iRow, float C );
  773. void   __vf  MFCol_addC( fPMatrix MA, unsigned ht, unsigned len,
  774.                          unsigned iCol, float C );
  775. void   __vf  MFDia_addC( fPMatrix MA, unsigned len, float C );
  776.  
  777. void   __vf  MFRow_subC( fPMatrix MA, unsigned ht, unsigned len,
  778.                          unsigned iRow, float C );
  779. void   __vf  MFCol_subC( fPMatrix MA, unsigned ht, unsigned len,
  780.                          unsigned iCol, float C );
  781. void   __vf  MFDia_subC( fPMatrix MA, unsigned len, float C );
  782.  
  783. void   __vf  MFRow_addV( fPMatrix MA, unsigned ht, unsigned len,
  784.                          unsigned iRow, fVector X );
  785. void   __vf  MFCol_addV( fPMatrix MA, unsigned ht, unsigned len,
  786.                          unsigned iCol, fVector X );
  787. void   __vf  MFDia_addV( fPMatrix MA, unsigned len, fVector X );
  788.  
  789. void   __vf  MFRow_subV( fPMatrix MA, unsigned ht, unsigned len,
  790.                          unsigned iRow, fVector X );
  791. void   __vf  MFCol_subV( fPMatrix MA, unsigned ht, unsigned len,
  792.                          unsigned iCol, fVector X );
  793. void   __vf  MFDia_subV( fPMatrix MA, unsigned len, fVector X );
  794.  
  795. void   __vf  MFRow_subrC( fPMatrix MA, unsigned ht, unsigned len,
  796.                          unsigned iRow, float C );
  797. void   __vf  MFCol_subrC( fPMatrix MA, unsigned ht, unsigned len,
  798.                          unsigned iCol, float C );
  799. void   __vf  MFDia_subrC( fPMatrix MA, unsigned len, float C );
  800.  
  801. void   __vf  MFRow_subrV( fPMatrix MA, unsigned ht, unsigned len,
  802.                          unsigned iRow, fVector X );
  803. void   __vf  MFCol_subrV( fPMatrix MA, unsigned ht, unsigned len,
  804.                          unsigned iCol, fVector X );
  805. void   __vf  MFDia_subrV( fPMatrix MA, unsigned len, fVector X );
  806.  
  807. void   __vf  MFRow_mulC( fPMatrix MA, unsigned ht, unsigned len,
  808.                          unsigned iRow, float C );
  809. void   __vf  MFCol_mulC( fPMatrix MA, unsigned ht, unsigned len,
  810.                          unsigned iCol, float C );
  811. void   __vf  MFDia_mulC( fPMatrix MA, unsigned len, float C );
  812.  
  813. void   __vf  MFRow_mulV( fPMatrix MA, unsigned ht, unsigned len,
  814.                          unsigned iRow, fVector X );
  815. void   __vf  MFCol_mulV( fPMatrix MA, unsigned ht, unsigned len,
  816.                          unsigned iCol, fVector X );
  817. void   __vf  MFDia_mulV( fPMatrix MA, unsigned len, fVector X );
  818.  
  819. void   __vf  MFRow_divC( fPMatrix MA, unsigned ht, unsigned len,
  820.                          unsigned iRow, float C );
  821. void   __vf  MFCol_divC( fPMatrix MA, unsigned ht, unsigned len,
  822.                          unsigned iCol, float C );
  823. void   __vf  MFDia_divC( fPMatrix MA, unsigned len, float C );
  824.  
  825. void   __vf  MFRow_divV( fPMatrix MA, unsigned ht, unsigned len,
  826.                          unsigned iRow, fVector X );
  827. void   __vf  MFCol_divV( fPMatrix MA, unsigned ht, unsigned len,
  828.                          unsigned iCol, fVector X );
  829. void   __vf  MFDia_divV( fPMatrix MA, unsigned len, fVector X );
  830.  
  831. void   __vf  MFRow_divrC( fPMatrix MA, unsigned ht, unsigned len,
  832.                          unsigned iRow, float C );
  833. void   __vf  MFCol_divrC( fPMatrix MA, unsigned ht, unsigned len,
  834.                          unsigned iCol, float C );
  835. void   __vf  MFDia_divrC( fPMatrix MA, unsigned len, float C );
  836.  
  837. void   __vf  MFRow_divrV( fPMatrix MA, unsigned ht, unsigned len,
  838.                          unsigned iRow, fVector X );
  839. void   __vf  MFCol_divrV( fPMatrix MA, unsigned ht, unsigned len,
  840.                          unsigned iCol, fVector X );
  841. void   __vf  MFDia_divrV( fPMatrix MA, unsigned len, fVector X );
  842.  
  843.  
  844. /******  One-dimensional vector operations **********************
  845.          performed along all rows or all columns simultaneously,
  846.          or along the diagonal of a square matrix                */
  847.  
  848. void  __vf  MFRows_max( fVector Y, fPMatrix MA, unsigned ht, unsigned len );
  849. void  __vf  MFCols_max( fVector Y, fPMatrix MA, unsigned ht, unsigned len );
  850. float __vf  MFDia_max(  fPMatrix MA, unsigned len );
  851. void  __vf  MFRows_min( fVector Y, fPMatrix MA, unsigned ht, unsigned len );
  852. void  __vf  MFCols_min( fVector Y, fPMatrix MA, unsigned ht, unsigned len );
  853. float __vf  MFDia_min(  fPMatrix MA, unsigned len );
  854.  
  855. void  __vf  MFRows_absmax( fVector Y, fPMatrix MA, unsigned ht, unsigned len );
  856. void  __vf  MFCols_absmax( fVector Y, fPMatrix MA, unsigned ht, unsigned len );
  857. float __vf  MFDia_absmax(  fPMatrix MA, unsigned len );
  858. void  __vf  MFRows_absmin( fVector Y, fPMatrix MA, unsigned ht, unsigned len );
  859. void  __vf  MFCols_absmin( fVector Y, fPMatrix MA, unsigned ht, unsigned len );
  860. float __vf  MFDia_absmin(  fPMatrix MA, unsigned len );
  861.  
  862. void  __vf  MFRows_sum( fVector Y, fPMatrix MA, unsigned ht, unsigned len );
  863. void  __vf  MFCols_sum( fVector Y, fPMatrix MA, unsigned ht, unsigned len );
  864. float __vf  MFDia_sum(  fPMatrix MA, unsigned len );
  865. void  __vf  MFRows_prod(fVector Y, fPMatrix MA, unsigned ht, unsigned len );
  866. void  __vf  MFCols_prod(fVector Y, fPMatrix MA, unsigned ht, unsigned len );
  867. float __vf  MFDia_prod( fPMatrix MA, unsigned len );
  868.  
  869. void  __vf  MFRows_runsum( fPMatrix MA, unsigned ht, unsigned len );
  870. void  __vf  MFCols_runsum( fPMatrix MA, unsigned ht, unsigned len );
  871. void  __vf  MFRows_runprod( fPMatrix MA, unsigned ht, unsigned len );
  872. void  __vf  MFCols_runprod( fPMatrix MA, unsigned ht, unsigned len );
  873.  
  874. void  __vf  MFRows_rotate( fPMatrix MA, unsigned ht, unsigned len, int pos );
  875. void  __vf  MFCols_rotate( fPMatrix MA, unsigned ht, unsigned len, int pos );
  876. void  __vf  MFRows_reflect( fPMatrix MA, unsigned ht, unsigned len );
  877. void  __vf  MFCols_reflect( fPMatrix MA, unsigned ht, unsigned len );
  878.  
  879. /********  Operations involving two rows or two colums of one matrix  *****/
  880.  
  881. void   __vf  MFRows_exchange( fPMatrix MA, unsigned ht, unsigned len,
  882.                               unsigned i1, unsigned i2 );
  883. void   __vf  MFCols_exchange( fPMatrix MA, unsigned ht, unsigned len,
  884.                               unsigned i1, unsigned i2 );
  885.  
  886. void   __vf  MFRows_add( fPMatrix MA, unsigned ht, unsigned len,
  887.                           unsigned destRow, unsigned sourceRow );
  888. void   __vf  MFCols_add( fPMatrix MA, unsigned ht, unsigned len,
  889.                           unsigned destCol, unsigned sourceCol );
  890.  
  891. void   __vf  MFRows_sub( fPMatrix MA, unsigned ht, unsigned len,
  892.                           unsigned destRow, unsigned sourceRow );
  893. void   __vf  MFCols_sub( fPMatrix MA, unsigned ht, unsigned len,
  894.                           unsigned destCol, unsigned sourceCol );
  895.  
  896. void   __vf  MFRows_Cadd( fPMatrix MA, unsigned ht, unsigned len,
  897.                            unsigned destRow, unsigned sourceRow, float C );
  898. void   __vf  MFCols_Cadd( fPMatrix MA, unsigned ht, unsigned len,
  899.                            unsigned destCol, unsigned sourceCol, float C );
  900.  
  901. void   __vf  MFRows_lincomb( fPMatrix MA, unsigned ht, unsigned len,
  902.                               unsigned destRow,  float  destC,
  903.                               unsigned srceRow,  float  srceC );
  904. void   __vf  MFCols_lincomb( fPMatrix MA, unsigned ht, unsigned len,
  905.                               unsigned destCol,  float  destC,
  906.                               unsigned srceCol,  float  srceC );
  907.  
  908.  
  909. /*************************  Transposing a matrix **********************/
  910.  
  911. void  __vf  MFtranspose( fPMatrix MTr, fPMatrix MA,
  912.                           unsigned htTr, unsigned lenTr );
  913.  
  914.  
  915. /************************ Matrix Arithmetics *************************/
  916.  
  917. #define MFaddM( MC, MA, MB, htA, lenA ) \
  918.                  VF_addV( MC, MA, MB, ((ui)htA)*lenA )
  919. #define MFsubM( MC, MA, MB, htA, lenA ) \
  920.                  VF_subV( MC, MA, MB, ((ui)htA)*lenA )
  921. #define MFmulC( MB, MA, htA, lenA, C ) \
  922.                  VF_mulC( MB, MA, ((ui)htA)*lenA, C )
  923. #define MFdivC( MB, MA, htA, lenA, C ) \
  924.                  VF_divC( MB, MA, ((ui)htA)*lenA, C )
  925. #define MFsaddM( MC, MA, MB, htA, lenA, C ) \
  926.                  VFs_addV( MC, MA, MB, ((ui)htA)*lenA, C )
  927. #define MFssubM( MC, MA, MB, htA, lenA, C ) \
  928.                  VFs_subV( MC, MA, MB, ((ui)htA)*lenA, C )
  929. #define MFlincomb( MC, MA, MB, htA, lenA, CA, CB ) \
  930.                  VF_lincomb( MC, MA, MB, ((ui)htA)*lenA, CA, CB )
  931. void  __vf  MFmulV( fVector Y, fPMatrix MA, fVector X,
  932.                     unsigned htA, unsigned lenA );
  933. void  __vf  VFmulM( fVector Y, fVector X, fPMatrix MA,
  934.                     unsigned sizX, unsigned lenA );
  935. void  __vf  MFmulM( fPMatrix MC, fPMatrix MA, fPMatrix MB,
  936.                     unsigned htA, unsigned lenA, unsigned lenB );
  937.  
  938.  
  939. /*************************  Linear Algebra    *****************************/
  940.  
  941. int    __vf  MFLUdecompose( fPMatrix MLU,  uiVector Ind, fPMatrix MA,
  942.                             unsigned len );
  943.  
  944. void   __vf  MFLUsolve( fVector X, fPMatrix MLU, fVector B, uiVector Ind,
  945.                         unsigned len );
  946. void   __vf  MFLUinv( fPMatrix MInv, fPMatrix MLU, uiVector Ind,
  947.                       unsigned len );
  948. float  __vf  MFLUdet( fPMatrix MLU, unsigned len, int permut );
  949. void   __vf  MFLUimprove( fVector X, fVector B, fPMatrix MA, fPMatrix MLU,
  950.                           uiVector Ind, unsigned len );
  951.  
  952. int   __vf  MFSVdecompose( fPMatrix MU, fPMatrix MV, fVector W, fPMatrix MA,
  953.                            unsigned htA, unsigned lenA );
  954. void  __vf  MFSVsolve( fVector X, fPMatrix MU, fPMatrix MV, fVector W,
  955.                        fVector B, unsigned htU, unsigned lenU );
  956. void  __vf  MFSVimprove(  fVector X, fVector B, fPMatrix MA,
  957.                        fPMatrix MU, fPMatrix MV, fVector W,
  958.                        unsigned htA, unsigned lenA );
  959.  
  960.           /*  functions using LUD or SVD     */
  961. int    __vf  MFsolve( fVector X, fPMatrix MA, fVector B, unsigned len );
  962.                   /* ret.value != 0 signals error */
  963. int    __vf  MFinv( fPMatrix MInv, fPMatrix MA, unsigned len );
  964.                  /* ret.value != 0 signals error */
  965. float  __vf  MFdet( fPMatrix MA, unsigned len );
  966.  
  967. int    __vf  MFsolveBySVD( fVector X, fPMatrix MA, fVector B,
  968.                            unsigned htA, unsigned lenA );
  969.               /*  sizX = lenA,  sizB = htA.  ret.value != 0 signals failure */
  970. int    __vf  MFsafeSolve( fVector X, fPMatrix MA, fVector B, unsigned len );
  971.               /* ret.value 0: success via LUD; 1: success via SVD; -1: error */
  972.  
  973.        /*********  Eigenvalues and Eigenvectors  ********/
  974.  
  975. void __vf MFs_eigenvalues( fVector EigV, fPMatrix EigM, fPMatrix MA, unsigned len,
  976.                         int CalcEigenVec );
  977.  
  978. /*************  Two-Dimensional Fourier-Transform Methods *****************/
  979.  
  980. void  __vf   MFlFFT( fPMatrix MY, fPMatrix MX,
  981.                      unsigned ht, unsigned len, int dir );
  982. void  __vf   MFlconvolve( fPMatrix MY, fPMatrix MFlt, fPMatrix MX,
  983.                           fPMatrix MRsp, unsigned ht, unsigned len );
  984. void  __vf   MFldeconvolve( fPMatrix MY, fPMatrix MFlt, fPMatrix MX,
  985.                             fPMatrix MRsp, unsigned ht, unsigned len );
  986. void  __vf   MFlfilter( fPMatrix MY, fPMatrix MX, fPMatrix MFlt,
  987.                         unsigned ht, unsigned len );
  988. void  __vf   MFlautocorr( fPMatrix MACorr, fPMatrix MX,
  989.                           unsigned ht, unsigned len );
  990. void  __vf   MFlxcorr( fPMatrix MXCorr, fPMatrix MX, fPMatrix MY,
  991.                        unsigned ht, unsigned len );
  992. void  __vf   MFlspectrum( fPMatrix MSpec, unsigned htSpec, unsigned lenSpec,
  993.                           fPMatrix MX, unsigned htX, unsigned lenX,
  994.                           fPMatrix MWin );
  995.  
  996. void  __vf   MFsFFT( fPMatrix MY, fPMatrix MX,
  997.                      unsigned ht, unsigned len, int dir );
  998. void  __vf   MFsconvolve( fPMatrix MY, fPMatrix MFlt, fPMatrix MX,
  999.                           fPMatrix MRsp, unsigned ht, unsigned len );
  1000. void  __vf   MFsdeconvolve( fPMatrix MY, fPMatrix MFlt, fPMatrix MX,
  1001.                             fPMatrix MRsp, unsigned ht, unsigned len );
  1002. void  __vf   MFsfilter( fPMatrix MY, fPMatrix MX, fPMatrix MFlt,
  1003.                         unsigned ht, unsigned len );
  1004. void  __vf   MFsautocorr( fPMatrix MACorr, fPMatrix MX,
  1005.                           unsigned ht, unsigned len );
  1006. void  __vf   MFsxcorr( fPMatrix MXCorr, fPMatrix MX, fPMatrix MY,
  1007.                        unsigned ht, unsigned len );
  1008. void  __vf   MFsspectrum( fPMatrix MSpec, unsigned htSpec, unsigned lenSpec,
  1009.                           fPMatrix MX, unsigned htX, unsigned lenX,
  1010.                           fPMatrix MWin );
  1011.  
  1012. /*************************  Data Fitting    *******************************/
  1013.  
  1014. void __vf VFpolyfitwW( fVector A, fPMatrix Covar, unsigned deg,
  1015.                         fVector X, fVector Y, fVector InvVar, ui sizex );
  1016. void __vf VFlinfitwW( fVector A, fPMatrix Covar, iVector AStatus, unsigned npars,
  1017.                     fVector X, fVector Y, fVector InvVar, ui sizex,
  1018.                     void (*funcs)(fVector BasFuncs, float x, unsigned nfuncs) );
  1019. float __vf VFnonlinfitwW( fVector A, fPMatrix Covar, iVector AStatus, unsigned npars,
  1020.                     fVector X, fVector Y, fVector InvVar, ui sizex,
  1021.                     void (*modelfunc)(fVector YModel, fVector X, ui size),
  1022.                     void (*derivatives)(fVector dYdAi, fVector X, ui size, unsigned i) );
  1023. void __vf MFlinfit( fVector A, iVector AStatus, unsigned npars,
  1024.                     fVector X, fVector Y, fPMatrix MZ, unsigned htZ, unsigned lenZ,
  1025.                     void (*funcs)(fVector BasFuncs, float x, float y, unsigned nfuncs) );
  1026. float __vf MFnonlinfit( fVector A, iVector AStatus, unsigned npars,
  1027.                     fVector X, fVector Y, fPMatrix MZ, unsigned htZ, unsigned lenZ,
  1028.                     void (*modelfunc)(fMatrix MZModel, unsigned htZ, unsigned lenZ, fVector X, fVector Y ),
  1029.                     void (*derivatives)(fMatrix dZdAi, unsigned htZ, unsigned lenZ, fVector X, fVector Y, unsigned ipar) );
  1030. void __vf MFlinfitwW( fVector A, fPMatrix Covar, iVector AStatus, unsigned npars,
  1031.                       fVector X, fVector Y, fPMatrix MZ, fPMatrix MInvVar, unsigned htZ, unsigned lenZ,
  1032.                       void (*funcs)(fVector BasFuncs, float x, float y, unsigned nfuncs) );
  1033. float __vf MFnonlinfitwW( fVector A, fPMatrix Covar, iVector AStatus, unsigned npars,
  1034.                     fVector X, fVector Y, fPMatrix MZ, fPMatrix MInvVar, unsigned htZ, unsigned lenZ,
  1035.                     void (*modelfunc)(fMatrix MZModel, unsigned htZ, unsigned lenZ, fVector X, fVector Y ),
  1036.                     void (*derivatives)(fMatrix dZdAi, unsigned htZ, unsigned lenZ, fVector X, fVector Y, unsigned ipar) );
  1037.  
  1038. void __vf VFmultiLinfitwW( fVector A, fPMatrix Covar, iVector AStatus, unsigned ma,
  1039.                 VF_EXPERIMENT _VFAR *ListOfExperiments, unsigned nexperiments,
  1040.                 void (*funcs)(fVector BasFuncs, float x,
  1041.                               unsigned nfuncs, unsigned nexperiment) );
  1042. void __vf MFmultiLinfitwW( fVector A, fPMatrix Covar,
  1043.                 iVector AStatus, unsigned npars,
  1044.                 MF_EXPERIMENT _VFAR *ListOfExperiments, unsigned nexperiments,
  1045.                 void (*funcs)(fVector BasFuncs, float x, float y,
  1046.                               unsigned nfuncs, unsigned nexperiment) );
  1047. float __vf VFmultiNonlinfitwW( fVector A, fPMatrix Covar,
  1048.                 iVector AStatus, unsigned npars,
  1049.                 VF_EXPERIMENT _VFAR *ListOfExperiments, unsigned nexperiments,
  1050.                 void (*modelfunc)(fVector YModel, fVector X, ui size,
  1051.                                   unsigned iexperiment),
  1052.                 void (*derivatives)(fVector dYdAi, fVector X, ui size,
  1053.                                   unsigned ipar, unsigned iexperiment) );
  1054. float __vf MFmultiNonlinfitwW( fVector A, fPMatrix Covar,
  1055.                 iVector AStatus, unsigned npars,
  1056.                 MF_EXPERIMENT _VFAR *ListOfExperiments, unsigned nexperiments,
  1057.                 void (*modelfunc)(fMatrix MZModel, unsigned htZ, unsigned lenZ,
  1058.                                   fVector X, fVector Y, unsigned iexperiment ),
  1059.                 void (*derivatives)(fMatrix dZdAi, unsigned htZ, unsigned lenZ,
  1060.                                     fVector X, fVector Y,
  1061.                                     unsigned ipar, unsigned iexperiment) );
  1062.  
  1063.       /*************  Input and Output  ****************/
  1064.  
  1065. void __vf MFfprint( FILE _VFAR *stream, fPMatrix MA, unsigned ht,
  1066.                      unsigned len, unsigned linewidth );
  1067. void __vf MFcprint( fPMatrix MA, unsigned ht, unsigned len );
  1068. void  __vf    MFwrite( FILE _VFAR *stream, fPMatrix X, unsigned ht, unsigned len  );
  1069. void  __vf    MFread( fPMatrix X, unsigned ht, unsigned len, FILE _VFAR *stream );
  1070. #define MFstore( str, MA, ht, len ) \
  1071.                            VF_store( str, MA, ((ui) (len))*(ht) );
  1072. #define MFrecall( MA, ht, len, str) \
  1073.                            VF_recall( MA, ((ui) (len))*(ht), str);
  1074.  
  1075. #ifdef __cplusplus
  1076. }
  1077. #endif
  1078. #endif 
  1079.