matrix_indirect.c

有限元分析源代码

          case INTEGER_ARRAY:
               MatrixFreeIndirectInteger( spA->uMatrix.iaa, spA->iNoRows);
               break;
          case COMPLEX_ARRAY:
               FatalError("In MatrixFreeIndirect() : spA->eType not implemented",
                         (char *) NULL);
               break;
          default:
               break;
      }

   /* (b) Free cpMatrixName and parent data structure for matrix */

      if( CheckUnits() == ON ) {
         for( i=1; i<=spA->iNoRows; i++ )
             free ((char *) spA->spRowUnits[i-1].units_name );
         for( i=1; i<=spA->iNoColumns; i++ )
             free ((char *) spA->spColUnits[i-1].units_name );
         free ((char *) spA->spRowUnits);
         free ((char *) spA->spColUnits);
      }
      free ((char *) spA->cpMatrixName);
      free ((char *) spA);
      spA = (MATRIX *)NULL;
}

/*
 *  =======================================================================
 *  MatrixFreeIndirectDouble() : Free memory for INDIRECT storage of data
 *                               type DOUBLE.
 *  
 *  Input  :  double **d  -- Pointer to matrix of data type double.
 *         :  int iNoRows -- No of Rows in Matrix.
 *  Output :  void
 *  =======================================================================
 */

#ifdef __STDC__
void MatrixFreeIndirectDouble( double **d, int iNoRows)
#else  /* Start case not STDC */
void MatrixFreeIndirectDouble( d, iNoRows)
double     **d;
int    iNoRows;
#endif /* End case not STDC */
{
int ii;

   if( d == (double **)NULL )  return;

   for(ii = 1; ii <= iNoRows; ii++)
       free ((char *) d[ii-1]);
   free ((char *) d);
}

/*
 *  =======================================================================
 *  MatrixFreeIndirectInteger() : Free memory for INDIRECT storage of data
 *                                type INTEGER.
 *  
 *  Input  :  int     **i  -- Pointer to matrix of data type double.
 *         :  int iNoRows  -- No of Rows in Matrix.
 *  Output :  void
 *  =======================================================================
 */

#ifdef __STDC__
void MatrixFreeIndirectInteger( int **i, int iNoRows)
#else  /* Start case not STDC */
void MatrixFreeIndirectInteger( i, iNoRows)
int        **i;
int    iNoRows;
#endif /* End case not STDC */
{
int ii;

   if( i == (int **)NULL )  return;

   for(ii = 1; ii <= iNoRows; ii++)
       free ((char *) i[ii-1]);
   free ((char *) i);
}


/*
 *  =========================================================
 *  MatrixCompareSize() : Compare sizes of matrices [A] and [B].
 *                      : If(Size [A] == Size[B])
 *                           return TRUE.
 *                        else
 *                           return FALSE.
 *  =========================================================
 */

#ifdef __STDC__
MatrixCompareSize( MATRIX *spA, MATRIX *spB )
#else  /* Start case not STDC */
MatrixCompareSize( spA, spB )
MATRIX *spA;
MATRIX *spB;
#endif /* End case not STDC */
{

    if((spA->iNoRows    != spB->iNoRows) ||
       (spA->iNoColumns != spB->iNoColumns)) {
        (void) printf("Problem : spA->iNoRows = %4d spA->iNoColumns = %4d\n",
                                 spA->iNoRows, spB->iNoColumns);
        (void) printf("Problem : spB->iNoRows = %4d spB->iNoColumns = %4d\n",
                                 spB->iNoRows, spB->iNoColumns);

        return (FALSE);
    }
    else
        return (TRUE);

}

/*
 *  =========================================================
 *  MatrixCompareInsideDimensions() : Compare inside
 *  dimensions of matrices [A] and [B].
 *
 *  If(Size [A] == Size[B]) return TRUE.
 *  else                    return FALSE.
 *  =========================================================
 */

#ifdef __STDC__
MatrixCompareInsideDimensions( MATRIX *spA, MATRIX *spB )
#else  /* Start case not STDC */
MatrixCompareInsideDimensions( spA, spB )
MATRIX *spA;
MATRIX *spB;
#endif /* End case not STDC */
{

    if(spA->iNoColumns != spB->iNoRows) {
        (void) printf("Problem : spA->iNoRows = %4d spA->iNoColumns = %4d\n",
                                 spA->iNoRows, spB->iNoColumns);
        (void) printf("Problem : spB->iNoRows = %4d spB->iNoColumns = %4d\n",
                                 spB->iNoRows, spB->iNoColumns);

        return (FALSE);
    }
    else
        return (TRUE);

}


/*
 *  =======================================================================
 *  MatrixAddIndirectDouble() : Add Matrices [C] = [A] + [B].
 *  
 *  Input  :  MATRIX     *spA  -- Pointer to (nxn) matrix A.
 *         :  MATRIX     *spB  -- Pointer to (nxn) matrix B.
 *  Output :  MATRIX     *spC  -- Pointer to (nxn) matrix C.
 *  =======================================================================
 */

