include/PSSMatrix.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
PSSMatrix	PSSMatrix_create (struct scoreMatrix scoreMatrix, char *query)
PSSMatrix	PSSMatrix_chop (struct PSSMatrix PSSMatrix, int4 amount)
PSSMatrix	PSSMatrix_reverse (struct PSSMatrix PSSMatrix)
uint4	PSSMatrix_strandStart (struct PSSMatrix PSSMatrix, uint4 queryOffset)
uint4	PSSMatrix_strandEnd (struct PSSMatrix PSSMatrix, uint4 queryOffset)
void	PSSMatrix_print (struct PSSMatrix PSSMatrix)
void	PSSMatrix_free (struct PSSMatrix PSSMatrix)
void	PSSMatrix_freeCopy (struct PSSMatrix PSSMatrix)
Variables
unsigned char *	PSSMatrix_packedRightMatches
unsigned char *	PSSMatrix_packedLeftMatches
int2 *	PSSMatrix_packedRightMatchScores
int2 *	PSSMatrix_packedLeftMatchScores
char *	PSSMatrix_packedScore

---

Function Documentation

struct PSSMatrix PSSMatrix_chop	(	struct PSSMatrix	PSSMatrix,
		int4	amount
	)			[read]

Definition at line 270 of file PSSMatrix.c.

References PSSMatrix::bytePackedCodes, PSSMatrix::highestValue, PSSMatrix::length, PSSMatrix::lowestValue, PSSMatrix::matrix, PSSMatrix::queryCodes, PSSMatrix::strandLength, and PSSMatrix::xorCodes.

Referenced by bytepackGappedScoring_score(), fasterGappedExtension_build(), gappedExtension_build(), gappedScoring_score(), nuGappedScoring_score(), oldGappedScoring_score(), oldSemiGappedScoring_score(), semiGappedScoring_score(), smithWatermanScoring_score(), smithWatermanScoring_scoreReverse(), smithWatermanTraceback_build(), and tableGappedScoring_score().

{
        struct PSSMatrix chopped;

        chopped.matrix = PSSMatrix.matrix + amount;
        chopped.queryCodes = PSSMatrix.queryCodes + amount;
        chopped.bytePackedCodes = PSSMatrix.bytePackedCodes + amount;
    chopped.xorCodes = PSSMatrix.xorCodes + amount;
        chopped.length = PSSMatrix.length - amount;
        chopped.highestValue = PSSMatrix.highestValue;
        chopped.lowestValue = PSSMatrix.lowestValue;
    chopped.strandLength = PSSMatrix.strandLength - amount;

    if (chopped.strandLength < 0)
        chopped.strandLength = 0;

        return chopped;
}

Here is the caller graph for this function:

struct PSSMatrix PSSMatrix_create	(	struct scoreMatrix	scoreMatrix,
		char *	query
	)			[read]

Definition at line 20 of file PSSMatrix.c.

References encoding_alphabetType, encoding_bytePack(), encoding_bytePackBeginning(), encoding_bytePackRemaining(), encoding_getCode(), encoding_getComplement(), encoding_nucleotide, encoding_numRegularLetters, encoding_randomEncodedLetter(), encoding_sentinalCode, global_malloc(), PSSMatrix::highestValue, int2, int4, PSSMatrix::lowestValue, PSSMatrix::matrix, parameters_matchScore, parameters_mismatchScore, parameters_strands, PSSMatrix_packedLeftMatches, PSSMatrix_packedLeftMatchScores, PSSMatrix_packedRightMatches, PSSMatrix_packedRightMatchScores, and PSSMatrix_packedScore.

Referenced by main().

