int main()
{
int n=5;
int c=10;
int w[]={0,4,2,6,5,4};
int v[]={0,6,3,5,4,6};
int m[6][11];
int x[6];
int i,sum=0;
knapsack(v,w,c,n,m);
Traceback(m,w,c,n,x);
for(i=1;i<=n;i++){
printf("%d ",x[i]);
sum+=(x[i]*v[i]);
}
printf("\nsum=%d\n",sum);
return 0;
}
void main(void)
{
int p[6] = {0, 6, 3, 5, 4, 6};
int w[6] = {0, 2, 2, 6, 5, 4};
int x[6];
int **f;
int n = 5;
int c = 10;
Make2DArray(f, n+1, c+1);
Knapsack(p, w, c, n, f);
cout << "Optimal value is ";
cout << f[1][c] << endl;
cout << "Rest of table is" << endl;
for (int i = 2; i <= n; i++) {
for (int j = 0; j <= c; j++)
cout << f[i][j] << ' ';
cout << endl;}
Traceback(f,w,c,n,x);
for (int i = 1; i <= n; i++)
cout << x[i] << ' ';
cout << endl;
}
// aligns the query sequence to the anchor using the Smith Waterman Gotoh algorithm
void CBandedSmithWaterman::Align(Alignment& alignment, const char* s1, const unsigned int s1Length, const char* s2, const unsigned int s2Length, HashRegion& hr) {
// determine the hash region type
unsigned int rowOffset;
unsigned int columnOffset;
PositionType positionType;
if(hr.Begin == 0) {
if(hr.QueryBegin == 0) {
rowOffset = 1;
columnOffset = (mBandwidth / 2) + 1;
positionType = Position_REF_AND_QUERY_ZERO;
} else {
rowOffset = 1 - hr.QueryBegin;
columnOffset = (mBandwidth / 2) + 1 + hr.QueryBegin;
positionType = Position_REF_ZERO;
}
} else {
if(hr.QueryBegin == 0) {
rowOffset = 1;
columnOffset = (mBandwidth / 2) + 1 - hr.Begin;
positionType = Position_QUERY_ZERO;
} else {
rowOffset = 1 - hr.QueryBegin;
columnOffset = (mBandwidth / 2) + 1 + hr.QueryBegin - hr.Begin;
positionType = Position_REF_AND_QUERO_NONZERO;
}
}
// =========================
// Reinitialize the matrices
// =========================
ReinitializeMatrices(positionType, s1Length, s2Length, hr);
// =======================================
// Banded Smith-Waterman forward algorithm
// =======================================
unsigned int bestColumn = 0;
unsigned int bestRow = 0;
float bestScore = FLOAT_NEGATIVE_INFINITY;
float currentQueryGapScore;
// rowNum and column indicate the row and column numbers in the Smith-Waterman matrix respectively
unsigned int rowNum = hr.QueryBegin;
unsigned int columnNum = hr.Begin;
// indicates how many rows including blank elements in the Banded SmithWaterman
int numBlankElements = (mBandwidth / 2) - columnNum;
// upper triangle matrix in Banded Smith-Waterman
for( ; numBlankElements > 0; numBlankElements--, rowNum++){
// in the upper triangle matrix, we always start at the 0th column
columnNum = 0;
// columnEnd indicates how many columns which should be dealt with in the current row
unsigned int columnEnd = min((mBandwidth - numBlankElements), (s1Length - columnNum + 1) );
currentQueryGapScore = FLOAT_NEGATIVE_INFINITY;
for( unsigned int j = 0; j < columnEnd; j++){
float score = CalculateScore(s1, s2, rowNum, columnNum, currentQueryGapScore, rowOffset, columnOffset);
UpdateBestScore(bestRow, bestColumn, bestScore, rowNum, columnNum, score);
columnNum++;
}
// replace the columnNum to the middle column in the Smith-Waterman matrix
columnNum = columnNum - (mBandwidth / 2);
}
// complete matrix in Banded Smith-Waterman
unsigned int completeNum = min((s1Length - columnNum - (mBandwidth / 2)), (s2Length - rowNum));
for(unsigned int i = 0; i < completeNum; i++, rowNum++){
columnNum = columnNum - (mBandwidth / 2);
// there are mBandwidth columns which should be dealt with in each row
currentQueryGapScore = FLOAT_NEGATIVE_INFINITY;
for(unsigned int j = 0; j < mBandwidth; j++){
float score = CalculateScore(s1, s2, rowNum, columnNum, currentQueryGapScore, rowOffset, columnOffset);
UpdateBestScore(bestRow, bestColumn, bestScore, rowNum, columnNum, score);
columnNum++;
}
// replace the columnNum to the middle column in the Smith-Waterman matrix
// because mBandwidth is an odd number, everytime the following equation shifts a column (pluses 1).
columnNum = columnNum - (mBandwidth / 2);
}
// lower triangle matrix
numBlankElements = min(mBandwidth, (s2Length - rowNum));
columnNum = columnNum - (mBandwidth / 2);
for(unsigned int i = 0; numBlankElements > 0; i++, rowNum++, numBlankElements--) {
mBestScores[ mBandwidth - i ] = FLOAT_NEGATIVE_INFINITY;;
// columnEnd indicates how many columns which should be dealt with
currentQueryGapScore = FLOAT_NEGATIVE_INFINITY;
for( unsigned int j = columnNum; j < s1Length; j++){
float score = CalculateScore(s1, s2, rowNum, columnNum, currentQueryGapScore, rowOffset, columnOffset);
UpdateBestScore(bestRow, bestColumn, bestScore, rowNum, columnNum, score);
columnNum++;
}
// replace the columnNum to the middle column in the Smith-Waterman matrix
columnNum = columnNum - mBandwidth + i + 2;
}
// =========================================
// Banded Smith-Waterman backtrace algorithm
// =========================================
Traceback(alignment, s1, s2, s2Length, bestRow, bestColumn, rowOffset, columnOffset);
}
// aligns the query sequence to the anchor using the Smith Waterman Gotoh algorithm
void CBandedSmithWaterman::Align(unsigned int& referenceAl, string& cigarAl, const string& s1, const string& s2, pair< pair<unsigned int, unsigned int>, pair<unsigned int, unsigned int> >& hr) {
unsigned int rowStart = min(hr.first.first, (unsigned int)hr.second.first);
hr.first.first -= rowStart;
hr.second.first -= rowStart;
//bool isLegalBandWidth = (s2.length() - hr.QueryBegin) > (mBandwidth / 2);
// isLegalBandWidth = isLegalBandWidth && ((s1.length() - hr.Begin) > (mBandwidth / 2));
// check the lengths of the input sequences
//if( (s1.length() <= 0) || (s2.length() <= 0) || (s1.length() < s2.length()) ) {
// printf("ERROR: An unexpected sequence length was encountered during pairwise alignment.\n");
// printf("Sequence lengths are listed as following:\n");
// printf("1. Reference length: %u\n2. Query length: %u\n", s1.length(), s2.length());
//printf("3. Hash region in reference:%4u-%4u\n", hr.Begin + rowStart, hr.End);
//printf("4. Hash region in query: %4u-%4u\n", hr.QueryBegin + rowStart, hr.QueryEnd);
// exit(1);
//}
// determine the hash region type
unsigned int rowOffset;
unsigned int columnOffset;
PositionType positionType;
if(hr.first.first == 0) {
if(hr.second.first == 0) {
rowOffset = 1;
columnOffset = (mBandwidth / 2) + 1;
positionType = Position_REF_AND_QUERY_ZERO;
} else {
rowOffset = 1 - hr.second.first;
columnOffset = (mBandwidth / 2) + 1 + hr.second.first;
positionType = Position_REF_ZERO;
}
} else {
if(hr.second.first == 0) {
rowOffset = 1;
columnOffset = (mBandwidth / 2) + 1 - hr.first.first;
positionType = Position_QUERY_ZERO;
} else {
rowOffset = 1 - hr.second.first;
columnOffset = (mBandwidth / 2) + 1 + hr.second.first - hr.first.first;
positionType = Position_REF_AND_QUERO_NONZERO;
}
}
// =========================
// Reinitialize the matrices
// =========================
ReinitializeMatrices(positionType, s1.length(), s2.length(), hr);
// =======================================
// Banded Smith-Waterman forward algorithm
// =======================================
unsigned int bestColumn = 0;
unsigned int bestRow = 0;
float bestScore = FLOAT_NEGATIVE_INFINITY;
float currentQueryGapScore;
// rowNum and column indicate the row and column numbers in the Smith-Waterman matrix respectively
unsigned int rowNum = hr.second.first;
unsigned int columnNum = hr.first.first;
// indicates how many rows including blank elements in the Banded SmithWaterman
int numBlankElements = (mBandwidth / 2) - columnNum;
//cout << numBlankElements << endl;
// upper triangle matrix in Banded Smith-Waterman
for( ; numBlankElements > 0; numBlankElements--, rowNum++){
// in the upper triangle matrix, we always start at the 0th column
columnNum = 0;
// columnEnd indicates how many columns which should be dealt with in the current row
unsigned int columnEnd = min((mBandwidth - numBlankElements), ((unsigned int) s1.length() - columnNum + 1) );
currentQueryGapScore = FLOAT_NEGATIVE_INFINITY;
for( unsigned int j = 0; j < columnEnd; j++){
float score = CalculateScore(s1, s2, rowNum, columnNum, currentQueryGapScore, rowOffset, columnOffset);
//cout << s1[columnNum] << s2[rowNum] << score << endl;
UpdateBestScore(bestRow, bestColumn, bestScore, rowNum, columnNum, score);
columnNum++;
}
// replace the columnNum to the middle column in the Smith-Waterman matrix
columnNum = columnNum - (mBandwidth / 2);
}
// complete matrix in Banded Smith-Waterman
unsigned int completeNum = min((s1.length() - columnNum - (mBandwidth / 2)), (s2.length() - rowNum));
//cout << completeNum << endl;
for(unsigned int i = 0; i < completeNum; i++, rowNum++){
columnNum = columnNum - (mBandwidth / 2);
// there are mBandwidth columns which should be dealt with in each row
currentQueryGapScore = FLOAT_NEGATIVE_INFINITY;
for(unsigned int j = 0; j < mBandwidth; j++){
float score = CalculateScore(s1, s2, rowNum, columnNum, currentQueryGapScore, rowOffset, columnOffset);
UpdateBestScore(bestRow, bestColumn, bestScore, rowNum, columnNum, score);
//cout << s1[columnNum] << s2[rowNum] << score << endl;
columnNum++;
}
// replace the columnNum to the middle column in the Smith-Waterman matrix
// because mBandwidth is an odd number, everytime the following equation shifts a column (pluses 1).
columnNum = columnNum - (mBandwidth / 2);
}
// lower triangle matrix
numBlankElements = min(mBandwidth, ((unsigned int) s2.length() - rowNum));
columnNum = columnNum - (mBandwidth / 2);
for(unsigned int i = 0; numBlankElements > 0; i++, rowNum++, numBlankElements--) {
mBestScores[ mBandwidth - i ] = FLOAT_NEGATIVE_INFINITY;;
// columnEnd indicates how many columns which should be dealt with
currentQueryGapScore = FLOAT_NEGATIVE_INFINITY;
for( unsigned int j = columnNum; j < s1.length(); j++){
float score = CalculateScore(s1, s2, rowNum, columnNum, currentQueryGapScore, rowOffset, columnOffset);
UpdateBestScore(bestRow, bestColumn, bestScore, rowNum, columnNum, score);
//cout << s1[columnNum] << s2[rowNum] << score << endl;
columnNum++;
}
// replace the columnNum to the middle column in the Smith-Waterman matrix
columnNum = columnNum - mBandwidth + i + 2;
}
// =========================================
// Banded Smith-Waterman backtrace algorithm
// =========================================
Traceback(referenceAl, cigarAl, s1, s2, bestRow, bestColumn, rowOffset, columnOffset);
}
