📄 matrix_indirect.c
字号:
#endif /* End case not STDC */
{
int i;
if( spA == (MATRIX *)NULL ) return;
/* [a] : Free body of matrix[iNoRows][iNoColumns] */
switch(spA->eType) {
case DOUBLE_ARRAY:
MatrixFreeIndirectDouble( spA->uMatrix.daa, spA->iNoRows);
break;
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;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -