home *** CD-ROM | disk | FTP | other *** search
/ io Programmo 21 / IOPROG_21.ISO / SOFT / LIBMAT.ZIP / MATOPT.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1992-10-16  |  5.2 KB  |  190 lines
  1. /**************************************************/
  2. /* matopt.c source for MatClass optima functions  */
  3. /**************************************************/
  4.  
  5.  
  6. /**************************************************/
  7. /*            MatClass Source File                */
  8. /*       Copyright of C. R. Birchenhall           */
  9. /*       University of Manchester, UK.            */
  10. /*   MatClass is freeware. This file should be    */
  11. /* made freely available to users of any software */
  12. /* whose creation is wholly or partly dependent   */
  13. /*                on this file.                   */
  14. /**************************************************/
  15.  
  16. #include "matrix.hpp"
  17. #include <math.h>
  18.  
  19. INDEX matrix::rowOpti( INDEX i, int option ) M_CONST
  20. /*
  21.    return column INDEX of optimum in ith row
  22. */
  23. {
  24.    INDEX j, optj, xnc = nCols() ;
  25.    REAL  r, optimum ;
  26.    if ( option & ABS )
  27.       optimum = (REAL) fabs( (DOUBLE) mat(i,1) ) ;
  28.    else
  29.       optimum = mat(i,1) ;
  30.    optj = 1 ;
  31.    for ( j = 2; j <= xnc; j++ ) {
  32.       r = mat(i,j) ;
  33.       if ( option & ABS )
  34.          r = (REAL) fabs( (DOUBLE) r ) ;
  35.       if ( ( option & MINIMUM ) ? ( r < optimum ) : ( r > optimum ) ) {
  36.          optimum = r ;
  37.          optj = j ;
  38.       } // if
  39.    } // for j
  40.    return optj ;
  41. } // matrix::rowOpti
  42.  
  43. INDEX matrix::colOpti( INDEX j, int option ) M_CONST
  44. /*
  45.    return row INDEX of optimum in jth column
  46. */
  47. {
  48.    INDEX i, opti, xnr = nRows() ;
  49.    REAL  r, optimum ;
  50.    if ( option & ABS )
  51.       optimum = (REAL) fabs( (DOUBLE) mat(1,j) ) ;
  52.    else
  53.       optimum = mat(1,j) ;
  54.    opti = 1 ;
  55.    for ( i = 2; i <= xnr; i++ ) {
  56.       r = mat(i,j) ;
  57.       if ( option & ABS )
  58.          r = (REAL) fabs( (DOUBLE) r ) ;
  59.       if ( ( option & MINIMUM ) ? ( r < optimum ) : ( r > optimum ) ) {
  60.          optimum = r ;
  61.          opti = i ;
  62.       } // if
  63.    } // for i
  64.    return opti ;
  65. } // matrix::colOpti
  66.  
  67. matrix& matrix::rowOptOf( const matrix& x, int option )
  68. {
  69.    static char *mName = "rowOptOf" ;
  70.    matFunc func( mName ) ; x.debugInfo( func ) ;
  71.    INDEX xnr = x.nRows(), i ;
  72.    reset( xnr ) ;
  73.    for ( i = 1; i <= xnr; i++ )
  74.       mat(i) = x( i, x.rowOpti( i, option ) ) ;
  75.    return *this ;
  76. } // matrix::rowOptOf
  77.  
  78. matrix& matrix::colOptOf( const matrix& x, int option )
  79. {
  80.    static char *mName = "colOptOf" ;
  81.    matFunc func( mName ) ; x.debugInfo( func ) ;
  82.    INDEX xnc = x.nCols(), j ;
  83.    reset( xnc ) ;
  84.    for ( j = 1; j <= xnc; j++ )
  85.       mat(j) = x( x.colOpti( j, option ), j ) ;
  86.    return *this ;
  87. } // matrix::colOptima
  88.  
  89. indexArray matrix::optimaMap( indexArray& map, int option ) M_CONST
  90. {
  91.    static char *mName = "optimaMap" ;
  92.    matFunc func( mName ) ; debugInfo( func ) ;
  93.    INDEX nr = nRows(), nc = nCols(), i, j ;
  94.    if ( isNull() )
  95.       errorExit( mName, NULRF ) ;
  96.    if ( option & ROWWISE ) {
  97.       if ( nr != map.length() )
  98.          map.reset( nr ) ;
  99.       for ( i = 1; i <= nr; i++ )
  100.          map(i) = rowOpti( i, option ) ;
  101.    } else {
  102.       if ( nc != map.length() )
  103.          map.reset( nc ) ;
  104.       for ( j = 1; j <= nc; j++ )
  105.          map(j) = colOpti( j, option ) ;
  106.    } // else
  107.    return map ;
  108. } // matrix::optimaMap
  109.  
  110. indexArray matrix::optimaMap( int option ) M_CONST
  111. {
  112.    static char *mName = "optimaMap()" ;
  113.    matFunc func( mName ) ; debugInfo( func ) ;
  114.    indexArray map( nRows() ) ;
  115.    optimaMap( map, option ) ;
  116.    return map ;
  117. } // matrix::optimaMap
  118.  
  119. matrix matrix::rowMax( int opt ) M_CONST
  120. {
  121.    static char *mName = "rowMax" ;
  122.    matFunc func( mName ) ; debugInfo( func ) ;
  123.    matrix z ;
  124.    z.rowOptOf( *this, opt ) ;
  125.    return z ;
  126. } // matrix::rowMax
  127.  
  128. matrix matrix::rowMin( int opt ) M_CONST
  129. {
  130.    static char *mName = "rowMin" ;
  131.    matFunc func( mName ) ; debugInfo( func ) ;
  132.    matrix z ;
  133.    z.rowOptOf( *this, opt | MINIMUM ) ;
  134.    return z ;
  135. } // matrix::rowMin
  136.  
  137. matrix matrix::colMax( int opt ) M_CONST
  138. {
  139.    static char *mName = "colMax" ;
  140.    matFunc func( mName ) ; debugInfo( func ) ;
  141.    matrix z ;
  142.    z.colOptOf( *this, opt ) ;
  143.    return z ;
  144. } // matrix::colMax
  145.  
  146. matrix matrix::colMin( int opt ) M_CONST
  147. {
  148.    static char *mName = "colMin" ;
  149.    matFunc func( mName ) ; debugInfo( func ) ;
  150.    matrix z ;
  151.    z.colOptOf( *this, opt | MINIMUM  ) ;
  152.    return z ;
  153. } // matrix::colMin
  154.  
  155. indexArray matrix::rowMaxMap( int opt ) M_CONST
  156. {
  157.    static char *mName = "rowMaxMap" ;
  158.    matFunc func( mName ) ; debugInfo( func ) ;
  159.    indexArray map( nRows() );
  160.    optimaMap( map, opt | ROWWISE ) ;
  161.    return map ;
  162. } // matrix::rowMaxMap
  163.  
  164. indexArray matrix::rowMinMap( int opt ) M_CONST
  165. {
  166.    static char *mName = "rowMinMap" ;
  167.    matFunc func( mName ) ; debugInfo( func ) ;
  168.    indexArray map( nRows() );
  169.    optimaMap( map, opt | MINROW ) ;
  170.    return map ;
  171. } // matrix::rowMini
  172.  
  173. indexArray matrix::colMaxMap( int opt  ) M_CONST
  174. {
  175.    static char *mName = "colMaxMap" ;
  176.    matFunc func( mName ) ; debugInfo( func ) ;
  177.    indexArray map( nRows() );
  178.    optimaMap( map, opt  ) ;
  179.    return map ;
  180. } // matrix::colMaxi
  181.  
  182. indexArray matrix::colMinMap( int opt  ) M_CONST
  183. {
  184.    static char *mName = "colMinMap" ;
  185.    matFunc func( mName ) ; debugInfo( func ) ;
  186.    indexArray map( nRows() );
  187.    optimaMap( map, opt | MINIMUM ) ;
  188.    return map ;
  189. } // matrix::colMini
  190.