#ifdef __STDC__
MATRIX *MatrixAddIndirectDouble( MATRIX *spA, MATRIX *spB )
#else  /* Start case not STDC */
MATRIX *MatrixAddIndirectDouble( spA, spB )
MATRIX *spA;
MATRIX *spB;
#endif /* End case not STDC */
{
MATRIX *spC;
int  ii, ij;
int  length, length1, length2;
DIMENSIONS *d1, *d2;
int UNITS_SWITCH;

     UNITS_SWITCH = CheckUnits();
    /* [a] : Compare Dimensions of Matrices */

       if(MatrixCompareSize( spA, spB ) != TRUE)
          FatalError("Execution halted in MatrixAddIndirectDouble()",
                     "Inconsistent Dimensions",
                     (char *) NULL);

       spC = MatrixAllocIndirect((char *) NULL, DOUBLE_ARRAY, spA->iNoRows, spB->iNoColumns);

       switch( UNITS_SWITCH) {
         case ON:
            for(ii = 1; ii <= spA->iNoRows; ii++)
                UnitsCopy( &(spC->spRowUnits[ii-1]), &(spA->spRowUnits[ii-1]) );
            for(ij = 1; ij <= spA->iNoColumns; ij++)
                UnitsCopy( &(spC->spColUnits[ij-1]), &(spA->spColUnits[ij-1]) );

         /* [b] : Check Units and Add Matrices : [C] = [A] + [B] */

            for(ii = 1; ii <= spA->iNoRows; ii++) {
                for(ij = 1; ij <= spA->iNoColumns; ij++) {

                    d1 = UnitsMult( &(spA->spRowUnits[ii-1]), &(spA->spColUnits[ij-1]) );
                    d2 = UnitsMult( &(spB->spRowUnits[ii-1]), &(spB->spColUnits[ij-1]) );

                    if(SameUnits(d1, d2) == TRUE) 
                        spC->uMatrix.daa[ii-1][ij-1] 
                        = spA->uMatrix.daa[ii-1][ij-1] + spB->uMatrix.daa[ii-1][ij-1];
                    else {
                       printf("For row No %d, column No %d \n", ii, ij);
                       FatalError("In MatrixAddIndirectDouble(): Inconsistent Units",
                       (char *)NULL);
                    }
                    free((char *) d1->units_name);
                    free((char *) d1);
                    free((char *) d2->units_name);
                    free((char *) d2);
                }
            }
            break;
         case OFF:
            for(ii = 1; ii <= spA->iNoRows; ii++) {
                for(ij = 1; ij <= spA->iNoColumns; ij++) {
                    spC->uMatrix.daa[ii-1][ij-1]
                    = spA->uMatrix.daa[ii-1][ij-1] + spB->uMatrix.daa[ii-1][ij-1];
                }
            }
            break;
         default:
            break;
       }

       return ( spC );
}

/*
 *  =======================================================================
 *  MatrixAddReplaceIndirectDouble() : Matrix Replacement [A] = [A] + [B].
 *  
 *  Input  :  MATRIX     *spA  -- Pointer to (nxn) matrix A.
 *         :  MATRIX     *spB  -- Pointer to (nxn) matrix B.
 *  Output :  MATRIX     *spC  -- Pointer to (nxn) matrix A.
 *  =======================================================================
 */

#ifdef __STDC__
MATRIX *MatrixAddReplaceIndirectDouble( MATRIX *spA, MATRIX *spB )
#else  /* Start case not STDC */
MATRIX *MatrixAddReplaceIndirectDouble( spA, spB )
MATRIX *spA;
MATRIX *spB;
#endif /* End case not STDC */
{
int  ii, ij;
int  length1, length2;
DIMENSIONS *d1, *d2;
int UNITS_SWITCH;

     UNITS_SWITCH = CheckUnits();
    /* [a] : Compare Dimensions of Matrices */

       if(MatrixCompareSize( spA, spB ) != TRUE)
          FatalError("Execution halted in MatrixAddIndirectDouble()",
                     "Inconsistent Dimensions",
                     (char *) NULL);

    /* [b] : Check Units and Add Matrices : [A] = [A] + [B] */

       switch( UNITS_SWITCH) {
          case ON:
            for(ii = 1; ii <= spA->iNoRows; ii++) {
                for(ij = 1; ij <= spA->iNoColumns; ij++) {

                    d1 = UnitsMult( &(spA->spRowUnits[ii-1]),&(spA->spColUnits[ij-1]));
                    d2 = UnitsMult( &(spB->spRowUnits[ii-1]),&(spB->spColUnits[ij-1]));

                    if(SameUnits(d1, d2) == TRUE) 
                      spA->uMatrix.daa[ii-1][ij-1] += spB->uMatrix.daa[ii-1][ij-1];
                    else {
                     printf("For row No %d, column No %d \n", ii, ij);
                     FatalError("In MatrixAddIndirectDouble(): Inconsistent Units",(char *)NULL);
                    }
                    free((char *) d1->units_name);
                    free((char *) d1);
                    free((char *) d2->units_name);
                    free((char *) d2);
                }
            }
            break;
         case OFF:
            for(ii = 1; ii <= spA->iNoRows; ii++) {
                for(ij = 1; ij <= spA->iNoColumns; ij++) {
                      spA->uMatrix.daa[ii-1][ij-1] += spB->uMatrix.daa[ii-1][ij-1];
                }
            }
            break;
         default:
            break;
       }

       free((char *) spA->cpMatrixName);
       spA->cpMatrixName = (char *)NULL;
       return (spA);
}

