home *** CD-ROM | disk | FTP | other *** search
/ io Programmo 21 / IOPROG_21.ISO / SOFT / LIBMAT.ZIP / MATREF.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1992-10-16  |  4.7 KB  |  182 lines
  1. /*****************************************************/
  2. /*         matref.c source for refMatrix class       */
  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 <string.h>
  18.  
  19. #ifdef __cplusplus
  20. refMatrix::refMatrix( void ) : matrix()
  21. #else
  22. refMatrix::refMatrix( void ) : ()
  23. #endif
  24. {
  25.     errorExit( "refMatrix(void)", NIMPL ) ; 
  26. } // refMatrix::refMatrix
  27.  
  28. #ifdef __cplusplus
  29. refMatrix::refMatrix( const matrix& m ) : matrix()
  30. #else
  31. refMatrix::refMatrix( const matrix& m ) : ()
  32. #endif
  33. {
  34.    static char *mName="refMatrix(&m)" ;
  35.    matFunc func( mName ) ;
  36.    ppm = m.pm ;
  37.    ppm->ref++ ;
  38.    if ( pm != 0 )
  39.       delete pm ;
  40.    pm = new matMap( *ppm ) ;
  41.    debugInfo( func ) ;
  42. } // refMatrix::refMatrix
  43.  
  44. #ifdef __cplusplus
  45. refMatrix::refMatrix( const refMatrix& m ) : matrix()
  46. #else
  47. refMatrix::refMatrix( const refMatrix& m ) : ()
  48. #endif
  49. {
  50.    static char *mName="refMatrix(&rm)" ;
  51.    matFunc func( mName ) ;
  52.    ppm = m.ppm ;
  53.    ppm->ref++ ;
  54.    pm = m.pm ;
  55.    pm->ref++ ;
  56.    debugInfo( func ) ;
  57. } // refMatrix::refMatrix
  58.  
  59. refMatrix::~refMatrix( void )
  60. {
  61.    if ( ppm != 0 && --ppm->ref == 0 )
  62.       delete ppm ;
  63. } // ~refMatrix
  64.  
  65. refMatrix& refMatrix::operator = ( const refMatrix& m )
  66. {
  67.    static char *mName="op = ref" ;
  68.    matFunc func( mName ) ;
  69.    clear() ;
  70.    ppm = m.ppm ;
  71.    ppm->ref++ ;
  72.    if ( pm != 0 && --pm->ref == 0 )
  73.       delete pm ;
  74.    pm = m.pm ;
  75.    pm->ref++ ;
  76.    debugInfo( func ) ;
  77.    return *this ;
  78. } // refMatrix =
  79.  
  80. matrix& refMatrix::operator = ( const matrix& m )
  81. {
  82.    static char *mName="op =" ;
  83.    matFunc func( mName ) ; debugInfo( func ) ;
  84.    INDEX nr = nRows(), nc = nCols(), j ;
  85.    if ( nr != m.nRows() || nc != m.nCols() )
  86.       errorExit( mName, NEDIM ) ;
  87.    INDEX size = nr * sizeof( REAL ) ;
  88.    for ( j = 1 ; j <= nc ; j++ )
  89.       memcpy( (void *)(pm->map[j] + 1),
  90.           (void *)(m.pm->map[j] + 1), size );
  91.    return *this ;
  92. } // refMatrix::refMatrix
  93.  
  94. void refMatrix::reset( INDEX nr, INDEX nc )
  95. {
  96.    if ( nRows() != nr || nCols() != nc )
  97.       errorExit( "reset", NEDIM ) ;
  98. } // refMatrix reset
  99.  
  100. void refMatrix::reset( INDEX nr )
  101. {
  102.    reset( nr, 1 ) ;
  103. } // refMatrix reset
  104.  
  105. void refMatrix::clear( void )
  106. {
  107.    if ( ppm != 0 && --ppm->ref == 0 )
  108.       delete ppm ;
  109.    ppm = 0 ;
  110.    matrix::clear() ;
  111. } // refMatrix clear
  112.  
  113. INDEX refMatrix::isNull( void ) M_CONST
  114. { return ( ppm == 0 || pm == 0 || pm->pa == 0 ) ; }
  115.  
  116. outFile& refMatrix::info( outFile& f ) M_CONST
  117. {
  118.    if ( matListCtrl() > 3 )
  119.       return f ;
  120.    objectInfo( f ) ;
  121.    if ( pm != 0 )
  122.       putName( pm->nm.array(), f ) ;
  123.    else
  124.       putName( "", f ) ;
  125.    putName( "refMat", f ) ;
  126.    putField( nRows(), f ) ;
  127.    putField( nCols(), f ) ;
  128.    if ( pm != 0 )
  129.       putField( pm->identity(), f ) ;
  130.    else
  131.       putField( "NA", f ) ;
  132.    if ( ppm != 0 )
  133.       putField( ppm->identity(), f ) ;
  134.    else
  135.       putField( "NA", f ) ;
  136.    f.newLine() ;
  137.    return f ;
  138. } // refMatrix::info
  139.  
  140. matrix& refMatrix::refSub( INDEX r1, INDEX r2,
  141.                   INDEX c1, INDEX c2 )
  142. {
  143.    static char *mName = "refSub" ;
  144.    matFunc func( mName ) ; debugInfo( func ) ;
  145.    if ( isNull() )
  146.       errorExit( mName, NULRF ) ;
  147.    INDEX nrow = ppm->nrow, ncol = ppm->ncol ;
  148.    if ( r1 < 1 || r1 > r2 || r2 > nrow ||
  149.     c1 < 1 || c1 > c2 || c2 > ncol )
  150.       errorExit( mName, NRANG ) ;
  151.    INDEX nr = r2 - r1 + 1, nc = c2 - c1 + 1, j ;
  152.    if ( nc > pm->mapSize )
  153.       errorExit( mName, NRANG ) ;
  154.    for ( j = 1 ; j <= nc ; j++ )
  155.       pm->map[j] = ppm->map[j+c1-1] + r1 - 1 ;
  156.    pm->ncol = nc ;
  157.    pm->nrow = nr ;
  158.    return *this ;
  159. } // refMatrix refSub
  160.  
  161. matrix& refMatrix::refRow( INDEX r1, INDEX r2 )
  162. {
  163.    static char *mName = "refRow" ;
  164.    matFunc func( mName ) ; debugInfo( func ) ;
  165.    if ( isNull() )
  166.       errorExit( mName, NULRF ) ;
  167.    if ( r2 == 0 )
  168.       r2 = r1 ;
  169.    return refSub( r1, r2, 1, ppm->ncol ) ;
  170. } // refMatrix refRow
  171.  
  172. matrix& refMatrix::refCol( INDEX c1, INDEX c2 )
  173. {
  174.    static char *mName = "refCol" ;
  175.    matFunc func( mName ) ; debugInfo( func ) ;
  176.    if ( isNull() )
  177.       errorExit( mName, NULRF ) ;
  178.    if ( c2 == 0 )
  179.       c2 = c1 ;
  180.    return refSub( 1, ppm->nrow, c1, c2 ) ;
  181. } // refMatrix refCols
  182.