{
        struct PSSMatrix PSSMatrix;
        int4 columnCount;
        unsigned char code, code2, bestCode;
    int4 packedByte, matches;

    if (encoding_alphabetType == encoding_nucleotide && parameters_strands == 3)
        {
        PSSMatrix.length = 2 * strlen(query);
        PSSMatrix.strandLength = strlen(query);
    }
    else if (encoding_alphabetType == encoding_nucleotide && parameters_strands == 2)
        {
        PSSMatrix.length = strlen(query);
        PSSMatrix.strandLength = 0;
    }
    else
    {
                PSSMatrix.strandLength = PSSMatrix.length = strlen(query);
        }

        // For each character in the query sequence
        columnCount = 0;
        while (columnCount < strlen(query))
        {
                // Convert the character to upper case
                query[columnCount] = toupper(query[columnCount]);       
                columnCount++;
        }
        
        // Declare memory for use by PSSMatrix
        PSSMatrix.matrix = (int2**)global_malloc(sizeof(int2*) * (PSSMatrix.length + 2));

    // Declare memory to store encoded query
    PSSMatrix.queryCodes = (unsigned char*)global_malloc(sizeof(unsigned char) * (PSSMatrix.length));

    // Declare memory to store the highest scoring regular letter for each position
    PSSMatrix.bestMatchCodes = (unsigned char*)global_malloc(sizeof(unsigned char) * (PSSMatrix.length));

    // The first column will be a sentinal column
        PSSMatrix.matrix++;

        // Set initial maximum, minimum values
        PSSMatrix.highestValue = scoreMatrix.highestValue;
        PSSMatrix.lowestValue = scoreMatrix.lowestValue;

        // For each character in the query sequence
        columnCount = 0;
        while (columnCount < PSSMatrix.length)
        {
                // Get its code
        if (columnCount < PSSMatrix.strandLength)
        {
                // Positive strand
                        code = encoding_getCode(query[columnCount]);
                }
        else
        {
                // Negative strand
                        code = encoding_getComplement(encoding_getCode(query[PSSMatrix.length - columnCount - 1]));
        }

                // Use column from scoreMatrix for PSSMatrix
                PSSMatrix.matrix[columnCount] = scoreMatrix.matrix[code];

        // Add code to encoded query
        PSSMatrix.queryCodes[columnCount] = code;

        // For each possible regular letter
                bestCode = 0;
        code2 = 0;
                while (code2 < encoding_numRegularLetters)
        {
                // Determine which scores highest at this position
            // (typically the same as the query letter for this position)
            if (PSSMatrix.matrix[columnCount][code2] > PSSMatrix.matrix[columnCount][bestCode])
            {
                bestCode = code2;
            }
            code2++;
        }

        // Set best code at this position
                if (encoding_alphabetType == encoding_nucleotide && code >= encoding_numRegularLetters)
        {
                PSSMatrix.bestMatchCodes[columnCount] = encoding_randomEncodedLetter(code);
        }
        else
        {
            PSSMatrix.bestMatchCodes[columnCount] = bestCode;
        }

                columnCount++;
        }

    // If this is a nucleotide sequence store byte-packed code information
    if (encoding_alphabetType == encoding_nucleotide)
    {
        // Declare memory to store xor codes; each 2-bit code copied 4 times in the byte
        PSSMatrix.xorCodes = (unsigned char*)global_malloc(sizeof(unsigned char) * (PSSMatrix.length));

        // For each nucleotide character in the query sequence
        columnCount = 0;
        while (columnCount < PSSMatrix.length)
        {
                code = PSSMatrix.queryCodes[columnCount];

            // Set xorCode which is the 2-bit code copied 4 times in the byte
            PSSMatrix.xorCodes[columnCount] = (code << 6) | code << 4 | code << 2 | code;

            columnCount++;
        }

        // Declare memory to store byte-packed query
        PSSMatrix.bytePackedCodes = (unsigned char*)global_malloc(sizeof(unsigned char) * (PSSMatrix.length + 5)) + 4;

        // For each position in the sequence
        columnCount = 0;
        while (columnCount < PSSMatrix.length)
        {
                // Store packed version of next 4 characters in query
                if (columnCount + 3 < PSSMatrix.length)
                        PSSMatrix.bytePackedCodes[columnCount]
                        = encoding_bytePack(PSSMatrix.bestMatchCodes + columnCount);
            // Of the remaining < 4 characters
            else
                                PSSMatrix.bytePackedCodes[columnCount] = encoding_bytePackRemaining(
                        PSSMatrix.bestMatchCodes + columnCount, PSSMatrix.length - columnCount);

            columnCount++;
                }

        // Store DUMMY packed value before and after sequence
                PSSMatrix.bytePackedCodes[-4] = 0;
                PSSMatrix.bytePackedCodes[PSSMatrix.length] = 0;

                // Store three before-sequence codes
        PSSMatrix.bytePackedCodes[-3] = encoding_bytePackBeginning(PSSMatrix.bestMatchCodes, 1);
        PSSMatrix.bytePackedCodes[-2] = encoding_bytePackBeginning(PSSMatrix.bestMatchCodes, 2);
        PSSMatrix.bytePackedCodes[-1] = encoding_bytePackBeginning(PSSMatrix.bestMatchCodes, 3);

                PSSMatrix_packedRightMatches = (unsigned char*)global_malloc(sizeof(unsigned char) * 256);
                PSSMatrix_packedLeftMatches = (unsigned char*)global_malloc(sizeof(unsigned char) * 256);
                PSSMatrix_packedRightMatchScores = (int2*)global_malloc(sizeof(int2) * 256);
                PSSMatrix_packedLeftMatchScores = (int2*)global_malloc(sizeof(int2) * 256);
                PSSMatrix_packedScore = (unsigned char*)global_malloc(sizeof(unsigned char) * 256);

        // For each packed byte
        packedByte = 0;
        while (packedByte < 256)
        {
            // For each possible XORed value determine number of matches going
            // from left to RIGHT
            matches = 0;
            if (!((packedByte >> 6) & 0x3))
            {
                matches++;
                if (!((packedByte >> 4) & 0x3))
                {
                        matches++;
                    if (!((packedByte >> 2) & 0x3))
                    {
                        matches++;
                        if (!(packedByte & 0x3))
                        {
                            matches++;
                        }
                    }
                                }
            }
            PSSMatrix_packedRightMatches[packedByte] = matches;
            PSSMatrix_packedRightMatchScores[packedByte] = matches * parameters_matchScore;

            // The same going from right to LEFT
            matches = 0;
            if (!(packedByte & 0x3))
            {
                matches++;
                if (!((packedByte >> 2) & 0x3))
                {
                        matches++;
                    if (!((packedByte >> 4) & 0x3))
                    {
                        matches++;
                        if (!((packedByte >> 6) & 0x3))
                        {
                            matches++;
                        }
                    }
                                }
            }
            PSSMatrix_packedLeftMatches[packedByte] = matches;
            PSSMatrix_packedLeftMatchScores[packedByte] = matches * parameters_matchScore;

            // Determine the score for this XORed pair
            matches = 0;
            if (!((packedByte >> 6) & 0x3))
                        matches += parameters_matchScore;
                        else
                matches += parameters_mismatchScore;

            if (!((packedByte >> 4) & 0x3))
                        matches += parameters_matchScore;
                        else
                matches += parameters_mismatchScore;

            if (!((packedByte >> 2) & 0x3))
                        matches += parameters_matchScore;
                        else
                matches += parameters_mismatchScore;

            if (!(packedByte & 0x3))
                        matches += parameters_matchScore;
                        else
                matches += parameters_mismatchScore;

            PSSMatrix_packedScore[packedByte] = matches;

            packedByte++;
        }
        }

    // Make columns flanking the query sentinal columns
        PSSMatrix.matrix[-1] = scoreMatrix.matrix[encoding_sentinalCode];
        PSSMatrix.matrix[PSSMatrix.length] = scoreMatrix.matrix[encoding_sentinalCode];

        return PSSMatrix;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void PSSMatrix_free

(

struct PSSMatrix

PSSMatrix

)

Definition at line 346 of file PSSMatrix.c.

References PSSMatrix::bestMatchCodes, PSSMatrix::bytePackedCodes, encoding_alphabetType, encoding_nucleotide, PSSMatrix::matrix, PSSMatrix_packedLeftMatches, PSSMatrix_packedLeftMatchScores, PSSMatrix_packedRightMatches, PSSMatrix_packedRightMatchScores, PSSMatrix_packedScore, PSSMatrix::queryCodes, and PSSMatrix::xorCodes.

Referenced by blast_search().

{
        // Do not iterate through each column and free it, since PSSMatrix shares memory
        // with scoreMatrix, which will free the columns
        PSSMatrix.matrix--;
        free(PSSMatrix.matrix);
    free(PSSMatrix.queryCodes);
    free(PSSMatrix.bestMatchCodes);

    if (encoding_alphabetType == encoding_nucleotide)
    {
        free(PSSMatrix.bytePackedCodes - 4);
        free(PSSMatrix.xorCodes);
        free(PSSMatrix_packedRightMatches);
        free(PSSMatrix_packedLeftMatches);
        free(PSSMatrix_packedScore);
                free(PSSMatrix_packedRightMatchScores);
                free(PSSMatrix_packedLeftMatchScores);
        }
}

Here is the caller graph for this function:

void PSSMatrix_freeCopy

(

struct PSSMatrix

PSSMatrix

)

Definition at line 368 of file PSSMatrix.c.

References PSSMatrix::matrix, and PSSMatrix::queryCodes.

Referenced by smithWatermanScoring_scoreReverse().

{
        free(PSSMatrix.matrix);
    free(PSSMatrix.queryCodes);
}

Here is the caller graph for this function:

void PSSMatrix_print

(

struct PSSMatrix

PSSMatrix

)

Definition at line 319 of file PSSMatrix.c.

References constants_sentinalScore, encoding_numCodes, int4, PSSMatrix::length, and PSSMatrix::matrix.

{
        int4 x, y;

        // Iterate through each row
        y = 0;
        while (y < encoding_numCodes)
        {
                // For each cell in the row
                x = 0;
                while (x < PSSMatrix.length)
                {
                        // Print value
                        if (PSSMatrix.matrix[x][y] == constants_sentinalScore)
                                printf(" X ");
                        else if (PSSMatrix.matrix[x][y] >= 0 && PSSMatrix.matrix[x][y] <= 9)
                                printf(" %d ", PSSMatrix.matrix[x][y]);
                        else
                                printf("%d ", PSSMatrix.matrix[x][y]);
                        x++;
                }
                printf("\n");
                y++;
        }
}

struct PSSMatrix PSSMatrix_reverse

(

struct PSSMatrix

PSSMatrix

)

[read]

Definition at line 290 of file PSSMatrix.c.

References PSSMatrix::bestMatchCodes, PSSMatrix::bytePackedCodes, global_malloc(), PSSMatrix::highestValue, int2, PSSMatrix::length, PSSMatrix::lowestValue, PSSMatrix::matrix, PSSMatrix::queryCodes, PSSMatrix::strandLength, uint4, and PSSMatrix::xorCodes.

Referenced by smithWatermanScoring_scoreReverse().

{
        struct PSSMatrix reversed;
        uint4 queryPosition = 0;

        reversed.matrix = (int2**)global_malloc(sizeof(int2*) * (PSSMatrix.length + 2));
    reversed.queryCodes = (unsigned char*)global_malloc(sizeof(unsigned char) * (PSSMatrix.length));
        reversed.length = PSSMatrix.length;
        reversed.strandLength = PSSMatrix.strandLength;
        reversed.highestValue = PSSMatrix.highestValue;
        reversed.lowestValue = PSSMatrix.lowestValue;
    reversed.bestMatchCodes = NULL;
    reversed.bytePackedCodes = NULL;
    reversed.xorCodes = NULL;

    // Make and reverse matrix and query codes
    while (queryPosition < reversed.length)
    {
        reversed.matrix[queryPosition]
                = PSSMatrix.matrix[reversed.length - queryPosition - 1];
        reversed.queryCodes[queryPosition]
                = PSSMatrix.queryCodes[reversed.length - queryPosition - 1];
        queryPosition++;
    }

    return reversed;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint4 PSSMatrix_strandEnd	(	struct PSSMatrix	PSSMatrix,
		uint4	queryOffset
	)

Definition at line 260 of file PSSMatrix.c.

References PSSMatrix::length, and PSSMatrix::strandLength.

Referenced by unpack_getRegions().

{
        if (queryOffset > PSSMatrix.strandLength)
        return PSSMatrix.length;
    else
        return PSSMatrix.strandLength;
}

Here is the caller graph for this function:

uint4 PSSMatrix_strandStart	(	struct PSSMatrix	PSSMatrix,
		uint4	queryOffset
	)

Definition at line 251 of file PSSMatrix.c.

References PSSMatrix::strandLength.

Referenced by unpack_getRegions().

{
        if (queryOffset > PSSMatrix.strandLength)
        return PSSMatrix.strandLength;
    else
        return 0;
}

Here is the caller graph for this function:

---

Variable Documentation

unsigned char* PSSMatrix_packedLeftMatches

Definition at line 13 of file PSSMatrix.c.

Referenced by PSSMatrix_create(), PSSMatrix_free(), search_nucleotide(), search_nucleotide_largeTable(), and search_nucleotide_longWord().

int2* PSSMatrix_packedLeftMatchScores

Definition at line 15 of file PSSMatrix.c.

Referenced by PSSMatrix_create(), PSSMatrix_free(), ungappedExtension_checkHit(), and ungappedExtension_nucleotideExtend().

unsigned char* PSSMatrix_packedRightMatches

Definition at line 12 of file PSSMatrix.c.

Referenced by PSSMatrix_create(), PSSMatrix_free(), search_nucleotide(), search_nucleotide_largeTable(), and search_nucleotide_longWord().

int2* PSSMatrix_packedRightMatchScores

Definition at line 14 of file PSSMatrix.c.

Referenced by PSSMatrix_create(), PSSMatrix_free(), ungappedExtension_checkHit(), and ungappedExtension_nucleotideExtend().

char* PSSMatrix_packedScore

Definition at line 16 of file PSSMatrix.c.

Referenced by bytepackGappedScoring_dpAfterSeed(), bytepackGappedScoring_dpBeforeSeed(), bytepackGappedScoring_score(), fasterBytepackGappedScoring_dpAfterSeed(), fasterBytepackGappedScoring_dpBeforeSeed(), PSSMatrix_create(), PSSMatrix_free(), and ungappedExtension_nucleotideExtend().

---