spBuild.c File Reference

#include "spConfig.h"
#include "spmatrix.h"
#include "spDefs.h"
#include "spmalloc.h"

Include dependency graph for spBuild.c:

Go to the source code of this file.

Defines
#define	spINSIDE_SPARSE
Functions
static void	Translate ()
static	EnlargeMatrix ()
static	ExpandTranslationArrays ()
void	spClear (char *eMatrix)
RealNumber *	spGetElement (char *eMatrix, int Row, int Col)
ElementPtr	spcFindElementInCol (MatrixPtr Matrix, ElementPtr *LastAddr, int Row, int Col, SPBOOLEAN CreateIfMissing)
ElementPtr	spcCreateElement (MatrixPtr Matrix, int Row, int Col, ElementPtr *LastAddr, SPBOOLEAN Fillin)
	spcLinkRows (MatrixPtr Matrix)
static	EnlargeMatrix (MatrixPtr Matrix, int NewSize)

---

Define Documentation

#define spINSIDE_SPARSE

Definition at line 62 of file spBuild.c.

---

Function Documentation

static EnlargeMatrix	(	MatrixPtr	Matrix,
		int	NewSize
	)			[static]

Definition at line 910 of file spBuild.c.

References I, int, MAX, NO, NULL, SPFREE, spNO_MEMORY, and SPREALLOC.

{
register int I, OldAllocatedSize = Matrix->AllocatedSize;

/* Begin `EnlargeMatrix'. */
    Matrix->Size = NewSize;

    if (NewSize <= OldAllocatedSize)
        return 0;

/* Expand the matrix frame. */
    NewSize = (int) MAX( NewSize, EXPANSION_FACTOR * OldAllocatedSize );
    Matrix->AllocatedSize = NewSize;

    if (( SPREALLOC(Matrix->IntToExtColMap, int, NewSize+1)) == NULL)
    {   Matrix->Error = spNO_MEMORY;
        return 0;
    }
    if (( SPREALLOC(Matrix->IntToExtRowMap, int, NewSize+1)) == NULL)
    {   Matrix->Error = spNO_MEMORY;
        return 0;
    }
    if (( SPREALLOC(Matrix->Diag, ElementPtr, NewSize+1)) == NULL)
    {   Matrix->Error = spNO_MEMORY;
        return 0;
    }
    if (( SPREALLOC(Matrix->FirstInCol, ElementPtr, NewSize+1)) == NULL)
    {   Matrix->Error = spNO_MEMORY;
        return 0;
    }
    if (( SPREALLOC(Matrix->FirstInRow, ElementPtr, NewSize+1)) == NULL)
    {   Matrix->Error = spNO_MEMORY;
        return 0;
    }

/*
 * Destroy the Markowitz and Intermediate vectors, they will be recreated
 * in spOrderAndFactor().
 */
    SPFREE( Matrix->MarkowitzRow );
    SPFREE( Matrix->MarkowitzCol );
    SPFREE( Matrix->MarkowitzProd );
    SPFREE( Matrix->DoRealDirect );
    SPFREE( Matrix->DoCmplxDirect );
    SPFREE( Matrix->Intermediate );
    Matrix->InternalVectorsAllocated = NO;

/* Initialize the new portion of the vectors. */
    for (I = OldAllocatedSize+1; I <= NewSize; I++)
    {   Matrix->IntToExtColMap[I] = I;
        Matrix->IntToExtRowMap[I] = I;
        Matrix->Diag[I] = NULL;
        Matrix->FirstInRow[I] = NULL;
        Matrix->FirstInCol[I] = NULL;
    }

    return 0;
}

static EnlargeMatrix

(

)

[static]

Referenced by spGetElement().

Here is the caller graph for this function:

static ExpandTranslationArrays

(

)

[static]

ElementPtr spcCreateElement	(	MatrixPtr	Matrix,
		int	Row,
		int	Col,
		ElementPtr *	LastAddr,
		SPBOOLEAN	Fillin
	)

Definition at line 713 of file spBuild.c.

References MatrixElement::Col, MatrixElement::NextInCol, MatrixElement::NextInRow, NULL, MatrixElement::Real, MatrixElement::Row, spcGetElement(), spcGetFillin(), and YES.

Referenced by CreateFillin(), and spcFindElementInCol().

