main() {
double ans, a, b, c;
a = 2.0;
b = -5.0;
c = 7.0;
printf( "\n\n Test of utility routines." );
printf( "\n\n" );
ans = dsqr( a );
printf( "\n a = %lf ans = dsqr( a ) = %lf", a, ans );
ans = dcub( a );
printf( "\n a = %lf ans = dcub( a ) = %lf", a, ans );
ans = dpow4( a );
printf( "\n a = %lf ans = dpow4( a ) = %lf", a, ans );
ans = dpow5( a );
printf( "\n a = %lf ans = dpow5( a ) = %lf", a, ans );
ans = dsgn( a );
printf( "\n a = %lf ans = dsgn( a ) = %lf", a, ans );
ans = dsgn( b );
printf( "\n b = %lf ans = dsgn( b ) = %lf", b, ans );
ans = dsign( a, b );
printf( "\n a = %lf, b = %lf, ans = sign( a, b ) = %lf", a, b, ans );
ans = dpythag( a, b );
printf( "\n a = %lf, b = %lf, ans = pythag( a, b ) = %lf", a, b, ans );
ans = dmin( a, b );
printf( "\n a = %lf, b = %lf, ans = dmin( a, b ) = %lf", a, b, ans );
ans = dmax( a, b );
printf( "\n a = %lf, b = %lf, ans = dmax( a, b ) = %lf", a, b, ans );
ans = dmin3( a, b, c );
printf( "\n a = %lf, b = %lf, c = %lf, ans = dmin3( a, b, c ) = %lf", a, b, c, ans );
ans = dmax3( a, b, c );
printf( "\n a = %lf, b = %lf, c = %lf, ans = dmax3( a, b, c ) = %lf", a, b, c, ans );
printf( "\n\n" );
}
void needlemanWunsch(t_Align *ptAlign, const char* acA, const char* acB, int nLenA, int nLenB)
{
double **aadFMatrix = NULL;
int **aanMoves = NULL;
char *acAlignA = NULL, *acAlignB = NULL;
int nCount = 0;
int i = 0, j = 0, nD = 0, nR = 0;
aadFMatrix = (double **) malloc((nLenA + 1)*sizeof(double *));
aanMoves = (int **) malloc((nLenA + 1)*sizeof(int *));
if(!aadFMatrix || !aanMoves)
goto memoryError;
for(i = 0; i < nLenA + 1; i++){
aadFMatrix[i] = (double *) malloc((nLenB + 1)*sizeof(double));
aanMoves[i] = (int *) malloc((nLenB + 1)*sizeof(int));
if(!aadFMatrix[i] || !aanMoves[i])
goto memoryError;
for(j = 0; j < nLenB + 1; j++){
aadFMatrix[i][j] = 0.0;
aanMoves[i][j] = -1;
}
}
for(i = 0; i <= nLenA; i++){
aadFMatrix[i][0] = GAP_PENALTY*i;
aanMoves[i][0] = UP;
}
for(j = 0; j <= nLenB; j++){
aadFMatrix[0][j] = GAP_PENALTY*j;
aanMoves[0][j] = LEFT;
}
for(i = 1; i <= nLenA; i++){
for(j = 1; j <= nLenB; j++){
double dChoice1, dChoice2, dChoice3;
dChoice1 = aadFMatrix[i-1][j-1] + dist(acA[i - 1], acB[j - 1]);
if(i == nLenA){
dChoice2 = aadFMatrix[i][j-1];
}
else{
dChoice2 = aadFMatrix[i][j-1] + GAP_PENALTY;
}
if(j == nLenB){
dChoice3 = aadFMatrix[i-1][j];
}
else{
dChoice3 = aadFMatrix[i-1][j] + GAP_PENALTY;
}
aanMoves[i][j] = getMove(dChoice1, dChoice2, dChoice3);
aadFMatrix[i][j] = dmin3(dChoice1, dChoice2, dChoice3);
}
}
ptAlign->dDist = aadFMatrix[nLenA][nLenB];
acAlignA = (char *) malloc((nLenA + nLenB)*sizeof(char));
if(!acAlignA)
goto memoryError;
acAlignB = (char *) malloc((nLenA + nLenB)*sizeof(char));
if(!acAlignB)
goto memoryError;
for(i = 0; i < nLenA + nLenB; i++){
acAlignA[i] = GAP; acAlignB[i] = GAP;
}
nCount = 0;
i = nLenA; j = nLenB;
while(i > 0 && j > 0){
switch(aanMoves[i][j]){
case DIAG:
acAlignA[nCount] = acA[i - 1];
acAlignB[nCount] = acB[j - 1];
i--;
j--;
break;
case UP:
acAlignA[nCount] = acA[i - 1];
if(j == nLenB){
acAlignB[nCount] = T_GAP;
}
else{
acAlignB[nCount] = GAP;
}
i--;
break;
case LEFT:
if(i == nLenA){
acAlignA[nCount] = T_GAP;
}
else{
acAlignA[nCount] = GAP;
}
acAlignB[nCount] = acB[j - 1];
j--;
break;
}
nCount++;
}
while(i > 0){
acAlignA[nCount] = acA[i - 1];
acAlignB[nCount] = GAP;
i--;
nCount++;
}
while(j > 0){
acAlignA[nCount] = GAP;
acAlignB[nCount] = acB[j - 1];
j--;
nCount++;
}
ptAlign->nLen = nCount;
ptAlign->acA = (char *) malloc(ptAlign->nLen*sizeof(char));
if(!ptAlign->acA)
goto memoryError;
ptAlign->acB = (char *) malloc(ptAlign->nLen*sizeof(char));
if(!ptAlign->acB)
goto memoryError;
for(i = 0; i < ptAlign->nLen; i++){
ptAlign->acA[ptAlign->nLen - 1 -i] = acAlignA[i];
ptAlign->acB[ptAlign->nLen - 1 -i] = acAlignB[i];
}
ptAlign->dDist = calcDistance(acAlignA, acAlignB, ptAlign->nLen);
ptAlign->nComp = ptAlign->nLen;
while(ptAlign->nComp > 0 && ptAlign->acA[ptAlign->nComp - 1] == T_GAP || ptAlign->acB[ptAlign->nComp - 1] == T_GAP){
ptAlign->nComp--;
}
ptAlign->anD = (int *) malloc(nLenA*sizeof(int));
if(!ptAlign->anD)
goto memoryError;
ptAlign->anR = (int *) malloc(nLenA*sizeof(int));
if(!ptAlign->anR)
goto memoryError;
ptAlign->anMapD = (int *) malloc(nLenA*sizeof(int));
if(!ptAlign->anMapD)
goto memoryError;
ptAlign->anMapR = (int *) malloc(nLenA*sizeof(int));
if(!ptAlign->anMapR)
goto memoryError;
nCount = 0; nD = 0;
for(i = 0; i < ptAlign->nLen; i++){
if(ptAlign->acA[i] == GAP){
nD++;
}
else if(ptAlign->acA[i] == T_GAP){
}
else{
if(ptAlign->acB[i] == GAP){
nD++;
}
else if(ptAlign->acB[i] == T_GAP){
}
else if(ptAlign->acA[i] != ptAlign->acB[i]){
nD++;
}
ptAlign->anD[nCount] = nD;
ptAlign->anMapD[nCount] = i;
nCount++;
}
}
ptAlign->nDiff = nD;
nCount = 0; nR = 0;
for(i = ptAlign->nLen - 1; i >= 0; i--){
if(ptAlign->acA[i] == GAP){
nR++;
}
else if(ptAlign->acA[i] == T_GAP){
}
else{
if(ptAlign->acB[i] == GAP){
nR++;
}
else if(ptAlign->acB[i] == T_GAP){
nR++;
}
else if(ptAlign->acB[i] != ptAlign->acA[i]){
nR++;
}
ptAlign->anR[nCount] = nR;
ptAlign->anMapR[nCount] = i;
nCount++;
}
}
for(i = 0; i <= nLenA; i++){
free(aadFMatrix[i]);
free(aanMoves[i]);
}
free(aadFMatrix);
free(aanMoves);
free(acAlignA);
free(acAlignB);
return;
memoryError:
fprintf(stderr, "Failed to allocate memory in needlemanWunsch\n");
fflush(stderr);
exit(EXIT_FAILURE);
}
double needlemanWunsch(const char* acA, const char* acB, int nLenA, int nLenB, int nM)
{
double **aadFMatrix = NULL;
int **aanMoves = NULL;
int **aanHA = NULL;
int **aanHB = NULL;
int anHA[nLenA + nLenB];
int anHB[nLenA + nLenB];
char *acAlignA = NULL, *acAlignB = NULL;
int nCount = 0, nLen = 0, nComp = 0;
int i = 0, j = 0;
double dDist = 0.0;
aadFMatrix = (double **) malloc((nLenA + 1)*sizeof(double *));
aanMoves = (int **) malloc((nLenA + 1)*sizeof(int *));
aanHA = (int **) malloc((nLenA + 1)*sizeof(int *));
aanHB = (int **) malloc((nLenA + 1)*sizeof(int *));
if(!aadFMatrix || !aanMoves)
goto memoryError;
for(i = 0; i < nLenA + 1; i++){
aadFMatrix[i] = (double *) malloc((nLenB + 1)*sizeof(double));
aanMoves[i] = (int *) malloc((nLenB + 1)*sizeof(int));
aanHA[i] = (int *) malloc((nLenB + 1)*sizeof(int));
aanHB[i] = (int *) malloc((nLenB + 1)*sizeof(int));
if(!aadFMatrix[i] || !aanMoves[i])
goto memoryError;
for(j = 0; j < nLenB + 1; j++){
aadFMatrix[i][j] = 0.0;
aanMoves[i][j] = -1;
aanHA[i][j] = -1;
aanHB[i][j] = -1;
}
}
for(i = 0; i <= nLenA; i++){
aadFMatrix[i][0] = GAP_PENALTY*i;
aanMoves[i][0] = UP;
aanHA[i][0] = 0;
aanHB[i][0] = 0;
}
for(j = 0; j <= nLenB; j++){
aadFMatrix[0][j] = GAP_PENALTY*j;
aanMoves[0][j] = LEFT;
aanHA[0][j] = 0;
aanHB[0][j] = 0;
}
for(i = 1; i <= nLenA; i++){
for(j = 1; j <= nLenB; j++){
double dChoice1, dChoice2, dChoice3;
dChoice1 = aadFMatrix[i-1][j-1] + dist(acA[i - 1], acB[j - 1]);
if(i == nLenA){
dChoice2 = aadFMatrix[i][j-1];
}
else{
double dGap = 0.0;
int nCurrH = aanHA[i][j - 1];
int nNewH = returnHomopolymerA(LEFT, aanHA, aanMoves, i, j, acA, acB);
/*Left gap in A*/
if(nNewH == 0){
dGap = GAP_PENALTY;
}
else{
dGap = HOMOPOLYMER_PENALTY;
}
dChoice2 = aadFMatrix[i][j-1] + dGap;
}
if(j == nLenB){
dChoice3 = aadFMatrix[i-1][j];
}
else{
double dGap = 0.0;
int nCurrH = aanHA[i][j - 1];
int nNewH = returnHomopolymerA(LEFT, aanHA, aanMoves, i, j, acA, acB);
/*Left gap in A*/
if(nNewH == 0){
dGap = GAP_PENALTY;
}
else{
dGap = HOMOPOLYMER_PENALTY;
}
/*Up gap in B*/
dChoice3 = aadFMatrix[i-1][j] + dGap;
}
aanMoves[i][j] = getMove(dChoice1, dChoice2, dChoice3);
aadFMatrix[i][j] = dmin3(dChoice1, dChoice2, dChoice3);
updateHomopolymers(aanHA, aanHB, aanMoves, i, j, acA, acB);
}
}
dDist = aadFMatrix[nLenA][nLenB];
acAlignA = (char *) malloc((nLenA + nLenB)*sizeof(char));
if(!acAlignA)
goto memoryError;
acAlignB = (char *) malloc((nLenA + nLenB)*sizeof(char));
if(!acAlignB)
goto memoryError;
for(i = 0; i < nLenA + nLenB; i++){
acAlignA[i] = GAP; acAlignB[i] = GAP;
}
nCount = 0;
i = nLenA; j = nLenB;
while(i > 0 && j > 0){
anHA[nCount] = aanHA[i][j];
anHB[nCount] = aanHB[i][j];
switch(aanMoves[i][j]){
case DIAG:
acAlignA[nCount] = acA[i - 1];
acAlignB[nCount] = acB[j - 1];
i--;
j--;
break;
case UP:
acAlignA[nCount] = acA[i - 1];
if(j == nLenB){
acAlignB[nCount] = T_GAP;
}
else{
acAlignB[nCount] = GAP;
}
i--;
break;
case LEFT:
if(i == nLenA){
acAlignA[nCount] = T_GAP;
}
else{
acAlignA[nCount] = GAP;
}
acAlignB[nCount] = acB[j - 1];
j--;
break;
}
nCount++;
}
while(i > 0){
acAlignA[nCount] = acA[i - 1];
acAlignB[nCount] = GAP;
anHA[nCount] = aanHA[i][j];
anHB[nCount] = aanHB[i][j];
i--;
nCount++;
}
while(j > 0){
acAlignA[nCount] = GAP;
acAlignB[nCount] = acB[j - 1];
anHA[nCount] = aanHA[i][j];
anHB[nCount] = aanHB[i][j];
j--;
nCount++;
}
nLen = nCount;
i = 0;
while(acAlignA[i] == T_GAP || acAlignB[i] == T_GAP){
i++;
}
nComp = nLen - i;
dDist = aadFMatrix[nLenA][nLenB]/((double) nComp); //normalise by M * true length not with terminal gaps
free(acAlignA); free(acAlignB);
for(i = 0; i <= nLenA; i++){
free(aadFMatrix[i]);
free(aanMoves[i]);
free(aanHA[i]);
free(aanHB[i]);
}
free(aadFMatrix);
free(aanMoves);
free(aanHA);
free(aanHB);
return dDist;
memoryError:
fprintf(stderr, "Failed to allocate memory in needlemanWunsch\n");
fflush(stderr);
exit(EXIT_FAILURE);
}
void needlemanWunsch(double *adFookUp, double* adF1,
double* adF2, t_Align *ptAlign, int* anA,
int* anB, int nLenA, int nLenB)
{
double **aadFMatrix = NULL;
int **aanMoves = NULL;
int *anPath = NULL;
int nCount = 0;
int i = 0, j = 0, k = 0;
aadFMatrix = (double **) malloc((nLenA + 1)*sizeof(double *));
aanMoves = (int **) malloc((nLenA + 1)*sizeof(int *));
if(!aadFMatrix || !aanMoves)
goto memoryError;
anPath = (int *) malloc(sizeof(int)*(nLenA + nLenB));
if(!anPath)
goto memoryError;
for(i = 0; i < nLenA + 1; i++){
aadFMatrix[i] = (double *) malloc((nLenB + 1)*sizeof(double));
aanMoves[i] = (int *) malloc((nLenB + 1)*sizeof(int));
if(!aadFMatrix[i] || !aanMoves[i])
goto memoryError;
for(j = 0; j < nLenB + 1; j++){
aadFMatrix[i][j] = 0.0;
aanMoves[i][j] = -1;
}
}
for(i = 0; i <= nLenA; i++){
aadFMatrix[i][0] = GAP_PENALTY*i;
aanMoves[i][0] = UP;
}
for(j = 0; j <= nLenB; j++){
aadFMatrix[0][j] = GAP_PENALTY*j;
aanMoves[0][j] = LEFT;
}
//printf("allocated memory %d %d\n",nLenA,nLenB); fflush(stdout);
for(i = 1; i <= nLenA; i++){
for(j = 1; j <= nLenB; j++){
double dChoice1, dChoice2, dChoice3;
dChoice1 = aadFMatrix[i-1][j-1] + adFookUp[anA[i - 1]*BINS + anB[j - 1]] - adF1[i - 1] - adF2[j - 1];
if(j >= 4){
if(i == nLenA){
dChoice2 = aadFMatrix[i][j-4];
}
else{
dChoice2 = aadFMatrix[i][j-4] + 4.0*GAP_PENALTY;
}
}
else{
dChoice2 = MAX_DBL;
}
if(i >= 4){
if(j == nLenB){
dChoice3 = aadFMatrix[i-4][j];
}
else{
dChoice3 = aadFMatrix[i-4][j] + 4.0*GAP_PENALTY;
}
}
else{
dChoice3 = MAX_DBL;
}
aanMoves[i][j] = getMove(dChoice1, dChoice2, dChoice3);
aadFMatrix[i][j] = dmin3(dChoice1, dChoice2, dChoice3);
}
}
ptAlign->dDist = aadFMatrix[nLenA][nLenB];
i = nLenA; j = nLenB;
while(i > 0 && j > 0){
anPath[nCount] = aanMoves[i][j];
switch(aanMoves[i][j]){
case DIAG:
i--;
j--;
nCount++;
break;
case UP:
i--;
nCount++;
k = 1;
while(k < 4 && i >= 0){
anPath[nCount] = UP;
i--;
k++;
nCount++;
}
break;
case LEFT:
j--;
nCount++;
while(k < 4 && j >= 0){
anPath[nCount] = LEFT;
j--;
k++;
nCount++;
}
break;
}
}
while(i > 0){
anPath[nCount] = aanMoves[i][j];
i--;
nCount++;
}
while(j > 0){
anPath[nCount] = aanMoves[i][j];
j--;
nCount++;
}
ptAlign->nLen = nCount;
ptAlign->nComp = nCount;
if(anPath[0] != DIAG){
int nStart = anPath[0];
i = 0;
while(anPath[i] == nStart && i < nCount){
ptAlign->nComp--;
i++;
}
}
//printf("free memory %d %d\n",nLenA,nLenB); fflush(stdout);
/*free up memory*/
free(anPath);
for(i = 0; i <= nLenA; i++){
free(aadFMatrix[i]);
free(aanMoves[i]);
}
free(aadFMatrix);
free(aanMoves);
return;
memoryError:
fprintf(stderr, "Failed to allocate memory in needlemanWunsch\n");
fflush(stderr);
exit(EXIT_FAILURE);
}