/*
 *  =======================================================================
 *  MatrixSubIndirectDouble() : Add Matrices [C] = [A] - [B].
 *  
 *  Input  :  MATRIX     *spA  -- Pointer to (nxn) matrix A.
 *         :  MATRIX     *spB  -- Pointer to (nxn) matrix B.
 *  Output :  MATRIX     *spC  -- Pointer to (nxn) matrix C.
 *  =======================================================================
 */

#ifdef __STDC__
MATRIX *MatrixSubIndirectDouble( MATRIX *spA, MATRIX *spB )
#else  /* Start case not STDC */
MATRIX *MatrixSubIndirectDouble( spA, spB )
MATRIX *spA;
MATRIX *spB;
#endif /* End case not STDC */
{
MATRIX *spC;
int  ii, ij;
int  length, length1, length2;
DIMENSIONS *d1, *d2;
int UNITS_SWITCH;

     UNITS_SWITCH = CheckUnits();
    /* [a] : Compare Dimensions of Matrices */

       if(MatrixCompareSize( spA, spB ) != TRUE)
          FatalError("Execution halted in MatrixAddIndirectDouble()",
                     "Inconsistent Dimensions",
                     (char *) NULL);

       spC = MatrixAllocIndirect((char *) NULL, DOUBLE_ARRAY, spA->iNoRows, spB->iNoColumns);

       switch( UNITS_SWITCH) {
          case ON:
            for(ii = 1; ii <= spA->iNoRows; ii++)
                UnitsCopy( &(spC->spRowUnits[ii-1]), &(spA->spRowUnits[ii-1]) );
            for(ij = 1; ij <= spA->iNoColumns; ij++)
                UnitsCopy( &(spC->spColUnits[ij-1]), &(spA->spColUnits[ij-1]) );

         /* [b] : Check Units and Sub Matrices : [C] = [A] - [B] */

            for(ii = 1; ii <= spA->iNoRows; ii++) {
                for(ij = 1; ij <= spA->iNoColumns; ij++) {

                    d1 = UnitsMult(&(spA->spRowUnits[ii-1]),&(spA->spColUnits[ij-1]));
                    d2 = UnitsMult(&(spB->spRowUnits[ii-1]),&(spB->spColUnits[ij-1]));

                    if(SameUnits(d1, d2) == TRUE) 
                      spC->uMatrix.daa[ii-1][ij-1] 
                      = spA->uMatrix.daa[ii-1][ij-1] - spB->uMatrix.daa[ii-1][ij-1];
                    else {
                     printf("For row No %d, column No %d \n", ii, ij);
                     FatalError("In MatrixAddIndirectDouble(): Inconsistent Units",(char *)NULL);
                    }
                    free((char *) d1->units_name);
                    free((char *) d1);
                    free((char *) d2->units_name);
                    free((char *) d2);
                }
            }
            break;
         case OFF:
            for(ii = 1; ii <= spA->iNoRows; ii++) {
                for(ij = 1; ij <= spA->iNoColumns; ij++) {
                      spC->uMatrix.daa[ii-1][ij-1] 
                      = spA->uMatrix.daa[ii-1][ij-1] - spB->uMatrix.daa[ii-1][ij-1];
                }
            }
            break;
         default:
            break;
      }

       return ( spC );
}

/*
 *  =======================================================================
 *  MatrixSubReplaceIndirectDouble() : Matrix Replacement [A] = [A] - [B].
 *  
 *  Input  :  MATRIX     *spA  -- Pointer to (nxn) matrix A.
 *         :  MATRIX     *spB  -- Pointer to (nxn) matrix B.
 *  Output :  MATRIX     *spC  -- Pointer to (nxn) matrix A.
 *  =======================================================================
 */

#ifdef __STDC__
MATRIX *MatrixSubReplaceIndirectDouble( MATRIX *spA, MATRIX *spB )
#else  /* Start case not STDC */
MATRIX *MatrixSubReplaceIndirectDouble( spA, spB )
MATRIX *spA;
MATRIX *spB;
#endif /* End case not STDC */