{
register  ElementPtr  pElement, pLastElement;
ElementPtr  pCreatedElement, spcGetElement(), spcGetFillin();

/* Begin `spcCreateElement'. */

    if (Matrix->RowsLinked)
    {
/* Row pointers cannot be ignored. */
        if (Fillin)
        {   pElement = spcGetFillin( Matrix );
            Matrix->Fillins++;
        }
        else
        {   pElement = spcGetElement( Matrix );
            Matrix->NeedsOrdering = YES;
        }
        if (pElement == NULL) return NULL;

/* If element is on diagonal, store pointer in Diag. */
        if (Row == Col) Matrix->Diag[Row] = pElement;

/* Initialize Element. */
        pCreatedElement = pElement;
        pElement->Row = Row;
        pElement->Col = Col;
        pElement->Real = 0.0;
#if spCOMPLEX
        pElement->Imag = 0.0;
#endif
#if INITIALIZE
        pElement->pInitInfo = NULL;
#endif

/* Splice element into column. */
        pElement->NextInCol = *LastAddr;
        *LastAddr = pElement;

 /* Search row for proper element position. */
        pElement = Matrix->FirstInRow[Row];
        pLastElement = NULL;
        while (pElement != NULL)
        {
/* Search for element row position. */
            if (pElement->Col < Col)
            {
/* Have not reached desired element. */
                pLastElement = pElement;
                pElement = pElement->NextInRow;
            }
            else pElement = NULL;
        }

/* Splice element into row. */
        pElement = pCreatedElement;
        if (pLastElement == NULL)
        {
/* Element is first in row. */
            pElement->NextInRow = Matrix->FirstInRow[Row];
            Matrix->FirstInRow[Row] = pElement;
        }
        else
/* Element is not first in row. */
        {
            pElement->NextInRow = pLastElement->NextInRow;
            pLastElement->NextInRow = pElement;
        }

    }
    else
    {
/*
 * Matrix has not been factored yet.  Thus get element rather than fill-in.
 * Also, row pointers can be ignored.
 */

/* Allocate memory for Element. */
        pElement = spcGetElement( Matrix );
        if (pElement == NULL) return NULL;

/* If element is on diagonal, store pointer in Diag. */
        if (Row == Col) Matrix->Diag[Row] = pElement;

/* Initialize Element. */
        pCreatedElement = pElement;
        pElement->Row = Row;
#if DEBUG
        pElement->Col = Col;
#endif
        pElement->Real = 0.0;
#if spCOMPLEX
        pElement->Imag = 0.0;
#endif
#if INITIALIZE
        pElement->pInitInfo = NULL;
#endif

/* Splice element into column. */
        pElement->NextInCol = *LastAddr;
        *LastAddr = pElement;
    }

    Matrix->Elements++;
    return pCreatedElement;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ElementPtr spcFindElementInCol	(	MatrixPtr	Matrix,
		ElementPtr *	LastAddr,
		int	Row,
		int	Col,
		SPBOOLEAN	CreateIfMissing
	)

Definition at line 290 of file spBuild.c.

References MatrixElement::NextInCol, NO, NULL, MatrixElement::Row, and spcCreateElement().

Referenced by ExchangeRowsAndCols(), and spGetElement().

{
register  ElementPtr  pElement;
ElementPtr  spcCreateElement();

/* Begin `spcFindElementInCol'. */
    pElement = *LastAddr;

/* Search for element. */
    while (pElement != NULL)
    {   if (pElement->Row < Row)
        {
/* Have not reached element yet. */
            LastAddr = &(pElement->NextInCol);
            pElement = pElement->NextInCol;
        }
        else if (pElement->Row == Row)
        {
/* Reached element. */
            return pElement;
        }
        else break;  /* while loop */
    }

/* Element does not exist and must be created. */
    if (CreateIfMissing)
       return spcCreateElement( Matrix, Row, Col, LastAddr, NO );
    else return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void spClear

(

char *

eMatrix

)

Definition at line 90 of file spBuild.c.

References ASSERT, I, IS_SPARSE, MatrixElement::NextInCol, NO, NULL, OR, MatrixElement::Real, and spOKAY.

{
MatrixPtr  Matrix = (MatrixPtr)eMatrix;
register  ElementPtr  pElement;
register  int  I;

/* Begin `spClear'. */
    ASSERT( IS_SPARSE( Matrix ) );

/* Clear matrix. */
#if spCOMPLEX
    if (Matrix->PreviousMatrixWasComplex OR Matrix->Complex)
    {   for (I = Matrix->Size; I > 0; I--)
        {   pElement = Matrix->FirstInCol[I];
            while (pElement != NULL)
            {   pElement->Real = 0.0;
                pElement->Imag = 0.0;
                pElement = pElement->NextInCol;
            }
        }
    }
    else
#endif
    {   for (I = Matrix->Size; I > 0; I--)
        {   pElement = Matrix->FirstInCol[I];
            while (pElement != NULL)
            {   pElement->Real = 0.0;
                pElement = pElement->NextInCol;
            }
        }
    }

/* Empty the trash. */
    Matrix->TrashCan.Real = 0.0;
#if spCOMPLEX
    Matrix->TrashCan.Imag = 0.0;
#endif

    Matrix->Error = spOKAY;
    Matrix->Factored = NO;
    Matrix->SingularCol = 0;
    Matrix->SingularRow = 0;
    Matrix->PreviousMatrixWasComplex = Matrix->Complex;
    return;
}

spcLinkRows

(

MatrixPtr

Matrix

)

Definition at line 859 of file spBuild.c.

References MatrixElement::Col, MatrixElement::NextInCol, MatrixElement::NextInRow, NULL, MatrixElement::Row, and YES.

Referenced by spOrderAndFactor().

{
register  ElementPtr  pElement, *FirstInRowEntry;
register  ArrayOfElementPtrs  FirstInRowArray;
register  int  Col;

/* Begin `spcLinkRows'. */
    FirstInRowArray = Matrix->FirstInRow;
    for (Col = Matrix->Size; Col >= 1; Col--)
    {
/* Generate row links for the elements in the Col'th column. */
        pElement = Matrix->FirstInCol[Col];

        while (pElement != NULL)
        {   pElement->Col = Col;
            FirstInRowEntry = &FirstInRowArray[pElement->Row];
            pElement->NextInRow = *FirstInRowEntry;
            *FirstInRowEntry = pElement;
            pElement = pElement->NextInCol;
        }
    }
    Matrix->RowsLinked = YES;
    return 0;
}

Here is the caller graph for this function:

RealNumber* spGetElement	(	char *	eMatrix,
		int	Row,
		int	Col
	)

Definition at line 184 of file spBuild.c.

References AND, ASSERT, EnlargeMatrix(), IS_SPARSE, MAX, NULL, OR, spcFindElementInCol(), spNO_MEMORY, Translate(), and YES.

{
MatrixPtr  Matrix = (MatrixPtr)eMatrix;
RealNumber  *pElement;
ElementPtr spcFindElementInCol();


/* Begin `spGetElement'. */
    ASSERT( IS_SPARSE( Matrix ) AND Row >= 0 AND Col >= 0 );

    if ((Row == 0) OR (Col == 0))
        return &Matrix->TrashCan.Real;

#if NOT TRANSLATE
    ASSERT(Matrix->NeedsOrdering);
#endif

#if TRANSLATE
    Translate( Matrix, &Row, &Col );
    if (Matrix->Error == spNO_MEMORY) return NULL;
#endif

#if NOT TRANSLATE
#if NOT EXPANDABLE
    ASSERT(Row <= Matrix->Size AND Col <= Matrix->Size);
#endif

#if EXPANDABLE
/* Re-size Matrix if necessary. */
    if ((Row > Matrix->Size) OR (Col > Matrix->Size))
        EnlargeMatrix( Matrix, MAX(Row, Col) );
    if (Matrix->Error == spNO_MEMORY) return NULL;
#endif
#endif

/*
 * The condition part of the following if statement tests to see if the
 * element resides along the diagonal, if it does then it tests to see
 * if the element has been created yet (Diag pointer not NULL).  The
 * pointer to the element is then assigned to Element after it is cast
 * into a pointer to a RealNumber.  This casting makes the pointer into
 * a pointer to Real.  This statement depends on the fact that Real
 * is the first record in the MatrixElement structure.
 */

    if ((Row != Col) OR ((pElement = (RealNumber *)Matrix->Diag[Row]) == NULL))
    {
/*
 * Element does not exist or does not reside along diagonal.  Search
 * column for element.  As in the if statement above, the pointer to the
 * element which is returned by spcFindElementInCol is cast into a
 * pointer to Real, a RealNumber.
 */
        pElement = (RealNumber*)spcFindElementInCol( Matrix,
                                                     &(Matrix->FirstInCol[Col]),
                                                     Row, Col, YES );
    }
    return pElement;
}

Here is the call graph for this function:

static void Translate

(

)

[static]

Referenced by spGetElement().

Here is the caller graph for this function:

---