id
int64 0
877k
| file_name
stringlengths 3
109
| file_path
stringlengths 13
185
| content
stringlengths 31
9.38M
| size
int64 31
9.38M
| language
stringclasses 1
value | extension
stringclasses 11
values | total_lines
int64 1
340k
| avg_line_length
float64 2.18
149k
| max_line_length
int64 7
2.22M
| alphanum_fraction
float64 0
1
| repo_name
stringlengths 6
66
| repo_stars
int64 94
47.3k
| repo_forks
int64 0
12k
| repo_open_issues
int64 0
3.4k
| repo_license
stringclasses 11
values | repo_extraction_date
stringclasses 197
values | exact_duplicates_redpajama
bool 2
classes | near_duplicates_redpajama
bool 2
classes | exact_duplicates_githubcode
bool 2
classes | exact_duplicates_stackv2
bool 1
class | exact_duplicates_stackv1
bool 2
classes | near_duplicates_githubcode
bool 2
classes | near_duplicates_stackv1
bool 2
classes | near_duplicates_stackv2
bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
1,537,938
|
alpha2.cpp
|
rcedgar_urmap/src/alpha2.cpp
|
#include "myutils.h"
#include "alpha.h"
/***
IUPAC nucleotide ambiguity codes
-------------------------------
Symbol Meaning Nucleic Acid
-------------------------------
A A Adenine
C C Cytosine
G G Guanine
T T Thymine
U U Uracil
M A or C
R A or G
W A or T
S C or G
Y C or T
K G or T
V A or C or G
H A or C or T
D A or G or T
B C or G or T
X G or A or T or C
N G or A or T or C
Reference:
IUPAC-IUB SYMBOLS FOR NUCLEOTIDE NOMENCLATURE:
Cornish-Bowden (1985) Nucl. Acids Res. 13: 3021-3030.
***/
struct IUPAC_Code
{
char Code;
const char *Chars;
char CompCode;
};
static IUPAC_Code IUPAC_Codes[] =
{
// Code Means Comp CompCode
{ 'M', "AC", 'K' }, // GT K
{ 'R', "AG", 'Y' }, // CT Y
{ 'W', "AT", 'W' }, // AT W
{ 'S', "CG", 'S' }, // CG S
{ 'Y', "CT", 'R' }, // AG R
{ 'K', "GT", 'M' }, // AC M
{ 'V', "ACG", 'B' }, // CGT B
{ 'H', "ACT", 'D' }, // AGT D
{ 'D', "AGT", 'H' }, // ACT H
{ 'B', "CGT", 'V' }, // ACG V
{ 'X', "GATC", 'X' }, // ACGT X
{ 'N', "GATC", 'N' }, // ACGT N
};
static const unsigned IUPAC_Code_Count = sizeof(IUPAC_Codes)/sizeof(IUPAC_Codes[0]);
static byte BIT_A = 0x1;
static byte BIT_C = 0x2;
static byte BIT_G = 0x4;
static byte BIT_T = 0x8;
static byte g_Nucleo_CharToBit[256];
static byte g_IUPAC_CharToBits[256];
static byte g_IUPAC_BitsToChar[256];
static byte g_IUPAC_CharToCompChar[256];
byte g_IUPAC_PairCharToChar1[256];
byte g_IUPAC_PairCharToChar2[256];
byte g_IUPAC_PairCharToCharCase[256];
bool **g_MatchMxAmino;
bool **g_MatchMxNucleo;
static inline bool IUPAC_Eq(unsigned char Char, unsigned char CharOrWildcard)
{
unsigned char Bit = g_Nucleo_CharToBit[Char];
unsigned char Bits = g_IUPAC_CharToBits[CharOrWildcard];
if ((Bit & Bits) == 0)
return false;
return true;
}
byte IUPAC_Pair(byte CharOrWildcard1, byte CharOrWildcard2)
{
byte Bits1 = g_IUPAC_CharToBits[CharOrWildcard1];
byte Bits2 = g_IUPAC_CharToBits[CharOrWildcard2];
byte Pair = g_IUPAC_BitsToChar[Bits1 | Bits2];
return Pair;
}
static void Init_IUPAC()
{
for (unsigned k = 0; k < 256; ++k)
g_IUPAC_CharToCompChar[k] = k;
g_Nucleo_CharToBit['a'] = BIT_A;
g_Nucleo_CharToBit['A'] = BIT_A;
g_Nucleo_CharToBit['c'] = BIT_C;
g_Nucleo_CharToBit['C'] = BIT_C;
g_Nucleo_CharToBit['g'] = BIT_G;
g_Nucleo_CharToBit['G'] = BIT_G;
g_Nucleo_CharToBit['t'] = BIT_T;
g_Nucleo_CharToBit['T'] = BIT_T;
g_Nucleo_CharToBit['u'] = BIT_T;
g_Nucleo_CharToBit['U'] = BIT_T;
g_IUPAC_CharToBits['a'] = BIT_A;
g_IUPAC_CharToBits['A'] = BIT_A;
g_IUPAC_CharToBits['c'] = BIT_C;
g_IUPAC_CharToBits['C'] = BIT_C;
g_IUPAC_CharToBits['g'] = BIT_G;
g_IUPAC_CharToBits['G'] = BIT_G;
g_IUPAC_CharToBits['t'] = BIT_T;
g_IUPAC_CharToBits['T'] = BIT_T;
g_IUPAC_CharToBits['u'] = BIT_T;
g_IUPAC_CharToBits['U'] = BIT_T;
g_IUPAC_CharToCompChar['A'] = 'T';
g_IUPAC_CharToCompChar['a'] = 't';
g_IUPAC_CharToCompChar['C'] = 'G';
g_IUPAC_CharToCompChar['c'] = 'g';
g_IUPAC_CharToCompChar['G'] = 'C';
g_IUPAC_CharToCompChar['g'] = 'c';
g_IUPAC_CharToCompChar['T'] = 'A';
g_IUPAC_CharToCompChar['t'] = 'a';
g_IUPAC_CharToCompChar['U'] = 'A';
g_IUPAC_CharToCompChar['u'] = 'a';
for (unsigned k = 0; k < IUPAC_Code_Count; ++k)
{
IUPAC_Code &IC = IUPAC_Codes[k];
byte Code = IC.Code;
byte CompCode = IC.CompCode;
g_IUPAC_CharToCompChar[Code] = CompCode;
byte Bits = 0;
for (const char *p = IC.Chars; *p; ++p)
{
byte Char = (byte) *p;
byte Bit = g_Nucleo_CharToBit[Char];
Bits |= Bit;
}
g_IUPAC_CharToBits[toupper(Code)] = Bits;
g_IUPAC_CharToBits[tolower(Code)] = Bits;
}
for (unsigned Bits = 0; Bits < 255; ++Bits)
{
g_IUPAC_BitsToChar[Bits] = 'N';
g_IUPAC_PairCharToChar1[Bits] = 'N';
g_IUPAC_PairCharToChar2[Bits] = 'N';
}
for (unsigned Char = 0; Char < 255; ++Char)
{
g_IUPAC_PairCharToCharCase[Char] = 'N';
byte Bits = g_IUPAC_CharToBits[Char];
if (Bits != 0)
g_IUPAC_BitsToChar[Bits] = Char;
}
const char *ACGT = "ACGT";
for (unsigned i = 0; i < 4; ++i)
{
char ci = ACGT[i];
for (unsigned j = 0; j < 4; ++j)
{
char cj = ACGT[j];
char PairChar = IUPAC_Pair(ci, cj);
g_IUPAC_PairCharToChar1[PairChar] = ci;
g_IUPAC_PairCharToChar2[PairChar] = cj;
PairChar = tolower(PairChar);
g_IUPAC_PairCharToChar1[PairChar] = ci;
g_IUPAC_PairCharToChar2[PairChar] = cj;
char Firstc = (ci > cj ? ci : cj);
char Secondc = (ci < cj ? ci : cj);
g_IUPAC_PairCharToCharCase[toupper(PairChar)] = Firstc;
g_IUPAC_PairCharToCharCase[tolower(PairChar)] = Secondc;
}
}
#if DEBUG
for (unsigned k = 0; k < 256; ++k)
assert(g_IUPAC_CharToCompChar[g_IUPAC_CharToCompChar[k]] == k || toupper(k) == 'U');
assert( IUPAC_Eq('a', 'A'));
assert( IUPAC_Eq('A', 'A'));
assert( IUPAC_Eq('A', 'M'));
assert( IUPAC_Eq('C', 'M'));
assert(!IUPAC_Eq('G', 'M'));
assert(!IUPAC_Eq('T', 'M'));
assert( IUPAC_Eq('A', 'V'));
assert( IUPAC_Eq('C', 'V'));
assert( IUPAC_Eq('G', 'V'));
assert(!IUPAC_Eq('T', 'V'));
assert( IUPAC_Eq('A', 'N'));
assert( IUPAC_Eq('C', 'N'));
assert( IUPAC_Eq('G', 'N'));
assert( IUPAC_Eq('T', 'N'));
#endif
}
static void Init_MatchMxs()
{
g_MatchMxAmino = myalloc(bool *, 256);
g_MatchMxNucleo = myalloc(bool *, 256);
for (unsigned i = 0; i < 256; ++i)
{
g_MatchMxAmino[i] = myalloc(bool, 256);
g_MatchMxNucleo[i] = myalloc(bool, 256);
bool IsAlphai = (isalpha(i) != 0);
unsigned CharBitsi = g_IUPAC_CharToBits[i];
for (unsigned j = 0; j < 256; ++j)
{
bool IsAlphaj = (isalpha(j) != 0);
if (!IsAlphai || !IsAlphaj)
{
if (isgap(i) && isgap(j))
{
g_MatchMxAmino[i][j] = true;
g_MatchMxNucleo[i][j] = true;
}
else
{
g_MatchMxAmino[i][j] = false;
g_MatchMxNucleo[i][j] = false;
}
continue;
}
if (toupper(i) == toupper(j))
{
g_MatchMxAmino[i][j] = true;
g_MatchMxNucleo[i][j] = true;
continue;
}
if (i == 'X')
g_MatchMxAmino[i][j] = true;
else
g_MatchMxAmino[i][j] = false;
bool Eqij = IUPAC_Eq(i, j);
bool Eqji = IUPAC_Eq(j, i);
g_MatchMxNucleo[i][j] = (Eqij || Eqji);
}
}
// B=N or D, Z=Q or E
g_MatchMxAmino['B']['N'] = true;
g_MatchMxAmino['N']['B'] = true;
g_MatchMxAmino['B']['D'] = true;
g_MatchMxAmino['D']['B'] = true;
g_MatchMxAmino['Z']['Q'] = true;
g_MatchMxAmino['Q']['Z'] = true;
g_MatchMxAmino['Z']['E'] = true;
g_MatchMxAmino['E']['Z'] = true;
#if 0
{
Log("\n");
Log(" x y a n\n");
for (unsigned i = 0; i < 256; ++i)
for (unsigned j = 0; j < 256; ++j)
{
if (!g_MatchMxAmino[i][j] && !g_MatchMxNucleo[i][j])
continue;
if (isalpha(i))
Log("%4c", i);
else
Log("0x%02x", i);
if (isalpha(j))
Log(" %4c", j);
else
Log(" 0x%02x", j);
Log(" %c", tof(g_MatchMxAmino[i][j]));
Log(" %c", tof(g_MatchMxNucleo[i][j]));
Log("\n");
}
}
#endif
}
void InitAlpha()
{
Init_IUPAC();
Init_MatchMxs();
}
const char *WordToStrAmino(unsigned Word, unsigned WordLength)
{
static char Str[32];
for (unsigned i = 0; i < WordLength; ++i)
{
unsigned Letter = Word%20;
Str[WordLength-i-1] = g_LetterToCharAmino[Letter];
Word /= 20;
}
Str[WordLength] = 0;
return Str;
}
const char *WordToStrAmino2(unsigned Word, unsigned WordLength, char *Str)
{
for (unsigned i = 0; i < WordLength; ++i)
{
unsigned Letter = Word%20;
Str[WordLength-i-1] = g_LetterToCharAmino[Letter];
Word /= 20;
}
Str[WordLength] = 0;
return Str;
}
const char *WordToStrNucleo(unsigned Word, unsigned WordLength)
{
static char Str[32];
for (unsigned i = 0; i < WordLength; ++i)
{
unsigned Letter = Word%4;
Str[WordLength-i-1] = g_LetterToCharNucleo[Letter];
Word /= 4;
}
Str[WordLength] = 0;
return Str;
}
const char *WordToStr(unsigned Word, unsigned WordLength, bool Nucleo)
{
return (Nucleo ? WordToStrNucleo : WordToStrAmino)(Word, WordLength);
}
byte *RevCompAlloc(const byte *Seq, unsigned L)
{
byte *RCSeq = myalloc(byte, L);
for (unsigned i = 0; i < L; ++i)
RCSeq[L-i-1] = g_CharToCompChar[Seq[i]];
return RCSeq;
}
void RevCompInPlace(byte *Seq, unsigned L)
{
unsigned L1 = L - 1;
unsigned L2 = L/2;
for (unsigned i = 0; i < L2; ++i)
{
unsigned j = L1 - i;
unsigned ci = Seq[i];
unsigned cj = Seq[j];
unsigned ri = g_CharToCompChar[ci];
unsigned rj = g_CharToCompChar[cj];
Seq[i] = rj;
Seq[j] = ri;
}
if (L%2 == 1)
Seq[L2] = g_CharToCompChar[Seq[L2]];
}
void RevComp(const byte *Seq, unsigned L, byte *RCSeq)
{
for (unsigned i = 0; i < L; ++i)
RCSeq[L-i-1] = g_CharToCompChar[Seq[i]];
}
void RevCompIUPAC(const byte *Seq, unsigned L, byte *RCSeq)
{
for (unsigned i = 0; i < L; ++i)
RCSeq[L-i-1] = g_IUPAC_CharToCompChar[Seq[i]];
}
unsigned char GetAminoCharFrom3NucChars(unsigned char c1, unsigned char c2,
unsigned char c3)
{
unsigned Letter1 = g_CharToLetterNucleo[c1];
unsigned Letter2 = g_CharToLetterNucleo[c2];
unsigned Letter3 = g_CharToLetterNucleo[c3];
unsigned Word = Letter1*(4*4) + Letter2*4 + Letter3;
unsigned Letter = g_CodonWordToAminoLetter[Word];
return g_LetterToCharAmino[Letter];
}
| 9,277
|
C++
|
.cpp
| 343
| 24.355685
| 86
| 0.614395
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| true
| false
| true
| false
|
1,537,939
|
search1pepend.cpp
|
rcedgar_urmap/src/search1pepend.cpp
|
#include "myutils.h"
#include "ufindex.h"
#include "seqinfo.h"
#include "alpha.h"
#include "state1.h"
#include "omplock.h"
#include <inttypes.h>
void State1::SearchPE_Pending(unsigned k)
{
const byte *Q = m_Query->m_Seq;
const unsigned QL = m_Query->m_L;
unsigned QWordCount = QL - (m_WordLength - 1);
m_MaxPenalty = MAX_PENALTY;
dpscore MinScorePhase1 = dpscore(QL) + XPHASE1*MISMATCH_SCORE;
dpscore MinScorePhase3 = dpscore(QL) + XPHASE3*MISMATCH_SCORE;
dpscore MinScorePhase4 = dpscore(QL) + XPHASE4*MISMATCH_SCORE;
dpscore TermHSPScorePhase3 = (dpscore(QL)*TERM_HSP_SCORE_PCT_PHASE3)/100;
uint32 QPos;
bool Plus;
uint32 DBPos;
while (k != UINT_MAX)
k = GetNextBoth1SeedEx(k, QPos, Plus, DBPos);
if (m_BestScore >= MinScorePhase1)
{
m_Mapq = CalcMAPQ6();
return;
}
if (m_BestHSPScore >= TermHSPScorePhase3)
{
for (unsigned i = 0; i < m_HSPCount; ++i)
AlignHSP(i);
if (m_BestScore >= MinScorePhase1)
{
m_Mapq = CalcMAPQ6();
return;
}
}
const uint64 *SlotsVec_Plus = m_SlotsVec_Plus;
const uint64 *SlotsVec_Minus = m_SlotsVec_Minus;
byte *BlobVec_Plus = m_BlobVec_Plus;
byte *BlobVec_Minus = m_BlobVec_Minus;
uint32 *PosVec = m_PosVec;
// Pending Plus round 1
unsigned QPosPendingCount_Plus2 = 0;
for (unsigned i = 0; i < m_QPosPendingCount_Plus; ++i)
{
unsigned QPos = m_QPosPendingVec_Plus[i];
uint64 Slot = SlotsVec_Plus[QPos];
unsigned RowLength = m_UFI->GetRow_Blob(Slot, BlobVec_Plus + 5*QPos, PosVec);
if (RowLength > 2)
{
m_QPosPendingVec_Plus[QPosPendingCount_Plus2++] = QPos;
continue;
}
for (unsigned RowIndex = 0; RowIndex < RowLength; ++RowIndex)
{
uint32 SeedPosDB = PosVec[RowIndex];
ExtendPen(QPos, SeedPosDB, true);
}
}
// Pending Minus round 1
unsigned QPosPendingCount_Minus2 = 0;
for (unsigned i = 0; i < m_QPosPendingCount_Minus; ++i)
{
unsigned QPos = m_QPosPendingVec_Minus[i];
uint64 Slot = SlotsVec_Minus[QPos];
unsigned RowLength = m_UFI->GetRow_Blob(Slot, BlobVec_Minus + 5*QPos, PosVec);
if (RowLength > 2)
{
m_QPosPendingVec_Minus[QPosPendingCount_Minus2++] = QPos;
continue;
}
for (unsigned RowIndex = 0; RowIndex < RowLength; ++RowIndex)
{
uint32 SeedPosDB = PosVec[RowIndex];
ExtendPen(QPos, SeedPosDB, false);
}
}
//if (m_BestScore >= MinScorePhase3)
// {
// m_Mapq = CalcMAPQ6();
// return;
// }
// Pending Plus round 2
for (unsigned i = 0; i < QPosPendingCount_Plus2; ++i)
{
unsigned QPos = m_QPosPendingVec_Plus[i];
uint64 Slot = SlotsVec_Plus[QPos];
unsigned RowLength = m_UFI->GetRow_Blob(Slot, BlobVec_Plus + 5*QPos, PosVec);
asserta(RowLength > 2);
for (unsigned RowIndex = 0; RowIndex < RowLength; ++RowIndex)
{
uint32 SeedPosDB = PosVec[RowIndex];
ExtendPen(QPos, SeedPosDB, true);
}
}
// Pending Minus round 2
for (unsigned i = 0; i < QPosPendingCount_Minus2; ++i)
{
unsigned QPos = m_QPosPendingVec_Minus[i];
uint64 Slot = SlotsVec_Minus[QPos];
unsigned RowLength = m_UFI->GetRow_Blob(Slot, BlobVec_Minus + 5*QPos, PosVec);
asserta(RowLength > 2);
for (unsigned RowIndex = 0; RowIndex < RowLength; ++RowIndex)
{
uint32 SeedPosDB = PosVec[RowIndex];
ExtendPen(QPos, SeedPosDB, false);
}
}
int B = max(m_BestScore, m_BestHSPScore) - 8;
for (unsigned i = 0; i < m_HSPCount; ++i)
{
const UFIHSP *HSP = GetHSP(i);
if (HSP->m_Score < B)
continue;
AlignHSP(i);
}
m_Mapq = CalcMAPQ6();
}
| 3,445
|
C++
|
.cpp
| 119
| 26.10084
| 80
| 0.692911
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,940
|
globalalignmem.cpp
|
rcedgar_urmap/src/globalalignmem.cpp
|
#include "myutils.h"
#include "seqinfo.h"
#include "xdpmem.h"
#include "hspfinder.h"
#include "alnheuristics.h"
#include "alignresult.h"
#include "alnparams.h"
#include "objmgr.h"
#include "pathinfo.h"
#include "hsp.h"
#include "cmd.h"
#define TRACE 0
void LogAlnPretty(const byte *A, const byte *B, const char *Path,
bool StripTermGaps);
float ViterbiFastMem(XDPMem &Mem, const byte *A, unsigned LA,
const byte *B, unsigned LB, const AlnParams &AP, PathInfo &PI);
float ViterbiFastMainDiagMem(XDPMem &Mem, const byte *A, unsigned LA,
const byte *B, unsigned LB, unsigned BandRadius, const AlnParams &AP,
PathInfo &PI);
void GetHole(const HSPData *HSP1, const HSPData *HSP2,
unsigned LA, unsigned LB, HSPData &Hole)
{
if (HSP1 != 0)
{
asserta(HSP1->Leni <= LA && HSP1->GetHii() < LA);
asserta(HSP1->Lenj <= LB && HSP1->GetHij() < LB);
}
if (HSP2 != 0)
{
asserta(HSP2->Leni <= LA && HSP2->GetHii() < LA);
asserta(HSP2->Lenj <= LB && HSP2->GetHij() < LB);
}
if (HSP1 != 0 && HSP2 != 0)
{
Hole.Loi = HSP1->GetHii() + 1;
Hole.Loj = HSP1->GetHij() + 1;
asserta(HSP2->Loi > HSP1->GetHii());
asserta(HSP2->Loj > HSP1->GetHij());
Hole.Leni = HSP2->Loi - HSP1->GetHii() - 1;
Hole.Lenj = HSP2->Loj - HSP1->GetHij() - 1;
}
else if (HSP1 == 0 && HSP2 != 0)
{
Hole.Loi = 0;
Hole.Loj = 0;
Hole.Leni = HSP2->Loi;
Hole.Lenj = HSP2->Loj;
}
else if (HSP1 != 0 && HSP2 == 0)
{
Hole.Loi = HSP1->GetHii() + 1;
Hole.Loj = HSP1->GetHij() + 1;
Hole.Leni = LA - Hole.Loi;
Hole.Lenj = LB - Hole.Loj;
}
else
Die("GetSPHole(0,0)");
}
static void AlignHSPMem(XDPMem &Mem, const byte *A, unsigned LA,
const byte *B, unsigned LB, const HSPData &HSP, const AlnParams &AP,
const AlnHeuristics &AH, PathInfo &PI)
{
StartTimer(AlignSPMem);
unsigned SLA = HSP.Leni;
unsigned SLB = HSP.Lenj;
PI.SetEmpty();
if (SLA == 0)
{
if (SLB > 0)
{
PI.Alloc(SLB+8);
PI.AppendIs(SLB);
}
EndTimer(AlignSPMem);
return;
}
if (SLB == 0)
{
if (SLA > 0)
{
PI.Alloc(SLA+8);
PI.AppendDs(SLA);
}
EndTimer(AlignSPMem);
return;
}
AlnParams LocalAP;
LocalAP.Init(AP, HSP, LA, LB);
EndTimer(AlignSPMem);
const byte *SubA = A + HSP.Loi;
const byte *SubB = B + HSP.Loj;
if (AH.BandRadius == 0)
ViterbiFastMem(Mem, SubA, SLA, SubB, SLB, LocalAP, PI);
else
ViterbiFastMainDiagMem(Mem, SubA, SLA, SubB, SLB, AH.BandRadius, LocalAP, PI);
#if TRACE
Log("AlignHSPMem:\n");
LogAlnPretty(SubA, SubB, PI.GetPath(), false);
#endif
}
void GlobalAlignBandMem(XDPMem &Mem, const byte *A, unsigned LA,
const byte *B, unsigned LB, const AlnParams &AP, unsigned BandRadius,
PathInfo &PI)
{
if (BandRadius == 0)
ViterbiFastMem(Mem, A, LA, B, LB, AP, PI);
else
ViterbiFastMainDiagMem(Mem, A, LA, B, LB, BandRadius, AP, PI);
#if TRACE
Log("GlobalAlignBandMem:\n");
LogAlnPretty(A, B, PI.GetPath(), false);
#endif
}
bool GlobalAlign_AllOpts(XDPMem &Mem, const SeqInfo &Query, const SeqInfo &Target,
const AlnParams &AP, const AlnHeuristics &AH, HSPFinder &HF, float &HSPFractId,
PathInfo &PI, bool FullDPAlways, bool FailIfNoHSPs)
{
IncCounter(GlobalAlign);
#if TRACE
Log("\n");
Log("GlobalAlignMem\n");
Log(" Q (%u) >%s\n", Query.m_L, Query.m_Label);
Log(" T (%u) >%s\n", Target.m_L, Target.m_Label);
AP.LogMe();
AH.LogMe();
#endif
HSPFractId = -1.0;
const byte *A = Query.m_Seq;
const byte *B = Target.m_Seq;
const unsigned LA = Query.m_L;
const unsigned LB = Target.m_L;
const unsigned MinL = min(LA, LB);
PI.Alloc2(LA, LB);
PI.SetEmpty();
if (FullDPAlways)
{
ViterbiFastMem(Mem, A, LA, B, LB, AP, PI);
return true;
}
unsigned BandRadius = AH.BandRadius;
HF.m_SubstMx = AP.SubstMx;
unsigned MinHSPLength = (AH.MinGlobalHSPLength == 0 ? 32 : AH.MinGlobalHSPLength);
if (MinHSPLength > LA/4)
MinHSPLength = LA/4;
if (MinHSPLength < 16)
MinHSPLength = 16;
unsigned HSPCount = HF.GetGlobalHSPs(MinHSPLength, AH.MinGlobalHSPFractId, false, HSPFractId);
IncCounter(GetGlobalHSPs);
AddCounter(GlobalHSPs, HSPCount);
#if TRACE
Log("%u global hsps, id %.1f%%\n", HSPCount, HSPFractId*100.0);
#endif
if (HSPFractId < AH.MinGlobalHSPFractId && FailIfNoHSPs)
return false;
if (HSPCount == 0)
{
if (AH.MinGlobalHSPLength > 0 && LA > 64 && FailIfNoHSPs)
return false;
GlobalAlignBandMem(Mem, A, LA, B, LB, AP, BandRadius, PI);
return true;
}
PathInfo *SubPath = ObjMgr::GetPathInfo();
SubPath->Alloc2(LA, LB);
//char *PathPtr = PI.m_Path;
for (unsigned i = 0; i < HSPCount; ++i)
{
const HSPData *PrevHSP = (i == 0 ? 0 : HF.m_ChainedHSPs[i-1]);
const HSPData *HSP = HF.m_ChainedHSPs[i];
// Align region before HSP
HSPData Hole;
GetHole(PrevHSP, HSP, LA, LB, Hole);
#if TRACE
Log("Hole: ");
Hole.LogMe();
#endif
AlignHSPMem(Mem, A, LA, B, LB, Hole, AP, AH, *SubPath);
//for (const char *p = SubPath->m_Path; *p; ++p)
// *PathPtr++ = *p;
PI.AppendPath(*SubPath);
// Trivial path for HSP
if (HSP->Leni != HSP->Lenj)
{
Warning("GlobalAlignMem, bad HSP");
HSP->LogMe();
return false;
}
//memset(PathPtr, 'M', HSP->GetLength());
//PathPtr += HSP->GetLength();
PI.AppendMs(HSP->GetLength());
}
HSPData Hole;
GetHole(HF.m_ChainedHSPs[HSPCount-1], 0, LA, LB, Hole);
AlignHSPMem(Mem, A, LA, B, LB, Hole, AP, AH, *SubPath);
//for (const char *p = SubPath->m_Path; *p; ++p)
// *PathPtr++ = *p;
//*PathPtr = 0;
PI.AppendPath(*SubPath);
#if TRACE
Log("Final:\n");
LogAlnPretty(A, B, PI.GetPath(), false);
#endif
ObjMgr::Down(SubPath);
SubPath = 0;
return true;
}
static XDPMem **g_Mems;
static HSPFinder **g_HFs;
static PathInfo **g_PIs;
static AlignResult **g_ARs;
static unsigned g_Size;
static void Alloc(unsigned ThreadIndex)
{
if (ThreadIndex < g_Size)
return;
unsigned NewSize = g_Size + 32;
XDPMem **Mems = myalloc(XDPMem *, NewSize);
HSPFinder **HFs = myalloc(HSPFinder *, NewSize);
PathInfo **PIs = myalloc(PathInfo *, NewSize);
AlignResult **ARs = myalloc(AlignResult *, NewSize);
memset_zero(Mems, NewSize);
memset_zero(HFs, NewSize);
memset_zero(PIs, NewSize);
memset_zero(ARs, NewSize);
if (g_Size > 0)
{
memcpy(Mems, g_Mems, g_Size*sizeof(XDPMem *));
memcpy(PIs, g_PIs, g_Size*sizeof(PathInfo *));
memcpy(HFs, g_HFs, g_Size*sizeof(HSPFinder *));
memcpy(ARs, g_ARs, g_Size*sizeof(AlignResult *));
myfree(g_Mems);
myfree(g_PIs);
myfree(g_HFs);
myfree(g_ARs);
}
g_Size = NewSize;
g_Mems = Mems;
g_PIs = PIs;
g_HFs = HFs;
g_ARs = ARs;
}
static XDPMem &GetDPMem_Thread()
{
unsigned ThreadIndex = GetThreadIndex();
Alloc(ThreadIndex);
if (g_Mems[ThreadIndex] == 0)
g_Mems[ThreadIndex] = new XDPMem;
return *g_Mems[ThreadIndex];
}
static HSPFinder &GetHF_Thread()
{
unsigned ThreadIndex = GetThreadIndex();
Alloc(ThreadIndex);
if (g_HFs[ThreadIndex] == 0)
{
g_HFs[ThreadIndex] = new HSPFinder;
g_HFs[ThreadIndex]->Init(*AlnParams::GetGlobalAP(), *AlnHeuristics::GetGlobalAH());
}
return *g_HFs[ThreadIndex];
}
static PathInfo &GetPI_Thread()
{
unsigned ThreadIndex = GetThreadIndex();
Alloc(ThreadIndex);
if (g_PIs[ThreadIndex] == 0)
g_PIs[ThreadIndex] = ObjMgr::GetPathInfo();
return *g_PIs[ThreadIndex];
}
static AlignResult &GetAR_Thread()
{
unsigned ThreadIndex = GetThreadIndex();
Alloc(ThreadIndex);
if (g_ARs[ThreadIndex] == 0)
g_ARs[ThreadIndex] = ObjMgr::GetAlignResult();
return *g_ARs[ThreadIndex];
}
bool GlobalAlign_Easy(SeqInfo &Query, SeqInfo &Target, AlignResult &AR)
{
XDPMem &Mem = GetDPMem_Thread();
HSPFinder &HF = GetHF_Thread();
PathInfo &PI = GetPI_Thread();
const AlnParams &AP = *AlnParams::GetGlobalAP();
const AlnHeuristics &AH = *AlnHeuristics::GetGlobalAH();
HF.SetA(&Query);
HF.SetB(&Target);
float HSPFractId;
bool Ok = GlobalAlign_AllOpts(Mem, Query, Target, AP, AH, HF, HSPFractId, PI, false, true);
if (!Ok)
return false;
AR.CreateGlobal(Query, Target, PI, true);
return true;
}
| 7,942
|
C++
|
.cpp
| 291
| 24.80756
| 95
| 0.680795
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,941
|
makebitvec.cpp
|
rcedgar_urmap/src/makebitvec.cpp
|
#include "myutils.h"
#include "bitvec.h"
#include "alpha.h"
#include "seqdb.h"
static void Scan(BitVec &BV, SeqDB &Ref, uint WordLength, bool Exclude)
{
uint64 BitCount = BV.m_BitCount;
uint64 ShiftMask = 0;
for (unsigned i = 0; i < 2u*WordLength; ++i)
ShiftMask |= (uint64(1) << i);
uint64 IncludedCount = 0;
uint64 ExcludedCount = 0;
const uint SeqCount = Ref.GetSeqCount();
ProgressOne(Exclude ? "Scanning exclude" : "Scanning ref");
for (uint SeqIndex = 0; SeqIndex < SeqCount; ++SeqIndex)
{
Progress_OnTick();
byte *Seq = Ref.GetSeq(SeqIndex);
const uint L = Ref.GetSeqLength(SeqIndex);
for (int Strand = 0; Strand <= 1; ++Strand)
{
if (Strand == 1)
RevCompSeq(Seq, L , Seq);
uint64 Word = 0;
byte K = 0;
for (uint SeqPos = 0; SeqPos < L - WordLength + 1; ++SeqPos)
{
byte c = Seq[SeqPos];
byte Letter = g_CharToLetterNucleo[c];
if (Letter == INVALID_LETTER)
{
K = 0;
Word = 0;
continue;
}
if (K < WordLength)
++K;
Word = ((Word << uint64(2)) | Letter) & ShiftMask;
if (K == WordLength)
{
if (Exclude)
{
if (BV.GetBit(Word))
{
++ExcludedCount;
BV.ClearBit(Word);
}
}
else
{
if (!BV.GetBit(Word))
{
++IncludedCount;
BV.SetBit(Word);
}
}
}
}
}
}
ProgressDone();
if (Exclude)
ProgressLog("%u words excluded (%s)\n",
ExcludedCount, IntToStr(ExcludedCount));
else
ProgressLog("%u words included (%s)\n",
IncludedCount, IntToStr(IncludedCount));
}
void cmd_make_bitvec()
{
const string &RefFileName = opt(make_bitvec);
const string &OutputFileName = opt(output);
const string &Input2FileName = opt(input2);
asserta(optset_wordlength);
uint WordLength = opt(wordlength);
uint64 BitCount = myipow64(4, WordLength);
ProgressLog("%" PRIu64 " bits (%s)\n", BitCount, Int64ToStr(BitCount));
FILE *fOut = CreateStdioFile(OutputFileName);
BitVec BV;
BV.Alloc(BitCount);
SeqDB Ref;
Ref.FromFasta(RefFileName);
SeqDB Input2;
Input2.FromFasta(Input2FileName);
Scan(BV, Ref, WordLength, false);
Scan(BV, Input2, WordLength, true);
ProgressFile(fOut, "Writing bitvec", OutputFileName);
WriteStdioFile(fOut, &BV_MAGIC, sizeof(BV_MAGIC));
WriteStdioFile(fOut, &WordLength, sizeof(WordLength));
uint64 Bytes = BV.m_BitCount/8;
WriteStdioFile64(fOut, BV.m_Vec, Bytes);
ProgressDone();
CloseStdioFile(fOut);
}
| 2,462
|
C++
|
.cpp
| 94
| 22.308511
| 72
| 0.656343
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,942
|
searchpending5.cpp
|
rcedgar_urmap/src/searchpending5.cpp
|
#include "myutils.h"
#include "ufindex.h"
#include "seqinfo.h"
#include "alpha.h"
#include "state1.h"
#include "omplock.h"
#include <inttypes.h>
void State1::SearchPE_Pending5(unsigned k)
{
const byte *Q = m_Query->m_Seq;
const unsigned QL = m_Query->m_L;
unsigned QWordCount = QL - (m_WordLength - 1);
m_MaxPenalty = MAX_PENALTY;
dpscore MinScorePhase1 = dpscore(QL) + XPHASE1*MISMATCH_SCORE;
dpscore MinScorePhase3 = dpscore(QL) + XPHASE3*MISMATCH_SCORE;
dpscore MinScorePhase4 = dpscore(QL) + XPHASE4*MISMATCH_SCORE;
dpscore TermHSPScorePhase3 = (dpscore(QL)*TERM_HSP_SCORE_PCT_PHASE3)/100;
uint32 QPos;
bool Plus;
uint32 DBPos;
while (k != UINT_MAX)
k = GetNextBoth1SeedEx(k, QPos, Plus, DBPos);
if (m_BestScore >= MinScorePhase1)
{
m_Mapq = CalcMAPQ6();
return;
}
if (m_BestHSPScore >= TermHSPScorePhase3)
{
for (unsigned i = 0; i < m_HSPCount; ++i)
AlignHSP5(i);
if (m_BestScore >= MinScorePhase1)
{
m_Mapq = CalcMAPQ6();
return;
}
}
const uint64 *SlotsVec_Plus = m_SlotsVec_Plus;
const uint64 *SlotsVec_Minus = m_SlotsVec_Minus;
byte *BlobVec_Plus = m_BlobVec_Plus;
byte *BlobVec_Minus = m_BlobVec_Minus;
uint32 *PosVec = m_PosVec;
// Pending Plus round 1
unsigned QPosPendingCount_Plus2 = 0;
for (unsigned i = 0; i < m_QPosPendingCount_Plus; ++i)
{
unsigned QPos = m_QPosPendingVec_Plus[i];
uint64 Slot = SlotsVec_Plus[QPos];
unsigned RowLength = m_UFI->GetRow_Blob(Slot, BlobVec_Plus + 5*QPos, PosVec);
if (RowLength > 2)
{
m_QPosPendingVec_Plus[QPosPendingCount_Plus2++] = QPos;
continue;
}
for (unsigned RowIndex = 0; RowIndex < RowLength; ++RowIndex)
{
uint32 SeedPosDB = PosVec[RowIndex];
ExtendPen(QPos, SeedPosDB, true);
}
}
// Pending Minus round 1
unsigned QPosPendingCount_Minus2 = 0;
for (unsigned i = 0; i < m_QPosPendingCount_Minus; ++i)
{
unsigned QPos = m_QPosPendingVec_Minus[i];
uint64 Slot = SlotsVec_Minus[QPos];
unsigned RowLength = m_UFI->GetRow_Blob(Slot, BlobVec_Minus + 5*QPos, PosVec);
if (RowLength > 2)
{
m_QPosPendingVec_Minus[QPosPendingCount_Minus2++] = QPos;
continue;
}
for (unsigned RowIndex = 0; RowIndex < RowLength; ++RowIndex)
{
uint32 SeedPosDB = PosVec[RowIndex];
ExtendPen(QPos, SeedPosDB, false);
}
}
// Pending Plus round 2
for (unsigned i = 0; i < QPosPendingCount_Plus2; ++i)
{
unsigned QPos = m_QPosPendingVec_Plus[i];
uint64 Slot = SlotsVec_Plus[QPos];
unsigned RowLength = m_UFI->GetRow_Blob(Slot, BlobVec_Plus + 5*QPos, PosVec);
asserta(RowLength > 2);
for (unsigned RowIndex = 0; RowIndex < RowLength; ++RowIndex)
{
uint32 SeedPosDB = PosVec[RowIndex];
ExtendPen(QPos, SeedPosDB, true);
}
}
// Pending Minus round 2
for (unsigned i = 0; i < QPosPendingCount_Minus2; ++i)
{
unsigned QPos = m_QPosPendingVec_Minus[i];
uint64 Slot = SlotsVec_Minus[QPos];
unsigned RowLength = m_UFI->GetRow_Blob(Slot, BlobVec_Minus + 5*QPos, PosVec);
asserta(RowLength > 2);
for (unsigned RowIndex = 0; RowIndex < RowLength; ++RowIndex)
{
uint32 SeedPosDB = PosVec[RowIndex];
ExtendPen(QPos, SeedPosDB, false);
}
}
int B = max(m_BestScore, m_BestHSPScore) - 8;
for (unsigned i = 0; i < m_HSPCount; ++i)
{
const UFIHSP *HSP = GetHSP(i);
if (HSP->m_Score < B)
continue;
AlignHSP5(i);
}
m_Mapq = CalcMAPQ6();
}
| 3,359
|
C++
|
.cpp
| 114
| 26.587719
| 80
| 0.696754
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,943
|
alpha.cpp
|
rcedgar_urmap/src/alpha.cpp
|
// Generated by /e/r/py/alphac.py
#include "myutils.h"
#include "alpha.h"
unsigned char g_AminoAcidChars[20] =
{
'A','C','D','E','F','G','H','I','K','L','M','N','P','Q','R','S','T','V','W','Y',
};
unsigned char g_CharToLetterAminoStop[256] =
{
INVALID_LETTER, // [ 0] 0x00
INVALID_LETTER, // [ 1] 0x01
INVALID_LETTER, // [ 2] 0x02
INVALID_LETTER, // [ 3] 0x03
INVALID_LETTER, // [ 4] 0x04
INVALID_LETTER, // [ 5] 0x05
INVALID_LETTER, // [ 6] 0x06
INVALID_LETTER, // [ 7] 0x07
INVALID_LETTER, // [ 8] 0x08
INVALID_LETTER, // [ 9] 0x09
INVALID_LETTER, // [ 10] 0x0a
INVALID_LETTER, // [ 11] 0x0b
INVALID_LETTER, // [ 12] 0x0c
INVALID_LETTER, // [ 13] 0x0d
INVALID_LETTER, // [ 14] 0x0e
INVALID_LETTER, // [ 15] 0x0f
INVALID_LETTER, // [ 16] 0x10
INVALID_LETTER, // [ 17] 0x11
INVALID_LETTER, // [ 18] 0x12
INVALID_LETTER, // [ 19] 0x13
INVALID_LETTER, // [ 20] 0x14
INVALID_LETTER, // [ 21] 0x15
INVALID_LETTER, // [ 22] 0x16
INVALID_LETTER, // [ 23] 0x17
INVALID_LETTER, // [ 24] 0x18
INVALID_LETTER, // [ 25] 0x19
INVALID_LETTER, // [ 26] 0x1a
INVALID_LETTER, // [ 27] 0x1b
INVALID_LETTER, // [ 28] 0x1c
INVALID_LETTER, // [ 29] 0x1d
INVALID_LETTER, // [ 30] 0x1e
INVALID_LETTER, // [ 31] 0x1f
INVALID_LETTER, // [ 32] ' '
INVALID_LETTER, // [ 33] '!'
INVALID_LETTER, // [ 34] '"'
INVALID_LETTER, // [ 35] '#'
INVALID_LETTER, // [ 36] '$'
INVALID_LETTER, // [ 37] '%'
INVALID_LETTER, // [ 38] '&'
INVALID_LETTER, // [ 39] '''
INVALID_LETTER, // [ 40] '('
INVALID_LETTER, // [ 41] ')'
20 , // [ 42] '*' = STP
INVALID_LETTER, // [ 43] '+'
INVALID_LETTER, // [ 44] ','
INVALID_LETTER, // [ 45] '-'
INVALID_LETTER, // [ 46] '.'
INVALID_LETTER, // [ 47] '/'
INVALID_LETTER, // [ 48] '0'
INVALID_LETTER, // [ 49] '1'
INVALID_LETTER, // [ 50] '2'
INVALID_LETTER, // [ 51] '3'
INVALID_LETTER, // [ 52] '4'
INVALID_LETTER, // [ 53] '5'
INVALID_LETTER, // [ 54] '6'
INVALID_LETTER, // [ 55] '7'
INVALID_LETTER, // [ 56] '8'
INVALID_LETTER, // [ 57] '9'
INVALID_LETTER, // [ 58] ':'
INVALID_LETTER, // [ 59] ';'
INVALID_LETTER, // [ 60] '<'
INVALID_LETTER, // [ 61] '='
INVALID_LETTER, // [ 62] '>'
INVALID_LETTER, // [ 63] '?'
INVALID_LETTER, // [ 64] '@'
0 , // [ 65] 'A' = Ala
INVALID_LETTER, // [ 66] 'B'
1 , // [ 67] 'C' = Cys
2 , // [ 68] 'D' = Asp
3 , // [ 69] 'E' = Glu
4 , // [ 70] 'F' = Phe
5 , // [ 71] 'G' = Gly
6 , // [ 72] 'H' = His
7 , // [ 73] 'I' = Ile
INVALID_LETTER, // [ 74] 'J'
8 , // [ 75] 'K' = Lys
9 , // [ 76] 'L' = Leu
10 , // [ 77] 'M' = Met
11 , // [ 78] 'N' = Asn
INVALID_LETTER, // [ 79] 'O'
12 , // [ 80] 'P' = Pro
13 , // [ 81] 'Q' = Gln
14 , // [ 82] 'R' = Arg
15 , // [ 83] 'S' = Ser
16 , // [ 84] 'T' = Thr
INVALID_LETTER, // [ 85] 'U'
17 , // [ 86] 'V' = Val
18 , // [ 87] 'W' = Trp
INVALID_LETTER, // [ 88] 'X'
19 , // [ 89] 'Y' = Tyr
INVALID_LETTER, // [ 90] 'Z'
INVALID_LETTER, // [ 91] '['
INVALID_LETTER, // [ 92] '\'
INVALID_LETTER, // [ 93] ']'
INVALID_LETTER, // [ 94] '^'
INVALID_LETTER, // [ 95] '_'
INVALID_LETTER, // [ 96] '`'
0 , // [ 97] 'a' = Ala
INVALID_LETTER, // [ 98] 'b'
1 , // [ 99] 'c' = Cys
2 , // [100] 'd' = Asp
3 , // [101] 'e' = Glu
4 , // [102] 'f' = Phe
5 , // [103] 'g' = Gly
6 , // [104] 'h' = His
7 , // [105] 'i' = Ile
INVALID_LETTER, // [106] 'j'
8 , // [107] 'k' = Lys
9 , // [108] 'l' = Leu
10 , // [109] 'm' = Met
11 , // [110] 'n' = Asn
INVALID_LETTER, // [111] 'o'
12 , // [112] 'p' = Pro
13 , // [113] 'q' = Gln
14 , // [114] 'r' = Arg
15 , // [115] 's' = Ser
16 , // [116] 't' = Thr
INVALID_LETTER, // [117] 'u'
17 , // [118] 'v' = Val
18 , // [119] 'w' = Trp
INVALID_LETTER, // [120] 'x'
19 , // [121] 'y' = Tyr
INVALID_LETTER, // [122] 'z'
INVALID_LETTER, // [123] '{'
INVALID_LETTER, // [124] '|'
INVALID_LETTER, // [125] '}'
INVALID_LETTER, // [126] '~'
INVALID_LETTER, // [127] 0x7f
INVALID_LETTER, // [128] 0x80
INVALID_LETTER, // [129] 0x81
INVALID_LETTER, // [130] 0x82
INVALID_LETTER, // [131] 0x83
INVALID_LETTER, // [132] 0x84
INVALID_LETTER, // [133] 0x85
INVALID_LETTER, // [134] 0x86
INVALID_LETTER, // [135] 0x87
INVALID_LETTER, // [136] 0x88
INVALID_LETTER, // [137] 0x89
INVALID_LETTER, // [138] 0x8a
INVALID_LETTER, // [139] 0x8b
INVALID_LETTER, // [140] 0x8c
INVALID_LETTER, // [141] 0x8d
INVALID_LETTER, // [142] 0x8e
INVALID_LETTER, // [143] 0x8f
INVALID_LETTER, // [144] 0x90
INVALID_LETTER, // [145] 0x91
INVALID_LETTER, // [146] 0x92
INVALID_LETTER, // [147] 0x93
INVALID_LETTER, // [148] 0x94
INVALID_LETTER, // [149] 0x95
INVALID_LETTER, // [150] 0x96
INVALID_LETTER, // [151] 0x97
INVALID_LETTER, // [152] 0x98
INVALID_LETTER, // [153] 0x99
INVALID_LETTER, // [154] 0x9a
INVALID_LETTER, // [155] 0x9b
INVALID_LETTER, // [156] 0x9c
INVALID_LETTER, // [157] 0x9d
INVALID_LETTER, // [158] 0x9e
INVALID_LETTER, // [159] 0x9f
INVALID_LETTER, // [160] 0xa0
INVALID_LETTER, // [161] 0xa1
INVALID_LETTER, // [162] 0xa2
INVALID_LETTER, // [163] 0xa3
INVALID_LETTER, // [164] 0xa4
INVALID_LETTER, // [165] 0xa5
INVALID_LETTER, // [166] 0xa6
INVALID_LETTER, // [167] 0xa7
INVALID_LETTER, // [168] 0xa8
INVALID_LETTER, // [169] 0xa9
INVALID_LETTER, // [170] 0xaa
INVALID_LETTER, // [171] 0xab
INVALID_LETTER, // [172] 0xac
INVALID_LETTER, // [173] 0xad
INVALID_LETTER, // [174] 0xae
INVALID_LETTER, // [175] 0xaf
INVALID_LETTER, // [176] 0xb0
INVALID_LETTER, // [177] 0xb1
INVALID_LETTER, // [178] 0xb2
INVALID_LETTER, // [179] 0xb3
INVALID_LETTER, // [180] 0xb4
INVALID_LETTER, // [181] 0xb5
INVALID_LETTER, // [182] 0xb6
INVALID_LETTER, // [183] 0xb7
INVALID_LETTER, // [184] 0xb8
INVALID_LETTER, // [185] 0xb9
INVALID_LETTER, // [186] 0xba
INVALID_LETTER, // [187] 0xbb
INVALID_LETTER, // [188] 0xbc
INVALID_LETTER, // [189] 0xbd
INVALID_LETTER, // [190] 0xbe
INVALID_LETTER, // [191] 0xbf
INVALID_LETTER, // [192] 0xc0
INVALID_LETTER, // [193] 0xc1
INVALID_LETTER, // [194] 0xc2
INVALID_LETTER, // [195] 0xc3
INVALID_LETTER, // [196] 0xc4
INVALID_LETTER, // [197] 0xc5
INVALID_LETTER, // [198] 0xc6
INVALID_LETTER, // [199] 0xc7
INVALID_LETTER, // [200] 0xc8
INVALID_LETTER, // [201] 0xc9
INVALID_LETTER, // [202] 0xca
INVALID_LETTER, // [203] 0xcb
INVALID_LETTER, // [204] 0xcc
INVALID_LETTER, // [205] 0xcd
INVALID_LETTER, // [206] 0xce
INVALID_LETTER, // [207] 0xcf
INVALID_LETTER, // [208] 0xd0
INVALID_LETTER, // [209] 0xd1
INVALID_LETTER, // [210] 0xd2
INVALID_LETTER, // [211] 0xd3
INVALID_LETTER, // [212] 0xd4
INVALID_LETTER, // [213] 0xd5
INVALID_LETTER, // [214] 0xd6
INVALID_LETTER, // [215] 0xd7
INVALID_LETTER, // [216] 0xd8
INVALID_LETTER, // [217] 0xd9
INVALID_LETTER, // [218] 0xda
INVALID_LETTER, // [219] 0xdb
INVALID_LETTER, // [220] 0xdc
INVALID_LETTER, // [221] 0xdd
INVALID_LETTER, // [222] 0xde
INVALID_LETTER, // [223] 0xdf
INVALID_LETTER, // [224] 0xe0
INVALID_LETTER, // [225] 0xe1
INVALID_LETTER, // [226] 0xe2
INVALID_LETTER, // [227] 0xe3
INVALID_LETTER, // [228] 0xe4
INVALID_LETTER, // [229] 0xe5
INVALID_LETTER, // [230] 0xe6
INVALID_LETTER, // [231] 0xe7
INVALID_LETTER, // [232] 0xe8
INVALID_LETTER, // [233] 0xe9
INVALID_LETTER, // [234] 0xea
INVALID_LETTER, // [235] 0xeb
INVALID_LETTER, // [236] 0xec
INVALID_LETTER, // [237] 0xed
INVALID_LETTER, // [238] 0xee
INVALID_LETTER, // [239] 0xef
INVALID_LETTER, // [240] 0xf0
INVALID_LETTER, // [241] 0xf1
INVALID_LETTER, // [242] 0xf2
INVALID_LETTER, // [243] 0xf3
INVALID_LETTER, // [244] 0xf4
INVALID_LETTER, // [245] 0xf5
INVALID_LETTER, // [246] 0xf6
INVALID_LETTER, // [247] 0xf7
INVALID_LETTER, // [248] 0xf8
INVALID_LETTER, // [249] 0xf9
INVALID_LETTER, // [250] 0xfa
INVALID_LETTER, // [251] 0xfb
INVALID_LETTER, // [252] 0xfc
INVALID_LETTER, // [253] 0xfd
INVALID_LETTER, // [254] 0xfe
INVALID_LETTER, // [255] 0xff
};
unsigned char g_CharToLetterAminoGap[256] =
{
INVALID_LETTER, // [ 0] 0x00
INVALID_LETTER, // [ 1] 0x01
INVALID_LETTER, // [ 2] 0x02
INVALID_LETTER, // [ 3] 0x03
INVALID_LETTER, // [ 4] 0x04
INVALID_LETTER, // [ 5] 0x05
INVALID_LETTER, // [ 6] 0x06
INVALID_LETTER, // [ 7] 0x07
INVALID_LETTER, // [ 8] 0x08
INVALID_LETTER, // [ 9] 0x09
INVALID_LETTER, // [ 10] 0x0a
INVALID_LETTER, // [ 11] 0x0b
INVALID_LETTER, // [ 12] 0x0c
INVALID_LETTER, // [ 13] 0x0d
INVALID_LETTER, // [ 14] 0x0e
INVALID_LETTER, // [ 15] 0x0f
INVALID_LETTER, // [ 16] 0x10
INVALID_LETTER, // [ 17] 0x11
INVALID_LETTER, // [ 18] 0x12
INVALID_LETTER, // [ 19] 0x13
INVALID_LETTER, // [ 20] 0x14
INVALID_LETTER, // [ 21] 0x15
INVALID_LETTER, // [ 22] 0x16
INVALID_LETTER, // [ 23] 0x17
INVALID_LETTER, // [ 24] 0x18
INVALID_LETTER, // [ 25] 0x19
INVALID_LETTER, // [ 26] 0x1a
INVALID_LETTER, // [ 27] 0x1b
INVALID_LETTER, // [ 28] 0x1c
INVALID_LETTER, // [ 29] 0x1d
INVALID_LETTER, // [ 30] 0x1e
INVALID_LETTER, // [ 31] 0x1f
INVALID_LETTER, // [ 32] ' '
INVALID_LETTER, // [ 33] '!'
INVALID_LETTER, // [ 34] '"'
INVALID_LETTER, // [ 35] '#'
INVALID_LETTER, // [ 36] '$'
INVALID_LETTER, // [ 37] '%'
INVALID_LETTER, // [ 38] '&'
INVALID_LETTER, // [ 39] '''
INVALID_LETTER, // [ 40] '('
INVALID_LETTER, // [ 41] ')'
20 , // [ 42] '*' = STP
INVALID_LETTER, // [ 43] '+'
INVALID_LETTER, // [ 44] ','
20 , // [ 45] '-' gap
INVALID_LETTER, // [ 46] '.'
INVALID_LETTER, // [ 47] '/'
INVALID_LETTER, // [ 48] '0'
INVALID_LETTER, // [ 49] '1'
INVALID_LETTER, // [ 50] '2'
INVALID_LETTER, // [ 51] '3'
INVALID_LETTER, // [ 52] '4'
INVALID_LETTER, // [ 53] '5'
INVALID_LETTER, // [ 54] '6'
INVALID_LETTER, // [ 55] '7'
INVALID_LETTER, // [ 56] '8'
INVALID_LETTER, // [ 57] '9'
INVALID_LETTER, // [ 58] ':'
INVALID_LETTER, // [ 59] ';'
INVALID_LETTER, // [ 60] '<'
INVALID_LETTER, // [ 61] '='
INVALID_LETTER, // [ 62] '>'
INVALID_LETTER, // [ 63] '?'
INVALID_LETTER, // [ 64] '@'
0 , // [ 65] 'A' = Ala
INVALID_LETTER, // [ 66] 'B'
1 , // [ 67] 'C' = Cys
2 , // [ 68] 'D' = Asp
3 , // [ 69] 'E' = Glu
4 , // [ 70] 'F' = Phe
5 , // [ 71] 'G' = Gly
6 , // [ 72] 'H' = His
7 , // [ 73] 'I' = Ile
INVALID_LETTER, // [ 74] 'J'
8 , // [ 75] 'K' = Lys
9 , // [ 76] 'L' = Leu
10 , // [ 77] 'M' = Met
11 , // [ 78] 'N' = Asn
INVALID_LETTER, // [ 79] 'O'
12 , // [ 80] 'P' = Pro
13 , // [ 81] 'Q' = Gln
14 , // [ 82] 'R' = Arg
15 , // [ 83] 'S' = Ser
16 , // [ 84] 'T' = Thr
INVALID_LETTER, // [ 85] 'U'
17 , // [ 86] 'V' = Val
18 , // [ 87] 'W' = Trp
INVALID_LETTER, // [ 88] 'X'
19 , // [ 89] 'Y' = Tyr
INVALID_LETTER, // [ 90] 'Z'
INVALID_LETTER, // [ 91] '['
INVALID_LETTER, // [ 92] '\'
INVALID_LETTER, // [ 93] ']'
INVALID_LETTER, // [ 94] '^'
INVALID_LETTER, // [ 95] '_'
INVALID_LETTER, // [ 96] '`'
0 , // [ 97] 'a' = Ala
INVALID_LETTER, // [ 98] 'b'
1 , // [ 99] 'c' = Cys
2 , // [100] 'd' = Asp
3 , // [101] 'e' = Glu
4 , // [102] 'f' = Phe
5 , // [103] 'g' = Gly
6 , // [104] 'h' = His
7 , // [105] 'i' = Ile
INVALID_LETTER, // [106] 'j'
8 , // [107] 'k' = Lys
9 , // [108] 'l' = Leu
10 , // [109] 'm' = Met
11 , // [110] 'n' = Asn
INVALID_LETTER, // [111] 'o'
12 , // [112] 'p' = Pro
13 , // [113] 'q' = Gln
14 , // [114] 'r' = Arg
15 , // [115] 's' = Ser
16 , // [116] 't' = Thr
INVALID_LETTER, // [117] 'u'
17 , // [118] 'v' = Val
18 , // [119] 'w' = Trp
INVALID_LETTER, // [120] 'x'
19 , // [121] 'y' = Tyr
INVALID_LETTER, // [122] 'z'
INVALID_LETTER, // [123] '{'
INVALID_LETTER, // [124] '|'
INVALID_LETTER, // [125] '}'
INVALID_LETTER, // [126] '~'
INVALID_LETTER, // [127] 0x7f
INVALID_LETTER, // [128] 0x80
INVALID_LETTER, // [129] 0x81
INVALID_LETTER, // [130] 0x82
INVALID_LETTER, // [131] 0x83
INVALID_LETTER, // [132] 0x84
INVALID_LETTER, // [133] 0x85
INVALID_LETTER, // [134] 0x86
INVALID_LETTER, // [135] 0x87
INVALID_LETTER, // [136] 0x88
INVALID_LETTER, // [137] 0x89
INVALID_LETTER, // [138] 0x8a
INVALID_LETTER, // [139] 0x8b
INVALID_LETTER, // [140] 0x8c
INVALID_LETTER, // [141] 0x8d
INVALID_LETTER, // [142] 0x8e
INVALID_LETTER, // [143] 0x8f
INVALID_LETTER, // [144] 0x90
INVALID_LETTER, // [145] 0x91
INVALID_LETTER, // [146] 0x92
INVALID_LETTER, // [147] 0x93
INVALID_LETTER, // [148] 0x94
INVALID_LETTER, // [149] 0x95
INVALID_LETTER, // [150] 0x96
INVALID_LETTER, // [151] 0x97
INVALID_LETTER, // [152] 0x98
INVALID_LETTER, // [153] 0x99
INVALID_LETTER, // [154] 0x9a
INVALID_LETTER, // [155] 0x9b
INVALID_LETTER, // [156] 0x9c
INVALID_LETTER, // [157] 0x9d
INVALID_LETTER, // [158] 0x9e
INVALID_LETTER, // [159] 0x9f
INVALID_LETTER, // [160] 0xa0
INVALID_LETTER, // [161] 0xa1
INVALID_LETTER, // [162] 0xa2
INVALID_LETTER, // [163] 0xa3
INVALID_LETTER, // [164] 0xa4
INVALID_LETTER, // [165] 0xa5
INVALID_LETTER, // [166] 0xa6
INVALID_LETTER, // [167] 0xa7
INVALID_LETTER, // [168] 0xa8
INVALID_LETTER, // [169] 0xa9
INVALID_LETTER, // [170] 0xaa
INVALID_LETTER, // [171] 0xab
INVALID_LETTER, // [172] 0xac
INVALID_LETTER, // [173] 0xad
INVALID_LETTER, // [174] 0xae
INVALID_LETTER, // [175] 0xaf
INVALID_LETTER, // [176] 0xb0
INVALID_LETTER, // [177] 0xb1
INVALID_LETTER, // [178] 0xb2
INVALID_LETTER, // [179] 0xb3
INVALID_LETTER, // [180] 0xb4
INVALID_LETTER, // [181] 0xb5
INVALID_LETTER, // [182] 0xb6
INVALID_LETTER, // [183] 0xb7
INVALID_LETTER, // [184] 0xb8
INVALID_LETTER, // [185] 0xb9
INVALID_LETTER, // [186] 0xba
INVALID_LETTER, // [187] 0xbb
INVALID_LETTER, // [188] 0xbc
INVALID_LETTER, // [189] 0xbd
INVALID_LETTER, // [190] 0xbe
INVALID_LETTER, // [191] 0xbf
INVALID_LETTER, // [192] 0xc0
INVALID_LETTER, // [193] 0xc1
INVALID_LETTER, // [194] 0xc2
INVALID_LETTER, // [195] 0xc3
INVALID_LETTER, // [196] 0xc4
INVALID_LETTER, // [197] 0xc5
INVALID_LETTER, // [198] 0xc6
INVALID_LETTER, // [199] 0xc7
INVALID_LETTER, // [200] 0xc8
INVALID_LETTER, // [201] 0xc9
INVALID_LETTER, // [202] 0xca
INVALID_LETTER, // [203] 0xcb
INVALID_LETTER, // [204] 0xcc
INVALID_LETTER, // [205] 0xcd
INVALID_LETTER, // [206] 0xce
INVALID_LETTER, // [207] 0xcf
INVALID_LETTER, // [208] 0xd0
INVALID_LETTER, // [209] 0xd1
INVALID_LETTER, // [210] 0xd2
INVALID_LETTER, // [211] 0xd3
INVALID_LETTER, // [212] 0xd4
INVALID_LETTER, // [213] 0xd5
INVALID_LETTER, // [214] 0xd6
INVALID_LETTER, // [215] 0xd7
INVALID_LETTER, // [216] 0xd8
INVALID_LETTER, // [217] 0xd9
INVALID_LETTER, // [218] 0xda
INVALID_LETTER, // [219] 0xdb
INVALID_LETTER, // [220] 0xdc
INVALID_LETTER, // [221] 0xdd
INVALID_LETTER, // [222] 0xde
INVALID_LETTER, // [223] 0xdf
INVALID_LETTER, // [224] 0xe0
INVALID_LETTER, // [225] 0xe1
INVALID_LETTER, // [226] 0xe2
INVALID_LETTER, // [227] 0xe3
INVALID_LETTER, // [228] 0xe4
INVALID_LETTER, // [229] 0xe5
INVALID_LETTER, // [230] 0xe6
INVALID_LETTER, // [231] 0xe7
INVALID_LETTER, // [232] 0xe8
INVALID_LETTER, // [233] 0xe9
INVALID_LETTER, // [234] 0xea
INVALID_LETTER, // [235] 0xeb
INVALID_LETTER, // [236] 0xec
INVALID_LETTER, // [237] 0xed
INVALID_LETTER, // [238] 0xee
INVALID_LETTER, // [239] 0xef
INVALID_LETTER, // [240] 0xf0
INVALID_LETTER, // [241] 0xf1
INVALID_LETTER, // [242] 0xf2
INVALID_LETTER, // [243] 0xf3
INVALID_LETTER, // [244] 0xf4
INVALID_LETTER, // [245] 0xf5
INVALID_LETTER, // [246] 0xf6
INVALID_LETTER, // [247] 0xf7
INVALID_LETTER, // [248] 0xf8
INVALID_LETTER, // [249] 0xf9
INVALID_LETTER, // [250] 0xfa
INVALID_LETTER, // [251] 0xfb
INVALID_LETTER, // [252] 0xfc
INVALID_LETTER, // [253] 0xfd
INVALID_LETTER, // [254] 0xfe
INVALID_LETTER, // [255] 0xff
};
unsigned char g_CharToLetterAmino[256] =
{
INVALID_LETTER, // [ 0] 0x00
INVALID_LETTER, // [ 1] 0x01
INVALID_LETTER, // [ 2] 0x02
INVALID_LETTER, // [ 3] 0x03
INVALID_LETTER, // [ 4] 0x04
INVALID_LETTER, // [ 5] 0x05
INVALID_LETTER, // [ 6] 0x06
INVALID_LETTER, // [ 7] 0x07
INVALID_LETTER, // [ 8] 0x08
INVALID_LETTER, // [ 9] 0x09
INVALID_LETTER, // [ 10] 0x0a
INVALID_LETTER, // [ 11] 0x0b
INVALID_LETTER, // [ 12] 0x0c
INVALID_LETTER, // [ 13] 0x0d
INVALID_LETTER, // [ 14] 0x0e
INVALID_LETTER, // [ 15] 0x0f
INVALID_LETTER, // [ 16] 0x10
INVALID_LETTER, // [ 17] 0x11
INVALID_LETTER, // [ 18] 0x12
INVALID_LETTER, // [ 19] 0x13
INVALID_LETTER, // [ 20] 0x14
INVALID_LETTER, // [ 21] 0x15
INVALID_LETTER, // [ 22] 0x16
INVALID_LETTER, // [ 23] 0x17
INVALID_LETTER, // [ 24] 0x18
INVALID_LETTER, // [ 25] 0x19
INVALID_LETTER, // [ 26] 0x1a
INVALID_LETTER, // [ 27] 0x1b
INVALID_LETTER, // [ 28] 0x1c
INVALID_LETTER, // [ 29] 0x1d
INVALID_LETTER, // [ 30] 0x1e
INVALID_LETTER, // [ 31] 0x1f
INVALID_LETTER, // [ 32] ' '
INVALID_LETTER, // [ 33] '!'
INVALID_LETTER, // [ 34] '"'
INVALID_LETTER, // [ 35] '#'
INVALID_LETTER, // [ 36] '$'
INVALID_LETTER, // [ 37] '%'
INVALID_LETTER, // [ 38] '&'
INVALID_LETTER, // [ 39] '''
INVALID_LETTER, // [ 40] '('
INVALID_LETTER, // [ 41] ')'
INVALID_LETTER, // [ 42] '*'
INVALID_LETTER, // [ 43] '+'
INVALID_LETTER, // [ 44] ','
INVALID_LETTER, // [ 45] '-'
INVALID_LETTER, // [ 46] '.'
INVALID_LETTER, // [ 47] '/'
INVALID_LETTER, // [ 48] '0'
INVALID_LETTER, // [ 49] '1'
INVALID_LETTER, // [ 50] '2'
INVALID_LETTER, // [ 51] '3'
INVALID_LETTER, // [ 52] '4'
INVALID_LETTER, // [ 53] '5'
INVALID_LETTER, // [ 54] '6'
INVALID_LETTER, // [ 55] '7'
INVALID_LETTER, // [ 56] '8'
INVALID_LETTER, // [ 57] '9'
INVALID_LETTER, // [ 58] ':'
INVALID_LETTER, // [ 59] ';'
INVALID_LETTER, // [ 60] '<'
INVALID_LETTER, // [ 61] '='
INVALID_LETTER, // [ 62] '>'
INVALID_LETTER, // [ 63] '?'
INVALID_LETTER, // [ 64] '@'
0 , // [ 65] 'A' = Ala
INVALID_LETTER, // [ 66] 'B'
1 , // [ 67] 'C' = Cys
2 , // [ 68] 'D' = Asp
3 , // [ 69] 'E' = Glu
4 , // [ 70] 'F' = Phe
5 , // [ 71] 'G' = Gly
6 , // [ 72] 'H' = His
7 , // [ 73] 'I' = Ile
INVALID_LETTER, // [ 74] 'J'
8 , // [ 75] 'K' = Lys
9 , // [ 76] 'L' = Leu
10 , // [ 77] 'M' = Met
11 , // [ 78] 'N' = Asn
INVALID_LETTER, // [ 79] 'O'
12 , // [ 80] 'P' = Pro
13 , // [ 81] 'Q' = Gln
14 , // [ 82] 'R' = Arg
15 , // [ 83] 'S' = Ser
16 , // [ 84] 'T' = Thr
INVALID_LETTER, // [ 85] 'U'
17 , // [ 86] 'V' = Val
18 , // [ 87] 'W' = Trp
INVALID_LETTER, // [ 88] 'X'
19 , // [ 89] 'Y' = Tyr
INVALID_LETTER, // [ 90] 'Z'
INVALID_LETTER, // [ 91] '['
INVALID_LETTER, // [ 92] '\'
INVALID_LETTER, // [ 93] ']'
INVALID_LETTER, // [ 94] '^'
INVALID_LETTER, // [ 95] '_'
INVALID_LETTER, // [ 96] '`'
0 , // [ 97] 'a' = Ala
INVALID_LETTER, // [ 98] 'b'
1 , // [ 99] 'c' = Cys
2 , // [100] 'd' = Asp
3 , // [101] 'e' = Glu
4 , // [102] 'f' = Phe
5 , // [103] 'g' = Gly
6 , // [104] 'h' = His
7 , // [105] 'i' = Ile
INVALID_LETTER, // [106] 'j'
8 , // [107] 'k' = Lys
9 , // [108] 'l' = Leu
10 , // [109] 'm' = Met
11 , // [110] 'n' = Asn
INVALID_LETTER, // [111] 'o'
12 , // [112] 'p' = Pro
13 , // [113] 'q' = Gln
14 , // [114] 'r' = Arg
15 , // [115] 's' = Ser
16 , // [116] 't' = Thr
INVALID_LETTER, // [117] 'u'
17 , // [118] 'v' = Val
18 , // [119] 'w' = Trp
INVALID_LETTER, // [120] 'x'
19 , // [121] 'y' = Tyr
INVALID_LETTER, // [122] 'z'
INVALID_LETTER, // [123] '{'
INVALID_LETTER, // [124] '|'
INVALID_LETTER, // [125] '}'
INVALID_LETTER, // [126] '~'
INVALID_LETTER, // [127] 0x7f
INVALID_LETTER, // [128] 0x80
INVALID_LETTER, // [129] 0x81
INVALID_LETTER, // [130] 0x82
INVALID_LETTER, // [131] 0x83
INVALID_LETTER, // [132] 0x84
INVALID_LETTER, // [133] 0x85
INVALID_LETTER, // [134] 0x86
INVALID_LETTER, // [135] 0x87
INVALID_LETTER, // [136] 0x88
INVALID_LETTER, // [137] 0x89
INVALID_LETTER, // [138] 0x8a
INVALID_LETTER, // [139] 0x8b
INVALID_LETTER, // [140] 0x8c
INVALID_LETTER, // [141] 0x8d
INVALID_LETTER, // [142] 0x8e
INVALID_LETTER, // [143] 0x8f
INVALID_LETTER, // [144] 0x90
INVALID_LETTER, // [145] 0x91
INVALID_LETTER, // [146] 0x92
INVALID_LETTER, // [147] 0x93
INVALID_LETTER, // [148] 0x94
INVALID_LETTER, // [149] 0x95
INVALID_LETTER, // [150] 0x96
INVALID_LETTER, // [151] 0x97
INVALID_LETTER, // [152] 0x98
INVALID_LETTER, // [153] 0x99
INVALID_LETTER, // [154] 0x9a
INVALID_LETTER, // [155] 0x9b
INVALID_LETTER, // [156] 0x9c
INVALID_LETTER, // [157] 0x9d
INVALID_LETTER, // [158] 0x9e
INVALID_LETTER, // [159] 0x9f
INVALID_LETTER, // [160] 0xa0
INVALID_LETTER, // [161] 0xa1
INVALID_LETTER, // [162] 0xa2
INVALID_LETTER, // [163] 0xa3
INVALID_LETTER, // [164] 0xa4
INVALID_LETTER, // [165] 0xa5
INVALID_LETTER, // [166] 0xa6
INVALID_LETTER, // [167] 0xa7
INVALID_LETTER, // [168] 0xa8
INVALID_LETTER, // [169] 0xa9
INVALID_LETTER, // [170] 0xaa
INVALID_LETTER, // [171] 0xab
INVALID_LETTER, // [172] 0xac
INVALID_LETTER, // [173] 0xad
INVALID_LETTER, // [174] 0xae
INVALID_LETTER, // [175] 0xaf
INVALID_LETTER, // [176] 0xb0
INVALID_LETTER, // [177] 0xb1
INVALID_LETTER, // [178] 0xb2
INVALID_LETTER, // [179] 0xb3
INVALID_LETTER, // [180] 0xb4
INVALID_LETTER, // [181] 0xb5
INVALID_LETTER, // [182] 0xb6
INVALID_LETTER, // [183] 0xb7
INVALID_LETTER, // [184] 0xb8
INVALID_LETTER, // [185] 0xb9
INVALID_LETTER, // [186] 0xba
INVALID_LETTER, // [187] 0xbb
INVALID_LETTER, // [188] 0xbc
INVALID_LETTER, // [189] 0xbd
INVALID_LETTER, // [190] 0xbe
INVALID_LETTER, // [191] 0xbf
INVALID_LETTER, // [192] 0xc0
INVALID_LETTER, // [193] 0xc1
INVALID_LETTER, // [194] 0xc2
INVALID_LETTER, // [195] 0xc3
INVALID_LETTER, // [196] 0xc4
INVALID_LETTER, // [197] 0xc5
INVALID_LETTER, // [198] 0xc6
INVALID_LETTER, // [199] 0xc7
INVALID_LETTER, // [200] 0xc8
INVALID_LETTER, // [201] 0xc9
INVALID_LETTER, // [202] 0xca
INVALID_LETTER, // [203] 0xcb
INVALID_LETTER, // [204] 0xcc
INVALID_LETTER, // [205] 0xcd
INVALID_LETTER, // [206] 0xce
INVALID_LETTER, // [207] 0xcf
INVALID_LETTER, // [208] 0xd0
INVALID_LETTER, // [209] 0xd1
INVALID_LETTER, // [210] 0xd2
INVALID_LETTER, // [211] 0xd3
INVALID_LETTER, // [212] 0xd4
INVALID_LETTER, // [213] 0xd5
INVALID_LETTER, // [214] 0xd6
INVALID_LETTER, // [215] 0xd7
INVALID_LETTER, // [216] 0xd8
INVALID_LETTER, // [217] 0xd9
INVALID_LETTER, // [218] 0xda
INVALID_LETTER, // [219] 0xdb
INVALID_LETTER, // [220] 0xdc
INVALID_LETTER, // [221] 0xdd
INVALID_LETTER, // [222] 0xde
INVALID_LETTER, // [223] 0xdf
INVALID_LETTER, // [224] 0xe0
INVALID_LETTER, // [225] 0xe1
INVALID_LETTER, // [226] 0xe2
INVALID_LETTER, // [227] 0xe3
INVALID_LETTER, // [228] 0xe4
INVALID_LETTER, // [229] 0xe5
INVALID_LETTER, // [230] 0xe6
INVALID_LETTER, // [231] 0xe7
INVALID_LETTER, // [232] 0xe8
INVALID_LETTER, // [233] 0xe9
INVALID_LETTER, // [234] 0xea
INVALID_LETTER, // [235] 0xeb
INVALID_LETTER, // [236] 0xec
INVALID_LETTER, // [237] 0xed
INVALID_LETTER, // [238] 0xee
INVALID_LETTER, // [239] 0xef
INVALID_LETTER, // [240] 0xf0
INVALID_LETTER, // [241] 0xf1
INVALID_LETTER, // [242] 0xf2
INVALID_LETTER, // [243] 0xf3
INVALID_LETTER, // [244] 0xf4
INVALID_LETTER, // [245] 0xf5
INVALID_LETTER, // [246] 0xf6
INVALID_LETTER, // [247] 0xf7
INVALID_LETTER, // [248] 0xf8
INVALID_LETTER, // [249] 0xf9
INVALID_LETTER, // [250] 0xfa
INVALID_LETTER, // [251] 0xfb
INVALID_LETTER, // [252] 0xfc
INVALID_LETTER, // [253] 0xfd
INVALID_LETTER, // [254] 0xfe
INVALID_LETTER, // [255] 0xff
};
unsigned char g_LetterToCharAmino[256] =
{
'A', // [0]
'C', // [1]
'D', // [2]
'E', // [3]
'F', // [4]
'G', // [5]
'H', // [6]
'I', // [7]
'K', // [8]
'L', // [9]
'M', // [10]
'N', // [11]
'P', // [12]
'Q', // [13]
'R', // [14]
'S', // [15]
'T', // [16]
'V', // [17]
'W', // [18]
'Y', // [19]
'*', // [20]
INVALID_CHAR, // [21]
INVALID_CHAR, // [22]
INVALID_CHAR, // [23]
INVALID_CHAR, // [24]
INVALID_CHAR, // [25]
INVALID_CHAR, // [26]
INVALID_CHAR, // [27]
INVALID_CHAR, // [28]
INVALID_CHAR, // [29]
INVALID_CHAR, // [30]
INVALID_CHAR, // [31]
INVALID_CHAR, // [32]
INVALID_CHAR, // [33]
INVALID_CHAR, // [34]
INVALID_CHAR, // [35]
INVALID_CHAR, // [36]
INVALID_CHAR, // [37]
INVALID_CHAR, // [38]
INVALID_CHAR, // [39]
INVALID_CHAR, // [40]
INVALID_CHAR, // [41]
INVALID_CHAR, // [42]
INVALID_CHAR, // [43]
INVALID_CHAR, // [44]
INVALID_CHAR, // [45]
INVALID_CHAR, // [46]
INVALID_CHAR, // [47]
INVALID_CHAR, // [48]
INVALID_CHAR, // [49]
INVALID_CHAR, // [50]
INVALID_CHAR, // [51]
INVALID_CHAR, // [52]
INVALID_CHAR, // [53]
INVALID_CHAR, // [54]
INVALID_CHAR, // [55]
INVALID_CHAR, // [56]
INVALID_CHAR, // [57]
INVALID_CHAR, // [58]
INVALID_CHAR, // [59]
INVALID_CHAR, // [60]
INVALID_CHAR, // [61]
INVALID_CHAR, // [62]
INVALID_CHAR, // [63]
INVALID_CHAR, // [64]
INVALID_CHAR, // [65]
INVALID_CHAR, // [66]
INVALID_CHAR, // [67]
INVALID_CHAR, // [68]
INVALID_CHAR, // [69]
INVALID_CHAR, // [70]
INVALID_CHAR, // [71]
INVALID_CHAR, // [72]
INVALID_CHAR, // [73]
INVALID_CHAR, // [74]
INVALID_CHAR, // [75]
INVALID_CHAR, // [76]
INVALID_CHAR, // [77]
INVALID_CHAR, // [78]
INVALID_CHAR, // [79]
INVALID_CHAR, // [80]
INVALID_CHAR, // [81]
INVALID_CHAR, // [82]
INVALID_CHAR, // [83]
INVALID_CHAR, // [84]
INVALID_CHAR, // [85]
INVALID_CHAR, // [86]
INVALID_CHAR, // [87]
INVALID_CHAR, // [88]
INVALID_CHAR, // [89]
INVALID_CHAR, // [90]
INVALID_CHAR, // [91]
INVALID_CHAR, // [92]
INVALID_CHAR, // [93]
INVALID_CHAR, // [94]
INVALID_CHAR, // [95]
INVALID_CHAR, // [96]
INVALID_CHAR, // [97]
INVALID_CHAR, // [98]
INVALID_CHAR, // [99]
INVALID_CHAR, // [100]
INVALID_CHAR, // [101]
INVALID_CHAR, // [102]
INVALID_CHAR, // [103]
INVALID_CHAR, // [104]
INVALID_CHAR, // [105]
INVALID_CHAR, // [106]
INVALID_CHAR, // [107]
INVALID_CHAR, // [108]
INVALID_CHAR, // [109]
INVALID_CHAR, // [110]
INVALID_CHAR, // [111]
INVALID_CHAR, // [112]
INVALID_CHAR, // [113]
INVALID_CHAR, // [114]
INVALID_CHAR, // [115]
INVALID_CHAR, // [116]
INVALID_CHAR, // [117]
INVALID_CHAR, // [118]
INVALID_CHAR, // [119]
INVALID_CHAR, // [120]
INVALID_CHAR, // [121]
INVALID_CHAR, // [122]
INVALID_CHAR, // [123]
INVALID_CHAR, // [124]
INVALID_CHAR, // [125]
INVALID_CHAR, // [126]
INVALID_CHAR, // [127]
INVALID_CHAR, // [128]
INVALID_CHAR, // [129]
INVALID_CHAR, // [130]
INVALID_CHAR, // [131]
INVALID_CHAR, // [132]
INVALID_CHAR, // [133]
INVALID_CHAR, // [134]
INVALID_CHAR, // [135]
INVALID_CHAR, // [136]
INVALID_CHAR, // [137]
INVALID_CHAR, // [138]
INVALID_CHAR, // [139]
INVALID_CHAR, // [140]
INVALID_CHAR, // [141]
INVALID_CHAR, // [142]
INVALID_CHAR, // [143]
INVALID_CHAR, // [144]
INVALID_CHAR, // [145]
INVALID_CHAR, // [146]
INVALID_CHAR, // [147]
INVALID_CHAR, // [148]
INVALID_CHAR, // [149]
INVALID_CHAR, // [150]
INVALID_CHAR, // [151]
INVALID_CHAR, // [152]
INVALID_CHAR, // [153]
INVALID_CHAR, // [154]
INVALID_CHAR, // [155]
INVALID_CHAR, // [156]
INVALID_CHAR, // [157]
INVALID_CHAR, // [158]
INVALID_CHAR, // [159]
INVALID_CHAR, // [160]
INVALID_CHAR, // [161]
INVALID_CHAR, // [162]
INVALID_CHAR, // [163]
INVALID_CHAR, // [164]
INVALID_CHAR, // [165]
INVALID_CHAR, // [166]
INVALID_CHAR, // [167]
INVALID_CHAR, // [168]
INVALID_CHAR, // [169]
INVALID_CHAR, // [170]
INVALID_CHAR, // [171]
INVALID_CHAR, // [172]
INVALID_CHAR, // [173]
INVALID_CHAR, // [174]
INVALID_CHAR, // [175]
INVALID_CHAR, // [176]
INVALID_CHAR, // [177]
INVALID_CHAR, // [178]
INVALID_CHAR, // [179]
INVALID_CHAR, // [180]
INVALID_CHAR, // [181]
INVALID_CHAR, // [182]
INVALID_CHAR, // [183]
INVALID_CHAR, // [184]
INVALID_CHAR, // [185]
INVALID_CHAR, // [186]
INVALID_CHAR, // [187]
INVALID_CHAR, // [188]
INVALID_CHAR, // [189]
INVALID_CHAR, // [190]
INVALID_CHAR, // [191]
INVALID_CHAR, // [192]
INVALID_CHAR, // [193]
INVALID_CHAR, // [194]
INVALID_CHAR, // [195]
INVALID_CHAR, // [196]
INVALID_CHAR, // [197]
INVALID_CHAR, // [198]
INVALID_CHAR, // [199]
INVALID_CHAR, // [200]
INVALID_CHAR, // [201]
INVALID_CHAR, // [202]
INVALID_CHAR, // [203]
INVALID_CHAR, // [204]
INVALID_CHAR, // [205]
INVALID_CHAR, // [206]
INVALID_CHAR, // [207]
INVALID_CHAR, // [208]
INVALID_CHAR, // [209]
INVALID_CHAR, // [210]
INVALID_CHAR, // [211]
INVALID_CHAR, // [212]
INVALID_CHAR, // [213]
INVALID_CHAR, // [214]
INVALID_CHAR, // [215]
INVALID_CHAR, // [216]
INVALID_CHAR, // [217]
INVALID_CHAR, // [218]
INVALID_CHAR, // [219]
INVALID_CHAR, // [220]
INVALID_CHAR, // [221]
INVALID_CHAR, // [222]
INVALID_CHAR, // [223]
INVALID_CHAR, // [224]
INVALID_CHAR, // [225]
INVALID_CHAR, // [226]
INVALID_CHAR, // [227]
INVALID_CHAR, // [228]
INVALID_CHAR, // [229]
INVALID_CHAR, // [230]
INVALID_CHAR, // [231]
INVALID_CHAR, // [232]
INVALID_CHAR, // [233]
INVALID_CHAR, // [234]
INVALID_CHAR, // [235]
INVALID_CHAR, // [236]
INVALID_CHAR, // [237]
INVALID_CHAR, // [238]
INVALID_CHAR, // [239]
INVALID_CHAR, // [240]
INVALID_CHAR, // [241]
INVALID_CHAR, // [242]
INVALID_CHAR, // [243]
INVALID_CHAR, // [244]
INVALID_CHAR, // [245]
INVALID_CHAR, // [246]
INVALID_CHAR, // [247]
INVALID_CHAR, // [248]
INVALID_CHAR, // [249]
INVALID_CHAR, // [250]
INVALID_CHAR, // [251]
INVALID_CHAR, // [252]
INVALID_CHAR, // [253]
INVALID_CHAR, // [254]
INVALID_CHAR, // [255]
};
unsigned char g_LetterToCharAminoGap[256] =
{
'A', // [0]
'C', // [1]
'D', // [2]
'E', // [3]
'F', // [4]
'G', // [5]
'H', // [6]
'I', // [7]
'K', // [8]
'L', // [9]
'M', // [10]
'N', // [11]
'P', // [12]
'Q', // [13]
'R', // [14]
'S', // [15]
'T', // [16]
'V', // [17]
'W', // [18]
'Y', // [19]
INVALID_CHAR, // [20]
'-', // [20]
INVALID_CHAR, // [22]
INVALID_CHAR, // [23]
INVALID_CHAR, // [24]
INVALID_CHAR, // [25]
INVALID_CHAR, // [26]
INVALID_CHAR, // [27]
INVALID_CHAR, // [28]
INVALID_CHAR, // [29]
INVALID_CHAR, // [30]
INVALID_CHAR, // [31]
INVALID_CHAR, // [32]
INVALID_CHAR, // [33]
INVALID_CHAR, // [34]
INVALID_CHAR, // [35]
INVALID_CHAR, // [36]
INVALID_CHAR, // [37]
INVALID_CHAR, // [38]
INVALID_CHAR, // [39]
INVALID_CHAR, // [40]
INVALID_CHAR, // [41]
INVALID_CHAR, // [42]
INVALID_CHAR, // [43]
INVALID_CHAR, // [44]
INVALID_CHAR, // [45]
INVALID_CHAR, // [46]
INVALID_CHAR, // [47]
INVALID_CHAR, // [48]
INVALID_CHAR, // [49]
INVALID_CHAR, // [50]
INVALID_CHAR, // [51]
INVALID_CHAR, // [52]
INVALID_CHAR, // [53]
INVALID_CHAR, // [54]
INVALID_CHAR, // [55]
INVALID_CHAR, // [56]
INVALID_CHAR, // [57]
INVALID_CHAR, // [58]
INVALID_CHAR, // [59]
INVALID_CHAR, // [60]
INVALID_CHAR, // [61]
INVALID_CHAR, // [62]
INVALID_CHAR, // [63]
INVALID_CHAR, // [64]
INVALID_CHAR, // [65]
INVALID_CHAR, // [66]
INVALID_CHAR, // [67]
INVALID_CHAR, // [68]
INVALID_CHAR, // [69]
INVALID_CHAR, // [70]
INVALID_CHAR, // [71]
INVALID_CHAR, // [72]
INVALID_CHAR, // [73]
INVALID_CHAR, // [74]
INVALID_CHAR, // [75]
INVALID_CHAR, // [76]
INVALID_CHAR, // [77]
INVALID_CHAR, // [78]
INVALID_CHAR, // [79]
INVALID_CHAR, // [80]
INVALID_CHAR, // [81]
INVALID_CHAR, // [82]
INVALID_CHAR, // [83]
INVALID_CHAR, // [84]
INVALID_CHAR, // [85]
INVALID_CHAR, // [86]
INVALID_CHAR, // [87]
INVALID_CHAR, // [88]
INVALID_CHAR, // [89]
INVALID_CHAR, // [90]
INVALID_CHAR, // [91]
INVALID_CHAR, // [92]
INVALID_CHAR, // [93]
INVALID_CHAR, // [94]
INVALID_CHAR, // [95]
INVALID_CHAR, // [96]
INVALID_CHAR, // [97]
INVALID_CHAR, // [98]
INVALID_CHAR, // [99]
INVALID_CHAR, // [100]
INVALID_CHAR, // [101]
INVALID_CHAR, // [102]
INVALID_CHAR, // [103]
INVALID_CHAR, // [104]
INVALID_CHAR, // [105]
INVALID_CHAR, // [106]
INVALID_CHAR, // [107]
INVALID_CHAR, // [108]
INVALID_CHAR, // [109]
INVALID_CHAR, // [110]
INVALID_CHAR, // [111]
INVALID_CHAR, // [112]
INVALID_CHAR, // [113]
INVALID_CHAR, // [114]
INVALID_CHAR, // [115]
INVALID_CHAR, // [116]
INVALID_CHAR, // [117]
INVALID_CHAR, // [118]
INVALID_CHAR, // [119]
INVALID_CHAR, // [120]
INVALID_CHAR, // [121]
INVALID_CHAR, // [122]
INVALID_CHAR, // [123]
INVALID_CHAR, // [124]
INVALID_CHAR, // [125]
INVALID_CHAR, // [126]
INVALID_CHAR, // [127]
INVALID_CHAR, // [128]
INVALID_CHAR, // [129]
INVALID_CHAR, // [130]
INVALID_CHAR, // [131]
INVALID_CHAR, // [132]
INVALID_CHAR, // [133]
INVALID_CHAR, // [134]
INVALID_CHAR, // [135]
INVALID_CHAR, // [136]
INVALID_CHAR, // [137]
INVALID_CHAR, // [138]
INVALID_CHAR, // [139]
INVALID_CHAR, // [140]
INVALID_CHAR, // [141]
INVALID_CHAR, // [142]
INVALID_CHAR, // [143]
INVALID_CHAR, // [144]
INVALID_CHAR, // [145]
INVALID_CHAR, // [146]
INVALID_CHAR, // [147]
INVALID_CHAR, // [148]
INVALID_CHAR, // [149]
INVALID_CHAR, // [150]
INVALID_CHAR, // [151]
INVALID_CHAR, // [152]
INVALID_CHAR, // [153]
INVALID_CHAR, // [154]
INVALID_CHAR, // [155]
INVALID_CHAR, // [156]
INVALID_CHAR, // [157]
INVALID_CHAR, // [158]
INVALID_CHAR, // [159]
INVALID_CHAR, // [160]
INVALID_CHAR, // [161]
INVALID_CHAR, // [162]
INVALID_CHAR, // [163]
INVALID_CHAR, // [164]
INVALID_CHAR, // [165]
INVALID_CHAR, // [166]
INVALID_CHAR, // [167]
INVALID_CHAR, // [168]
INVALID_CHAR, // [169]
INVALID_CHAR, // [170]
INVALID_CHAR, // [171]
INVALID_CHAR, // [172]
INVALID_CHAR, // [173]
INVALID_CHAR, // [174]
INVALID_CHAR, // [175]
INVALID_CHAR, // [176]
INVALID_CHAR, // [177]
INVALID_CHAR, // [178]
INVALID_CHAR, // [179]
INVALID_CHAR, // [180]
INVALID_CHAR, // [181]
INVALID_CHAR, // [182]
INVALID_CHAR, // [183]
INVALID_CHAR, // [184]
INVALID_CHAR, // [185]
INVALID_CHAR, // [186]
INVALID_CHAR, // [187]
INVALID_CHAR, // [188]
INVALID_CHAR, // [189]
INVALID_CHAR, // [190]
INVALID_CHAR, // [191]
INVALID_CHAR, // [192]
INVALID_CHAR, // [193]
INVALID_CHAR, // [194]
INVALID_CHAR, // [195]
INVALID_CHAR, // [196]
INVALID_CHAR, // [197]
INVALID_CHAR, // [198]
INVALID_CHAR, // [199]
INVALID_CHAR, // [200]
INVALID_CHAR, // [201]
INVALID_CHAR, // [202]
INVALID_CHAR, // [203]
INVALID_CHAR, // [204]
INVALID_CHAR, // [205]
INVALID_CHAR, // [206]
INVALID_CHAR, // [207]
INVALID_CHAR, // [208]
INVALID_CHAR, // [209]
INVALID_CHAR, // [210]
INVALID_CHAR, // [211]
INVALID_CHAR, // [212]
INVALID_CHAR, // [213]
INVALID_CHAR, // [214]
INVALID_CHAR, // [215]
INVALID_CHAR, // [216]
INVALID_CHAR, // [217]
INVALID_CHAR, // [218]
INVALID_CHAR, // [219]
INVALID_CHAR, // [220]
INVALID_CHAR, // [221]
INVALID_CHAR, // [222]
INVALID_CHAR, // [223]
INVALID_CHAR, // [224]
INVALID_CHAR, // [225]
INVALID_CHAR, // [226]
INVALID_CHAR, // [227]
INVALID_CHAR, // [228]
INVALID_CHAR, // [229]
INVALID_CHAR, // [230]
INVALID_CHAR, // [231]
INVALID_CHAR, // [232]
INVALID_CHAR, // [233]
INVALID_CHAR, // [234]
INVALID_CHAR, // [235]
INVALID_CHAR, // [236]
INVALID_CHAR, // [237]
INVALID_CHAR, // [238]
INVALID_CHAR, // [239]
INVALID_CHAR, // [240]
INVALID_CHAR, // [241]
INVALID_CHAR, // [242]
INVALID_CHAR, // [243]
INVALID_CHAR, // [244]
INVALID_CHAR, // [245]
INVALID_CHAR, // [246]
INVALID_CHAR, // [247]
INVALID_CHAR, // [248]
INVALID_CHAR, // [249]
INVALID_CHAR, // [250]
INVALID_CHAR, // [251]
INVALID_CHAR, // [252]
INVALID_CHAR, // [253]
INVALID_CHAR, // [254]
INVALID_CHAR, // [255]
};
unsigned char g_CharToLetterNucleo[256] =
{
INVALID_LETTER, // [ 0] = 0x00
INVALID_LETTER, // [ 1] = 0x01
INVALID_LETTER, // [ 2] = 0x02
INVALID_LETTER, // [ 3] = 0x03
INVALID_LETTER, // [ 4] = 0x04
INVALID_LETTER, // [ 5] = 0x05
INVALID_LETTER, // [ 6] = 0x06
INVALID_LETTER, // [ 7] = 0x07
INVALID_LETTER, // [ 8] = 0x08
INVALID_LETTER, // [ 9] = 0x09
INVALID_LETTER, // [ 10] = 0x0a
INVALID_LETTER, // [ 11] = 0x0b
INVALID_LETTER, // [ 12] = 0x0c
INVALID_LETTER, // [ 13] = 0x0d
INVALID_LETTER, // [ 14] = 0x0e
INVALID_LETTER, // [ 15] = 0x0f
INVALID_LETTER, // [ 16] = 0x10
INVALID_LETTER, // [ 17] = 0x11
INVALID_LETTER, // [ 18] = 0x12
INVALID_LETTER, // [ 19] = 0x13
INVALID_LETTER, // [ 20] = 0x14
INVALID_LETTER, // [ 21] = 0x15
INVALID_LETTER, // [ 22] = 0x16
INVALID_LETTER, // [ 23] = 0x17
INVALID_LETTER, // [ 24] = 0x18
INVALID_LETTER, // [ 25] = 0x19
INVALID_LETTER, // [ 26] = 0x1a
INVALID_LETTER, // [ 27] = 0x1b
INVALID_LETTER, // [ 28] = 0x1c
INVALID_LETTER, // [ 29] = 0x1d
INVALID_LETTER, // [ 30] = 0x1e
INVALID_LETTER, // [ 31] = 0x1f
INVALID_LETTER, // [ 32] = 32
INVALID_LETTER, // [ 33] = 33
INVALID_LETTER, // [ 34] = 34
INVALID_LETTER, // [ 35] = 35
INVALID_LETTER, // [ 36] = 36
INVALID_LETTER, // [ 37] = 37
INVALID_LETTER, // [ 38] = 38
INVALID_LETTER, // [ 39] = 39
INVALID_LETTER, // [ 40] = 40
INVALID_LETTER, // [ 41] = 41
INVALID_LETTER, // [ 42] = 42
INVALID_LETTER, // [ 43] = 43
INVALID_LETTER, // [ 44] = 44
INVALID_LETTER, // [ 45] = 45
INVALID_LETTER, // [ 46] = 46
INVALID_LETTER, // [ 47] = 47
INVALID_LETTER, // [ 48] = 48
INVALID_LETTER, // [ 49] = 49
INVALID_LETTER, // [ 50] = 50
INVALID_LETTER, // [ 51] = 51
INVALID_LETTER, // [ 52] = 52
INVALID_LETTER, // [ 53] = 53
INVALID_LETTER, // [ 54] = 54
INVALID_LETTER, // [ 55] = 55
INVALID_LETTER, // [ 56] = 56
INVALID_LETTER, // [ 57] = 57
INVALID_LETTER, // [ 58] = 58
INVALID_LETTER, // [ 59] = 59
INVALID_LETTER, // [ 60] = 60
INVALID_LETTER, // [ 61] = 61
INVALID_LETTER, // [ 62] = 62
INVALID_LETTER, // [ 63] = 63
INVALID_LETTER, // [ 64] = 64
0 , // [ 65] = A (Nucleotide)
INVALID_LETTER, // [ 66] = 66
1 , // [ 67] = C (Nucleotide)
INVALID_LETTER, // [ 68] = 68
INVALID_LETTER, // [ 69] = 69
INVALID_LETTER, // [ 70] = 70
2 , // [ 71] = G (Nucleotide)
INVALID_LETTER, // [ 72] = 72
INVALID_LETTER, // [ 73] = 73
INVALID_LETTER, // [ 74] = 74
INVALID_LETTER, // [ 75] = 75
INVALID_LETTER, // [ 76] = 76
INVALID_LETTER, // [ 77] = 77
INVALID_LETTER, // [ 78] = 78
INVALID_LETTER, // [ 79] = 79
INVALID_LETTER, // [ 80] = 80
INVALID_LETTER, // [ 81] = 81
INVALID_LETTER, // [ 82] = 82
INVALID_LETTER, // [ 83] = 83
3 , // [ 84] = T (Nucleotide)
3 , // [ 85] = U (Nucleotide)
INVALID_LETTER, // [ 86] = 86
INVALID_LETTER, // [ 87] = 87
INVALID_LETTER, // [ 88] = 88
INVALID_LETTER, // [ 89] = 89
INVALID_LETTER, // [ 90] = 90
INVALID_LETTER, // [ 91] = 91
INVALID_LETTER, // [ 92] = 92
INVALID_LETTER, // [ 93] = 93
INVALID_LETTER, // [ 94] = 94
INVALID_LETTER, // [ 95] = 95
INVALID_LETTER, // [ 96] = 96
0 , // [ 97] = a (Nucleotide)
INVALID_LETTER, // [ 98] = 98
1 , // [ 99] = c (Nucleotide)
INVALID_LETTER, // [100] = 100
INVALID_LETTER, // [101] = 101
INVALID_LETTER, // [102] = 102
2 , // [103] = g (Nucleotide)
INVALID_LETTER, // [104] = 104
INVALID_LETTER, // [105] = 105
INVALID_LETTER, // [106] = 106
INVALID_LETTER, // [107] = 107
INVALID_LETTER, // [108] = 108
INVALID_LETTER, // [109] = 109
INVALID_LETTER, // [110] = 110
INVALID_LETTER, // [111] = 111
INVALID_LETTER, // [112] = 112
INVALID_LETTER, // [113] = 113
INVALID_LETTER, // [114] = 114
INVALID_LETTER, // [115] = 115
3 , // [116] = t (Nucleotide)
3 , // [117] = u (Nucleotide)
INVALID_LETTER, // [118] = 118
INVALID_LETTER, // [119] = 119
INVALID_LETTER, // [120] = 120
INVALID_LETTER, // [121] = 121
INVALID_LETTER, // [122] = 122
INVALID_LETTER, // [123] = 123
INVALID_LETTER, // [124] = 124
INVALID_LETTER, // [125] = 125
INVALID_LETTER, // [126] = 126
INVALID_LETTER, // [127] = 0x7f
INVALID_LETTER, // [128] = 0x80
INVALID_LETTER, // [129] = 0x81
INVALID_LETTER, // [130] = 0x82
INVALID_LETTER, // [131] = 0x83
INVALID_LETTER, // [132] = 0x84
INVALID_LETTER, // [133] = 0x85
INVALID_LETTER, // [134] = 0x86
INVALID_LETTER, // [135] = 0x87
INVALID_LETTER, // [136] = 0x88
INVALID_LETTER, // [137] = 0x89
INVALID_LETTER, // [138] = 0x8a
INVALID_LETTER, // [139] = 0x8b
INVALID_LETTER, // [140] = 0x8c
INVALID_LETTER, // [141] = 0x8d
INVALID_LETTER, // [142] = 0x8e
INVALID_LETTER, // [143] = 0x8f
INVALID_LETTER, // [144] = 0x90
INVALID_LETTER, // [145] = 0x91
INVALID_LETTER, // [146] = 0x92
INVALID_LETTER, // [147] = 0x93
INVALID_LETTER, // [148] = 0x94
INVALID_LETTER, // [149] = 0x95
INVALID_LETTER, // [150] = 0x96
INVALID_LETTER, // [151] = 0x97
INVALID_LETTER, // [152] = 0x98
INVALID_LETTER, // [153] = 0x99
INVALID_LETTER, // [154] = 0x9a
INVALID_LETTER, // [155] = 0x9b
INVALID_LETTER, // [156] = 0x9c
INVALID_LETTER, // [157] = 0x9d
INVALID_LETTER, // [158] = 0x9e
INVALID_LETTER, // [159] = 0x9f
INVALID_LETTER, // [160] = 0xa0
INVALID_LETTER, // [161] = 0xa1
INVALID_LETTER, // [162] = 0xa2
INVALID_LETTER, // [163] = 0xa3
INVALID_LETTER, // [164] = 0xa4
INVALID_LETTER, // [165] = 0xa5
INVALID_LETTER, // [166] = 0xa6
INVALID_LETTER, // [167] = 0xa7
INVALID_LETTER, // [168] = 0xa8
INVALID_LETTER, // [169] = 0xa9
INVALID_LETTER, // [170] = 0xaa
INVALID_LETTER, // [171] = 0xab
INVALID_LETTER, // [172] = 0xac
INVALID_LETTER, // [173] = 0xad
INVALID_LETTER, // [174] = 0xae
INVALID_LETTER, // [175] = 0xaf
INVALID_LETTER, // [176] = 0xb0
INVALID_LETTER, // [177] = 0xb1
INVALID_LETTER, // [178] = 0xb2
INVALID_LETTER, // [179] = 0xb3
INVALID_LETTER, // [180] = 0xb4
INVALID_LETTER, // [181] = 0xb5
INVALID_LETTER, // [182] = 0xb6
INVALID_LETTER, // [183] = 0xb7
INVALID_LETTER, // [184] = 0xb8
INVALID_LETTER, // [185] = 0xb9
INVALID_LETTER, // [186] = 0xba
INVALID_LETTER, // [187] = 0xbb
INVALID_LETTER, // [188] = 0xbc
INVALID_LETTER, // [189] = 0xbd
INVALID_LETTER, // [190] = 0xbe
INVALID_LETTER, // [191] = 0xbf
INVALID_LETTER, // [192] = 0xc0
INVALID_LETTER, // [193] = 0xc1
INVALID_LETTER, // [194] = 0xc2
INVALID_LETTER, // [195] = 0xc3
INVALID_LETTER, // [196] = 0xc4
INVALID_LETTER, // [197] = 0xc5
INVALID_LETTER, // [198] = 0xc6
INVALID_LETTER, // [199] = 0xc7
INVALID_LETTER, // [200] = 0xc8
INVALID_LETTER, // [201] = 0xc9
INVALID_LETTER, // [202] = 0xca
INVALID_LETTER, // [203] = 0xcb
INVALID_LETTER, // [204] = 0xcc
INVALID_LETTER, // [205] = 0xcd
INVALID_LETTER, // [206] = 0xce
INVALID_LETTER, // [207] = 0xcf
INVALID_LETTER, // [208] = 0xd0
INVALID_LETTER, // [209] = 0xd1
INVALID_LETTER, // [210] = 0xd2
INVALID_LETTER, // [211] = 0xd3
INVALID_LETTER, // [212] = 0xd4
INVALID_LETTER, // [213] = 0xd5
INVALID_LETTER, // [214] = 0xd6
INVALID_LETTER, // [215] = 0xd7
INVALID_LETTER, // [216] = 0xd8
INVALID_LETTER, // [217] = 0xd9
INVALID_LETTER, // [218] = 0xda
INVALID_LETTER, // [219] = 0xdb
INVALID_LETTER, // [220] = 0xdc
INVALID_LETTER, // [221] = 0xdd
INVALID_LETTER, // [222] = 0xde
INVALID_LETTER, // [223] = 0xdf
INVALID_LETTER, // [224] = 0xe0
INVALID_LETTER, // [225] = 0xe1
INVALID_LETTER, // [226] = 0xe2
INVALID_LETTER, // [227] = 0xe3
INVALID_LETTER, // [228] = 0xe4
INVALID_LETTER, // [229] = 0xe5
INVALID_LETTER, // [230] = 0xe6
INVALID_LETTER, // [231] = 0xe7
INVALID_LETTER, // [232] = 0xe8
INVALID_LETTER, // [233] = 0xe9
INVALID_LETTER, // [234] = 0xea
INVALID_LETTER, // [235] = 0xeb
INVALID_LETTER, // [236] = 0xec
INVALID_LETTER, // [237] = 0xed
INVALID_LETTER, // [238] = 0xee
INVALID_LETTER, // [239] = 0xef
INVALID_LETTER, // [240] = 0xf0
INVALID_LETTER, // [241] = 0xf1
INVALID_LETTER, // [242] = 0xf2
INVALID_LETTER, // [243] = 0xf3
INVALID_LETTER, // [244] = 0xf4
INVALID_LETTER, // [245] = 0xf5
INVALID_LETTER, // [246] = 0xf6
INVALID_LETTER, // [247] = 0xf7
INVALID_LETTER, // [248] = 0xf8
INVALID_LETTER, // [249] = 0xf9
INVALID_LETTER, // [250] = 0xfa
INVALID_LETTER, // [251] = 0xfb
INVALID_LETTER, // [252] = 0xfc
INVALID_LETTER, // [253] = 0xfd
INVALID_LETTER, // [254] = 0xfe
INVALID_LETTER, // [255] = 0xff
};
unsigned char g_CharToLetterNucleoGap[256] =
{
INVALID_LETTER, // [ 0] = 0x00
INVALID_LETTER, // [ 1] = 0x01
INVALID_LETTER, // [ 2] = 0x02
INVALID_LETTER, // [ 3] = 0x03
INVALID_LETTER, // [ 4] = 0x04
INVALID_LETTER, // [ 5] = 0x05
INVALID_LETTER, // [ 6] = 0x06
INVALID_LETTER, // [ 7] = 0x07
INVALID_LETTER, // [ 8] = 0x08
INVALID_LETTER, // [ 9] = 0x09
INVALID_LETTER, // [ 10] = 0x0a
INVALID_LETTER, // [ 11] = 0x0b
INVALID_LETTER, // [ 12] = 0x0c
INVALID_LETTER, // [ 13] = 0x0d
INVALID_LETTER, // [ 14] = 0x0e
INVALID_LETTER, // [ 15] = 0x0f
INVALID_LETTER, // [ 16] = 0x10
INVALID_LETTER, // [ 17] = 0x11
INVALID_LETTER, // [ 18] = 0x12
INVALID_LETTER, // [ 19] = 0x13
INVALID_LETTER, // [ 20] = 0x14
INVALID_LETTER, // [ 21] = 0x15
INVALID_LETTER, // [ 22] = 0x16
INVALID_LETTER, // [ 23] = 0x17
INVALID_LETTER, // [ 24] = 0x18
INVALID_LETTER, // [ 25] = 0x19
INVALID_LETTER, // [ 26] = 0x1a
INVALID_LETTER, // [ 27] = 0x1b
INVALID_LETTER, // [ 28] = 0x1c
INVALID_LETTER, // [ 29] = 0x1d
INVALID_LETTER, // [ 30] = 0x1e
INVALID_LETTER, // [ 31] = 0x1f
INVALID_LETTER, // [ 32] = 32
INVALID_LETTER, // [ 33] = 33
INVALID_LETTER, // [ 34] = 34
INVALID_LETTER, // [ 35] = 35
INVALID_LETTER, // [ 36] = 36
INVALID_LETTER, // [ 37] = 37
INVALID_LETTER, // [ 38] = 38
INVALID_LETTER, // [ 39] = 39
INVALID_LETTER, // [ 40] = 40
INVALID_LETTER, // [ 41] = 41
INVALID_LETTER, // [ 42] = 42
INVALID_LETTER, // [ 43] = 43
INVALID_LETTER, // [ 44] = 44
4 , // [ 45] = - (gap)
INVALID_LETTER, // [ 46] = 46
INVALID_LETTER, // [ 47] = 47
INVALID_LETTER, // [ 48] = 48
INVALID_LETTER, // [ 49] = 49
INVALID_LETTER, // [ 50] = 50
INVALID_LETTER, // [ 51] = 51
INVALID_LETTER, // [ 52] = 52
INVALID_LETTER, // [ 53] = 53
INVALID_LETTER, // [ 54] = 54
INVALID_LETTER, // [ 55] = 55
INVALID_LETTER, // [ 56] = 56
INVALID_LETTER, // [ 57] = 57
INVALID_LETTER, // [ 58] = 58
INVALID_LETTER, // [ 59] = 59
INVALID_LETTER, // [ 60] = 60
INVALID_LETTER, // [ 61] = 61
INVALID_LETTER, // [ 62] = 62
INVALID_LETTER, // [ 63] = 63
INVALID_LETTER, // [ 64] = 64
0 , // [ 65] = A (Nucleotide)
INVALID_LETTER, // [ 66] = 66
1 , // [ 67] = C (Nucleotide)
INVALID_LETTER, // [ 68] = 68
INVALID_LETTER, // [ 69] = 69
INVALID_LETTER, // [ 70] = 70
2 , // [ 71] = G (Nucleotide)
INVALID_LETTER, // [ 72] = 72
INVALID_LETTER, // [ 73] = 73
INVALID_LETTER, // [ 74] = 74
INVALID_LETTER, // [ 75] = 75
INVALID_LETTER, // [ 76] = 76
INVALID_LETTER, // [ 77] = 77
INVALID_LETTER, // [ 78] = 78
INVALID_LETTER, // [ 79] = 79
INVALID_LETTER, // [ 80] = 80
INVALID_LETTER, // [ 81] = 81
INVALID_LETTER, // [ 82] = 82
INVALID_LETTER, // [ 83] = 83
3 , // [ 84] = T (Nucleotide)
3 , // [ 85] = U (Nucleotide)
INVALID_LETTER, // [ 86] = 86
INVALID_LETTER, // [ 87] = 87
INVALID_LETTER, // [ 88] = 88
INVALID_LETTER, // [ 89] = 89
INVALID_LETTER, // [ 90] = 90
INVALID_LETTER, // [ 91] = 91
INVALID_LETTER, // [ 92] = 92
INVALID_LETTER, // [ 93] = 93
INVALID_LETTER, // [ 94] = 94
INVALID_LETTER, // [ 95] = 95
INVALID_LETTER, // [ 96] = 96
0 , // [ 97] = a (Nucleotide)
INVALID_LETTER, // [ 98] = 98
1 , // [ 99] = c (Nucleotide)
INVALID_LETTER, // [100] = 100
INVALID_LETTER, // [101] = 101
INVALID_LETTER, // [102] = 102
2 , // [103] = g (Nucleotide)
INVALID_LETTER, // [104] = 104
INVALID_LETTER, // [105] = 105
INVALID_LETTER, // [106] = 106
INVALID_LETTER, // [107] = 107
INVALID_LETTER, // [108] = 108
INVALID_LETTER, // [109] = 109
INVALID_LETTER, // [110] = 110
INVALID_LETTER, // [111] = 111
INVALID_LETTER, // [112] = 112
INVALID_LETTER, // [113] = 113
INVALID_LETTER, // [114] = 114
INVALID_LETTER, // [115] = 115
3 , // [116] = t (Nucleotide)
3 , // [117] = u (Nucleotide)
INVALID_LETTER, // [118] = 118
INVALID_LETTER, // [119] = 119
INVALID_LETTER, // [120] = 120
INVALID_LETTER, // [121] = 121
INVALID_LETTER, // [122] = 122
INVALID_LETTER, // [123] = 123
INVALID_LETTER, // [124] = 124
INVALID_LETTER, // [125] = 125
INVALID_LETTER, // [126] = 126
INVALID_LETTER, // [127] = 0x7f
INVALID_LETTER, // [128] = 0x80
INVALID_LETTER, // [129] = 0x81
INVALID_LETTER, // [130] = 0x82
INVALID_LETTER, // [131] = 0x83
INVALID_LETTER, // [132] = 0x84
INVALID_LETTER, // [133] = 0x85
INVALID_LETTER, // [134] = 0x86
INVALID_LETTER, // [135] = 0x87
INVALID_LETTER, // [136] = 0x88
INVALID_LETTER, // [137] = 0x89
INVALID_LETTER, // [138] = 0x8a
INVALID_LETTER, // [139] = 0x8b
INVALID_LETTER, // [140] = 0x8c
INVALID_LETTER, // [141] = 0x8d
INVALID_LETTER, // [142] = 0x8e
INVALID_LETTER, // [143] = 0x8f
INVALID_LETTER, // [144] = 0x90
INVALID_LETTER, // [145] = 0x91
INVALID_LETTER, // [146] = 0x92
INVALID_LETTER, // [147] = 0x93
INVALID_LETTER, // [148] = 0x94
INVALID_LETTER, // [149] = 0x95
INVALID_LETTER, // [150] = 0x96
INVALID_LETTER, // [151] = 0x97
INVALID_LETTER, // [152] = 0x98
INVALID_LETTER, // [153] = 0x99
INVALID_LETTER, // [154] = 0x9a
INVALID_LETTER, // [155] = 0x9b
INVALID_LETTER, // [156] = 0x9c
INVALID_LETTER, // [157] = 0x9d
INVALID_LETTER, // [158] = 0x9e
INVALID_LETTER, // [159] = 0x9f
INVALID_LETTER, // [160] = 0xa0
INVALID_LETTER, // [161] = 0xa1
INVALID_LETTER, // [162] = 0xa2
INVALID_LETTER, // [163] = 0xa3
INVALID_LETTER, // [164] = 0xa4
INVALID_LETTER, // [165] = 0xa5
INVALID_LETTER, // [166] = 0xa6
INVALID_LETTER, // [167] = 0xa7
INVALID_LETTER, // [168] = 0xa8
INVALID_LETTER, // [169] = 0xa9
INVALID_LETTER, // [170] = 0xaa
INVALID_LETTER, // [171] = 0xab
INVALID_LETTER, // [172] = 0xac
INVALID_LETTER, // [173] = 0xad
INVALID_LETTER, // [174] = 0xae
INVALID_LETTER, // [175] = 0xaf
INVALID_LETTER, // [176] = 0xb0
INVALID_LETTER, // [177] = 0xb1
INVALID_LETTER, // [178] = 0xb2
INVALID_LETTER, // [179] = 0xb3
INVALID_LETTER, // [180] = 0xb4
INVALID_LETTER, // [181] = 0xb5
INVALID_LETTER, // [182] = 0xb6
INVALID_LETTER, // [183] = 0xb7
INVALID_LETTER, // [184] = 0xb8
INVALID_LETTER, // [185] = 0xb9
INVALID_LETTER, // [186] = 0xba
INVALID_LETTER, // [187] = 0xbb
INVALID_LETTER, // [188] = 0xbc
INVALID_LETTER, // [189] = 0xbd
INVALID_LETTER, // [190] = 0xbe
INVALID_LETTER, // [191] = 0xbf
INVALID_LETTER, // [192] = 0xc0
INVALID_LETTER, // [193] = 0xc1
INVALID_LETTER, // [194] = 0xc2
INVALID_LETTER, // [195] = 0xc3
INVALID_LETTER, // [196] = 0xc4
INVALID_LETTER, // [197] = 0xc5
INVALID_LETTER, // [198] = 0xc6
INVALID_LETTER, // [199] = 0xc7
INVALID_LETTER, // [200] = 0xc8
INVALID_LETTER, // [201] = 0xc9
INVALID_LETTER, // [202] = 0xca
INVALID_LETTER, // [203] = 0xcb
INVALID_LETTER, // [204] = 0xcc
INVALID_LETTER, // [205] = 0xcd
INVALID_LETTER, // [206] = 0xce
INVALID_LETTER, // [207] = 0xcf
INVALID_LETTER, // [208] = 0xd0
INVALID_LETTER, // [209] = 0xd1
INVALID_LETTER, // [210] = 0xd2
INVALID_LETTER, // [211] = 0xd3
INVALID_LETTER, // [212] = 0xd4
INVALID_LETTER, // [213] = 0xd5
INVALID_LETTER, // [214] = 0xd6
INVALID_LETTER, // [215] = 0xd7
INVALID_LETTER, // [216] = 0xd8
INVALID_LETTER, // [217] = 0xd9
INVALID_LETTER, // [218] = 0xda
INVALID_LETTER, // [219] = 0xdb
INVALID_LETTER, // [220] = 0xdc
INVALID_LETTER, // [221] = 0xdd
INVALID_LETTER, // [222] = 0xde
INVALID_LETTER, // [223] = 0xdf
INVALID_LETTER, // [224] = 0xe0
INVALID_LETTER, // [225] = 0xe1
INVALID_LETTER, // [226] = 0xe2
INVALID_LETTER, // [227] = 0xe3
INVALID_LETTER, // [228] = 0xe4
INVALID_LETTER, // [229] = 0xe5
INVALID_LETTER, // [230] = 0xe6
INVALID_LETTER, // [231] = 0xe7
INVALID_LETTER, // [232] = 0xe8
INVALID_LETTER, // [233] = 0xe9
INVALID_LETTER, // [234] = 0xea
INVALID_LETTER, // [235] = 0xeb
INVALID_LETTER, // [236] = 0xec
INVALID_LETTER, // [237] = 0xed
INVALID_LETTER, // [238] = 0xee
INVALID_LETTER, // [239] = 0xef
INVALID_LETTER, // [240] = 0xf0
INVALID_LETTER, // [241] = 0xf1
INVALID_LETTER, // [242] = 0xf2
INVALID_LETTER, // [243] = 0xf3
INVALID_LETTER, // [244] = 0xf4
INVALID_LETTER, // [245] = 0xf5
INVALID_LETTER, // [246] = 0xf6
INVALID_LETTER, // [247] = 0xf7
INVALID_LETTER, // [248] = 0xf8
INVALID_LETTER, // [249] = 0xf9
INVALID_LETTER, // [250] = 0xfa
INVALID_LETTER, // [251] = 0xfb
INVALID_LETTER, // [252] = 0xfc
INVALID_LETTER, // [253] = 0xfd
INVALID_LETTER, // [254] = 0xfe
INVALID_LETTER, // [255] = 0xff
};
unsigned char g_CharToLetterNucleoMasked[256] =
{
INVALID_LETTER, // [ 0] = 0x00
INVALID_LETTER, // [ 1] = 0x01
INVALID_LETTER, // [ 2] = 0x02
INVALID_LETTER, // [ 3] = 0x03
INVALID_LETTER, // [ 4] = 0x04
INVALID_LETTER, // [ 5] = 0x05
INVALID_LETTER, // [ 6] = 0x06
INVALID_LETTER, // [ 7] = 0x07
INVALID_LETTER, // [ 8] = 0x08
INVALID_LETTER, // [ 9] = 0x09
INVALID_LETTER, // [ 10] = 0x0a
INVALID_LETTER, // [ 11] = 0x0b
INVALID_LETTER, // [ 12] = 0x0c
INVALID_LETTER, // [ 13] = 0x0d
INVALID_LETTER, // [ 14] = 0x0e
INVALID_LETTER, // [ 15] = 0x0f
INVALID_LETTER, // [ 16] = 0x10
INVALID_LETTER, // [ 17] = 0x11
INVALID_LETTER, // [ 18] = 0x12
INVALID_LETTER, // [ 19] = 0x13
INVALID_LETTER, // [ 20] = 0x14
INVALID_LETTER, // [ 21] = 0x15
INVALID_LETTER, // [ 22] = 0x16
INVALID_LETTER, // [ 23] = 0x17
INVALID_LETTER, // [ 24] = 0x18
INVALID_LETTER, // [ 25] = 0x19
INVALID_LETTER, // [ 26] = 0x1a
INVALID_LETTER, // [ 27] = 0x1b
INVALID_LETTER, // [ 28] = 0x1c
INVALID_LETTER, // [ 29] = 0x1d
INVALID_LETTER, // [ 30] = 0x1e
INVALID_LETTER, // [ 31] = 0x1f
INVALID_LETTER, // [ 32] = 32
INVALID_LETTER, // [ 33] = 33
INVALID_LETTER, // [ 34] = 34
INVALID_LETTER, // [ 35] = 35
INVALID_LETTER, // [ 36] = 36
INVALID_LETTER, // [ 37] = 37
INVALID_LETTER, // [ 38] = 38
INVALID_LETTER, // [ 39] = 39
INVALID_LETTER, // [ 40] = 40
INVALID_LETTER, // [ 41] = 41
INVALID_LETTER, // [ 42] = 42
INVALID_LETTER, // [ 43] = 43
INVALID_LETTER, // [ 44] = 44
INVALID_LETTER, // [ 45] = 45
INVALID_LETTER, // [ 46] = 46
INVALID_LETTER, // [ 47] = 47
INVALID_LETTER, // [ 48] = 48
INVALID_LETTER, // [ 49] = 49
INVALID_LETTER, // [ 50] = 50
INVALID_LETTER, // [ 51] = 51
INVALID_LETTER, // [ 52] = 52
INVALID_LETTER, // [ 53] = 53
INVALID_LETTER, // [ 54] = 54
INVALID_LETTER, // [ 55] = 55
INVALID_LETTER, // [ 56] = 56
INVALID_LETTER, // [ 57] = 57
INVALID_LETTER, // [ 58] = 58
INVALID_LETTER, // [ 59] = 59
INVALID_LETTER, // [ 60] = 60
INVALID_LETTER, // [ 61] = 61
INVALID_LETTER, // [ 62] = 62
INVALID_LETTER, // [ 63] = 63
INVALID_LETTER, // [ 64] = 64
0 , // [ 65] = A (Nucleotide)
INVALID_LETTER, // [ 66] = 66
1 , // [ 67] = C (Nucleotide)
INVALID_LETTER, // [ 68] = 68
INVALID_LETTER, // [ 69] = 69
INVALID_LETTER, // [ 70] = 70
2 , // [ 71] = G (Nucleotide)
INVALID_LETTER, // [ 72] = 72
INVALID_LETTER, // [ 73] = 73
INVALID_LETTER, // [ 74] = 74
INVALID_LETTER, // [ 75] = 75
INVALID_LETTER, // [ 76] = 76
INVALID_LETTER, // [ 77] = 77
INVALID_LETTER, // [ 78] = 78
INVALID_LETTER, // [ 79] = 79
INVALID_LETTER, // [ 80] = 80
INVALID_LETTER, // [ 81] = 81
INVALID_LETTER, // [ 82] = 82
INVALID_LETTER, // [ 83] = 83
3 , // [ 84] = T (Nucleotide)
3 , // [ 85] = U (Nucleotide)
INVALID_LETTER, // [ 86] = 86
INVALID_LETTER, // [ 87] = 87
INVALID_LETTER, // [ 88] = 88
INVALID_LETTER, // [ 89] = 89
INVALID_LETTER, // [ 90] = 90
INVALID_LETTER, // [ 91] = 91
INVALID_LETTER, // [ 92] = 92
INVALID_LETTER, // [ 93] = 93
INVALID_LETTER, // [ 94] = 94
INVALID_LETTER, // [ 95] = 95
INVALID_LETTER, // [ 96] = 96
INVALID_LETTER, // [ 97] = 0x61
INVALID_LETTER, // [ 98] = 0x62
INVALID_LETTER, // [ 99] = 0x63
INVALID_LETTER, // [100] = 0x64
INVALID_LETTER, // [101] = 0x65
INVALID_LETTER, // [102] = 0x66
INVALID_LETTER, // [103] = 0x67
INVALID_LETTER, // [104] = 0x68
INVALID_LETTER, // [105] = 0x69
INVALID_LETTER, // [106] = 0x6a
INVALID_LETTER, // [107] = 0x6b
INVALID_LETTER, // [108] = 0x6c
INVALID_LETTER, // [109] = 0x6d
INVALID_LETTER, // [110] = 0x6e
INVALID_LETTER, // [111] = 0x6f
INVALID_LETTER, // [112] = 0x70
INVALID_LETTER, // [113] = 0x71
INVALID_LETTER, // [114] = 0x72
INVALID_LETTER, // [115] = 0x73
INVALID_LETTER, // [116] = 0x74
INVALID_LETTER, // [117] = 0x75
INVALID_LETTER, // [118] = 0x76
INVALID_LETTER, // [119] = 0x77
INVALID_LETTER, // [120] = 0x78
INVALID_LETTER, // [121] = 0x79
INVALID_LETTER, // [122] = 0x7a
INVALID_LETTER, // [123] = 123
INVALID_LETTER, // [124] = 124
INVALID_LETTER, // [125] = 125
INVALID_LETTER, // [126] = 126
INVALID_LETTER, // [127] = 0x7f
INVALID_LETTER, // [128] = 0x80
INVALID_LETTER, // [129] = 0x81
INVALID_LETTER, // [130] = 0x82
INVALID_LETTER, // [131] = 0x83
INVALID_LETTER, // [132] = 0x84
INVALID_LETTER, // [133] = 0x85
INVALID_LETTER, // [134] = 0x86
INVALID_LETTER, // [135] = 0x87
INVALID_LETTER, // [136] = 0x88
INVALID_LETTER, // [137] = 0x89
INVALID_LETTER, // [138] = 0x8a
INVALID_LETTER, // [139] = 0x8b
INVALID_LETTER, // [140] = 0x8c
INVALID_LETTER, // [141] = 0x8d
INVALID_LETTER, // [142] = 0x8e
INVALID_LETTER, // [143] = 0x8f
INVALID_LETTER, // [144] = 0x90
INVALID_LETTER, // [145] = 0x91
INVALID_LETTER, // [146] = 0x92
INVALID_LETTER, // [147] = 0x93
INVALID_LETTER, // [148] = 0x94
INVALID_LETTER, // [149] = 0x95
INVALID_LETTER, // [150] = 0x96
INVALID_LETTER, // [151] = 0x97
INVALID_LETTER, // [152] = 0x98
INVALID_LETTER, // [153] = 0x99
INVALID_LETTER, // [154] = 0x9a
INVALID_LETTER, // [155] = 0x9b
INVALID_LETTER, // [156] = 0x9c
INVALID_LETTER, // [157] = 0x9d
INVALID_LETTER, // [158] = 0x9e
INVALID_LETTER, // [159] = 0x9f
INVALID_LETTER, // [160] = 0xa0
INVALID_LETTER, // [161] = 0xa1
INVALID_LETTER, // [162] = 0xa2
INVALID_LETTER, // [163] = 0xa3
INVALID_LETTER, // [164] = 0xa4
INVALID_LETTER, // [165] = 0xa5
INVALID_LETTER, // [166] = 0xa6
INVALID_LETTER, // [167] = 0xa7
INVALID_LETTER, // [168] = 0xa8
INVALID_LETTER, // [169] = 0xa9
INVALID_LETTER, // [170] = 0xaa
INVALID_LETTER, // [171] = 0xab
INVALID_LETTER, // [172] = 0xac
INVALID_LETTER, // [173] = 0xad
INVALID_LETTER, // [174] = 0xae
INVALID_LETTER, // [175] = 0xaf
INVALID_LETTER, // [176] = 0xb0
INVALID_LETTER, // [177] = 0xb1
INVALID_LETTER, // [178] = 0xb2
INVALID_LETTER, // [179] = 0xb3
INVALID_LETTER, // [180] = 0xb4
INVALID_LETTER, // [181] = 0xb5
INVALID_LETTER, // [182] = 0xb6
INVALID_LETTER, // [183] = 0xb7
INVALID_LETTER, // [184] = 0xb8
INVALID_LETTER, // [185] = 0xb9
INVALID_LETTER, // [186] = 0xba
INVALID_LETTER, // [187] = 0xbb
INVALID_LETTER, // [188] = 0xbc
INVALID_LETTER, // [189] = 0xbd
INVALID_LETTER, // [190] = 0xbe
INVALID_LETTER, // [191] = 0xbf
INVALID_LETTER, // [192] = 0xc0
INVALID_LETTER, // [193] = 0xc1
INVALID_LETTER, // [194] = 0xc2
INVALID_LETTER, // [195] = 0xc3
INVALID_LETTER, // [196] = 0xc4
INVALID_LETTER, // [197] = 0xc5
INVALID_LETTER, // [198] = 0xc6
INVALID_LETTER, // [199] = 0xc7
INVALID_LETTER, // [200] = 0xc8
INVALID_LETTER, // [201] = 0xc9
INVALID_LETTER, // [202] = 0xca
INVALID_LETTER, // [203] = 0xcb
INVALID_LETTER, // [204] = 0xcc
INVALID_LETTER, // [205] = 0xcd
INVALID_LETTER, // [206] = 0xce
INVALID_LETTER, // [207] = 0xcf
INVALID_LETTER, // [208] = 0xd0
INVALID_LETTER, // [209] = 0xd1
INVALID_LETTER, // [210] = 0xd2
INVALID_LETTER, // [211] = 0xd3
INVALID_LETTER, // [212] = 0xd4
INVALID_LETTER, // [213] = 0xd5
INVALID_LETTER, // [214] = 0xd6
INVALID_LETTER, // [215] = 0xd7
INVALID_LETTER, // [216] = 0xd8
INVALID_LETTER, // [217] = 0xd9
INVALID_LETTER, // [218] = 0xda
INVALID_LETTER, // [219] = 0xdb
INVALID_LETTER, // [220] = 0xdc
INVALID_LETTER, // [221] = 0xdd
INVALID_LETTER, // [222] = 0xde
INVALID_LETTER, // [223] = 0xdf
INVALID_LETTER, // [224] = 0xe0
INVALID_LETTER, // [225] = 0xe1
INVALID_LETTER, // [226] = 0xe2
INVALID_LETTER, // [227] = 0xe3
INVALID_LETTER, // [228] = 0xe4
INVALID_LETTER, // [229] = 0xe5
INVALID_LETTER, // [230] = 0xe6
INVALID_LETTER, // [231] = 0xe7
INVALID_LETTER, // [232] = 0xe8
INVALID_LETTER, // [233] = 0xe9
INVALID_LETTER, // [234] = 0xea
INVALID_LETTER, // [235] = 0xeb
INVALID_LETTER, // [236] = 0xec
INVALID_LETTER, // [237] = 0xed
INVALID_LETTER, // [238] = 0xee
INVALID_LETTER, // [239] = 0xef
INVALID_LETTER, // [240] = 0xf0
INVALID_LETTER, // [241] = 0xf1
INVALID_LETTER, // [242] = 0xf2
INVALID_LETTER, // [243] = 0xf3
INVALID_LETTER, // [244] = 0xf4
INVALID_LETTER, // [245] = 0xf5
INVALID_LETTER, // [246] = 0xf6
INVALID_LETTER, // [247] = 0xf7
INVALID_LETTER, // [248] = 0xf8
INVALID_LETTER, // [249] = 0xf9
INVALID_LETTER, // [250] = 0xfa
INVALID_LETTER, // [251] = 0xfb
INVALID_LETTER, // [252] = 0xfc
INVALID_LETTER, // [253] = 0xfd
INVALID_LETTER, // [254] = 0xfe
INVALID_LETTER, // [255] = 0xff
};
unsigned char g_CharToLetterNucleoW[256] =
{
0 , // [ 0] = 0x00
0 , // [ 1] = 0x01
0 , // [ 2] = 0x02
0 , // [ 3] = 0x03
0 , // [ 4] = 0x04
0 , // [ 5] = 0x05
0 , // [ 6] = 0x06
0 , // [ 7] = 0x07
0 , // [ 8] = 0x08
0 , // [ 9] = 0x09
0 , // [ 10] = 0x0a
0 , // [ 11] = 0x0b
0 , // [ 12] = 0x0c
0 , // [ 13] = 0x0d
0 , // [ 14] = 0x0e
0 , // [ 15] = 0x0f
0 , // [ 16] = 0x10
0 , // [ 17] = 0x11
0 , // [ 18] = 0x12
0 , // [ 19] = 0x13
0 , // [ 20] = 0x14
0 , // [ 21] = 0x15
0 , // [ 22] = 0x16
0 , // [ 23] = 0x17
0 , // [ 24] = 0x18
0 , // [ 25] = 0x19
0 , // [ 26] = 0x1a
0 , // [ 27] = 0x1b
0 , // [ 28] = 0x1c
0 , // [ 29] = 0x1d
0 , // [ 30] = 0x1e
0 , // [ 31] = 0x1f
0 , // [ 32] = 32
0 , // [ 33] = 33
0 , // [ 34] = 34
0 , // [ 35] = 35
0 , // [ 36] = 36
0 , // [ 37] = 37
0 , // [ 38] = 38
0 , // [ 39] = 39
0 , // [ 40] = 40
0 , // [ 41] = 41
0 , // [ 42] = 42
0 , // [ 43] = 43
0 , // [ 44] = 44
0 , // [ 45] = 45
0 , // [ 46] = 46
0 , // [ 47] = 47
0 , // [ 48] = 48
0 , // [ 49] = 49
0 , // [ 50] = 50
0 , // [ 51] = 51
0 , // [ 52] = 52
0 , // [ 53] = 53
0 , // [ 54] = 54
0 , // [ 55] = 55
0 , // [ 56] = 56
0 , // [ 57] = 57
0 , // [ 58] = 58
0 , // [ 59] = 59
0 , // [ 60] = 60
0 , // [ 61] = 61
0 , // [ 62] = 62
0 , // [ 63] = 63
0 , // [ 64] = 64
0 , // [ 65] = A (Nucleotide)
1 , // [ 66] = B (Wildcard)
1 , // [ 67] = C (Nucleotide)
0 , // [ 68] = D (Wildcard)
0 , // [ 69] = 69
0 , // [ 70] = 70
2 , // [ 71] = G (Nucleotide)
0 , // [ 72] = H (Wildcard)
0 , // [ 73] = 73
0 , // [ 74] = 74
2 , // [ 75] = K (Wildcard)
0 , // [ 76] = 76
0 , // [ 77] = M (Wildcard)
2 , // [ 78] = N (Wildcard)
0 , // [ 79] = 79
0 , // [ 80] = 80
0 , // [ 81] = 81
0 , // [ 82] = R (Wildcard)
1 , // [ 83] = S (Wildcard)
3 , // [ 84] = T (Nucleotide)
3 , // [ 85] = U (Nucleotide)
0 , // [ 86] = V (Wildcard)
0 , // [ 87] = W (Wildcard)
2 , // [ 88] = X (Wildcard)
1 , // [ 89] = Y (Wildcard)
0 , // [ 90] = 90
0 , // [ 91] = 91
0 , // [ 92] = 92
0 , // [ 93] = 93
0 , // [ 94] = 94
0 , // [ 95] = 95
0 , // [ 96] = 96
0 , // [ 97] = a (Nucleotide)
1 , // [ 98] = b (Nucleotide)
1 , // [ 99] = c (Nucleotide)
0 , // [100] = d (Nucleotide)
0 , // [101] = 101
0 , // [102] = 102
2 , // [103] = g (Nucleotide)
0 , // [104] = h (Nucleotide)
0 , // [105] = 105
0 , // [106] = 106
2 , // [107] = k (Nucleotide)
0 , // [108] = 108
0 , // [109] = m (Nucleotide)
2 , // [110] = n (Nucleotide)
0 , // [111] = 111
0 , // [112] = 112
0 , // [113] = 113
0 , // [114] = r (Nucleotide)
1 , // [115] = s (Nucleotide)
3 , // [116] = t (Nucleotide)
3 , // [117] = u (Nucleotide)
0 , // [118] = v (Nucleotide)
0 , // [119] = w (Nucleotide)
2 , // [120] = x (Nucleotide)
1 , // [121] = y (Nucleotide)
0 , // [122] = 122
0 , // [123] = 123
0 , // [124] = 124
0 , // [125] = 125
0 , // [126] = 126
0 , // [127] = 0x7f
0 , // [128] = 0x80
0 , // [129] = 0x81
0 , // [130] = 0x82
0 , // [131] = 0x83
0 , // [132] = 0x84
0 , // [133] = 0x85
0 , // [134] = 0x86
0 , // [135] = 0x87
0 , // [136] = 0x88
0 , // [137] = 0x89
0 , // [138] = 0x8a
0 , // [139] = 0x8b
0 , // [140] = 0x8c
0 , // [141] = 0x8d
0 , // [142] = 0x8e
0 , // [143] = 0x8f
0 , // [144] = 0x90
0 , // [145] = 0x91
0 , // [146] = 0x92
0 , // [147] = 0x93
0 , // [148] = 0x94
0 , // [149] = 0x95
0 , // [150] = 0x96
0 , // [151] = 0x97
0 , // [152] = 0x98
0 , // [153] = 0x99
0 , // [154] = 0x9a
0 , // [155] = 0x9b
0 , // [156] = 0x9c
0 , // [157] = 0x9d
0 , // [158] = 0x9e
0 , // [159] = 0x9f
0 , // [160] = 0xa0
0 , // [161] = 0xa1
0 , // [162] = 0xa2
0 , // [163] = 0xa3
0 , // [164] = 0xa4
0 , // [165] = 0xa5
0 , // [166] = 0xa6
0 , // [167] = 0xa7
0 , // [168] = 0xa8
0 , // [169] = 0xa9
0 , // [170] = 0xaa
0 , // [171] = 0xab
0 , // [172] = 0xac
0 , // [173] = 0xad
0 , // [174] = 0xae
0 , // [175] = 0xaf
0 , // [176] = 0xb0
0 , // [177] = 0xb1
0 , // [178] = 0xb2
0 , // [179] = 0xb3
0 , // [180] = 0xb4
0 , // [181] = 0xb5
0 , // [182] = 0xb6
0 , // [183] = 0xb7
0 , // [184] = 0xb8
0 , // [185] = 0xb9
0 , // [186] = 0xba
0 , // [187] = 0xbb
0 , // [188] = 0xbc
0 , // [189] = 0xbd
0 , // [190] = 0xbe
0 , // [191] = 0xbf
0 , // [192] = 0xc0
0 , // [193] = 0xc1
0 , // [194] = 0xc2
0 , // [195] = 0xc3
0 , // [196] = 0xc4
0 , // [197] = 0xc5
0 , // [198] = 0xc6
0 , // [199] = 0xc7
0 , // [200] = 0xc8
0 , // [201] = 0xc9
0 , // [202] = 0xca
0 , // [203] = 0xcb
0 , // [204] = 0xcc
0 , // [205] = 0xcd
0 , // [206] = 0xce
0 , // [207] = 0xcf
0 , // [208] = 0xd0
0 , // [209] = 0xd1
0 , // [210] = 0xd2
0 , // [211] = 0xd3
0 , // [212] = 0xd4
0 , // [213] = 0xd5
0 , // [214] = 0xd6
0 , // [215] = 0xd7
0 , // [216] = 0xd8
0 , // [217] = 0xd9
0 , // [218] = 0xda
0 , // [219] = 0xdb
0 , // [220] = 0xdc
0 , // [221] = 0xdd
0 , // [222] = 0xde
0 , // [223] = 0xdf
0 , // [224] = 0xe0
0 , // [225] = 0xe1
0 , // [226] = 0xe2
0 , // [227] = 0xe3
0 , // [228] = 0xe4
0 , // [229] = 0xe5
0 , // [230] = 0xe6
0 , // [231] = 0xe7
0 , // [232] = 0xe8
0 , // [233] = 0xe9
0 , // [234] = 0xea
0 , // [235] = 0xeb
0 , // [236] = 0xec
0 , // [237] = 0xed
0 , // [238] = 0xee
0 , // [239] = 0xef
0 , // [240] = 0xf0
0 , // [241] = 0xf1
0 , // [242] = 0xf2
0 , // [243] = 0xf3
0 , // [244] = 0xf4
0 , // [245] = 0xf5
0 , // [246] = 0xf6
0 , // [247] = 0xf7
0 , // [248] = 0xf8
0 , // [249] = 0xf9
0 , // [250] = 0xfa
0 , // [251] = 0xfb
0 , // [252] = 0xfc
0 , // [253] = 0xfd
0 , // [254] = 0xfe
0 , // [255] = 0xff
};
unsigned char g_LetterToCharNucleo[256] =
{
'A', // [0]
'C', // [1]
'G', // [2]
'T', // [3]
INVALID_CHAR, // [4]
INVALID_CHAR, // [5]
INVALID_CHAR, // [6]
INVALID_CHAR, // [7]
INVALID_CHAR, // [8]
INVALID_CHAR, // [9]
INVALID_CHAR, // [10]
INVALID_CHAR, // [11]
INVALID_CHAR, // [12]
INVALID_CHAR, // [13]
INVALID_CHAR, // [14]
INVALID_CHAR, // [15]
INVALID_CHAR, // [16]
INVALID_CHAR, // [17]
INVALID_CHAR, // [18]
INVALID_CHAR, // [19]
INVALID_CHAR, // [20]
INVALID_CHAR, // [21]
INVALID_CHAR, // [22]
INVALID_CHAR, // [23]
INVALID_CHAR, // [24]
INVALID_CHAR, // [25]
INVALID_CHAR, // [26]
INVALID_CHAR, // [27]
INVALID_CHAR, // [28]
INVALID_CHAR, // [29]
INVALID_CHAR, // [30]
INVALID_CHAR, // [31]
INVALID_CHAR, // [32]
INVALID_CHAR, // [33]
INVALID_CHAR, // [34]
INVALID_CHAR, // [35]
INVALID_CHAR, // [36]
INVALID_CHAR, // [37]
INVALID_CHAR, // [38]
INVALID_CHAR, // [39]
INVALID_CHAR, // [40]
INVALID_CHAR, // [41]
INVALID_CHAR, // [42]
INVALID_CHAR, // [43]
INVALID_CHAR, // [44]
INVALID_CHAR, // [45]
INVALID_CHAR, // [46]
INVALID_CHAR, // [47]
INVALID_CHAR, // [48]
INVALID_CHAR, // [49]
INVALID_CHAR, // [50]
INVALID_CHAR, // [51]
INVALID_CHAR, // [52]
INVALID_CHAR, // [53]
INVALID_CHAR, // [54]
INVALID_CHAR, // [55]
INVALID_CHAR, // [56]
INVALID_CHAR, // [57]
INVALID_CHAR, // [58]
INVALID_CHAR, // [59]
INVALID_CHAR, // [60]
INVALID_CHAR, // [61]
INVALID_CHAR, // [62]
INVALID_CHAR, // [63]
INVALID_CHAR, // [64]
INVALID_CHAR, // [65]
INVALID_CHAR, // [66]
INVALID_CHAR, // [67]
INVALID_CHAR, // [68]
INVALID_CHAR, // [69]
INVALID_CHAR, // [70]
INVALID_CHAR, // [71]
INVALID_CHAR, // [72]
INVALID_CHAR, // [73]
INVALID_CHAR, // [74]
INVALID_CHAR, // [75]
INVALID_CHAR, // [76]
INVALID_CHAR, // [77]
INVALID_CHAR, // [78]
INVALID_CHAR, // [79]
INVALID_CHAR, // [80]
INVALID_CHAR, // [81]
INVALID_CHAR, // [82]
INVALID_CHAR, // [83]
INVALID_CHAR, // [84]
INVALID_CHAR, // [85]
INVALID_CHAR, // [86]
INVALID_CHAR, // [87]
INVALID_CHAR, // [88]
INVALID_CHAR, // [89]
INVALID_CHAR, // [90]
INVALID_CHAR, // [91]
INVALID_CHAR, // [92]
INVALID_CHAR, // [93]
INVALID_CHAR, // [94]
INVALID_CHAR, // [95]
INVALID_CHAR, // [96]
INVALID_CHAR, // [97]
INVALID_CHAR, // [98]
INVALID_CHAR, // [99]
INVALID_CHAR, // [100]
INVALID_CHAR, // [101]
INVALID_CHAR, // [102]
INVALID_CHAR, // [103]
INVALID_CHAR, // [104]
INVALID_CHAR, // [105]
INVALID_CHAR, // [106]
INVALID_CHAR, // [107]
INVALID_CHAR, // [108]
INVALID_CHAR, // [109]
INVALID_CHAR, // [110]
INVALID_CHAR, // [111]
INVALID_CHAR, // [112]
INVALID_CHAR, // [113]
INVALID_CHAR, // [114]
INVALID_CHAR, // [115]
INVALID_CHAR, // [116]
INVALID_CHAR, // [117]
INVALID_CHAR, // [118]
INVALID_CHAR, // [119]
INVALID_CHAR, // [120]
INVALID_CHAR, // [121]
INVALID_CHAR, // [122]
INVALID_CHAR, // [123]
INVALID_CHAR, // [124]
INVALID_CHAR, // [125]
INVALID_CHAR, // [126]
INVALID_CHAR, // [127]
INVALID_CHAR, // [128]
INVALID_CHAR, // [129]
INVALID_CHAR, // [130]
INVALID_CHAR, // [131]
INVALID_CHAR, // [132]
INVALID_CHAR, // [133]
INVALID_CHAR, // [134]
INVALID_CHAR, // [135]
INVALID_CHAR, // [136]
INVALID_CHAR, // [137]
INVALID_CHAR, // [138]
INVALID_CHAR, // [139]
INVALID_CHAR, // [140]
INVALID_CHAR, // [141]
INVALID_CHAR, // [142]
INVALID_CHAR, // [143]
INVALID_CHAR, // [144]
INVALID_CHAR, // [145]
INVALID_CHAR, // [146]
INVALID_CHAR, // [147]
INVALID_CHAR, // [148]
INVALID_CHAR, // [149]
INVALID_CHAR, // [150]
INVALID_CHAR, // [151]
INVALID_CHAR, // [152]
INVALID_CHAR, // [153]
INVALID_CHAR, // [154]
INVALID_CHAR, // [155]
INVALID_CHAR, // [156]
INVALID_CHAR, // [157]
INVALID_CHAR, // [158]
INVALID_CHAR, // [159]
INVALID_CHAR, // [160]
INVALID_CHAR, // [161]
INVALID_CHAR, // [162]
INVALID_CHAR, // [163]
INVALID_CHAR, // [164]
INVALID_CHAR, // [165]
INVALID_CHAR, // [166]
INVALID_CHAR, // [167]
INVALID_CHAR, // [168]
INVALID_CHAR, // [169]
INVALID_CHAR, // [170]
INVALID_CHAR, // [171]
INVALID_CHAR, // [172]
INVALID_CHAR, // [173]
INVALID_CHAR, // [174]
INVALID_CHAR, // [175]
INVALID_CHAR, // [176]
INVALID_CHAR, // [177]
INVALID_CHAR, // [178]
INVALID_CHAR, // [179]
INVALID_CHAR, // [180]
INVALID_CHAR, // [181]
INVALID_CHAR, // [182]
INVALID_CHAR, // [183]
INVALID_CHAR, // [184]
INVALID_CHAR, // [185]
INVALID_CHAR, // [186]
INVALID_CHAR, // [187]
INVALID_CHAR, // [188]
INVALID_CHAR, // [189]
INVALID_CHAR, // [190]
INVALID_CHAR, // [191]
INVALID_CHAR, // [192]
INVALID_CHAR, // [193]
INVALID_CHAR, // [194]
INVALID_CHAR, // [195]
INVALID_CHAR, // [196]
INVALID_CHAR, // [197]
INVALID_CHAR, // [198]
INVALID_CHAR, // [199]
INVALID_CHAR, // [200]
INVALID_CHAR, // [201]
INVALID_CHAR, // [202]
INVALID_CHAR, // [203]
INVALID_CHAR, // [204]
INVALID_CHAR, // [205]
INVALID_CHAR, // [206]
INVALID_CHAR, // [207]
INVALID_CHAR, // [208]
INVALID_CHAR, // [209]
INVALID_CHAR, // [210]
INVALID_CHAR, // [211]
INVALID_CHAR, // [212]
INVALID_CHAR, // [213]
INVALID_CHAR, // [214]
INVALID_CHAR, // [215]
INVALID_CHAR, // [216]
INVALID_CHAR, // [217]
INVALID_CHAR, // [218]
INVALID_CHAR, // [219]
INVALID_CHAR, // [220]
INVALID_CHAR, // [221]
INVALID_CHAR, // [222]
INVALID_CHAR, // [223]
INVALID_CHAR, // [224]
INVALID_CHAR, // [225]
INVALID_CHAR, // [226]
INVALID_CHAR, // [227]
INVALID_CHAR, // [228]
INVALID_CHAR, // [229]
INVALID_CHAR, // [230]
INVALID_CHAR, // [231]
INVALID_CHAR, // [232]
INVALID_CHAR, // [233]
INVALID_CHAR, // [234]
INVALID_CHAR, // [235]
INVALID_CHAR, // [236]
INVALID_CHAR, // [237]
INVALID_CHAR, // [238]
INVALID_CHAR, // [239]
INVALID_CHAR, // [240]
INVALID_CHAR, // [241]
INVALID_CHAR, // [242]
INVALID_CHAR, // [243]
INVALID_CHAR, // [244]
INVALID_CHAR, // [245]
INVALID_CHAR, // [246]
INVALID_CHAR, // [247]
INVALID_CHAR, // [248]
INVALID_CHAR, // [249]
INVALID_CHAR, // [250]
INVALID_CHAR, // [251]
INVALID_CHAR, // [252]
INVALID_CHAR, // [253]
INVALID_CHAR, // [254]
INVALID_CHAR, // [255]
};
unsigned char g_LetterToCharNucleoGap[256] =
{
'A', // [0]
'C', // [1]
'G', // [2]
'T', // [3]
'-', // [4]
INVALID_CHAR, // [5]
INVALID_CHAR, // [6]
INVALID_CHAR, // [7]
INVALID_CHAR, // [8]
INVALID_CHAR, // [9]
INVALID_CHAR, // [10]
INVALID_CHAR, // [11]
INVALID_CHAR, // [12]
INVALID_CHAR, // [13]
INVALID_CHAR, // [14]
INVALID_CHAR, // [15]
INVALID_CHAR, // [16]
INVALID_CHAR, // [17]
INVALID_CHAR, // [18]
INVALID_CHAR, // [19]
INVALID_CHAR, // [20]
INVALID_CHAR, // [21]
INVALID_CHAR, // [22]
INVALID_CHAR, // [23]
INVALID_CHAR, // [24]
INVALID_CHAR, // [25]
INVALID_CHAR, // [26]
INVALID_CHAR, // [27]
INVALID_CHAR, // [28]
INVALID_CHAR, // [29]
INVALID_CHAR, // [30]
INVALID_CHAR, // [31]
INVALID_CHAR, // [32]
INVALID_CHAR, // [33]
INVALID_CHAR, // [34]
INVALID_CHAR, // [35]
INVALID_CHAR, // [36]
INVALID_CHAR, // [37]
INVALID_CHAR, // [38]
INVALID_CHAR, // [39]
INVALID_CHAR, // [40]
INVALID_CHAR, // [41]
INVALID_CHAR, // [42]
INVALID_CHAR, // [43]
INVALID_CHAR, // [44]
INVALID_CHAR, // [45]
INVALID_CHAR, // [46]
INVALID_CHAR, // [47]
INVALID_CHAR, // [48]
INVALID_CHAR, // [49]
INVALID_CHAR, // [50]
INVALID_CHAR, // [51]
INVALID_CHAR, // [52]
INVALID_CHAR, // [53]
INVALID_CHAR, // [54]
INVALID_CHAR, // [55]
INVALID_CHAR, // [56]
INVALID_CHAR, // [57]
INVALID_CHAR, // [58]
INVALID_CHAR, // [59]
INVALID_CHAR, // [60]
INVALID_CHAR, // [61]
INVALID_CHAR, // [62]
INVALID_CHAR, // [63]
INVALID_CHAR, // [64]
INVALID_CHAR, // [65]
INVALID_CHAR, // [66]
INVALID_CHAR, // [67]
INVALID_CHAR, // [68]
INVALID_CHAR, // [69]
INVALID_CHAR, // [70]
INVALID_CHAR, // [71]
INVALID_CHAR, // [72]
INVALID_CHAR, // [73]
INVALID_CHAR, // [74]
INVALID_CHAR, // [75]
INVALID_CHAR, // [76]
INVALID_CHAR, // [77]
INVALID_CHAR, // [78]
INVALID_CHAR, // [79]
INVALID_CHAR, // [80]
INVALID_CHAR, // [81]
INVALID_CHAR, // [82]
INVALID_CHAR, // [83]
INVALID_CHAR, // [84]
INVALID_CHAR, // [85]
INVALID_CHAR, // [86]
INVALID_CHAR, // [87]
INVALID_CHAR, // [88]
INVALID_CHAR, // [89]
INVALID_CHAR, // [90]
INVALID_CHAR, // [91]
INVALID_CHAR, // [92]
INVALID_CHAR, // [93]
INVALID_CHAR, // [94]
INVALID_CHAR, // [95]
INVALID_CHAR, // [96]
INVALID_CHAR, // [97]
INVALID_CHAR, // [98]
INVALID_CHAR, // [99]
INVALID_CHAR, // [100]
INVALID_CHAR, // [101]
INVALID_CHAR, // [102]
INVALID_CHAR, // [103]
INVALID_CHAR, // [104]
INVALID_CHAR, // [105]
INVALID_CHAR, // [106]
INVALID_CHAR, // [107]
INVALID_CHAR, // [108]
INVALID_CHAR, // [109]
INVALID_CHAR, // [110]
INVALID_CHAR, // [111]
INVALID_CHAR, // [112]
INVALID_CHAR, // [113]
INVALID_CHAR, // [114]
INVALID_CHAR, // [115]
INVALID_CHAR, // [116]
INVALID_CHAR, // [117]
INVALID_CHAR, // [118]
INVALID_CHAR, // [119]
INVALID_CHAR, // [120]
INVALID_CHAR, // [121]
INVALID_CHAR, // [122]
INVALID_CHAR, // [123]
INVALID_CHAR, // [124]
INVALID_CHAR, // [125]
INVALID_CHAR, // [126]
INVALID_CHAR, // [127]
INVALID_CHAR, // [128]
INVALID_CHAR, // [129]
INVALID_CHAR, // [130]
INVALID_CHAR, // [131]
INVALID_CHAR, // [132]
INVALID_CHAR, // [133]
INVALID_CHAR, // [134]
INVALID_CHAR, // [135]
INVALID_CHAR, // [136]
INVALID_CHAR, // [137]
INVALID_CHAR, // [138]
INVALID_CHAR, // [139]
INVALID_CHAR, // [140]
INVALID_CHAR, // [141]
INVALID_CHAR, // [142]
INVALID_CHAR, // [143]
INVALID_CHAR, // [144]
INVALID_CHAR, // [145]
INVALID_CHAR, // [146]
INVALID_CHAR, // [147]
INVALID_CHAR, // [148]
INVALID_CHAR, // [149]
INVALID_CHAR, // [150]
INVALID_CHAR, // [151]
INVALID_CHAR, // [152]
INVALID_CHAR, // [153]
INVALID_CHAR, // [154]
INVALID_CHAR, // [155]
INVALID_CHAR, // [156]
INVALID_CHAR, // [157]
INVALID_CHAR, // [158]
INVALID_CHAR, // [159]
INVALID_CHAR, // [160]
INVALID_CHAR, // [161]
INVALID_CHAR, // [162]
INVALID_CHAR, // [163]
INVALID_CHAR, // [164]
INVALID_CHAR, // [165]
INVALID_CHAR, // [166]
INVALID_CHAR, // [167]
INVALID_CHAR, // [168]
INVALID_CHAR, // [169]
INVALID_CHAR, // [170]
INVALID_CHAR, // [171]
INVALID_CHAR, // [172]
INVALID_CHAR, // [173]
INVALID_CHAR, // [174]
INVALID_CHAR, // [175]
INVALID_CHAR, // [176]
INVALID_CHAR, // [177]
INVALID_CHAR, // [178]
INVALID_CHAR, // [179]
INVALID_CHAR, // [180]
INVALID_CHAR, // [181]
INVALID_CHAR, // [182]
INVALID_CHAR, // [183]
INVALID_CHAR, // [184]
INVALID_CHAR, // [185]
INVALID_CHAR, // [186]
INVALID_CHAR, // [187]
INVALID_CHAR, // [188]
INVALID_CHAR, // [189]
INVALID_CHAR, // [190]
INVALID_CHAR, // [191]
INVALID_CHAR, // [192]
INVALID_CHAR, // [193]
INVALID_CHAR, // [194]
INVALID_CHAR, // [195]
INVALID_CHAR, // [196]
INVALID_CHAR, // [197]
INVALID_CHAR, // [198]
INVALID_CHAR, // [199]
INVALID_CHAR, // [200]
INVALID_CHAR, // [201]
INVALID_CHAR, // [202]
INVALID_CHAR, // [203]
INVALID_CHAR, // [204]
INVALID_CHAR, // [205]
INVALID_CHAR, // [206]
INVALID_CHAR, // [207]
INVALID_CHAR, // [208]
INVALID_CHAR, // [209]
INVALID_CHAR, // [210]
INVALID_CHAR, // [211]
INVALID_CHAR, // [212]
INVALID_CHAR, // [213]
INVALID_CHAR, // [214]
INVALID_CHAR, // [215]
INVALID_CHAR, // [216]
INVALID_CHAR, // [217]
INVALID_CHAR, // [218]
INVALID_CHAR, // [219]
INVALID_CHAR, // [220]
INVALID_CHAR, // [221]
INVALID_CHAR, // [222]
INVALID_CHAR, // [223]
INVALID_CHAR, // [224]
INVALID_CHAR, // [225]
INVALID_CHAR, // [226]
INVALID_CHAR, // [227]
INVALID_CHAR, // [228]
INVALID_CHAR, // [229]
INVALID_CHAR, // [230]
INVALID_CHAR, // [231]
INVALID_CHAR, // [232]
INVALID_CHAR, // [233]
INVALID_CHAR, // [234]
INVALID_CHAR, // [235]
INVALID_CHAR, // [236]
INVALID_CHAR, // [237]
INVALID_CHAR, // [238]
INVALID_CHAR, // [239]
INVALID_CHAR, // [240]
INVALID_CHAR, // [241]
INVALID_CHAR, // [242]
INVALID_CHAR, // [243]
INVALID_CHAR, // [244]
INVALID_CHAR, // [245]
INVALID_CHAR, // [246]
INVALID_CHAR, // [247]
INVALID_CHAR, // [248]
INVALID_CHAR, // [249]
INVALID_CHAR, // [250]
INVALID_CHAR, // [251]
INVALID_CHAR, // [252]
INVALID_CHAR, // [253]
INVALID_CHAR, // [254]
INVALID_CHAR, // [255]
};
unsigned char g_CodonWordToAminoLetter[4*4*4] =
{
8 , // [ 0] = AAA K (Lys)
11, // [ 1] = AAC N (Asn)
8 , // [ 2] = AAG K (Lys)
11, // [ 3] = AAT N (Asn)
16, // [ 4] = ACA T (Thr)
16, // [ 5] = ACC T (Thr)
16, // [ 6] = ACG T (Thr)
16, // [ 7] = ACT T (Thr)
14, // [ 8] = AGA R (Arg)
15, // [ 9] = AGC S (Ser)
14, // [10] = AGG R (Arg)
15, // [11] = AGT S (Ser)
7 , // [12] = ATA I (Ile)
7 , // [13] = ATC I (Ile)
10, // [14] = ATG M (Met)
7 , // [15] = ATT I (Ile)
13, // [16] = CAA Q (Gln)
6 , // [17] = CAC H (His)
13, // [18] = CAG Q (Gln)
6 , // [19] = CAT H (His)
12, // [20] = CCA P (Pro)
12, // [21] = CCC P (Pro)
12, // [22] = CCG P (Pro)
12, // [23] = CCT P (Pro)
14, // [24] = CGA R (Arg)
14, // [25] = CGC R (Arg)
14, // [26] = CGG R (Arg)
14, // [27] = CGT R (Arg)
9 , // [28] = CTA L (Leu)
9 , // [29] = CTC L (Leu)
9 , // [30] = CTG L (Leu)
9 , // [31] = CTT L (Leu)
3 , // [32] = GAA E (Glu)
2 , // [33] = GAC D (Asp)
3 , // [34] = GAG E (Glu)
2 , // [35] = GAT D (Asp)
0 , // [36] = GCA A (Ala)
0 , // [37] = GCC A (Ala)
0 , // [38] = GCG A (Ala)
0 , // [39] = GCT A (Ala)
5 , // [40] = GGA G (Gly)
5 , // [41] = GGC G (Gly)
5 , // [42] = GGG G (Gly)
5 , // [43] = GGT G (Gly)
17, // [44] = GTA V (Val)
17, // [45] = GTC V (Val)
17, // [46] = GTG V (Val)
17, // [47] = GTT V (Val)
20, // [48] = TAA * (STP)
19, // [49] = TAC Y (Tyr)
20, // [50] = TAG * (STP)
19, // [51] = TAT Y (Tyr)
15, // [52] = TCA S (Ser)
15, // [53] = TCC S (Ser)
15, // [54] = TCG S (Ser)
15, // [55] = TCT S (Ser)
20, // [56] = TGA * (STP)
1 , // [57] = TGC C (Cys)
18, // [58] = TGG W (Trp)
1 , // [59] = TGT C (Cys)
9 , // [60] = TTA L (Leu)
4 , // [61] = TTC F (Phe)
9 , // [62] = TTG L (Leu)
4 , // [63] = TTT F (Phe)
};
unsigned char g_CodonWordToAminoChar[4*4*4] =
{
'K', // [ 0] = AAA (Lys)
'N', // [ 1] = AAC (Asn)
'K', // [ 2] = AAG (Lys)
'N', // [ 3] = AAT (Asn)
'T', // [ 4] = ACA (Thr)
'T', // [ 5] = ACC (Thr)
'T', // [ 6] = ACG (Thr)
'T', // [ 7] = ACT (Thr)
'R', // [ 8] = AGA (Arg)
'S', // [ 9] = AGC (Ser)
'R', // [10] = AGG (Arg)
'S', // [11] = AGT (Ser)
'I', // [12] = ATA (Ile)
'I', // [13] = ATC (Ile)
'M', // [14] = ATG (Met)
'I', // [15] = ATT (Ile)
'Q', // [16] = CAA (Gln)
'H', // [17] = CAC (His)
'Q', // [18] = CAG (Gln)
'H', // [19] = CAT (His)
'P', // [20] = CCA (Pro)
'P', // [21] = CCC (Pro)
'P', // [22] = CCG (Pro)
'P', // [23] = CCT (Pro)
'R', // [24] = CGA (Arg)
'R', // [25] = CGC (Arg)
'R', // [26] = CGG (Arg)
'R', // [27] = CGT (Arg)
'L', // [28] = CTA (Leu)
'L', // [29] = CTC (Leu)
'L', // [30] = CTG (Leu)
'L', // [31] = CTT (Leu)
'E', // [32] = GAA (Glu)
'D', // [33] = GAC (Asp)
'E', // [34] = GAG (Glu)
'D', // [35] = GAT (Asp)
'A', // [36] = GCA (Ala)
'A', // [37] = GCC (Ala)
'A', // [38] = GCG (Ala)
'A', // [39] = GCT (Ala)
'G', // [40] = GGA (Gly)
'G', // [41] = GGC (Gly)
'G', // [42] = GGG (Gly)
'G', // [43] = GGT (Gly)
'V', // [44] = GTA (Val)
'V', // [45] = GTC (Val)
'V', // [46] = GTG (Val)
'V', // [47] = GTT (Val)
'*', // [48] = TAA (STP)
'Y', // [49] = TAC (Tyr)
'*', // [50] = TAG (STP)
'Y', // [51] = TAT (Tyr)
'S', // [52] = TCA (Ser)
'S', // [53] = TCC (Ser)
'S', // [54] = TCG (Ser)
'S', // [55] = TCT (Ser)
'*', // [56] = TGA (STP)
'C', // [57] = TGC (Cys)
'W', // [58] = TGG (Trp)
'C', // [59] = TGT (Cys)
'L', // [60] = TTA (Leu)
'F', // [61] = TTC (Phe)
'L', // [62] = TTG (Leu)
'F', // [63] = TTT (Phe)
};
unsigned char g_CharToCompChar[256] =
{
'?', // [ 0] 0x00 invalid nt
'?', // [ 1] 0x01 invalid nt
'?', // [ 2] 0x02 invalid nt
'?', // [ 3] 0x03 invalid nt
'?', // [ 4] 0x04 invalid nt
'?', // [ 5] 0x05 invalid nt
'?', // [ 6] 0x06 invalid nt
'?', // [ 7] 0x07 invalid nt
'?', // [ 8] 0x08 invalid nt
'?', // [ 9] 0x09 invalid nt
'?', // [ 10] 0x0a invalid nt
'?', // [ 11] 0x0b invalid nt
'?', // [ 12] 0x0c invalid nt
'?', // [ 13] 0x0d invalid nt
'?', // [ 14] 0x0e invalid nt
'?', // [ 15] 0x0f invalid nt
'?', // [ 16] 0x10 invalid nt
'?', // [ 17] 0x11 invalid nt
'?', // [ 18] 0x12 invalid nt
'?', // [ 19] 0x13 invalid nt
'?', // [ 20] 0x14 invalid nt
'?', // [ 21] 0x15 invalid nt
'?', // [ 22] 0x16 invalid nt
'?', // [ 23] 0x17 invalid nt
'?', // [ 24] 0x18 invalid nt
'?', // [ 25] 0x19 invalid nt
'?', // [ 26] 0x1a invalid nt
'?', // [ 27] 0x1b invalid nt
'?', // [ 28] 0x1c invalid nt
'?', // [ 29] 0x1d invalid nt
'?', // [ 30] 0x1e invalid nt
'?', // [ 31] 0x1f invalid nt
'?', // [ 32] 0x20 invalid nt
'?', // [ 33] 0x21 invalid nt
'?', // [ 34] 0x22 invalid nt
'?', // [ 35] 0x23 invalid nt
'?', // [ 36] 0x24 invalid nt
'?', // [ 37] 0x25 invalid nt
'?', // [ 38] 0x26 invalid nt
'?', // [ 39] 0x27 invalid nt
'?', // [ 40] 0x28 invalid nt
'?', // [ 41] 0x29 invalid nt
'?', // [ 42] 0x2a invalid nt
'?', // [ 43] 0x2b invalid nt
'?', // [ 44] 0x2c invalid nt
'?', // [ 45] 0x2d invalid nt
'?', // [ 46] 0x2e invalid nt
'?', // [ 47] 0x2f invalid nt
'?', // [ 48] 0x30 invalid nt
'?', // [ 49] 0x31 invalid nt
'?', // [ 50] 0x32 invalid nt
'?', // [ 51] 0x33 invalid nt
'?', // [ 52] 0x34 invalid nt
'?', // [ 53] 0x35 invalid nt
'?', // [ 54] 0x36 invalid nt
'?', // [ 55] 0x37 invalid nt
'?', // [ 56] 0x38 invalid nt
'?', // [ 57] 0x39 invalid nt
'?', // [ 58] 0x3a invalid nt
'?', // [ 59] 0x3b invalid nt
'?', // [ 60] 0x3c invalid nt
'?', // [ 61] 0x3d invalid nt
'?', // [ 62] 0x3e invalid nt
'?', // [ 63] 0x3f invalid nt
'?', // [ 64] 0x40 invalid nt
'T', // [ 65] A -> T
'V', // [ 66] B -> V
'G', // [ 67] C -> G
'H', // [ 68] D -> H
'?', // [ 69] E invalid nt
'?', // [ 70] F invalid nt
'C', // [ 71] G -> C
'D', // [ 72] H -> D
'?', // [ 73] I invalid nt
'?', // [ 74] J invalid nt
'M', // [ 75] K -> M
'?', // [ 76] L invalid nt
'K', // [ 77] M -> K
'N', // [ 78] N -> N
'?', // [ 79] O invalid nt
'?', // [ 80] P invalid nt
'?', // [ 81] Q invalid nt
'Y', // [ 82] R -> Y
'S', // [ 83] S -> S
'A', // [ 84] T -> A
'A', // [ 85] U -> A
'B', // [ 86] V -> B
'W', // [ 87] W -> W
'X', // [ 88] X -> X
'R', // [ 89] Y -> R
'?', // [ 90] Z invalid nt
'?', // [ 91] 0x5b invalid nt
'?', // [ 92] 0x5c invalid nt
'?', // [ 93] 0x5d invalid nt
'?', // [ 94] 0x5e invalid nt
'?', // [ 95] 0x5f invalid nt
'?', // [ 96] 0x60 invalid nt
't', // [ 97] a -> t
'v', // [ 98] b -> v
'g', // [ 99] c -> g
'h', // [100] d -> h
'?', // [101] e invalid nt
'?', // [102] f invalid nt
'c', // [103] g -> c
'd', // [104] h -> d
'?', // [105] i invalid nt
'?', // [106] j invalid nt
'm', // [107] k -> m
'?', // [108] l invalid nt
'k', // [109] m -> k
'n', // [110] n -> n
'?', // [111] o invalid nt
'?', // [112] p invalid nt
'?', // [113] q invalid nt
'y', // [114] r -> y
's', // [115] s -> s
'a', // [116] t -> a
'?', // [117] u invalid nt
'b', // [118] v -> b
'w', // [119] w -> w
'x', // [120] x -> x
'r', // [121] y -> r
'?', // [122] z invalid nt
'?', // [123] 0x7b invalid nt
'?', // [124] 0x7c invalid nt
'?', // [125] 0x7d invalid nt
'?', // [126] 0x7e invalid nt
'?', // [127] 0x7f invalid nt
'?', // [128] 0x80 invalid nt
'?', // [129] 0x81 invalid nt
'?', // [130] 0x82 invalid nt
'?', // [131] 0x83 invalid nt
'?', // [132] 0x84 invalid nt
'?', // [133] 0x85 invalid nt
'?', // [134] 0x86 invalid nt
'?', // [135] 0x87 invalid nt
'?', // [136] 0x88 invalid nt
'?', // [137] 0x89 invalid nt
'?', // [138] 0x8a invalid nt
'?', // [139] 0x8b invalid nt
'?', // [140] 0x8c invalid nt
'?', // [141] 0x8d invalid nt
'?', // [142] 0x8e invalid nt
'?', // [143] 0x8f invalid nt
'?', // [144] 0x90 invalid nt
'?', // [145] 0x91 invalid nt
'?', // [146] 0x92 invalid nt
'?', // [147] 0x93 invalid nt
'?', // [148] 0x94 invalid nt
'?', // [149] 0x95 invalid nt
'?', // [150] 0x96 invalid nt
'?', // [151] 0x97 invalid nt
'?', // [152] 0x98 invalid nt
'?', // [153] 0x99 invalid nt
'?', // [154] 0x9a invalid nt
'?', // [155] 0x9b invalid nt
'?', // [156] 0x9c invalid nt
'?', // [157] 0x9d invalid nt
'?', // [158] 0x9e invalid nt
'?', // [159] 0x9f invalid nt
'?', // [160] 0xa0 invalid nt
'?', // [161] 0xa1 invalid nt
'?', // [162] 0xa2 invalid nt
'?', // [163] 0xa3 invalid nt
'?', // [164] 0xa4 invalid nt
'?', // [165] 0xa5 invalid nt
'?', // [166] 0xa6 invalid nt
'?', // [167] 0xa7 invalid nt
'?', // [168] 0xa8 invalid nt
'?', // [169] 0xa9 invalid nt
'?', // [170] 0xaa invalid nt
'?', // [171] 0xab invalid nt
'?', // [172] 0xac invalid nt
'?', // [173] 0xad invalid nt
'?', // [174] 0xae invalid nt
'?', // [175] 0xaf invalid nt
'?', // [176] 0xb0 invalid nt
'?', // [177] 0xb1 invalid nt
'?', // [178] 0xb2 invalid nt
'?', // [179] 0xb3 invalid nt
'?', // [180] 0xb4 invalid nt
'?', // [181] 0xb5 invalid nt
'?', // [182] 0xb6 invalid nt
'?', // [183] 0xb7 invalid nt
'?', // [184] 0xb8 invalid nt
'?', // [185] 0xb9 invalid nt
'?', // [186] 0xba invalid nt
'?', // [187] 0xbb invalid nt
'?', // [188] 0xbc invalid nt
'?', // [189] 0xbd invalid nt
'?', // [190] 0xbe invalid nt
'?', // [191] 0xbf invalid nt
'?', // [192] 0xc0 invalid nt
'?', // [193] 0xc1 invalid nt
'?', // [194] 0xc2 invalid nt
'?', // [195] 0xc3 invalid nt
'?', // [196] 0xc4 invalid nt
'?', // [197] 0xc5 invalid nt
'?', // [198] 0xc6 invalid nt
'?', // [199] 0xc7 invalid nt
'?', // [200] 0xc8 invalid nt
'?', // [201] 0xc9 invalid nt
'?', // [202] 0xca invalid nt
'?', // [203] 0xcb invalid nt
'?', // [204] 0xcc invalid nt
'?', // [205] 0xcd invalid nt
'?', // [206] 0xce invalid nt
'?', // [207] 0xcf invalid nt
'?', // [208] 0xd0 invalid nt
'?', // [209] 0xd1 invalid nt
'?', // [210] 0xd2 invalid nt
'?', // [211] 0xd3 invalid nt
'?', // [212] 0xd4 invalid nt
'?', // [213] 0xd5 invalid nt
'?', // [214] 0xd6 invalid nt
'?', // [215] 0xd7 invalid nt
'?', // [216] 0xd8 invalid nt
'?', // [217] 0xd9 invalid nt
'?', // [218] 0xda invalid nt
'?', // [219] 0xdb invalid nt
'?', // [220] 0xdc invalid nt
'?', // [221] 0xdd invalid nt
'?', // [222] 0xde invalid nt
'?', // [223] 0xdf invalid nt
'?', // [224] 0xe0 invalid nt
'?', // [225] 0xe1 invalid nt
'?', // [226] 0xe2 invalid nt
'?', // [227] 0xe3 invalid nt
'?', // [228] 0xe4 invalid nt
'?', // [229] 0xe5 invalid nt
'?', // [230] 0xe6 invalid nt
'?', // [231] 0xe7 invalid nt
'?', // [232] 0xe8 invalid nt
'?', // [233] 0xe9 invalid nt
'?', // [234] 0xea invalid nt
'?', // [235] 0xeb invalid nt
'?', // [236] 0xec invalid nt
'?', // [237] 0xed invalid nt
'?', // [238] 0xee invalid nt
'?', // [239] 0xef invalid nt
'?', // [240] 0xf0 invalid nt
'?', // [241] 0xf1 invalid nt
'?', // [242] 0xf2 invalid nt
'?', // [243] 0xf3 invalid nt
'?', // [244] 0xf4 invalid nt
'?', // [245] 0xf5 invalid nt
'?', // [246] 0xf6 invalid nt
'?', // [247] 0xf7 invalid nt
'?', // [248] 0xf8 invalid nt
'?', // [249] 0xf9 invalid nt
'?', // [250] 0xfa invalid nt
'?', // [251] 0xfb invalid nt
'?', // [252] 0xfc invalid nt
'?', // [253] 0xfd invalid nt
'?', // [254] 0xfe invalid nt
'?', // [255] 0xff invalid nt
};
unsigned char g_LetterToCompLetter[256] =
{
3, // 0(A) -> 3(T)
2, // 1(C) -> 2(G)
1, // 2(G) -> 1(C)
0, // 3(T) -> 0(A)
INVALID_LETTER, // [ 4]
INVALID_LETTER, // [ 5]
INVALID_LETTER, // [ 6]
INVALID_LETTER, // [ 7]
INVALID_LETTER, // [ 8]
INVALID_LETTER, // [ 9]
INVALID_LETTER, // [ 10]
INVALID_LETTER, // [ 11]
INVALID_LETTER, // [ 12]
INVALID_LETTER, // [ 13]
INVALID_LETTER, // [ 14]
INVALID_LETTER, // [ 15]
INVALID_LETTER, // [ 16]
INVALID_LETTER, // [ 17]
INVALID_LETTER, // [ 18]
INVALID_LETTER, // [ 19]
INVALID_LETTER, // [ 20]
INVALID_LETTER, // [ 21]
INVALID_LETTER, // [ 22]
INVALID_LETTER, // [ 23]
INVALID_LETTER, // [ 24]
INVALID_LETTER, // [ 25]
INVALID_LETTER, // [ 26]
INVALID_LETTER, // [ 27]
INVALID_LETTER, // [ 28]
INVALID_LETTER, // [ 29]
INVALID_LETTER, // [ 30]
INVALID_LETTER, // [ 31]
INVALID_LETTER, // [ 32]
INVALID_LETTER, // [ 33]
INVALID_LETTER, // [ 34]
INVALID_LETTER, // [ 35]
INVALID_LETTER, // [ 36]
INVALID_LETTER, // [ 37]
INVALID_LETTER, // [ 38]
INVALID_LETTER, // [ 39]
INVALID_LETTER, // [ 40]
INVALID_LETTER, // [ 41]
INVALID_LETTER, // [ 42]
INVALID_LETTER, // [ 43]
INVALID_LETTER, // [ 44]
INVALID_LETTER, // [ 45]
INVALID_LETTER, // [ 46]
INVALID_LETTER, // [ 47]
INVALID_LETTER, // [ 48]
INVALID_LETTER, // [ 49]
INVALID_LETTER, // [ 50]
INVALID_LETTER, // [ 51]
INVALID_LETTER, // [ 52]
INVALID_LETTER, // [ 53]
INVALID_LETTER, // [ 54]
INVALID_LETTER, // [ 55]
INVALID_LETTER, // [ 56]
INVALID_LETTER, // [ 57]
INVALID_LETTER, // [ 58]
INVALID_LETTER, // [ 59]
INVALID_LETTER, // [ 60]
INVALID_LETTER, // [ 61]
INVALID_LETTER, // [ 62]
INVALID_LETTER, // [ 63]
INVALID_LETTER, // [ 64]
INVALID_LETTER, // [ 65]
INVALID_LETTER, // [ 66]
INVALID_LETTER, // [ 67]
INVALID_LETTER, // [ 68]
INVALID_LETTER, // [ 69]
INVALID_LETTER, // [ 70]
INVALID_LETTER, // [ 71]
INVALID_LETTER, // [ 72]
INVALID_LETTER, // [ 73]
INVALID_LETTER, // [ 74]
INVALID_LETTER, // [ 75]
INVALID_LETTER, // [ 76]
INVALID_LETTER, // [ 77]
INVALID_LETTER, // [ 78]
INVALID_LETTER, // [ 79]
INVALID_LETTER, // [ 80]
INVALID_LETTER, // [ 81]
INVALID_LETTER, // [ 82]
INVALID_LETTER, // [ 83]
INVALID_LETTER, // [ 84]
INVALID_LETTER, // [ 85]
INVALID_LETTER, // [ 86]
INVALID_LETTER, // [ 87]
INVALID_LETTER, // [ 88]
INVALID_LETTER, // [ 89]
INVALID_LETTER, // [ 90]
INVALID_LETTER, // [ 91]
INVALID_LETTER, // [ 92]
INVALID_LETTER, // [ 93]
INVALID_LETTER, // [ 94]
INVALID_LETTER, // [ 95]
INVALID_LETTER, // [ 96]
INVALID_LETTER, // [ 97]
INVALID_LETTER, // [ 98]
INVALID_LETTER, // [ 99]
INVALID_LETTER, // [100]
INVALID_LETTER, // [101]
INVALID_LETTER, // [102]
INVALID_LETTER, // [103]
INVALID_LETTER, // [104]
INVALID_LETTER, // [105]
INVALID_LETTER, // [106]
INVALID_LETTER, // [107]
INVALID_LETTER, // [108]
INVALID_LETTER, // [109]
INVALID_LETTER, // [110]
INVALID_LETTER, // [111]
INVALID_LETTER, // [112]
INVALID_LETTER, // [113]
INVALID_LETTER, // [114]
INVALID_LETTER, // [115]
INVALID_LETTER, // [116]
INVALID_LETTER, // [117]
INVALID_LETTER, // [118]
INVALID_LETTER, // [119]
INVALID_LETTER, // [120]
INVALID_LETTER, // [121]
INVALID_LETTER, // [122]
INVALID_LETTER, // [123]
INVALID_LETTER, // [124]
INVALID_LETTER, // [125]
INVALID_LETTER, // [126]
INVALID_LETTER, // [127]
INVALID_LETTER, // [128]
INVALID_LETTER, // [129]
INVALID_LETTER, // [130]
INVALID_LETTER, // [131]
INVALID_LETTER, // [132]
INVALID_LETTER, // [133]
INVALID_LETTER, // [134]
INVALID_LETTER, // [135]
INVALID_LETTER, // [136]
INVALID_LETTER, // [137]
INVALID_LETTER, // [138]
INVALID_LETTER, // [139]
INVALID_LETTER, // [140]
INVALID_LETTER, // [141]
INVALID_LETTER, // [142]
INVALID_LETTER, // [143]
INVALID_LETTER, // [144]
INVALID_LETTER, // [145]
INVALID_LETTER, // [146]
INVALID_LETTER, // [147]
INVALID_LETTER, // [148]
INVALID_LETTER, // [149]
INVALID_LETTER, // [150]
INVALID_LETTER, // [151]
INVALID_LETTER, // [152]
INVALID_LETTER, // [153]
INVALID_LETTER, // [154]
INVALID_LETTER, // [155]
INVALID_LETTER, // [156]
INVALID_LETTER, // [157]
INVALID_LETTER, // [158]
INVALID_LETTER, // [159]
INVALID_LETTER, // [160]
INVALID_LETTER, // [161]
INVALID_LETTER, // [162]
INVALID_LETTER, // [163]
INVALID_LETTER, // [164]
INVALID_LETTER, // [165]
INVALID_LETTER, // [166]
INVALID_LETTER, // [167]
INVALID_LETTER, // [168]
INVALID_LETTER, // [169]
INVALID_LETTER, // [170]
INVALID_LETTER, // [171]
INVALID_LETTER, // [172]
INVALID_LETTER, // [173]
INVALID_LETTER, // [174]
INVALID_LETTER, // [175]
INVALID_LETTER, // [176]
INVALID_LETTER, // [177]
INVALID_LETTER, // [178]
INVALID_LETTER, // [179]
INVALID_LETTER, // [180]
INVALID_LETTER, // [181]
INVALID_LETTER, // [182]
INVALID_LETTER, // [183]
INVALID_LETTER, // [184]
INVALID_LETTER, // [185]
INVALID_LETTER, // [186]
INVALID_LETTER, // [187]
INVALID_LETTER, // [188]
INVALID_LETTER, // [189]
INVALID_LETTER, // [190]
INVALID_LETTER, // [191]
INVALID_LETTER, // [192]
INVALID_LETTER, // [193]
INVALID_LETTER, // [194]
INVALID_LETTER, // [195]
INVALID_LETTER, // [196]
INVALID_LETTER, // [197]
INVALID_LETTER, // [198]
INVALID_LETTER, // [199]
INVALID_LETTER, // [200]
INVALID_LETTER, // [201]
INVALID_LETTER, // [202]
INVALID_LETTER, // [203]
INVALID_LETTER, // [204]
INVALID_LETTER, // [205]
INVALID_LETTER, // [206]
INVALID_LETTER, // [207]
INVALID_LETTER, // [208]
INVALID_LETTER, // [209]
INVALID_LETTER, // [210]
INVALID_LETTER, // [211]
INVALID_LETTER, // [212]
INVALID_LETTER, // [213]
INVALID_LETTER, // [214]
INVALID_LETTER, // [215]
INVALID_LETTER, // [216]
INVALID_LETTER, // [217]
INVALID_LETTER, // [218]
INVALID_LETTER, // [219]
INVALID_LETTER, // [220]
INVALID_LETTER, // [221]
INVALID_LETTER, // [222]
INVALID_LETTER, // [223]
INVALID_LETTER, // [224]
INVALID_LETTER, // [225]
INVALID_LETTER, // [226]
INVALID_LETTER, // [227]
INVALID_LETTER, // [228]
INVALID_LETTER, // [229]
INVALID_LETTER, // [230]
INVALID_LETTER, // [231]
INVALID_LETTER, // [232]
INVALID_LETTER, // [233]
INVALID_LETTER, // [234]
INVALID_LETTER, // [235]
INVALID_LETTER, // [236]
INVALID_LETTER, // [237]
INVALID_LETTER, // [238]
INVALID_LETTER, // [239]
INVALID_LETTER, // [240]
INVALID_LETTER, // [241]
INVALID_LETTER, // [242]
INVALID_LETTER, // [243]
INVALID_LETTER, // [244]
INVALID_LETTER, // [245]
INVALID_LETTER, // [246]
INVALID_LETTER, // [247]
INVALID_LETTER, // [248]
INVALID_LETTER, // [249]
INVALID_LETTER, // [250]
INVALID_LETTER, // [251]
INVALID_LETTER, // [252]
INVALID_LETTER, // [253]
INVALID_LETTER, // [254]
INVALID_LETTER, // [255]
};
unsigned char g_CharToCompLetter[256] =
{
INVALID_LETTER, // [ 0]
INVALID_LETTER, // [ 1]
INVALID_LETTER, // [ 2]
INVALID_LETTER, // [ 3]
INVALID_LETTER, // [ 4]
INVALID_LETTER, // [ 5]
INVALID_LETTER, // [ 6]
INVALID_LETTER, // [ 7]
INVALID_LETTER, // [ 8]
INVALID_LETTER, // [ 9]
INVALID_LETTER, // [ 10]
INVALID_LETTER, // [ 11]
INVALID_LETTER, // [ 12]
INVALID_LETTER, // [ 13]
INVALID_LETTER, // [ 14]
INVALID_LETTER, // [ 15]
INVALID_LETTER, // [ 16]
INVALID_LETTER, // [ 17]
INVALID_LETTER, // [ 18]
INVALID_LETTER, // [ 19]
INVALID_LETTER, // [ 20]
INVALID_LETTER, // [ 21]
INVALID_LETTER, // [ 22]
INVALID_LETTER, // [ 23]
INVALID_LETTER, // [ 24]
INVALID_LETTER, // [ 25]
INVALID_LETTER, // [ 26]
INVALID_LETTER, // [ 27]
INVALID_LETTER, // [ 28]
INVALID_LETTER, // [ 29]
INVALID_LETTER, // [ 30]
INVALID_LETTER, // [ 31]
INVALID_LETTER, // [ 32]
INVALID_LETTER, // [ 33]
INVALID_LETTER, // [ 34]
INVALID_LETTER, // [ 35]
INVALID_LETTER, // [ 36]
INVALID_LETTER, // [ 37]
INVALID_LETTER, // [ 38]
INVALID_LETTER, // [ 39]
INVALID_LETTER, // [ 40]
INVALID_LETTER, // [ 41]
INVALID_LETTER, // [ 42]
INVALID_LETTER, // [ 43]
INVALID_LETTER, // [ 44]
INVALID_LETTER, // [ 45]
INVALID_LETTER, // [ 46]
INVALID_LETTER, // [ 47]
INVALID_LETTER, // [ 48]
INVALID_LETTER, // [ 49]
INVALID_LETTER, // [ 50]
INVALID_LETTER, // [ 51]
INVALID_LETTER, // [ 52]
INVALID_LETTER, // [ 53]
INVALID_LETTER, // [ 54]
INVALID_LETTER, // [ 55]
INVALID_LETTER, // [ 56]
INVALID_LETTER, // [ 57]
INVALID_LETTER, // [ 58]
INVALID_LETTER, // [ 59]
INVALID_LETTER, // [ 60]
INVALID_LETTER, // [ 61]
INVALID_LETTER, // [ 62]
INVALID_LETTER, // [ 63]
INVALID_LETTER, // [ 64]
3, // [ 65] A -> T
INVALID_LETTER, // [ 66] B -> V
2, // [ 67] C -> G
INVALID_LETTER, // [ 68] D -> H
INVALID_LETTER, // [ 69]
INVALID_LETTER, // [ 70]
1, // [ 71] G -> C
INVALID_LETTER, // [ 72] H -> D
INVALID_LETTER, // [ 73]
INVALID_LETTER, // [ 74]
INVALID_LETTER, // [ 75] K -> M
INVALID_LETTER, // [ 76]
INVALID_LETTER, // [ 77] M -> K
INVALID_LETTER, // [ 78] N -> N
INVALID_LETTER, // [ 79]
INVALID_LETTER, // [ 80]
INVALID_LETTER, // [ 81]
INVALID_LETTER, // [ 82] R -> Y
INVALID_LETTER, // [ 83] S -> S
0, // [ 84] T -> A
0, // [ 85] U -> A
INVALID_LETTER, // [ 86] V -> B
INVALID_LETTER, // [ 87] W -> W
INVALID_LETTER, // [ 88] X -> X
INVALID_LETTER, // [ 89] Y -> R
INVALID_LETTER, // [ 90]
INVALID_LETTER, // [ 91]
INVALID_LETTER, // [ 92]
INVALID_LETTER, // [ 93]
INVALID_LETTER, // [ 94]
INVALID_LETTER, // [ 95]
INVALID_LETTER, // [ 96]
3, // [ 97] a -> t
INVALID_LETTER, // [ 98] b -> v
2, // [ 99] c -> g
INVALID_LETTER, // [100] d -> h
INVALID_LETTER, // [101]
INVALID_LETTER, // [102]
1, // [103] g -> c
INVALID_LETTER, // [104] h -> d
INVALID_LETTER, // [105]
INVALID_LETTER, // [106]
INVALID_LETTER, // [107] k -> m
INVALID_LETTER, // [108]
INVALID_LETTER, // [109] m -> k
INVALID_LETTER, // [110] n -> n
INVALID_LETTER, // [111]
INVALID_LETTER, // [112]
INVALID_LETTER, // [113]
INVALID_LETTER, // [114] r -> y
INVALID_LETTER, // [115] s -> s
0, // [116] t -> a
INVALID_LETTER, // [117]
INVALID_LETTER, // [118] v -> b
INVALID_LETTER, // [119] w -> w
INVALID_LETTER, // [120] x -> x
INVALID_LETTER, // [121] y -> r
INVALID_LETTER, // [122]
INVALID_LETTER, // [123]
INVALID_LETTER, // [124]
INVALID_LETTER, // [125]
INVALID_LETTER, // [126]
INVALID_LETTER, // [127]
INVALID_LETTER, // [128]
INVALID_LETTER, // [129]
INVALID_LETTER, // [130]
INVALID_LETTER, // [131]
INVALID_LETTER, // [132]
INVALID_LETTER, // [133]
INVALID_LETTER, // [134]
INVALID_LETTER, // [135]
INVALID_LETTER, // [136]
INVALID_LETTER, // [137]
INVALID_LETTER, // [138]
INVALID_LETTER, // [139]
INVALID_LETTER, // [140]
INVALID_LETTER, // [141]
INVALID_LETTER, // [142]
INVALID_LETTER, // [143]
INVALID_LETTER, // [144]
INVALID_LETTER, // [145]
INVALID_LETTER, // [146]
INVALID_LETTER, // [147]
INVALID_LETTER, // [148]
INVALID_LETTER, // [149]
INVALID_LETTER, // [150]
INVALID_LETTER, // [151]
INVALID_LETTER, // [152]
INVALID_LETTER, // [153]
INVALID_LETTER, // [154]
INVALID_LETTER, // [155]
INVALID_LETTER, // [156]
INVALID_LETTER, // [157]
INVALID_LETTER, // [158]
INVALID_LETTER, // [159]
INVALID_LETTER, // [160]
INVALID_LETTER, // [161]
INVALID_LETTER, // [162]
INVALID_LETTER, // [163]
INVALID_LETTER, // [164]
INVALID_LETTER, // [165]
INVALID_LETTER, // [166]
INVALID_LETTER, // [167]
INVALID_LETTER, // [168]
INVALID_LETTER, // [169]
INVALID_LETTER, // [170]
INVALID_LETTER, // [171]
INVALID_LETTER, // [172]
INVALID_LETTER, // [173]
INVALID_LETTER, // [174]
INVALID_LETTER, // [175]
INVALID_LETTER, // [176]
INVALID_LETTER, // [177]
INVALID_LETTER, // [178]
INVALID_LETTER, // [179]
INVALID_LETTER, // [180]
INVALID_LETTER, // [181]
INVALID_LETTER, // [182]
INVALID_LETTER, // [183]
INVALID_LETTER, // [184]
INVALID_LETTER, // [185]
INVALID_LETTER, // [186]
INVALID_LETTER, // [187]
INVALID_LETTER, // [188]
INVALID_LETTER, // [189]
INVALID_LETTER, // [190]
INVALID_LETTER, // [191]
INVALID_LETTER, // [192]
INVALID_LETTER, // [193]
INVALID_LETTER, // [194]
INVALID_LETTER, // [195]
INVALID_LETTER, // [196]
INVALID_LETTER, // [197]
INVALID_LETTER, // [198]
INVALID_LETTER, // [199]
INVALID_LETTER, // [200]
INVALID_LETTER, // [201]
INVALID_LETTER, // [202]
INVALID_LETTER, // [203]
INVALID_LETTER, // [204]
INVALID_LETTER, // [205]
INVALID_LETTER, // [206]
INVALID_LETTER, // [207]
INVALID_LETTER, // [208]
INVALID_LETTER, // [209]
INVALID_LETTER, // [210]
INVALID_LETTER, // [211]
INVALID_LETTER, // [212]
INVALID_LETTER, // [213]
INVALID_LETTER, // [214]
INVALID_LETTER, // [215]
INVALID_LETTER, // [216]
INVALID_LETTER, // [217]
INVALID_LETTER, // [218]
INVALID_LETTER, // [219]
INVALID_LETTER, // [220]
INVALID_LETTER, // [221]
INVALID_LETTER, // [222]
INVALID_LETTER, // [223]
INVALID_LETTER, // [224]
INVALID_LETTER, // [225]
INVALID_LETTER, // [226]
INVALID_LETTER, // [227]
INVALID_LETTER, // [228]
INVALID_LETTER, // [229]
INVALID_LETTER, // [230]
INVALID_LETTER, // [231]
INVALID_LETTER, // [232]
INVALID_LETTER, // [233]
INVALID_LETTER, // [234]
INVALID_LETTER, // [235]
INVALID_LETTER, // [236]
INVALID_LETTER, // [237]
INVALID_LETTER, // [238]
INVALID_LETTER, // [239]
INVALID_LETTER, // [240]
INVALID_LETTER, // [241]
INVALID_LETTER, // [242]
INVALID_LETTER, // [243]
INVALID_LETTER, // [244]
INVALID_LETTER, // [245]
INVALID_LETTER, // [246]
INVALID_LETTER, // [247]
INVALID_LETTER, // [248]
INVALID_LETTER, // [249]
INVALID_LETTER, // [250]
INVALID_LETTER, // [251]
INVALID_LETTER, // [252]
INVALID_LETTER, // [253]
INVALID_LETTER, // [254]
INVALID_LETTER, // [255]
};
bool g_IsSeqChar[256] =
{
false, // [ 0] 0x00
false, // [ 1] 0x01
false, // [ 2] 0x02
false, // [ 3] 0x03
false, // [ 4] 0x04
false, // [ 5] 0x05
false, // [ 6] 0x06
false, // [ 7] 0x07
false, // [ 8] 0x08
false, // [ 9] 0x09
false, // [ 10] 0x0a
false, // [ 11] 0x0b
false, // [ 12] 0x0c
false, // [ 13] 0x0d
false, // [ 14] 0x0e
false, // [ 15] 0x0f
false, // [ 16] 0x10
false, // [ 17] 0x11
false, // [ 18] 0x12
false, // [ 19] 0x13
false, // [ 20] 0x14
false, // [ 21] 0x15
false, // [ 22] 0x16
false, // [ 23] 0x17
false, // [ 24] 0x18
false, // [ 25] 0x19
false, // [ 26] 0x1a
false, // [ 27] 0x1b
false, // [ 28] 0x1c
false, // [ 29] 0x1d
false, // [ 30] 0x1e
false, // [ 31] 0x1f
false, // [ 32] ' '
false, // [ 33] '!'
false, // [ 34] '"'
false, // [ 35] '#'
false, // [ 36] '$'
false, // [ 37] '%'
false, // [ 38] '&'
false, // [ 39] '''
false, // [ 40] '('
false, // [ 41] ')'
true, // [ 42] '*'
false, // [ 43] '+'
false, // [ 44] ','
false, // [ 45] '-'
false, // [ 46] '.'
false, // [ 47] '/'
false, // [ 48] '0'
false, // [ 49] '1'
false, // [ 50] '2'
false, // [ 51] '3'
false, // [ 52] '4'
false, // [ 53] '5'
false, // [ 54] '6'
false, // [ 55] '7'
false, // [ 56] '8'
false, // [ 57] '9'
false, // [ 58] ':'
false, // [ 59] ';'
false, // [ 60] '<'
false, // [ 61] '='
false, // [ 62] '>'
false, // [ 63] '?'
false, // [ 64] '@'
true, // [ 65] 'A'
true, // [ 66] 'B'
true, // [ 67] 'C'
true, // [ 68] 'D'
true, // [ 69] 'E'
true, // [ 70] 'F'
true, // [ 71] 'G'
true, // [ 72] 'H'
true, // [ 73] 'I'
false, // [ 74] 'J'
true, // [ 75] 'K'
true, // [ 76] 'L'
true, // [ 77] 'M'
true, // [ 78] 'N'
false, // [ 79] 'O'
true, // [ 80] 'P'
true, // [ 81] 'Q'
true, // [ 82] 'R'
true, // [ 83] 'S'
true, // [ 84] 'T'
true, // [ 85] 'U'
true, // [ 86] 'V'
true, // [ 87] 'W'
true, // [ 88] 'X'
true, // [ 89] 'Y'
true, // [ 90] 'Z'
false, // [ 91] '['
false, // [ 92] '\'
false, // [ 93] ']'
false, // [ 94] '^'
false, // [ 95] '_'
false, // [ 96] '`'
true, // [ 97] 'a'
true, // [ 98] 'b'
true, // [ 99] 'c'
true, // [100] 'd'
true, // [101] 'e'
true, // [102] 'f'
true, // [103] 'g'
true, // [104] 'h'
true, // [105] 'i'
false, // [106] 'j'
true, // [107] 'k'
true, // [108] 'l'
true, // [109] 'm'
true, // [110] 'n'
false, // [111] 'o'
true, // [112] 'p'
true, // [113] 'q'
true, // [114] 'r'
true, // [115] 's'
true, // [116] 't'
true, // [117] 'u'
true, // [118] 'v'
true, // [119] 'w'
true, // [120] 'x'
true, // [121] 'y'
true, // [122] 'z'
false, // [123] '{'
false, // [124] '|'
false, // [125] '}'
false, // [126] '~'
false, // [127] 0x7f
false, // [128] 0x80
false, // [129] 0x81
false, // [130] 0x82
false, // [131] 0x83
false, // [132] 0x84
false, // [133] 0x85
false, // [134] 0x86
false, // [135] 0x87
false, // [136] 0x88
false, // [137] 0x89
false, // [138] 0x8a
false, // [139] 0x8b
false, // [140] 0x8c
false, // [141] 0x8d
false, // [142] 0x8e
false, // [143] 0x8f
false, // [144] 0x90
false, // [145] 0x91
false, // [146] 0x92
false, // [147] 0x93
false, // [148] 0x94
false, // [149] 0x95
false, // [150] 0x96
false, // [151] 0x97
false, // [152] 0x98
false, // [153] 0x99
false, // [154] 0x9a
false, // [155] 0x9b
false, // [156] 0x9c
false, // [157] 0x9d
false, // [158] 0x9e
false, // [159] 0x9f
false, // [160] 0xa0
false, // [161] 0xa1
false, // [162] 0xa2
false, // [163] 0xa3
false, // [164] 0xa4
false, // [165] 0xa5
false, // [166] 0xa6
false, // [167] 0xa7
false, // [168] 0xa8
false, // [169] 0xa9
false, // [170] 0xaa
false, // [171] 0xab
false, // [172] 0xac
false, // [173] 0xad
false, // [174] 0xae
false, // [175] 0xaf
false, // [176] 0xb0
false, // [177] 0xb1
false, // [178] 0xb2
false, // [179] 0xb3
false, // [180] 0xb4
false, // [181] 0xb5
false, // [182] 0xb6
false, // [183] 0xb7
false, // [184] 0xb8
false, // [185] 0xb9
false, // [186] 0xba
false, // [187] 0xbb
false, // [188] 0xbc
false, // [189] 0xbd
false, // [190] 0xbe
false, // [191] 0xbf
false, // [192] 0xc0
false, // [193] 0xc1
false, // [194] 0xc2
false, // [195] 0xc3
false, // [196] 0xc4
false, // [197] 0xc5
false, // [198] 0xc6
false, // [199] 0xc7
false, // [200] 0xc8
false, // [201] 0xc9
false, // [202] 0xca
false, // [203] 0xcb
false, // [204] 0xcc
false, // [205] 0xcd
false, // [206] 0xce
false, // [207] 0xcf
false, // [208] 0xd0
false, // [209] 0xd1
false, // [210] 0xd2
false, // [211] 0xd3
false, // [212] 0xd4
false, // [213] 0xd5
false, // [214] 0xd6
false, // [215] 0xd7
false, // [216] 0xd8
false, // [217] 0xd9
false, // [218] 0xda
false, // [219] 0xdb
false, // [220] 0xdc
false, // [221] 0xdd
false, // [222] 0xde
false, // [223] 0xdf
false, // [224] 0xe0
false, // [225] 0xe1
false, // [226] 0xe2
false, // [227] 0xe3
false, // [228] 0xe4
false, // [229] 0xe5
false, // [230] 0xe6
false, // [231] 0xe7
false, // [232] 0xe8
false, // [233] 0xe9
false, // [234] 0xea
false, // [235] 0xeb
false, // [236] 0xec
false, // [237] 0xed
false, // [238] 0xee
false, // [239] 0xef
false, // [240] 0xf0
false, // [241] 0xf1
false, // [242] 0xf2
false, // [243] 0xf3
false, // [244] 0xf4
false, // [245] 0xf5
false, // [246] 0xf6
false, // [247] 0xf7
false, // [248] 0xf8
false, // [249] 0xf9
false, // [250] 0xfa
false, // [251] 0xfb
false, // [252] 0xfc
false, // [253] 0xfd
false, // [254] 0xfe
false, // [255] 0xff
};
bool g_IsAminoChar[256] =
{
false, // [ 0] 0x00
false, // [ 1] 0x01
false, // [ 2] 0x02
false, // [ 3] 0x03
false, // [ 4] 0x04
false, // [ 5] 0x05
false, // [ 6] 0x06
false, // [ 7] 0x07
false, // [ 8] 0x08
false, // [ 9] 0x09
false, // [ 10] 0x0a
false, // [ 11] 0x0b
false, // [ 12] 0x0c
false, // [ 13] 0x0d
false, // [ 14] 0x0e
false, // [ 15] 0x0f
false, // [ 16] 0x10
false, // [ 17] 0x11
false, // [ 18] 0x12
false, // [ 19] 0x13
false, // [ 20] 0x14
false, // [ 21] 0x15
false, // [ 22] 0x16
false, // [ 23] 0x17
false, // [ 24] 0x18
false, // [ 25] 0x19
false, // [ 26] 0x1a
false, // [ 27] 0x1b
false, // [ 28] 0x1c
false, // [ 29] 0x1d
false, // [ 30] 0x1e
false, // [ 31] 0x1f
false, // [ 32] ' '
false, // [ 33] '!'
false, // [ 34] '"'
false, // [ 35] '#'
false, // [ 36] '$'
false, // [ 37] '%'
false, // [ 38] '&'
false, // [ 39] '''
false, // [ 40] '('
false, // [ 41] ')'
true, // [ 42] '*' = STP
false, // [ 43] '+'
false, // [ 44] ','
false, // [ 45] '-'
false, // [ 46] '.'
false, // [ 47] '/'
false, // [ 48] '0'
false, // [ 49] '1'
false, // [ 50] '2'
false, // [ 51] '3'
false, // [ 52] '4'
false, // [ 53] '5'
false, // [ 54] '6'
false, // [ 55] '7'
false, // [ 56] '8'
false, // [ 57] '9'
false, // [ 58] ':'
false, // [ 59] ';'
false, // [ 60] '<'
false, // [ 61] '='
false, // [ 62] '>'
false, // [ 63] '?'
false, // [ 64] '@'
true, // [ 65] 'A' = Ala
false, // [ 66] 'B'
true, // [ 67] 'C' = Cys
true, // [ 68] 'D' = Asp
true, // [ 69] 'E' = Glu
true, // [ 70] 'F' = Phe
true, // [ 71] 'G' = Gly
true, // [ 72] 'H' = His
true, // [ 73] 'I' = Ile
false, // [ 74] 'J'
true, // [ 75] 'K' = Lys
true, // [ 76] 'L' = Leu
true, // [ 77] 'M' = Met
true, // [ 78] 'N' = Asn
false, // [ 79] 'O'
true, // [ 80] 'P' = Pro
true, // [ 81] 'Q' = Gln
true, // [ 82] 'R' = Arg
true, // [ 83] 'S' = Ser
true, // [ 84] 'T' = Thr
false, // [ 85] 'U'
true, // [ 86] 'V' = Val
true, // [ 87] 'W' = Trp
false, // [ 88] 'X'
true, // [ 89] 'Y' = Tyr
false, // [ 90] 'Z'
false, // [ 91] '['
false, // [ 92] '\'
false, // [ 93] ']'
false, // [ 94] '^'
false, // [ 95] '_'
false, // [ 96] '`'
true, // [ 97] 'A' = Ala
false, // [ 98] 'B'
true, // [ 99] 'C' = Cys
true, // [100] 'D' = Asp
true, // [101] 'E' = Glu
true, // [102] 'F' = Phe
true, // [103] 'G' = Gly
true, // [104] 'H' = His
true, // [105] 'I' = Ile
false, // [106] 'J'
true, // [107] 'K' = Lys
true, // [108] 'L' = Leu
true, // [109] 'M' = Met
true, // [110] 'N' = Asn
false, // [111] 'O'
true, // [112] 'P' = Pro
true, // [113] 'Q' = Gln
true, // [114] 'R' = Arg
true, // [115] 'S' = Ser
true, // [116] 'T' = Thr
false, // [117] 'U'
true, // [118] 'V' = Val
true, // [119] 'W' = Trp
false, // [120] 'X'
true, // [121] 'Y' = Tyr
false, // [122] 'Z'
false, // [123] '{'
false, // [124] '|'
false, // [125] '}'
false, // [126] '~'
false, // [127] 0x7f
false, // [128] 0x80
false, // [129] 0x81
false, // [130] 0x82
false, // [131] 0x83
false, // [132] 0x84
false, // [133] 0x85
false, // [134] 0x86
false, // [135] 0x87
false, // [136] 0x88
false, // [137] 0x89
false, // [138] 0x8a
false, // [139] 0x8b
false, // [140] 0x8c
false, // [141] 0x8d
false, // [142] 0x8e
false, // [143] 0x8f
false, // [144] 0x90
false, // [145] 0x91
false, // [146] 0x92
false, // [147] 0x93
false, // [148] 0x94
false, // [149] 0x95
false, // [150] 0x96
false, // [151] 0x97
false, // [152] 0x98
false, // [153] 0x99
false, // [154] 0x9a
false, // [155] 0x9b
false, // [156] 0x9c
false, // [157] 0x9d
false, // [158] 0x9e
false, // [159] 0x9f
false, // [160] 0xa0
false, // [161] 0xa1
false, // [162] 0xa2
false, // [163] 0xa3
false, // [164] 0xa4
false, // [165] 0xa5
false, // [166] 0xa6
false, // [167] 0xa7
false, // [168] 0xa8
false, // [169] 0xa9
false, // [170] 0xaa
false, // [171] 0xab
false, // [172] 0xac
false, // [173] 0xad
false, // [174] 0xae
false, // [175] 0xaf
false, // [176] 0xb0
false, // [177] 0xb1
false, // [178] 0xb2
false, // [179] 0xb3
false, // [180] 0xb4
false, // [181] 0xb5
false, // [182] 0xb6
false, // [183] 0xb7
false, // [184] 0xb8
false, // [185] 0xb9
false, // [186] 0xba
false, // [187] 0xbb
false, // [188] 0xbc
false, // [189] 0xbd
false, // [190] 0xbe
false, // [191] 0xbf
false, // [192] 0xc0
false, // [193] 0xc1
false, // [194] 0xc2
false, // [195] 0xc3
false, // [196] 0xc4
false, // [197] 0xc5
false, // [198] 0xc6
false, // [199] 0xc7
false, // [200] 0xc8
false, // [201] 0xc9
false, // [202] 0xca
false, // [203] 0xcb
false, // [204] 0xcc
false, // [205] 0xcd
false, // [206] 0xce
false, // [207] 0xcf
false, // [208] 0xd0
false, // [209] 0xd1
false, // [210] 0xd2
false, // [211] 0xd3
false, // [212] 0xd4
false, // [213] 0xd5
false, // [214] 0xd6
false, // [215] 0xd7
false, // [216] 0xd8
false, // [217] 0xd9
false, // [218] 0xda
false, // [219] 0xdb
false, // [220] 0xdc
false, // [221] 0xdd
false, // [222] 0xde
false, // [223] 0xdf
false, // [224] 0xe0
false, // [225] 0xe1
false, // [226] 0xe2
false, // [227] 0xe3
false, // [228] 0xe4
false, // [229] 0xe5
false, // [230] 0xe6
false, // [231] 0xe7
false, // [232] 0xe8
false, // [233] 0xe9
false, // [234] 0xea
false, // [235] 0xeb
false, // [236] 0xec
false, // [237] 0xed
false, // [238] 0xee
false, // [239] 0xef
false, // [240] 0xf0
false, // [241] 0xf1
false, // [242] 0xf2
false, // [243] 0xf3
false, // [244] 0xf4
false, // [245] 0xf5
false, // [246] 0xf6
false, // [247] 0xf7
false, // [248] 0xf8
false, // [249] 0xf9
false, // [250] 0xfa
false, // [251] 0xfb
false, // [252] 0xfc
false, // [253] 0xfd
false, // [254] 0xfe
false, // [255] 0xff
};
bool g_IsNucleoChar[256] =
{
false, // [ 0] 0x00
false, // [ 1] 0x01
false, // [ 2] 0x02
false, // [ 3] 0x03
false, // [ 4] 0x04
false, // [ 5] 0x05
false, // [ 6] 0x06
false, // [ 7] 0x07
false, // [ 8] 0x08
false, // [ 9] 0x09
false, // [ 10] 0x0a
false, // [ 11] 0x0b
false, // [ 12] 0x0c
false, // [ 13] 0x0d
false, // [ 14] 0x0e
false, // [ 15] 0x0f
false, // [ 16] 0x10
false, // [ 17] 0x11
false, // [ 18] 0x12
false, // [ 19] 0x13
false, // [ 20] 0x14
false, // [ 21] 0x15
false, // [ 22] 0x16
false, // [ 23] 0x17
false, // [ 24] 0x18
false, // [ 25] 0x19
false, // [ 26] 0x1a
false, // [ 27] 0x1b
false, // [ 28] 0x1c
false, // [ 29] 0x1d
false, // [ 30] 0x1e
false, // [ 31] 0x1f
false, // [ 32] ' '
false, // [ 33] '!'
false, // [ 34] '"'
false, // [ 35] '#'
false, // [ 36] '$'
false, // [ 37] '%'
false, // [ 38] '&'
false, // [ 39] '''
false, // [ 40] '('
false, // [ 41] ')'
false, // [ 42] '*'
false, // [ 43] '+'
false, // [ 44] ','
false, // [ 45] '-'
false, // [ 46] '.'
false, // [ 47] '/'
false, // [ 48] '0'
false, // [ 49] '1'
false, // [ 50] '2'
false, // [ 51] '3'
false, // [ 52] '4'
false, // [ 53] '5'
false, // [ 54] '6'
false, // [ 55] '7'
false, // [ 56] '8'
false, // [ 57] '9'
false, // [ 58] ':'
false, // [ 59] ';'
false, // [ 60] '<'
false, // [ 61] '='
false, // [ 62] '>'
false, // [ 63] '?'
false, // [ 64] '@'
true, // [ 65] 'A' (Nucleotide)
false, // [ 66] 'B'
true, // [ 67] 'C' (Nucleotide)
false, // [ 68] 'D'
false, // [ 69] 'E'
false, // [ 70] 'F'
true, // [ 71] 'G' (Nucleotide)
false, // [ 72] 'H'
false, // [ 73] 'I'
false, // [ 74] 'J'
false, // [ 75] 'K'
false, // [ 76] 'L'
false, // [ 77] 'M'
true, // [ 78] 'N' (Nucleotide)
false, // [ 79] 'O'
false, // [ 80] 'P'
false, // [ 81] 'Q'
false, // [ 82] 'R'
false, // [ 83] 'S'
true, // [ 84] 'T' (Nucleotide)
true, // [ 85] 'U' (Nucleotide)
false, // [ 86] 'V'
false, // [ 87] 'W'
false, // [ 88] 'X'
false, // [ 89] 'Y'
false, // [ 90] 'Z'
false, // [ 91] '['
false, // [ 92] '\'
false, // [ 93] ']'
false, // [ 94] '^'
false, // [ 95] '_'
false, // [ 96] '`'
true, // [ 97] 'A' (Nucleotide)
false, // [ 98] 'B'
true, // [ 99] 'C' (Nucleotide)
false, // [100] 'D'
false, // [101] 'E'
false, // [102] 'F'
true, // [103] 'G' (Nucleotide)
false, // [104] 'H'
false, // [105] 'I'
false, // [106] 'J'
false, // [107] 'K'
false, // [108] 'L'
false, // [109] 'M'
true, // [110] 'N' (Nucleotide)
false, // [111] 'O'
false, // [112] 'P'
false, // [113] 'Q'
false, // [114] 'R'
false, // [115] 'S'
true, // [116] 'T' (Nucleotide)
true, // [117] 'U' (Nucleotide)
false, // [118] 'V'
false, // [119] 'W'
false, // [120] 'X'
false, // [121] 'Y'
false, // [122] 'Z'
false, // [123] '{'
false, // [124] '|'
false, // [125] '}'
false, // [126] '~'
false, // [127] 0x7f
false, // [128] 0x80
false, // [129] 0x81
false, // [130] 0x82
false, // [131] 0x83
false, // [132] 0x84
false, // [133] 0x85
false, // [134] 0x86
false, // [135] 0x87
false, // [136] 0x88
false, // [137] 0x89
false, // [138] 0x8a
false, // [139] 0x8b
false, // [140] 0x8c
false, // [141] 0x8d
false, // [142] 0x8e
false, // [143] 0x8f
false, // [144] 0x90
false, // [145] 0x91
false, // [146] 0x92
false, // [147] 0x93
false, // [148] 0x94
false, // [149] 0x95
false, // [150] 0x96
false, // [151] 0x97
false, // [152] 0x98
false, // [153] 0x99
false, // [154] 0x9a
false, // [155] 0x9b
false, // [156] 0x9c
false, // [157] 0x9d
false, // [158] 0x9e
false, // [159] 0x9f
false, // [160] 0xa0
false, // [161] 0xa1
false, // [162] 0xa2
false, // [163] 0xa3
false, // [164] 0xa4
false, // [165] 0xa5
false, // [166] 0xa6
false, // [167] 0xa7
false, // [168] 0xa8
false, // [169] 0xa9
false, // [170] 0xaa
false, // [171] 0xab
false, // [172] 0xac
false, // [173] 0xad
false, // [174] 0xae
false, // [175] 0xaf
false, // [176] 0xb0
false, // [177] 0xb1
false, // [178] 0xb2
false, // [179] 0xb3
false, // [180] 0xb4
false, // [181] 0xb5
false, // [182] 0xb6
false, // [183] 0xb7
false, // [184] 0xb8
false, // [185] 0xb9
false, // [186] 0xba
false, // [187] 0xbb
false, // [188] 0xbc
false, // [189] 0xbd
false, // [190] 0xbe
false, // [191] 0xbf
false, // [192] 0xc0
false, // [193] 0xc1
false, // [194] 0xc2
false, // [195] 0xc3
false, // [196] 0xc4
false, // [197] 0xc5
false, // [198] 0xc6
false, // [199] 0xc7
false, // [200] 0xc8
false, // [201] 0xc9
false, // [202] 0xca
false, // [203] 0xcb
false, // [204] 0xcc
false, // [205] 0xcd
false, // [206] 0xce
false, // [207] 0xcf
false, // [208] 0xd0
false, // [209] 0xd1
false, // [210] 0xd2
false, // [211] 0xd3
false, // [212] 0xd4
false, // [213] 0xd5
false, // [214] 0xd6
false, // [215] 0xd7
false, // [216] 0xd8
false, // [217] 0xd9
false, // [218] 0xda
false, // [219] 0xdb
false, // [220] 0xdc
false, // [221] 0xdd
false, // [222] 0xde
false, // [223] 0xdf
false, // [224] 0xe0
false, // [225] 0xe1
false, // [226] 0xe2
false, // [227] 0xe3
false, // [228] 0xe4
false, // [229] 0xe5
false, // [230] 0xe6
false, // [231] 0xe7
false, // [232] 0xe8
false, // [233] 0xe9
false, // [234] 0xea
false, // [235] 0xeb
false, // [236] 0xec
false, // [237] 0xed
false, // [238] 0xee
false, // [239] 0xef
false, // [240] 0xf0
false, // [241] 0xf1
false, // [242] 0xf2
false, // [243] 0xf3
false, // [244] 0xf4
false, // [245] 0xf5
false, // [246] 0xf6
false, // [247] 0xf7
false, // [248] 0xf8
false, // [249] 0xf9
false, // [250] 0xfa
false, // [251] 0xfb
false, // [252] 0xfc
false, // [253] 0xfd
false, // [254] 0xfe
false, // [255] 0xff
};
bool g_IsACGTU[256] =
{
false, // [ 0] 0x00
false, // [ 1] 0x01
false, // [ 2] 0x02
false, // [ 3] 0x03
false, // [ 4] 0x04
false, // [ 5] 0x05
false, // [ 6] 0x06
false, // [ 7] 0x07
false, // [ 8] 0x08
false, // [ 9] 0x09
false, // [ 10] 0x0a
false, // [ 11] 0x0b
false, // [ 12] 0x0c
false, // [ 13] 0x0d
false, // [ 14] 0x0e
false, // [ 15] 0x0f
false, // [ 16] 0x10
false, // [ 17] 0x11
false, // [ 18] 0x12
false, // [ 19] 0x13
false, // [ 20] 0x14
false, // [ 21] 0x15
false, // [ 22] 0x16
false, // [ 23] 0x17
false, // [ 24] 0x18
false, // [ 25] 0x19
false, // [ 26] 0x1a
false, // [ 27] 0x1b
false, // [ 28] 0x1c
false, // [ 29] 0x1d
false, // [ 30] 0x1e
false, // [ 31] 0x1f
false, // [ 32] ' '
false, // [ 33] '!'
false, // [ 34] '"'
false, // [ 35] '#'
false, // [ 36] '$'
false, // [ 37] '%'
false, // [ 38] '&'
false, // [ 39] '''
false, // [ 40] '('
false, // [ 41] ')'
false, // [ 42] '*'
false, // [ 43] '+'
false, // [ 44] ','
false, // [ 45] '-'
false, // [ 46] '.'
false, // [ 47] '/'
false, // [ 48] '0'
false, // [ 49] '1'
false, // [ 50] '2'
false, // [ 51] '3'
false, // [ 52] '4'
false, // [ 53] '5'
false, // [ 54] '6'
false, // [ 55] '7'
false, // [ 56] '8'
false, // [ 57] '9'
false, // [ 58] ':'
false, // [ 59] ';'
false, // [ 60] '<'
false, // [ 61] '='
false, // [ 62] '>'
false, // [ 63] '?'
false, // [ 64] '@'
true, // [ 65] 'A' (ACGT)
false, // [ 66] 'B'
true, // [ 67] 'C' (ACGT)
false, // [ 68] 'D'
false, // [ 69] 'E'
false, // [ 70] 'F'
true, // [ 71] 'G' (ACGT)
false, // [ 72] 'H'
false, // [ 73] 'I'
false, // [ 74] 'J'
false, // [ 75] 'K'
false, // [ 76] 'L'
false, // [ 77] 'M'
false, // [ 78] 'N'
false, // [ 79] 'O'
false, // [ 80] 'P'
false, // [ 81] 'Q'
false, // [ 82] 'R'
false, // [ 83] 'S'
true, // [ 84] 'T' (ACGT)
true, // [ 85] 'U' (ACGT)
false, // [ 86] 'V'
false, // [ 87] 'W'
false, // [ 88] 'X'
false, // [ 89] 'Y'
false, // [ 90] 'Z'
false, // [ 91] '['
false, // [ 92] '\'
false, // [ 93] ']'
false, // [ 94] '^'
false, // [ 95] '_'
false, // [ 96] '`'
true, // [ 97] 'A' (ACGT)
false, // [ 98] 'B'
true, // [ 99] 'C' (ACGT)
false, // [100] 'D'
false, // [101] 'E'
false, // [102] 'F'
true, // [103] 'G' (ACGT)
false, // [104] 'H'
false, // [105] 'I'
false, // [106] 'J'
false, // [107] 'K'
false, // [108] 'L'
false, // [109] 'M'
false, // [110] 'N'
false, // [111] 'O'
false, // [112] 'P'
false, // [113] 'Q'
false, // [114] 'R'
false, // [115] 'S'
true, // [116] 'T' (ACGT)
true, // [117] 'U' (ACGT)
false, // [118] 'V'
false, // [119] 'W'
false, // [120] 'X'
false, // [121] 'Y'
false, // [122] 'Z'
false, // [123] '{'
false, // [124] '|'
false, // [125] '}'
false, // [126] '~'
false, // [127] 0x7f
false, // [128] 0x80
false, // [129] 0x81
false, // [130] 0x82
false, // [131] 0x83
false, // [132] 0x84
false, // [133] 0x85
false, // [134] 0x86
false, // [135] 0x87
false, // [136] 0x88
false, // [137] 0x89
false, // [138] 0x8a
false, // [139] 0x8b
false, // [140] 0x8c
false, // [141] 0x8d
false, // [142] 0x8e
false, // [143] 0x8f
false, // [144] 0x90
false, // [145] 0x91
false, // [146] 0x92
false, // [147] 0x93
false, // [148] 0x94
false, // [149] 0x95
false, // [150] 0x96
false, // [151] 0x97
false, // [152] 0x98
false, // [153] 0x99
false, // [154] 0x9a
false, // [155] 0x9b
false, // [156] 0x9c
false, // [157] 0x9d
false, // [158] 0x9e
false, // [159] 0x9f
false, // [160] 0xa0
false, // [161] 0xa1
false, // [162] 0xa2
false, // [163] 0xa3
false, // [164] 0xa4
false, // [165] 0xa5
false, // [166] 0xa6
false, // [167] 0xa7
false, // [168] 0xa8
false, // [169] 0xa9
false, // [170] 0xaa
false, // [171] 0xab
false, // [172] 0xac
false, // [173] 0xad
false, // [174] 0xae
false, // [175] 0xaf
false, // [176] 0xb0
false, // [177] 0xb1
false, // [178] 0xb2
false, // [179] 0xb3
false, // [180] 0xb4
false, // [181] 0xb5
false, // [182] 0xb6
false, // [183] 0xb7
false, // [184] 0xb8
false, // [185] 0xb9
false, // [186] 0xba
false, // [187] 0xbb
false, // [188] 0xbc
false, // [189] 0xbd
false, // [190] 0xbe
false, // [191] 0xbf
false, // [192] 0xc0
false, // [193] 0xc1
false, // [194] 0xc2
false, // [195] 0xc3
false, // [196] 0xc4
false, // [197] 0xc5
false, // [198] 0xc6
false, // [199] 0xc7
false, // [200] 0xc8
false, // [201] 0xc9
false, // [202] 0xca
false, // [203] 0xcb
false, // [204] 0xcc
false, // [205] 0xcd
false, // [206] 0xce
false, // [207] 0xcf
false, // [208] 0xd0
false, // [209] 0xd1
false, // [210] 0xd2
false, // [211] 0xd3
false, // [212] 0xd4
false, // [213] 0xd5
false, // [214] 0xd6
false, // [215] 0xd7
false, // [216] 0xd8
false, // [217] 0xd9
false, // [218] 0xda
false, // [219] 0xdb
false, // [220] 0xdc
false, // [221] 0xdd
false, // [222] 0xde
false, // [223] 0xdf
false, // [224] 0xe0
false, // [225] 0xe1
false, // [226] 0xe2
false, // [227] 0xe3
false, // [228] 0xe4
false, // [229] 0xe5
false, // [230] 0xe6
false, // [231] 0xe7
false, // [232] 0xe8
false, // [233] 0xe9
false, // [234] 0xea
false, // [235] 0xeb
false, // [236] 0xec
false, // [237] 0xed
false, // [238] 0xee
false, // [239] 0xef
false, // [240] 0xf0
false, // [241] 0xf1
false, // [242] 0xf2
false, // [243] 0xf3
false, // [244] 0xf4
false, // [245] 0xf5
false, // [246] 0xf6
false, // [247] 0xf7
false, // [248] 0xf8
false, // [249] 0xf9
false, // [250] 0xfa
false, // [251] 0xfb
false, // [252] 0xfc
false, // [253] 0xfd
false, // [254] 0xfe
false, // [255] 0xff
};
float g_AminoFreqs[20] =
{
0.0777f, // 'A' = Ala
0.0161f, // 'C' = Cys
0.0527f, // 'D' = Asp
0.0631f, // 'E' = Glu
0.0417f, // 'F' = Phe
0.0718f, // 'G' = Gly
0.0238f, // 'H' = His
0.0606f, // 'I' = Ile
0.0601f, // 'K' = Lys
0.0906f, // 'L' = Leu
0.0233f, // 'M' = Met
0.0439f, // 'N' = Asn
0.0456f, // 'P' = Pro
0.0368f, // 'Q' = Gln
0.0526f, // 'R' = Arg
0.0639f, // 'S' = Ser
0.0570f, // 'T' = Thr
0.0712f, // 'V' = Val
0.0134f, // 'W' = Trp
0.0339f, // 'Y' = Tyr
};
| 132,916
|
C++
|
.cpp
| 4,826
| 25.534397
| 81
| 0.525904
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| true
| true
| true
| false
|
1,537,944
|
localaligner.cpp
|
rcedgar_urmap/src/localaligner.cpp
|
#include "myutils.h"
#include "pathinfo.h"
#include "alignresult.h"
#include "localaligner.h"
float XDropAlignMem(XDPMem &Mem, const byte *A, unsigned LA, const byte *B, unsigned LB,
unsigned AncLoi, unsigned AncLoj, unsigned AncLen, const AlnParams &AP,
float X, HSPData &HSP, PathInfo &PI);
static float GetAnchor(const byte *Q, const byte *T,
unsigned Loi, unsigned Loj, unsigned SegLength,
const float * const *SubstMx,
unsigned &AncLoi, unsigned &AncLoj, unsigned &AncLen)
{
StartTimer(GetAnchor);
unsigned i = Loi;
unsigned j = Loj;
unsigned L = SegLength;
unsigned Startk = UINT_MAX;
unsigned BestStartk = UINT_MAX;
unsigned Length = 0;
float AnchorScore = 0.0f;
float BestScore = 0.0f;
for (unsigned k = 0; k < L; ++k)
{
byte a = Q[i++];
byte b = T[j++];
float Score = SubstMx[a][b];
if (Score > 0)
{
if (Startk == UINT_MAX)
{
Startk = k;
AnchorScore = Score;
}
else
AnchorScore += Score;
}
else
{
if (AnchorScore > BestScore)
{
BestScore = AnchorScore;
BestStartk = Startk;
asserta(k > Startk);
Length = k - Startk;
}
Startk = UINT_MAX;
}
}
if (AnchorScore > BestScore)
{
BestScore = AnchorScore;
BestStartk = Startk;
asserta(L > Startk);
Length = L - Startk;
}
AncLoi = Loi + BestStartk;
AncLoj = Loj + BestStartk;
AncLen = Length;
EndTimer(GetAnchor);
return BestScore;
}
LocalAligner::LocalAligner(ALIGNER_TYPE Type)
{
m_IsNucleo = false;
m_SubstMx = 0;
m_XDropU = -1.0f;
m_XDropG = -1.0f;
m_MinUngappedRawScore = -1.0f;
}
void LocalAligner::InitImpl()
{
asserta(m_AP != 0);
asserta(m_AH != 0);
m_IsNucleo = m_AP->Nucleo;
m_SubstMx = m_AP->SubstMx;
asserta(m_SubstMx != 0);
m_XDropU = m_AH->XDropU;
m_XDropG = m_AH->XDropG;
}
void LocalAligner::SetQueryPSSM()
{
const unsigned QL = m_Query->m_L;
m_QueryPSSM.Alloc(QL);
const byte *Q = m_Query->m_Seq;
const float **PSSM = m_QueryPSSM.Data;
for (unsigned i = 0; i < QL; ++i)
{
byte a = Q[i];
const float *Row = m_SubstMx[a];
PSSM[i] = Row;
}
}
AlignResult *LocalAligner::AlignPos(unsigned QueryPos, unsigned TargetPos)
{
StartTimer(LocalAligner_AlignPos);
const byte *Q = m_Query->m_Seq;
const byte *T = m_Target->m_Seq;
const float * const *PSSM = m_QueryPSSM.Data;
// Ungapped extend left
float LeftScore = 0.0f;
unsigned LeftLength = 0;
unsigned k = 0;
float LeftTotal = 0.0f;
int i = (int) QueryPos;
int j = (int) TargetPos;
while (i >= 0 && j >= 0)
{
++k;
// byte a = Q[i];
// byte b = T[j];
// LeftTotal += SubstMx[a][b];
byte b = T[j];
LeftTotal += PSSM[i][b];
if (LeftTotal > LeftScore)
{
LeftScore = LeftTotal;
LeftLength = k;
}
else if (LeftScore - LeftTotal > m_XDropU)
break;
--i;
--j;
}
// Ungapped extend right
float RightScore = 0.0f;
unsigned RightLength = 0;
float RightTotal = 0.0f;
const unsigned QL = m_Query->m_L;
const unsigned TL = m_Target->m_L;
i = QueryPos + 1;
j = TargetPos + 1;
k = 0;
while (i < (int) QL && j < (int) TL)
{
++k;
// byte a = Q[i];
// byte b = T[j];
// RightTotal += SubstMx[a][b];
byte b = T[j];
RightTotal += PSSM[i][b];
if (RightTotal > RightScore)
{
RightScore = RightTotal;
RightLength = k;
}
else if (RightScore - RightTotal > m_XDropU)
break;
++i;
++j;
}
EndTimer(LocalAligner_AlignPos);
// Accept ungapped segment?
const float Score = LeftScore + RightScore;
if (Score < m_MinUngappedRawScore)
{
IncCounter(FailedExtends);
return 0;
}
IncCounter(SuccessfulExtends);
//if (opt(log_ugx))
// {
// static bool HdrDone = false;
// if (!HdrDone)
// {
// Log("@UGX Y QPos TPos Word UXScore MinScore Labels\n");
// Log("@UGX - ----- ----- ------- ------- -------- ------\n");
// HdrDone = true;
// }
// const char *QueryLabel = m_Query->m_Label;
// const char *TargetLabel = m_Target->m_Label;
// unsigned PattLen = m_UDBParams->m_WordWidth;
// Log("@UGX %c %5u %5u %*.*s %7.1f %8.1f %s, %s\n",
// yon(Score >= m_MinUngappedRawScore),
// QueryPos,
// TargetPos,
// PattLen, PattLen, Q + QueryPos,
// Score,
// m_MinUngappedRawScore,
// QueryLabel,
// TargetLabel);
// }
// Find anchor
unsigned Loi = (QueryPos + 1) - LeftLength;
unsigned Loj = (TargetPos + 1) - LeftLength;
unsigned SegLength = LeftLength + RightLength;
unsigned AncLoi, AncLoj, AncLen;
float AncRawScore = GetAnchor(Q, T, Loi, Loj, SegLength, m_SubstMx,
AncLoi, AncLoj, AncLen);
if (AncRawScore <= 0.0f)
{
IncCounter(FailedAnchors);
return 0;
}
PathInfo *PI = ObjMgr::GetPathInfo();
// Gapped extension
HSPData HSP;
XDropAlignMem(m_Mem, Q, QL, T, TL,
AncLoi, AncLoj, AncLen, *m_AP, m_XDropG, HSP, *PI);
float GappedScore = HSP.Score;
if (GappedScore <= 0.0f)
{
IncCounter(FailedGappedExtensions_DP);
ObjMgr::Down(PI);
return 0;
}
double Evalue = g_ES->RawScoreToEvalue(GappedScore, QL, true);
if (Evalue > opt(evalue))
{
ObjMgr::Down(PI);
IncCounter(FailedGappedExtensions_Evalue);
return 0;
}
AlignResult *AR = ObjMgr::GetAlignResult();
AR->CreateLocalGapped(*m_Query, *m_Target, HSP, *PI, m_IsNucleo);
ObjMgr::Down(PI);
return AR;
}
AlignResult *LocalAligner::Align()
{
Die("LocalAligner::Align()");
return 0;
}
void LocalAligner::AlignMulti(GoBuff<AlignResult *, 32, true, false> &ARs)
{
Die("LocalAligner::AlignMulti");
}
void LocalAligner::SetQueryImpl()
{
m_MinUngappedRawScore = (float) g_ES->GetMinUngappedRawScore(m_Query->m_L);
SetQueryPSSM();
}
void LocalAligner::SetTargetImpl()
{
// Empty
}
void LocalAligner::OnQueryDoneImpl()
{
// Empty
}
void LocalAligner::OnTargetDoneImpl()
{
// Empty
}
PathInfo *LocalAligner::AlignTargetPos(const byte *T, unsigned TL,
unsigned QueryPos, unsigned TargetPos, HSPData &HSP)
{
StartTimer(LocalAligner_AlignPos);
const byte *Q = m_Query->m_Seq;
const float * const *PSSM = m_QueryPSSM.Data;
// Ungapped extend left
float LeftScore = 0.0f;
unsigned LeftLength = 0;
unsigned k = 0;
float LeftTotal = 0.0f;
int i = (int) QueryPos;
int j = (int) TargetPos;
while (i >= 0 && j >= 0)
{
++k;
// byte a = Q[i];
// byte b = T[j];
// LeftTotal += SubstMx[a][b];
byte b = T[j];
LeftTotal += PSSM[i][b];
if (LeftTotal > LeftScore)
{
LeftScore = LeftTotal;
LeftLength = k;
}
else if (LeftScore - LeftTotal > m_XDropU)
break;
--i;
--j;
}
// Ungapped extend right
float RightScore = 0.0f;
unsigned RightLength = 0;
float RightTotal = 0.0f;
const unsigned QL = m_Query->m_L;
i = QueryPos + 1;
j = TargetPos + 1;
k = 0;
while (i < (int) QL && j < (int) TL)
{
++k;
// byte a = Q[i];
// byte b = T[j];
// RightTotal += SubstMx[a][b];
byte b = T[j];
RightTotal += PSSM[i][b];
if (RightTotal > RightScore)
{
RightScore = RightTotal;
RightLength = k;
}
else if (RightScore - RightTotal > m_XDropU)
break;
++i;
++j;
}
EndTimer(LocalAligner_AlignPos);
// Accept ungapped segment?
const float Score = LeftScore + RightScore;
if (Score < m_MinUngappedRawScore)
{
IncCounter(FailedExtends);
return 0;
}
IncCounter(SuccessfulExtends);
//if (opt(log_ugx))
// {
// static bool HdrDone = false;
// if (!HdrDone)
// {
// Log("@UGX Y QPos TPos Word UXScore MinScore Labels\n");
// Log("@UGX - ----- ----- ------- ------- -------- ------\n");
// HdrDone = true;
// }
// const char *QueryLabel = m_Query->m_Label;
// const char *TargetLabel = m_Target->m_Label;
// unsigned PattLen = m_UDBParams->m_WordWidth;
// Log("@UGX %c %5u %5u %*.*s %7.1f %8.1f %s, %s\n",
// yon(Score >= m_MinUngappedRawScore),
// QueryPos,
// TargetPos,
// PattLen, PattLen, Q + QueryPos,
// Score,
// m_MinUngappedRawScore,
// QueryLabel,
// TargetLabel);
// }
// Find anchor
unsigned Loi = (QueryPos + 1) - LeftLength;
unsigned Loj = (TargetPos + 1) - LeftLength;
unsigned SegLength = LeftLength + RightLength;
unsigned AncLoi, AncLoj, AncLen;
float AncRawScore = GetAnchor(Q, T, Loi, Loj, SegLength, m_SubstMx,
AncLoi, AncLoj, AncLen);
if (AncRawScore <= 0.0f)
{
IncCounter(FailedAnchors);
return 0;
}
PathInfo *PI = ObjMgr::GetPathInfo();
// Gapped extension
XDropAlignMem(m_Mem, Q, QL, T, TL,
AncLoi, AncLoj, AncLen, *m_AP, m_XDropG, HSP, *PI);
float GappedScore = HSP.Score;
if (GappedScore <= 0.0f)
{
IncCounter(FailedGappedExtensions_DP);
ObjMgr::Down(PI);
return 0;
}
double Evalue = g_ES->RawScoreToEvalue(GappedScore, QL, true);
if (Evalue > opt(evalue))
{
ObjMgr::Down(PI);
IncCounter(FailedGappedExtensions_Evalue);
return 0;
}
//AlignResult *AR = ObjMgr::GetAlignResult();
//AR->CreateLocalGapped(*m_Query, *m_Target, HSP, *PI, m_IsNucleo);
//ObjMgr::Down(PI);
return PI;
}
| 8,801
|
C++
|
.cpp
| 366
| 21.478142
| 88
| 0.651448
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,945
|
ufistats.cpp
|
rcedgar_urmap/src/ufistats.cpp
|
#include "myutils.h"
#include "ufindex.h"
#include <inttypes.h>
void UFIndex::LogStats()
{
if (m_SlotCounts == 0)
CountSlots();
if (m_SlotCounts_Minus == 0)
CountSlots_Minus();
unsigned FreeCount = 0;
unsigned SinglePlusCount = 0;
unsigned SingleBothCount = 0;
unsigned EndCount = 0;
unsigned MineCount = 0;
unsigned OtherCount = 0;
unsigned TruncCount = 0;
unsigned LongMineCount = 0;
unsigned LongOtherCount = 0;
unsigned Trunc2Count = 0;
unsigned TotalCount = 0;
uint32 *PosVec = myalloc(uint32, m_MaxIx);
vector<unsigned> CountHist(256);
vector<unsigned> TruncHist(256);
for (uint64 Slot = 0; Slot < m_SlotCount; ++Slot)
{
byte T = GetTally(Slot);
if (T == TALLY_FREE)
++FreeCount;
else if (T == TALLY_PLUS1)
++SinglePlusCount;
else if (T == TALLY_BOTH1)
++SingleBothCount;
else if (T == TALLY_END)
++EndCount;
else if (T == TALLY_NEXT_LONG_MINE)
++LongMineCount;
else if (T == TALLY_NEXT_LONG_OTHER)
++LongOtherCount;
if (T != TALLY_FREE)
{
if (TallyMine(T))
++MineCount;
else
++OtherCount;
}
unsigned K = GetRow(Slot, PosVec);
unsigned n = m_SlotCounts[Slot];
unsigned n_minus = m_SlotCounts_Minus[Slot];
++(CountHist[n]);
TotalCount += n;
if (n > 0 && K < n && n <= m_MaxIx && n_minus <= m_MaxIx)
{
++Trunc2Count;
TruncCount += n;
++(TruncHist[n]);
}
assert(K <= n);
}
unsigned Maxi = 0;
for (unsigned i = 0; i < 256; ++i)
if (CountHist[i] > 0)
Maxi = i;
if (Maxi > 4)
Maxi = 4;
for (unsigned i = 0; i <= Maxi; ++i)
{
unsigned CH = CountHist[i];
Log("[%3u] %10u", i, CH);
if (i == 0)
Log(" %7.7s ", "");
else
Log(" %7.2f%%", GetPct(CH, TotalCount));
unsigned TH = TruncHist[i];
if ((i > 1 && i <= m_MaxIx) || TH != 0)
{
Log(" %10u ", TH);
Log(" %7.2f%%", GetPct(TH, CH));
if (i == 1 && TH > 0)
Log(" <<< TRUNCATED SINGLES");
if (TH > 0 && i > m_MaxIx)
Log(" <<< GT MaxIx %u", m_MaxIx);
}
Log("\n");
}
unsigned IndexedCount, NotIndexedCount, WildcardCount;
CountIndexedWords(IndexedCount, NotIndexedCount, WildcardCount);
uint64 CollisionCount;
uint64 Indexed2Count;
GetCollisionCount(CollisionCount, Indexed2Count);
Log("\n");
Log("%10" PRIu32 " Word length\n", m_WordLength);
Log("%10" PRIu32 " MaxIx\n", m_MaxIx);
Log("%10" PRIu32 " Sequence data (%s)\n", m_SeqDataSize, IntToStr(m_SeqDataSize));
Log("%10" PRIu64 " Slots (%s)\n", m_SlotCount, Int64ToStr(m_SlotCount));
#define X(x) Log("%10" PRIu64 " " #x "\n", x##Count);
X(Indexed)
X(Indexed2)
X(NotIndexed)
X(Wildcard)
X(Free)
X(Collision)
X(SingleBoth)
X(SinglePlus)
X(End)
X(Mine)
X(Other)
X(Trunc)
X(Trunc2)
X(LongMine)
X(LongOther)
X(Total)
#undef X
Log("\n");
}
void cmd_ufi_stats()
{
UFIndex UFI;
UFI.FromFile(opt(ufi_stats));
UFI.LogStats();
}
void cmd_ufi_counts()
{
UFIndex UFI;
UFI.FromFile(opt(ufi_counts));
UFI.CountSlots();
FILE *f = CreateStdioFile(opt(output));
WriteStdioFile64(f, UFI.m_SlotCounts, UFI.m_SlotCount);
CloseStdioFile(f);
}
void cmd_ufi_validate()
{
UFIndex UFI;
UFI.FromFile(opt(ufi_validate));
UFI.Validate();
}
void cmd_ufi_info()
{
const string &FileName = opt(ufi_info);
FILE *f = OpenStdioFile(FileName);
uint32 WordLength, MaxIx, SeqDataSize;
uint64 SlotCount;
uint32 u;
ReadStdioFile(f, &u, 4);
asserta(u == UFI_MAGIC1);
ReadStdioFile(f, &WordLength, 4);
ReadStdioFile(f, &MaxIx, 4);
ReadStdioFile(f, &SeqDataSize, 4);
ReadStdioFile(f, &SlotCount, 8);
ProgressLog(" Word length %u\n", WordLength);
ProgressLog(" MaxIx %u\n", MaxIx);
ProgressLog(" SeqData %u (%s)\n",
SeqDataSize, MemBytesToStr((double) SeqDataSize));
ProgressLog(" Slots %" PRIu64 " (%s)\n",
SlotCount, MemBytesToStr((double) SlotCount));
CloseStdioFile(f);
}
| 3,816
|
C++
|
.cpp
| 156
| 21.814103
| 84
| 0.652759
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,946
|
setnucmx.cpp
|
rcedgar_urmap/src/setnucmx.cpp
|
#include "myutils.h"
#include "mx.h"
#include "omplock.h"
#include "alpha.h"
Mx<float> g_SubstMxf;
float **g_SubstMx;
static const char Alphabet[] = "ACGTU";
void SetNucSubstMx(double Match, double Mismatch)
{
LOCK();
static bool Done = false;
if (Done)
{
asserta(g_SubstMx != 0);
UNLOCK();
return;
}
Done = true;
if (Match <= 0.0)
Die("Match score should be +ve");
if (Mismatch >= 0.0)
Die("Mismatch score should be -ve");
unsigned N = unsigned(strlen(Alphabet));
g_SubstMxf.Alloc("NUCMX", 256, 256);
g_SubstMxf.PutAll(0);
g_SubstMx = g_SubstMxf.GetData();
for (unsigned i = 0; i < N; ++i)
{
byte leti = g_CharToLetterNucleo[Alphabet[i]];
for (unsigned j = 0; j < N; ++j)
{
byte letj = g_CharToLetterNucleo[Alphabet[j]];
float v = float(leti == letj ? Match : Mismatch);
byte ui = (byte) toupper(Alphabet[i]);
byte uj = (byte) toupper(Alphabet[j]);
byte li = (byte) tolower(ui);
byte lj = (byte) tolower(uj);
ui = (byte) toupper(ui);
uj = (byte) toupper(uj);
g_SubstMx[ui][uj] = v;
g_SubstMx[uj][ui] = v;
g_SubstMx[ui][lj] = v;
g_SubstMx[uj][li] = v;
g_SubstMx[li][uj] = v;
g_SubstMx[lj][ui] = v;
g_SubstMx[li][lj] = v;
g_SubstMx[lj][li] = v;
}
}
for (unsigned j = 0; j < N; ++j)
{
float v = 0.0f;
byte ui = (byte) 'N';
byte uj = (byte) toupper(Alphabet[j]);
byte li = (byte) 'n';
byte lj = (byte) tolower(uj);
ui = (byte) toupper(ui);
uj = (byte) toupper(uj);
g_SubstMx[ui][uj] = v;
g_SubstMx[uj][ui] = v;
g_SubstMx[ui][lj] = v;
g_SubstMx[uj][li] = v;
g_SubstMx[li][uj] = v;
g_SubstMx[lj][ui] = v;
g_SubstMx[li][lj] = v;
g_SubstMx[lj][li] = v;
}
for (unsigned i = 0; i < N; ++i)
{
for (unsigned j = 0; j < N; ++j)
{
if (i == '?' || j == '?')
g_SubstMx[i][j] = -9e9;
}
}
UNLOCK();
}
| 1,850
|
C++
|
.cpp
| 77
| 20.87013
| 52
| 0.584475
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,947
|
searchbitvec2.cpp
|
rcedgar_urmap/src/searchbitvec2.cpp
|
#include "myutils.h"
#include "bitvec.h"
#include "alpha.h"
#include "seqdb.h"
#include "objmgr.h"
#include "seqinfo.h"
#include "omplock.h"
#include <time.h>
#include "fastqseqsource.h"
static const uint MINCOUNT = 1;
static uint32 g_QueryCount;
static uint32 g_FoundCount;
static FILE *g_fOut1;
static FILE *g_fOut2;
bool SearchBitVec1(SeqInfo *Query, const BitVec &BV,
uint WordLength, uint64 ShiftMask);
static void SearchThread(FASTQSeqSource &FSS1, FASTQSeqSource &FSS2,
const BitVec &BV, uint WordLength, uint64 ShiftMask)
{
SeqInfo *Query1 = ObjMgr::GetSeqInfo();
SeqInfo *Query2 = ObjMgr::GetSeqInfo();
uint QueryCount = 0;
uint FoundCount = 0;
for (;;)
{
Lock();
bool Ok1 = FSS1.GetNext(Query1);
bool Ok2 = FSS2.GetNext(Query2);
Unlock();
if (!Ok1)
{
asserta(!Ok2);
break;
}
++QueryCount;
if (QueryCount%1000 == 0)
Progress_OnTick();
bool Found1 = SearchBitVec1(Query1, BV, WordLength, ShiftMask);
bool Found2 = SearchBitVec1(Query2, BV, WordLength, ShiftMask);
if (Found1 || Found2)
{
Lock();
Query1->ToFastq(g_fOut1);
Query2->ToFastq(g_fOut2);
Unlock();
++FoundCount;
}
}
Lock();
g_QueryCount += QueryCount;
g_FoundCount += FoundCount;
Unlock();
}
void cmd_search_bitvec2()
{
const string &QueryFileName1 = opt(search_bitvec2);
const string &QueryFileName2 = opt(reverse);
const string &BVFileName = opt(ref);
g_fOut1 = CreateStdioFile(opt(output1));
g_fOut2 = CreateStdioFile(opt(output2));
FILE *fRef = OpenStdioFile(BVFileName);
uint32 Magic;
ReadStdioFile(fRef, &Magic, sizeof(Magic));
if (Magic != BV_MAGIC)
Die("Invalid .bv file");
uint32 WordLength;
ReadStdioFile(fRef, &WordLength, sizeof(WordLength));
ProgressLog("Word length %u\n", WordLength);
uint64 BitCount = myipow64(4, WordLength);
ProgressLog("%" PRIu64 " bits (%s)\n", BitCount, Int64ToStr(BitCount));
BitVec BV;
BV.Alloc(BitCount);
ProgressOne("Reading bitvec");
ReadStdioFile64(fRef, BV.m_Vec, BitCount/8);
CloseStdioFile(fRef);
ProgressDone();
FASTQSeqSource FSS1;
FASTQSeqSource FSS2;
FSS1.Open(QueryFileName1);
FSS2.Open(QueryFileName2);
uint64 ShiftMask = 0;
for (unsigned i = 0; i < 2u*WordLength; ++i)
ShiftMask |= (uint64(1) << i);
time_t t1 = time(0);
unsigned ThreadCount = GetRequestedThreadCount();
ProgressFile(FSS1.m_LR.m_f, "Searching", QueryFileName1);
#pragma omp parallel num_threads(ThreadCount)
{
SearchThread(FSS1, FSS2, BV, WordLength, ShiftMask);
}
ProgressDone();
CloseStdioFile(g_fOut1);
CloseStdioFile(g_fOut2);
time_t t2 = time(0);
time_t Secs = t2 - t1;
if (Secs == 0)
Secs = 1;
double ReadsPerSec = double(g_QueryCount)/double(Secs);
ProgressLog("%u / %u found (%.1f%%)\n",
g_FoundCount, g_QueryCount, GetPct(g_FoundCount, g_QueryCount));
ProgressLog("Search time %s secs", Int64ToStr((uint64) Secs));
ProgressLog(", %s reads/sec\n",
FloatToStr(ReadsPerSec));
}
| 2,922
|
C++
|
.cpp
| 104
| 25.663462
| 72
| 0.722599
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,948
|
scanslots.cpp
|
rcedgar_urmap/src/scanslots.cpp
|
#include "myutils.h"
#include "alpha.h"
#include "seqinfo.h"
#include "ufindex.h"
#include "state1.h"
void State1::ScanSlots(uint32 DBLo, unsigned DBSegLength, bool Plus)
{
unsigned QL = m_Query->m_L;
unsigned QueryWordCount = QL - (m_WordLength - 1);
const uint64 *SlotsVec = (Plus ? m_SlotsVec_Plus : m_SlotsVec_Minus);
const byte *BlobVec = (Plus ? m_BlobVec_Plus : m_BlobVec_Minus);
if (QL <= m_WordLength*4)
return;
const byte *DBSegSeq = m_UFI->m_SeqData + DBLo;
const byte *Q = (Plus ? m_Query->m_Seq : m_RevCompQuerySeq.Data);
uint64 Word = 0;
byte K = 0;
for (uint32 DBPos = 0; DBPos < m_WordLength-1; ++DBPos)
{
byte c = DBSegSeq[DBPos];
byte Letter = g_CharToLetterNucleo[c];
if (Letter == INVALID_LETTER)
{
K = 0;
Word = 0;
continue;
}
if (K < m_WordLength)
++K;
Word = (Word << uint64(2)) | Letter;
}
for (uint32 DBPos = m_WordLength-1; DBPos < DBSegLength; ++DBPos)
{
byte c = DBSegSeq[DBPos];
byte Letter = g_CharToLetterNucleo[c];
if (Letter == INVALID_LETTER)
{
K = 0;
Word = 0;
continue;
}
if (K < m_WordLength)
++K;
Word = (Word << uint64(2)) | Letter;
if (K == m_WordLength)
{
uint64 Slot = WordToSlot(Word & m_ShiftMask, m_SlotCount);
for (unsigned k = 0; k < SCANK; ++k)
{
unsigned QPos = (k*PRIME_STRIDE)%QueryWordCount;
if (Slot == SlotsVec[QPos])
{
unsigned DBSeedPos = DBLo + DBPos - m_WordLength + 1;
ExtendScan(QPos, DBSeedPos, Plus);
}
}
}
}
}
| 1,505
|
C++
|
.cpp
| 59
| 22.271186
| 70
| 0.634789
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,949
|
search1m1.cpp
|
rcedgar_urmap/src/search1m1.cpp
|
#include "myutils.h"
#include "ufindex.h"
#include "seqinfo.h"
#include "alpha.h"
#include "state1.h"
#include "omplock.h"
#include <inttypes.h>
void State1::Search1(SeqInfo *Query)
{
m_Query = Query;
m_HitCount = 0;
m_HSPCount = 0;
m_TopHit = 0;
m_BestScore = 0;
m_SecondBestScore = 0;
m_Mapq = -1;
Search1_Lo(Query);
Output1();
Unlock();
}
bool State1::Search1_Lo(SeqInfo *Query)
{
const byte *Q = m_Query->m_Seq;
const unsigned QL = m_Query->m_L;
unsigned QWordCount = QL - (m_WordLength - 1);
m_BestHSPScore = 0;
m_AllocBuffOffset = 0;
uint64 *SlotsVec_Plus = alloc_buff(uint64, QL);
uint64 *SlotsVec_Minus = alloc_buff(uint64, QL);
byte *BlobVec_Plus = alloc_buff(byte, 5*QL);
byte *BlobVec_Minus = alloc_buff(byte, 5*QL);
SetSlotsVec(Q, QL, SlotsVec_Plus);
m_RevCompQuerySeq.Alloc(QL);
RevCompSeq(Q, QL, m_RevCompQuerySeq.Data);
const byte *QRC = m_RevCompQuerySeq.Data;
SetSlotsVec(QRC, QL, SlotsVec_Minus);
// ========================== Start Phase 1 =============================
// Extend BOTH1 seeds with stride = word length
for (uint32 QPos = 0; QPos < QWordCount; QPos += m_WordLength)
{
{/// Plus
uint64 Slot = SlotsVec_Plus[QPos];
if (Slot == UINT64_MAX)
{
BlobVec_Plus[5*QPos] = TALLY_FREE;
goto Minus1;
}
m_UFI->GetBlob(Slot, BlobVec_Plus + 5*QPos);
byte T = BlobVec_Plus[5*QPos];
if (T != TALLY_BOTH1)
goto Minus1;
uint32 SeedPosDB = *(uint32 *) (BlobVec_Plus + 5*QPos + 1);
bool Yes = ExtendExact(QPos, SeedPosDB, true);
if (Yes)
return true;
}
Minus1:
{///Minus
uint64 Slot = SlotsVec_Minus[QPos];
if (Slot == UINT64_MAX)
{
BlobVec_Minus[5*QPos] = TALLY_FREE;
continue;
}
m_UFI->GetBlob(Slot, BlobVec_Minus + 5*QPos);
byte T = BlobVec_Minus[5*QPos];
if (T != TALLY_BOTH1)
continue;
uint32 SeedPosDB = *(uint32 *) (BlobVec_Minus + 5*QPos + 1);
bool Yes = ExtendExact(QPos, SeedPosDB, false);
if (Yes)
return true;
}
}
// ========================== Start Phase 2 =============================
// Extend BOTH1 seeds not tried in Phase 1
for (uint32 QPos = 0; QPos < QWordCount; ++QPos)
{
if (QPos%m_WordLength == 0)
continue;
{/// Plus
uint64 Slot = SlotsVec_Plus[QPos];
if (Slot == UINT64_MAX)
{
BlobVec_Plus[5*QPos] = TALLY_FREE;
goto Minus2;
}
m_UFI->GetBlob(Slot, BlobVec_Plus + 5*QPos);
byte T = BlobVec_Plus[5*QPos];
if (T != TALLY_BOTH1)
goto Minus2;
uint32 SeedPosDB = *(uint32 *) (BlobVec_Plus + 5*QPos + 1);
bool Yes = ExtendExact(QPos, SeedPosDB, true);
if (Yes)
return true;
}
Minus2:
{///Minus
uint64 Slot = SlotsVec_Minus[QPos];
if (Slot == UINT64_MAX)
{
BlobVec_Minus[5*QPos] = TALLY_FREE;
continue;
}
m_UFI->GetBlob(Slot, BlobVec_Minus + 5*QPos);
byte T = BlobVec_Minus[5*QPos];
if (T != TALLY_BOTH1)
continue;
uint32 SeedPosDB = *(uint32 *) (BlobVec_Minus + 5*QPos + 1);
bool Yes = ExtendExact(QPos, SeedPosDB, false);
if (Yes)
return true;
}
}
// ========================== End Phase 2 =============================
// ========================== Start Phase 4 =============================
// Extend seeds with ab<=2 except BOTH1.
// Save HSPs for later gapped extension.
uint32 *PosVec = alloc_buff(uint32, m_UFI->m_MaxIx);
unsigned TodoCount_Plus = 0;
uint32 *QPosTodoVec_Plus = alloc_buff(uint32, QL);
{//plus
for (uint32 QPos = 0; QPos < QWordCount; ++QPos)
{
byte T = BlobVec_Plus[5*QPos];
if (T == TALLY_FREE || T == TALLY_BOTH1 || TallyOther(T))
continue;
uint64 Slot = SlotsVec_Plus[QPos];
unsigned RowLength = m_UFI->GetRow_Blob(Slot, BlobVec_Plus + 5*QPos, PosVec);
if (RowLength > 2)
{
QPosTodoVec_Plus[TodoCount_Plus] = QPos;
++TodoCount_Plus;
continue;
}
for (unsigned RowIndex = 0; RowIndex < RowLength; ++RowIndex)
{
uint32 SeedPosDB = PosVec[RowIndex];
bool Yes = ExtendExact(QPos, SeedPosDB, true);
if (Yes)
return true;
}
} // end for QPos
} // end plus
unsigned TodoCount_Minus = 0;
uint32 *QPosTodoVec_Minus = alloc_buff(uint32, QL);
{//minus
for (uint32 QPos = 0; QPos < QWordCount; ++QPos)
{
byte T = BlobVec_Minus[5*QPos];
if (T == TALLY_FREE || T == TALLY_BOTH1 || TallyOther(T))
continue;
uint64 Slot = SlotsVec_Minus[QPos];
//TODO: cache blob
unsigned RowLength = m_UFI->GetRow_Blob(Slot, BlobVec_Minus + 5*QPos, PosVec);
if (RowLength > 2)
{
QPosTodoVec_Minus[TodoCount_Minus] = QPos;
++TodoCount_Minus;
continue;
}
for (unsigned RowIndex = 0; RowIndex < RowLength; ++RowIndex)
{
uint32 SeedPosDB = PosVec[RowIndex];
bool Yes = ExtendExact(QPos, SeedPosDB, false);
if (Yes)
return true;
}
} // end for QPos
} // end minus
// ========================== Start Phase 5 =============================
// Extend all other seeds, i.e. with ab>=2
{ // plus
for (unsigned TodoIndex = 0; TodoIndex < TodoCount_Plus; ++TodoIndex)
{
uint32 QPos = QPosTodoVec_Plus[TodoIndex];
uint64 Slot = SlotsVec_Plus[QPos];
unsigned RowLength = m_UFI->GetRow_Blob(Slot, BlobVec_Plus + 5*QPos, PosVec);
for (unsigned RowIndex = 0; RowIndex < RowLength; ++RowIndex)
{
uint32 SeedPosDB = PosVec[RowIndex];
bool Yes = ExtendExact(QPos, SeedPosDB, true);
if (Yes)
return true;
}
} // end for TodoIndex
} // end plus
{ // minus
for (unsigned TodoIndex = 0; TodoIndex < TodoCount_Minus; ++TodoIndex)
{
uint32 QPos = QPosTodoVec_Minus[TodoIndex];
uint64 Slot = SlotsVec_Minus[QPos];
unsigned RowLength = m_UFI->GetRow_Blob(Slot, BlobVec_Minus + 5*QPos, PosVec);
for (unsigned RowIndex = 0; RowIndex < RowLength; ++RowIndex)
{
uint32 SeedPosDB = PosVec[RowIndex];
bool Yes = ExtendExact(QPos, SeedPosDB, false);
if (Yes)
return true;
}
} // end for TodoIndex
} // end minus
return false;
}
| 5,819
|
C++
|
.cpp
| 204
| 25.563725
| 80
| 0.635763
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,950
|
getseed.cpp
|
rcedgar_urmap/src/getseed.cpp
|
#include "myutils.h"
#include "ufindex.h"
#include "seqinfo.h"
#include "alpha.h"
#include "state1.h"
#include "omplock.h"
#include <inttypes.h>
unsigned State1::GetFirstBoth1Seed(uint32 &QPos, bool &Plus, uint32 &DBPos)
{
unsigned QL = m_Query->m_L;
unsigned QueryWordCount = QL - (m_WordLength - 1);
for (unsigned k = 0; k < QueryWordCount; ++k)
{
QPos = (k*PRIME_STRIDE)%QueryWordCount;
{// Plus
uint64 Slot = m_SlotsVec_Plus[QPos];
if (Slot == UINT64_MAX)
goto Minus1;
m_UFI->GetBlob(Slot, m_BlobVec_Plus + 5*QPos);
byte T = m_BlobVec_Plus[5*QPos];
if (TallyOther(T))
goto Minus1;
if (T != TALLY_BOTH1)
{
m_QPosPendingVec_Plus[m_QPosPendingCount_Plus++] = QPos;
goto Minus1;
}
DBPos = *(uint32 *) (m_BlobVec_Plus + 5*QPos + 1);
Plus = true;
return k;
}
Minus1:
{// Minus
uint64 Slot = m_SlotsVec_Minus[QPos];
if (Slot == UINT64_MAX)
continue;
m_UFI->GetBlob(Slot, m_BlobVec_Minus + 5*QPos);
byte T = m_BlobVec_Minus[5*QPos];
if (TallyOther(T))
continue;
if (T != TALLY_BOTH1)
{
m_QPosPendingVec_Minus[m_QPosPendingCount_Minus++] = QPos;
continue;
}
DBPos = *(uint32 *) (m_BlobVec_Minus + 5*QPos + 1);
Plus = false;
return k;
}
}
return UINT_MAX;
}
unsigned State1::GetNextBoth1Seed(unsigned ak,
uint32 &aQPos, bool &Plus, uint32 &DBPos)
{
unsigned QL = m_Query->m_L;
unsigned QueryWordCount = QL - (m_WordLength - 1);
{
// Special case: if last BOTH1 seed was Plus=true, need to check
// minus strand at same position before incrementing k.
if (!Plus)
goto Skip;
unsigned QPos = (ak*PRIME_STRIDE)%QueryWordCount;
uint64 Slot = m_SlotsVec_Minus[QPos];
if (Slot == UINT64_MAX)
goto Skip;
m_UFI->GetBlob(Slot, m_BlobVec_Minus + 5*QPos);
byte T = m_BlobVec_Minus[5*QPos];
if (!TallyMine(T))
goto Skip;
if (T == TALLY_BOTH1)
{
uint32 NewDBPos = *(uint32 *) (m_BlobVec_Minus + 5*QPos + 1);
if (NewDBPos - QPos != DBPos - aQPos)
{
DBPos = NewDBPos;
aQPos = QPos;
Plus = false;
return ak;
}
else
m_QPosPendingVec_Minus[m_QPosPendingCount_Minus++] = QPos;
}
}
Skip:
for (unsigned k = ak + 1; k < QueryWordCount; ++k)
{
unsigned QPos = (k*PRIME_STRIDE)%QueryWordCount;
{// Plus
uint64 Slot = m_SlotsVec_Plus[QPos];
if (Slot == UINT64_MAX)
goto Minus1;
m_UFI->GetBlob(Slot, m_BlobVec_Plus + 5*QPos);
byte T = m_BlobVec_Plus[5*QPos];
if (TallyOther(T))
goto Minus1;
if (T != TALLY_BOTH1)
{
m_QPosPendingVec_Plus[m_QPosPendingCount_Plus++] = QPos;
goto Minus1;
}
uint32 NewDBPos = *(uint32 *) (m_BlobVec_Plus + 5*QPos + 1);
if (NewDBPos - QPos == DBPos - aQPos)
goto Minus1;
DBPos = NewDBPos;
aQPos = QPos;
Plus = true;
return k;
}
Minus1:
{// Minus
uint64 Slot = m_SlotsVec_Minus[QPos];
if (Slot == UINT64_MAX)
continue;
m_UFI->GetBlob(Slot, m_BlobVec_Minus + 5*QPos);
byte T = m_BlobVec_Minus[5*QPos];
if (TallyOther(T))
continue;
if (T != TALLY_BOTH1)
{
m_QPosPendingVec_Minus[m_QPosPendingCount_Minus++] = QPos;
continue;
}
uint32 NewDBPos = *(uint32 *) (m_BlobVec_Minus + 5*QPos + 1);
if (NewDBPos - QPos == DBPos - aQPos)
continue;
DBPos = NewDBPos;
aQPos = QPos;
Plus = false;
return k;
}
}
return UINT32_MAX;
}
void State1::GetBoth1Seeds(vector<unsigned> &QPosVec,
vector<uint32> &DBPosVec, vector<bool> &PlusVec, vector<uint64> &DiagVec)
{
QPosVec.clear();
DBPosVec.clear();
PlusVec.clear();
DiagVec.clear();
unsigned QL = m_Query->m_L;
unsigned QueryWordCount = QL - (m_WordLength - 1);
for (unsigned QPos = 0; QPos < QueryWordCount; ++QPos)
{
for (int iPlus = 0; iPlus < 2; ++iPlus)
{
bool Plus = (iPlus == 0);
const uint64 *SlotsVec = (Plus ? m_SlotsVec_Plus : m_SlotsVec_Minus);
uint64 Slot = SlotsVec[QPos];
if (Slot == UINT64_MAX)
continue;
byte T = m_UFI->GetTally(Slot);
if (T != TALLY_BOTH1)
continue;
unsigned RowLength = m_UFI->GetRow(Slot, m_PosVec);
asserta(RowLength == 1);
uint32 DBPos = m_PosVec[0];
uint64 Diag = uint64(DBPos) - uint64(QPos);
bool Found = false;
for (unsigned i = 0; i < SIZE(DiagVec); ++i)
if (DiagVec[i] == Diag)
{
Found = true;
break;
}
if (!Found)
DiagVec.push_back(Diag);
QPosVec.push_back(QPos);
DBPosVec.push_back(DBPos);
PlusVec.push_back(Plus);
}
}
}
unsigned State1::GetFirstBoth1SeedEx(uint32 &QPos,
bool &Plus, uint32 &DBPos)
{
unsigned k = GetFirstBoth1Seed(QPos, Plus, DBPos);
while (k != UINT_MAX)
{
int Score = ExtendPen(QPos, DBPos, Plus);
if (Score != -1)
return k;
k = GetNextBoth1Seed(k, QPos, Plus, DBPos);
}
return UINT_MAX;
}
unsigned State1::GetNextBoth1SeedEx(unsigned k, uint32 &QPos,
bool &Plus, uint32 &DBPos)
{
uint64 LastDiag = uint64(DBPos) - uint64(QPos);
for (;;)
{
k = GetNextBoth1Seed(k, QPos, Plus, DBPos);
if (k == UINT_MAX)
return UINT_MAX;
uint64 Diag = uint64(DBPos) - uint64(QPos);
if (Diag == LastDiag)
continue;
int Score = ExtendPen(QPos, DBPos, Plus);
if (Score != -1)
return k;
}
return UINT_MAX;
}
| 5,103
|
C++
|
.cpp
| 205
| 21.829268
| 76
| 0.656097
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,951
|
alnparams.cpp
|
rcedgar_urmap/src/alnparams.cpp
|
#include "myutils.h"
#include <float.h> // for FLT_MAX
#include "mx.h"
#include "alnparams.h"
#include "alnheuristics.h"
#include "hsp.h"
#include "omplock.h"
#define TEST 0
void SetNucSubstMx(double Match, double Mismatch);
extern Mx<float> g_SubstMxf;
extern float **g_SubstMx;
static AlnParams g_AP;
static AlnHeuristics g_AH;
static bool g_InitGlobalsDone;
void ResetGlobalAPAH(bool Nucleo)
{
LOCK();
g_AP.InitFromCmdLine(Nucleo);
g_AH.InitFromCmdLine(g_AP);
UNLOCK();
}
const AlnHeuristics *AlnHeuristics::GetGlobalAH()
{
asserta(g_InitGlobalsDone);
return &g_AH;
}
const AlnParams *AlnParams::GetGlobalAP()
{
asserta(g_InitGlobalsDone);
return &g_AP;
}
void InitGlobals(bool Nucleo)
{
LOCK();
if (g_InitGlobalsDone)
{
UNLOCK();
return;
}
g_AP.InitFromCmdLine(Nucleo);
g_AH.InitFromCmdLine(g_AP);
g_InitGlobalsDone = true;
UNLOCK();
}
const float * const *AlnParams::GetSubstMx()
{
asserta(g_SubstMx != 0);
return g_SubstMx;
}
void AlnParams::Clear()
{
SubstMxName = 0;
LocalOpen = OBVIOUSLY_WRONG_PENALTY;
LocalExt = OBVIOUSLY_WRONG_PENALTY;
OpenA = OBVIOUSLY_WRONG_PENALTY;
OpenB = OBVIOUSLY_WRONG_PENALTY;
ExtA = OBVIOUSLY_WRONG_PENALTY;
ExtB = OBVIOUSLY_WRONG_PENALTY;
LOpenA = OBVIOUSLY_WRONG_PENALTY;
LOpenB = OBVIOUSLY_WRONG_PENALTY;
ROpenA = OBVIOUSLY_WRONG_PENALTY;
ROpenB = OBVIOUSLY_WRONG_PENALTY;
LExtA = OBVIOUSLY_WRONG_PENALTY;
LExtB = OBVIOUSLY_WRONG_PENALTY;
RExtA = OBVIOUSLY_WRONG_PENALTY;
RExtB = OBVIOUSLY_WRONG_PENALTY;
Nucleo = false;
NucleoSet = false;
}
bool AlnParams::Is2() const
{
float g = OpenA;
float e = ExtA;
if (OpenB != g || LOpenA != g || LOpenB != g || ROpenA != g || ROpenB != g)
return false;
if (ExtB != e || LExtA != e || LExtB != e || RExtA != e || RExtB != e)
return false;
return true;
}
bool AlnParams::Is4() const
{
float g = OpenA;
float tg = LOpenA;
float e = ExtA;
float te = LExtA;
if (OpenB != g || LOpenA != tg || LOpenB != tg || ROpenA != tg || ROpenB != tg)
return false;
if (ExtB != e || LExtA != te || LExtB != te || RExtA != te || RExtB != te)
return false;
return true;
}
const char *AlnParams::GetType() const
{
if (Is2())
return "2";
else if (Is4())
return "4";
return "12";
}
void AlnParams::Init2(const float * const *Mx, float Open, float Ext)
{
SubstMx = Mx;
OpenA = OpenB = LOpenA = LOpenB = ROpenA = ROpenB = Open;
ExtA = ExtB = LExtA = LExtB = RExtA = RExtB = Ext;
}
void AlnParams::SetLocal(float Open, float Ext)
{
LocalOpen = Open;
LocalExt = Ext;
}
void AlnParams::Init4(const float * const *Mx, float Open, float Ext,
float TermOpen, float TermExt)
{
SubstMx = Mx;
OpenA = OpenB = Open;
LOpenA = LOpenB = ROpenA = ROpenB = TermOpen;
ExtA = ExtB = Ext;
LExtA = LExtB = RExtA = RExtB = TermExt;
}
void AlnParams::Init(const AlnParams &AP, const HSPData &HSP,
unsigned LA, unsigned LB)
{
SubstMx = AP.SubstMx;
OpenA = AP.OpenA;
OpenB = AP.OpenB;
ExtA = AP.ExtA;
ExtB = AP.ExtB;
if (HSP.LeftA())
{
LOpenA = AP.LOpenA;
LExtA = AP.LExtA;
}
else
{
LOpenA = AP.OpenA;
LExtA = AP.ExtA;
}
if (HSP.LeftB())
{
LOpenB = AP.LOpenB;
LExtB = AP.LExtB;
}
else
{
LOpenB = AP.OpenB;
LExtB = AP.ExtB;
}
if (HSP.RightA(LA))
{
ROpenA = AP.ROpenA;
RExtA = AP.RExtA;
}
else
{
ROpenA = AP.OpenA;
RExtA = AP.ExtA;
}
if (HSP.RightB(LB))
{
ROpenB = AP.ROpenB;
RExtB = AP.RExtB;
}
else
{
ROpenB = AP.OpenB;
RExtB = AP.ExtB;
}
}
void AlnParams::LogMe() const
{
Log("AlnParams(%s)", GetType());
Log(" Nuc %c", NucleoSet ? tof(Nucleo) : '?');
if (SubstMx == 0)
Log(" SubstMx NULL");
else
{
Log(" AA %.1f, AT %.1f, LV %.1f\n",
SubstMx['A']['A'],
SubstMx['A']['T'],
SubstMx['L']['V']);
}
if (Is2())
Log(" g=%.1f e=%.1f", -OpenA, -ExtA);
else if (Is4())
Log(" g=%.1f tg=%.1f e=%.1f te=%.1f", -OpenA, -ExtA, -LOpenA, -LExtA);
else
Log(
" gA=%.1f gB=%.1f gAL=%.1f gBL=%.1f gAR=%.1f gBR=%.1f eA=%.1f eB=%.1f eAL=%.1f eBL=%.1f eAR=%.1f eBR=%.1f",
OpenA, OpenB, LOpenA, LOpenB, ROpenA, ROpenB, ExtA, ExtB, LExtA, LExtB, RExtA, RExtB);
Log("\n");
}
/***
Open/Ext format string is one or more:
[<flag><flag>...]<value>
Value is (positive) penalty or * (disabled).
Flag is:
Q Query.
T Target sequence.
I Internal gaps (defafault internal and terminal).
E End gaps (default internal and terminal).
L Left end.
R Right end.
***/
static void ParseGapStr(const string &s,
float &QI, float &QL, float &QR,
float &TI, float &TL, float &TR)
{
if (s.empty())
return;
bool Q = false;
bool T = false;
bool I = false;
bool E = false;
bool L = false;
bool R = false;
const unsigned K = SIZE(s);
unsigned Dec = 0;
float Value = FLT_MAX;
for (unsigned i = 0; i <= K; ++i)
{
char c = s.c_str()[i];
if (c == 0 || c == '/')
{
if (Value == FLT_MAX)
Die("Invalid gap penalty string, missing penalty '%s'", s.c_str());
if (!Q && !T && !I && !E && !L && !R)
{
Q = true;
T = true;
L = true;
R = true;
I = true;
}
if (!E && !I && !L && !R)
{
E = false;
I = true;
L = true;
R = true;
}
if (E)
{
if (L || R)
Die("Invalid gap penalty string (E and L or R) '%s'", s.c_str());
L = true;
R = true;
}
if (!Q && !T)
{
Q = true;
T = true;
}
if (Q && L)
QL = -Value;
if (Q && R)
QR = -Value;
if (Q && I)
QI = -Value;
if (T && L)
TL = -Value;
if (T && R)
TR = -Value;
if (T && I)
TI = -Value;
Value = FLT_MAX;
Dec = 0;
Q = false;
T = false;
I = false;
E = false;
L = false;
R = false;
}
else if (c == '*')
{
if (Value != FLT_MAX)
Die("Invalid gap penalty (* in floating point number) '%s'", s.c_str());
Value = -MINUS_INFINITY;
}
else if (isdigit(c))
{
if (Value == -MINUS_INFINITY)
Die("Invalid gap penalty (* in floating point number) '%s'", s.c_str());
if (Value == FLT_MAX)
Value = 0.0;
if (Dec > 0)
{
Dec *= 10;
Value += float(c - '0')/Dec;
}
else
Value = Value*10 + (c - '0');
}
else if (c == '.')
{
if (Dec > 0)
Die("Invalid gap penalty (two decimal points) '%s'", s.c_str());
Dec = 1;
}
else
{
switch (c)
{
case 'Q':
Q = true;
break;
case 'T':
T = true;
break;
case 'I':
I = true;
break;
case 'L':
L = true;
break;
case 'R':
R = true;
break;
case 'E':
E = true;
break;
default:
Die("Invalid char '%c' in gap penalty string '%s'", c, s.c_str());
}
}
}
}
void AlnParams::SetPenalties(const string &OpenStr, const string &ExtStr)
{
ParseGapStr(OpenStr, OpenA, LOpenA, ROpenA, OpenB, LOpenB, ROpenB);
ParseGapStr(ExtStr, ExtA, LExtA, RExtA, ExtB, LExtB, RExtB);
}
void AlnParams::SetMxFromCmdLine(bool IsNucleo)
{
SetNucSubstMx(opt(match), opt(mismatch));
SubstMx = g_SubstMx;
asserta(SubstMx != 0);
}
void AlnParams::InitFromCmdLine(bool IsNucleo)
{
Clear();
Nucleo = IsNucleo;
NucleoSet = true;
SetMxFromCmdLine(IsNucleo);
// Local
if (optset_lopen || optset_lext)
{
if (!optset_lopen || !optset_lext)
Die("Must set both --lopen and --lext");
if (opt(lopen) < 0.0 || opt(lext) < 0.0)
Die("Invalid --lopen/--lext, gap penalties must be >= 0");
SetLocal(float(-opt(lopen)), float(-opt(lext)));
}
else
{
// Same penalties, if-statement to note could differ.
if (IsNucleo)
SetLocal(-10.0f, -1.0f);
else
SetLocal(-10.0f, -1.0f);
}
// Global
if (IsNucleo)
Init4(g_SubstMx, -10.0, -1.0, -0.5, -0.5);
else
Init4(g_SubstMx, -17.0, -1.0, -0.5, -0.5);
SetPenalties(opt(gapopen), opt(gapext));
}
float AlnParams::GetLocalOpen() const
{
return LocalOpen;
}
float AlnParams::GetLocalExt() const
{
return LocalExt;
}
bool AlnParams::GetIsNucleo() const
{
asserta(NucleoSet);
return Nucleo;
}
float AlnParams::ScoreLocalPathMasked(const byte *A, const byte *B, const char *Path) const
{
const byte *a = A;
const byte *b = B;
float Score = 0.0;
char LastState = 'M';
for (const char *p = Path; *p; ++p)
{
char State = *p;
if (State == 'M')
{
byte ca = *a++;
byte cb = *b++;
if (isupper(ca) && isupper(cb))
Score += SubstMx[ca][cb];
}
else if (State == 'D')
{
Score += (LastState == 'M' ? LocalOpen : LocalExt);
++a;
}
else if (State == 'I')
{
Score += (LastState == 'M' ? LocalOpen : LocalExt);
++b;
}
LastState = State;
}
return Score;
}
float AlnParams::ScoreLocalPathIgnoreMask(const byte *A, const byte *B, const char *Path) const
{
const byte *a = A;
const byte *b = B;
float Score = 0.0;
char LastState = 'M';
for (const char *p = Path; *p; ++p)
{
char State = *p;
if (State == 'M')
{
byte ca = toupper(*a++);
byte cb = toupper(*b++);
Score += SubstMx[ca][cb];
}
else if (State == 'D')
{
Score += (LastState == 'M' ? LocalOpen : LocalExt);
++a;
}
else if (State == 'I')
{
Score += (LastState == 'M' ? LocalOpen : LocalExt);
++b;
}
LastState = State;
}
return Score;
}
| 9,132
|
C++
|
.cpp
| 440
| 17.8
| 107
| 0.607614
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| true
| false
| false
|
1,537,952
|
xdropbwdmem.cpp
|
rcedgar_urmap/src/xdropbwdmem.cpp
|
#include "myutils.h"
#include "mx.h"
#include "alnparams.h"
#include "xdpmem.h"
#include "pathinfo.h"
#define TRACE 0
float XDropFwdFastMem(XDPMem &Mem, const byte *A, unsigned LA, const byte *B, unsigned LB,
const AlnParams &AP, float X, unsigned &Leni, unsigned &Lenj, PathInfo &PI);
//static byte *g_RevA;
//static byte *g_RevB;
//static unsigned g_RevASize;
//static unsigned g_RevBSize;
//
static void RevSeq(const byte *s, byte *r, unsigned L)
{
for (unsigned i = 0; i < L; ++i)
r[i] = s[L-i-1];
}
float XDropBwdFastMem(XDPMem &Mem, const byte *A, unsigned LA, const byte *B, unsigned LB,
const AlnParams &AP, float X, unsigned &Leni, unsigned &Lenj,
PathInfo &PI)
{
#if TRACE
Log("\n");
Log("===========================================\n");
Log("XDropBwdFastMem()\n");
Log(" A %2u %*.*s\n", LA, LA, LA, A);
Log(" B %2u %*.*s\n", LB, LB, LB, B);
#endif
Mem.Alloc(LA, LB);
StartTimer(XDropBwd);
byte *RevA = Mem.GetRevA();
byte *RevB = Mem.GetRevB();
RevSeq(A, RevA, LA);
RevSeq(B, RevB, LB);
#if TRACE
Log("RevA %2u %*.*s\n", LA, LA, LA, RevA);
Log("RevB %2u %*.*s\n", LB, LB, LB, RevB);
#endif
EndTimer(XDropBwd);
float Score = XDropFwdFastMem(Mem, RevA, LA, RevB, LB, AP, X, Leni, Lenj, PI);
#if TRACE
Log("XDropFwdFastMem Score %.1f, Leni %u, Lenj %u\n", Score, Leni, Lenj);
#endif
if (Score <= 0.0)
return Score;
#if DEBUG
{
unsigned M, D, I;
PI.GetCounts(M, D, I);
asserta(M + D == Leni);
asserta(M + I == Lenj);
}
#endif
StartTimer(XDropBwd);
PI.Reverse();
#if DEBUG
{
unsigned M, D, I;
PI.GetCounts(M, D, I);
asserta(M + D == Leni);
asserta(M + I == Lenj);
}
#endif
#if TRACE
LogAln((const byte *) A + LA - Leni, (const byte *) B + LB - Lenj, PI.m_Path);
#endif
EndTimer(XDropBwd);
return Score;
}
| 1,768
|
C++
|
.cpp
| 70
| 23.5
| 90
| 0.634002
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,953
|
fastaseqsource.cpp
|
rcedgar_urmap/src/fastaseqsource.cpp
|
#include "myutils.h"
#include "fastaseqsource.h"
#include "seqinfo.h"
#include "alpha.h"
#include "omplock.h"
bool FastaFileIsNucleo(FILE *f);
FASTASeqSource::FASTASeqSource()
{
}
FASTASeqSource::~FASTASeqSource()
{
}
bool FASTASeqSource::GetIsNucleo()
{
FILE *f = m_LR.m_f;
asserta(f != 0);
return FastaFileIsNucleo(f);
}
// Caller must own memory because SeqSource may be shared
// between threads, so SeqInfo should be thread-private.
bool FASTASeqSource::GetNextLo(SeqInfo *SI)
{
if (m_LR.m_EOF)
return false;
bool TruncLabels = opt(trunclabels);
// Outer for loop just to allow skipping of empty sequences
for (;;)
{
// Special case at start of file
if (m_LR.m_LineNr == 0)
{
bool Ok = ReadLine();
if (!Ok)
return false;
}
unsigned SeqIndex = m_SeqCount;
SI->Init(SeqIndex);
SI->m_Qual = 0;
const char *Line = m_LineBuff.Data;
unsigned n = m_LineBuff.Size;
if (n == 0)
{
bool Ok = ReadLine();
if (!Ok)
return false;
asserta(n > 0);
}
if (Line[0] != '>')
Die("Bad FASTA file %s, expected '>' in line %u",
GetFileNameC(), m_LR.m_LineNr);
SI->AllocLabel(n);
char *Label = SI->m_LabelBuffer;
for (unsigned i = 1; i < n; ++i)
{
byte c = Line[i];
if (TruncLabels && isspace(c))
{
Label[i-1] = 0;
break;
}
Label[i-1] = c;
}
Label[n-1] = 0;
unsigned SeqLength = 0;
for (;;)
{
bool Ok = ReadLine();
if (!Ok)
break;
const char *Line = m_LineBuff.Data;
unsigned n = m_LineBuff.Size;
if (n > 0 && Line[0] == '>')
break;
SI->m_L = SeqLength;
SI->AllocSeq(SeqLength + n);
byte *Seq = SI->m_SeqBuffer;
for (unsigned i = 0; i < n; ++i)
{
byte c = (byte) Line[i];
if (isspace(c))
continue;
if (c == '-' || c == '.')
{
if (m_StripGaps)
continue;
}
else if (!isalpha(c))
{
BadByte(c);
continue;
}
Seq[SeqLength++] = c;
}
}
SI->m_L = SeqLength;
if (SeqLength > 0)
return true;
else
{
Warning("Empty sequence at line %u in FASTA file %s, label >%s",
GetLineNr(), GetFileNameC(), SI->m_Label);
continue;
}
}
}
| 2,167
|
C++
|
.cpp
| 105
| 17.028571
| 67
| 0.598441
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| true
| false
| true
| false
|
1,537,954
|
searchbitvec.cpp
|
rcedgar_urmap/src/searchbitvec.cpp
|
#include "myutils.h"
#include "bitvec.h"
#include "alpha.h"
#include "seqdb.h"
#include "objmgr.h"
#include "seqinfo.h"
#include "omplock.h"
#include <time.h>
#include "fastqseqsource.h"
static const uint MINCOUNT = 1;
static uint32 g_QueryCount;
static uint32 g_FoundCount;
static FILE *g_fOut;
bool SearchBitVec1(SeqInfo *Query, const BitVec &BV,
uint WordLength, uint64 ShiftMask)
{
const uint64 BitCount = BV.m_BitCount;
const uint L = Query->m_L;
const byte *Seq = Query->m_Seq;
for (int Strand = 0; Strand <= 1; ++Strand)
{
if (Strand == 1)
Query->RevCompInPlace();
uint Count = 0;
uint64 Word = 0;
byte K = 0;
for (uint SeqPos = 0; SeqPos < L - WordLength + 1; ++SeqPos)
{
byte c = Seq[SeqPos];
byte Letter = g_CharToLetterNucleo[c];
if (Letter == INVALID_LETTER)
{
K = 0;
Word = 0;
continue;
}
if (K < WordLength)
++K;
Word = ((Word << uint64(2)) | Letter) & ShiftMask;
if (K == WordLength)
{
if (BV.GetBit(Word))
{
uint StartPos = SeqPos - WordLength + 1;
++Count;
if (Count >= MINCOUNT)
return true;
K = 0;
Word = 0;
}
}
}
}
return false;
}
static void SearchThread(FASTQSeqSource &FSS, const BitVec &BV,
uint WordLength, uint64 ShiftMask)
{
SeqInfo *Query = ObjMgr::GetSeqInfo();
uint QueryCount = 0;
uint FoundCount = 0;
while (FSS.GetNext(Query))
{
if (QueryCount%1000 == 0)
Progress_OnTick();
++QueryCount;
bool Found = SearchBitVec1(Query, BV, WordLength, ShiftMask);
if (Found)
{
Lock();
Query->ToFastq(g_fOut);
Unlock();
++FoundCount;
}
}
Lock();
g_QueryCount += QueryCount;
g_FoundCount += FoundCount;
Unlock();
}
void cmd_search_bitvec()
{
const string &QueryFileName = opt(search_bitvec);
const string &BVFileName = opt(ref);
g_fOut = CreateStdioFile(opt(output));
FILE *fRef = OpenStdioFile(BVFileName);
uint32 Magic;
ReadStdioFile(fRef, &Magic, sizeof(Magic));
if (Magic != BV_MAGIC)
Die("Invalid .bv file");
uint32 WordLength;
ReadStdioFile(fRef, &WordLength, sizeof(WordLength));
ProgressLog("Word length %u\n", WordLength);
uint64 BitCount = myipow64(4, WordLength);
ProgressLog("%" PRIu64 " bits (%s)\n", BitCount, Int64ToStr(BitCount));
BitVec BV;
BV.Alloc(BitCount);
ProgressOne("Reading bitvec");
ReadStdioFile64(fRef, BV.m_Vec, BitCount/8);
CloseStdioFile(fRef);
ProgressDone();
FASTQSeqSource FSS;
FSS.Open(QueryFileName);
uint64 ShiftMask = 0;
for (unsigned i = 0; i < 2u*WordLength; ++i)
ShiftMask |= (uint64(1) << i);
time_t t1 = time(0);
unsigned ThreadCount = GetRequestedThreadCount();
ProgressFile(FSS.m_LR.m_f, "Searching", QueryFileName);
#pragma omp parallel num_threads(ThreadCount)
{
SearchThread(FSS, BV, WordLength, ShiftMask);
}
ProgressDone();
CloseStdioFile(g_fOut);
time_t t2 = time(0);
time_t Secs = t2 - t1;
if (Secs == 0)
Secs = 1;
double ReadsPerSec = double(g_QueryCount)/double(Secs);
ProgressLog("%u / %u found (%.1f%%)\n",
g_FoundCount, g_QueryCount, GetPct(g_FoundCount, g_QueryCount));
ProgressLog("Search time %s secs", Int64ToStr((uint64) Secs));
ProgressLog(", %s reads/sec\n",
FloatToStr(ReadsPerSec));
}
| 3,206
|
C++
|
.cpp
| 126
| 22.555556
| 72
| 0.68167
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,955
|
cmdline.cpp
|
rcedgar_urmap/src/cmdline.cpp
|
#include "myutils.h"
void CompilerInfo();
vector<string> g_Argv;
#define FLAG_OPT(Name) bool opt_##Name; bool optset_##Name; bool optused_##Name;
#define UNS_OPT(Name, Default, Min, Max) unsigned opt_##Name; bool optset_##Name; bool optused_##Name;
#define FLT_OPT(Name, Default, Min, Max) double opt_##Name; bool optset_##Name; bool optused_##Name;
#define STR_OPT(Name) string opt_##Name; bool optset_##Name; bool optused_##Name;
#include "myopts.h"
static void CheckUsedOpt(bool Set, bool Used, const char *Name)
{
if (Set && !Used)
Warning("Option -%s not used", Name);
}
void CheckUsedOpts(bool LogAll)
{
#define FLAG_OPT(Name) CheckUsedOpt(optset_##Name, optused_##Name, #Name);
#define UNS_OPT(Name, Default, Min, Max) CheckUsedOpt(optset_##Name, optused_##Name, #Name);
#define FLT_OPT(Name, Default, Min, Max) CheckUsedOpt(optset_##Name, optused_##Name, #Name);
#define STR_OPT(Name) CheckUsedOpt(optset_##Name, optused_##Name, #Name);
#include "myopts.h"
}
static void CmdLineErr(const char *Format, ...)
{
fprintf(stderr, "\n\n");
va_list ArgList;
va_start(ArgList, Format);
fprintf(stderr, "Invalid command line\n");
vfprintf(stderr, Format, ArgList);
fprintf(stderr, "\n\n");
va_end(ArgList);
exit(1);
}
static void GetArgsFromFile(const string &FileName, vector<string> &Args)
{
Args.clear();
FILE *f = OpenStdioFile(FileName);
string Line;
while (ReadLineStdioFile(f, Line))
{
size_t n = Line.find('#');
if (n != string::npos)
Line = Line.substr(0, n);
vector<string> Fields;
Split(Line, Fields, 0);
Args.insert(Args.end(), Fields.begin(), Fields.end());
}
CloseStdioFile(f);
}
static bool TryFlagOpt(const char *OptName)
{
#define FLAG_OPT(Name) if (strcmp(OptName, #Name) == 0) { opt_##Name = true; optset_##Name = true; return true; }
#define UNS_OPT(Name, Default, Min, Max) /* empty */
#define FLT_OPT(Name, Default, Min, Max) /* empty */
#define STR_OPT(Name) /* empty */
#include "myopts.h"
return false;
}
static bool TryUnsOpt(const char *OptName, const char *Value)
{
#define UNS_OPT(Name, Default, Min, Max) if (strcmp(OptName, #Name) == 0) { opt_##Name = StrToUint(Value); optset_##Name = true; return true; }
#define FLAG_OPT(Name) /* empty */
#define FLT_OPT(Name, Default, Min, Max) /* empty */
#define STR_OPT(Name) /* empty */
#include "myopts.h"
return false;
}
static bool TryFloatOpt(const char *OptName, const char *Value)
{
#define FLT_OPT(Name, Default, Min, Max) if (strcmp(OptName, #Name) == 0) { opt_##Name = StrToFloat(Value); optset_##Name = true; return true; }
#define UNS_OPT(Name, Default, Min, Max) /* empty */
#define FLAG_OPT(Name) /* empty */
#define STR_OPT(Name) /* empty */
#include "myopts.h"
return false;
}
static bool TryStrOpt(const char *OptName, const char *Value)
{
#define STR_OPT(Name) if (strcmp(OptName, #Name) == 0) { opt_##Name = mystrsave(Value); optset_##Name = true; return true; }
#define UNS_OPT(Name, Default, Min, Max) /* empty */
#define FLT_OPT(Name, Default, Min, Max) /* empty */
#define FLAG_OPT(Name) /* empty */
#include "myopts.h"
return false;
}
static bool IsVectorOpt(const char *Opt)
{
if (*Opt != '-')
return false;
const char *OptName = Opt + 1;
#define STR_OPT(Name) /* empty */
#define UNS_OPT(Name, Default, Min, Max) /* empty */
#define FLT_OPT(Name, Default, Min, Max) /* empty */
#define FLAG_OPT(Name) /* empty */
#define VECTOR_OPT(Name) if (strcmp(OptName, #Name) == 0) return true;
#include "myopts.h"
return false;
}
static void MergeVectorArgs()
{
vector<string> NewArgs;
unsigned ArgCount = SIZE(g_Argv);
unsigned i = 0;
for (;;)
{
if (i >= ArgCount)
break;
const string &Arg = g_Argv[i];
NewArgs.push_back(Arg);
++i;
if (IsVectorOpt(Arg.c_str()))
{
string Value;
for (;;)
{
if (i >= ArgCount)
break;
const string &a = g_Argv[i];
if (StartsWith(a, "-"))
break;
if (!Value.empty())
Value += " ";
Value += a;
++i;
}
NewArgs.push_back(Value);
}
}
g_Argv = NewArgs;
}
void MyCmdLine(int argc, char **argv)
{
if (argc == 1)
{
Help();
return;
}
#define UNS_OPT(Name, Default, Min, Max) opt_##Name = Default;
#define FLT_OPT(Name, Default, Min, Max) opt_##Name = Default;
#define FLAG_OPT(Name) /* empty */
#define STR_OPT(Name) /* empty */
#include "myopts.h"
for (unsigned i = 0; i < (unsigned) argc; )
{
const string &Arg = argv[i];
if (Arg == "file:" && i + 1 < (unsigned) argc)
{
const string &FileName = argv[i+1];
vector<string> Args;
GetArgsFromFile(FileName, Args);
for (unsigned k = 0; k < SIZE(Args); ++k)
g_Argv.push_back(Args[k]);
i += 2;
}
else
{
g_Argv.push_back(Arg);
i += 1;
}
}
MergeVectorArgs();
const unsigned ArgCount = SIZE(g_Argv);
unsigned ArgIndex = 1;
for (;;)
{
if (ArgIndex >= ArgCount)
break;
const string &Arg = g_Argv[ArgIndex];
if (Arg.size() > 1 && Arg[0] == '-')
{
string LongName = (Arg.size() > 2 && Arg[1] == '-' ? Arg.substr(2) : Arg.substr(1));
if (LongName == "version")
{
void cmd_version();
cmd_version();
return;
}
if (IsVectorOpt(LongName.c_str()))
{
string Value;
for (;;)
{
++ArgIndex;
if (ArgIndex >= ArgCount)
break;
const string &Arg = g_Argv[ArgIndex];
if (StartsWith(Arg, "-"))
break;
if (!Value.empty())
Value += " ";
Value += Arg;
}
continue;
}
bool IsFlag = TryFlagOpt(LongName.c_str());
if (IsFlag)
{
++ArgIndex;
continue;
}
++ArgIndex;
if (ArgIndex >= ArgCount)
CmdLineErr("Invalid option or missing value -%s", LongName.c_str());
const char *Value = g_Argv[ArgIndex].c_str();
bool IsUns = TryUnsOpt(LongName.c_str(), Value);
if (IsUns)
{
++ArgIndex;
continue;
}
bool IsFloat = TryFloatOpt(LongName.c_str(), Value);
if (IsFloat)
{
++ArgIndex;
continue;
}
bool IsStr = TryStrOpt(LongName.c_str(), Value);
if (IsStr)
{
++ArgIndex;
continue;
}
CmdLineErr("Unknown option %s", LongName.c_str());
}
else if ((byte) Arg[0] > 127)
CmdLineErr("Invalid 8-bit byte in '%s' (did you paste from web page?)", Arg.c_str());
else
CmdLineErr("Expected -option_name or --option_name, got '%s'", Arg.c_str());
}
#if TIMING
if (opt_threads > 1)
Die("--threads > 1 && TIMING");
#endif
if (opt_compilerinfo)
{
CompilerInfo();
exit(0);
}
}
| 6,534
|
C++
|
.cpp
| 238
| 24.37395
| 144
| 0.632226
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,957
|
seqhash.cpp
|
rcedgar_urmap/src/seqhash.cpp
|
#include "myutils.h"
#include "alpha.h"
#include "seqdb.h"
#include "seqhash.h"
uint32 SeqHash32(const byte *Seq, unsigned L)
{
unsigned a = 63689;
unsigned b = 378551;
uint32 h = 0;
for (unsigned i = 0; i < L; ++i)
{
h = h*a + toupper(Seq[i]);
a *= b;
}
return h;
}
uint32 SeqHashRC32(const byte *Seq, unsigned L)
{
unsigned a = 63689;
unsigned b = 378551;
uint32 h = 0;
for (unsigned k = 0; k < L; ++k)
{
unsigned i = L - k - 1;
h = h*a + toupper(g_CharToCompChar[Seq[i]]);
a *= b;
}
return h;
}
uint32 SeqHash32_EitherStrand(const byte *Seq, unsigned L)
{
uint32 h1 = SeqHash32(Seq, L);
uint32 h2 = SeqHashRC32(Seq, L);
uint32 h = h1 ^ h2;
return h;
}
bool SeqEq(const byte *Seq1, unsigned L1, const byte *Seq2, unsigned L2)
{
if (L1 != L2)
return false;
for (unsigned i = 0; i < L1; ++i)
if (toupper(Seq1[i]) != toupper(Seq2[i]))
return false;
return true;
}
bool SeqEqRC(const byte *Seq1, unsigned L1, const byte *Seq2, unsigned L2)
{
if (L1 != L2)
return false;
for (unsigned i = 0; i < L1; ++i)
{
byte c1 = Seq1[i];
byte c2 = g_CharToCompChar[Seq2[L2 - i - 1]];
if (toupper(c1) != toupper(c2))
return false;
}
return true;
}
| 1,209
|
C++
|
.cpp
| 58
| 18.517241
| 74
| 0.63549
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,958
|
estats.cpp
|
rcedgar_urmap/src/estats.cpp
|
#include "myutils.h"
#include "estats.h"
#include "seqdb.h"
#include <math.h>
/***
NCBI BLAST parameters.
Method Lambda K H
--------------- ------ ------ -----
BLASTN gapped 1.280 0.460 0.850
BLASTN ungapped 1.330 0.621 1.120
BLASTP gapped 0.267 0.0410 0.140
BLASTP ungapped 0.311 0.128 0.407
BLASTX gapped 0.267 0.0410 0.140
BLASTX ungapped 0.318 0.134 0.401
***/
static double Log2 = log(2.0);
EStats *g_ES;
EStats::EStats(bool Nucleo, double DBSize, double MaxEvalue)
{
m_DBSize = DBSize;
m_MaxEvalue = MaxEvalue;
if (Nucleo)
{
m_GappedLambda = 1.280;
m_UngappedLambda = 1.330;
m_GappedK = 0.460;
m_UngappedK = 0.621;
}
else
{
m_GappedLambda = 0.267;
m_UngappedLambda = 0.311;
m_GappedK = 0.0410;
m_UngappedK = 0.128;
}
if (optset_ka_ungapped_k)
m_UngappedK = (double) opt(ka_ungapped_k);
if (optset_ka_ungapped_lambda)
m_UngappedLambda = (double) opt(ka_ungapped_lambda);
if (optset_ka_gapped_k)
m_GappedK = (double) opt(ka_gapped_k);
if (optset_ka_gapped_lambda)
m_GappedLambda = (double) opt(ka_gapped_lambda);
m_LogGappedK = log(m_GappedK);
m_LogUngappedK = log(m_UngappedK);
}
EStats::~EStats()
{
}
double EStats::GetMinUngappedRawScore(unsigned QueryLength) const
{
double DBSize = GetDBSize();
double BitScore = (log(DBSize*QueryLength) - log(m_MaxEvalue))/Log2;
asserta(m_UngappedLambda > 0.0);
return (BitScore*Log2 + m_LogUngappedK)/m_UngappedLambda;
}
double EStats::RawScoreToEvalue(double RawScore, unsigned QueryLength, bool Gapped) const
{
double BitScore = RawScoreToBitScore(RawScore, Gapped);
return BitScoreToEvalue(BitScore, QueryLength, Gapped);
}
double EStats::RawScoreToBitScore(double RawScore, bool Gapped) const
{
double Lambda = GetLambda(Gapped);
double LogK = GetLogK(Gapped);
double BitScore = (RawScore*Lambda - LogK)/Log2;
return BitScore;
}
// Evalue = (NM)/2^BitScore
double EStats::BitScoreToEvalue(double BitScore, unsigned QueryLength, bool Gapped) const
{
double DBSize = GetDBSize();
asserta(DBSize > 0.0);
double NM = double(QueryLength)*m_DBSize;
double p = pow(2.0, BitScore);
double E = NM/p;
return E;
}
double EStats::GetDBSize() const
{
return m_DBSize;
}
| 2,217
|
C++
|
.cpp
| 82
| 24.914634
| 89
| 0.721172
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,959
|
diagbox.cpp
|
rcedgar_urmap/src/diagbox.cpp
|
#include "myutils.h"
#include "diagbox.h"
#define TEST 0
/***
DiagBox represents a diagonal "rectangle" in the D.P. matrix.
i = 0..LA-1
j = 0..LB-1
d = LA - i + j = 1 .. LA+LB-1
j = d - LA + i
i = LA - d + j
***/
void GetDiagRange(unsigned LA, unsigned LB, unsigned d,
unsigned &mini, unsigned &minj, unsigned &maxi, unsigned &maxj)
{
if (d >= LA)
{
mini = 0;
maxi = min(LA+LB-1-d, LA-1);
minj = d - LA;
maxj = min(LB-1, d-1);
}
else
{
mini = LA-d;
maxi = min(LA+LB-1-d, LA-1);
minj = 0;
maxj = min(LB-1, d-1);
}
}
void GetDiagBox(unsigned LA, unsigned LB, unsigned DiagLo, unsigned DiagHi, DiagBox &Box)
{
asserta(DiagLo <= DiagHi);
asserta(DiagLo >= 1);
asserta(DiagHi <= LA + LB - 1);
Box.LA = LA;
Box.LB = LB;
Box.dlo = DiagLo;
Box.dhi = DiagHi;
GetDiagRange(LA, LB, DiagLo, Box.dlo_mini, Box.dlo_minj, Box.dlo_maxi, Box.dlo_maxj);
GetDiagRange(LA, LB, DiagHi, Box.dhi_mini, Box.dhi_minj, Box.dhi_maxi, Box.dhi_maxj);
}
void GetDiagLoHi(unsigned LA, unsigned LB, const char *Path,
unsigned &dlo, unsigned &dhi)
{
dlo = UINT_MAX;
dhi = UINT_MAX;
unsigned i = 0;
unsigned j = 0;
for (unsigned k = 0; ; ++k)
{
char c = Path[k];
if (c == 0)
break;
if (c == 'M')
{
unsigned d = LA - i + j;
if (dlo == UINT_MAX)
{
dlo = d;
dhi = d;
}
else
{
if (d < dlo)
dlo = d;
if (d > dhi)
dhi = d;
}
}
if (c == 'M' || c == 'D')
++i;
if (c == 'M' || c == 'I')
++j;
}
}
#if TEST
static void Test2(unsigned LA, unsigned LB, unsigned DiagLo, unsigned DiagHi)
{
DiagBox Box;
GetDiagBox(LA, LB, DiagLo, DiagHi, Box);
Box.LogMe();
Box.Validate();
}
static void Test1(unsigned LA, unsigned LB, unsigned d,
unsigned i, unsigned j, unsigned I, unsigned J)
{
unsigned mini, maxi, minj, maxj;
GetDiagRange(LA, LB, d, mini, minj, maxi, maxj);
Log("LA=%u LB=%u d=%u (%u,%u) (%u,%u) expected (%u,%u) (%u,%u)\n",
LA, LB, d, mini, minj, maxi, maxj, i, j, I, J);
asserta(mini == i);
asserta(maxi == I);
asserta(minj == j);
asserta(maxj == J);
}
void TestDiagBox()
{
Test2(16, 19, 17, 37);
Test1(5, 3, 1, 4, 0, 4, 0);
Test1(5, 3, 2, 3, 0, 4, 1);
Test1(5, 3, 3, 2, 0, 4, 2);
Test1(5, 3, 4, 1, 0, 3, 2);
Test1(5, 3, 5, 0, 0, 2, 2);
Test1(5, 3, 6, 0, 1, 1, 2);
Test1(5, 3, 7, 0, 2, 0, 2);
Test1(3, 5, 1, 2, 0, 2, 0);
Test1(3, 5, 2, 1, 0, 2, 1);
Test1(3, 5, 3, 0, 0, 2, 2);
Test1(3, 5, 4, 0, 1, 2, 3);
Test1(3, 5, 5, 0, 2, 2, 4);
Test1(3, 5, 6, 0, 3, 1, 4);
Test1(3, 5, 7, 0, 4, 0, 4);
Test1(5, 5, 1, 4, 0, 4, 0);
Test1(5, 5, 2, 3, 0, 4, 1);
Test1(5, 5, 3, 2, 0, 4, 2);
Test1(5, 5, 4, 1, 0, 4, 3);
Test1(5, 5, 5, 0, 0, 4, 4);
Test1(5, 5, 6, 0, 1, 3, 4);
Test1(5, 5, 7, 0, 2, 2, 4);
Test1(5, 5, 8, 0, 3, 1, 4);
Test1(5, 5, 9, 0, 4, 0, 4);
for (unsigned LA = 2; LA <= 5; ++LA)
for (unsigned LB = 2; LB <= 5; ++LB)
for (unsigned dlo = 1; dlo <= LA+LB-1; ++dlo)
for (unsigned dhi = dlo; dhi <= LA+LB-1; ++dhi)
Test2(LA, LB, dlo, dhi);
Log("\n");
Log("ALL OK\n");
}
#endif // TEST
| 3,055
|
C++
|
.cpp
| 130
| 20.830769
| 89
| 0.551617
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,960
|
alignhsp.cpp
|
rcedgar_urmap/src/alignhsp.cpp
|
#include "myutils.h"
#include "ufindex.h"
#include "seqinfo.h"
#include "alpha.h"
#include "state1.h"
#include "alignresult.h"
#include "pathinfo.h"
#include "alnparams.h"
#include <inttypes.h>
#define BRN 2//TODO:PARAM
void LogAlnPretty(const byte *A, const byte *B, const char *Path,
bool StripTermGaps);
void State1::LogHSP(const UFIHSP *HSP) const
{
if (HSP == 0)
{
Log("LogHSP(NULL)\n");
return;
}
unsigned Len = HSP->m_Length;
unsigned StartPosQ = HSP->m_StartPosQ;
unsigned StartPosDB = HSP->m_StartPosDB;
const byte *Q = (HSP->m_Plus ? m_Query->m_Seq : m_RevCompQuerySeq.Data);
const byte *T = m_UFI->m_SeqData;
Log("LogHSP");
Log(" StartPosQ %u", StartPosQ);
Log(", StartPosDB %u", HSP->m_StartPosDB);
Log(", Len %u", Len);
Log(", Score %.1f", double(HSP->m_Score));
Log(", Plus %c", pom(HSP->m_Plus));
Log(", Aligned %c", tof(HSP->m_Aligned));
Log("\n");
Log("Q>%s\n", m_Query->m_Label);
Log("Q: ");
for (unsigned i = 0; i < Len; ++i)
Log("%c", Q[StartPosQ+i]);
Log(" %u - %u\n", StartPosQ + 1, StartPosQ + Len);
Log(" ");
for (unsigned i = 0; i < Len; ++i)
{
byte q = Q[StartPosQ+i];
byte t = T[StartPosDB+i];
Log("%c", q == t ? '|' : 'x');
}
Log("\n");
Log("T: ");
for (unsigned i = 0; i < Len; ++i)
Log("%c", T[StartPosDB+i]);
Log("\n");
}
unsigned State1::AlignHSP(unsigned HSPIndex)
{
UFIHSP *HSP = m_HSPs.Data[HSPIndex];
if (HSP->m_Aligned)
return UINT_MAX;
HSP->m_Aligned = true;
dpscore TotalPen = dpscore(HSP->m_Length) - HSP->m_Score;
dpscore TotalScore = HSP->m_Score;
if (TotalPen > m_MaxPenalty)
return UINT_MAX;
const unsigned StartPosQ = HSP->m_StartPosQ;
const unsigned StartPosDB = HSP->m_StartPosDB;
const unsigned HSPLength = HSP->m_Length;
const bool Plus = HSP->m_Plus;
const unsigned QL = m_Query->m_L;
const unsigned TL = m_UFI->m_SeqDataSize;
unsigned CombinedTLo = StartPosDB;
const byte *Q = (HSP->m_Plus ? m_Query->m_Seq : m_RevCompQuerySeq.Data);
const byte *T = m_UFI->m_SeqData;
m_LeftPI->SetEmpty();
m_RightPI->SetEmpty();
/***
0 StartPosQ QL-1
LeftQLo LeftQHi RightQLo RightQHi
| | | |
Q: LEFTQ qqqqq HSP qqqq RIGHTQ
T: LEFTT ttttt HSP tttt RIGHTT
| |
LeftTHi RightTLo
StartPosDB
***/
/////////////////////////////// Left /////////////////////////
// TODO:optimize by doing right first?
if (StartPosQ > 0)
{
if (StartPosDB < StartPosQ)
return UINT_MAX;
unsigned LeftQLo = 0;
unsigned LeftQHi = StartPosQ - 1;
unsigned LeftQL = LeftQHi - LeftQLo + 1;
unsigned LeftTHi = StartPosDB - 1;
unsigned LeftTL = LeftQL + BRN*GLOBAL_BAND_RADIUS;
if (LeftTL >= LeftTHi)
return UINT_MAX;
unsigned LeftTLo = LeftTHi - LeftTL + 1;
const byte *LeftQ = Q;
const byte *LeftT = T + LeftTLo;
for (unsigned i = 0; i < LeftTL; ++i)
if (LeftT[i] == '-')
return UINT_MAX;
dpscore LeftScore = (dpscore) Viterbi(LeftQ, LeftQL, LeftT, LeftTL, true, false, *m_LeftPI);
unsigned LeftICount = m_LeftPI->TrimLeftIs();
CombinedTLo = LeftTLo + LeftICount;
dpscore AllGapScore = GAP_OPEN_SCORE + (LeftQL-1)*GAP_EXT_SCORE;
if (AllGapScore > LeftScore)
LeftScore = AllGapScore;
dpscore BestPossibleScore = dpscore(LeftQL);
dpscore LeftPen = BestPossibleScore - LeftScore;
TotalScore += LeftScore;
TotalPen += LeftPen;
if (TotalPen > m_MaxPenalty)
return UINT_MAX;
} // end Left
/////////////////////////////// Right /////////////////////////
const unsigned RightQLo = StartPosQ + HSPLength;
if (RightQLo < QL)
{
unsigned RightQHi = QL - 1;
asserta(RightQHi >= RightQLo);
unsigned RightQL = RightQHi - RightQLo + 1;
unsigned RightTLo = StartPosDB + HSPLength;
unsigned RightTHi = RightTLo + RightQL + BRN*GLOBAL_BAND_RADIUS;
if (RightTHi >= TL)
RightTHi = TL - 1;
unsigned RightTL = RightTHi - RightTLo + 1;
const byte *RightQ = Q + RightQLo;
const byte *RightT = T + RightTLo;
for (unsigned i = 0; i < RightTL; ++i)
if (RightT[i] == '-')
return UINT_MAX;
dpscore RightScore = (dpscore) Viterbi(RightQ, RightQL, RightT, RightTL, false, true, *m_RightPI);
m_RightPI->TrimRightIs();
dpscore AllGapScore = GAP_OPEN_SCORE + (RightQL-1)*GAP_EXT_SCORE;
if (AllGapScore > RightScore)
RightScore = AllGapScore;
dpscore BestPossibleScore = dpscore(RightQL);
dpscore RightPen = BestPossibleScore - RightScore;
TotalScore += RightScore;
TotalPen += RightPen;
if (TotalPen > m_MaxPenalty)
return UINT_MAX;
} // end Right
m_PI->SetEmpty();
m_PI->AppendPath(*m_LeftPI);
m_PI->AppendMs(HSPLength);
m_PI->AppendPath(*m_RightPI);
string Path = string(m_PI->GetPath());
unsigned HitIndex = AddHitX(CombinedTLo, Plus, TotalScore, Path);
return HitIndex;
}
| 4,816
|
C++
|
.cpp
| 150
| 29.153333
| 100
| 0.644918
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,961
|
alignresult.cpp
|
rcedgar_urmap/src/alignresult.cpp
|
#include "myutils.h"
#include "objmgr.h"
#include "pathinfo.h"
#include "alignresult.h"
#include "seqinfo.h"
#include "omplock.h"
#include "alpha.h"
#include "alnparams.h"
/***
Sequences in m_Query and m_Target are full-length sequences.
The m_Query sequence may be translated and/or reverse complemented
relative to the original sequence.
The m_Query sequence may be an ORF derived from an original nucleotide
sequence, which is accessible in SeqInfo.m_ORFNucSeq.
For global alignments:
m_HSP.Loi = 0
m_HSP.Leni = LA
m_HSP.Loj = 0
m_HSP.Lenj = Lb
For local alignments:
m_HSP specifies the segments of the full-length sequences
that appear in the alignments.
***/
AlignResult::AlignResult() : Obj(OT_AlignResult)
{
m_Empty = true;
m_Local = false;
m_Gapped = false;
m_Query = 0;
m_Target = 0;
m_PI = 0;
m_HSP.Leni = 0;
m_HSP.Lenj = 0;
m_Filled = false;
m_FirstMCol = 0;
m_LastMCol = 0;
m_FirstMQPos = 0;
m_FirstMTPos = 0;
m_AlnLength = 0;
m_IdCount = 0;
m_MismatchCount = 0;
m_IntGapCount = 0;
m_MaxAlnLength = 0;
m_EvalueSet = false;
m_BitScoreSet = false;
m_RawScoreSet = false;
m_Evalue = 0;
m_BitScore = 0;
m_RawScore = 0;
m_CompressedPath = 0;
m_QueryRow = 0;
m_QueryQualRow = 0;
m_TargetRow = 0;
m_AnnotRow = 0;
}
AlignResult::~AlignResult()
{
}
void AlignResult::OnZeroRefCount()
{
if (m_Query)
{
ObjMgr::Down(m_Query);
m_Query = 0;
}
if (m_Target)
{
ObjMgr::Down(m_Target);
m_Target = 0;
}
if (m_PI)
{
ObjMgr::Down(m_PI);
m_PI = 0;
}
m_HSP.Leni = 0;
m_HSP.Lenj = 0;
m_Empty = true;
m_Local = false;
m_Gapped = false;
}
void AlignResult::CreateEmpty()
{
asserta(m_Query == 0);
asserta(m_Target == 0);
asserta(m_PI == 0);
m_Query = 0;
m_Target = 0;
m_PI = 0;
m_HSP.Leni = 0;
m_HSP.Lenj = 0;
m_Empty = true;
m_Local = false;
m_Gapped = false;
m_BitScoreSet = false;
m_RawScoreSet = false;
m_EvalueSet = false;
}
void AlignResult::Create(bool Local, bool Gapped, SeqInfo &Query, SeqInfo &Target,
const HSPData *HSP, PathInfo *PI, bool Nucleo)
{
asserta(m_Query == 0);
asserta(m_Target == 0);
asserta(m_PI == 0);
m_Empty = false;
m_Local = Local;
m_Gapped = Gapped;
m_Nucleo = Nucleo;
m_Query = &Query;
ObjMgr::Up(m_Query);
m_Target = &Target;
ObjMgr::Up(m_Target);
if (Local)
{
asserta(HSP != 0);
m_HSP.Copy(*HSP);
}
else
{
m_HSP.Loi = 0;
m_HSP.Loj = 0;
m_HSP.Leni = m_Query->m_L;
m_HSP.Lenj = m_Target->m_L;
}
if (Local && !Gapped)
{
asserta(PI == 0);
m_PI = ObjMgr::GetPathInfo();
unsigned SegLength = HSP->Leni;
m_PI->Alloc2(SegLength, SegLength);
m_PI->SetEmpty();
m_PI->AppendMs(SegLength);
}
else
{
m_PI = PI;
if (m_PI != 0)
ObjMgr::Up(m_PI);
}
m_BitScoreSet = false;
m_RawScoreSet = false;
m_EvalueSet = false;
m_Filled = false;
#if DEBUG
Validate();
#endif
}
void AlignResult::CreateLocalGapped(SeqInfo &Query, SeqInfo &Target, const HSPData &HSP,
PathInfo &PI, bool Nucleo)
{
Create(true, true, Query, Target, &HSP, &PI, Nucleo);
}
void AlignResult::CreateLocalUngapped(SeqInfo &Query, SeqInfo &Target, const HSPData &HSP,
bool Nucleo)
{
Create(true, false, Query, Target, &HSP, 0, Nucleo);
}
void AlignResult::CreateGlobal(SeqInfo &Query, SeqInfo &Target, PathInfo &PI, bool Nucleo)
{
Create(false, true, Query, Target, 0, &PI, Nucleo);
}
void AlignResult::Validate() const
{
if (m_Empty)
return;
asserta(m_Query != 0);
asserta(m_Target != 0);
asserta(m_HSP.GetHii() < m_Query->m_L);
asserta(m_HSP.GetHij() < m_Target->m_L);
if (m_Local)
{
if (!m_Gapped)
asserta(m_HSP.Leni == m_HSP.Lenj);
}
else
{
// Global
asserta(m_Gapped);
asserta(m_HSP.Loi == 0);
asserta(m_HSP.Loj == 0);
asserta(m_HSP.Leni == m_Query->m_L);
asserta(m_HSP.Lenj == m_Target->m_L);
}
if (m_Gapped)
{
unsigned M, D, I;
m_PI->GetCounts(M, D, I);
if (!m_Gapped)
asserta(D == 0 && I == 0);
if (m_Local)
{
asserta(M + D == m_HSP.Leni);
asserta(M + I == m_HSP.Lenj);
}
else
{
asserta(M + D == m_Query->m_L);
asserta(M + I == m_Target->m_L);
}
}
}
void AlignResult::LogAlnPretty(bool StripTermGaps) const
{
void LogAlnPretty(const byte *A, const byte *B, const char *Path,
bool StripTermGaps);
Log("Q [%u] >%s\n", m_Query->m_L, m_Query->m_Label);
Log("T [%u] >%s\n", m_Target->m_L, m_Target->m_Label);
LogAlnPretty(m_Query->m_Seq + m_HSP.Loi, m_Target->m_Seq + m_HSP.Loj, m_PI->GetPath(), StripTermGaps);
}
void AlignResult::LogMe() const
{
LOCK();
Log("\n");
if (m_Query == 0 || m_Target == 0)
{
Log("AlignResult::LogMe(), m_Query=%p m_Target=%p\n", m_Query, m_Target);
UNLOCK();
return;
}
Log("AlignResult::LogMe(), refc %u\n", m_RefCount);
Log("Q %5u-%5u (%5u%c) >%s\n", m_HSP.Loi, m_HSP.GetHii(), m_Query->m_L, pom(!m_Query->m_RevComp),m_Query->m_Label);
Log("T %5u-%5u (%5u%c) >%s\n", m_HSP.Loj, m_HSP.GetHij(), m_Target->m_L, pom(!m_Target->m_RevComp), m_Target->m_Label);
const byte *Q = m_Query->m_Seq;
const byte *T = m_Target->m_Seq;
unsigned Loi = m_HSP.Loi;
unsigned Loj = m_HSP.Loj;
if (m_PI == 0)
{
Log("AlignResut::LogMe(), m_PI=0\n");
unsigned SegLength = m_HSP.Leni;
asserta(m_HSP.Lenj == SegLength);
asserta(m_HSP.GetHii() < m_Query->m_L);
asserta(m_HSP.GetHij() < m_Target->m_L);
Log("%*.*s\n", SegLength, SegLength, Q + Loi);
for (unsigned k = 0; k < SegLength; ++k)
{
char q = toupper(Q[Loi+k]);
char t = toupper(T[Loj+k]);
if (q == t)
Log("|");
else
Log("x");
}
Log("%*.*s\n", SegLength, SegLength, T + Loj);
return;
}
const char *Path = m_PI->GetPath();
unsigned i = Loi;
unsigned j = Loj;
for (const char *p = Path; *p; ++p)
{
char c = *p;
if (c == 'M' || c == 'D')
Log("%c", Q[i++]);
else
Log("-");
}
Log("\n");
i = Loi;
j = Loj;
for (const char *p = Path; *p; ++p)
{
char c = *p;
if (c == 'M')
{
char q = Q[i++];
char t = T[j++];
if (toupper(q) == toupper(t))
Log("|");
else
Log(" ");
}
else if (c == 'D')
{
Log(" ");
++i;
}
else if (c == 'I')
{
Log(" ");
++j;
}
else
asserta(false);
}
Log("\n");
j = Loj;
for (const char *p = Path; *p; ++p)
{
char c = *p;
if (c == 'M' || c == 'I')
Log("%c", T[j++]);
else
Log("-");
}
Log("\n");
UNLOCK();
}
const char *AlignResult::GetPath() const
{
asserta(m_PI != 0);
const char *Path = m_PI->GetPath();
asserta(Path != 0);
return Path;
}
unsigned AlignResult::GetQLo_AlnOut()
{
if (opt(show_termgaps))
return m_HSP.Loi;
return GetQLo();
}
unsigned AlignResult::GetTLo_AlnOut()
{
if (opt(show_termgaps))
return m_HSP.Loj;
return GetTLo();
}
unsigned AlignResult::PosToIPosQ1(unsigned Pos, bool Left, bool AllGaps)
{
unsigned p = PosToIPosQ(Pos, Left);;
if (!AllGaps)
++p;
return p;
}
unsigned AlignResult::PosToIPosT1(unsigned Pos, bool Left, bool AllGaps)
{
if (AllGaps)
return Pos;
return Pos + 1;
}
| 6,962
|
C++
|
.cpp
| 330
| 18.524242
| 120
| 0.624962
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,962
|
arscorer.cpp
|
rcedgar_urmap/src/arscorer.cpp
|
#include "myutils.h"
#include "alnparams.h"
#include "alignresult.h"
#include "objmgr.h"
#include "seqinfo.h"
#include "estats.h"
#include "alpha.h"
static inline char GetAminoSym(byte Char1, byte Char2)
{
if (g_MatchMxAmino[Char1][Char2])
return '|';
extern float **g_SubstMx;
float Score = g_SubstMx[Char1][Char2];
if (Score >= 2.0f)
return ':';
if (Score > 0.0f)
return '.';
return ' ';
}
static inline char GetNucleoSym(byte Char1, byte Char2)
{
if (toupper(Char1) == toupper(Char2) && g_IsACGTU[Char1] && g_IsACGTU[Char2])
return '|';
if (g_MatchMxNucleo[Char1][Char2])
return '+';
return ' ';
}
static inline char GetAnnotSym(byte Char1, byte Char2, bool Nucleo)
{
if (Char1 == '-' || Char2 == '-')
return ' ';
if (Nucleo)
return GetNucleoSym(Char1, Char2);
else
return GetAminoSym(Char1, Char2);
}
void AlignResult::AllocAlnLength()
{
unsigned AlnLength = GetAlnLength();
if (AlnLength <= m_MaxAlnLength)
return;
m_MaxAlnLength = RoundUp(AlnLength, 1024-8);
myfree(m_CompressedPath);
myfree(m_QueryRow);
myfree(m_QueryQualRow);
myfree(m_TargetRow);
myfree(m_AnnotRow);
// +8 is slop for nul byte at end of buffers.
m_CompressedPath = myalloc(char, m_MaxAlnLength + 8);
m_QueryRow = myalloc(char, m_MaxAlnLength + 8);
m_QueryQualRow = myalloc(char, m_MaxAlnLength + 8);
m_TargetRow = myalloc(char, m_MaxAlnLength + 8);
m_AnnotRow = myalloc(char, m_MaxAlnLength + 8);
}
double AlignResult::GetEvalue()
{
bool Local = m_Local;
if (!Local)
return -1.0f;
if (m_EvalueSet)
return m_Evalue;
unsigned QL = m_Query->m_L;
bool Gapped = m_Gapped;
double RawScore = GetRawScore();
asserta(g_ES != 0);
m_Evalue = g_ES->RawScoreToEvalue(RawScore, QL, Gapped);
m_EvalueSet = true;
return m_Evalue;
}
double AlignResult::GetRawScore()
{
bool Local = m_Local;
if (!Local)
return 0.0f;
if (m_RawScoreSet)
return m_RawScore;
const byte *Q = GetQuerySeg();
const byte *T = GetTargetSeg();
const char *Path = GetPath();
const AlnParams &AP = *AlnParams::GetGlobalAP();
m_RawScore = AP.ScoreLocalPathIgnoreMask(Q, T, Path);
m_RawScoreSet = true;
return m_RawScore;
}
double AlignResult::GetBitScore()
{
bool Local = m_Local;
if (!Local)
return 0.0f;
if (m_BitScoreSet)
return m_BitScore;
double RawScore = GetRawScore();
bool Gapped = m_Gapped;
asserta(g_ES != 0);
m_BitScore = g_ES->RawScoreToBitScore(RawScore, Gapped);
m_BitScoreSet = true;
return m_BitScore;
}
double AlignResult::GetQueryCov()
{
unsigned QL = m_Query->m_L;
asserta(QL > 0);
if (m_Local)
{
unsigned QSegL = m_HSP.Leni;
return double(QSegL)/double(QL);
}
else
{
Fill();
unsigned n = m_LastMQPos - m_FirstMQPos + 1;
return double(n)/QL;
}
}
double AlignResult::GetTargetCov()
{
unsigned TL = m_Target->m_L;
asserta(TL > 0);
if (m_Local)
{
unsigned TSegL = m_HSP.Lenj;
return double(TSegL)/double(TL);
}
else
{
Fill();
unsigned MCount = m_IdCount + m_MismatchCount;
return double(MCount)/double(TL);
}
}
char AlignResult::GetQueryStrand()
{
if (!m_Nucleo)
return '.';
if (m_Query->m_RevComp)
return '-';
else
return '+';
}
char AlignResult::GetTargetStrand()
{
if (!m_Nucleo)
return '.';
if (m_Target->m_RevComp)
return '-';
else
return '+';
}
int AlignResult::GetQueryFrame()
{
const SeqInfo *Q = m_Query;
if (!Q->m_IsORF)
return 0;
return Q->m_ORFFrame;
}
unsigned AlignResult::GetSAMBits(unsigned HitIndex)
{
unsigned Bits = 0;
if (m_Query->m_RevComp)
Bits |= 0x10;
if (HitIndex > 0)
Bits |= 0x100; // "secondary" hit
return Bits;
}
static unsigned GetMapQ()
{
return 255;
}
void AlignResult::FillLo()
{
m_FirstMCol = UINT_MAX;
m_LastMCol = UINT_MAX;
m_IntGapCount = 0;
m_TermGapCount = 0;
m_IdCount = 0;
m_MismatchCount = 0;
m_DiffCountA = 0;
unsigned Col = 0;
const char *Path = GetPath();
for (;;)
{
char c = Path[Col];
if (c == 0)
break;
else if (c == 'M')
{
if (m_FirstMCol == UINT_MAX)
m_FirstMCol = Col;
m_LastMCol = Col;
}
++Col;
}
unsigned ColCount = Col;
const unsigned Loi = m_HSP.Loi;
const unsigned Loj = m_HSP.Loj;
m_FirstMQPos = Loi;
m_FirstMTPos = Loj;
for (unsigned Col2 = 0; Col2 < m_FirstMCol; ++Col2)
{
char c = Path[Col2];
if (c == 'M' || c == 'D')
++m_FirstMQPos;
if (c == 'M' || c == 'I')
++m_FirstMTPos;
}
const SeqInfo *Query = m_Query;
const SeqInfo *Target = m_Target;
asserta(m_FirstMQPos < Query->m_L);
asserta(m_FirstMTPos < Target->m_L);
const byte *CharToLetter;
if (m_Nucleo)
CharToLetter = g_CharToLetterNucleo;
else
CharToLetter = g_CharToLetterAmino;
const byte *Q = Query->m_Seq;
const byte *T = Target->m_Seq;
const bool * const *MatchMx = (m_Nucleo ? g_MatchMxNucleo : g_MatchMxAmino);
unsigned QPos = m_FirstMQPos;
unsigned TPos = m_FirstMTPos;
for (unsigned Col2 = m_FirstMCol; Col2 <= m_LastMCol; ++Col2)
{
char c = Path[Col2];
if (c == 'M')
{
byte q = Q[QPos];
byte t = T[TPos];
if (toupper(q) != toupper(t))
++m_DiffCountA;
if (MatchMx[q][t])
++m_IdCount;
else
++m_MismatchCount;
++QPos;
++TPos;
}
else if (c == 'D')
{
if (Col2 > m_FirstMCol)
++m_IntGapCount;
++QPos;
}
else if (c == 'I')
{
if (Col2 > m_FirstMCol)
++m_IntGapCount;
++TPos;
}
else
asserta(false);
}
m_LastMQPos = QPos - 1;
m_LastMTPos = TPos - 1;
m_AlnLength = m_LastMCol - m_FirstMCol + 1;
m_TermGapCount = ColCount - m_AlnLength;
m_Filled = true;
}
const char *AlignResult::GetQueryRow()
{
AllocAlnLength();
if (opt(show_termgaps))
return GetQueryRowWithTermGaps();
const byte *Q = GetQuerySeg();
const char *Path = GetPath();
char *Row = m_QueryRow;
for (unsigned Col = m_FirstMCol; Col <= m_LastMCol; ++Col)
{
char c = Path[Col];
if (c == 'M' || c == 'D')
*Row++ = toupper(*Q++);
else
*Row++ = '-';
}
*Row = 0;
return m_QueryRow;
}
const char *AlignResult::GetQueryQualRow()
{
AllocAlnLength();
asserta(!opt(show_termgaps));
const char *Qual = GetQueryQualSeg();
const char *Path = GetPath();
char *Row = m_QueryRow;
for (unsigned Col = m_FirstMCol; Col <= m_LastMCol; ++Col)
{
char c = Path[Col];
if (c == 'M' || c == 'D')
*Row++ = *Qual++;
else
*Row++ = ' ';
}
*Row = 0;
return m_QueryRow;
}
const char *AlignResult::GetQueryRowWithTermGaps()
{
AllocAlnLength();
const byte *Q = GetQSeq();
const char *Path = GetPath();
char *Row = m_QueryRow;
unsigned ColCount = ustrlen(Path);
unsigned QPos = 0;
for (unsigned Col = 0; Col < ColCount; ++Col)
{
char c = Path[Col];
if (c == 'M' || c == 'D')
*Row++ = toupper(*Q++);
else
{
assert(c == 'I');
*Row++ = '-';
}
}
*Row = 0;
return m_QueryRow;
}
const char *AlignResult::GetTargetRowWithTermGaps()
{
AllocAlnLength();
const byte *T = GetTSeq();
const char *Path = GetPath();
char *Row = m_TargetRow;
unsigned ColCount = ustrlen(Path);
unsigned TPos = 0;
for (unsigned Col = 0; Col < ColCount; ++Col)
{
char c = Path[Col];
if (c == 'M' || c == 'I')
*Row++ = toupper(*T++);
else
{
assert(c == 'D');
*Row++ = '-';
}
}
*Row = 0;
return m_TargetRow;
}
const char *AlignResult::GetQueryRowDots()
{
AllocAlnLength();
const byte *Q = GetQuerySeg();
const byte *T = GetTargetSeg();
const char *Path = GetPath();
char *Row = m_QueryRow;
const bool * const * Mx = (m_Nucleo ? g_MatchMxNucleo : g_MatchMxAmino);
for (unsigned Col = m_FirstMCol; Col <= m_LastMCol; ++Col)
{
char c = Path[Col];
char t;
if (c == 'M' || c == 'I')
t = toupper(*T++);
else
t = '-';
if (c == 'M' || c == 'D')
{
char q = toupper(*Q++);
if (Mx[q][t])
*Row++ = '.';
else
*Row++ = q;
}
else
*Row++ = '-';
}
*Row = 0;
return m_QueryRow;
}
const char *AlignResult::GetTargetRowDots()
{
AllocAlnLength();
const byte *Q = GetQuerySeg();
const byte *T = GetTargetSeg();
const char *Path = GetPath();
char *Row = m_TargetRow;
const bool * const * Mx = (m_Nucleo ? g_MatchMxNucleo : g_MatchMxAmino);
for (unsigned Col = m_FirstMCol; Col <= m_LastMCol; ++Col)
{
char c = Path[Col];
char q;
if (c == 'M' || c == 'D')
q = toupper(*Q++);
else
q = '-';
if (c == 'M' || c == 'I')
{
char t = toupper(*T++);
if (Mx[q][t])
*Row++ = '.';
else
*Row++ = t;
}
else
*Row++ = '-';
}
*Row = 0;
return m_TargetRow;
}
const char *AlignResult::GetAnnotRowWithTermGaps(bool Nucleo)
{
AllocAlnLength();
const char *Path = GetPath();
const byte *Q = GetQSeq();
const byte *T = GetTSeq();
char *Row = m_AnnotRow;
unsigned ColCount = ustrlen(Path);
for (unsigned Col = 0; Col < ColCount; ++Col)
{
char c = Path[Col];
if (c == 'M')
*Row++ = GetAnnotSym(*Q, *T, Nucleo);
else
*Row++ = ' ';
if (c == 'M' || c == 'D')
++Q;
if (c == 'M' || c == 'I')
++T;
}
*Row = 0;
return m_AnnotRow;
}
const char *AlignResult::GetAnnotRow(bool Nucleo)
{
if (opt(show_termgaps))
return GetAnnotRowWithTermGaps(Nucleo);
const char *Path = GetPath();
const byte *Q = GetQuerySeg();
const byte *T = GetTargetSeg();
char *Row = m_AnnotRow;
for (unsigned Col = m_FirstMCol; Col <= m_LastMCol; ++Col)
{
char c = Path[Col];
if (c == 'M')
*Row++ = GetAnnotSym(*Q, *T, Nucleo);
else
*Row++ = ' ';
if (c == 'M' || c == 'D')
++Q;
if (c == 'M' || c == 'I')
++T;
}
*Row = 0;
return m_AnnotRow;
}
const char *AlignResult::GetTargetRow()
{
AllocAlnLength();
if (opt(show_termgaps))
return GetTargetRowWithTermGaps();
const byte *T = GetTargetSeg();
const char *Path = GetPath();
char *Row = m_TargetRow;
for (unsigned Col = m_FirstMCol; Col <= m_LastMCol; ++Col)
{
char c = Path[Col];
if (c == 'M' || c == 'I')
*Row++ = toupper(*T++);
else
*Row++ = '-';
}
*Row = 0;
return m_TargetRow;
}
double AlignResult::GetPctPositives()
{
unsigned N = GetPositiveCount();
unsigned L = GetAlnLength();
return GetPct(N, L);
}
unsigned AlignResult::GetPositiveCount()
{
const char *Path = GetPath();
const byte *Q = GetQuerySeg();
const byte *T = GetTargetSeg();
const float * const *SubstMx = AlnParams::GetSubstMx();
unsigned n = 0;
for (unsigned Col = m_FirstMCol; Col <= m_LastMCol; ++Col)
{
char c = Path[Col];
if (c == 'M' && SubstMx[*Q][*T] > 0.0)
++n;
if (c == 'M' || c == 'D')
++Q;
if (c == 'M' || c == 'I')
++T;
}
return n;
}
unsigned AlignResult::GetGapOpenCount()
{
const char *Path = GetPath();
const byte *Q = GetQuerySeg();
const byte *T = GetTargetSeg();
unsigned n = 0;
char Lastc = 'M';
for (unsigned Col = m_FirstMCol; Col <= m_LastMCol; ++Col)
{
char c = Path[Col];
if (c != 'M' && Lastc == 'M')
++n;
Lastc = c;
}
return n;
}
unsigned AlignResult::GetGapExtCount()
{
const char *Path = GetPath();
const byte *Q = GetQuerySeg();
const byte *T = GetTargetSeg();
unsigned n = 0;
char Lastc = 'M';
for (unsigned Col = m_FirstMCol; Col <= m_LastMCol; ++Col)
{
char c = Path[Col];
if (c != 'M' && Lastc != 'M')
++n;
Lastc = c;
}
return n;
}
unsigned AlignResult::PosToIPosQ(unsigned Pos, bool Left)
{
const SeqInfo *Query = m_Query;
const HSPData &HSP = m_HSP;
// assert(Pos >= HSP.Loi && Pos <= HSP.GetHii());
if (Query->m_IsORF)
{
if (Query->m_ORFFrame > 0)
{
unsigned NucPos = Query->m_ORFNucLo + Pos*3;
if (Left)
return NucPos;
else
return NucPos + 2;
}
else
{
/***
NucHI NucLo
v v
<- NNNNNNNNNNNNNNNNNNNNNNNN
AAAAAAAAAAAA ->
^ ^
Pos=0 Pos
***/
asserta(Pos*3 <= Query->m_ORFNucHi);
unsigned k = Pos*3;
assert(k <= Query->m_ORFNucHi);
unsigned NucPos = Query->m_ORFNucHi - k;
if (Left)
return NucPos;
else
{
assert(NucPos >= 2);
return NucPos - 2;
}
}
}
else if (Query->m_RevComp)
{
unsigned LA = Query->m_L;
assert(Pos < LA);
return LA - Pos - 1;
}
else
return Pos;
}
unsigned AlignResult::GetORFLo()
{
if (m_Query->m_IsORF)
return m_Query->m_ORFNucLo;
return 0;
}
unsigned AlignResult::GetORFHi()
{
if (m_Query->m_IsORF)
return m_Query->m_ORFNucHi;
return 0;
}
int AlignResult::GetORFFrame()
{
if (m_Query->m_IsORF)
return m_Query->m_ORFFrame;
return 0;
}
unsigned AlignResult::GetQLoR()
{
return m_HSP.Loi;
}
unsigned AlignResult::GetQHiR()
{
return m_HSP.GetHii();
}
unsigned AlignResult::GetTLoR()
{
return m_HSP.Loj;
}
unsigned AlignResult::GetTHiR()
{
return m_HSP.GetHij();
}
unsigned AlignResult::GetIQLo()
{
const SeqInfo *Query = m_Query;
const HSPData &HSP = m_HSP;
if (Query->m_IsORF)
{
if (Query->m_ORFFrame > 0)
{
unsigned NucPos = Query->m_ORFNucLo + HSP.Loi*3;
return NucPos;
}
else
{
unsigned k = HSP.GetHii()*3;
assert(k <= Query->m_ORFNucHi);
unsigned NucPos = Query->m_ORFNucHi - k;
assert(NucPos >= 2);
return NucPos - 2;
}
}
else if (Query->m_RevComp)
{
unsigned LA = Query->m_L;
return LA - HSP.GetHii() - 1;
}
else
return HSP.Loi;
}
unsigned AlignResult::GetIQHi()
{
const SeqInfo *Query = m_Query;
const HSPData &HSP = m_HSP;
if (Query->m_IsORF)
{
if (Query->m_ORFFrame > 0)
{
unsigned NucPos = Query->m_ORFNucLo + HSP.GetHii()*3;
return NucPos + 2;
}
else
{
unsigned k = HSP.Loi*3;
assert(k <= Query->m_ORFNucHi);
unsigned NucPos = Query->m_ORFNucHi - k;
return NucPos;
}
}
else if (Query->m_RevComp)
{
unsigned LA = Query->m_L;
assert(HSP.GetHii() < LA);
return LA - HSP.Loi - 1;
}
else
return HSP.GetHii();
}
bool AlignResult::Blast6FlipQuery()
{
const SeqInfo *Query = m_Query;
return Query->m_IsORF && Query->m_ORFFrame < 0;
}
bool AlignResult::Blast6FlipTarget()
{
const SeqInfo *Query = m_Query;
return Query->m_RevComp;
}
unsigned AlignResult::GetQLo6()
{
if (Blast6FlipQuery())
return GetIQHi1();
else
return GetIQLo1();
}
// Coords on plus strand, even if revcomp'd
unsigned AlignResult::GetQLoPlus()
{
if (!m_Query->m_RevComp)
return m_HSP.Loi;
else
return m_Query->m_L - m_HSP.GetHii() - 1;
}
unsigned AlignResult::GetQHiPlus()
{
if (!m_Query->m_RevComp)
return m_HSP.GetHii();
else
return m_Query->m_L - m_HSP.Loi - 1;
}
unsigned AlignResult::GetQHi6()
{
if (Blast6FlipQuery())
return GetIQLo1();
else
return GetIQHi1();
}
unsigned AlignResult::GetTLo6()
{
if (Blast6FlipTarget())
return GetITHi1();
else
return GetITLo1();
}
unsigned AlignResult::GetTHi6()
{
if (Blast6FlipTarget())
return GetITLo1();
else
return GetITHi1();
}
double AlignResult::GetAbSkew()
{
unsigned GetSizeFromLabel(const string &Label, unsigned Default);
unsigned QSize = GetSizeFromLabel(m_Query->m_Label, UINT_MAX);
unsigned TSize = GetSizeFromLabel(m_Target->m_Label, UINT_MAX);
return double(TSize)/double(QSize);
}
float AlignResult::GetScore()
{
if (m_Local)
return (float) GetRawScore();
else
return (float) GetFractId();
}
float AlignResult::GetSAMScore()
{
if (m_Local)
return (float) GetRawScore();
else
return (float) GetPctId();
}
unsigned AlignResult::GetQuerySegWildcardCount()
{
const byte *Seg = GetQuerySeg();
unsigned SegLength = GetQuerySegLength();
unsigned n = 0;
bool Nucleo = IsNucleo();
const byte *CharToLetter = (Nucleo ? g_CharToLetterNucleo : g_CharToLetterAmino);
unsigned AlphaSize = (Nucleo ? 4 : 20);
for (unsigned i = 0; i < n; ++i)
{
char c = Seg[i];
byte Letter = CharToLetter[c];
if (Letter >= AlphaSize)
++n;
}
return n;
}
unsigned AlignResult::GetTargetSegWildcardCount()
{
const byte *Seg = GetTargetSeg();
unsigned SegLength = GetTargetSegLength();
unsigned n = 0;
bool Nucleo = IsNucleo();
const byte *CharToLetter = (Nucleo ? g_CharToLetterNucleo : g_CharToLetterAmino);
unsigned AlphaSize = (Nucleo ? 4 : 20);
for (unsigned i = 0; i < n; ++i)
{
char c = Seg[i];
byte Letter = CharToLetter[c];
if (Letter >= AlphaSize)
++n;
}
return n;
}
const char *AlignResult::GetSAMReadSeq()
{
Fill();
if (opt(sam_softclip))
return (const char *) m_Query->m_Seq;
else
return (const char *) GetQuerySeg();
}
unsigned AlignResult::GetSAMReadSeqLength()
{
Fill();
if (opt(sam_softclip))
return m_Query->m_L;
else
return GetQuerySegLength();
}
double AlignResult::GetGCPct()
{
const byte *QSeg = GetQuerySeg();
unsigned QSegL = GetQuerySegLength();
if (QSegL == 0)
return 0.0;
unsigned n = 0;
for (unsigned i = 0; i < QSegL; ++i)
{
byte c = QSeg[i];
byte Letter = g_CharToLetterNucleo[c];
if (Letter == 1 || Letter == 2)
++n;
}
double Pct = (100.0*n)/QSegL;
return Pct;
}
double AlignResult::GetKmerId()
{
Fill();
const unsigned w = (optset_wordlength ? opt(wordlength) : 8);
const unsigned MinL = min(m_Query->m_L, m_Target->m_L);
if (MinL < w)
return 0.0;
const unsigned KmerCount = MinL - w + 1;
unsigned QPos = m_FirstMQPos;
unsigned TPos = m_FirstMTPos;
const char *Path = GetPath();
const byte *Q = m_Query->m_Seq;
const byte *T = m_Target->m_Seq;
unsigned MatchCount = 0;
unsigned ConsecutiveMatchCount = 0;
for (unsigned Col2 = m_FirstMCol; Col2 <= m_LastMCol; ++Col2)
{
char c = Path[Col2];
if (c == 'M')
{
byte q = Q[QPos];
byte t = T[TPos];
if (toupper(q) == toupper(t))
++ConsecutiveMatchCount;
else
ConsecutiveMatchCount = 0;
if (ConsecutiveMatchCount >= w)
++MatchCount;
++QPos;
++TPos;
}
else if (c == 'D')
{
ConsecutiveMatchCount = 0;
++QPos;
}
else if (c == 'I')
{
ConsecutiveMatchCount = 0;
++TPos;
}
else
asserta(false);
}
asserta(MatchCount <= KmerCount);
return double(MatchCount)/double(KmerCount);
}
| 17,743
|
C++
|
.cpp
| 844
| 18.313981
| 82
| 0.639729
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,963
|
sam2aln.cpp
|
rcedgar_urmap/src/sam2aln.cpp
|
#include "myutils.h"
#include "seqdb.h"
#include "seqinfo.h"
#include "linereader.h"
#include "samrec.h"
#include "cigar.h"
static unsigned WriteAln(FILE *f, const byte *ReadSeq, unsigned ReadL,
const byte *RefSeq, unsigned RefSeqL, const string &CIGAR)
{
if (f == 0)
return 0;
if (CIGAR.empty() || CIGAR == "*")
Die("CIGAR='%s'", CIGAR.c_str());
vector<char> Ops;
vector<unsigned> Lengths;
CIGARGetOps(CIGAR, Ops, Lengths);
const unsigned N = SIZE(Ops);
asserta(SIZE(Lengths) == N);
unsigned ReadPos = 0;
unsigned RefPos = 0;
string ReadRow;
string RefRow;
string AnnotRow;
unsigned IdCount = 0;
unsigned SubCount = 0;
unsigned InsCount = 0;
unsigned DelCount = 0;
for (unsigned i = 0; i < N; ++i)
{
char Op = Ops[i];
unsigned n = Lengths[i];
switch (Op)
{
case 'S':
for (unsigned j = 0; j < n; ++j)
{
byte q = toupper(ReadSeq[ReadPos++]);
ReadRow += q;
RefRow += ' ';
AnnotRow += 'S';
}
break;
case 'M':
for (unsigned j = 0; j < n; ++j)
{
byte q = toupper(ReadSeq[ReadPos++]);
byte t = toupper(RefSeq[RefPos++]);
ReadRow += q;
RefRow += t;
if (q == t)
{
++IdCount;
AnnotRow += '|';
}
else
{
++SubCount;
AnnotRow += 'x';
}
}
break;
case 'D':
for (unsigned j = 0; j < n; ++j)
{
byte t = toupper(RefSeq[RefPos++]);
++DelCount;
ReadRow += '-';
RefRow += t;
AnnotRow += ' ';
}
break;
case 'I':
for (unsigned j = 0; j < n; ++j)
{
++InsCount;
byte q = toupper(ReadSeq[ReadPos++]);
ReadRow += q;
RefRow += '-';
AnnotRow += ' ';
}
break;
case 'H':
break;
default:
Die("Invalid op '%c' in CIGAR '%s'", Op, CIGAR.c_str());
}
}
fprintf(f, "%s\n", ReadRow.c_str());
fprintf(f, "%s\n", AnnotRow.c_str());
fprintf(f, "%s\n", RefRow.c_str());
return IdCount;
}
void cmd_sam2aln()
{
const string SamFileName = opt(sam2aln);
const string &DBFileName = opt(ref);
FILE *fOut = CreateStdioFile(opt(output));
SeqDB DB;
DB.FromFasta(DBFileName);
t_LineBuff LB;
LineReader LR;
LR.Open(SamFileName);
ProgressFile(LR.m_f, "sam2aln", SamFileName);
for (;;)
{
bool Ok = LR.ReadLine(LB);
if (!Ok)
break;
if (LB.Size == 0 || LB.Data[0] == '@')
continue;
string Line = string(LB.Data);
SAMRec Rec;
Rec.FromLine(Line);
if (Rec.IsUnmapped())
continue;
bool Plus = Rec.GetStrand();
const char *ReadSeq = Rec.m_ReadSeq;
unsigned ReadL = Rec.m_ReadSeqLength;
const string &RefLabel = Rec.m_TargetLabel;
unsigned RefPos = Rec.m_TargetLo;
asserta(RefPos > 0);
const string &CIGAR = Rec.m_Cigar;
unsigned RefSeqIndex = DB.GetSeqIndex(RefLabel);
const byte *RefSeq = DB.GetSeq(RefSeqIndex) + RefPos - 1;
unsigned RefSeqL = DB.GetSeqLength(RefSeqIndex);
int Mapq = Rec.m_Mapq;
unsigned BitFlags = Rec.m_BitFlags;
fprintf(fOut, "\n");
fprintf(fOut, "@%s", Rec.m_ReadLabel);
if (BitFlags & 0x40)
fprintf(fOut, " (R1)");
else if (BitFlags & 0x80)
fprintf(fOut, " (R2)");
fprintf(fOut, "\n");
unsigned IdCount = WriteAln(fOut, (const byte *) ReadSeq, ReadL, RefSeq, RefSeqL, CIGAR);
double PctId = GetPct(IdCount, ReadL);
fprintf(fOut, "%s:%u(%c) Q%d, %.1f%% id\n",
RefLabel.c_str(), RefPos, pom(Plus), Mapq, PctId);
}
ProgressDone();
LR.Close();
CloseStdioFile(fOut);
}
| 3,387
|
C++
|
.cpp
| 143
| 20.181818
| 91
| 0.615791
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,964
|
tracebackbitmem.cpp
|
rcedgar_urmap/src/tracebackbitmem.cpp
|
#include "myutils.h"
#include "tracebit.h"
#include "xdpmem.h"
#include "pathinfo.h"
#define TRACE 0
void TraceBackBitMem(XDPMem &Mem, unsigned LA, unsigned LB, char State, PathInfo &PI)
{
PI.Alloc2(LA, LB);
StartTimer(TraceBackBitMem);
PI.SetEmpty();
byte **TB = Mem.GetTBBit();
#if TRACE
Log("\n");
Log("TraceBackBit\n");
#endif
size_t i = LA;
size_t j = LB;
for (;;)
{
#if TRACE
Log("i=%3d j=%3d state=%c\n", (int) i, (int) j, State);
#endif
if (i == 0 && j == 0)
break;
PI.AppendChar(State);
byte t;
switch (State)
{
case 'M':
asserta(i > 0 && j > 0);
t = TB[i-1][j-1];
if (t & TRACEBITS_DM)
State = 'D';
else if (t & TRACEBITS_IM)
State = 'I';
else
State = 'M';
--i;
--j;
break;
case 'D':
asserta(i > 0);
t = TB[i-1][j];
if (t & TRACEBITS_MD)
State = 'M';
else
State = 'D';
--i;
break;
case 'I':
asserta(j > 0);
t = TB[i][j-1];
if (t & TRACEBITS_MI)
State = 'M';
else
State = 'I';
--j;
break;
default:
Die("TraceBackBit, invalid state %c", State);
}
}
PI.Reverse();
EndTimer(TraceBackBitMem);
}
| 1,147
|
C++
|
.cpp
| 65
| 14.415385
| 85
| 0.567164
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,965
|
extendscan.cpp
|
rcedgar_urmap/src/extendscan.cpp
|
#include "myutils.h"
#include "ufindex.h"
#include "seqinfo.h"
#include "alpha.h"
#include "state1.h"
#include "ufihit.h"
unsigned State1::AddHSPScan(unsigned StartPosQ, uint32 StartPosDB, bool Plus,
unsigned Length, int Score)
{
#if COUNTERS
bool Correct = DBPosIsCorrect(StartPosDB);
#endif
asserta(Score > 0);
unsigned HSPIndex = OverlapsHSP(StartPosQ, StartPosDB, Plus);
if (HSPIndex != UINT_MAX)
{
IncCounter(ScanHSPOverlap);
UFIHSP *HSP = m_HSPs.Data[HSPIndex];
if (Score > HSP->m_Score)
{
IncCounter(ScanHSPReplace);
HSP->m_StartPosQ = StartPosQ;
HSP->m_StartPosDB = StartPosDB;
HSP->m_Score = Score;
HSP->m_Length = Length;
HSP->m_Plus = Plus;
HSP->m_Aligned = false;
}
else
{
;
}
return HSPIndex;
}
HSPIndex = m_HSPCount++;
AllocHSPs(m_HSPCount);
UFIHSP *HSP = m_HSPs.Data[HSPIndex];
HSP->m_StartPosQ = StartPosQ;
HSP->m_StartPosDB = StartPosDB;
HSP->m_Score = Score;
HSP->m_Length = Length;
HSP->m_Plus = Plus;
HSP->m_Aligned = false;
if (Score > m_BestHSPScore)
m_BestHSPScore = Score;
return HSPIndex;
}
unsigned State1::ExtendScan(uint32 SeedPosQ, uint32 SeedPosDB, bool Plus)
{
if (SeedPosDB < SeedPosQ)
return UINT_MAX;
uint32 DBLo = SeedPosDB - SeedPosQ;
#if COUNTERS
bool Correct = DBPosIsCorrect(DBLo);
if (Correct)
Inc(ScanCorrectExtend);
#endif
const byte *QSeq = (Plus ? m_Query->m_Seq : m_RevCompQuerySeq.Data);
const unsigned QL = m_Query->m_L;
const byte *DBSeq = m_UFI->m_SeqData + DBLo;
const int MinHSPScore = int(m_WordLength*2);//TODO:PARAM
int MaxPenalty = 120;//@@TODO
// Assume seed matches
int Pen = 0;
int Score = int(m_WordLength);
int BestScore = 0;
int EndPos = int(SeedPosQ+m_WordLength) - 1;
for (int QPos = EndPos + 1; QPos < int(QL); ++QPos)
{
byte q = QSeq[QPos];
byte t = DBSeq[QPos];
if (q == t)
{
++Score;
if (Score > BestScore)
{
BestScore = Score;
EndPos = QPos;
}
}
else
{
Pen -= MISMATCH_SCORE;
if (Pen > m_MaxPenalty)
{
#if COUNTERS
if (Correct)
Inc(ScanCorrectExtendFailedMaxPen);
#endif
return UINT_MAX;
}
Score += MISMATCH_SCORE;
int Drop = (BestScore - Score);
if (Drop > XDROP)
break;
}
}
int StartPos = int(SeedPosQ);
for (int QPos = StartPos-1; QPos >= 0; --QPos)
{
byte q = QSeq[QPos];
byte t = DBSeq[QPos];
if (q == t)
{
++Score;
if (Score > BestScore)
{
BestScore = Score;
StartPos = QPos;
}
}
else
{
if (Pen > m_MaxPenalty)
{
#if COUNTERS
if (Correct)
Inc(ScanCorrectExtendFailedMaxPen);
#endif
return UINT_MAX;
}
Score += MISMATCH_SCORE;
int Drop = (BestScore - Score);
if (Drop > XDROP)
break;
}
}
if (StartPos == 0 && EndPos == int(QL) - 1)
{
#if COUNTERS
{
if (Correct)
Inc(ScanCorrectGlobalHSPs);
}
#endif
unsigned HitIndex = AddHitX(DBLo, Plus, BestScore, "");
#if COUNTERS
{
if (Correct)
{
if (HitIndex == UINT_MAX)
Inc(ScanCorrectGlobalHSPAddFails);
else
{
Inc(ScanCorrectGlobalHSPSuccess);
Inc(ScanTotalSuccess);
}
}
}
#endif
return HitIndex;
}
if (BestScore < MinHSPScore)
return UINT_MAX;
unsigned HSPIndex = AddHSPScan(unsigned(StartPos), DBLo + unsigned(StartPos),
Plus, unsigned(EndPos - StartPos + 1), BestScore);
#if COUNTERS
if (Correct && HSPIndex == UINT_MAX)
Inc(ScanCorrectHSPAddHSPFail);
#endif
unsigned HitIndex = UINT_MAX;
if (HSPIndex != UINT_MAX)
{
HitIndex = AlignHSP(HSPIndex);
#if COUNTERS
if (Correct)
{
if (HitIndex == UINT_MAX)
Inc(ScanCorrectExtendFailedAlign);
else
{
Inc(ScanTotalSuccess);
Inc(ScanAlignSuccess);
}
}
#endif
}
return HitIndex;
}
| 3,721
|
C++
|
.cpp
| 179
| 17.670391
| 78
| 0.667233
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,966
|
localaligner2.cpp
|
rcedgar_urmap/src/localaligner2.cpp
|
#include "myutils.h"
#include "pathinfo.h"
#include "alignresult.h"
#include "localaligner2.h"
#include "alpha.h"
#define TEST 0
const char *LocalAligner2::WordToStr(uint32 Word, char *Str) const
{
for (unsigned i = 0; i < m_WordLength; ++i)
{
unsigned Letter = Word%m_AlphaSize;
Str[m_WordLength-i-1] = m_LetterToChar[Letter];
Word /= m_AlphaSize;
}
Str[m_WordLength] = 0;
return Str;
}
uint32 LocalAligner2::SeqToWord(const byte *Seq) const
{
uint32 Word = 0;
for (unsigned i = 0; i < m_WordLength; ++i)
{
unsigned Letter = m_CharToLetter[Seq[i]];
if (Letter >= m_AlphaSize)
Letter = 0;
Word = (Word*m_AlphaSize) + Letter;
}
return Word;
}
LocalAligner2::LocalAligner2(unsigned WordLength, unsigned AlphaSize,
const byte *CharToLetter, const byte *LetterToChar) : LocalAligner(AT_LocalNoPos)
{
m_WordLength = WordLength;
m_AlphaSize = AlphaSize;
m_CharToLetter = CharToLetter;
m_LetterToChar = LetterToChar;
m_QueryWordCounts = 0;
m_QueryWordCounts2 = 0;
m_WordToQueryPosVecBase = 0;
}
void LocalAligner2::InitImpl()
{
LocalAligner::InitImpl();
asserta(m_WordLength > 0 && m_WordLength < 32);
asserta(m_AlphaSize >= 4 && m_AlphaSize <= 20);
m_DictSize = myipow(m_AlphaSize, m_WordLength);
m_AlphaHi = m_DictSize/m_AlphaSize;
m_QueryWordCounts = myalloc(uint32, m_DictSize);
m_QueryWordCounts2 = myalloc(uint32, m_DictSize);
memset_zero(m_QueryWordCounts, m_DictSize);
memset_zero(m_QueryWordCounts2, m_DictSize);
m_WordToQueryPosVecBase = myalloc(uint32, m_DictSize);
}
void LocalAligner2::SetQueryImpl()
{
LocalAligner::SetQueryImpl();
#if 0
{
for (unsigned i = 0; i < m_DictSize; ++i)
{
asserta(m_QueryWordCounts[i] == 0);
asserta(m_QueryWordCounts2[i] == 0);
}
}
#endif
const byte *Q = m_Query->m_Seq;
const unsigned QL = m_Query->m_L;
if (QL <= m_WordLength)
return;
const unsigned QueryWordCount = QL - m_WordLength + 1;
m_QueryWords.Alloc(QL);
m_QueryPosVec.Alloc(QL);
assert(m_WordLength > 0);
uint32 Word = 0;
const byte *Front = Q;
const byte *Back = Q;
for (unsigned i = 0; i < m_WordLength-1; ++i)
{
unsigned Letter = m_CharToLetter[*Front++];
if (Letter >= m_AlphaSize)
Letter = 0;
Word = (Word*m_AlphaSize) + Letter;
}
uint32 *QueryWords = m_QueryWords.Data;
for (unsigned QueryPos = m_WordLength-1; QueryPos < QL; ++QueryPos)
{
unsigned Letter = m_CharToLetter[*Front++];
// Can't skip wildcards because query pos assumed in vector subscripts
if (Letter >= m_AlphaSize)
Letter = 0;
Word = (Word*m_AlphaSize) + Letter;
assert(Word < m_DictSize);
*QueryWords++ = Word;
++(m_QueryWordCounts2[Word]);
Letter = m_CharToLetter[*Back++];
if (Letter >= m_AlphaSize)
Letter = 0;
Word -= Letter*m_AlphaHi;
}
asserta((unsigned) (QueryWords - m_QueryWords.Data) == QueryWordCount);
m_QueryWords.Size = QueryWordCount;
unsigned Base = 0;
QueryWords = m_QueryWords.Data;
for (unsigned QueryPos = 0; QueryPos < QueryWordCount; ++QueryPos)
{
uint32 Word = QueryWords[QueryPos];
unsigned n = m_QueryWordCounts2[Word];
if (n == 0)
continue;
m_WordToQueryPosVecBase[Word] = Base;
m_QueryWordCounts2[Word] = 0;
assert(n > 0 && n < QL);
Base += n;
assert(Base < QL);
}
asserta(Base == QueryWordCount);
uint32 *QueryPosVec = m_QueryPosVec.Data;
m_QueryPosVec.Size = QueryWordCount;
for (unsigned QueryPos = 0; QueryPos < QueryWordCount; ++QueryPos)
{
uint32 Word = QueryWords[QueryPos];
unsigned n = m_QueryWordCounts[Word];
m_QueryWordCounts[Word] = n + 1;
unsigned Base = m_WordToQueryPosVecBase[Word];
assert(Base < QL);
assert(Base + n < m_QueryPosVec.Size);
QueryPosVec[Base + n] = QueryPos;
}
#if DEBUG
Validate();
#endif
}
void LocalAligner2::OnQueryDoneImpl()
{
unsigned QueryWordCount = m_QueryWords.Size;
const uint32 *QueryWords = m_QueryWords.Data;
for (unsigned QPos = 0; QPos < QueryWordCount; ++QPos)
{
uint32 Word = QueryWords[QPos];
m_QueryWordCounts[Word] = 0;
m_QueryWordCounts2[Word] = 0;
}
LocalAligner::OnQueryDoneImpl();
}
void LocalAligner2::Validate() const
{
unsigned QL = m_Query->m_L;
const byte *Q = m_Query->m_Seq;
unsigned QueryWordCount = m_QueryWords.Size;
const uint32 *QueryWords = m_QueryWords.Data;
for (unsigned QPos = 0; QPos < QueryWordCount; ++QPos)
{
uint32 Word = QueryWords[QPos];
unsigned n = m_QueryWordCounts[Word];
unsigned Base = m_WordToQueryPosVecBase[Word];
for (unsigned k = Base; k < Base + n; ++k)
{
unsigned QPos2 = m_QueryPosVec.Data[k];
asserta(QPos2 < QL);
uint32 Word2 = SeqToWord(Q + QPos2);
if (Word2 != Word)
{
Log("\n");
char Str1[64], Str2[64];
Log("QPos %u QPos2 %u Word %u(%s) Word2 %u(%s)\n",
QPos, QPos2, Word, WordToStr(Word, Str1), Word2, WordToStr(Word2, Str2));
LogQueryData();
Die("LocalAligner2::Validate()");
}
}
}
}
void LocalAligner2::LogQueryData() const
{
Log("\n");
unsigned QL = m_Query->m_L;
const byte *Q = m_Query->m_Seq;
Log("LocalAligner2::LogQueryData()\n");
Log("Query %u letters >%s\n", QL, m_Query->m_Label);
Log("Seq %*.*s\n", QL, QL, Q);
unsigned QueryWordCount = m_QueryWords.Size;
const uint32 *QueryWords = m_QueryWords.Data;
Log("\n");
Log("%u words:\n", QueryWordCount);
Log(" QPos n Seq, Word, PosVec\n");
Log("----- --- -----------------\n");
for (unsigned QPos = 0; QPos < QueryWordCount; ++QPos)
{
char Str[32];
uint32 Word = QueryWords[QPos];
unsigned n = m_QueryWordCounts[Word];
Log("%5u %3u %*.*s %s",
QPos,
n,
m_WordLength, m_WordLength, Q + QPos,
WordToStr(Word, Str));
unsigned Base = m_WordToQueryPosVecBase[Word];
Log(" [%u]", Base);
for (unsigned k = Base; k < Base + n; ++k)
{
unsigned Pos = m_QueryPosVec.Data[k];
Log(" %u", Pos);
}
Log("\n");
}
}
bool LocalAligner2::KeepAR(const AlignResult &AR,
const GoBuff<AlignResult *, 32, true, false> &ARs) const
{
const unsigned N = ARs.Size;
for (unsigned i = 0; i < N; ++i)
{
const AlignResult &AR2 = *(ARs.Data[i]);
if (LargeOverlap(AR, AR2))
return false;
}
return true;
}
bool LocalAligner2::LargeOverlap(const AlignResult &AR1, const AlignResult &AR2) const
{
const HSPData &HSP1 = AR1.GetHSP();
const HSPData &HSP2 = AR2.GetHSP();
double OvFract = HSP1.OverlapFract(HSP2);
return OvFract > 0.5;
}
AlignResult *LocalAligner2::Align()
{
Die("LocalAligner2::Align()\n");
return 0;
}
void LocalAligner2::SetTargetImpl()
{
/* empty */
}
void LocalAligner2::OnTargetDoneImpl()
{
/* empty */
}
#if TEST
#include "seqdb.h"
void TestLocalAligner2()
{
SeqDB Input;
Input.FromFasta(opt(input));
bool Nucleo = Input.GetIsNucleo();
AlnParams AP;
AP.InitFromCmdLine(Nucleo);
AlnHeuristics AH;
AH.InitFromCmdLine(AP);
ObjMgr *OM = new ObjMgr;
EStats *ES = new EStats(Nucleo, 1e6, &Input, 1e-6);
LocalAligner2 *LA2 = new LocalAligner2(OM, ES, 5, 20, g_CharToLetterAmino,
g_LetterToCharAmino);
LA2->Init(OM, &AP, &AH);
ES->SetDBSize(1000);
GoBuff<AlignResult *, 32, true, false> ARs;
unsigned SeqCount = Input.GetSeqCount();
for (unsigned SeqIndex = 0; SeqIndex < SeqCount; ++SeqIndex)
{
SeqInfo *Query = ObjMgr::GetSeqInfo();
Input.GetSI(SeqIndex, *Query);
LA2->SetQuery(Query);
// LA2->LogQueryData();
for (unsigned SeqIndex2 = 0; SeqIndex2 < SeqCount; ++SeqIndex2)
{
SeqInfo *Target = ObjMgr::GetSeqInfo();
Input.GetSI(SeqIndex2, *Target);
LA2->SetTarget(Target);
LA2->AlignMulti(ARs);
LA2->OnTargetDone(Target);
ObjMgr::Down(Target);
}
LA2->OnQueryDone(Query);
ObjMgr::Down(Query);
}
}
#endif // TEST
| 7,626
|
C++
|
.cpp
| 277
| 24.837545
| 86
| 0.688493
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,967
|
output1.cpp
|
rcedgar_urmap/src/output1.cpp
|
#include "myutils.h"
#include "ufindex.h"
#include "state1.h"
#include "seqinfo.h"
#include "omplock.h"
#include "outfiles.h"
void State1::Output1()
{
Lock();
if (g_fSAM != 0)
{
SetSAM(0, "*", UINT32_MAX, 0);
fputs(m_SAM.Data, g_fSAM);
}
Unlock();
UpdateHitStats();
}
void State1::UpdateHitStats()
{
Lock();
if (m_TopHit == 0)
++m_NoHitCount;
else if (m_Mapq >= int(m_Minq))
++m_AcceptCount;
else
++m_RejectCount;
Unlock();
}
| 455
|
C++
|
.cpp
| 28
| 14.214286
| 32
| 0.649412
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,968
|
mx.cpp
|
rcedgar_urmap/src/mx.cpp
|
#include "myutils.h"
#include "mx.h"
#include "sparsemx.h"
#include "seqdb.h"
// #include "omplock.h"
char ProbToChar(float p);
list<MxBase *> *MxBase::m_Matrices = 0;
unsigned MxBase::m_AllocCount;
unsigned MxBase::m_ZeroAllocCount;
unsigned MxBase::m_GrowAllocCount;
double MxBase::m_TotalBytes;
double MxBase::m_MaxBytes;
static const char *LogizeStr(const char *s)
{
double d = atof(s);
d = log(d);
return TypeToStr<float>(float(d));
}
static const char *ExpizeStr(const char *s)
{
double d = atof(s);
d = exp(d);
return TypeToStr<float>(float(d));
}
void MxBase::OnCtor(MxBase *Mx)
{
#if 0
Lock();
if (m_Matrices == 0)
m_Matrices = new list<MxBase *>;
asserta(m_Matrices != 0);
m_Matrices->push_front(Mx);
Unlock();
#endif
}
void MxBase::OnDtor(MxBase *Mx)
{
#if 0
Lock();
if (m_Matrices == 0)
{
Warning("MxBase::OnDtor, m_Matrices = 0");
Unlock();
return;
}
for (list<MxBase*>::iterator p = m_Matrices->begin();
p != m_Matrices->end(); ++p)
{
if (*p == Mx)
{
m_Matrices->erase(p);
if (m_Matrices->empty())
delete m_Matrices;
return;
}
}
Warning("MxBase::OnDtor, not found");
Unlock();
#endif // 0
}
void MxBase::Alloc(unsigned RowCount, unsigned ColCount, const string &Name)
{
StartTimer(MxBase_Alloc);
m_Name = Name;
++m_AllocCount;
if (m_AllocatedRowCount == 0)
++m_ZeroAllocCount;
if (RowCount > m_AllocatedRowCount || ColCount > m_AllocatedColCount)
{
if (m_AllocatedRowCount > 0)
{
if (opt(logmemgrows))
Log("MxBase::Alloc grow %s %u x %u -> %u x %u, %s bytes\n",
Name.c_str(), m_AllocatedRowCount, m_AllocatedColCount,
RowCount, ColCount,
IntToStr(GetTotalBytes()));
++m_GrowAllocCount;
}
m_TotalBytes -= GetTotalBytes();
EndTimer(MxBase_Alloc);
StartTimer(MxBase_FreeData);
FreeData();
EndTimer(MxBase_FreeData);
StartTimer(MxBase_Alloc);
unsigned N = max(RowCount + 16, m_AllocatedRowCount);
unsigned M = max(ColCount + 16, m_AllocatedColCount);
EndTimer(MxBase_Alloc);
StartTimer(MxBase_AllocData);
AllocData(N, M);
EndTimer(MxBase_AllocData);
StartTimer(MxBase_Alloc);
m_TotalBytes += GetTotalBytes();
if (m_TotalBytes > m_MaxBytes)
m_MaxBytes = m_TotalBytes;
}
m_Name = Name;
asserta(RowCount <= m_AllocatedRowCount);
asserta(ColCount <= m_AllocatedColCount);
m_RowCount = RowCount;
m_ColCount = ColCount;
EndTimer(MxBase_Alloc);
}
void MxBase::LogMe(bool WithData, int Opts) const
{
Log("\n");
if (Opts & OPT_EXP)
Log("Exp ");
else if (Opts & OPT_LOG)
Log("Log ");
bool ZeroBased = ((Opts & OPT_ZERO_BASED) != 0);
Log("%s(%p) Rows %u/%u, Cols %u/%u",
m_Name.c_str(), this,
m_RowCount, m_AllocatedRowCount,
m_ColCount, m_AllocatedColCount);
Log("\n");
if (!WithData || m_RowCount == 0 || m_ColCount == 0)
return;
const char *z = GetAsStr(0, 0);
unsigned Width = (unsigned) strlen(z);
unsigned Mod = 1;
for (unsigned i = 0; i < Width; ++i)
Mod *= 10;
const byte *A = 0;
const byte *B = 0;
if (B != 0)
{
if (A != 0)
Log(" ");
Log("%5.5s", "");
if (ZeroBased)
for (unsigned j = 0; j < m_ColCount; ++j)
Log("%*c", Width, B[j]);
else
for (unsigned j = 0; j < m_ColCount; ++j)
Log("%*c", Width, j == 0 ? ' ' : B[j-1]);
Log("\n");
}
if (A != 0)
Log(" ");
Log("%5.5s", "");
for (unsigned j = 0; j < m_ColCount; ++j)
Log("%*u", Width, j%Mod);
Log("\n");
for (unsigned i = 0; i < m_RowCount; ++i)
{
if (A != 0)
{
if (ZeroBased)
Log("%c ", A[i]);
else
Log("%c ", i == 0 ? ' ' : A[i-1]);
}
Log("%4u ", i);
for (unsigned j = 0; j < m_ColCount; ++j)
{
const char *s = GetAsStr(i, j);
if (Opts & OPT_LOG)
s = LogizeStr(s);
else if (Opts & OPT_EXP)
s = ExpizeStr(s);
Log("%s", s);
}
Log("\n");
}
}
static unsigned g_MatrixFileCount;
void MxBase::LogCounts()
{
Log("\n");
Log("MxBase::LogCounts()\n");
Log(" What N\n");
Log("---------- ----------\n");
Log(" Allocs %10u\n", m_AllocCount);
Log("ZeroAllocs %10u\n", m_ZeroAllocCount);
Log(" Grows %10u\n", m_GrowAllocCount);
Log(" Bytes %10.10s\n", MemBytesToStr(m_TotalBytes));
Log(" Max bytes %10.10s\n", MemBytesToStr(m_MaxBytes));
}
void MxToSparseMx(const Mx<float> &M, const vector<string> &Labels, SparseMx<float> &S,
float MinValue, float MaxValue)
{
S.Alloc(M.m_RowCount);
S.m_Labels = Labels;
for (unsigned i = 0; i < M.m_RowCount; ++i)
{
unsigned Size = 0;
for (unsigned j = 0; j < M.m_RowCount; ++j)
{
if (j == i)
continue;
float d = (float) M.Get(i, j);
if (d >= MinValue && d <= MaxValue)
++Size;
}
S.m_Sizes[i] = Size;
S.m_Capacities[i] = Size;
if (Size == 0)
{
S.m_Rows[i] = 0;
S.m_Indexes[i] = 0;
continue;
}
float *Row = myalloc(float, Size);
unsigned *Indexes = myalloc(unsigned, Size);
unsigned Size2 = 0;
for (unsigned j = 0; j < M.m_RowCount; ++j)
{
if (j == i)
continue;
float d = (float) M.Get(i, j);
if (d >= MinValue && d <= MaxValue)
{
Row[Size2] = d;
Indexes[Size2] = j;
++Size2;
}
}
S.m_Rows[i] = Row;
S.m_Indexes[i] = Indexes;
}
}
void SparseMxToMx(const SparseMx<float> &S, Mx<float> &M)
{
M.Alloc(S.m_RowCount, S.m_RowCount);
for (unsigned i = 0; i < S.m_RowCount; ++i)
{
for (unsigned j = 0; j < S.m_RowCount; ++j)
{
float d = (float) S.Get(i, j);
M.Put(i, j, d);
}
}
}
| 5,442
|
C++
|
.cpp
| 233
| 20.399142
| 87
| 0.608419
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,969
|
filetype.cpp
|
rcedgar_urmap/src/filetype.cpp
|
#include "myutils.h"
#include "filetype.h"
bool FastaFileIsNucleo(FILE *f);
FILE_TYPE GetFileType(const string &FileName, bool *ptrNucleo)
{
FILE_TYPE Type = FT_Unknown;
*ptrNucleo = false;
FILE *f = OpenStdioFile(FileName);
uintB FileSize = GetStdioFileSizeB(f);
if (FileSize == 0)
Die("Empty file %s", FileName.c_str());
byte b;
ReadStdioFile(f, &b, 1);
if (b == '>')
{
Type = FT_FASTA;
*ptrNucleo = FastaFileIsNucleo(f);
}
else if (b == '@')
{
Type = FT_FASTQ;
*ptrNucleo = true;
}
CloseStdioFile(f);
if (Type == FT_Unknown)
Die("Unknown file format %s", FileName.c_str());
return Type;
}
| 633
|
C++
|
.cpp
| 28
| 20.142857
| 62
| 0.672241
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,970
|
output2.cpp
|
rcedgar_urmap/src/output2.cpp
|
#include "myutils.h"
#include "seqinfo.h"
#include "state1.h"
#include "state2.h"
#include "omplock.h"
#include "outfiles.h"
static int64 g_PrevSeqIndex;
void State2::Output2()
{
OutputSAM2();
OutputTab2();
m_UD_Fwd.UpdateHitStats();
m_UD_Rev.UpdateHitStats();
}
uint32 State2::GetPairedFlags(bool First, bool RevComp, bool MateRevComp, bool MateUnmapped)
{
uint32 Flags = 0;
if (First)
Flags |= 0x41;
else
Flags |= 0x81;
if (RevComp)
Flags |= 0x10;
if (MateUnmapped)
Flags |= 0x08;
else if (MateRevComp)
Flags |= 0x20;
return Flags;
}
void State2::OutputSAM2()
{
if (g_fSAM == 0)
return;
SetSAM2();
Lock();
fputs(m_UD_Fwd.m_SAM.Data, g_fSAM);
fputs(m_UD_Rev.m_SAM.Data, g_fSAM);
Unlock();
}
unsigned State2::GetTemplateLength(const UFIHit *Hit1, const UFIHit *Hit2) const
{
if (Hit1 == 0 || Hit2 == 0)
return UINT_MAX;
unsigned L1 = m_UD_Fwd.m_Query->m_L;
unsigned L2 = m_UD_Rev.m_Query->m_L;
unsigned Pos1 = Hit1->m_DBStartPos;
unsigned Pos2 = Hit2->m_DBStartPos;
int iTL;
if (Pos1 <= Pos2)
iTL = int(Pos2 + m_UD_Rev.m_Query->m_L) - int(Pos1);
else
iTL = int(Pos1 + m_UD_Fwd.m_Query->m_L) - int(Pos2);
if (iTL < 0 || iTL > 1000)
iTL = 0;
return unsigned(iTL);
}
void State2::SetSAM2()
{
m_UD_Fwd.SetMappedPos();
m_UD_Rev.SetMappedPos();
const string &TargetLabel1 = m_UD_Fwd.m_MappedTargetLabel;
const string &TargetLabel2 = m_UD_Rev.m_MappedTargetLabel;
uint32 TargetPos1 = m_UD_Fwd.m_MappedTargetPos;
uint32 TargetPos2 = m_UD_Rev.m_MappedTargetPos;
int TLEN1 = 0;
int TLEN2 = 0;
bool Mapped1 = (m_UD_Fwd.m_MappedTargetPos != UINT32_MAX);
bool Mapped2 = (m_UD_Rev.m_MappedTargetPos != UINT32_MAX);
const UFIHit *Hit1 = m_UD_Fwd.m_TopHit;
const UFIHit *Hit2 = m_UD_Rev.m_TopHit;
bool Plus1 = (Hit1 != 0 && Hit1->m_Plus);
bool Plus2 = (Hit2 != 0 && Hit2->m_Plus);
bool StrandsConsistent = (Hit1 != 0 && Hit2 != 0 && (Plus1 != Plus2));
bool CorrectlyPaired = false;
if (Mapped1 && Mapped2)
{
if (TargetPos1 <= TargetPos2)
{
TLEN1 = int(TargetPos2 + m_UD_Rev.m_Query->m_L) - int(TargetPos1);
if (TLEN1 > 0 && TLEN1 < 1000 && StrandsConsistent)
CorrectlyPaired = true;
if (TLEN1 > 1000)
TLEN1 = 0;
TLEN2 = -TLEN1;
}
else
{
TLEN2 = int(TargetPos1 + m_UD_Fwd.m_Query->m_L) - int(TargetPos2);
if (TLEN2 > 0 && TLEN2 < 1000 && StrandsConsistent)
CorrectlyPaired = true;
if (TLEN2 > 1000)
TLEN2 = 0;
TLEN1 = -TLEN2;
}
}
bool RevComp1 = (Mapped1 && Hit1 != 0 && !Hit1->m_Plus);
bool RevComp2 = (Mapped2 && Hit2 != 0 && !Hit2->m_Plus);
uint32 Flags1 = GetPairedFlags(true, RevComp1, RevComp2, !Mapped2);
uint32 Flags2 = GetPairedFlags(false, RevComp2, RevComp1, !Mapped1);
if (CorrectlyPaired)
{
Flags1 |= 0x02;
Flags2 |= 0x02;
}
m_UD_Fwd.SetSAM(Flags1, TargetLabel2, TargetPos2, TLEN1);
m_UD_Rev.SetSAM(Flags2, TargetLabel1, TargetPos1, TLEN2);
}
| 2,913
|
C++
|
.cpp
| 107
| 24.598131
| 92
| 0.675297
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,972
|
search2.cpp
|
rcedgar_urmap/src/search2.cpp
|
#include "myutils.h"
#include "ufindex.h"
#include "state2.h"
#include "seqinfo.h"
#include "omplock.h"
#include "sort.h"
void State2::AdjustTopHitsAndMapqs()
{
const unsigned PairCount= SIZE(m_Paired_TotalScoreVec);
if (PairCount == 0)
{
m_UD_Fwd.m_Mapq /= 2;
m_UD_Rev.m_Mapq /= 2;
return;
}
// BAD IDEA!
//if (PairCount == 1)
// {
// m_UD_Fwd.m_Mapq = 30;
// m_UD_Rev.m_Mapq = 30;
// return;
// }
unsigned QL = m_UD_Fwd.m_Query->m_L + m_UD_Rev.m_Query->m_L;
double BestPossibleScore = double(QL);
double Fract = double(m_BestPairScore)/double(BestPossibleScore);
double Drop = m_BestPairScore - m_SecondBestPairScore;
if (Drop > 30)
Drop = 30;
unsigned mapq = (unsigned)(Drop*Fract*Fract);
if (mapq > 40)
mapq = 40;
if (mapq > m_UD_Fwd.m_Mapq)
m_UD_Fwd.m_Mapq = mapq;
if (mapq > m_UD_Rev.m_Mapq)
m_UD_Rev.m_Mapq = mapq;
if (m_BestPairIndex != UINT_MAX)
{
unsigned fi = m_Paired_HitIndexVec_Fwd[m_BestPairIndex];
unsigned ri = m_Paired_HitIndexVec_Rev[m_BestPairIndex];
m_UD_Fwd.m_TopHit = m_UD_Fwd.GetHit(fi);
m_UD_Rev.m_TopHit = m_UD_Rev.GetHit(ri);
}
if (m_SecondPairIndex != UINT_MAX)
{
unsigned fi = m_Paired_HitIndexVec_Fwd[m_SecondPairIndex];
unsigned ri = m_Paired_HitIndexVec_Rev[m_SecondPairIndex];
m_UD_Fwd.m_SecondHit = m_UD_Fwd.GetHit(fi);
m_UD_Rev.m_SecondHit = m_UD_Rev.GetHit(ri);
}
}
void State2::Search(SeqInfo *Query_Fwd, SeqInfo *Query_Rev)
{
switch (m_Method)
{
case 4:
Search4(Query_Fwd, Query_Rev);
break;
case 5:
Search5(Query_Fwd, Query_Rev);
break;
default:
asserta(false);
}
Output2();
}
| 1,609
|
C++
|
.cpp
| 65
| 22.323077
| 66
| 0.68099
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,973
|
map2.cpp
|
rcedgar_urmap/src/map2.cpp
|
#include "myutils.h"
#include "ufindex.h"
#include "objmgr.h"
#include "seqinfo.h"
#include "fastqseqsource.h"
#include <inttypes.h>
#include "state2.h"
#include "omplock.h"
#include "outfiles.h"
static void UFIMapThread(const UFIndex &UFI, FASTQSeqSource &SS1,
FASTQSeqSource &SS2)
{
State2 UD;
UD.m_UD_Fwd.SetMethod(6);
UD.m_UD_Rev.SetMethod(6);
if (UD.m_Method == 5)
{
UD.m_UD_Fwd.GLOBAL_BAND_RADIUS = 4;
UD.m_UD_Rev.GLOBAL_BAND_RADIUS = 4;
}
UD.SetUFI(UFI);
SeqInfo *Query1 = ObjMgr::GetSeqInfo();
SeqInfo *Query2 = ObjMgr::GetSeqInfo();
for (;;)
{
Lock();
bool Ok1 = SS1.GetNext(Query1);
bool Ok2 = SS2.GetNext(Query2);
Unlock();
if (Ok1 != Ok2)
Die("Premature end of file in FASTQ%c", Ok1 ? '2' : '1');
if (!Ok1)
break;
UD.Search(Query1, Query2);
}
}
void cmd_map2()
{
const string &FwdFileName = opt(map2);
if (!optset_reverse)
Die("-reverse required");
const string &RevFileName = opt(reverse);
State2::m_Method = 4;
if (opt(veryfast))
State2::m_Method = 5;
void InitGlobals(bool Nucleo);
InitGlobals(true);
FASTQSeqSource SS1;
FASTQSeqSource SS2;
SS1.Open(FwdFileName);
SS2.Open(RevFileName);
UFIndex UFI;
UFI.FromFile(opt(ufi));
//{
//byte Blob[1024];
//uint32 PosVec[64];
//UFI.GetRow_Blob(18446744073709551615, Blob, PosVec);
//return;
//}
State1::WriteSAMHeader(g_fSAM, UFI);
if (opt(veryfast) && UFI.m_MaxIx > 3)
Warning("Genome index not optimal for -veryfast");
unsigned ThreadCount = GetRequestedThreadCount();
State1::m_StartSecs = GetElapsedSecs();
State1::m_Minq = opt(minq);
State2::m_Minq = opt(minq);
if (SS1.m_LR.m_gz)
Progress("Mapping paired %s\n", FwdFileName.c_str());
else
ProgressFile(SS1.m_LR.m_f, "Mapping (paired)", FwdFileName);
#pragma omp parallel num_threads(ThreadCount)
{
UFIMapThread(UFI, SS1, SS2);
}
ProgressDone();
State1::HitStats();
}
| 1,882
|
C++
|
.cpp
| 77
| 22.116883
| 66
| 0.701451
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,975
|
pcb.cpp
|
rcedgar_urmap/src/pcb.cpp
|
#include "myutils.h"
#include "cmd.h"
#include "seqdb.h"
static char *g_S;
static string g_strQueryFileName;
static string g_strDBFileName;
static const char *g_QueryFileName;
static const char *g_DBFileName;
void SetPCBQueryFileName(const string &FileName)
{
g_strQueryFileName = FileName.c_str();
for (const char *p = g_strQueryFileName.c_str(); *p != 0; ++p)
{
if (*p == '/' || *p == '\\')
g_QueryFileName = p + 1;
}
}
void SetPCBDBFileName(const string &FileName)
{
g_strDBFileName = FileName.c_str();
for (const char *p = g_strDBFileName.c_str(); *p != 0; ++p)
{
if (*p == '/' || *p == '\\')
g_DBFileName = p + 1;
}
}
static void AllocS()
{
if (g_S != 0)
return;
g_S = myalloc(char, 128);
}
| 732
|
C++
|
.cpp
| 32
| 20.75
| 63
| 0.643678
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,976
|
outfiles.cpp
|
rcedgar_urmap/src/outfiles.cpp
|
#include "myutils.h"
FILE *g_fSAM;
FILE *g_fTab;
FILE *g_fOut;
void OpenOutputFiles()
{
g_fSAM = CreateStdioFile(opt(samout));
g_fTab = CreateStdioFile(opt(tabbedout));
g_fOut = CreateStdioFile(opt(output));
}
void CloseOutputFiles()
{
CloseStdioFile(g_fSAM);
CloseStdioFile(g_fTab);
CloseStdioFile(g_fOut);
}
| 323
|
C++
|
.cpp
| 16
| 18.375
| 42
| 0.75
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,977
|
seqsource.cpp
|
rcedgar_urmap/src/seqsource.cpp
|
#include "myutils.h"
#include "fastaseqsource.h"
#include "fastqseqsource.h"
#include "seqdbseqsource.h"
#include "objmgr.h"
#include "seqinfo.h"
#include "cmd.h"
#include "filetype.h"
#define TIME_LOCKS 0
#if TIME_LOCKS
#include "getticks.h"
static TICKS g_tLocks;
static TICKS g_tUnLocks;
#endif
SeqSource::SeqSource()
{
m_SI = ObjMgr::GetSeqInfo();
m_SeqCount = 0;
m_DoGetLock = true;
}
SeqSource::~SeqSource()
{
ObjMgr::Down(m_SI);
}
bool SeqSource::GetNext(SeqInfo *SI)
{
if (m_DoGetLock)
{
#if TIME_LOCKS
TICKS t1 = GetClockTicks();
#endif
LOCK_CLASS();
#if TIME_LOCKS
TICKS t2 = GetClockTicks();
g_tLocks += (t2 - t1);
#endif
}
bool Ok = GetNextLo(SI);
if (m_DoGetLock)
{
#if TIME_LOCKS
TICKS t1 = GetClockTicks();
#endif
UNLOCK_CLASS();
#if TIME_LOCKS
TICKS t2 = GetClockTicks();
g_tUnLocks += (t2 - t1);
#endif
}
if (!Ok)
{
#if TIME_LOCKS
Log("SeqSource locks %.3e, unlocks %.3e\n", double(g_tLocks), double(g_tUnLocks));
#endif
return false;
}
++m_SeqCount;
return true;
}
SeqSource *MakeSeqSource(const string &FileName, DB_SORT SortOrder)
{
bool Nucleo;
FILE_TYPE FileType = GetFileType(FileName, &Nucleo);
SeqSource *SS = 0;
if (SortOrder != DBS_None)
{
SeqDB *DB = new SeqDB;
SeqSource *SS2 = MakeSeqSource(FileName, DBS_None);
DB->FromSS(*SS2);
DB->Sort(SortOrder);
SeqDBSeqSource *DBSS = new SeqDBSeqSource;
DBSS->Init(DB);
SS = DBSS;
}
else
{
if (FileType == FT_FASTA)
{
FASTASeqSource *FSS = new FASTASeqSource;
FSS->Open(FileName);
SS = FSS;
}
else if (FileType == FT_FASTQ)
{
FASTQSeqSource *FSS = new FASTQSeqSource;
FSS->Open(FileName);
SS = FSS;
}
else
Die("Input file format not supported by %s: %s",
CmdToStr(GetCmd()), FileName.c_str());
}
asserta(SS != 0);
return SS;
}
| 1,832
|
C++
|
.cpp
| 95
| 16.863158
| 84
| 0.684241
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,978
|
prime.cpp
|
rcedgar_urmap/src/prime.cpp
|
#include "myutils.h"
#define TEST 0
static uint64 g_Primes[] =
{
#include "primes.h"
};
static unsigned g_PrimeCount = sizeof(g_Primes)/sizeof(g_Primes[0]);
uint64 GetPrime(uint64 n)
{
for (unsigned i = 0; i < g_PrimeCount; ++i)
{
uint64 Prime = g_Primes[i];
if (Prime >= n)
return Prime;
}
Die("GetPrime(%.3g) overflow", double(n));
return 0;
}
| 367
|
C++
|
.cpp
| 18
| 18.222222
| 68
| 0.66763
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| true
| false
| true
| false
|
1,537,979
|
getcmd.cpp
|
rcedgar_urmap/src/getcmd.cpp
|
#include "myutils.h"
#include "cmd.h"
CMD g_Cmd = CMD_none;
static void StoreCmd(CMD x)
{
if (g_Cmd != CMD_none)
Die("Two commands specified %s, %s", CmdToStr(g_Cmd), CmdToStr(x));
g_Cmd = x;
}
CMD GetCmd()
{
if (g_Cmd != CMD_none)
return g_Cmd;
g_Cmd = CMD_none;
#define A(x) if (optset_##x) StoreCmd(CMD_##x);
#include "cmds.h"
if (g_Cmd == CMD_none)
Die("No command specified");
return g_Cmd;
}
| 420
|
C++
|
.cpp
| 20
| 18.9
| 69
| 0.64467
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,980
|
alnheuristics.cpp
|
rcedgar_urmap/src/alnheuristics.cpp
|
#include "myutils.h"
#include "alnparams.h"
#include "alnheuristics.h"
#include "alpha.h"
AlnHeuristics::AlnHeuristics()
{
FullDPAlways = opt(fulldp);
BandRadius = 0;
HSPFinderWordLength = 0;
XDropG = 0.0f;
XDropU = 0.0f;
MinGlobalHSPLength = 0;
}
void AlnHeuristics::LogMe() const
{
Log("AH: Band %u, HSPw %u, Xg %.1f, Xu %.1f, HSP %u\n",
BandRadius,
HSPFinderWordLength,
XDropG,
XDropU,
MinGlobalHSPLength);
}
void AlnHeuristics::InitFromCmdLine(const AlnParams &AP)
{
FullDPAlways = opt(fulldp);
XDropU = (float) opt(xdrop_u);
XDropG = (float) opt(xdrop_g);
XDropGlobalHSP = (float) opt(xdrop_nw);
BandRadius = opt(band);
MinGlobalHSPLength = opt(minhsp);
if (AP.GetIsNucleo())
{
HSPFinderWordLength = 5;
MinGlobalHSPFractId = max((float) opt(id), 0.75f);
MinGlobalHSPScore = MinGlobalHSPFractId*MinGlobalHSPLength*(float) opt(match);
}
else
{
HSPFinderWordLength = 3;
// Avg BLOSUM62 score on the diagonal is 5.2, for comparison
const float * const *SubstMx = AP.SubstMx;
float MinDiagScore = 9e9f;
for (unsigned i = 0; i < 20; ++i)
{
byte c = g_LetterToCharAmino[i];
float Score = SubstMx[c][c];
if (Score < MinDiagScore)
MinDiagScore = Score;
}
MinGlobalHSPFractId = max((float) opt(id), 0.5f);
MinGlobalHSPScore = MinGlobalHSPFractId*MinDiagScore*MinGlobalHSPLength;
}
if (optset_hspw)
HSPFinderWordLength = opt(hspw);
if (opt(fulldp))
{
InitGlobalFullDP();
return;
}
}
void AlnHeuristics::InitGlobalFullDP()
{
MinGlobalHSPLength = 0;
HSPFinderWordLength = 0;
BandRadius = 0;
}
| 1,596
|
C++
|
.cpp
| 66
| 21.5
| 80
| 0.716733
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,981
|
rcemalloc.cpp
|
rcedgar_urmap/src/rcemalloc.cpp
|
#include "myutils.h"
#if RCE_MALLOC
#include <windows.h>
#include <stdio.h>
#include "omplock.h"
#define TRACE 0
#define CHECKMEM 1
static const unsigned BigBlockSize = 1500*1024*1024;
static const unsigned BigBlockCount = 128;
static char StartGuard[8] = "STARTGD";
static char EndGuard[8] = "END__GD";
static const unsigned StartGuardSize = sizeof(StartGuard);
static unsigned EndGuardSize = sizeof(EndGuard);
static unsigned MagicBusy = 0x8057;
static unsigned MagicFree = 0x5133;
static FILE *g_fMemLog = fopen("e:/tmp/mem.log", "w");
struct MemBlock
{
unsigned Magic;
MemBlock *Next;
MemBlock *Prev;
const char *FileName;
int Line;
uint64 AllocatedSize;
uint64 RequestedSize;
};
static unsigned BLOCK_OVERHEAD_BYTES = sizeof(MemBlock) + StartGuardSize + EndGuardSize;
struct BigBlock
{
uint64 Pos;
char *Data;
};
static BigBlock g_BigBlocks[BigBlockCount];
static MemBlock *g_BusyBlocks;
static MemBlock *g_FreeBlocks;
static void LogBlock(FILE *f, const MemBlock *Block, const char *Msg)
{
fprintf(f, "LogBlock(%s) Block=%p", Msg, Block);
if (Block->Magic == MagicBusy)
fprintf(f, " %8s", "Busy");
else if (Block->Magic == MagicFree)
fprintf(f, " %8s", "??FREE");
else
fprintf(f, " %8x", Block->Magic);
fprintf(f, " Prev %p Next %p", Block->Prev, Block->Next);
uint64 Bytes = Block->RequestedSize;
char *ptrStartGuard = (char *) Block + sizeof(MemBlock);
char *ptrUserData = ptrStartGuard + StartGuardSize;
char *ptrEndGuard = ptrUserData + Bytes;
if (memcmp(ptrStartGuard, StartGuard, StartGuardSize) == 0)
fprintf(f, " %s", "START");
else
fprintf(f, " %s", "??Err??");
if (memcmp(ptrEndGuard, EndGuard, EndGuardSize) == 0)
fprintf(f, " %s", "END");
else
fprintf(f, " %s", "??Err??");
fprintf(f, " Alloc %llu Req %llu", Block->AllocatedSize, Block->RequestedSize);
fprintf(f, " %s(%d)\n", Block->FileName, Block->Line);
}
static bool PtrInBigBlock(const void *pv)
{
const char *p = (const char *) pv;
for (unsigned i = 0; i < BigBlockCount; ++i)
{
const BigBlock &BB = g_BigBlocks[i];
if (BB.Data == 0)
return false;
if (p >= BB.Data && p < BB.Data + BB.Pos)
return true;
}
return false;
}
void rce_dumpptr_(void *p, const char *FileName, int LineNr)
{
FILE *f = g_fMemLog;
if (f == 0)
return;
if (p == 0)
{
fprintf(f, "\n%s(%d) rce_dumpptr(NULL)\n", FileName, LineNr);
return;
}
char *pc = (char *) p;
MemBlock *Block = (MemBlock *) (pc - sizeof(MemBlock) - StartGuardSize);
fprintf(f, "\n%s(%d)rce_dumpptr(%p) Block=%p", FileName, LineNr, p, Block);
if (Block->Magic == MagicBusy)
fprintf(f, " %8s", "Busy");
else if (Block->Magic == MagicFree)
fprintf(f, " %8s", "Free");
else
fprintf(f, " %8x", Block->Magic);
fprintf(f, " Prev %p Next %p", Block->Prev, Block->Next);
uint64 Bytes = Block->RequestedSize;
char *ptrStartGuard = (char *) Block + sizeof(MemBlock);
char *ptrUserData = ptrStartGuard + StartGuardSize;
char *ptrEndGuard = ptrUserData + Bytes;
if (memcmp(ptrStartGuard, StartGuard, StartGuardSize) == 0)
fprintf(f, " %s", "START");
else
fprintf(f, " %s", "??Err??");
if (memcmp(ptrEndGuard, EndGuard, EndGuardSize) == 0)
fprintf(f, " %s", "END");
else
fprintf(f, " %s", "??Err??");
fprintf(f, " Alloc %llu Req %llu", Block->AllocatedSize, Block->RequestedSize);
fprintf(f, " %s(%d)\n", Block->FileName, Block->Line);
}
void rce_dumpmem(FILE *f)
{
if (f == 0)
f = g_fMemLog;
if (f == 0)
return;
setbuf(f, 0);
fprintf(f, "\n");
fprintf(f, "BigBlocks\n");
fprintf(f, " Addr Pos\n");
fprintf(f, "-------- --------\n");
for (unsigned i = 0; i < BigBlockCount; ++i)
{
const BigBlock &BB = g_BigBlocks[i];
if (i > 0 && BB.Data == 0)
break;
fprintf(f, "%p %llu\n", BB.Data, BB.Pos);
}
fprintf(f, "\n");
fprintf(f, "BusyBlocks %p\n", g_BusyBlocks);
fprintf(f, " Addr Ptr Magic Prev Next StartGd EndGd AllocSz ReqSz Source\n");
for (const MemBlock *Block = g_BusyBlocks; Block; Block = Block->Next)
{
fprintf(f, "%p", Block);
char *ptrStartGuard = (char *) Block + sizeof(MemBlock);
char *ptrUserData = ptrStartGuard + StartGuardSize;
fprintf(f, " %p", ptrUserData);
if (Block->Magic == MagicBusy)
fprintf(f, " %8.8s", "Busy");
else if (Block->Magic == MagicFree)
fprintf(f, " %8.8s", "??FREE");
else
fprintf(f, " %8.8x", Block->Magic);
fprintf(f, " %p %p", Block->Prev, Block->Next);
uint64 Bytes = Block->RequestedSize;
char *ptrEndGuard = ptrUserData + Bytes;
if (memcmp(ptrStartGuard, StartGuard, StartGuardSize) == 0)
fprintf(f, " %8.8s", "START");
else
fprintf(f, " %8.8s", "??Err??");
if (memcmp(ptrEndGuard, EndGuard, EndGuardSize) == 0)
fprintf(f, " %8.8s", "END");
else
fprintf(f, " %8.8s", "??Err??");
fprintf(f, " %8llu %8llu", Block->AllocatedSize, Block->RequestedSize);
fprintf(f, " %s(%d)\n", Block->FileName, Block->Line);
}
fprintf(f, "\n");
fprintf(f, "FreeBlocks %p\n", g_FreeBlocks);
fprintf(f, " Block Ptr Magic Prev Next AllocSz ReqSz Source\n");
fprintf(f, "-------- -------- -------- -------- -------- -------- -------- ------\n");
for (const MemBlock *Block = g_FreeBlocks; Block; Block = Block->Next)
{
fprintf(f, "%p", Block);
char *ptrStartGuard = (char *) Block + sizeof(MemBlock);
char *ptrUserData = ptrStartGuard + StartGuardSize;
fprintf(f, " %p", ptrUserData);
if (Block->Magic == MagicBusy)
fprintf(f, " %8.8s", "??BUSY");
else if (Block->Magic == MagicFree)
fprintf(f, " %8.8s", "Free");
else
fprintf(f, " %8.8x", Block->Magic);
fprintf(f, " %p %p %llu %llu",
Block->Prev, Block->Next, Block->AllocatedSize, Block->RequestedSize);
fprintf(f, " %s(%d)\n", Block->FileName, Block->Line);
}
}
void rce_dumpmem_(const char *FileName, int LineNr)
{
if (g_fMemLog != 0)
fprintf(g_fMemLog, "\nrce_dumpmem: %s(%d)\n", FileName, LineNr);
rce_dumpmem(g_fMemLog);
}
static void Quit()
{
rce_dumpmem(0);
if (IsDebuggerPresent())
__debugbreak();
exit(1);
}
#undef rce_chkmem
static void static_rce_chkmem()
{
unsigned FirstEmpty = UINT_MAX;
for (unsigned i = 0; i < BigBlockCount; ++i)
{
const BigBlock &BB = g_BigBlocks[i];
if (BB.Pos >= BigBlockSize)
{
fprintf(stderr, "\nrce_chkmem, BB.Pos > BigBlockSize\n");
Quit();
}
if (BB.Data == 0)
{
if (FirstEmpty == UINT_MAX)
FirstEmpty = i;
}
if (BB.Data != 0 && FirstEmpty != UINT_MAX)
{
fprintf(stderr, "\nrce_chkmem, big block empty\n");
Quit();
}
}
if (g_BusyBlocks && g_BusyBlocks->Prev != 0)
{
fprintf(stderr, "\nrce_chkmem, g_BusyBlocks->Prev != 0\n");
Quit();
}
if (g_FreeBlocks && g_FreeBlocks->Prev != 0)
{
fprintf(stderr, "\nrce_chkmem, g_BusyBlocks->Prev != 0\n");
Quit();
}
for (const MemBlock *Block = g_BusyBlocks; Block; Block = Block->Next)
{
if (!PtrInBigBlock(Block))
{
fprintf(stderr, "\nrce_chkmem, ptr not in big block\n");
Quit();
}
if (Block->Magic != MagicBusy)
{
fprintf(stderr, "\nrce_chkmem, magic!=busy\n");
Quit();
}
if (Block->Next && Block->Next->Prev != Block)
{
fprintf(stderr, "\nrce_chkmem, Block->Next && Block->Next->Prev != Block\n");
Quit();
}
if (Block->Prev && Block->Prev->Next != Block)
{
fprintf(stderr, "\nrce_chkmem, Block->Prev && Block->Prev->Next != Block\n");
Quit();
}
uint64 Bytes = Block->RequestedSize;
char *ptrStartGuard = (char *) Block + sizeof(MemBlock);
char *ptrUserData = ptrStartGuard + StartGuardSize;
char *ptrEndGuard = ptrUserData + Bytes;
if (memcmp(ptrStartGuard, StartGuard, StartGuardSize) != 0)
{
fprintf(stderr, "\nrce_chkmem(), start guard\n");
Quit();
}
if (memcmp(ptrEndGuard, EndGuard, EndGuardSize) != 0)
{
fprintf(g_fMemLog, "Block %p bad end guard = %p\n", Block, ptrEndGuard);
fprintf(stderr, "\nrce_chkmem(), end guard\n");
Quit();
}
}
for (const MemBlock *Block = g_FreeBlocks; Block; Block = Block->Next)
{
if (!PtrInBigBlock(Block))
{
fprintf(stderr, "\nrce_chkmem, ptr not in big block\n");
Quit();
}
if (Block->Magic != MagicFree)
{
fprintf(stderr, "\nrce_chkmem, magic!=free\n");
Quit();
}
if (Block->Next && Block->Next->Prev != Block)
{
fprintf(stderr, "\nrce_chkmem, Block->Next && Block->Next->Prev != Block\n");
Quit();
}
if (Block->Prev && Block->Prev->Next != Block)
{
fprintf(stderr, "\nrce_chkmem, Block->Prev && Block->Prev->Next != Block\n");
Quit();
}
}
}
static char *OSAlloc(uint64 Bytes)
{
#if TRACE
fprintf(g_fMemLog, "OSAlloc(%u) = ", Bytes);
#endif
HANDLE hHeap = GetProcessHeap();
char *p = (char *) HeapAlloc(hHeap, 0, Bytes);
if (p == 0)
{
fprintf(stderr, "\nHeapAlloc failed (bytes=%" PRIu64 ")\n", Bytes);
Quit();
}
#if TRACE
fprintf(g_fMemLog, "%x\n", p);
#endif
return p;
}
static MemBlock *FindFreeBlock(uint64 Bytes)
{
for (MemBlock *Block = g_FreeBlocks; Block; Block = Block->Next)
{
if (Block->Magic != MagicFree)
{
fprintf(stderr, "\nFindFreeBlock, heap corrupted\n");
Quit();
}
if (Bytes <= Block->AllocatedSize)
return Block;
}
return 0;
}
static MemBlock *MakeNewBlock(uint64 Bytes)
{
asserta(Bytes < BigBlockSize);
BigBlock *BB = 0;
uint64 Bytes2 = Bytes + BLOCK_OVERHEAD_BYTES;
for (unsigned i = 0; i < BigBlockCount; ++i)
{
BB = &g_BigBlocks[i];
if (BB->Data == 0)
{
BB->Data = OSAlloc(BigBlockSize);
BB->Pos = 0;
break;
}
if (BigBlockSize - BB->Pos > Bytes2)
break;
}
if (BB == 0)
{
fprintf(stderr, "\nMakeNewBlock, out of memory\n");
Quit();
}
char *ptrBlock = BB->Data + BB->Pos;
BB->Pos += Bytes2;
MemBlock *Block = (MemBlock *) ptrBlock;
Block->Next = 0;
Block->Prev = 0;
Block->AllocatedSize = Bytes;
return Block;
}
void *rce_malloc(uint64 n, uint64 m, const char *FileName, int Line)
{
Lock();
uint64 Bytes = n*m;
#if TRACE
setbuf(g_fMemLog, 0);
fprintf(g_fMemLog, "\n");
fprintf(g_fMemLog, "rce_malloc Bytes=%u, %s(%d)\n", Bytes, FileName, Line);
#endif
#if CHECKMEM
static_rce_chkmem();
#endif
MemBlock *Block = FindFreeBlock(Bytes);
#if TRACE
fprintf(g_fMemLog, "FindFreeBlock=%x\n", Block);
#endif
if (Block == 0)
{
Block = MakeNewBlock(Bytes + 128);
}
else
{
if (Block->Prev)
{
Block->Prev->Next = Block->Next;
}
else
{
if (Block != g_FreeBlocks)
{
fprintf(stderr, "\nrce_malloc, Block != g_FreeBlocks\n");
Quit();
}
g_FreeBlocks = g_FreeBlocks->Next;
}
if (Block->Next)
Block->Next->Prev = Block->Prev;
}
if (g_BusyBlocks)
g_BusyBlocks->Prev = Block;
Block->Next = g_BusyBlocks;
if (g_BusyBlocks != 0)
g_BusyBlocks->Prev = Block;
Block->Prev = 0;
g_BusyBlocks = Block;
Block->Magic = MagicBusy;
Block->RequestedSize = Bytes;
Block->FileName = FileName;
Block->Line = Line;
char *ptrStartGuard = (char *) Block + sizeof(MemBlock);
char *ptrUserData = ptrStartGuard + StartGuardSize;
char *ptrEndGuard = ptrUserData + Bytes;
asserta(ptrEndGuard + EndGuardSize - (char *) Block == Bytes + BLOCK_OVERHEAD_BYTES);
memcpy(ptrStartGuard, StartGuard, StartGuardSize);
memcpy(ptrEndGuard, EndGuard, EndGuardSize);
#if TRACE
fprintf(g_fMemLog, "Block %x end guard = %x\n", Block, ptrEndGuard);
fprintf(g_fMemLog, "rce_malloc(%u) = %x\n", Bytes, ptrUserData);
#endif
#if CHECKMEM
static_rce_chkmem();
#endif
Unlock();
return (void *) ptrUserData;
}
void *rce_malloc64(uint64 n, uint64 m, const char *FileName, int Line)
{
return rce_malloc(n, m, FileName, Line);
}
void rce_free(void *p, const char *FileName, int Line)
{
Lock();
#if TRACE
fprintf(g_fMemLog, "\n");
fprintf(g_fMemLog, "rce_free(%x)\n", p);
#endif
#if CHECKMEM
static_rce_chkmem();
#endif
if (p == 0)
{
Unlock();
return;
}
char *pc = (char *) p;
MemBlock *Block = (MemBlock *) (pc - sizeof(MemBlock) - StartGuardSize);
if (Block->Magic != MagicBusy)
{
fprintf(stderr, "\nrce_free), magic\n");
Quit();
}
uint64 Bytes = Block->RequestedSize;
char *ptrStartGuard = (char *) Block + sizeof(MemBlock);
char *ptrUserData = ptrStartGuard + StartGuardSize;
char *ptrEndGuard = ptrUserData + Bytes;
if (memcmp(ptrStartGuard, StartGuard, StartGuardSize) != 0)
{
fprintf(stderr, "\nrce_free), start guard\n");
Quit();
}
if (memcmp(ptrEndGuard, EndGuard, EndGuardSize) != 0)
{
fprintf(stderr, "\nrce_free(), end guard\n");
Quit();
}
Block->Magic = MagicFree;
if (Block->Prev)
Block->Prev->Next = Block->Next;
else
{
if (g_BusyBlocks != Block)
{
fprintf(stderr, "\nrce_free, g_BusyBlocks!=Block\n");
Quit();
}
g_BusyBlocks = Block->Next;
}
if (Block->Next)
Block->Next->Prev = Block->Prev;
Block->Next = g_FreeBlocks;
if (g_FreeBlocks != 0)
g_FreeBlocks->Prev = Block;
Block->Prev = 0;
g_FreeBlocks = Block;
#if CHECKMEM
static_rce_chkmem();
#endif
Unlock();
}
void rce_assertvalidptr_(void *p, const char *FileName, int LineNr)
{
if (p == 0)
return;
char *pc = (char *) p;
MemBlock *Block = (MemBlock *) (pc - sizeof(MemBlock) - StartGuardSize);
if (Block->Magic != MagicBusy)
{
fprintf(stderr, "\n%s:%d rce_assertvalidptr(%p), magic %x (should be %x)\n",
FileName, LineNr, p, Block->Magic, MagicBusy);
Quit();
}
uint64 Bytes = Block->RequestedSize;
char *ptrStartGuard = (char *) Block + sizeof(MemBlock);
char *ptrUserData = ptrStartGuard + StartGuardSize;
char *ptrEndGuard = ptrUserData + Bytes;
if (memcmp(ptrStartGuard, StartGuard, StartGuardSize) != 0)
{
fprintf(stderr, "\n%s:%d rce_assertvalidptr(%p), start guard\n",
FileName, LineNr, p);
Quit();
}
if (memcmp(ptrEndGuard, EndGuard, EndGuardSize) != 0)
{
fprintf(stderr, "\n%s:%d rce_assertvalidptr(%p), end guard\n",
FileName, LineNr, p);
Quit();
}
}
void rce_chkmem()
{
Lock();
static_rce_chkmem();
Unlock();
}
#endif // RCEMALLOC
| 14,012
|
C++
|
.cpp
| 510
| 24.717647
| 146
| 0.64324
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,983
|
globalaligner.cpp
|
rcedgar_urmap/src/globalaligner.cpp
|
#include "myutils.h"
#include "pathinfo.h"
#include "globalaligner.h"
#include "alignresult.h"
GlobalAligner::GlobalAligner()
{
m_PI = 0;
m_IsNucleo = false;
m_FullDPAlways = false;
m_FailIfNoHSPs = true;
if (opt(gaforce))
m_FailIfNoHSPs = false;
}
void GlobalAligner::InitImpl()
{
m_FullDPAlways = opt(fulldp);
asserta(m_AP != 0);
asserta(m_AH != 0);
if (!m_FullDPAlways)
m_HF.Init(*m_AP, *m_AH);
m_IsNucleo = m_AP->Nucleo;
}
void GlobalAligner::AlignMulti(GoBuff<AlignResult *, 32, true, false> &ARs)
{
Die("GlobalAligner::AlignMulti");
}
AlignResult *GlobalAligner::AlignPos(unsigned QueryPos, unsigned TargetPos)
{
Die("GlobalAligner::AlignPos");
return 0;
}
AlignResult *GlobalAligner::Align()
{
IncCounter(GlobalAligner_Align);
asserta(m_Target != 0);
asserta(m_PI == 0);
m_PI = ObjMgr::GetPathInfo();
float HSPFractId;
bool Aligned = GlobalAlign_AllOpts(m_Mem, *m_Query, *m_Target, *m_AP, *m_AH, m_HF,
HSPFractId, *m_PI, m_FullDPAlways, m_FailIfNoHSPs);
AlignResult *AR = 0;
if (Aligned)
{
AR = ObjMgr::GetAlignResult();
AR->CreateGlobal(*m_Query, *m_Target, *m_PI, m_IsNucleo);
}
ObjMgr::Down(m_PI);
m_PI = 0;
return AR;
}
void GlobalAligner::SetQueryImpl()
{
if (!m_FullDPAlways)
m_HF.SetA(m_Query);
}
void GlobalAligner::SetTargetImpl()
{
// Don't do this here -- might be rejected before
if (!m_FullDPAlways)
m_HF.SetB(m_Target);
}
void GlobalAligner::OnQueryDoneImpl()
{
// Empty
}
void GlobalAligner::OnTargetDoneImpl()
{
// Empty
}
| 1,522
|
C++
|
.cpp
| 69
| 19.956522
| 83
| 0.709722
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,984
|
myutils.cpp
|
rcedgar_urmap/src/myutils.cpp
|
#ifdef _MSC_VER
#define _SCL_SECURE_NO_WARNINGS
#define _HAS_ITERATOR_DEBUGGING 0
#define _ITERATOR_DEBUG_LEVEL 0
#define MYUTILS_CPP
#endif
#include <time.h>
#include <stdarg.h>
#include <sys/stat.h>
#include <errno.h>
#include <string.h>
#include <ctype.h>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <signal.h>
#include <float.h>
#include <algorithm>
#include <stdlib.h>
#ifdef _MSC_VER
#define WIN32_LEAN_AND_MEAN
#include <crtdbg.h>
#include <process.h>
#include <windows.h>
#include <psapi.h>
#include <io.h>
#else
#include <sys/time.h>
#include <sys/resource.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <dirent.h>
#endif
#ifndef _MSC_VER
#include <dirent.h>
#include <sys/types.h>
#endif
#include "myutils.h"
unsigned g_AllocLine;
const char *g_AllocFile;
static map<FILE *, string> FileToFileName;
const unsigned MY_IO_BUFSIZ = 32000;
const unsigned MAX_FORMATTED_STRING_LENGTH = 64000;
static char *g_IOBuffers[256];
static time_t g_StartTime = time(0);
extern vector<string> g_Argv;
static double g_PeakMemUseBytes;
static char g_TmpStr[64];
static string g_TmpStdStr;
unsigned g_AllocCount;
unsigned g_FreeCount;
const unsigned MAX_FILENO = 255;
static uint64 g_FilenoToByesRead[MAX_FILENO+1];
static uint64 g_BytesIOSinceLastProgressTick;
static const uint64 PROGRESS_TICK_BYTES = 16*1024*1024;
static void IncIO(FILE *f, uint64 Bytes)
{
int fn = fileno(f);
if (fn >= 0 && fn <= MAX_FILENO)
g_FilenoToByesRead[fn] += Bytes;
g_BytesIOSinceLastProgressTick += Bytes;
if (g_BytesIOSinceLastProgressTick >= PROGRESS_TICK_BYTES)
{
Progress_OnTick();
g_BytesIOSinceLastProgressTick = 0;
}
}
#if ALLOC_TOTALS
uint64 g_AllocTotal;
uint64 g_FreeTotal;
#endif
const char *SVN_VERSION =
#include "svnversion.h"
;
static const double LOG2 = log(2.0);
static const double LOG10 = log(10.0);
#ifdef _MSC_VER
void OSInit()
{
_putenv("TZ=");
DWORD OldState = SetThreadExecutionState(ES_SYSTEM_REQUIRED | ES_CONTINUOUS | ES_AWAYMODE_REQUIRED);
if (OldState == NULL)
fprintf(stderr,
"\n\nWarning: SetThreadExecutionState=NULL\n"
"Computer may go to sleep while " PROGRAM_NAME " is running\n\n");
}
#else
void OSInit() {}
#endif
double mylog2(double x)
{
return log(x)/LOG2;
}
double mylog10(double x)
{
return log(x)/LOG10;
}
unsigned GetThreadCount()
{
return omp_get_num_threads();
}
unsigned GetRequestedThreadCount()
{
static unsigned N = 1;
static bool Done = false;
if (Done)
return N;
unsigned MaxN = omp_get_max_threads();
unsigned CoreCount = GetCPUCoreCount();
if (optset_threads)
N = opt(threads);
else
{
if (CoreCount > 10)
{
Progress("CPU has %u cores, defaulting to 10 threads\n", CoreCount);
N = 10;
}
else
N = CoreCount;
}
if (N > MaxN)
{
Warning("Max OMP threads %u", MaxN);
N = MaxN;
}
if (N == 0)
N = 1;
Done = true;
return N;
}
const char *GetPlatform()
{
#if BITS==32
asserta(sizeof(void *) == 4);
#ifdef _MSC_VER
return "win32";
#elif defined(__APPLE__)
return "i86osx32";
#elif defined(__GNUC__)
return "i86linux32";
#else
#error "Unknown compiler"
#endif
#elif BITS==64
asserta(sizeof(void *) == 8);
#ifdef _MSC_VER
return "win64";
#elif defined(__APPLE__)
return "i86osx64";
#elif defined(__GNUC__)
return "i86linux64";
#else
#error "Unknown compiler"
#endif
#else
#error "Bad BITS"
#endif
}
const char *BaseName(const char *PathName)
{
const char *q = 0;
for (const char *p = PathName; *p; ++p)
{
if (*p == '/' || *p == '\\')
q = p + 1;
}
if (q != 0)
return q;
return PathName;
}
void BaseName(const string &PathName, string &FileName)
{
if (PathName == "-" || PathName == "/dev/stdin")
FileName = "(stdin)";
else
FileName = string(BaseName(PathName.c_str()));
}
static void AllocBuffer(FILE *f)
{
#if DEBUG
setbuf(f, 0);
#else
int fd = fileno(f);
if (fd < 0 || fd >= 256)
return;
if (g_IOBuffers[fd] == 0)
g_IOBuffers[fd] = myalloc(char, MY_IO_BUFSIZ);
setvbuf(f, g_IOBuffers[fd], _IOFBF, MY_IO_BUFSIZ);
#endif
}
static void FreeBuffer(FILE *f)
{
#if 0
int fd = fileno(f);
if (fd < 0 || fd >= 256)
return;
if (g_IOBuffers[fd] == 0)
return;
myfree(g_IOBuffers[fd]);
g_IOBuffers[fd] = 0;
#endif
}
unsigned GetElapsedSecs()
{
return (unsigned) (time(0) - g_StartTime);
}
bool StdioFileExists(const string &FileName)
{
struct stat SD;
int i = stat(FileName.c_str(), &SD);
return i == 0;
}
void myassertfail(const char *Exp, const char *File, unsigned Line)
{
Die("%s(%u) assert failed: %s", File, Line, Exp);
}
bool myisatty(int fd)
{
return isatty(fd) != 0;
}
#ifdef _MSC_VER
#include <io.h>
int fseeko(FILE *stream, off_t offset, int whence)
{
off_t FilePos = _fseeki64(stream, offset, whence);
return (FilePos == -1L) ? -1 : 0;
}
#define ftello(fm) (off_t) _ftelli64(fm)
#endif
void LogStdioFileState(FILE *f)
{
unsigned long tellpos = (unsigned long) ftello(f);
long fseek_pos = fseek(f, 0, SEEK_CUR);
int fd = fileno(f);
Log("FILE * %p\n", f);
Log("fileno %d\n", fd);
Log("feof %d\n", feof(f));
Log("ferror %d\n", ferror(f));
Log("ftell %ld\n", tellpos);
Log("fseek %ld\n", fseek_pos);
#if !defined(_GNU_SOURCE) && !defined(__APPLE_CC__)
fpos_t fpos;
int fgetpos_retval = fgetpos(f, &fpos);
Log("fpos %ld (retval %d)\n", (long) fpos, fgetpos_retval);
// Log("eof %d\n", _eof(fd));
#endif
#ifdef _MSC_VER
__int64 pos64 = _ftelli64(f);
Log("_ftelli64 %lld\n", pos64);
#endif
if (FileToFileName.find(f) == FileToFileName.end())
Log("Not found in FileToFileName\n");
else
Log("Name %s\n", FileToFileName[f].c_str());
}
void ParseFileName(const string &FileName, string &Path, string &Name)
{
size_t n = string::npos;
size_t n1 = FileName.rfind('/');
if (n1 != string::npos)
n = n1;
#if _MSC_VER
size_t n2 = FileName.rfind('\\');
size_t n3 = FileName.rfind(':');
if (n2 != string::npos && n2 > n)
n = n2;
if (n3 != string::npos && n3 > n)
n = n3;
#endif
if (n == string::npos)
{
Path = ".";
Name = FileName;
return;
}
Path = FileName.substr(0, n);
Name = FileName.substr(n+1, string::npos);
}
#ifdef _MSC_VER
void ReadDir(const string &DirName, vector<string> &FileNames)
{
FileNames.clear();
if (DirName.find('?') != string::npos || DirName.find('*') != string::npos)
Die("Invalid directory name '%s'", DirName.c_str());
string DirNameSlashStar = DirName;
if (!EndsWith(DirName, "/") && !EndsWith(DirName, "\\"))
DirNameSlashStar += "/";
DirNameSlashStar += "*";
struct _finddata_t FileInfo;
intptr_t h = _findfirst(DirNameSlashStar.c_str(), &FileInfo);
if (h == -1)
Die("Directory not found '%s'", DirName.c_str());
for (;;)
{
string FileName = string(FileInfo.name);
FileNames.push_back(FileName);
int rc = _findnext(h, &FileInfo);
if (rc != 0)
break;
FileNames.push_back(FileInfo.name);
}
_findclose(h);
sort(FileNames.begin(), FileNames.end());
}
#else
void ReadDir(const string &DirName, vector<string> &FileNames)
{
FileNames.clear();
DIR *h = opendir(DirName.c_str());
if (h == 0)
Die("Directory not found '%s'", DirName.c_str());
for (;;)
{
struct dirent *d = readdir(h);
if (d == 0)
break;
string FileName = string(d->d_name);
FileNames.push_back(FileName);
}
closedir(h);
sort(FileNames.begin(), FileNames.end());
}
#endif
static void ReadStdioFile_Raw(FILE *f, void *Buffer, uint64 Bytes)
{
asserta(f != 0);
uint64 BytesLeft = Bytes;
uint64 BufferPos = 0;
const unsigned ChunkSize = 32*1024*1024;
for (;;)
{
if (BytesLeft == 0)
break;
uint64 BytesToRead = BytesLeft;
if (BytesToRead > ChunkSize)
BytesToRead = ChunkSize;
byte *ptrBuffer = (byte *) Buffer + BufferPos;
size_t ElementsRead = fread(ptrBuffer, BytesToRead, 1, f);
if (ElementsRead != 1)
{
LogStdioFileState(f);
Die("File read failed, errno %d", errno);
}
IncIO(f, BytesToRead);
BufferPos += BytesToRead;
BytesLeft -= BytesToRead;
}
}
static void WriteStdioFile_Raw(FILE *f, const void *Buffer, uint64 Bytes)
{
asserta(f != 0);
uint64 BytesLeft = Bytes;
uint64 BufferPos = 0;
const unsigned ChunkSize = 32*1024*1024;
for (;;)
{
if (BytesLeft == 0)
break;
uint64 BytesToWrite = BytesLeft;
if (BytesToWrite > ChunkSize)
BytesToWrite = ChunkSize;
byte *ptrBuffer = (byte *) Buffer + BufferPos;
size_t ElementsWritten = fwrite(ptrBuffer, BytesToWrite, 1, f);
if (ElementsWritten != 1)
{
LogStdioFileState(f);
Die("File write failed errno=%d", int(errno));
}
IncIO(f, BytesToWrite);
BufferPos += BytesToWrite;
BytesLeft -= BytesToWrite;
}
}
void ReadStdioFile(FILE *f, void *Buffer, uint32 Bytes)
{
ReadStdioFile_Raw(f, Buffer, Bytes);
}
FILE *OpenStdioFile(const string &FileName)
{
if (FileName == "")
Die("Missing input file name");
if (FileName == "-")
return stdin;
#if _MSC_VER
if (FileName == "/dev/stdin")
return stdin;
#endif
const char *Mode = "rb";
FILE *f = fopen(FileName.c_str(), Mode);
if (f == 0)
Die("Cannot open %s, errno=%d %s",
FileName.c_str(), errno, strerror(errno));
AllocBuffer(f);
FileToFileName[f] = FileName;
return f;
}
FILE *CreateStdioFile(const string &FileName)
{
if (FileName == "")
// Die("Missing output file name");
return 0;
if (FileName == "-")
return stdout;
#if _MSC_VER
if (FileName == "/dev/stdout")
return stdout;
#endif
FILE *f = fopen(FileName.c_str(), "wb+");
if (0 == f)
Die("Cannot create %s, errno=%d %s",
FileName.c_str(), errno, strerror(errno));
const unsigned MYBUFFSZ = 262144+8;
char *buf = (char *) malloc(MYBUFFSZ);
setvbuf(f, buf, _IOFBF, MYBUFFSZ);
AllocBuffer(f);
FileToFileName[f] = FileName;
return f;
}
void SetStdioFilePos(FILE *f, uint32 Pos)
{
if (0 == f)
Die("SetStdioFilePos failed, f=NULL");
int Ok = fseeko(f, Pos, SEEK_SET);
off_t NewPos = ftello(f);
if (Ok != 0 || Pos != NewPos)
{
LogStdioFileState(f);
Die("SetStdioFilePos(%d) failed, Ok=%d NewPos=%d",
(int) Pos, Ok, (int) NewPos);
}
}
void SetStdioFilePos64(FILE *f, uint64 Pos)
{
if (0 == f)
Die("SetStdioFilePos failed, f=NULL");
int Ok = fseeko(f, Pos, SEEK_SET);
off_t NewPos = ftello(f);
if (Ok != 0 || Pos != NewPos)
{
LogStdioFileState(f);
Die("SetStdioFilePos64(%ul) failed, Ok=%d NewPos=%ul",
(unsigned long) Pos, Ok, (unsigned long) NewPos);
}
}
void ReadStdioFile(FILE *f, uint32 Pos, void *Buffer, uint32 Bytes)
{
asserta(f != 0);
SetStdioFilePos(f, Pos);
ReadStdioFile_Raw(f, Buffer, Bytes);
}
void ReadStdioFile64(FILE *f, uint64 Pos, void *Buffer, uint64 Bytes)
{
asserta(f != 0);
SetStdioFilePos64(f, Pos);
ReadStdioFile_Raw(f, Buffer, Bytes);
}
uint32 ReadStdioFile_NoFail(FILE *f, void *Buffer, uint32 Bytes)
{
asserta(f != 0);
off_t PosBefore = ftello(f);
size_t ElementsRead = fread(Buffer, Bytes, 1, f);
off_t PosAfter = ftello(f);
if (ElementsRead == 1)
{
IncIO(f, Bytes);
return Bytes;
}
uint32 BytesRead = uint32(PosAfter - PosBefore);
IncIO(f, BytesRead);
return BytesRead;
}
void ReadStdioFile64(FILE *f, void *Buffer, uint64 Bytes)
{
ReadStdioFile_Raw(f, Buffer, Bytes);
}
void WriteStdioFile(FILE *f, uint32 Pos, const void *Buffer, uint32 Bytes)
{
asserta(f != 0);
SetStdioFilePos(f, Pos);
WriteStdioFile_Raw(f, Buffer, Bytes);
}
void WriteStdioFileStr(FILE *f, const char *s)
{
uint32 Bytes = ustrlen(s);
WriteStdioFile_Raw(f, s, Bytes);
}
void WriteStdioFile(FILE *f, const void *Buffer, uint32 Bytes)
{
WriteStdioFile_Raw(f, Buffer, Bytes);
}
void WriteStdioFile64(FILE *f, const void *Buffer, uint64 Bytes)
{
WriteStdioFile_Raw(f, Buffer, Bytes);
}
// Return false on EOF, true if line successfully read.
bool ReadLineStdioFile(FILE *f, char *Line, uint32 Bytes)
{
if (feof(f))
return false;
if ((int) Bytes < 0)
Die("ReadLineStdioFile: Bytes < 0");
off_t PosBefore = ftello(f);
char *RetVal = fgets(Line, (int) Bytes, f);
off_t PosAfter = ftello(f);
uint64 BytesRead = PosAfter - PosBefore;
IncIO(f, BytesRead);
if (NULL == RetVal)
{
if (feof(f))
return false;
if (ferror(f))
Die("ReadLineStdioFile: errno=%d", errno);
Die("ReadLineStdioFile: fgets=0, feof=0, ferror=0");
}
if (RetVal != Line)
Die("ReadLineStdioFile: fgets != Buffer");
size_t n = strlen(Line);
if (n < 1 || Line[n-1] != '\n')
Die("ReadLineStdioFile: line too long or missing end-of-line");
if (n > 0 && (Line[n-1] == '\r' || Line[n-1] == '\n'))
Line[n-1] = 0;
if (n > 1 && (Line[n-2] == '\r' || Line[n-2] == '\n'))
Line[n-2] = 0;
return true;
}
void ReadTabbedLineStdioFile(FILE *f, vector<string> &Fields, unsigned FieldCount)
{
string Line;
bool Ok = ReadLineStdioFile(f, Line);
if (!Ok)
Die("Unxpected end-of-file in tabbed text");
Split(Line, Fields, '\t');
unsigned n = SIZE(Fields);
if (FieldCount != UINT_MAX && n != FieldCount)
{
Log("\n");
Log("Line='%s'\n", Line.c_str());
Die("Expected %u tabbed fields, got %u", FieldCount, n);
}
}
// Return false on EOF, true if line successfully read.
bool ReadLineStdioFile(FILE *f, string &Line)
{
Line.clear();
off_t PosBefore = ftello(f);
for (;;)
{
int c = fgetc(f);
if (c == -1)
{
if (feof(f))
{
if (!Line.empty())
return true;
return false;
}
Die("ReadLineStdioFile, errno=%d", errno);
}
if (c == '\r')
continue;
if (c == '\n')
{
off_t PosAfter = ftello(f);
IncIO(f, PosAfter - PosBefore);
return true;
}
Line.push_back((char) c);
}
}
void RenameStdioFile(const string &FileNameFrom, const string &FileNameTo)
{
int Ok = rename(FileNameFrom.c_str(), FileNameTo.c_str());
if (Ok != 0)
Die("RenameStdioFile(%s,%s) failed, errno=%d %s",
FileNameFrom.c_str(), FileNameTo.c_str(), errno, strerror(errno));
}
void FlushStdioFile(FILE *f)
{
int Ok = fflush(f);
if (Ok != 0)
Die("fflush(%p)=%d,", f, Ok);
}
void CloseStdioFile_(FILE **f)
{
if (f == 0 || *f == 0)
return;
int Ok = fclose(*f);
if (Ok != 0)
Die("fclose(%p)=%d", *f, Ok);
FreeBuffer(*f);
f = 0;
}
uint32 GetStdioFilePos32(FILE *f)
{
off_t FilePos = ftello(f);
if (FilePos < 0)
Die("GetStdioFilePos32 ftello=%d", (int) FilePos);
if (FilePos > UINT32_MAX)
Die("File offset too big for 32-bit version (%s)", MemBytesToStr((double) FilePos));
return (uint32) FilePos;
}
uint64 GetStdioFilePos64(FILE *f)
{
off_t FilePos = ftello(f);
if (FilePos < 0)
Die("GetStdioFilePos64 ftello=%d", (int) FilePos);
return (uint64) FilePos;
}
uint64 GetStdioFilePos64_NoFail(FILE *f)
{
off_t FilePos = ftello(f);
if (FilePos < 0)
return UINT64_MAX;
return (uint64) FilePos;
}
uint32 GetStdioFilePos32_NoFail(FILE *f)
{
off_t FilePos = ftello(f);
if (FilePos < 0 || FilePos > off_t(UINT32_MAX))
return UINT32_MAX;
return (uint32) FilePos;
}
uint64 GetStdioFileBytesRead(FILE *f)
{
int fn = fileno(f);
if (fn >= 0 && fn <= MAX_FILENO)
return g_FilenoToByesRead[fn];
return 0;
}
uint32 GetStdioFileSize32(FILE *f)
{
uint32 CurrentPos = GetStdioFilePos32(f);
int Ok = fseeko(f, 0, SEEK_END);
if (Ok < 0)
Die("fseek in GetFileSize");
off_t Length = ftello(f);
SetStdioFilePos(f, CurrentPos);
if (Length < 0)
Die("ftello in GetFileSize");
#if BITS == 32
if (Length > UINT32_MAX)
Die("File size too big for 32-bit version (%s)", MemBytesToStr((double) Length));
#endif
return (uint32) Length;
}
uint32 GetStdioFileSize32_NoFail(FILE *f)
{
uint32 CurrentPos = GetStdioFilePos32(f);
int Ok = fseeko(f, 0, SEEK_END);
if (Ok < 0)
return UINT32_MAX;
off_t Length = ftello(f);
SetStdioFilePos(f, CurrentPos);
if (Length < 0 || Length > off_t(UINT32_MAX))
return UINT32_MAX;
return (uint32) Length;
}
uint64 GetStdioFileSize64(FILE *f)
{
uint64 CurrentPos = GetStdioFilePos64(f);
int Ok = fseeko(f, 0, SEEK_END);
if (Ok < 0)
Die("fseek in GetFileSize64");
off_t Length = ftello(f);
SetStdioFilePos64(f, CurrentPos);
if (Length < 0)
Die("ftello in GetFileSize");
#if BITS == 32
if (Length > UINT32_MAX)
Die("File size too big for 32-bit version (%s)", MemBytesToStr((double) Length));
#endif
return (uint64) Length;
}
uint64 GetStdioFileSize64_NoFail(FILE *f)
{
uint64 CurrentPos = GetStdioFilePos64_NoFail(f);
int Ok = fseeko(f, 0, SEEK_END);
if (Ok < 0)
return UINT64_MAX;
off_t Length = ftello(f);
SetStdioFilePos64(f, CurrentPos);
if (Length < 0)
return UINT64_MAX;
return (uint64) Length;
}
void MoveStdioFile(const string &FileName1, const string &FileName2)
{
if (StdioFileExists(FileName2))
DeleteStdioFile(FileName2);
RenameStdioFile(FileName1, FileName2);
}
void DeleteStdioFile(const string &FileName)
{
int Ok = remove(FileName.c_str());
if (Ok != 0)
Die("remove(%s) failed, errno=%d %s", FileName.c_str(), errno, strerror(errno));
}
double GetUsableMemBytes()
{
double RAM = GetPhysMemBytes();
#if BITS==32
#ifdef _MSC_VER
if (RAM > 2e9)
return 2e9;
#else
if (RAM > 4e9)
return 4e9;
#endif
#endif
return RAM;
}
static char **g_ThreadStrs;
static unsigned g_ThreadStrCount;
static char *GetThreadStr()
{
unsigned ThreadIndex = GetThreadIndex();
if (ThreadIndex >= g_ThreadStrCount)
{
unsigned NewThreadStrCount = ThreadIndex + 4;
char **NewThreadStrs = myalloc(char *, NewThreadStrCount);
memset_zero(NewThreadStrs, NewThreadStrCount);
if (g_ThreadStrCount > 0)
memcpy(NewThreadStrs, g_ThreadStrs, g_ThreadStrCount*sizeof(char *));
g_ThreadStrs = NewThreadStrs;
g_ThreadStrCount = NewThreadStrCount;
}
if (g_ThreadStrs[ThreadIndex] == 0)
g_ThreadStrs[ThreadIndex] = myalloc(char, MAX_FORMATTED_STRING_LENGTH+1);
char *Str = g_ThreadStrs[ThreadIndex];
return Str;
}
void myvstrprintf(string &Str, const char *Format, va_list ArgList)
{
char *szStr = GetThreadStr();
vsnprintf(szStr, MAX_FORMATTED_STRING_LENGTH-1, Format, ArgList);
szStr[MAX_FORMATTED_STRING_LENGTH - 1] = '\0';
Str.assign(szStr);
}
void Pf(FILE *f, const char *Format, ...)
{
if (f == 0)
return;
va_list ArgList;
va_start(ArgList, Format);
vfprintf(f, Format, ArgList);
va_end(ArgList);
}
void Ps(string &Str, const char *Format, ...)
{
va_list ArgList;
va_start(ArgList, Format);
myvstrprintf(Str, Format, ArgList);
va_end(ArgList);
}
void Psa(string &Str, const char *Format, ...)
{
va_list ArgList;
va_start(ArgList, Format);
string Tmp;
myvstrprintf(Tmp, Format, ArgList);
va_end(ArgList);
Str += Tmp;
}
void AppendIntToStr(string &Str, unsigned i)
{
do
{
Str += ('0' + i%10);
i /= 10;
}
while (i != 0);
}
void Psasc(string &Str, const char *Format, ...)
{
unsigned n = SIZE(Str);
if (n > 0 && Str[n-1] != ';')
Str += ";";
va_list ArgList;
va_start(ArgList, Format);
string Tmp;
myvstrprintf(Tmp, Format, ArgList);
va_end(ArgList);
Str += Tmp;
n = SIZE(Str);
if (n > 0 && Str[n-1] != ';')
Str += ";";
}
FILE *g_fLog = 0;
void SetLogFileName(const string &FileName)
{
if (g_fLog != 0)
CloseStdioFile(g_fLog);
g_fLog = 0;
if (FileName.empty())
return;
g_fLog = CreateStdioFile(FileName);
setbuf(g_fLog, 0);
}
void Log(const char *Format, ...)
{
if (g_fLog == 0)
return;
va_list ArgList;
va_start(ArgList, Format);
vfprintf(g_fLog, Format, ArgList);
va_end(ArgList);
fflush(g_fLog);
}
void Die_(const char *Format, ...)
{
#pragma omp critical
{
static bool InDie = false;
if (InDie)
exit(1);
InDie = true;
string Msg;
if (g_fLog != 0)
setbuf(g_fLog, 0);
va_list ArgList;
va_start(ArgList, Format);
myvstrprintf(Msg, Format, ArgList);
va_end(ArgList);
fprintf(stderr, "\n\n");
Log("\n");
time_t t = time(0);
Log("%s", asctime(localtime(&t)));
for (unsigned i = 0; i < g_Argv.size(); i++)
{
fprintf(stderr, (i == 0) ? "%s" : " %s", g_Argv[i].c_str());
Log((i == 0) ? "%s" : " %s", g_Argv[i].c_str());
}
fprintf(stderr, "\n");
Log("\n");
time_t CurrentTime = time(0);
unsigned ElapsedSeconds = unsigned(CurrentTime - g_StartTime);
const char *sstr = SecsToStr(ElapsedSeconds);
Log("Elapsed time: %s\n", sstr);
const char *szStr = Msg.c_str();
fprintf(stderr, "Elapsed time %s\n", SecsToHHMMSS((int) ElapsedSeconds));
fprintf(stderr, "Max memory %s\n", MemBytesToStr(g_PeakMemUseBytes));
fprintf(stderr, "\n---Fatal error---\n%s\n", szStr);
Log("\n---Fatal error---\n%s\n", szStr);
#ifdef _MSC_VER
if (IsDebuggerPresent())
__debugbreak();
_CrtSetDbgFlag(0);
#endif
exit(1);
}
}
void Warning_(const char *Format, ...)
{
string Msg;
va_list ArgList;
va_start(ArgList, Format);
myvstrprintf(Msg, Format, ArgList);
va_end(ArgList);
const char *szStr = Msg.c_str();
fprintf(stderr, "\nWARNING: %s\n\n", szStr);
if (g_fLog != stdout)
{
Log("\nWARNING: %s\n", szStr);
fflush(g_fLog);
}
}
#ifdef _MSC_VER
void mysleep(unsigned ms)
{
Sleep(ms);
}
#else
void mysleep(unsigned ms)
{
usleep(1000*ms);
}
#endif
#ifdef _MSC_VER
double GetMemUseBytes()
{
HANDLE hProc = GetCurrentProcess();
PROCESS_MEMORY_COUNTERS PMC;
BOOL bOk = GetProcessMemoryInfo(hProc, &PMC, sizeof(PMC));
if (!bOk)
return 1000000;
double Bytes = (double) PMC.WorkingSetSize;
if (Bytes > g_PeakMemUseBytes)
g_PeakMemUseBytes = Bytes;
return Bytes;
}
double GetPhysMemBytes()
{
MEMORYSTATUSEX MS;
MS.dwLength = sizeof(MS);
BOOL Ok = GlobalMemoryStatusEx(&MS);
if (!Ok)
return 0.0;
return double(MS.ullTotalPhys);
}
#elif linux || __linux__ || __CYGWIN__
double GetPhysMemBytes()
{
int fd = open("/proc/meminfo", O_RDONLY);
if (fd < 0)
return 0.0;
// MemTotal: 255908 kB
char Line[128];
int n = read(fd, Line, sizeof(Line));
if (n < 0)
return 0.0;
Line[127] = 0;
unsigned kb;
n = sscanf(Line, "MemTotal: %u", &kb);
if (n != 1)
return 0.0;
return double(kb)*1000.0;
}
double GetMemUseBytes()
{
static char statm[64];
static int PageSize = 1;
if (0 == statm[0])
{
PageSize = sysconf(_SC_PAGESIZE);
pid_t pid = getpid();
sprintf(statm, "/proc/%d/statm", (int) pid);
}
int fd = open(statm, O_RDONLY);
if (fd < 0)
return 0.0;
char Buffer[64];
int n = read(fd, Buffer, sizeof(Buffer) - 1);
close(fd);
fd = -1;
if (n <= 0)
return 0.0;
Buffer[n] = 0;
double Pages = atof(Buffer);
double Bytes = Pages*PageSize;
if (Bytes > g_PeakMemUseBytes)
g_PeakMemUseBytes = Bytes;
return Bytes;
}
#elif defined(__MACH__)
#include <memory.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/sysctl.h>
#include <sys/socket.h>
#include <sys/gmon.h>
#include <mach/vm_param.h>
#include <netinet/in.h>
#include <netinet/icmp6.h>
#include <sys/vmmeter.h>
#include <sys/proc.h>
// #include <mach/task_info.h>
#include <mach/task.h>
#include <mach/mach_init.h>
#include <mach/vm_statistics.h>
#define DEFAULT_MEM_USE 0.0
double GetMemUseBytes()
{
task_t mytask = mach_task_self();
struct task_basic_info ti;
memset((void *) &ti, 0, sizeof(ti));
mach_msg_type_number_t count = TASK_BASIC_INFO_COUNT;
kern_return_t ok = task_info(mytask, TASK_BASIC_INFO, (task_info_t) &ti, &count);
if (ok == KERN_INVALID_ARGUMENT)
return DEFAULT_MEM_USE;
if (ok != KERN_SUCCESS)
return DEFAULT_MEM_USE;
double Bytes = (double ) ti.resident_size;
if (Bytes > g_PeakMemUseBytes)
g_PeakMemUseBytes = Bytes;
return Bytes;
}
double GetPhysMemBytes()
{
uint64_t mempages = 0;
size_t len = sizeof(mempages);
int rc = sysctlbyname("hw.memsize", &mempages, &len, NULL, 0);
if (rc < 0)
return 0.0;
return double(mempages);
}
#else
double GetMemUseBytes()
{
return 0.0;
}
#endif
#ifdef _MSC_VER
void mylistdir(const string &DirName, vector<string> &FileNames)
{
FileNames.clear();
bool First = true;
HANDLE h = INVALID_HANDLE_VALUE;
WIN32_FIND_DATA FFD;
for (;;)
{
if (First)
{
string s = DirName + string("/*");
h = FindFirstFile(s.c_str(), &FFD);
if (h == INVALID_HANDLE_VALUE)
return;
First = false;
}
else
{
BOOL Ok = FindNextFile(h, &FFD);
if (!Ok)
return;
}
FileNames.push_back(string(FFD.cFileName));
}
}
#else
void mylistdir(const string &DirName, vector<string> &FileNames)
{
FileNames.clear();
DIR *dir = opendir(DirName.c_str());
if (dir == 0)
Die("Directory not found: %s", DirName.c_str());
for (;;)
{
struct dirent *dp = readdir(dir);
if (dp == 0)
break;
FileNames.push_back(string(dp->d_name));
}
closedir(dir);
}
#endif
double GetPeakMemUseBytes()
{
return g_PeakMemUseBytes;
}
const char *SecsToHHMMSS(int Secs)
{
int HH = Secs/3600;
int MM = (Secs - HH*3600)/60;
int SS = Secs%60;
if (HH == 0)
sprintf(g_TmpStr, "%02d:%02d", MM, SS);
else
sprintf(g_TmpStr, "%02d:%02d:%02d", HH, MM, SS);
return g_TmpStr;
}
const char *GetResourceStr()
{
double Bytes = GetMemUseBytes();
unsigned Secs = GetElapsedSecs();
g_TmpStdStr = string(SecsToHHMMSS(Secs));
if (Bytes > 0)
{
g_TmpStdStr.push_back(' ');
char Str[32];
sprintf(Str, "%s", MemBytesToStr(Bytes));
g_TmpStdStr += string(Str);
}
return g_TmpStdStr.c_str();
}
const char *SecsToStr(double Secs)
{
if (Secs >= 60.0)
return SecsToHHMMSS((int) Secs);
if (Secs < 1e-6)
sprintf(g_TmpStr, "%.2gs", Secs);
else if (Secs < 1e-3)
sprintf(g_TmpStr, "%.2fms", Secs*1e3);
else if (Secs < 1.0)
sprintf(g_TmpStr, "%.3fs", Secs);
else if (Secs < 10.0)
sprintf(g_TmpStr, "%.2fs", Secs);
else
sprintf(g_TmpStr, "%.1fs", Secs);
return g_TmpStr;
}
const char *MemBytesToStr(double Bytes)
{
if (Bytes < 1e4)
sprintf(g_TmpStr, "%.1fb", Bytes);
else if (Bytes < 1e6)
sprintf(g_TmpStr, "%.1fkb", Bytes/1e3);
else if (Bytes < 10e6)
sprintf(g_TmpStr, "%.1fMb", Bytes/1e6);
else if (Bytes < 1e9)
sprintf(g_TmpStr, "%.0fMb", Bytes/1e6);
else if (Bytes < 100e9)
sprintf(g_TmpStr, "%.1fGb", Bytes/1e9);
else
sprintf(g_TmpStr, "%.0fGb", Bytes/1e9);
return g_TmpStr;
}
bool IsValidFloatStr(const char *s)
{
char *p = 0;
double d = strtod(s, &p);
bool Bad = (p == 0 || *p != 0);
return !Bad;
}
bool IsValidFloatStr(const string &s)
{
return IsValidFloatStr(s.c_str());
}
double StrToFloat(const string &s, bool StarIsDblMax)
{
return StrToFloat(s.c_str(), StarIsDblMax);
}
double StrToFloat(const char *s, bool StarIsDblMax)
{
if (StarIsDblMax && s[0] == '*' && s[1] == 0)
return DBL_MAX;
if (!IsValidFloatStr(s))
Die("Invalid floating-point number '%s'", s);
return atof(s);
}
double StrToMemBytes(const string &s)
{
unsigned n = SIZE(s);
if (n == 0)
return 0.0;
double d = StrToFloat(s.c_str());
char c = toupper(s[n-1]);
if (isdigit(c))
return d;
else if (c == 'K')
return 1000.0*d;
else if (c == 'M')
return 1e6*d;
else if (c == 'G')
return 1e9*d;
else
Die("Invalid amount of memory '%s'", s.c_str());
return 0.0;
}
bool Replace(string &s, const string &a, const string &b)
{
size_t n = s.find(a);
if (n == string::npos)
return false;
string t;
for (size_t i = 0; i < n; ++i)
t += s[i];
size_t m = a.size();
for (size_t i = n + m; i < n; ++i)
t += s[i];
s = t;
return true;
}
bool EndsWith(const string &s, const string &t)
{
unsigned n = SIZE(s);
unsigned m = SIZE(t);
if (n < m)
return false;
for (unsigned i = 0; i < m; ++i)
if (s[n-i-1] != t[m-i-1])
return false;
return true;
}
bool IsUintStr(const char *s)
{
if (!isdigit(*s++))
return false;
while (*s)
if (!isdigit(*s++))
return false;
return true;
}
unsigned StrToUint(const char *s, bool StarIsUnitMax)
{
if (StarIsUnitMax && s[0] == '*' && s[1] == 0)
return UINT_MAX;
if (!IsUintStr(s))
Die("Invalid integer '%s'", s);
unsigned n = 0;
while (char c = *s++)
{
if (!isdigit(c))
return n;
n = n*10 + (c - '0');
}
return n;
}
int StrToInt(const char *s)
{
int i = atoi(s);
return i;
}
int StrToInt(const string &s)
{
return StrToInt(s.c_str());
}
uint64 StrToUint64(const char *s)
{
if (!IsUintStr(s))
Die("Invalid integer '%s'", s);
uint64 n = 0;
while (char c = *s++)
{
if (!isdigit(c))
return n;
n = n*10 + (c - '0');
}
return n;
}
uint64 StrToUint64(const string &s)
{
return StrToUint64(s.c_str());
}
unsigned StrToUint(const string &s, bool StarIsUnitMax)
{
return StrToUint(s.c_str(), StarIsUnitMax);
}
const char *IntToStr2(uint64 i)
{
static char *TmpStr = 0;
if (TmpStr == 0)
TmpStr = (char *) malloc(64);
if (i < 9999)
sprintf(TmpStr, "%u", (unsigned) i);
else if (i < UINT_MAX)
sprintf(TmpStr, "%u (%s)", (unsigned) i, IntToStr(i));
else
return IntToStr(i);
return TmpStr;
}
const char *PctToStr(double Pct)
{
if (Pct == 0.0)
sprintf(g_TmpStr, "0%%");
else if (Pct >= 0.1)
sprintf(g_TmpStr, "%.1f%%", Pct);
else
sprintf(g_TmpStr, "%.3f%%", Pct);
return g_TmpStr;
}
const char *IntToStrCommas(uint64 i)
{
char Tmp[64];
sprintf(Tmp, "%" PRIu64, i);
unsigned n = ustrlen(Tmp);
char Tmp2[64];
unsigned k = 0;
for (unsigned i = 0; i < n; ++i)
{
char c = Tmp[n-i-1];
if (i > 0 && i%3 == 0)
Tmp2[k++] = ',';
Tmp2[k++] = c;
}
for (unsigned i = 0; i < k; ++i)
g_TmpStr[k-i-1] = Tmp2[i];
g_TmpStr[k] = 0;
return g_TmpStr;
}
const char *IntToStr(uint64 i)
{
double d = (double) i;
if (i < 10000)
sprintf(g_TmpStr, "%u", (unsigned) i);
else if (i < 1e6)
sprintf(g_TmpStr, "%.1fk", d/1e3);
else if (i < 100e6)
sprintf(g_TmpStr, "%.1fM", d/1e6);
else if (i < 1e9)
sprintf(g_TmpStr, "%.0fM", d/1e6);
else if (i < 10e9)
sprintf(g_TmpStr, "%.1fG", d/1e9);
else if (i < 100e9)
sprintf(g_TmpStr, "%.0fG", d/1e9);
else
sprintf(g_TmpStr, "%.3g", d);
return g_TmpStr;
}
const char *Int64ToStr(uint64 i)
{
double d = (double) i;
if (i < 10000)
sprintf(g_TmpStr, "%u", (unsigned) i);
else if (i < 1e6)
sprintf(g_TmpStr, "%.1fk", d/1e3);
else if (i < 10e6)
sprintf(g_TmpStr, "%.1fM", d/1e6);
else if (i < 1e9)
sprintf(g_TmpStr, "%.0fM", d/1e6);
else if (i < 10e9)
sprintf(g_TmpStr, "%.1fG", d/1e9);
else if (i < 100e9)
sprintf(g_TmpStr, "%.0fG", d/1e9);
else
sprintf(g_TmpStr, "%.3g", d);
return g_TmpStr;
}
const char *FloatToStr(double d)
{
double a = fabs(d);
if (a < 0.01)
sprintf(g_TmpStr, "%.3g", a);
else if (a >= 0.01 && a < 1)
sprintf(g_TmpStr, "%.3f", a);
else if (a <= 10 && a >= 1)
{
double intpart;
if (modf(a, &intpart) < 0.05)
sprintf(g_TmpStr, "%.0f", d);
else
sprintf(g_TmpStr, "%.1f", d);
}
else if (a > 10 && a < 10000)
sprintf(g_TmpStr, "%.1f", d);
else if (a < 1e6)
sprintf(g_TmpStr, "%.1fk", d/1e3);
else if (a < 10e6)
sprintf(g_TmpStr, "%.1fM", d/1e6);
else if (a < 1e9)
sprintf(g_TmpStr, "%.1fM", d/1e6);
else if (a < 999e9)
sprintf(g_TmpStr, "%.1fG", d/1e9);
else if (a < 999e12)
sprintf(g_TmpStr, "%.1fT", d/1e9);
else
sprintf(g_TmpStr, "%.3g", d);
return g_TmpStr;
}
const char *FloatToStr(uint64 u)
{
return FloatToStr(double(u));
}
const char *IntFloatToStr(double d)
{
double a = fabs(d);
if (a < 1.0)
sprintf(g_TmpStr, "%.3g", a);
else if (a <= 10)
sprintf(g_TmpStr, "%.0f", d);
else if (a > 10 && a < 10000)
sprintf(g_TmpStr, "%.0f", d);
else if (a < 1e6)
sprintf(g_TmpStr, "%.1fk", d/1e3);
else if (a < 10e6)
sprintf(g_TmpStr, "%.1fM", d/1e6);
else if (a < 1e9)
sprintf(g_TmpStr, "%.1fM", d/1e6);
else if (a < 10e9)
sprintf(g_TmpStr, "%.1fG", d/1e9);
else if (a < 100e9)
sprintf(g_TmpStr, "%.1fG", d/1e9);
else
sprintf(g_TmpStr, "%.3g", d);
return g_TmpStr;
}
//static string g_CurrentProgressLine;
//static string g_ProgressDesc;
//static unsigned g_ProgressIndex;
//static unsigned g_ProgressCount;
//
//static unsigned g_CurrProgressLineLength;
//static unsigned g_LastProgressLineLength;
//static unsigned g_CountsInterval;
//static unsigned g_StepCalls;
//static time_t g_TimeLastOutputStep;
//
//static string &GetProgressPrefixStr(string &s)
// {
// double Bytes = GetMemUseBytes();
// unsigned Secs = GetElapsedSecs();
// s = string(SecsToHHMMSS(Secs));
// if (Bytes > 0)
// {
// s.push_back(' ');
// char Str[32];
// sprintf(Str, "%-6s", MemBytesToStr(Bytes));
// s += string(Str);
// }
// s.push_back(' ');
// return s;
// }
const char *GetElapsedTimeStr(string &s)
{
unsigned Secs = GetElapsedSecs();
s = string(SecsToHHMMSS(Secs));
return s.c_str();
}
const char *GetMaxRAMStr(string &s)
{
char Str[32];
sprintf(Str, "%5s", MemBytesToStr(g_PeakMemUseBytes));
s = string(Str);
return s.c_str();
}
//static bool g_ProgressPrefixOn = true;
//
//bool ProgressPrefix(bool On)
// {
// bool OldValue = g_ProgressPrefixOn;
// g_ProgressPrefixOn = On;
// return OldValue;
// }
//
//void Progress(const char *Format, ...)
// {
// string Str;
// va_list ArgList;
// va_start(ArgList, Format);
// myvstrprintf(Str, Format, ArgList);
// va_end(ArgList);
//
// Log("%s", Str.c_str());
// bool SavedPrefix = g_ProgressPrefixOn;
// g_ProgressPrefixOn = false;
// Progress("%s", Str.c_str());
// g_ProgressPrefixOn = SavedPrefix;
// }
//
//void ProgressLogPrefix(const char *Format, ...)
// {
// string Str;
// va_list ArgList;
// va_start(ArgList, Format);
// myvstrprintf(Str, Format, ArgList);
// va_end(ArgList);
//
// Log("%s\n", Str.c_str());
// Progress("%s\n", Str.c_str());
// }
void Pr(FILE *f, const char *Format, ...)
{
if (f == 0)
return;
va_list args;
va_start(args, Format);
vfprintf(f, Format, args);
va_end(args);
}
//void Progress(const char *Format, ...)
// {
// if (opt(quiet))
// return;
//
// string Str;
// va_list ArgList;
// va_start(ArgList, Format);
// myvstrprintf(Str, Format, ArgList);
// va_end(ArgList);
//
//#if 0
// Log("Progress(");
// for (unsigned i = 0; i < Str.size(); ++i)
// {
// char c = Str[i];
// if (c == '\r')
// Log("\\r");
// else if (c == '\n')
// Log("\\n");
// else
// Log("%c", c);
// }
// Log(")\n");
//#endif //0
//
// for (unsigned i = 0; i < Str.size(); ++i)
// {
// if (g_ProgressPrefixOn && g_CurrProgressLineLength == 0)
// {
// string s;
// GetProgressPrefixStr(s);
// for (unsigned j = 0; j < s.size(); ++j)
// {
// fputc(s[j], stderr);
// ++g_CurrProgressLineLength;
// }
// }
//
// char c = Str[i];
// if (c == '\n' || c == '\r')
// {
// for (unsigned j = g_CurrProgressLineLength; j < g_LastProgressLineLength; ++j)
// fputc(' ', stderr);
// if (c == '\n')
// g_LastProgressLineLength = 0;
// else
// g_LastProgressLineLength = g_CurrProgressLineLength;
// g_CurrProgressLineLength = 0;
// fputc(c, stderr);
// }
// else
// {
// fputc(c, stderr);
// ++g_CurrProgressLineLength;
// }
// }
// }
void LogProgramInfoAndCmdLine()
{
PrintProgramInfo(g_fLog);
PrintCmdLine(g_fLog);
#ifdef _MSC_VER
const char *e = getenv("CYGTZ");
if (e != 0 && strcmp(e, "YES") == 0)
putenv("TZ=");
#endif
time_t Now = time(0);
struct tm *t = localtime(&Now);
const char *s = asctime(t);
Log("Started %s", s); // there is a newline in s
}
void LogElapsedTimeAndRAM()
{
time_t Now = time(0);
struct tm *t = localtime(&Now);
const char *s = asctime(t);
unsigned Secs = GetElapsedSecs();
Log("\n");
Log("Finished %s", s); // there is a newline in s
Log("Elapsed time %s\n", SecsToHHMMSS((int) Secs));
Log("Max memory %s\n", MemBytesToStr(g_PeakMemUseBytes));
#if WIN32 && DEBUG
// Skip exit(), which can be very slow in DEBUG build
// VERY DANGEROUS practice, because it skips global destructors.
// But if you know the rules, you can break 'em, right?
ExitProcess(0);
#endif
}
const char *PctStr(double x, double y)
{
if (y == 0)
{
if (x == 0)
return "100%";
else
return "inf%";
}
static char Str[16];
double p = x*100.0/y;
sprintf(Str, "%5.1f%%", p);
return Str;
}
#if TIMING
static time_t g_LastLogTimerSecs;
#endif
static unsigned GetStructPack()
{
struct
{
char a;
char b;
} x;
return (unsigned) (&x.b - &x.a);
}
void CompilerInfo()
{
printf("%u bits\n", BITS);
#ifdef __GNUC__
printf("__GNUC__\n");
#endif
#ifdef __APPLE__
printf("__APPLE__\n");
#endif
#ifdef _MSC_VER
printf("_MSC_VER %d\n", _MSC_VER);
#endif
#define x(t) printf("sizeof(" #t ") = %d\n", (int) sizeof(t));
x(int)
x(long)
x(float)
x(double)
x(void *)
x(off_t)
x(size_t)
#undef x
printf("pack(%u)\n", GetStructPack());
#ifdef _FILE_OFFSET_BITS
printf("_FILE_OFFSET_BITS = %d\n", _FILE_OFFSET_BITS);
#else
printf("_FILE_OFFSET_BITS not defined\n");
#endif
exit(0);
}
bool StartsWith(const char *S, const char *T)
{
for (;;)
{
char t = *T++;
if (t == 0)
return true;
char s = *S++;
if (s != t)
return false;
}
}
void Reverse(string &s)
{
unsigned n = SIZE(s);
string t;
for (unsigned i = 0; i < n; ++i)
t += s[n-i-1];
s = t;
}
bool StartsWith(const string &S, const char *T)
{
return StartsWith(S.c_str(), T);
}
bool StartsWith(const string &s, const string &t)
{
return StartsWith(s.c_str(), t.c_str());
}
void ToUpper(const string &s, string &t)
{
t.clear();
const unsigned n = SIZE(s);
for (unsigned i = 0; i < n; ++i)
t.push_back(toupper(s[i]));
}
void ToLower(const string &s, string &t)
{
t.clear();
const unsigned n = SIZE(s);
for (unsigned i = 0; i < n; ++i)
t.push_back(tolower(s[i]));
}
void TruncWhiteSpace(string &Str)
{
for (unsigned i = 0; i < SIZE(Str); ++i)
{
char c = Str[i];
if (isspace(c))
{
Str.resize(i);
return;
}
}
}
void StripWhiteSpace(string &Str)
{
unsigned n = SIZE(Str);
unsigned FirstNonWhite = UINT_MAX;
unsigned LastNonWhite = UINT_MAX;
for (unsigned i = 0; i < n; ++i)
{
char c = Str[i];
if (!isspace(c))
{
if (FirstNonWhite == UINT_MAX)
FirstNonWhite = i;
LastNonWhite = i;
}
}
if (FirstNonWhite == UINT_MAX)
return;
string t;
for (unsigned i = FirstNonWhite; i <= LastNonWhite; ++i)
{
char c = Str[i];
t += c;
}
Str = t;
}
void Split(const string &Str, vector<string> &Fields, char Sep)
{
Fields.clear();
const unsigned Length = (unsigned) Str.size();
string s;
for (unsigned i = 0; i < Length; ++i)
{
char c = Str[i];
if ((Sep == 0 && isspace(c)) || c == Sep)
{
if (!s.empty() || Sep != 0)
Fields.push_back(s);
s.clear();
}
else
s.push_back(c);
}
if (!s.empty())
Fields.push_back(s);
}
void Version(FILE *f)
{
if (f == 0)
return;
const char *Flags = ""
#if DEBUG
"D"
#endif
#if TIMING
"T"
#endif
;
fprintf(f, PROGRAM_NAME " v%s.%s_%s%s", MY_VERSION, SVN_VERSION, GetPlatform(), Flags);
}
void cmd_version()
{
Version(stdout);
printf("\n");
exit(0);
}
void Help()
{
PrintProgramInfo(stdout);
PrintCopyright(stdout);
exit(0);
}
void PrintProgramInfo(FILE *f)
{
if (f == 0)
return;
fprintf(f, "\n");
Version(f);
double RAM = GetPhysMemBytes();
double UsableRAM = GetUsableMemBytes();
if (RAM > 0)
{
if (RAM == UsableRAM)
fprintf(f, ", %s RAM", MemBytesToStr(RAM));
else
{
fprintf(f, ", %s RAM", MemBytesToStr(UsableRAM));
fprintf(f, " (%s total)", MemBytesToStr(RAM));
}
fprintf(f, ", %u cores\n", GetCPUCoreCount());
}
}
void PrintCopyright(FILE *f)
{
if (f == 0)
return;
fprintf(f, "(C) Copyright 2019 Robert C. Edgar\n");
fprintf(f, "https://drive5.com/urmap\n");
fprintf(f, "\n");
}
void PrintCmdLine(FILE *f)
{
if (f == 0)
return;
for (unsigned i = 0; i < SIZE(g_Argv); ++i)
fprintf(f, "%s ", g_Argv[i].c_str());
fprintf(f, "\n");
}
void GetCmdLine(string &s)
{
s.clear();
for (unsigned i = 0; i < SIZE(g_Argv); ++i)
{
if (i > 0)
s += " ";
s += g_Argv[i];
}
}
char *mystrsave(const char *s)
{
unsigned n = unsigned(strlen(s));
char *t = myalloc(char, n+1);
memcpy(t, s, n+1);
return t;
}
unsigned myipow(unsigned x, unsigned y)
{
unsigned result = 1;
for (unsigned k = 0; k < y; ++k)
{
if (result > UINT_MAX/x)
Die("myipow(%u, %u), overflow", x, y);
result *= x;
}
return result;
}
uint64 myipow64(unsigned x, unsigned y)
{
uint64 result = 1;
for (unsigned k = 0; k < y; ++k)
{
if (result > uint64(UINT64_MAX)/uint64(x))
Die("myipow(%u, %u), overflow", x, y);
result *= x;
}
return result;
}
void LogInt(unsigned i, unsigned w)
{
if (w == UINT_MAX)
{
if (i < 9999)
Log("%u", i);
else
Log("%u (%s)", i, IntToStr(i));
}
else
{
if (i < 9999)
Log("%*u", w, i);
else
Log("%*u (%s)", w, i, IntToStr(i));
}
}
void Logu(unsigned u, unsigned w, unsigned prefixspaces)
{
for (unsigned i = 0; i < prefixspaces; ++i)
Log(" ");
if (u == UINT_MAX)
Log("%*.*s", w, w, "*");
else
Log("%*u", w, u);
}
void Logf(float x, unsigned w, unsigned prefixspaces)
{
for (unsigned i = 0; i < prefixspaces; ++i)
Log(" ");
if (x == FLT_MAX)
Log("%*.*s", w, w, "*");
else
Log("%*.2f", w, x);
}
static uint32 g_SLCG_state = 1;
// Simple Linear Congruential Generator
// Bad properties; used just to initialize the better generator.
// Numerical values used by Microsoft C, according to wikipedia:
// http://en.wikipedia.org/wiki/Linear_congruential_generator
static uint32 g_SLCG_a = 214013;
static uint32 g_SLCG_c = 2531011;
static uint32 SLCG_rand()
{
g_SLCG_state = g_SLCG_state*g_SLCG_a + g_SLCG_c;
return g_SLCG_state;
}
static void SLCG_srand(uint32 Seed)
{
g_SLCG_state = Seed;
for (int i = 0; i < 10; ++i)
SLCG_rand();
}
/***
A multiply-with-carry random number generator, see:
http://en.wikipedia.org/wiki/Multiply-with-carry
The particular multipliers used here were found on
the web where they are attributed to George Marsaglia.
***/
static bool g_InitRandDone = false;
static uint32 g_X[5];
static void InitRand()
{
if (g_InitRandDone)
return;
// Do this first to avoid recursion
g_InitRandDone = true;
unsigned Seed;
if (optset_randseed)
Seed = opt(randseed);
else
Seed = (unsigned) (time(0)*getpid());
ResetRand(Seed);
}
static void IncrementRand()
{
uint64 Sum = 2111111111*(uint64) g_X[3] + 1492*(uint64) g_X[2] +
1776*(uint64) g_X[1] + 5115*(uint64) g_X[0] + g_X[4];
g_X[3] = g_X[2];
g_X[2] = g_X[1];
g_X[1] = g_X[0];
g_X[4] = (uint32) (Sum >> 32);
g_X[0] = (uint32) Sum;
}
uint32 RandInt32()
{
InitRand();
IncrementRand();
return g_X[0];
}
unsigned randu32()
{
return (unsigned) RandInt32();
}
uint64 randu64()
{
union
{
struct
{
uint32 u32[2];
};
uint64 u64;
} x;
x.u32[0] = randu32();
x.u32[1] = randu32();
return x.u64;
}
void ResetRand(unsigned Seed)
{
SLCG_srand(Seed);
for (unsigned i = 0; i < 5; i++)
g_X[i] = SLCG_rand();
for (unsigned i = 0; i < 100; i++)
IncrementRand();
}
unsigned GetCPUCoreCount()
{
#ifdef _MSC_VER
SYSTEM_INFO SI;
GetSystemInfo(&SI);
unsigned n = SI.dwNumberOfProcessors;
if (n == 0 || n > 64)
return 1;
return n;
#else
long n = sysconf(_SC_NPROCESSORS_ONLN);
if (n <= 0)
return 1;
return (unsigned) n;
#endif
}
unsigned GetThreadIndex()
{
return omp_get_thread_num();
}
// MUST COME AT END BECAUSE OF #undefs
#undef myalloc
#undef myfree
#if RCE_MALLOC
#undef mymalloc
#undef myfree
#undef myfree2
static unsigned g_NewCalls;
static unsigned g_FreeCalls;
static double g_InitialMemUseBytes;
static double g_TotalAllocBytes;
static double g_TotalFreeBytes;
static double g_NetBytes;
static double g_MaxNetBytes;
void LogAllocStats()
{
Log("\n");
Log(" Allocs %u\n", g_NewCalls);
Log(" Frees %u\n", g_FreeCalls);
Log("Initial alloc %s\n", MemBytesToStr(g_InitialMemUseBytes));
Log(" Total alloc %s\n", MemBytesToStr(g_TotalAllocBytes));
Log(" Total free %s\n", MemBytesToStr(g_TotalFreeBytes));
Log(" Net bytes %s\n", MemBytesToStr(g_NetBytes));
Log("Max net bytes %s\n", MemBytesToStr(g_MaxNetBytes));
Log(" Peak total %s\n", MemBytesToStr(g_MaxNetBytes + g_InitialMemUseBytes));
}
void *mymalloc(unsigned n, unsigned bytes, const char *FileName, int Line)
{
// void *rce_malloc(unsigned bytes, const char *FileName, int Line);
return rce_malloc(n, bytes, FileName, Line);
}
void myfree(void *p, const char *FileName, int Line)
{
// void rce_free(void *p, const char *FileName, int Line);
rce_free(p, FileName, Line);
}
void myfree2(void *p, unsigned bytes, const char *FileName, int Line)
{
// void rce_free(void *p, const char *FileName, int Line);
rce_free(p, FileName, Line);
}
#else // RCE_MALLOC
#if ALLOC_TOTALS
void LogAllocSummary()
{
extern unsigned g_AllocCount;
extern unsigned g_FreeCount;
extern uint64 g_AllocTotal;
extern uint64 g_FreeTotal;
double RAM = GetMemUseBytes();
Log("RAM %s", MemBytesToStr(RAM));
Log(", malloc %s", MemBytesToStr(g_AllocTotal));
Log(", free %s", MemBytesToStr(g_FreeTotal));
Log(", net %s\n", MemBytesToStr(g_AllocTotal - g_FreeTotal));
}
#endif
void *mymalloc64(uint64 BytesPerObject, uint64 N)
{
uint64 Bytes64 = BytesPerObject*N;
#if USE_DBG_MALLOC
void *p = _malloc_dbg(Bytes64, _NORMAL_BLOCK, __FILE__, __LINE__);
#else
void *p = malloc(Bytes64);
#endif
if (p == 0)
Die("myalloc64(%" PRIu64 ", %" PRIu64 ") failed", BytesPerObject, N);
return p;
}
void *mymalloc(unsigned n, unsigned bytes)
{
++g_AllocCount;
uint64 Bytes64 = uint64(n)*uint64(bytes);
if (Bytes64 > uint64(UINT_MAX))
Die("%s(%u): mymalloc(%u, %u) overflow", g_AllocFile, g_AllocLine, n, bytes);
#if ALLOC_TOTALS
g_AllocTotal += Bytes64;
Bytes64 += 4;
#endif
uint32 Bytes32 = uint32(Bytes64);
#if USE_DBG_MALLOC
void *p = _malloc_dbg(Bytes32, _NORMAL_BLOCK, __FILE__, __LINE__);
#else
void *p = malloc(Bytes32);
#endif
if (0 == p)
{
double b = GetMemUseBytes();
double Total = b + double(Bytes32);
#if BITS==32
if (Total > 2e9)
{
Log("\n%s(%u): Out of memory, mymalloc(%u, %u), curr %.3g bytes, total %.3g (%s)\n",
g_AllocFile, g_AllocLine, n, bytes, b, Total, MemBytesToStr(Total));
Die("Memory limit of 32-bit process exceeded, 64-bit build required");
}
#endif
fprintf(stderr, "\n%s(%u): Out of memory mymalloc(%u), curr %.3g bytes",
g_AllocFile, g_AllocLine, (unsigned) bytes, b);
#if DEBUG && defined(_MSC_VER)
asserta(_CrtCheckMemory());
#endif
Die("%s(%u): Out of memory, mymalloc(%u, %u), curr %.3g bytes, total %.3g (%s)\n",
g_AllocFile, g_AllocLine, n, bytes, b, Total, MemBytesToStr(Total));
}
#if ALLOC_TOTALS
*((uint32 *) p) = Bytes32;
return (void *) ((byte *) p + 4);
#else
return p;
#endif
}
void myfree(void *p)
{
if (p == 0)
return;
++g_FreeCount;
#if ALLOC_TOTALS
uint32 *pi = (uint32 *) p;
uint32 Bytes32 = *(pi - 1);
g_FreeTotal += Bytes32;
free((void *) (pi - 1));
#else
#if USE_DBG_MALLOC
_free_dbg(p, _NORMAL_BLOCK);
#else
free(p);
#endif
#endif
}
#endif // RCE_MALLOC
| 46,466
|
C++
|
.cpp
| 2,053
| 20.400877
| 101
| 0.654139
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,985
|
cmd.cpp
|
rcedgar_urmap/src/cmd.cpp
|
#include "myutils.h"
#include "cmd.h"
#define IS_TRUE(x) case CMD_##x: return true;
//#define ____(x) case CMD_##x: return false;
const char *CmdToStr(CMD Cmd)
{
switch (Cmd)
{
#define A(x) case CMD_##x: return #x;
#include "cmds.h"
default:
asserta(false);
}
return 0;
}
CMD StrToCmd(const char *Str)
{
#define A(x) if (!strcmp(Str, #x)) return CMD_##x;
Die("Invalid cmd '%s'", Str);
return CMD_none;
}
| 422
|
C++
|
.cpp
| 21
| 18.238095
| 50
| 0.650754
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,986
|
fastq.cpp
|
rcedgar_urmap/src/fastq.cpp
|
#include "myutils.h"
#include "fastq.h"
#include "seqinfo.h"
/***
FASTQ format variants per:
Cock et al. (2010) The Sanger FASTQ file format for sequences
with quality scores, and the Solexa/Illumina FASTQ variants, NAR.
Qual score
ASCII Offset Type Range Variant
------ ------ ---- ----- -------
33-126 33 Phred 0 to 93 Sanger
59-126 64 Solexa -5 to 62 Solexa (Solexa and Illumina < v1.3)
64-126 64 Phred 0 to 40 Illumina (Illumina v1.3+)
P_e = prob error
Phred definition, this is the only one usually found in practice:
Q_Phred = -10 x log_10(P_e)
Solexa definition used only in obsolete FASTQ variant:
Q_Solexa = -10 x log_10(P_e/(1 - P_e))
Conversion:
P_e = 10 ^ (-Q_Phred/10)
Q to P_e table (phred.py):
33=! 0 1.00000 1.00e+00 34=" 1 0.79433 7.94e-01 35=# 2 0.63096 6.31e-01
36=$ 3 0.50119 5.01e-01 37=% 4 0.39811 3.98e-01 38=& 5 0.31623 3.16e-01
39=' 6 0.25119 2.51e-01 40=( 7 0.19953 2.00e-01 41=) 8 0.15849 1.58e-01
42=* 9 0.12589 1.26e-01 43=+ 10 0.10000 1.00e-01 44=, 11 0.07943 7.94e-02
45=- 12 0.06310 6.31e-02 46=. 13 0.05012 5.01e-02 47=/ 14 0.03981 3.98e-02
48=0 15 0.03162 3.16e-02 49=1 16 0.02512 2.51e-02 50=2 17 0.01995 2.00e-02
51=3 18 0.01585 1.58e-02 52=4 19 0.01259 1.26e-02 53=5 20 0.01000 1.00e-02
54=6 21 0.00794 7.94e-03 55=7 22 0.00631 6.31e-03 56=8 23 0.00501 5.01e-03
57=9 24 0.00398 3.98e-03 58=: 25 0.00316 3.16e-03 59=; 26 0.00251 2.51e-03
60=< 27 0.00200 2.00e-03 61== 28 0.00158 1.58e-03 62=> 29 0.00126 1.26e-03
63=? 30 0.00100 1.00e-03 64=@ 31 0.00079 7.94e-04 65=A 32 0.00063 6.31e-04
66=B 33 0.00050 5.01e-04 67=C 34 0.00040 3.98e-04 68=D 35 0.00032 3.16e-04
69=E 36 0.00025 2.51e-04 70=F 37 0.00020 2.00e-04 71=G 38 0.00016 1.58e-04
72=H 39 0.00013 1.26e-04 73=I 40 0.00010 1.00e-04
Expected number of errors = Sum P_e
FASTQ variants per Wikipedia 10/14/2012:
S - Sanger Phred+33, raw reads typically (0, 40)
X - Solexa Solexa+64, raw reads typically (-5, 40)
I - Illumina 1.3+ Phred+64, raw reads typically (0, 40)
J - Illumina 1.5+ Phred+64, raw reads typically (3, 40)
with 0=unused, 1=unused, 2=Read Segment Quality Control Indicator (bold)
(Note: See discussion above).
L - Illumina 1.8+ Phred+33, raw reads typically (0, 41)
Challenge
---------
PacBio ASCII='!'=33 .. '0'=48, range 16
-fastq_qmin 0 -fastq_qmax 16 -fastq_ascii 33
454, IonTorrent ASCII='!'=33 .. 'I'=73, range 41
-fastq_qmin 0 -fastq_qmax 40 -fastq_ascii 33
Illumina ASCII='!'=33 .. 'J'=74, range 42
-fastq_qmin 0 -fastq_qmax 41 -fastq_ascii 33
***/
byte FastQ::m_ASCII_Offset = 33;
byte FastQ::m_IntQual_Min = 0;
byte FastQ::m_IntQual_Max = 41;
byte FastQ::m_IntQualOut_Max = 41;
bool FastQ::m_ForceQ = false;
byte *FastQ::m_CharToIntQual;
double *FastQ::m_CharToProb;
double *FastQ::m_CharToProb33;
double *FastQ::m_CharToProb64;
double *FastQ::m_IntQualToProb;
double *FastQ::m_IntQualToLogProbCorrect;
byte **FastQ::m_PairMatchInt = 0;
byte **FastQ::m_PairMatchChar = 0;
byte **FastQ::m_PairMismatchInt = 0;
char **FastQ::m_CharPairMatchChar = 0;
char **FastQ::m_CharPairMismatchChar = 0;
void FastQ::Alloc()
{
if (m_CharToProb != 0)
return;
m_CharToProb = myalloc(double, 256);
m_CharToProb33 = myalloc(double, 256);
m_CharToProb64 = myalloc(double, 256);
m_IntQualToProb = myalloc(double, 256);
m_IntQualToLogProbCorrect = myalloc(double, 256);
m_CharToIntQual = myalloc(byte, 256);
}
void FastQ::Init(byte Base, byte MinQ, byte MaxQ, byte MaxQOut)
{
m_ASCII_Offset = Base;
m_IntQual_Min = MinQ;
m_IntQual_Max = MaxQ;
m_IntQualOut_Max = MaxQOut;
Alloc();
for (unsigned i = 0; i < 256; ++i)
{
m_CharToIntQual[i] = 0xff;
m_CharToProb[i] = 0.0;
m_CharToProb33[i] = 0.0;
m_CharToProb64[i] = 0.0;
m_IntQualToProb[i] = 0.0;
}
for (int IntQual = 0; IntQual < 256; ++IntQual)
{
double Prob = pow(10.0, -(IntQual/10.0));
if (IntQual + 33 < 127)
m_CharToProb33[IntQual + 33] = Prob;
if (IntQual + 64 < 127)
m_CharToProb64[IntQual + 64] = Prob;
}
for (unsigned IntQual = m_IntQual_Min; IntQual <= m_IntQual_Max; ++IntQual)
{
double Prob = pow(10.0, -(IntQual/10.0));
double ProbCorrect = 1.0 - Prob;
double LogProbCorrect = log(ProbCorrect);
m_IntQualToProb[IntQual] = Prob;
m_IntQualToLogProbCorrect[IntQual] = LogProbCorrect;
byte Ch = IntQualToChar(IntQual);
m_CharToProb[Ch] = Prob;
byte Q = byte(IntQual);
m_CharToIntQual[Ch] = Q;
}
InitMerge();
}
void FastQ::AllocMerge()
{
m_PairMatchInt = myalloc(byte *, 256);
m_PairMismatchInt = myalloc(byte *, 256);
m_PairMatchChar = myalloc(byte *, 256);
m_CharPairMatchChar = myalloc(char *, 256);
m_CharPairMismatchChar = myalloc(char *, 256);
for (unsigned i = 0; i < 256; ++i)
{
m_PairMatchInt[i] = myalloc(byte, 256);
m_PairMatchChar[i] = myalloc(byte, 256);
m_PairMismatchInt[i] = myalloc(byte, 256);
m_CharPairMatchChar[i] = myalloc(char, 256);
m_CharPairMismatchChar[i] = myalloc(char, 256);
memset_zero(m_PairMatchInt[i], 256);
memset_zero(m_PairMatchChar[i], 256);
memset_zero(m_PairMismatchInt[i], 256);
memset(m_CharPairMatchChar[i], '?', 256);
memset(m_CharPairMismatchChar[i], '?', 256);
}
}
void FastQ::InitMerge()
{
AllocMerge();
for (unsigned IntQual1 = FastQ::m_IntQual_Min; IntQual1 <= FastQ::m_IntQual_Max; ++IntQual1)
{
double P1 = pow(10.0, -double(IntQual1)/10.0);
asserta(P1 >= 0.0 && P1 <= 1.01);
for (unsigned IntQual2 = FastQ::m_IntQual_Min; IntQual2 <= FastQ::m_IntQual_Max; ++IntQual2)
{
double P2 = pow(10.0, -double(IntQual2)/10.0);
asserta(P2 >= 0.0 && P2 <= 1.01);
double PC = (1.0 - P1)*(1.0 - P2);
double PF = (1.0 - P1)*P2;
double PR = (1.0 - P2)*P1;
double PW = (2.0/3.0)*P1*P2;
double PX = (1.0/3.0)*P1*P2;
double P = PC + PF + PR + PW + PX;
asserta(P > 0.99 && P < 1.01);
double PA = PC + PX;
double PD = PF + PR + PW;
asserta(PA+PD > 0.99 && PA+PD < 1.01);
double PMatch = PX/PA;
double PMismatch = (PR + PW)/PD;
double QMatch = -10.0*log10(PMatch);
double QMismatch = -10.0*log10(PMismatch);
int iQMatch = int(QMatch + 0.5);
int iQMismatch = int(QMismatch + 0.5);
if (iQMatch < (int) m_IntQual_Min)
iQMatch = (int) m_IntQual_Min;
if (iQMatch > (int) m_IntQualOut_Max)
iQMatch = (int) m_IntQualOut_Max;
if (iQMismatch < (int) m_IntQual_Min)
iQMismatch = (int) m_IntQual_Min;
if (iQMismatch > (int) m_IntQualOut_Max)
iQMismatch = (int) m_IntQualOut_Max;
byte qm = (byte) iQMatch;
m_PairMatchInt[IntQual1][IntQual2] = qm;
m_PairMatchInt[IntQual2][IntQual1] = qm;
byte qmm = (byte) iQMismatch;
m_PairMismatchInt[IntQual1][IntQual2] = qmm;
m_PairMismatchInt[IntQual2][IntQual1] = qmm;
byte c1 = IntQualToChar(IntQual1);
byte c2 = IntQualToChar(IntQual2);
byte cm = IntQualToChar(qm);
byte cmm = IntQualToChar(qmm);
m_PairMatchChar[c1][c2] = cm;
m_PairMatchChar[c2][c1] = cm;
m_CharPairMatchChar[c1][c2] = cm;
m_CharPairMatchChar[c2][c1] = cm;
m_CharPairMismatchChar[c1][c2] = cmm;
m_CharPairMismatchChar[c2][c1] = cmm;
}
}
}
void FastQ::InitFromCmdLine()
{
static bool InitDone = false;
if (InitDone)
return;
InitDone = true;
byte Base = opt(fastq_ascii);
byte MinQ = opt(fastq_qmin);
byte MaxQ = opt(fastq_qmax);
byte MaxQOut = opt(fastq_qmaxout);
Init(Base, MinQ, MaxQ, MaxQOut);
FastQ::m_ForceQ = opt(fastq_forceq);
}
double FastQ::GetEE(const char *Qual, unsigned L)
{
asserta(Qual != 0);
double SumP = 0.0;
for (unsigned i = 0; i < L; ++i)
{
char q = Qual[i];
double P = CharToProb(q);
SumP += P;
}
return SumP;
}
void FastQ::LogTables()
{
Log("\n");
Log("Merge:\n");
Log("Qf Qr Qa Qd\n");
Log("-- -- -- --\n");
for (unsigned Qf = 2; Qf <= 40; ++Qf)
{
for (unsigned Qr = 2; Qr <= 40; ++Qr)
{
unsigned Qa = m_PairMatchInt[Qf][Qr];
unsigned Qd = m_PairMismatchInt[Qf][Qr];
Log("%2u %2u %2u %2u\n", Qf, Qr, Qa, Qd);
}
}
}
byte FastQ::GetMinCharQ(const char *Qual, unsigned L)
{
byte MinQ = 255;
for (unsigned i = 0; i < L; ++i)
{
if (Qual[i] < MinQ)
MinQ = Qual[i];
}
return MinQ;
}
byte FastQ::GetMaxCharQ(const char *Qual, unsigned L)
{
byte MaxQ = 0;
for (unsigned i = 0; i < L; ++i)
{
if (Qual[i] > MaxQ)
MaxQ = Qual[i];
}
return MaxQ;
}
double FastQ::GetEE_33(const char *Qual, unsigned L)
{
double EE = 0.0;
for (unsigned i = 0; i < L; ++i)
EE += m_CharToProb33[Qual[i]];
return EE;
}
double FastQ::GetEE_64(const char *Qual, unsigned L)
{
double EE = 0.0;
for (unsigned i = 0; i < L; ++i)
EE += m_CharToProb64[Qual[i]];
return EE;
}
unsigned FastQ::GuessBase(const string &FileName)
{
vector<byte> Chars;
GetQualChars(FileName, 500, Chars);
byte Base = GuessBaseFromChars(Chars);
return Base;
}
unsigned FastQ::GuessBaseFromChars(const vector<byte> &Chars)
{
const unsigned N = SIZE(Chars);
if (N < 100)
return 0xff;
unsigned N33 = 0;
unsigned N64 = 0;
for (unsigned i = 0; i < N; ++i)
{
unsigned c = (unsigned char) Chars[i];
if (c < 33)
return UINT_MAX;
if (c >= 33 && c <= 33+45)
++N33;
if (c >= 64 && c <= 64+45)
++N64;
}
if (N33 > N64 && N33 > 3*N/4)
return 33;
if (N64 > N33 && N64 > 3*N/4)
return 64;
return 0xff;
}
void FastQ::GetQualChars(const string &FileName, unsigned N,
vector<byte> &Chars)
{
Chars.clear();
Chars.reserve(N);
string Line;
unsigned Total = 0;
FILE *f = OpenStdioFile(FileName);
for (;;)
{
for (unsigned i = 0; i < 4; ++i)
{
bool Ok = ReadLineStdioFile(f, Line);
if (!Ok)
goto Done;
if (i == 3)
{
unsigned L = SIZE(Line);
for (unsigned j = 0; j < L; ++j)
{
if (Total >= N)
return;
byte c = Line[j];
Chars.push_back(c);
++Total;
}
}
}
}
Done:;
CloseStdioFile(f);
}
static byte g_Base;
void FastQ::SetBaseGuess(const string &FileName)
{
if (opt(fastq_noguess))
return;
byte Base = FastQ::GuessBase(FileName);
if (Base != 0xff)
{
if (g_Base == 0)
{
g_Base = Base;
Progress("FASTQ base %u for file %s\n", Base, FileName.c_str());
byte MinQ = opt(fastq_qmin);
byte MaxQ = opt(fastq_qmax);
byte MaxQOut = opt(fastq_qmaxout);
FastQ::Init(Base, MinQ, MaxQ, MaxQOut);
}
else if (g_Base != Base)
Die("FASTQ format conflict, base 33 and 64 detected");
}
}
| 10,578
|
C++
|
.cpp
| 350
| 27.428571
| 94
| 0.635881
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| true
| false
| true
| false
|
1,537,987
|
ungappedblast.cpp
|
rcedgar_urmap/src/ungappedblast.cpp
|
#include "myutils.h"
#include "hspfinder.h"
#include "mx.h"
#include "evalue.h"
#define TRACE 0
void HSPFinder::UngappedBlast(float X, bool StaggerOk, unsigned MinLength, float MinScore)
{
IncCounter(UngappedBlast);
#if TRACE
Log("\n");
Log("Blast()\n");
Log("A>%s\n", m_SA->m_Label);
Log("B>%s\n", m_SB->m_Label);
Log("A=%*.*s\n", m_SA->m_L, m_SA->m_L, m_SA->m_Seq);
Log("B=%*.*s\n", m_SB->m_L, m_SB->m_L, m_SB->m_Seq);
#endif
StartTimer(UngappedBlast);
if (MinScore < 0)
MinScore = (float) ComputeMinScoreGivenEvalueQUngapped(opt(evalue), m_SA->m_L);
m_UngappedHSPCount = 0;
if (m_SB->m_L < 2*m_WordLength)
{
EndTimer(UngappedBlast);
return;
}
const byte *A = m_SA->m_Seq;
const byte *B = m_SB->m_Seq;
unsigned LA = m_SA->m_L;
unsigned LB = m_SB->m_L;
unsigned HitCount = 0;
#if TRACE
{
Log(" APos BPos %*.*s Diag\n", m_WordLength, m_WordLength, "Word");
Log("----- ----- ");
for (unsigned i = 0; i < m_WordLength; ++i)
Log("-");
Log(" -----");
Log("\n");
}
#endif
unsigned BPos = 0;
for (;;)
{
if (BPos >= m_WordCountB)
break;
unsigned Word = m_WordsB[BPos];
assert(Word < m_WordCount);
unsigned NA = m_WordCountsA[Word];
if (NA == 0)
{
++BPos;
continue;
}
for (unsigned i = 0; i < NA; ++i)
{
unsigned APos = m_WordToPosA[Word*MaxReps+i];
unsigned Diag = (LA + BPos) - APos;
#if TRACE
Log("%5u %5u %s %5u", APos, BPos, WordToStr(Word), Diag);
#endif
unsigned BPos2 = BPos + m_WordLength - 1;
unsigned APos2 = APos + m_WordLength - 1;
// if (APos2 >= m_WordCountA || BPos2 >= m_WordCountB)
if (APos2 >= LA || BPos2 >= LB)
{
#if TRACE
Log("\n");
#endif
continue;
}
float Score = 0;
for (unsigned j = 0; j < m_WordLength; ++j)
{
byte a = A[APos + j];
byte b = B[BPos + j];
Score += m_SubstMx[a][b];
}
float BestScore = Score;
unsigned BestBPos2 = BPos2;
// Extend right
#if TRACE
Log(" >>");
#endif
for (;;)
{
++BPos2;
if (BPos2 >= LB)
break;
++APos2;
if (APos2 >= LA)
break;
byte a = A[APos2];
byte b = B[BPos2];
Score += m_SubstMx[a][b];
#if TRACE
Log(" %c%c(%+.0f=%.0f)",
a, b, m_SubstMx[a][b], Score);
#endif
if (Score > BestScore)
{
#if TRACE
Log("*");
#endif
BestScore = Score;
BestBPos2 = BPos2;
}
else if (BestScore - Score > X)
break;
}
// Extend left
#if TRACE
Log(" <<");
#endif
unsigned APos1 = APos;
unsigned BPos1 = BPos;
unsigned BestBPos1 = BPos1;
Score = BestScore;
for (;;)
{
if (BPos1 == 0 || APos1 == 0)
break;
--BPos1;
--APos1;
byte a = A[APos1];
byte b = B[BPos1];
Score += m_SubstMx[a][b];
#if TRACE
Log(" %c%c(%+.0f=%.0f)",
a, b, m_SubstMx[a][b], Score);
#endif
if (Score > BestScore)
{
#if TRACE
Log("*");
#endif
BestScore = Score;
BestBPos1 = BPos1;
}
else if (BestScore - Score > X)
break;
}
unsigned Blo = BestBPos1;
unsigned Bhi = BestBPos2;
assert(Bhi < LB);
unsigned Length = Bhi - Blo + 1;
unsigned Alo = (m_SA->m_L + BestBPos1) - Diag;
unsigned Ahi = Alo + Length - 1;
assert(Ahi < LA);
#if TRACE
{
float Score2 = 0.0f;
for (unsigned i = 0; i < Length; ++i)
{
byte a = A[Alo+i];
byte b = B[Blo+i];
Score2 += m_SubstMx[a][b];
Log(" %c%c", a, b);
}
Log(" = %.1f %.1f", BestScore, Score2);
Log("\n");
}
#endif
bool Ok = (Length >= MinLength && BestScore >= MinScore);
if (!StaggerOk)
Ok = (Ok && IsGlobalHSP(Alo, Blo, Length, LA, LB));
if (Ok)
{
++HitCount;
IncCounter(HitExtends);
AddCounter(HitExtendLetters, Length);
AllocHSPCount(m_UngappedHSPCount+1);
HSPData &HSP = *m_UngappedHSPs[m_UngappedHSPCount];
HSP.Loi = Alo;
HSP.Loj = Blo;
HSP.Leni = Length;
HSP.Lenj = Length;
HSP.Score = BestScore;
asserta(HSP.GetHii() < LA);
asserta(HSP.GetHij() < LB);
#if DEBUG
{
float Score2 = ComputeGaplessHSPScore(HSP, m_SubstMx);
asserta(HSP.Score == Score2);
}
#endif
++m_UngappedHSPCount;
BPos = Bhi + 1;
goto HSPFound;
}
else
{
IncCounter(FailedExtends);
AddCounter(FailedExtendLetters, Length);
}
}
++BPos;
HSPFound:;
}
EndTimer(UngappedBlast);
}
| 4,345
|
C++
|
.cpp
| 200
| 17.935
| 90
| 0.577325
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,988
|
state2.cpp
|
rcedgar_urmap/src/state2.cpp
|
#include "myutils.h"
#include "ufindex.h"
#include "seqinfo.h"
#include "alpha.h"
#include "state2.h"
#include "ufihit.h"
#include "alignresult.h"
#include "sort.h"
#include "omplock.h"
unsigned State2::m_Method;
unsigned State2::m_Minq;
void State2::SetUFI(const UFIndex &UFI)
{
m_UD_Fwd.SetUFI(UFI);
m_UD_Rev.SetUFI(UFI);
}
void State2::FindPairs()
{
m_Paired_HitIndexVec_Fwd.clear();
m_Paired_HitIndexVec_Rev.clear();
m_Paired_TotalScoreVec.clear();
m_Paired_TLVec.clear();
const unsigned QL2 = (m_UD_Fwd.m_Query->m_L + m_UD_Rev.m_Query->m_L)/2;
const unsigned HitCount_Fwd = m_UD_Fwd.m_HitCount;
const unsigned HitCount_Rev = m_UD_Rev.m_HitCount;
m_BestPairIndex = UINT_MAX;
m_SecondPairIndex = UINT_MAX;
m_BestPairScore = -1;
m_SecondBestPairScore = -1;
for (unsigned HitIndex_Fwd = 0; HitIndex_Fwd < HitCount_Fwd; ++HitIndex_Fwd)
{
const UFIHit *Hit_Fwd = m_UD_Fwd.GetHit(HitIndex_Fwd);
int Score_Fwd = Hit_Fwd->m_Score;
int64 DBPos_Fwd = (int64) Hit_Fwd->m_DBStartPos;
if (Score_Fwd < m_UD_Fwd.m_SecondBestScore - 12)//@@TODO:param
continue;
bool Plus_Fwd = Hit_Fwd->m_Plus;
for (unsigned HitIndex_Rev = 0; HitIndex_Rev < HitCount_Rev; ++HitIndex_Rev)
{
const UFIHit *Hit_Rev = m_UD_Rev.GetHit(HitIndex_Rev);
int Score_Rev = Hit_Rev->m_Score;
if (Score_Rev < m_UD_Rev.m_SecondBestScore - 12)//@@TODO:param
continue;
int64 DBPos_Rev = (int64) Hit_Rev->m_DBStartPos;
int64 TL = abs(DBPos_Fwd - DBPos_Rev) + int64(QL2);
if (TL > 1000) // TODO:param/adaptive
continue;
bool Plus_Rev = Hit_Rev->m_Plus;
if (Plus_Rev == Plus_Fwd)
continue;
int TotalScore = Score_Fwd + Score_Rev;
if (TotalScore > m_BestPairScore)
{
m_SecondPairIndex = m_BestPairIndex;
m_SecondBestPairScore = m_BestPairScore;
m_BestPairScore = TotalScore;
m_BestPairIndex = SIZE(m_Paired_TotalScoreVec);
}
else if (TotalScore == m_BestPairScore)
{
m_SecondPairIndex = SIZE(m_Paired_TotalScoreVec);
m_SecondBestPairScore = m_BestPairScore;
}
else if (TotalScore > m_SecondBestPairScore)
{
m_SecondPairIndex = m_BestPairIndex;
m_SecondBestPairScore = TotalScore;
}
m_Paired_TotalScoreVec.push_back(TotalScore);
m_Paired_HitIndexVec_Fwd.push_back(HitIndex_Fwd);
m_Paired_HitIndexVec_Rev.push_back(HitIndex_Rev);
m_Paired_TLVec.push_back(unsigned(TL));
}
}
}
void State2::ScanPair()
{
const unsigned HitCount_Fwd = m_UD_Fwd.m_HitCount;
const unsigned HitCount_Rev = m_UD_Rev.m_HitCount;
const unsigned SCAN_DB_SEG_LENGTH = 1024;//TODO:PARAM
int SavedMapq_Fwd = m_UD_Fwd.m_Mapq;
int SavedMapq_Rev = m_UD_Rev.m_Mapq;
bool DoVit_Fwd = (SavedMapq_Fwd >= 10);
bool DoVit_Rev = (SavedMapq_Rev >= 10);
//@@TODO:check underflow
for (unsigned HitIndex_Fwd = 0; HitIndex_Fwd < HitCount_Fwd; ++HitIndex_Fwd)
{
unsigned QL_Rev = m_UD_Fwd.m_Query->m_L;
const UFIHit *Hit_Fwd = m_UD_Fwd.GetHit(HitIndex_Fwd);
if (Hit_Fwd->m_Score < m_UD_Fwd.m_SecondBestScore)//@@TODO:param
continue;
uint32 DBPos = Hit_Fwd->m_DBStartPos;
bool Plus = Hit_Fwd->m_Plus;
if (Plus)
m_UD_Rev.Scan(DBPos, SCAN_DB_SEG_LENGTH, false, DoVit_Fwd);
else
{
if (DBPos >= SCAN_DB_SEG_LENGTH)
m_UD_Rev.Scan(DBPos-SCAN_DB_SEG_LENGTH, SCAN_DB_SEG_LENGTH+2*QL_Rev,
true, DoVit_Fwd);
}
}
for (unsigned HitIndex_Rev = 0; HitIndex_Rev < HitCount_Rev; ++HitIndex_Rev)
{
unsigned QL_Fwd = m_UD_Fwd.m_Query->m_L;
const UFIHit *Hit_Rev = m_UD_Rev.GetHit(HitIndex_Rev);
if (Hit_Rev->m_Score < m_UD_Rev.m_SecondBestScore)//@@TODO:param
continue;
uint32 DBPos = Hit_Rev->m_DBStartPos;
bool Plus = Hit_Rev->m_Plus;
if (Plus)
m_UD_Fwd.Scan(DBPos, SCAN_DB_SEG_LENGTH, false, DoVit_Rev);
else
{
if (DBPos >= SCAN_DB_SEG_LENGTH)
m_UD_Fwd.Scan(DBPos-SCAN_DB_SEG_LENGTH, SCAN_DB_SEG_LENGTH+2*QL_Fwd,
true, DoVit_Rev);
}
}
m_UD_Fwd.CalcMAPQ6();
m_UD_Rev.CalcMAPQ6();
}
void State2::LogPairs() const
{
const unsigned PairCount = SIZE(m_Paired_TotalScoreVec);
Log("\n");
Log("LogPairs, %u pairs\n", PairCount);
if (PairCount == 0)
return;
vector<unsigned> Order(PairCount);
QuickSortOrderDesc(m_Paired_TotalScoreVec.data(), PairCount, Order.data());
Log("Best score %.1f, second %.1f\n",
double(m_BestPairScore), double(m_SecondBestPairScore));
for (unsigned k = 0; k < PairCount; ++k)
{
unsigned i = Order[k];
unsigned fi = m_Paired_HitIndexVec_Fwd[i];
unsigned ri = m_Paired_HitIndexVec_Rev[i];
int TotalScore = m_Paired_TotalScoreVec[i];
const UFIHit *FwdHit = m_UD_Fwd.GetHit(fi);
const UFIHit *RevHit = m_UD_Rev.GetHit(ri);
int Score_Fwd = FwdHit->m_Score;
int Score_Rev = RevHit->m_Score;
unsigned FwdDBPos = FwdHit->m_DBStartPos;
unsigned RevDBPos = RevHit->m_DBStartPos;
unsigned Offset = (FwdDBPos >= RevDBPos ?
FwdDBPos - RevDBPos : RevDBPos - FwdDBPos);
//Log("%10u", m_DBPosVec[i]);
Log(" %6.2f", double(TotalScore));
Log(" %6.1f", double(Score_Fwd));
Log(" %6.2f", double(Score_Rev));
Log(" %7u", Offset);
Log(" Fwd=");
m_UD_Fwd.LogPos(FwdDBPos);
Log(", Rev=");
m_UD_Rev.LogPos(RevDBPos);
Log("\n");
}
}
void State2::GetChrPos(const UFIHit *Hit, string &ChrLabel, uint32 &ChrPos) const
{
m_UD_Fwd.GetChrPos(Hit, ChrLabel, ChrPos);
}
bool State2::AcceptTemplateLength(int64 TL) const
{
return TL <= MAX_TL;
}
| 5,375
|
C++
|
.cpp
| 167
| 29.083832
| 81
| 0.689801
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,989
|
tenx.cpp
|
rcedgar_urmap/src/tenx.cpp
|
#include "myutils.h"
#include "tenx.h"
#include "alpha.h"
#include <set>
uint32 Tenx_GetIntegerBarcode(const byte *Seq)
{
uint32 BC = 0;
for (unsigned i = 0; i < 16; ++i)
{
byte Letter = g_CharToLetterNucleo[Seq[i]];
BC = BC*4 + Letter;
}
return BC;
}
void Tenx_ReadWhitelist(const string &FileName, set<uint32> &WhiteSet)
{
WhiteSet.clear();
FILE *f = OpenStdioFile(FileName);
string Line;
ProgressFile(f, "Whitelist", FileName);
unsigned Counter = 0;
while (ReadLineStdioFile(f, Line))
{
ProgressLoopTick(Counter++);
if (Line.empty())
continue;
if (SIZE(Line) != 16)
Die("Bad barcode '%s'", Line.c_str());
uint32 BC = Tenx_GetIntegerBarcode((const byte *) Line.c_str());
WhiteSet.insert(BC);
}
ProgressDone();
ProgressLog("%s whitelisted barcodes\n", IntToStrCommas(SIZE(WhiteSet)));
}
// 012345678901234
// B.4f7c42de.1256
uint32 Tenx_GetIntegerBarcodeFromLabel(const char *Label)
{
unsigned n = ustrlen(Label);
if (n < 12)
Die("Tenx_GetIntegerBarcodeFromLabel(%s), <12 chars", Label);
if (Label[0] != 'B' || Label[1] != '.' || Label[10] != '.')
Die("Tenx_GetIntegerBarcodeFromLabel(%s), must start with 'B.'", Label);
char s[9];
for (unsigned i = 0; i < 8; ++i)
s[i] = Label[i+2];
s[8] = 0;
char *p;
unsigned long ul = strtoul(s, &p, 16);
asserta(ul <= UINT32_MAX);
unsigned BC = uint32(ul);
return BC;
}
const char *Tenx_GetBarcodeFromSeq(const byte *Seq, string &BC)
{
BC.clear();
for (unsigned i = 0; i < 16; ++i)
BC += char(Seq[i]);
return BC.c_str();
}
const char *Tenx_IntegerBarcodeToStr(uint32 BC, string &s)
{
s.clear();
const byte *B = (const byte *) &BC;
for (unsigned i = 0; i < 16; ++i)
{
unsigned i1 = i/4;
unsigned i2 = i%4;
byte Letter = (B[i1] >> i2*2) & 0x3;
char c = g_LetterToCharNucleo[Letter];
s = c + s;
}
return s.c_str();
}
| 1,849
|
C++
|
.cpp
| 74
| 22.689189
| 74
| 0.656674
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,990
|
chainer.cpp
|
rcedgar_urmap/src/chainer.cpp
|
#include "myutils.h"
#include "hspfinder.h"
#include "chainer.h"
#define TRACE 0
#define TEST 0
#define HARD_TEST 0
/***
Two-dimensional HSP chaining algorithm per Gusfield
section 13.3.
HSPs between sequences A, i=0..LA-1 and B, j=0..LB-1.
HSP coordinates Begin=(ilo, jlo), End=(ihi, jhi).
K HSPs, so coordinates are ilo[k], k=0..K-1, etc.
"Bendpoint" = beginning or end point of the HSP, i.e. either
Begin or End.
In outline, the algorithm is as follows.
For a given point i,j, the optimal path is the
highest-scoring path in the region x <= i, y <= j.
A list L of optimal chains is maintained sorted by jhi
for the right-most HSP in the chain.
A line sweeps from left to right through the bendpoints
in sequence A.
If the bendpoint is ilo[k], then the best chain
that can be made with this HSP is noted by searching L for
the highest-scoring path j that ends on a point j < loj[k].
The score of the combined path is HSP[k].Score + Score[j],
this is stored in a vector indexed by k for future use.
If the bendpoint is ihi[k], then we determine whether
the best chain ending in k scores more highly than the best
chain in the region R_k, i.e. by finding the entry j in L
with highest Y value <= SP_k.hiY and comparing V[j] with V[k].
If V[k] is higher, then insert the new chain into L, otherwise
discard SP_k because a higher-scoring chain can always be
formed without it.
If the new chain is inserted, then any chains m with lower
scores and hiY_m > hiY_k are deleted because under these
conditions any chain including m can be substituted by a
chain including k, thus achieving a better score.
***/
Chainer::Chainer()
{
Clear(true);
}
Chainer::~Chainer()
{
Clear();
}
void Chainer::Clear(bool ctor)
{
if (!ctor)
{
myfree(m_BPs);
myfree(m_PrevHSPIndexes);
myfree(m_HSPIndexToChainScore);
}
m_HSPCount = 0;
m_HSPs = 0;
m_BPs = 0;
m_MaxHSPCount = 0;
m_HSPIndexToChainScore = 0;
m_PrevHSPIndexes = 0;
}
void Chainer::Reset()
{
m_HSPs = 0;
m_HSPCount = 0;
m_Chains.clear();
}
void Chainer::LogHSPs(HSPData **HSPs, unsigned HSPCount) const
{
Log("\n");
Log("HSP Score Len Loi Hii Loj Hij User\n");
Log("--- ------- ----- ----- ----- ----- ----- ----\n");
for (unsigned i = 0; i < HSPCount; ++i)
{
const HSPData &HSP = *HSPs[i];
Log("%3u %7.1f %5u %5u %5u %5u %5u %u\n",
i, HSP.Score, HSP.GetLength(), HSP.Loi, HSP.GetHii(), HSP.Loj, HSP.GetHij(), HSP.User);
}
}
static void LogHSPsMacro(HSPData **HSPs, unsigned HSPCount)
{
for (unsigned i = 0; i < HSPCount; ++i)
{
const HSPData &HSP = *HSPs[i];
Log("H(%5u, %5u, %5u, %7.1f)\n",
HSP.GetLength(), HSP.Loi, HSP.Loj, HSP.Score);
}
}
float Chainer::GetChainScore(HSPData **HSPs, unsigned HSPCount)
{
float Score = 0.0f;
for (unsigned i = 0; i < HSPCount; ++i)
Score += HSPs[i]->Score;
return Score;
}
void Chainer::LogChain(HSPData **HSPs, unsigned HSPCount)
{
float Score = 0.0f;
for (unsigned i = 0; i < HSPCount; ++i)
{
if (i > 0)
Log(" -> ");
const HSPData &HSP = *(HSPs[i]);
Score += HSP.Score;
Log("(%u-%u,%u-%u/%.1f)", HSP.Loi, HSP.GetHii(), HSP.Loj, HSP.GetHij(), HSP.Score);
if (HSP.User != UINT_MAX)
Log(":%u", HSP.User);
}
if (IsValidChain(HSPs, HSPCount))
Log(" = %.1f ok\n", Score);
else
Log(" = %.1f Invalid\n", Score);
}
void Chainer::LogChain2(HSPData **HSPs, unsigned HSPCount)
{
Log("A: ");
for (unsigned i = 0; i < HSPCount; ++i)
{
if (i > 0)
Log(" -> ");
const HSPData &HSP = *(HSPs[i]);
Log("%u-%u", HSP.Loi, HSP.GetHii());
}
Log("\n");
Log("B: ");
for (unsigned i = 0; i < HSPCount; ++i)
{
if (i > 0)
Log(" -> ");
const HSPData &HSP = *(HSPs[i]);
Log("%u-%u", HSP.Loj, HSP.GetHij());
}
Log("\n");
}
bool Chainer::IsValidChain(HSPData **HSPs, unsigned HSPCount)
{
for (unsigned i = 1; i < HSPCount; ++i)
{
const HSPData &PrevHSP = *(HSPs[i-1]);
const HSPData &HSP = *(HSPs[i]);
if (PrevHSP.GetHii() >= HSP.Loi)
return false;
if (PrevHSP.GetHij() >= HSP.Loj)
return false;
}
return true;
}
void Chainer::AssertValidChain(HSPData **HSPs, unsigned HSPCount)
{
for (unsigned i = 1; i < HSPCount; ++i)
{
const HSPData &PrevHSP = *(HSPs[i-1]);
const HSPData &HSP = *(HSPs[i]);
if (PrevHSP.GetHii() >= HSP.Loi)
{
Log("\n");
Log("Ahi[%u]=%u >= Loi[%u]=%u\n",
i-1, PrevHSP.GetHii(), i, HSP.Loi);
LogChain(HSPs, HSPCount);
Die("AssertValidChain");
}
if (PrevHSP.GetHij() >= HSP.Loj)
{
Log("\n");
Log("Bhi[%u]=%u >= Loj[%u]=%u\n",
i-1, PrevHSP.GetHij(), i, HSP.Loj);
LogChain(HSPs, HSPCount);
Die("AssertValidChain");
}
}
}
void Chainer::AllocHSPCount(unsigned MaxHSPCount)
{
if (MaxHSPCount <= m_MaxHSPCount)
return;
m_MaxHSPCount = MaxHSPCount;
unsigned MaxBPCount = 2*MaxHSPCount;
myfree(m_BPs);
myfree(m_HSPIndexToChainScore);
myfree(m_PrevHSPIndexes);
//m_BPs = myalloc<BPData>(MaxBPCount);
m_BPs = myalloc(BPData, MaxBPCount);
// m_HSPIndexToChainScore = myalloc<float>(MaxHSPCount);
m_HSPIndexToChainScore = myalloc(float, MaxHSPCount);
//m_PrevHSPIndexes = myalloc<unsigned>(m_HSPCount);
m_PrevHSPIndexes = myalloc(unsigned, MaxHSPCount);
}
// Ties: Los before His
static int CmpBPs(const void *vpBP1, const void *vpBP2)
{
const BPData *BP1 = (const BPData *) vpBP1;
const BPData *BP2 = (const BPData *) vpBP2;
if (BP1->Pos < BP2->Pos)
return -1;
else if (BP1->Pos > BP2->Pos)
return 1;
assert(BP1->Pos == BP2->Pos);
if (BP1->IsLo != BP2->IsLo)
{
if (BP1->IsLo && !BP2->IsLo)
return -1;
else
return 1;
}
return 0;
}
void SortBPVecInPlace(BPData *BPVec, unsigned N)
{
qsort(BPVec, N, sizeof(BPData), CmpBPs);
}
void Chainer::SortBPs()
{
// qsort(m_BPs, 2*m_HSPCount, sizeof(m_BPs[0]), CmpBPs);
SortBPVecInPlace(m_BPs, 2*m_HSPCount);
}
void Chainer::SetBPs()
{
AllocHSPCount(m_HSPCount);
for (unsigned i = 0; i < m_HSPCount; ++i)
{
const HSPData &HSP = *m_HSPs[i];
BPData &BPlo = *(m_BPs + 2*i);
BPData &BPhi = *(m_BPs + 2*i + 1);
BPlo.IsLo = true;
BPhi.IsLo = false;
BPlo.Index = i;
BPhi.Index = i;
BPlo.Pos = HSP.Loi;
BPhi.Pos = HSP.GetHii();
}
}
void Chainer::LogBPs() const
{
Log("\n");
Log(" BP Pos Lo Index\n");
Log("----- ----- -- -----\n");
for (unsigned i = 0; i < 2*m_HSPCount; ++i)
{
const BPData &BP = m_BPs[i];
Log("%5u %5u %2s %5u\n",
i, BP.Pos, BP.IsLo ? "Lo" : "Hi", BP.Index);
}
}
void Chainer::LogMe() const
{
Log("\n");
Log(" HSP H.Score C.Score Ahi Bhi\n");
Log("----- ------- ------- ----- -----\n");
for (list<unsigned>::const_iterator p = m_Chains.begin();
p != m_Chains.end(); ++p)
{
unsigned HSPIndex = *p;
const HSPData &HSP = *m_HSPs[HSPIndex];
Log("%5u", HSPIndex);
Log(" %7.1f", HSP.Score);
float ChainScore = m_HSPIndexToChainScore[HSPIndex];
if (ChainScore == BAD_SCORE)
Log(" %7.7s", "*");
else
Log(" %7.1f", ChainScore);
Log(" %5u", HSP.GetHii());
Log(" %5u", HSP.GetHij());
for (;;)
{
const HSPData &HSP = *m_HSPs[HSPIndex];
Log(" [%u]", HSPIndex);
HSP.LogMe2();
HSPIndex = m_PrevHSPIndexes[HSPIndex];
if (HSPIndex == UINT_MAX)
break;
Log(" ->");
}
Log("\n");
}
Log("\n");
}
unsigned Chainer::FindBestChainLT(unsigned Ahi, unsigned Bhi)
{
#if TRACE
Log("FindBestChainLT(Ahi=%u, Bhi=%u)\n", Ahi, Bhi);
#endif
float BestScore = BAD_SCORE;
unsigned BestChain = UINT_MAX;
for (list<unsigned>::iterator p = m_Chains.begin();
p != m_Chains.end(); ++p)
{
unsigned HSPIndex = *p;
const HSPData &HSP = *m_HSPs[HSPIndex];
unsigned ChainAhi = HSP.GetHii();
unsigned ChainBhi = HSP.GetHij();
float ChainScore = m_HSPIndexToChainScore[HSPIndex];
bool Better = ChainAhi < Ahi && ChainBhi < Bhi &&
(BestChain == UINT_MAX || ChainScore > BestScore);
#if TRACE
Log(" HSP %u Ahi %u, Bhi %u Score %.1f %s\n",
HSPIndex, ChainAhi, ChainBhi, ChainScore, Better ? "Yes" : "No");
#endif
if (Better)
{
BestChain = HSPIndex;
BestScore = ChainScore;
}
}
return BestChain;
}
float Chainer::Chain(HSPData **HSPs, unsigned HSPCount,
HSPData **OptChain, unsigned &OptChainLength)
{
#if TRACE
Log("\n");
Log("Chain, HSPCount=%u\n", HSPCount);
#endif
asserta(OptChain != HSPs);
Reset();
m_HSPs = HSPs;
m_HSPCount = HSPCount;
if (m_HSPCount == 0)
{
OptChainLength = 0;
return 0.0f;
}
StartTimer(Chain);
#if TRACE
LogHSPs(HSPs, HSPCount);
#endif
SetBPs();
SortBPs();
for (unsigned i = 0; i < m_HSPCount; ++i)
{
#if DEBUG
m_HSPIndexToChainScore[i] = BAD_SCORE;
#endif
m_PrevHSPIndexes[i] = UINT_MAX;
}
m_Chains.clear();
#if TRACE
Log("\n");
#endif
for (unsigned BPIndex = 0; BPIndex < 2*m_HSPCount; ++BPIndex)
{
const BPData &BP = m_BPs[BPIndex];
unsigned HSPIndex = BP.Index;
const HSPData &HSP = (*m_HSPs[HSPIndex]);
#if TRACE
{
Log("\n");
Log("-------------------------------------\n");
BP.LogMe();
HSP.LogMe2();
Log("\n");
}
#endif
if (BP.IsLo)
{
unsigned Ahi = HSP.Loi;
unsigned Bhi = HSP.Loj;
unsigned Chain = FindBestChainLT(Ahi, Bhi);
#if TRACE
{
Log("BestChain < Ahi %u, Bhi %u = ", Ahi, Bhi);
if (Chain == UINT_MAX)
Log("*\n");
else
Log("%u\n", Chain);
}
#endif
m_Chains.push_back(HSPIndex);
m_PrevHSPIndexes[HSPIndex] = Chain;
#if DEBUG
asserta(m_HSPIndexToChainScore[HSPIndex] == BAD_SCORE);
#endif
if (Chain == UINT_MAX)
m_HSPIndexToChainScore[HSPIndex] = HSP.Score;
else
m_HSPIndexToChainScore[HSPIndex] = m_HSPIndexToChainScore[Chain] + HSP.Score;
}
else
{
float Score = m_HSPIndexToChainScore[HSPIndex];
asserta(Score != BAD_SCORE);
// Delete enclosed chains that are lower-scoring
// Warning -- elements deleted inside loop, be careful of iterators
unsigned Ahi = HSP.GetHii();
unsigned Bhi = HSP.GetHij();
list<unsigned>::iterator pNext;
for (list<unsigned>::iterator p = m_Chains.begin();
p != m_Chains.end(); )
{
unsigned Chain = *p;
const HSPData &ChainHSP = *m_HSPs[Chain];
list<unsigned>::iterator pThis = p;
++p;
if (ChainHSP.GetHii() <= Ahi && ChainHSP.GetHij() <= Bhi
&& m_HSPIndexToChainScore[HSPIndex] < Score)
{
#if TRACE
Log(" -- del chain hsp %u ahi %u<%u bhi %u<%u score %.1f<%.1f\n",
HSPIndex, HSP.GetHii(), Ahi, HSP.GetHij(), Bhi,
m_HSPIndexToChainScore[HSPIndex], Score);
#endif
m_Chains.erase(pThis);
}
}
}
#if TRACE
Log("End main loop:\n");
LogMe();
#endif
}
#if TRACE
Log("\n");
Log("FINAL:\n");
LogMe();
#endif
unsigned OptChainHSP = 0;
float OptScore = m_HSPIndexToChainScore[0];
for (unsigned HSPIndex = 1; HSPIndex < HSPCount; ++HSPIndex)
{
float ChainScore = m_HSPIndexToChainScore[HSPIndex];
if (ChainScore > OptScore)
{
OptChainHSP = HSPIndex;
OptScore = ChainScore;
}
}
OptChainLength = 0;
for (unsigned HSPIndex = OptChainHSP; HSPIndex != UINT_MAX;
HSPIndex = m_PrevHSPIndexes[HSPIndex])
{
asserta(OptChainLength < HSPCount);
asserta(HSPIndex < m_HSPCount);
OptChainLength++;
}
unsigned i = 1;
for (unsigned HSPIndex = OptChainHSP; HSPIndex != UINT_MAX;
HSPIndex = m_PrevHSPIndexes[HSPIndex])
OptChain[OptChainLength - i++] = m_HSPs[HSPIndex];
#if DEBUG
AssertValidChain(OptChain, OptChainLength);
#endif
EndTimer(Chain);
return OptScore;
}
#if TEST
const unsigned MaxTries = 10000;
const unsigned MinCount = 1;
const unsigned MaxCount = 8;
const unsigned MinLen = 1;
const unsigned MaxLen = 100;
const unsigned MaxPos = 100;
const unsigned MinScore = 1;
const unsigned MaxScore = 100;
const unsigned RandSeed = 6;
static void GetRandomHSP(HSPData &HSP, unsigned MaxPos, unsigned MinLen, unsigned MaxLen,
unsigned MinScore, unsigned MaxScore)
{
asserta(MinLen <= MaxLen);
asserta(MinScore <= MaxScore);
HSP.Loi = unsigned(rand()%MaxPos);
HSP.Loj = unsigned(rand()%MaxPos);
HSP.GetLength() = MinLen + unsigned(rand()%(MaxLen - MinLen + 1));
HSP.Score = float(MinScore + unsigned(rand()%(MaxScore - MinScore + 1)));
}
static unsigned GetRandomHSPs(HSPData **HSPs,
unsigned MinCount, unsigned MaxCount,
unsigned MaxPos,
unsigned MinLen, unsigned MaxLen,
unsigned MinScore, unsigned MaxScore)
{
asserta(MinCount <= MaxCount);
unsigned Count = MinCount + unsigned(rand()%(MaxCount - MinCount + 1));
for (unsigned i = 0; i < Count; ++i)
GetRandomHSP(*HSPs[i], MaxPos, MinLen, MaxLen, MinScore, MaxScore);
return Count;
}
static void Test1(Chainer &C, unsigned Try, HSPData **HSPs, unsigned HSPCount)
{
#if TRACE
Log("\n");
Log("Test1:\n");
LogHSPsMacro(HSPs, HSPCount);
#endif
//const HSPData **OptChain = myalloc<const HSPData *>(MaxCount);
//const HSPData **OptChainB = myalloc<const HSPData *>(MaxCount);
const HSPData **OptChain = myalloc(const HSPData *, MaxCount);
const HSPData **OptChainB = MYALLOC(const HSPData *, MaxCount, Test;
unsigned L;
unsigned LB;
float Score = C.Chain(HSPs, HSPCount, OptChain, L);
float ScoreB = C.ChainBrute(HSPs, HSPCount, OptChainB, LB);
Log("Try %u, N %u L %u, LB %u, Score %.1f, ScoreB %.1f\n", Try, HSPCount, L, LB, Score, ScoreB);
Progress("Try %u/%u, N %u L %u, LB %u, Score %.1f, ScoreB %.1f\n",
Try+1, MaxTries, HSPCount, L, LB, Score, ScoreB);
if (L != LB)
{
LogHSPsMacro(HSPs, HSPCount);
Log("Fast : ");
Chainer::LogChain(OptChain, L);
Log("Brute: ");
Chainer::LogChain(OptChainB, LB);
Warning("L!=LB");
}
if (!feq(Score, ScoreB))
{
LogHSPsMacro(HSPs, HSPCount);
Log("Fast : ");
Chainer::LogChain(OptChain, L);
Chainer::LogChain2(OptChain, L);
Log("Brute: ");
Chainer::LogChain(OptChainB, LB);
Chainer::LogChain2(OptChainB, LB);
Die("Scores differ");
}
myfree(OptChain);
myfree(OptChainB);
}
#endif // TEST
#if TEST && HARD_TEST
void TestChain()
{
Chainer C;
// HSPData **HSPs = myalloc<HSPData *>(MaxCount);
HSPData **HSPs = myalloc(HSPData *, MaxCount);
for (unsigned i = 0; i < MaxCount; ++i)
//HSPs[i] = myalloc<HSPData>(1);
HSPs[i] = myalloc(HSPData, 1);
unsigned HSPCount = 0;
#define H(len, alo, blo, score) \
{ \
HSPData &HSP = (*HSPs[HSPCount++]); \
HSP.GetLength() = len; \
HSP.Loi = alo; \
HSP.Loj = blo; \
HSP.Score = score; \
}
H( 2, 64, 17, 82.0)
H( 3, 10, 21, 49.0)
H( 3, 32, 28, 60.0)
H( 10, 73, 43, 77.0)
Test1(C, 0, HSPs, HSPCount);
}
#endif // TEST && HARD_TEST
#if TEST && !HARD_TEST
void TestChain()
{
Chainer C;
//HSPData **HSPs = myalloc<HSPData *>(MaxCount);
HSPData **HSPs = MYALLOCE(HSPData *, MaxCount, Test);
for (unsigned i = 0; i < MaxCount; ++i)
//HSPs[i] = myalloc<HSPData>(1);
HSPs[i] = myalloc(HSPData, 1);
for (unsigned Try = 0; Try < MaxTries; ++Try)
{
#if TRACE
Log("\n");
Log("==================\n");
Log("TRY %u\n", Try);
Log("==================\n");
#endif
unsigned HSPCount = GetRandomHSPs(HSPs, MinCount, MaxCount, MaxPos,
MinLen, MaxLen, MinScore, MaxScore);
Test1(C, Try, HSPs, HSPCount);
}
}
#endif // TEST && !HARD_TEST
| 15,096
|
C++
|
.cpp
| 565
| 24.056637
| 97
| 0.647189
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,991
|
xdropbwdsplit.cpp
|
rcedgar_urmap/src/xdropbwdsplit.cpp
|
#include "myutils.h"
#include "tracebit.h"
#include "xtype.h"
#include "hsp.h"
#include "alnparams.h"
#include "xdpmem.h"
#include "objmgr.h"
#include "pathinfo.h"
#define TRACE 0
float XDropBwdFastMem(XDPMem &Mem, const byte *A, unsigned LA, const byte *B, unsigned LB,
const AlnParams &AP, float X, unsigned &Leni, unsigned &Lenj, PathInfo &PI);
float XDropBwdSplit(XDPMem &Mem, const byte *A, unsigned LA, const byte *B, unsigned LB,
const AlnParams &AP, float X, unsigned &Leni, unsigned &Lenj, PathInfo &PI)
{
#if TRACE
Log("\n");
Log("XDropBwdSplit\n");
Log("A %5u %*.*s\n", LA, LA, LA, A);
Log("B %5u %*.*s\n", LB, LB, LB, B);
#endif
Leni = 0;
Lenj = 0;
PI.SetEmpty();
PathInfo *SubPI = ObjMgr::GetPathInfo();
float SumScore = 0.0f;
unsigned DoneA = 0;
unsigned DoneB = 0;
for (;;)
{
if (DoneA == LA || DoneB == LB)
break;
unsigned SubLA = GetSubL(LA - DoneA);
unsigned SubLB = GetSubL(LB - DoneB);
asserta(DoneA + SubLA <= LA);
asserta(DoneB + SubLB <= LB);
const byte *SubA = A + LA - DoneA - SubLA;
const byte *SubB = B + LB - DoneB - SubLB;
#if TRACE
Log("\n");
Log("DoneA %u, DoneB %u, LeftA %u, LeftB %u\n",
DoneA, DoneB, LA - DoneA, LB - DoneB);
Log("SubA %2u %*.*s\n", SubLA, SubLA, SubLA, SubA);
Log("SubB %2u %*.*s\n", SubLB, SubLB, SubLB, SubB);
#endif
unsigned SubLeni, SubLenj;
float Score = XDropBwdFastMem(Mem, SubA, SubLA, SubB, SubLB, AP, X, SubLeni, SubLenj, *SubPI);
#if TRACE
Log("XDropBwdFastMem=%.1f SubLeni=%u SubLenj=%u\n", Score, SubLeni, SubLenj);
if (Score > 0.0f)
LogAln(SubA + SubLA - SubLeni, SubB + SubLB - SubLenj, SubPI->m_Path);
#endif
if (Score == 0.0f)
break;
SumScore += Score;
Leni += SubLeni;
Lenj += SubLenj;
PI.PrependPath(*SubPI);
if (SubLeni < SubLA && SubLenj < SubLB)
break;
asserta(SubLeni == SubLA || SubLenj == SubLB);
DoneA += SubLeni;
DoneB += SubLenj;
}
ObjMgr::Down(SubPI);
return SumScore;
}
| 1,952
|
C++
|
.cpp
| 66
| 27.060606
| 96
| 0.655283
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,992
|
search2m5.cpp
|
rcedgar_urmap/src/search2m5.cpp
|
#include "myutils.h"
#include "ufindex.h"
#include "state2.h"
#include "seqinfo.h"
#include "omplock.h"
#include "sort.h"
// Does everything except output
void State2::Search5(SeqInfo *Query_Fwd, SeqInfo *Query_Rev)
{
m_UD_Fwd.InitPE(Query_Fwd);
m_UD_Rev.InitPE(Query_Rev);
unsigned QLf = m_UD_Fwd.m_Query->m_L;
unsigned QLr = m_UD_Rev.m_Query->m_L;
unsigned QL2 = (QLf + QLr)/2;
unsigned Sizef = 2*QLf;
unsigned Sizer = 2*QLr;
if (Sizef > m_B1Sizef)
{
Sizef += 64;
m_B1_QPosVecf.Alloc(Sizef);
m_B1_PlusVecf.Alloc(Sizef);
m_B1_DBPosVecf.Alloc(Sizef);
m_B1Sizef = Sizef;
}
if (Sizer > m_B1Sizer)
{
Sizer += 64;
m_B1_QPosVecr.Alloc(Sizer);
m_B1_PlusVecr.Alloc(Sizer);
m_B1_DBPosVecr.Alloc(Sizer);
m_B1Sizer = Sizer;
}
m_TermPairScorePhase1 = int(QLf) + int(QLr) + 5*State1::MISMATCH_SCORE;//TODO:PARAM
unsigned kf = UINT_MAX;
unsigned kr = UINT_MAX;
uint32 *B1_QPosVecf = m_B1_QPosVecf.Data;
uint32 *B1_QPosVecr = m_B1_QPosVecr.Data;
bool *B1_PlusVecf = m_B1_PlusVecf.Data;
bool *B1_PlusVecr = m_B1_PlusVecr.Data;
uint32 *B1_DBPosVecf = m_B1_DBPosVecf.Data;
uint32 *B1_DBPosVecr = m_B1_DBPosVecr.Data;
unsigned NB1f = 0;
unsigned NB1r = 0;
{
uint32 QPosf;
uint32 QPosr;
bool Plusf;
bool Plusr;
uint32 DBPosf;
uint32 DBPosr;
kf = m_UD_Fwd.GetFirstBoth1Seed(QPosf, Plusf, DBPosf);
kr = m_UD_Rev.GetFirstBoth1Seed(QPosr, Plusr, DBPosr);
do
{
if (kf != UINT_MAX)
{
B1_QPosVecf[NB1f] = QPosf;
B1_PlusVecf[NB1f] = Plusf;
B1_DBPosVecf[NB1f] = DBPosf;
++NB1f;
for (unsigned i = 0; i < NB1r; ++i)
{
uint32 DBPosr = B1_DBPosVecr[i];
int64 TL = abs(int64(DBPosf) - int64(DBPosr)) + int64(QL2);
if (AcceptTemplateLength(TL))
{
uint32 QPosr = B1_QPosVecr[i];
bool Done = ExtendBoth1Pair5(QPosf, DBPosf, Plusf,
QPosr, DBPosr);
if (Done)
{
return;
}
}
}
}
if (kr != UINT_MAX)
{
B1_QPosVecr[NB1r] = QPosr;
B1_PlusVecr[NB1r] = Plusr;
B1_DBPosVecr[NB1r] = DBPosr;
++NB1r;
for (unsigned i = 0; i < NB1f; ++i)
{
uint32 DBPosf = B1_DBPosVecf[i];
int64 TL = abs(int64(DBPosf) - int64(DBPosr)) + int64(QL2);
if (AcceptTemplateLength(TL))
{
uint32 QPosf = B1_QPosVecf[i];
bool Done = ExtendBoth1Pair5(QPosf, DBPosf, !Plusr,
QPosr, DBPosr);
if (Done)
{
return;
}
}
}
}
if (kf != UINT_MAX)
kf = m_UD_Fwd.GetNextBoth1Seed(kf, QPosf, Plusf, DBPosf);
if (kr != UINT_MAX)
kr = m_UD_Rev.GetNextBoth1Seed(kr, QPosr, Plusr, DBPosr);
}
while (kf != UINT_MAX || kr != UINT_MAX);
}
for (unsigned i = 0; i < NB1f; ++i)
{
uint32 QPos = B1_QPosVecf[i];
uint32 DBPos = B1_DBPosVecf[i];
bool Plus = B1_PlusVecf[i];
m_UD_Fwd.ExtendPen(QPos, DBPos, Plus);
}
for (unsigned i = 0; i < NB1r; ++i)
{
uint32 QPos = B1_QPosVecr[i];
uint32 DBPos = B1_DBPosVecr[i];
bool Plus = B1_PlusVecr[i];
m_UD_Rev.ExtendPen(QPos, DBPos, Plus);
}
m_UD_Fwd.SearchPE_Pending(kf);
m_UD_Rev.SearchPE_Pending(kr);
}
bool State2::ExtendBoth1Pair5(uint32 QPosf, uint32 DBPosf, bool Plusf,
uint32 QPosr, uint32 DBPosr)
{
int FwdScore = m_UD_Fwd.ExtendPen(QPosf, DBPosf, Plusf);
if (FwdScore <= 0)
return false;
int RevScore = m_UD_Rev.ExtendPen(QPosr, DBPosr, !Plusf);
if (RevScore <= 0)
return false;
int SumScore = FwdScore + RevScore;
if (SumScore < m_TermPairScorePhase1)
{
m_UD_Fwd.CalcMAPQ6();
m_UD_Rev.CalcMAPQ6();
return false;
}
m_UD_Fwd.m_Mapq = 40;
m_UD_Rev.m_Mapq = 40;
return true;
}
| 3,555
|
C++
|
.cpp
| 142
| 21.704225
| 84
| 0.65431
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,994
|
viterbifastmem.cpp
|
rcedgar_urmap/src/viterbifastmem.cpp
|
#include "myutils.h"
#include "xdpmem.h"
#include "tracebit.h"
#include "pathinfo.h"
#include "alnparams.h"
void TraceBackBitMem(XDPMem &Mem, unsigned LA, unsigned LB, char State, PathInfo &PI);
float ViterbiFastMem(XDPMem &Mem, const byte *A, unsigned LA,
const byte *B, unsigned LB, const AlnParams &AP, PathInfo &PI)
{
if (LA*LB > 100*1000*1000)
Die("ViterbiFastMem, seqs too long LA=%u, LB=%u", LA, LB);
Mem.Alloc(LA, LB);
PI.Alloc2(LA, LB);
StartTimer(ViterbiFastMem);
const float * const *Mx = AP.SubstMx;
float OpenA = AP.LOpenA;
float ExtA = AP.LExtA;
float *Mrow = Mem.GetDPRow1();
float *Drow = Mem.GetDPRow2();
byte **TB = Mem.GetTBBit();
// Use Mrow[-1], so...
Mrow[-1] = MINUS_INFINITY;
for (unsigned j = 0; j <= LB; ++j)
{
Mrow[j] = MINUS_INFINITY;
Drow[j] = MINUS_INFINITY;
}
// Main loop
float M0 = float (0);
for (unsigned i = 0; i < LA; ++i)
{
byte a = A[i];
const float *MxRow = Mx[a];
float OpenB = AP.LOpenB;
float ExtB = AP.LExtB;
float I0 = MINUS_INFINITY;
byte *TBrow = TB[i];
for (unsigned j = 0; j < LB; ++j)
{
byte b = B[j];
byte TraceBits = 0;
float SavedM0 = M0;
// MATCH
{
// M0 = DPM[i][j]
// I0 = DPI[i][j]
// Drow[j] = DPD[i][j]
float xM = M0;
if (Drow[j] > xM)
{
xM = Drow[j];
TraceBits = TRACEBITS_DM;
}
if (I0 > xM)
{
xM = I0;
TraceBits = TRACEBITS_IM;
}
M0 = Mrow[j];
Mrow[j] = xM + MxRow[b];
// Mrow[j] = DPM[i+1][j+1])
}
// DELETE
{
// SavedM0 = DPM[i][j]
// Drow[j] = DPD[i][j]
float md = SavedM0 + OpenB;
Drow[j] += ExtB;
if (md >= Drow[j])
{
Drow[j] = md;
TraceBits |= TRACEBITS_MD;
}
// Drow[j] = DPD[i+1][j]
}
// INSERT
{
// SavedM0 = DPM[i][j]
// I0 = DPI[i][j]
float mi = SavedM0 + OpenA;
I0 += ExtA;
if (mi >= I0)
{
I0 = mi;
TraceBits |= TRACEBITS_MI;
}
// I0 = DPI[i][j+1]
}
OpenB = AP.OpenB;
ExtB = AP.ExtB;
TBrow[j] = TraceBits;
}
// Special case for end of Drow[]
{
// M0 = DPM[i][LB]
// Drow[LB] = DPD[i][LB]
TBrow[LB] = 0;
float md = M0 + AP.ROpenB;
Drow[LB] += AP.RExtB;
if (md >= Drow[LB])
{
Drow[LB] = md;
TBrow[LB] = TRACEBITS_MD;
}
// Drow[LB] = DPD[i+1][LB]
}
M0 = MINUS_INFINITY;
OpenA = AP.OpenA;
ExtA = AP.ExtA;
}
// Special case for last row of DPI
byte *TBrow = TB[LA];
float I1 = MINUS_INFINITY;
for (unsigned j = 1; j < LB; ++j)
{
// Mrow[j-1] = DPM[LA][j]
// I1 = DPI[LA][j]
TBrow[j] = 0;
float mi = Mrow[int(j)-1] + AP.ROpenA;
I1 += AP.RExtA;
if (mi > I1)
{
I1 = mi;
TBrow[j] = TRACEBITS_MI;
}
}
float FinalM = Mrow[LB-1];
float FinalD = Drow[LB];
float FinalI = I1;
// FinalM = DPM[LA][LB]
// FinalD = DPD[LA][LB]
// FinalI = DPI[LA][LB]
float Score = FinalM;
byte State = 'M';
if (FinalD > Score)
{
Score = FinalD;
State = 'D';
}
if (FinalI > Score)
{
Score = FinalI;
State = 'I';
}
EndTimer(ViterbiFastMem);
TraceBackBitMem(Mem, LA, LB, State, PI);
return Score;
}
| 3,088
|
C++
|
.cpp
| 148
| 17.486486
| 86
| 0.572022
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,995
|
state1.cpp
|
rcedgar_urmap/src/state1.cpp
|
#include "myutils.h"
#include "ufindex.h"
#include "seqinfo.h"
#include "alpha.h"
#include "state1.h"
#include "ufihit.h"
#include "alignresult.h"
#include "sort.h"
#include "cigar.h"
#include "omplock.h"
//////////////
//#include "readsimbench.h"
//bool State1::IsCorrect() const
// {
// if (m_TopHit == 0)
// return false;
//
// string TrueLabel;
// uint32 TruePos;
// bool Strand;
// GetCoordsFromLabel(m_Query->m_Label, TrueLabel, TruePos, Strand);
//
// string PredLabel;
// unsigned PredPos;
// m_TopHit->GetStartCoord(PredLabel, PredPos);
//
// int64 d = int64(TruePos) - int64(PredPos);
// if (d < 0)
// d = -d;
//
// bool Correct = (TrueLabel == PredLabel && d <= MAX_LOCUS_D);
// return Correct;
// }
const UFIHit *State1::GetSecondHit() const
{
for (unsigned HitIndex = 0; HitIndex < m_HitCount; ++HitIndex)
{
const UFIHit *Hit = m_Hits.Data[HitIndex];
if (Hit != m_TopHit && Hit->m_Score == m_SecondBestScore)
return Hit;
}
return 0;
}
///////////
void LogAlnPretty(const byte *A, const byte *B, const char *Path,
bool StripTermGaps);
int State1::MISMATCH_SCORE;
int State1::GAP_OPEN_SCORE;
int State1::GAP_EXT_SCORE;
int State1::MIN_HSP_SCORE_PCT;
int State1::TERM_HSP_SCORE_PCT_PHASE3;
int State1::XDROP;
int State1::MAX_PENALTY;
int State1::XPHASE1;
int State1::XPHASE3;
int State1::XPHASE4;
unsigned State1::GLOBAL_BAND_RADIUS;
unsigned State1::m_Method = UINT_MAX;
unsigned State1::m_StartSecs;
unsigned State1::m_QueryCount;
unsigned State1::m_AcceptCount;
unsigned State1::m_RejectCount;
unsigned State1::m_NoHitCount;
unsigned State1::m_Minq = 10;
uint32 GetTrueDBPos(SeqInfo *Query, const UFIndex &UFI)
{
string TrueLabel;
uint32 TrueCoord;
bool TrueStrand;
GetCoordsFromLabel(Query->m_Label, TrueLabel, TrueCoord, TrueStrand);
asserta(TrueCoord > 0);
uint32 TrueDBPos = UFI.CoordToPos(TrueLabel, TrueCoord-1);
return TrueDBPos;
}
void State1::AllocCachedVectors(unsigned QL)
{
m_SlotsVec_Plus = alloc_buff(uint64, QL);
m_SlotsVec_Minus = alloc_buff(uint64, QL);
m_PosVec = alloc_buff(uint32, m_UFI->m_MaxIx);
m_BlobVec_Plus = alloc_buff(byte, 5 * QL);
m_BlobVec_Minus = alloc_buff(byte, 5 * QL);
m_QPosPendingVec_Plus = alloc_buff(byte, QL);
m_QPosPendingVec_Minus = alloc_buff(byte, QL);
m_QPosPendingCount_Plus = 0;
m_QPosPendingCount_Minus = 0;
}
void State1::InitPE(SeqInfo *Query)
{
Lock();
++m_QueryCount;
Unlock();
m_Query = Query;
const byte *Q = Query->m_Seq;
unsigned QL = Query->m_L;
m_AllocBuffOffset = 0;
AllocCachedVectors(Query->m_L);
SetSlotsVec(Q, QL, m_SlotsVec_Plus);
m_RevCompQuerySeq.Alloc(QL);
RevCompSeq(Q, QL, m_RevCompQuerySeq.Data);
const byte *QRC = m_RevCompQuerySeq.Data;
SetSlotsVec(QRC, QL, m_SlotsVec_Minus);
m_HitCount = 0;
m_HSPCount = 0;
m_TopHit = 0;
m_SecondHit = 0;
m_BestScore = 0;
m_BestHSPScore = 0;
m_SecondBestScore = 0;
m_Mapq = -1;
m_MaxPenalty = MAX_PENALTY;
m_MappedTargetLabel.clear();
m_MappedTargetPos = UINT32_MAX;
}
void State1::SetMappedPos()
{
m_MappedTargetLabel.clear();
m_MappedTargetPos = UINT32_MAX;
if (m_TopHit == 0)
return;
unsigned TargetL = 0;
m_MappedTargetPos = m_UFI->PosToCoordL(m_TopHit->m_DBStartPos,
m_MappedTargetLabel, TargetL);
if (m_MappedTargetPos + m_Query->m_L > TargetL)
{
m_MappedTargetLabel.clear();
m_MappedTargetPos = UINT32_MAX;
m_TopHit = 0;
}
return;
}
void State1::SetMethod(unsigned Method)
{
m_Method = Method;
if (Method == 1)
return;
if (Method == 6 || Method == 8)
{
State1::MISMATCH_SCORE = -3;
State1::GAP_OPEN_SCORE = -5;
State1::GAP_EXT_SCORE = -1;
State1::MIN_HSP_SCORE_PCT = 20;
State1::TERM_HSP_SCORE_PCT_PHASE3 = 60;
State1::XDROP = 9;
State1::MAX_PENALTY = 100;
State1::XPHASE1 = 1;
State1::XPHASE3 = 1;
State1::XPHASE4 = 1;
State1::GLOBAL_BAND_RADIUS = 12;
}
else if (Method == 7)
{
State1::MISMATCH_SCORE = -4;
State1::GAP_OPEN_SCORE = -6;
State1::GAP_EXT_SCORE = -2;
State1::MIN_HSP_SCORE_PCT = 35;
State1::TERM_HSP_SCORE_PCT_PHASE3 = 35;
State1::XDROP = 12;
State1::MAX_PENALTY = 75;
State1::XPHASE1 = 8;
State1::XPHASE3 = 6;
State1::XPHASE4 = 5;
State1::GLOBAL_BAND_RADIUS = 8;
}
else
asserta(false);
return;
}
void State1::SetUFI(const UFIndex &UFI)
{
m_UFI = &UFI;
m_WordLength = m_UFI->m_WordLength;
m_ShiftMask = m_UFI->m_ShiftMask;
m_SlotCount = m_UFI->m_SlotCount;
}
void State1::AllocHits(unsigned n)
{
unsigned OldSize = m_Hits.MaxSize;
if (OldSize >= n)
return;
unsigned NewSize = n + 64;
UFIHit **OldHits = m_Hits.Data;
m_Hits.Alloc(NewSize);
unsigned NewMaxSize = m_Hits.MaxSize;
memcpy(m_Hits.Data, OldHits, OldSize*sizeof(UFIHit *));
for (unsigned i = OldSize; i < NewMaxSize; ++i)
{
UFIHit *NewHit = new UFIHit;
asserta(NewHit != 0);
m_Hits.Data[i] = NewHit;
NewHit->m_UD = this;
}
}
void State1::AllocHSPs(unsigned n)
{
unsigned OldSize = m_HSPs.MaxSize;
if (OldSize >= n)
return;
unsigned NewSize = n + 64;
UFIHSP **OldHSPs = m_HSPs.Data;
m_HSPs.Alloc(NewSize);
unsigned NewMaxSize = m_HSPs.MaxSize;
memcpy(m_HSPs.Data, OldHSPs, OldSize*sizeof(UFIHSP *));
for (unsigned i = OldSize; i < NewMaxSize; ++i)
{
UFIHSP *NewHit = new UFIHSP;
asserta(NewHit != 0);
m_HSPs.Data[i] = NewHit;
}
}
UFIHit *State1::OverlapsHit(uint32 DBStartPos, bool Plus)
{
for (unsigned HitIndex = 0; HitIndex < m_HitCount; ++HitIndex)
{
UFIHit *Hit = m_Hits.Data[HitIndex];
if (DBStartPos/64 == Hit->m_DBStartPos/64)//TODO:better
return Hit;
}
return 0;
}
unsigned State1::OverlapsHSP(uint32 StartPosQ, uint32 StartPosDB, bool Plus)
{
int64 Diag = int64(StartPosDB) - int64(StartPosQ);
for (unsigned HSPIndex = 0; HSPIndex < m_HSPCount; ++HSPIndex)
{
UFIHSP *HSP = m_HSPs.Data[HSPIndex];
int64 HSPDiag = int64(HSP->m_StartPosDB) - int64(HSP->m_StartPosQ);
if (Diag == HSPDiag)
return HSPIndex;
}
return UINT_MAX;
}
void State1::LogPos(uint32 DBPos) const
{
PrPos(g_fLog, DBPos);
}
void State1::PrPos(FILE *f, uint32 DBPos) const
{
if (DBPos == UINT32_MAX)
Pf(f, "*");
else
{
string TargetLabel;
uint32 TargetPos = m_UFI->PosToCoord(DBPos, TargetLabel);
Pf(f, "%u=%s(%u)", DBPos, TargetLabel.c_str(), TargetPos+1);
}
}
void State1::LogHit(unsigned HitIndex) const
{
if (HitIndex == UINT_MAX)
return;
const UFIHit *Hit = m_Hits.Data[HitIndex];
string TargetLabel;
uint32 TargetPos = m_UFI->PosToCoord(Hit->m_DBStartPos, TargetLabel);
Log("hit %u dbpos %u score %d(%c) %s(%u)",
HitIndex, Hit->m_DBStartPos, Hit->m_Score, pom(Hit->m_Plus),
TargetLabel.c_str(), TargetPos+1);
const unsigned QL = m_Query->m_L;
string Path = Hit->m_Path;
if (Path.empty())
for (unsigned i = 0; i < m_Query->m_L; ++i)
Path.push_back('M');
const byte *DBSeq = m_UFI->m_SeqData + Hit->m_DBStartPos;
bool Plus = Hit->m_Plus;
const byte *QSeq = (Plus ? m_Query->m_Seq : m_RevCompQuerySeq.Data);
LogAlnPretty(QSeq, DBSeq, Path.c_str(), false);
}
void State1::LogHSPSummary() const
{
Log("Q>%s %u HSPs\n", m_Query->m_Label, m_HSPCount);
if (m_HSPCount == 0)
return;
vector<int> Scores;
vector<unsigned> Order;
for (unsigned i = 0; i < m_HSPCount; ++i)
{
int Score = GetHSP(i)->m_Score;
Scores.push_back(Score);
}
Order.resize(m_HSPCount);
QuickSortOrderDesc(Scores.data(), m_HSPCount, Order.data());
for (unsigned k = 0; k < m_HSPCount; ++k)
{
unsigned HSPIndex = Order[k];
const UFIHSP *HSP = GetHSP(HSPIndex);
string TargetLabel;
unsigned TargetLo;
Log("HSP[%2u] ", HSPIndex+1);
Log(" %6.1f", double(HSP->m_Score));
if (HSP->m_Aligned)
Log(" ALN");
else
Log(" una");
TargetLo = m_UFI->PosToCoord(HSP->m_StartPosDB, TargetLabel);
Log(" %5.5s(%9u)%c", TargetLabel.c_str(), TargetLo+1, pom(HSP->m_Plus));
Log("\n");
}
}
void State1::LogHitsSummary() const
{
Log("Q>%s %u hits\n", m_Query->m_Label, m_HitCount);
if (m_HitCount == 0)
return;
vector<unsigned> Order(m_HitCount);
GetHitOrder(Order);
for (unsigned k = 0; k < m_HitCount; ++k)
{
unsigned HitIndex = Order[k];
const UFIHit *Hit = m_Hits.Data[HitIndex];
// string TargetLabel;
// unsigned TargetLo;
// Hit->GetStartCoord(TargetLabel, TargetLo);
Log("Hit[%2u] ", HitIndex+1);
Log(" %6.1f", double(Hit->m_Score));
Log(" %10u", Hit->m_DBStartPos);
// Log(" %5.5s(%9u)%c", TargetLabel.c_str(), TargetLo+1, pom(Hit->m_Plus));
if (k == 0)
Log(" MAPQ %.1f", double(m_Mapq));
Log("\n");
}
}
void State1::LogHits() const
{
Log("Q>%s %u hits\n", m_Query->m_Label, m_HitCount);
for (unsigned HitIndex = 0; HitIndex < m_HitCount; ++HitIndex)
{
LogHit(HitIndex);
Log("\n");
}
}
int State1::GetSecondBestDelta() const
{
int BestScore = GetBestScore();
int BestDelta = 99;
for (unsigned i = 0; i < m_HitCount; ++i)
{
int s = m_Hits.Data[i]->m_Score;
if (s == BestScore)
continue;
int Delta = BestScore - s;
if (Delta < BestDelta)
BestDelta = Delta;
}
return BestDelta;
}
const UFIHit *State1::GetTopHit() const
{
if (m_HitCount == 0)
return 0;
int BestScore = GetBestScore();
const UFIHit *TopHit = 0;
for (unsigned i = 0; i < m_HitCount; ++i)
{
const UFIHit *Hit = m_Hits.Data[i];
if (Hit->m_Score == BestScore)
{
if (TopHit != 0)
return 0;
TopHit = Hit;
}
}
return TopHit;
}
void State1::SetSlotsVec(const byte *Seq, unsigned L, uint64 *SlotsVec) const
{
uint64 Word = 0;
byte K = 0;
unsigned SlotCount = 0;
for (uint32 SeqPos = 0; SeqPos < m_WordLength-1; ++SeqPos)
{
byte c = Seq[SeqPos];
byte Letter = g_CharToLetterNucleo[c];
if (Letter == INVALID_LETTER)
{
K = 0;
Word = 0;
continue;
}
if (K < m_WordLength)
++K;
Word = (Word << uint64(2)) | Letter;
}
for (uint32 SeqPos = m_WordLength-1; SeqPos < L; ++SeqPos)
{
byte c = Seq[SeqPos];
byte Letter = g_CharToLetterNucleo[c];
if (Letter == INVALID_LETTER)
{
K = 0;
Word = 0;
SlotsVec[SeqPos-m_WordLength+1] = UINT64_MAX;
continue;
}
if (K < m_WordLength)
++K;
Word = (Word << uint64(2)) | Letter;
if (K == m_WordLength)
{
uint64 Slot = WordToSlot(Word & m_ShiftMask, m_SlotCount);
SlotsVec[SeqPos-m_WordLength+1] = Slot;
}
else
SlotsVec[SeqPos-m_WordLength+1] = UINT64_MAX;
}
}
void State1::SetSlotsVecRC(const byte *Seq, unsigned L, uint64 *SlotsVec) const
{
uint64 Word = 0;
byte K = 0;
unsigned SlotCount = 0;
for (uint32 SeqPos = 0; SeqPos < m_WordLength-1; ++SeqPos)
{
byte c = Seq[SeqPos-L-1];
byte Letter = g_CharToCompLetter[c];
if (Letter == INVALID_LETTER)
{
K = 0;
Word = 0;
continue;
}
if (K < m_WordLength)
++K;
Word = (Word << uint64(2)) | Letter;
}
for (uint32 SeqPos = m_WordLength-1; SeqPos < L; ++SeqPos)
{
byte c = Seq[SeqPos-L-1];
byte Letter = g_CharToCompLetter[c];
if (Letter == INVALID_LETTER)
{
K = 0;
Word = 0;
continue;
}
if (K < m_WordLength)
++K;
Word = (Word << uint64(2)) | Letter;
if (K == m_WordLength)
{
uint64 Slot = WordToSlot(Word & m_ShiftMask, m_SlotCount);
SlotsVec[SeqPos-m_WordLength+1] = Slot;
}
else
SlotsVec[SeqPos-m_WordLength+1] = UINT64_MAX;
}
}
void State1::SetTallyVec(const uint64 *Slots, unsigned N, byte *TallyVec) const
{
for (unsigned i = 0; i < N; ++i)
{
uint64 Slot = Slots[i];
if (Slot == UINT64_MAX)
TallyVec[i] = 0;
else
TallyVec[i] = m_UFI->GetTally(Slot);
}
}
void State1::SetBlobVec(const uint64 *Slots, unsigned N, byte *BlobVec) const
{
for (unsigned i = 0; i < N; ++i)
{
uint64 Slot = Slots[i];
if (Slot == UINT64_MAX)
BlobVec[5*i] = TALLY_FREE;
else
m_UFI->GetBlob(Slot, BlobVec + 5*i);
}
}
unsigned State1::AddHitX(uint32 StartPosDB, bool Plus,
int Score, const string &Path)
{
if (Score < 10)//TODO:PARAM
return UINT_MAX;
asserta(Score > 0);
UFIHit *Hit = OverlapsHit(StartPosDB, Plus);
if (Hit != 0)
return UINT_MAX;
unsigned QL = m_Query->m_L;
int Pen = int(QL) - int(Score);
int MaxPen = Pen - 2*MISMATCH_SCORE;
if (MaxPen < m_MaxPenalty)
m_MaxPenalty = MaxPen;
unsigned HitIndex = m_HitCount;
AllocHits(m_HitCount+1);
Hit = m_Hits.Data[HitIndex];
Hit->m_Score = Score;
Hit->m_Plus = Plus;
Hit->m_DBStartPos = StartPosDB;
Hit->m_Path = Path;
if (Score > m_BestScore)
{
m_SecondBestScore = m_BestScore;
m_BestScore = Score;
m_TopHit = Hit;
}
else if (Score == m_BestScore)
m_SecondBestScore = Score;
else
{
asserta(Score < m_BestScore);
if (Score < m_BestScore - SECONDARY_HIT_MAX_DELTA)
return UINT_MAX;
if (Score > m_SecondBestScore)
m_SecondBestScore = Score;
}
++m_HitCount;
return HitIndex;
}
void State1::AddHSPX(unsigned StartPosQ, uint32 StartPosDB, bool Plus,
unsigned Length, int Score)
{
asserta(Score > 0);
if (Score < m_BestScore - 4) //TODO:PARAM
return;
unsigned HSPIndex = OverlapsHSP(StartPosQ, StartPosDB, Plus);
if (HSPIndex != UINT_MAX)
{
UFIHSP *HSP = m_HSPs.Data[HSPIndex];
if (Score > HSP->m_Score)
{
HSP->m_StartPosQ = StartPosQ;
HSP->m_StartPosDB = StartPosDB;
HSP->m_Score = Score;
HSP->m_Length = Length;
HSP->m_Plus = Plus;
HSP->m_Aligned = false;
}
else
{
;
}
return;
}
AllocHSPs(m_HSPCount+1);
UFIHSP *HSP = m_HSPs.Data[m_HSPCount++];
HSP->m_StartPosQ = StartPosQ;
HSP->m_StartPosDB = StartPosDB;
HSP->m_Score = Score;
HSP->m_Length = Length;
HSP->m_Plus = Plus;
HSP->m_Aligned = false;
if (Score > m_BestHSPScore)
m_BestHSPScore = Score;
}
void State1::HitStats()
{
unsigned Secs = GetElapsedSecs() - m_StartSecs;
double ReadsPerSec = 0.0;
if (Secs > 0)
ReadsPerSec = double(m_QueryCount)/Secs;
unsigned ThreadCount = GetRequestedThreadCount();
//Log("%u threads, %u secs\n", ThreadCount, Secs);
double AcceptPct = GetPct(m_AcceptCount, m_QueryCount);
double RejectPct = GetPct(m_RejectCount, m_QueryCount);
double NoHitPct = GetPct(m_NoHitCount, m_QueryCount);
Log("@rps=%.1f\n", ReadsPerSec);
//Log("%u secs, %s rps", Secs, FloatToStr(ReadsPerSec));
//Log(", acc %u (%.1f%%)", m_AcceptCount, AcceptPct);
//Log(", rej %u (%.1f%%)", m_RejectCount, RejectPct);
//Log(", nohit %u (%.1f%%)\n", m_NoHitCount, NoHitPct);
//Log("\n");
ProgressPrefix(false);
ProgressLog("\n");
ProgressLog("%16u Seconds to load index\n", m_StartSecs);
if (Secs < 180)
ProgressLog("%16u Seconds in mapper\n", Secs);
else if (Secs < 2*60*60)
ProgressLog("%16.1f Minutes in mapper\n", Secs/60.0);
else
ProgressLog("%16.1f Hours in mapper\n", Secs/(60.0*60.0));
ProgressLog("%16s Reads", IntToStrCommas(m_QueryCount));
ProgressLog(" (%s)\n", IntToStr(m_QueryCount));
ProgressLog("%16.16s Reads/sec. (%u threads)\n", FloatToStr(ReadsPerSec), ThreadCount);
ProgressLog("%16s Mapped Q>=%u (%.1f%%)\n", IntToStrCommas(m_AcceptCount), m_Minq, AcceptPct);
ProgressLog("%16s Mapped Q< %u (%.1f%%)\n", IntToStrCommas(m_RejectCount), m_Minq, RejectPct);
ProgressLog("%16s Unmapped (%.1f%%)\n", IntToStrCommas(m_NoHitCount), NoHitPct);
ProgressLog("\n");
ProgressPrefix(true);
}
const UFIHSP *State1::GetHSP(unsigned Index) const
{
asserta(Index < m_HSPCount);
const UFIHSP *HSP = m_HSPs.Data[Index];
return HSP;
}
UFIHSP *State1::GetHSP(unsigned Index)
{
asserta(Index < m_HSPCount);
UFIHSP *HSP = m_HSPs.Data[Index];
return HSP;
}
const UFIHit *State1::GetHit(unsigned Index) const
{
asserta(Index < m_HitCount);
const UFIHit *Hit = m_Hits.Data[Index];
return Hit;
}
void State1::GetTopHitIndexes(vector<unsigned> &HitIndexes) const
{
HitIndexes.clear();
for (unsigned HitIndex = 0; HitIndex < m_HitCount; ++HitIndex)
{
if (m_Hits.Data[HitIndex]->m_Score == m_BestScore)
HitIndexes.push_back(HitIndex);
}
}
UFIHit *State1::GetHit(unsigned Index)
{
asserta(Index < m_HitCount);
UFIHit *Hit = m_Hits.Data[Index];
return Hit;
}
void State1::GetHitOrder(vector<unsigned> &Order) const
{
vector<int> Scores;
for (unsigned i = 0; i < m_HitCount; ++i)
{
int Score = GetHit(i)->m_Score;
Scores.push_back(Score);
}
Order.resize(m_HitCount);
QuickSortOrderDesc(Scores.data(), m_HitCount, Order.data());
}
void State1::LogState(const string &s) const
{
Log("LogState(%s)\n", s.c_str());
#define X(x) Log(" %6.1f %s\n", double(x), #x)
X(MISMATCH_SCORE);
X(GAP_OPEN_SCORE);
X(GAP_EXT_SCORE);
X(MIN_HSP_SCORE_PCT);
X(TERM_HSP_SCORE_PCT_PHASE3);
X(XDROP);
X(MAX_PENALTY);
X(XPHASE1);
X(XPHASE3);
X(XPHASE4);
X(GLOBAL_BAND_RADIUS);
X(m_MaxPenalty);
X(m_BestScore);
X(m_SecondBestScore);
X(m_HSPCount);
X(m_HitCount);
}
bool State1::PolishCIGAR(string &CIGAR) const
{
vector<char> Ops;
vector<unsigned> Lengths;
CIGARGetOps(CIGAR, Ops, Lengths);
CIGAROpsFixDanglingMs(Ops, Lengths);
OpsToCIGAR(Ops, Lengths, CIGAR);
return true;
}
void State1::GetCIGAR(string &CIGAR) const
{
if (m_TopHit == 0)
{
CIGAR = "*";
return;
}
const char *Path = m_TopHit->m_Path.c_str();
if (*Path == 0)
{
unsigned QL = m_Query->m_L;
Ps(CIGAR, "%uM", QL);
}
else
PathToCIGAR(Path, CIGAR);
PolishCIGAR(CIGAR);
}
void State1::WriteSAMHeader(FILE *f, const UFIndex &UFI)
{
if (f == 0)
return;
unsigned SeqCount = SIZE(UFI.m_SeqLengths);
asserta(SIZE(UFI.m_Labels) == SeqCount);
for (unsigned i = 0; i < SeqCount; ++i)
{
const char *Label = UFI.m_Labels[i].c_str();
unsigned Len = UFI.m_SeqLengths[i];
fprintf(f, "@SQ SN:%s LN:%u\n", Label, Len);
}
fprintf(f, "@PG ID:urmap PN:urmap VN:%s.%s CL:",
MY_VERSION, SVN_VERSION);
PrintCmdLine(f);
}
uint32 State1::GetTopHitPos() const
{
if (m_TopHit == 0)
return UINT32_MAX;
uint32 Pos = m_TopHit->m_DBStartPos;
return Pos;
}
void State1::GetPairLabel(string &Label) const
{
Label.clear();
const char *s = m_Query->m_Label;;
unsigned n = ustrlen(s);
if (n > 2 && s[n-2] == '/' &&
(s[n-1] == '1' || s[n-1] == '2'))
n -= 2;
for (unsigned i = 0; i < n; ++i)
{
char c = s[i];
if (isspace(c))
break;
Label += c;
}
}
void State1::GetChrPos(const UFIHit *Hit, string &ChrLabel, uint32 &ChrPos) const
{
if (Hit == 0)
{
ChrLabel = "*";
ChrPos = 0;
return;
}
ChrPos = m_UFI->PosToCoord(Hit->m_DBStartPos, ChrLabel);
}
| 18,145
|
C++
|
.cpp
| 718
| 22.800836
| 96
| 0.672717
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,996
|
ufindexio.cpp
|
rcedgar_urmap/src/ufindexio.cpp
|
#include "myutils.h"
#include "ufindex.h"
void UFIndex::ToFile(const string &FileName) const
{
if (FileName == "")
return;
ProgressOne("Writing %s", FileName.c_str());
FILE *f = CreateStdioFile(FileName);
ToFile(f);
ProgressDone();
CloseStdioFile(f);
}
void UFIndex::ToFile(FILE *f) const
{
uint32 u;
u = UFI_MAGIC1;
WriteStdioFile(f, &u, 4);
WriteStdioFile(f, &m_WordLength, 4);
WriteStdioFile(f, &m_MaxIx, 4);
WriteStdioFile(f, &m_SeqDataSize, 4);
WriteStdioFile(f, &m_SlotCount, 8);
const uint32 SeqCount = SIZE(m_Labels);
WriteStdioFile(f, &SeqCount, 4);
for (unsigned SeqIndex = 0; SeqIndex < SeqCount; ++SeqIndex)
{
WriteStdioFile(f, &m_SeqLengths[SeqIndex], 4);
WriteStdioFile(f, &m_Offsets[SeqIndex], 4);
const string &Label = m_Labels[SeqIndex];
u = SIZE(Label);
WriteStdioFile(f, &u, 4);
WriteStdioFile(f, Label.c_str(), u);
}
u = UFI_MAGIC2;
WriteStdioFile(f, &u, 4);
WriteStdioFile64(f, m_Blob, 5*m_SlotCount);
u = UFI_MAGIC3;
WriteStdioFile(f, &u, 4);
WriteStdioFile(f, m_SeqData, m_SeqDataSize);
u = UFI_MAGIC5;
WriteStdioFile(f, &u, 4);
}
void UFIndex::FromFile(const string &FileName)
{
FILE *f = OpenStdioFile(FileName);
ProgressFile(f, "Reading index", FileName);
FromFile(f);
ProgressDone();
CloseStdioFile(f);
}
void UFIndex::FromFile(FILE *f)
{
uint32 u;
ReadStdioFile(f, &u, 4);
asserta(u == UFI_MAGIC1);
ReadStdioFile(f, &m_WordLength, 4);
ReadStdioFile(f, &m_MaxIx, 4);
ReadStdioFile(f, &m_SeqDataSize, 4);
ReadStdioFile(f, &m_SlotCount, 8);
m_StartPos = 0;
m_EndPos = m_SeqDataSize - 1;
SetShiftMask();
uint32 SeqCount;
ReadStdioFile(f, &SeqCount, 4);
for (unsigned SeqIndex = 0; SeqIndex < SeqCount; ++SeqIndex)
{
uint32 SeqLength;
uint32 Offset;
ReadStdioFile(f, &SeqLength, 4);
ReadStdioFile(f, &Offset, 4);
m_SeqLengths.push_back(SeqLength);
m_Offsets.push_back(Offset);
m_GenomeSize += SeqLength;
ReadStdioFile(f, &u, 4);
char *s = myalloc(char, u+1);
ReadStdioFile(f, s, u);
s[u] = 0;
string Label;
Label = string(s);
m_Labels.push_back(Label);
}
ReadStdioFile(f, &u, 4);
asserta(u == UFI_MAGIC2);
m_Blob = (byte *) malloc(5*m_SlotCount);
if (m_Blob == 0)
Die("Out of memory %s:%u", __FILE__, __LINE__);
ReadStdioFile64(f, m_Blob, 5*m_SlotCount);
ReadStdioFile(f, &u, 4);
asserta(u == UFI_MAGIC3);
// m_SeqData = myalloc(byte, m_SeqDataSize);
m_SeqData = (byte *) malloc(m_SeqDataSize);
if (m_SeqData == 0)
Die("Out of memory %s:%u", __FILE__, __LINE__);
ReadStdioFile(f, m_SeqData, m_SeqDataSize);
ReadStdioFile(f, &u, 4);
asserta(u == UFI_MAGIC5);
}
void cmd_make_ufi()
{
const string &RefFileName = opt(make_ufi);
double LoadFactor = opt(load_factor);
unsigned WordLength = 24;
unsigned MaxIx = 32;
if (!optset_notrunclabels)
{
opt_trunclabels = true;
optset_trunclabels = true;
optused_trunclabels = true;
}
if (optset_wordlength)
WordLength = opt(wordlength);
if (opt(veryfast))
MaxIx = 3;
if (optset_maxix)
MaxIx = opt(maxix);
FILE *f = OpenStdioFile(RefFileName);
int64 GenomeSize = GetStdioFileSize64(f);
CloseStdioFile(f);
uint64 SlotCount;
if (optset_slots)
SlotCount = StrToUint64(opt(slots));
else
{
int64 iMinSlotCount = int64(GenomeSize/LoadFactor);
uint64 GetPrime(uint64 n);
SlotCount = GetPrime(iMinSlotCount);
}
if (GenomeSize > UINT32_MAX - 100000)
Die("Genome too big (%s), email robert@drive5.com for update",
Int64ToStr(GenomeSize));
Progress("\n");
Progress(" Genome size %s\n", Int64ToStr(GenomeSize));
Progress(" Slots %" PRIu64 " (%s)\n", SlotCount, Int64ToStr(SlotCount));
Progress(" Load factor %.2f\n", GenomeSize/double(SlotCount));
Progress(" Word length %u\n", WordLength);
Progress(" Max abund. %u\n", MaxIx);
Progress("\n");
UFIndex UFI;
UFI.m_WordLength = WordLength;
UFI.m_MaxIx = MaxIx;
UFI.m_SlotCount = SlotCount;
UFI.SetShiftMask();
UFI.ReadSeqData(RefFileName);
UFI.MakeIndex();
if (opt(validate))
UFI.Validate();
if (opt(logstats))
{
UFI.LogMe();
UFI.LogStats();
}
UFI.ToFile(opt(output));
}
void cmd_suggest_slots()
{
double GenomeSize = StrToFloat(opt(suggest_slots))*1e6;
double LoadFactor = opt(load_factor);
Progress("\n");
Progress("Genome size %s\n", FloatToStr(GenomeSize));
Progress("Load factor %.2f\n", LoadFactor);
int64 iMinSlotCount = int64(GenomeSize/LoadFactor);
uint64 GetPrime(uint64 n);
uint64 SlotCount = GetPrime(iMinSlotCount);
Progress("Prime slots %" PRIu64 " (%s)\n", SlotCount, Int64ToStr(SlotCount));
Progress("Prime load %.2f\n", GenomeSize/double(SlotCount));
Progress("\n");
}
| 4,637
|
C++
|
.cpp
| 166
| 25.493976
| 81
| 0.698581
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,997
|
fastqseqsource.cpp
|
rcedgar_urmap/src/fastqseqsource.cpp
|
#include "myutils.h"
#include "fastqseqsource.h"
#include "seqinfo.h"
#include "alpha.h"
#include "omplock.h"
#define TRACE 0
bool FASTQSeqSource::GetNextLo(SeqInfo *SI)
{
// Label
bool Ok = ReadLine();
if (!Ok)
return false;
unsigned n = m_LineBuff.Size;
const char *Line = m_LineBuff.Data;
bool TruncLabels = opt(trunclabels);
#if TRACE
{
Log("m_LineBuff.Size=%u Line=\"", n);
for (unsigned i = 0; i < n; ++i)
Log("%c", Line[i]);
Log("\"\n");
}
#endif
// Allow empty lines at EOF
if (n == 0)
{
for (;;)
{
unsigned LineNr = m_LR.m_LineNr;
bool Ok = ReadLine();
if (!Ok)
return false;
if (m_LineBuff.Size != 0)
Die("Empty line nr %u in FASTQ file '%s'", LineNr, GetFileNameC());
}
}
if (Line[0] != '@')
{
Log("\n");
Log("Line %u: %s\n", m_LR.m_LineNr, Line);
Die("Bad line %u in FASTQ file '%s': expected '@'", m_LR.m_LineNr, GetFileNameC());
}
unsigned SeqIndex = m_SeqCount;
SI->Init(SeqIndex);
SI->AllocLabel(n);
for (unsigned i = 1; i < n; ++i)
{
char c = Line[i];
if (isspace(c) && TruncLabels)
{
SI->m_LabelBuffer[i-1] = 0;
break;
}
SI->m_LabelBuffer[i-1] = c;
}
SI->m_LabelBuffer[n-1] = 0;
// Seq
Ok = ReadLine();
if (!Ok)
Die("Unexpected end-of-file in FASTQ file %s", GetFileNameC());
Line = m_LineBuff.Data;
unsigned L = m_LineBuff.Size;
SI->AllocSeq(L);
SI->m_L = L;
byte *Seq = SI->m_SeqBuffer;
for (unsigned i = 0; i < L; ++i)
{
byte c = (byte) Line[i];
if (!isalpha(c))
{
if (isprint(c))
Die("Invalid sequence letter '%c' in FASTQ, line %u file %s",
c, m_LR.m_LineNr, GetFileNameC());
else
Die("Non-printing byte 0x%02x in FASTQ sequence line %u file %s label %s",
c, m_LR.m_LineNr, GetFileNameC(), SI->m_Label);
}
Seq[i] = c;
}
// +[Label]
// Ignore contents & possible eof
ReadLine();
// Qual
Ok = ReadLine();
if (!Ok)
Die("Unexpected end-of-file in FASTQ file %s", GetFileNameC());
Line = m_LineBuff.Data;
if (Line == 0)
Die("Unexpected end-of-file in FASTQ file %s", GetFileNameC());
unsigned LQ = m_LineBuff.Size;
if (LQ != L)
Die("Bad FASTQ record: %u bases, %u quals line %u file %s label %s",
L, LQ, m_LR.m_LineNr, GetFileNameC(), SI->m_Label);
SI->AllocQual(L);
char *Qual = SI->m_QualBuffer;
for (unsigned i = 0; i < L; ++i)
{
char c = (byte) Line[i];
Qual[i] = c;
}
return true;
}
| 2,388
|
C++
|
.cpp
| 102
| 20.627451
| 85
| 0.611356
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| true
| false
| true
| false
|
1,537,998
|
search2m4.cpp
|
rcedgar_urmap/src/search2m4.cpp
|
#include "myutils.h"
#include "ufindex.h"
#include "state2.h"
#include "seqinfo.h"
#include "omplock.h"
#include "sort.h"
#define PINTEST 0
#if PINTEST
uint32 GetTrueDBPos(SeqInfo *Query, const UFIndex &UFI);
bool SamePos(uint32 Pos1, uint32 Pos2);
#endif
void State2::Search4(SeqInfo *Query_Fwd, SeqInfo *Query_Rev)
{
m_UD_Fwd.InitPE(Query_Fwd);
m_UD_Rev.InitPE(Query_Rev);
#if PINTEST
uint32 TruePosf = GetTrueDBPos(Query_Fwd, *m_UD_Fwd.m_UFI);
uint32 TruePosr = GetTrueDBPos(Query_Rev, *m_UD_Rev.m_UFI);
Log("\n");
Log("1>%s\n", Query_Fwd->m_Label);
Log("2>%s\n", Query_Rev->m_Label);
#endif
m_BestPairScore = 0;
m_SecondBestPairScore = 0;
m_BestPairIndex = 0;
m_SecondPairIndex = UINT_MAX;
unsigned QLf = m_UD_Fwd.m_Query->m_L;
unsigned QLr = m_UD_Rev.m_Query->m_L;
unsigned QL2 = (QLf + QLr)/2;
unsigned Sizef = 2*QLf;
unsigned Sizer = 2*QLr;
if (Sizef > m_B1Sizef)
{
Sizef += 64;
m_B1_QPosVecf.Alloc(Sizef);
m_B1_PlusVecf.Alloc(Sizef);
m_B1_DBPosVecf.Alloc(Sizef);
m_B1Sizef = Sizef;
}
if (Sizer > m_B1Sizer)
{
Sizer += 64;
m_B1_QPosVecr.Alloc(Sizer);
m_B1_PlusVecr.Alloc(Sizer);
m_B1_DBPosVecr.Alloc(Sizer);
m_B1Sizer = Sizer;
}
m_TermPairScorePhase1 = int(QLf) + int(QLr) + 5*State1::MISMATCH_SCORE;//TODO:PARAM
unsigned kf = UINT_MAX;
unsigned kr = UINT_MAX;
uint32 *B1_QPosVecf = m_B1_QPosVecf.Data;
uint32 *B1_QPosVecr = m_B1_QPosVecr.Data;
bool *B1_PlusVecf = m_B1_PlusVecf.Data;
bool *B1_PlusVecr = m_B1_PlusVecr.Data;
uint32 *B1_DBPosVecf = m_B1_DBPosVecf.Data;
uint32 *B1_DBPosVecr = m_B1_DBPosVecr.Data;
unsigned NB1f = 0;
unsigned NB1r = 0;
{
uint32 QPosf;
uint32 QPosr;
bool Plusf;
bool Plusr;
uint32 DBPosf;
uint32 DBPosr;
kf = m_UD_Fwd.GetFirstBoth1Seed(QPosf, Plusf, DBPosf);
kr = m_UD_Rev.GetFirstBoth1Seed(QPosr, Plusr, DBPosr);
do
{
if (kf != UINT_MAX)
{
B1_QPosVecf[NB1f] = QPosf;
B1_PlusVecf[NB1f] = Plusf;
B1_DBPosVecf[NB1f] = DBPosf;
++NB1f;
for (unsigned i = 0; i < NB1r; ++i)
{
uint32 DBPosr = B1_DBPosVecr[i];
int64 TL = abs(int64(DBPosf) - int64(DBPosr)) + int64(QL2);
if (AcceptTemplateLength(TL))
{
uint32 QPosr = B1_QPosVecr[i];
bool Done = ExtendBoth1Pair4(QPosf, DBPosf, Plusf,
QPosr, DBPosr);
#if PINTEST
{
bool Truef = SamePos(DBPosf, TruePosf);
bool Truer = SamePos(DBPosr, TruePosr);
Log(" (a) truef %c, truer %c, done %c\n",
tof(Truef), tof(Truer), tof(Done));
}
#endif
if (Done)
return;
}
}
}
if (kr != UINT_MAX)
{
B1_QPosVecr[NB1r] = QPosr;
B1_PlusVecr[NB1r] = Plusr;
B1_DBPosVecr[NB1r] = DBPosr;
++NB1r;
for (unsigned i = 0; i < NB1f; ++i)
{
uint32 DBPosf = B1_DBPosVecf[i];
int64 TL = abs(int64(DBPosf) - int64(DBPosr)) + int64(QL2);
if (AcceptTemplateLength(TL))
{
uint32 QPosf = B1_QPosVecf[i];
bool Done = ExtendBoth1Pair4(QPosf, DBPosf, !Plusr,
QPosr, DBPosr);
#if PINTEST
{
bool Truef = SamePos(DBPosf, TruePosf);
bool Truer = SamePos(DBPosr, TruePosr);
Log(" (b) truef %c, truer %c, done %c\n",
tof(Truef), tof(Truer), tof(Done));
}
#endif
if (Done)
return;
}
}
}
if (kf != UINT_MAX)
kf = m_UD_Fwd.GetNextBoth1Seed(kf, QPosf, Plusf, DBPosf);
if (kr != UINT_MAX)
kr = m_UD_Rev.GetNextBoth1Seed(kr, QPosr, Plusr, DBPosr);
}
while (kf != UINT_MAX || kr != UINT_MAX);
}
for (unsigned i = 0; i < NB1f; ++i)
{
uint32 QPos = B1_QPosVecf[i];
uint32 DBPos = B1_DBPosVecf[i];
bool Plus = B1_PlusVecf[i];
m_UD_Fwd.ExtendPen(QPos, DBPos, Plus);
}
for (unsigned i = 0; i < NB1r; ++i)
{
uint32 QPos = B1_QPosVecr[i];
uint32 DBPos = B1_DBPosVecr[i];
bool Plus = B1_PlusVecr[i];
m_UD_Rev.ExtendPen(QPos, DBPos, Plus);
}
int TermScore_Fwd = (QLf*9)/10;
int TermScore_Rev = (QLr*9)/10;
if (m_UD_Fwd.m_BestScore >= TermScore_Fwd &&
m_UD_Rev.m_BestScore >= TermScore_Rev)
{
uint32 DBPosf = m_UD_Fwd.m_TopHit->m_DBStartPos;
uint32 DBPosr = m_UD_Rev.m_TopHit->m_DBStartPos;
int64 TL = abs(int64(DBPosf) - int64(DBPosr)) + int64(QL2);
if (AcceptTemplateLength(TL))
{
m_UD_Fwd.m_Mapq = 40;
m_UD_Rev.m_Mapq = 40;
return;
}
}
m_UD_Fwd.SearchPE_Pending(kf);
m_UD_Rev.SearchPE_Pending(kr);
FindPairs();
const unsigned N = SIZE(m_Paired_TotalScoreVec);
if (N == 0)
{
ScanPair();
FindPairs();
}
AdjustTopHitsAndMapqs();
}
bool State2::ExtendBoth1Pair4(uint32 QPosf, uint32 DBPosf, bool Plusf,
uint32 QPosr, uint32 DBPosr)
{
int FwdScore = m_UD_Fwd.ExtendPen(QPosf, DBPosf, Plusf);
if (FwdScore <= 0)
return false;
int RevScore = m_UD_Rev.ExtendPen(QPosr, DBPosr, !Plusf);
if (RevScore <= 0)
return false;
int SumScore = FwdScore + RevScore;
if (SumScore < m_TermPairScorePhase1)
return false;
m_UD_Fwd.m_Mapq = 40;
m_UD_Rev.m_Mapq = 40;
return true;
}
| 4,900
|
C++
|
.cpp
| 188
| 22.81383
| 84
| 0.657928
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,537,999
|
viterbifastbandmem.cpp
|
rcedgar_urmap/src/viterbifastbandmem.cpp
|
#include "myutils.h"
#include "diagbox.h"
#include "alnparams.h"
#include "tracebit.h"
#include "pathinfo.h"
#include "xdpmem.h"
void TraceBackBitMem(XDPMem &Mem, unsigned LA, unsigned LB, char State, PathInfo &PI);
float ViterbiFastBandMem(XDPMem &Mem, const byte *A, unsigned LA, const byte *B, unsigned LB,
unsigned DiagLo, unsigned DiagHi, const AlnParams &AP, PathInfo &PI)
{
asserta(LA > 0 && LB > 0);
asserta(DiagLo <= DiagHi);
// Verify diagonal range includes terminals
DiagBox Box(LA, LB, DiagLo, DiagHi);
asserta(Box.InBox(0, 0));
asserta(Box.InBox(LA-1, LB-1));
Mem.Alloc(LA, LB);
PI.Alloc2(LA, LB);
StartTimer(ViterbiFastBandMem);
const float * const *Mx = AP.SubstMx;
float OpenA = AP.LOpenA;
float ExtA = AP.LExtA;
float *Mrow = Mem.GetDPRow1();
float *Drow = Mem.GetDPRow2();
byte **TB = Mem.GetTBBit();
// Use Mrow[j-1] when j=0, so...
Mrow[-1] = MINUS_INFINITY;
// ? Surely don't need to initialize all entries in vector
for (unsigned j = 0; j <= LB; ++j)
{
Mrow[j] = MINUS_INFINITY;
Drow[j] = MINUS_INFINITY;
}
// Main loop
for (unsigned i = 0; i < LA; ++i)
{
unsigned Startj, Endj;
Box.GetRange_j(i, Startj, Endj);
if (Endj == 0)
{
static bool WarningDone = false;
if (!WarningDone)
{
Warning("Endj==0");
WarningDone = true;
}
continue;
}
float OpenB = Startj == 0 ? AP.LOpenB : AP.OpenB;
float ExtB = Startj == 0 ? AP.LExtB : AP.ExtB;
byte a = A[i];
const float *MxRow = Mx[a];
float I0 = MINUS_INFINITY;
float M0;
if (i == 0)
M0 = 0;
else
{
if (Startj == 0)
M0 = MINUS_INFINITY;
else
M0 = Mrow[int(Startj)-1];
}
byte *TBrow = TB[i];
if (Startj > 0)
TBrow[int(Startj)-1] = TRACEBITS_IM;
for (unsigned j = Startj; j < Endj; ++j)
{
byte b = B[j];
byte TraceBits = 0;
float SavedM0 = M0;
// MATCH
{
// M0 = DPM[i][j]
// I0 = DPI[i][j]
// Drow[j] = DPD[i][j]
float xM = M0;
if (Drow[j] > xM)
{
xM = Drow[j];
TraceBits = TRACEBITS_DM;
}
if (I0 > xM)
{
xM = I0;
TraceBits = TRACEBITS_IM;
}
M0 = Mrow[j];
Mrow[j] = xM + MxRow[b];
// Mrow[j] = DPM[i+1][j+1])
}
// DELETE
{
// SavedM0 = DPM[i][j]
// Drow[j] = DPD[i][j]
float md = SavedM0 + OpenB;
Drow[j] += ExtB;
if (md >= Drow[j])
{
Drow[j] = md;
TraceBits |= TRACEBITS_MD;
}
// Drow[j] = DPD[i+1][j]
}
// INSERT
{
// SavedM0 = DPM[i][j]
// I0 = DPI[i][j]
float mi = SavedM0 + OpenA;
I0 += ExtA;
if (mi >= I0)
{
I0 = mi;
TraceBits |= TRACEBITS_MI;
}
// I0 = DPI[i][j+1]
}
OpenB = AP.OpenB;
ExtB = AP.ExtB;
TBrow[j] = TraceBits;
}
// Special case for end of Drow[]
{
// M0 = DPM[i][LB]
// Drow[LB] = DPD[i][LB]
TBrow[LB] = 0;
float md = M0 + AP.ROpenB;
Drow[LB] += AP.RExtB;
if (md >= Drow[LB])
{
Drow[LB] = md;
TBrow[LB] = TRACEBITS_MD;
}
// Drow[LB] = DPD[i+1][LB]
}
M0 = MINUS_INFINITY;
OpenA = AP.OpenA;
ExtA = AP.ExtA;
}
unsigned Startj, Endj;
Box.GetRange_j(LA-1, Startj, Endj);
asserta(Endj == LB);
// Special case for last row of DPI
byte *TBrow = TB[LA];
float I1 = MINUS_INFINITY;
Mrow[int(Startj)-1] = MINUS_INFINITY;
for (unsigned j = Startj; j < Endj; ++j)
{
// Mrow[j-1] = DPM[LA][j]
// I1 = DPI[LA][j]
TBrow[j] = 0;
float mi = Mrow[int(j)-1] + AP.ROpenA;
I1 += AP.RExtA;
if (mi > I1)
{
I1 = mi;
TBrow[j] = TRACEBITS_MI;
}
}
float FinalM = Mrow[LB-1];
float FinalD = Drow[LB];
float FinalI = I1;
// FinalM = DPM[LA][LB]
// FinalD = DPD[LA][LB]
// FinalI = DPI[LA][LB]
float Score = FinalM;
byte State = 'M';
if (FinalD > Score)
{
Score = FinalD;
State = 'D';
}
if (FinalI > Score)
{
Score = FinalI;
State = 'I';
}
EndTimer(ViterbiFastBandMem);
TraceBackBitMem(Mem, LA, LB, State, PI);
return Score;
}
float ViterbiFastMainDiagMem(XDPMem &Mem, const byte *A, unsigned LA,
const byte *B, unsigned LB, unsigned BandRadius, const AlnParams &AP,
PathInfo &PI)
{
// Main diagonal
// d = LA - i + j = 1 .. LA+LB-1
// Left term: i=0,j=0 d=LA
// Right term: i=LA-1,j=LB-1 d=LA-(LA-1)+(LB-1) = LB
unsigned DiagLo = min(LA, LB);
unsigned DiagHi = max(LA, LB);
if (DiagLo > BandRadius)
DiagLo -= BandRadius;
else
DiagLo = 1;
DiagHi += BandRadius;
unsigned MaxDiag = LA + LB - 1;
if (DiagHi > MaxDiag)
DiagHi = MaxDiag;
return ViterbiFastBandMem(Mem, A, LA, B, LB, DiagLo, DiagHi, AP, PI);
}
| 4,517
|
C++
|
.cpp
| 201
| 19.18408
| 93
| 0.599953
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,000
|
gzipfileio.cpp
|
rcedgar_urmap/src/gzipfileio.cpp
|
#include "myutils.h"
#if 1 // _MSC_VER
#include "zlib.h"
#else
#include <zlib.h>
#endif
FILE *OpenGzipFile(const string &FileName)
{
gzFile f = gzopen(FileName.c_str(), "rb");
if (f == 0)
Die("Error opening gzip file %s", FileName.c_str());
return (FILE *) f;
}
uint32 ReadGzipFile(FILE *f, void *Buff, uint32 MaxBytes)
{
int n = gzread(gzFile(f), Buff, MaxBytes);
if (n < 0)
Die("Error reading gzip file");
return unsigned(n);
}
void CloseGzipFile(FILE *f)
{
if (f == 0)
return;
gzclose_r(gzFile(f));
}
| 527
|
C++
|
.cpp
| 26
| 18.384615
| 57
| 0.668675
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,001
|
timing.cpp
|
rcedgar_urmap/src/timing.cpp
|
#include "myutils.h"
#include "getticks.h"
#include <time.h>
#include <algorithm>
#ifdef _MSC_VER
#include <Windows.h> // for IsDebuggerPresent()
#endif
static unsigned g_LockCalls;
static TICKS g_TotalLockTicks;
static time_t t_Start = time(0);
static time_t t_End;
static TICKS g_TicksStart = GetClockTicks();
static TICKS g_TicksEnd;
void IncLockTicks(TICKS t)
{
++g_LockCalls;
g_TotalLockTicks += t;
}
void LogLockTicks()
{
g_TicksEnd = GetClockTicks();
t_End = time(0);
time_t Secs = t_End - t_Start;
if (Secs == 0)
Secs = 1;
TICKS ElapsedTicks = g_TicksEnd - g_TicksStart;
double Pct = GetPct((double) g_TotalLockTicks, (double) ElapsedTicks);
Progress("\n");
Progress("%10u Lock calls\n", g_LockCalls);
Progress("%10.0f Lock ticks (%s)\n", (double) g_TotalLockTicks, FloatToStr(double(g_TotalLockTicks)));
Progress("%10.0f Elapsed ticks (%s)\n", (double) ElapsedTicks, FloatToStr(double(ElapsedTicks)));
Progress("%10.1f%% Pct locks\n", Pct);
Progress("\n");
}
#if TIMING
TIMER g_CurrTimer = TIMER_None;
TIMER g_LastTimer;
TICKS g_LastTicks;
#if TIMING_2D
TICKS g_PrefixTicks2D[TimerCount][TimerCount];
unsigned g_PrefixCounts2D[TimerCount][TimerCount];
#else
#define T(x) \
TICKS g_PrefixTicks##x;
#include "timers.h"
#endif
unsigned g_Counters[CounterCount];
#define T(x) \
TICKS g_TotalTicks##x; \
unsigned g_TimerStartCount##x;
#include "timers.h"
#define T(x) unsigned g_STimerTicks##x;
#include "stimers.h"
static TICKS g_StartTicks;
static time_t g_StartTime;
void ResetTimers()
{
#define T(x) g_TimerStartCount##x = 0; g_TotalTicks##x = 0;
#include "timers.h"
#define T(x) g_STimerTicks##x = 0;
#include "stimers.h"
InitTiming();
memset_zero(g_Counters, CounterCount);
#if TIMING_2D
for (unsigned i = 0; i < TimerCount; ++i)
{
for (unsigned j = 0; j < TimerCount; ++j)
{
g_PrefixTicks2D[i][j] = 0;
g_PrefixCounts2D[i][j] = 0;
}
}
#else
#define T(x) g_PrefixTicks##x = 0;
#include "timers.h"
#endif
}
static double GetTimerOverheadTicks()
{
const unsigned N = 1000*1000;
TICKS t1 = GetClockTicks();
for (unsigned i = 0; i < N; ++i)
{
StartTimer(GetTimerOverhead);
EndTimer(GetTimerOverhead);
}
TICKS t2 = GetClockTicks();
double Ticks = double(t2 - t1);
return Ticks/N;
}
void InitTiming()
{
g_StartTime = time(0);
TICKS Now = GetClockTicks();
g_StartTicks = Now;
g_LastTicks = Now;
}
static const char *CounterToStr(COUNTER c)
{
switch (c)
{
#define C(x) case COUNTER_##x: return #x;
#include "counters.h"
#undef C
}
return "?";
}
static void LogCounters()
{
Log("\n");
Log(" Counter N\n");
Log("-------------------------------- ----------\n");
for (unsigned i = 0; i < CounterCount; ++i)
{
double N = g_Counters[i];
if (N == 0)
continue;
Log("%32.32s %10.10s\n", CounterToStr((COUNTER) i), FloatToStr(N));
}
}
const char *TimerToStr(TIMER t)
{
switch (t)
{
#define T(x) case TIMER_##x: return #x;
#include "timers.h"
#undef T
}
return "?";
}
static void LogTimers(const GlobalTimingData >D,
const vector<TimerData> &TDs)
{
const unsigned TDCount = SIZE(TDs);
double TotalTimerCalls = 0.0;
double TotalTimerTicks = 0.0;
for (unsigned i = 0; i < TDCount; ++i)
{
const TimerData &TD = TDs[i];
TotalTimerTicks += TD.Ticks;
if (!TD.Is1D && !TD.Is2D)
TotalTimerCalls += TD.Calls;
}
double TicksPerSec = GTD.ElapsedTicks/GTD.ElapsedSecs;
double TotalTimerSecs = TotalTimerTicks/TicksPerSec;
double TotalTimerOverheadTicks = TotalTimerCalls*GTD.TimerOverheadTicks;
double TotalTimerOverheadSecs = TotalTimerOverheadTicks/TicksPerSec;
double TotalPct = 0.0;
double TotalPctShown = 0.0;
double TotalCPct = 0.0;
double TotalSecs = 0.0;
Log("\n");
Log(" Pct TotPct Ticks Secs Calls Ticks/Call Timer\n");
Log("------- ------- ----------- ---------- ---------- ---------- -----\n");
for (unsigned i = 0; i < TDCount; ++i)
{
const TimerData &TD = TDs[i];
double pct = GetPct(TD.Ticks, TotalTimerTicks);
TotalPct += pct;
double Secs = TD.Ticks/TicksPerSec;
TotalSecs += Secs;
double CTicks = TD.Ticks;
if (!TD.Is1D && !TD.Is2D)
CTicks -= TD.Calls*GTD.TimerOverheadTicks;
double TicksPerCall = TD.Calls == 0.0 ? 0.0 : CTicks/TD.Calls;
if (pct >= opt(min_timer_pct))
{
TotalPctShown += pct;
Log("%6.1f%%", pct);
Log(" %6.1f%%", TotalPct);
Log(" %11.4e", TD.Ticks);
Log(" %10.10s", FloatToStr(Secs));
Log(" %10.10s", FloatToStr(TD.Calls));
Log(" %10.10s", TD.Is1D ? "" : FloatToStr(TicksPerCall));
Log(" %s", TD.Name.c_str());
Log("\n");
}
}
Log("======= ======= =========== ========== ========== ========== =====\n");
Log("%6.1f%%", TotalPctShown);
Log(" %6.1f%%", TotalPct);
Log(" %11.11s", FloatToStr(TotalTimerTicks));
Log(" %10.10s", FloatToStr(TotalSecs));
Log(" %10.10s", FloatToStr(TotalTimerCalls));
Log(" %10.10s", "");
Log(" TOTAL\n");
Log("\n");
Log("\n");
Log("%11.4g Ticks elapsed (%.1f secs)\n",
GTD.ElapsedTicks, GTD.ElapsedTicks/TicksPerSec);
Log("%11.4g Ticks total timers (%.1f%%)\n",
TotalTimerTicks,
GetPct(TotalTimerTicks, GTD.ElapsedTicks));
Log("%11.11s Secs elapsed\n", SecsToStr(GTD.ElapsedSecs));
Log("%11.11s Timer overhead ticks\n", FloatToStr(GTD.TimerOverheadTicks));
double TimerOverheadSecs = TotalTimerCalls*GTD.TimerOverheadTicks/TicksPerSec;
double EstdSecs = GTD.ElapsedSecs - TimerOverheadSecs;
Log("%11.11s Secs timer overhead (%.1f%%)\n",
SecsToStr(TimerOverheadSecs),
GetPct(TimerOverheadSecs, GTD.ElapsedSecs));
Log("%11.11s Secs estd. without timers\n",
SecsToStr(EstdSecs));
}
void LogTiming()
{
TICKS ExitTicks = GetClockTicks();
time_t ExitTime = time(0);
#if TIMING_2D
g_PrefixTicks2D[g_LastTimer][TIMER_ExitTiming] = ExitTicks - g_LastTicks;
#else
g_TotalTicksExitTiming = ExitTicks - g_LastTicks;
#endif
GlobalTimingData GTD;
double ElapsedSecs = double(ExitTime - g_StartTime);
if (ElapsedSecs == 0.0)
ElapsedSecs = 1.0;
double ElapsedTicks = double(ExitTicks - g_StartTicks);
vector<TimerData> TDs;
#define T(x) \
{ \
double Ticks = (double) g_TotalTicks##x; \
if (Ticks > 0.0) \
{ \
TimerData TD; \
TD.Name = #x; \
TD.Ticks = Ticks; \
TD.Calls = g_TimerStartCount##x; \
TD.Is1D = false; \
TD.Is2D = false; \
TDs.push_back(TD); \
} \
}
#include "timers.h"
#if TIMING_2D
#define T(x) \
{ \
for (unsigned i = 0; i < TimerCount; ++i) \
{ \
double Ticks = (double) g_PrefixTicks2D[TIMER_##x][i];\
if (Ticks > 0.0) \
{ \
TimerData TD; \
TD.Name = string(#x) + string(" - ") \
+ string(TimerToStr((TIMER) i)); \
TD.Ticks = Ticks; \
TD.Calls = g_PrefixCounts2D[i][TIMER_##x]; \
TD.Is1D = false; \
TD.Is2D = true; \
TDs.push_back(TD); \
} \
} \
}
#include "timers.h"
#else
#define T(x) \
{ \
double Ticks = (double) g_PrefixTicks##x; \
if (Ticks > 0.0) \
{ \
TimerData TD; \
TD.Name = "> " #x; \
TD.Ticks = Ticks; \
TD.Calls = g_TimerStartCount##x; \
TD.Is1D = true; \
TD.Is2D = false; \
TDs.push_back(TD); \
} \
}
#include "timers.h"
#endif
sort(TDs.begin(), TDs.end());
Log("\n");
#ifdef _MSC_VER
Log("Debugger %s\n", IsDebuggerPresent() ? "Yes " : "No");
#endif
GTD.ElapsedSecs = ElapsedSecs;
GTD.ElapsedTicks = ElapsedTicks;
GTD.TimerOverheadTicks = GetTimerOverheadTicks();
LogCounters();
LogTimers(GTD, TDs);
double TicksPerSec = GTD.ElapsedTicks/GTD.ElapsedSecs;
bool Any = false;
#define T(x) \
if (g_STimerTicks##x > 0) \
{ \
if (!Any) \
{ \
Any = true; \
Log("\n"); \
Log(" STimer Ticks Secs\n"); \
Log("-------------------------------- ----------- ----\n"); \
} \
Log("%32.32s %11.4g %s\n", \
#x, \
(double) g_STimerTicks##x, \
SecsToStr(g_STimerTicks##x/TicksPerSec)); \
}
#include "stimers.h"
}
#else
void InitTiming()
{
}
void LogTiming()
{
}
#endif // TIMING
#if 0
void cmd_test()
{
time_t t1 = time(0);
double Sum = 0.0;
TICKS ticks1 = GetClockTicks();
for (;;)
{
time_t t2 = time(0);
if (t2 - t1 >= 10)
break;
Sum += t2;
}
TICKS ticks2 = GetClockTicks();
Log("Sum = %.3g\n", Sum);
double Ticks = ticks2 - ticks1;
double TicksPerSec = Ticks/10.0;
double WrapSecs = INT64_MAX/TicksPerSec;
Progress("%.3g ticks\n", Ticks);
Progress("%s ticks/sec\n", FloatToStr(TicksPerSec));
Progress("%s wrap secs\n", FloatToStr(WrapSecs));
}
#endif // 0
| 8,826
|
C++
|
.cpp
| 330
| 24.321212
| 104
| 0.617546
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,002
|
progress.cpp
|
rcedgar_urmap/src/progress.cpp
|
#include "myutils.h"
#include <time.h>
enum PSTATE
{
WAITING = 1,
PARTLINE = 2,
BAR = 3,
BUSY = 4,
};
static PSTATE g_State = WAITING;
static string g_Msg = "Processing";
static FILE *g_fOut = stderr;
static FILE *g_fMon;
static uint64 g_FileSize = UINT64_MAX;
static FN_PROGRESS_CALLBACK g_CB = 0;
static uint32 g_StepCount32;
static uint64 g_StepCount64;
static const uint32 *g_ptrStepIndex32;
static const uint64 *g_ptrStepIndex64;
static time_t g_TimeLastOutput;
static time_t g_TimeStart;
static time_t g_TimeDone;
static double g_MemStart;
static double g_MemDone;
static bool g_Prefix = true;
static string g_ProgressBar;
static string g_CurrentLine;
static string g_BusyStr;
static void ForceNewLine()
{
switch (g_State)
{
case WAITING:
return;
case PARTLINE:
fputs(g_CurrentLine.c_str(), g_fOut);
g_CurrentLine.clear();
fputc('\n', g_fOut);
time(&g_TimeLastOutput);
g_State = WAITING;
return;
case BAR:
fputs(g_CurrentLine.c_str(), g_fOut);
g_CurrentLine.clear();
fputc('\n', g_fOut);
time(&g_TimeLastOutput);
g_State = WAITING;
return;
case BUSY:
fputc('\n', g_fOut);
g_State = WAITING;
return;
default:
Warning("ForceNewLine state=%d", g_State);
}
}
static void Append(char c)
{
if (c == '\n')
{
if (g_Prefix)
{
fputs(GetResourceStr(), g_fOut);
fputc(' ', g_fOut);
}
fputs(g_CurrentLine.c_str(), g_fOut);
g_CurrentLine.clear();
fputc('\n', g_fOut);
time(&g_TimeLastOutput);
g_State = WAITING;
}
else
{
g_CurrentLine += c;
g_State = PARTLINE;
}
}
static void Append(const string &s)
{
if (s.empty())
return;
for (size_t i = 0; i < s.size(); ++i)
Append(s[i]);
}
static void UpdateProgressBar(bool Done)
{
if (g_CB == 0)
return;
if (g_State != BAR)
ForceNewLine();
size_t OldL = g_ProgressBar.size();
string Msg;
double PctDone;
if (g_CB == 0)
return;
(*g_CB)(Msg, PctDone);
g_ProgressBar = string(GetResourceStr());
if (PctDone >= 0.0)
{
if (Done)
g_ProgressBar += " 100%";
else
{
if (PctDone < 1.0)
Psa(g_ProgressBar, " %.2f%%", PctDone);
else if (PctDone > 99.9)
g_ProgressBar += " 99.9%";
else
Psa(g_ProgressBar, " %.1f%%", PctDone);
}
}
g_ProgressBar += " ";
g_ProgressBar += Msg;
size_t NewL = g_ProgressBar.size();
fputc('\r', g_fOut);
fputs(g_ProgressBar.c_str(), g_fOut);
for (size_t i = NewL; i < OldL; ++i)
fputc(' ', g_fOut);
time(&g_TimeLastOutput);
if (Done)
{
Log("%s\n", g_ProgressBar.c_str());
g_ProgressBar.clear();
fputc('\n', g_fOut);
g_State = WAITING;
}
else
g_State = BAR;
}
static void CB_Step32(string &s, double &PctDone)
{
uint32 Index = *g_ptrStepIndex32;
if (Index >= g_StepCount32+1)
Index = g_StepCount32;
PctDone = GetPct(Index, g_StepCount32+1);
s = g_Msg;
}
static void CB_Step64(string &s, double &PctDone)
{
uint64 Index = *g_ptrStepIndex64;
if (Index >= g_StepCount64+1)
Index = g_StepCount64;
PctDone = GetPct64(Index, g_StepCount64+1);
s = g_Msg;
}
static void CB_File(string &s, double &PctDone)
{
if (g_fMon == 0)
return;
s = g_Msg;
uint64 Bytes = GetStdioFileBytesRead(g_fMon);
if (g_FileSize == UINT64_MAX)
{
PctDone = -1.0;
string t = string(MemBytesToStr(Bytes));
s += string(" (") + t + string(")");
}
else
PctDone = GetPct((double) Bytes, (double) g_FileSize);
}
static void CB_One(string &s, double &PctDone)
{
s = g_Msg;
PctDone = -1;
}
void Progress_OnTick()
{
if (g_TimeLastOutput == 0)
return;
time_t Now = time(0);
time_t Delay = Now - g_TimeLastOutput;
if (Delay == 0)
return;
switch (g_State)
{
case WAITING:
case PARTLINE:
{
if (Delay < 3)
return;
ForceNewLine();
g_BusyStr = string(GetResourceStr()) + " Busy";
fputs(g_BusyStr.c_str(), g_fOut);
g_State = BUSY;
break;
}
case BAR:
{
UpdateProgressBar(false);
break;
}
case BUSY:
{
if (Delay < 2)
return;
unsigned OldLength = SIZE(g_BusyStr);
g_BusyStr = string(GetResourceStr()) + " Busy";
unsigned NewLength = SIZE(g_BusyStr);
fputc('\r', g_fOut);
fputs(g_BusyStr.c_str(), g_fOut);
for (unsigned i = OldLength; i < NewLength; ++i)
fputc(' ', g_fOut);
break;
}
default:
Warning("Progress_OnTimer state=%d", g_State);
break;
}
}
void ProgressClose()
{
if (g_State != WAITING)
{
fputc('\n', g_fOut);
g_State = WAITING;
}
}
void ProgressStart(FN_PROGRESS_CALLBACK PCB)
{
PSTATE CurrState = g_State;
switch (CurrState)
{
case PARTLINE:
Warning("ProgressStart() state=PARTLINE");
ForceNewLine();
break;
case WAITING:
break;
case BAR:
Warning("ProgressStart() state=BAR");
ForceNewLine();
break;
case BUSY:
ForceNewLine();
break;
default:
Warning("ProgressStart() state=%d", CurrState);
break;
}
g_CB = PCB;
time(&g_TimeStart);
g_TimeDone = 0;
g_MemStart = GetMemUseBytes();
g_MemDone = 0;
UpdateProgressBar(false);
}
void Progress(const char *Format, ...)
{
string Str;
va_list ArgList;
va_start(ArgList, Format);
myvstrprintf(Str, Format, ArgList);
va_end(ArgList);
Append(Str);
}
void ProgressOne(const char *Format, ...)
{
va_list ArgList;
va_start(ArgList, Format);
myvstrprintf(g_Msg, Format, ArgList);
va_end(ArgList);
g_CB = CB_One;
UpdateProgressBar(false);
}
void ProgressFile(FILE *f, const string &Msg, const string &PathName)
{
if (f == 0)
return;
if (PathName.empty())
return;
g_fMon = f;
int fd = fileno(f);
string FileName;
BaseName(PathName, FileName);
g_FileSize = GetStdioFileSize64_NoFail(f);
g_Msg = Msg + string(" ") + FileName;
ProgressStart(CB_File);
}
void ProgressFileWrite(FILE *f, const string &Msg, const string &PathName)
{
if (f == 0)
return;
if (PathName.empty())
return;
g_fMon = f;
int fd = fileno(f);
string FileName;
BaseName(PathName, FileName);
g_FileSize = UINT64_MAX;
g_Msg = Msg + string(" ") + FileName;
ProgressStart(CB_File);
}
void ProgressLoop(uint32 Count, uint32 *ptrIndex, const string &Msg)
{
g_StepCount32 = Count;
g_ptrStepIndex32 = ptrIndex;
*ptrIndex = 0;
g_Msg = Msg;
ProgressStart(CB_Step32);
}
void ProgressLoop64(uint64 Count, uint64 *ptrIndex, const string &Msg)
{
g_StepCount64 = Count;
g_ptrStepIndex64 = ptrIndex;
*ptrIndex = 0;
g_Msg = Msg;
ProgressStart(CB_Step64);
}
void ProgressDone()
{
time(&g_TimeDone);
UpdateProgressBar(true);
g_Msg = "Processing";
g_CB = 0;
}
void ProgressPrefix(bool On)
{
g_Prefix = On;
}
void ProgressSetMsg(const string &Msg)
{
g_Msg = Msg;
}
void ProgressLog(const char *Format, ...)
{
string Str;
va_list ArgList;
va_start(ArgList, Format);
myvstrprintf(Str, Format, ArgList);
va_end(ArgList);
Log("%s", Str.c_str());
Progress("%s", Str.c_str());
}
void Progress_Init()
{
}
void Progress_OnExit()
{
ProgressPrefix(true);
Progress("Exiting\n");
fputc('\n', g_fOut);
ProgressPrefix(false);
ProgressClose();
}
| 6,903
|
C++
|
.cpp
| 344
| 17.636628
| 74
| 0.675476
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,003
|
xdropfwdmem.cpp
|
rcedgar_urmap/src/xdropfwdmem.cpp
|
#include "myutils.h"
#include "mx.h"
#include "alnparams.h"
#include "xdpmem.h"
#include "tracebit.h"
#include "pathinfo.h"
#define TRACE 0
#define TRACETB 0
#define CMP 0 // with simple
#define TRACESTATE 0
#if TRACE
static string opt(tracestate);
static unsigned opt(itrace);
static unsigned opt(jtrace);
#endif
static inline char GetTBBitM(byte **TB, unsigned i, unsigned j)
{
byte c = TB[i][j];
#if DEBUG
if (c == TRACEBITS_UNINIT)
return 'u';
#endif
if (c & TRACEBITS_DM)
return 'D';
if (c & TRACEBITS_IM)
return 'I';
return 'M';
}
static inline char GetTBBitD(byte **TB, unsigned i, unsigned j)
{
byte c = TB[i][j+1];
#if DEBUG
if (c == TRACEBITS_UNINIT)
return 'u';
#endif
if (c & TRACEBITS_MD)
return 'M';
return 'D';
}
static inline char GetTBBitI(byte **TB, unsigned i, unsigned j)
{
byte c = TB[i+1][j];
#if DEBUG
if (c == TRACEBITS_UNINIT)
return 'u';
#endif
if (c & TRACEBITS_MI)
return 'M';
return 'I';
}
#if CMP
static Mx<float> *g_MxDPMSimple;
static Mx<float> *g_MxDPDSimple;
static Mx<float> *g_MxDPISimple;
static float **g_DPMSimple;
static float **g_DPDSimple;
static float **g_DPISimple;
static void GetSimple()
{
GetXDropFwdSimpleDPMxs(&g_MxDPMSimple, &g_MxDPDSimple, &g_MxDPISimple);
g_DPMSimple = g_MxDPMSimple->GetData();
g_DPDSimple = g_MxDPDSimple->GetData();
g_DPISimple = g_MxDPISimple->GetData();
}
#define cmpm(i, j, x) { if (!feq(x, g_DPMSimple[i][j])) \
{ \
LogDP(); \
Die("%s:%d %.1f != DPMSimple[%u][%u] = %.1f", \
__FILE__, __LINE__, x, i, j, g_DPMSimple[i][j]); \
} \
}
#define cmpd(i, j, x) { if (!feq(x, g_DPDSimple[i][j])) \
{ \
LogDP(); \
Die("%s:%d %.1f != DPDSimple[%u][%u] = %.1f", \
__FILE__, __LINE__, x, i, j, g_DPDSimple[i][j]); \
} \
}
#define cmpi(i, j, x) { if (!feq(x, g_DPISimple[i][j])) \
{ \
LogDP(); \
Die("%s:%d %.1f != DPISimple[%u][%u] = %.1f", \
__FILE__, __LINE__, x, i, j, g_DPISimple[i][j]); \
} \
}
#else
#define GetSimple() /* empty */
#define cmpm(i, j, x) /* empty */
#define cmpd(i, j, x) /* empty */
#define cmpi(i, j, x) /* empty */
#endif
#if TRACE
static Mx<float> g_MxDPM;
static Mx<float> g_MxDPD;
static Mx<float> g_MxDPI;
static Mx<char> g_MxTBM;
static Mx<char> g_MxTBD;
static Mx<char> g_MxTBI;
static float **g_DPM;
static float **g_DPD;
static float **g_DPI;
static char **g_TBM;
static char **g_TBD;
static char **g_TBI;
static float g_BestScore;
static const AlnParams *g_AP;
static const byte *g_A;
static const byte *g_B;
static void LogTBBit(byte **g_TBBit, char State, unsigned LA, unsigned LB)
{
Log("\n");
Log("TBBit%c:\n", State);
Log(" ");
for (unsigned j = 0; j < LB; ++j)
Log("%u", j%10);
Log("\n");
for (unsigned i = 0; i < LA; ++i)
{
Log("%3u ", i);
for (unsigned j = 0; j < LB; ++j)
{
char c;
switch (State)
{
case 'M':
c = GetTBBitM(g_TBBit, i, j);
break;
case 'D':
c = GetTBBitD(g_TBBit, i, j);
break;
case 'I':
c = GetTBBitI(g_TBBit, i, j);
break;
default:
asserta(false);
}
Log("%c", c);
}
Log("\n");
}
}
static void AllocSave(unsigned LA, unsigned LB)
{
g_MxDPM.Alloc("XFastM", LA+1, LB+1);
g_MxDPD.Alloc("XFastD", LA+1, LB+1);
g_MxDPI.Alloc("XFastI", LA+1, LB+1);
g_MxDPM.Assign(UNINIT);
g_MxDPD.Assign(UNINIT);
g_MxDPI.Assign(UNINIT);
g_MxTBM.Alloc("XFastTBM", LA+1, LB+1);
g_MxTBD.Alloc("XFastTBD", LA+1, LB+1);
g_MxTBI.Alloc("XFastTBI", LA+1, LB+1);
g_MxTBM.Assign('u');
g_MxTBD.Assign('u');
g_MxTBI.Assign('u');
g_DPM = g_MxDPM.GetData();
g_DPD = g_MxDPD.GetData();
g_DPI = g_MxDPI.GetData();
g_TBM = g_MxTBM.GetData();
g_TBD = g_MxTBD.GetData();
g_TBI = g_MxTBI.GetData();
}
static void LogDP()
{
#if CMP
g_MxDPMSimple->LogMe();
g_MxDPDSimple->LogMe();
g_MxDPISimple->LogMe();
#endif
g_MxDPM.LogMe();
g_MxDPD.LogMe();
g_MxDPI.LogMe();
}
static void SAVE_DPM(unsigned i, unsigned j, float x, float PrevM, float PrevD, float PrevI)
{
#if TRACESTATE
if (!opt(tracestate).empty() && opt(tracestate)[0] == 'M' && opt(itrace) == i && opt(jtrace) == j)
Log("TRACESTATE Fast DPM[%u][%u] = %.1f, M %.1f D %.1f I %.1f\n",
i, j, x, PrevM, PrevD, PrevI);
#endif
#if TRACE
Log("Fast: DPM[%u][%u] = %.1f, PM %.1f PD %.1f PI %.1f\n",
i, j, x, PrevM, PrevD, PrevI);
#endif
g_DPM[i][j] = x;
#if CMP
if (i > 0 && j > 0 && !feq(x, g_DPMSimple[i][j]))
{
LogDP();
Die("%.1f != %.1f DPMSimple[%u][%u]", x, g_DPMSimple[i][j], i, j);
}
#endif
}
static void SAVE_DPD(unsigned i, unsigned j, float x, float PrevM, float PrevD)
{
#if TRACESTATE
if (!opt(tracestate).empty() && opt(tracestate)[0] == 'D' && opt(itrace) == i && opt(jtrace) == j)
Log("TRACESTATE Fast DPD[%u][%u] = %.1f, M %.1f D %.1f\n",
i, j, x, PrevM, PrevD);
#endif
#if TRACE
Log("Fast: DPD[%u][%u] = %.1f, PM %.1f PD %.1f\n",
i, j, x, PrevM, PrevD);
#endif
g_DPD[i][j] = x;
#if CMP
if (i > 0 && j > 0)
if (!feq(x, g_DPDSimple[i][j]))
{
LogDP();
Die("%.1f != %.1f DPDSimple[%u][%u]", x, g_DPDSimple[i][j], i, j);
}
#endif
}
static void SAVE_DPI(unsigned i, unsigned j, float x, float PrevM, float PrevI)
{
#if TRACESTATE
if (!opt(tracestate).empty() && opt(tracestate)[0] == 'I' && opt(itrace) == i && opt(jtrace) == j)
Log("TRACESTATE Fast DPI[%u][%u] = %.1f, M %.1f I %.1f\n",
i, j, x, PrevM, PrevI);
#endif
#if TRACE
Log("Fast: DPI[%u][%u] = %.1f, PM %.1f PI %.1f\n",
i, j, x, PrevM, PrevI);
#endif
g_DPI[i][j] = x;
#if CMP
if (i > 0 && j > 0 && !feq(x, g_DPISimple[i][j]))
{
LogDP();
Die("%.1f != %.1f DPISimple[%u][%u]", x, g_DPISimple[i][j], i, j);
}
#endif
}
static void SAVE_TBM(unsigned i, unsigned j, char x)
{
g_TBM[i][j] = x;
}
static void SAVE_TBD(unsigned i, unsigned j, char x)
{
g_TBD[i][j] = x;
}
static void SAVE_TBI(unsigned i, unsigned j, char x)
{
g_TBI[i][j] = x;
}
#else // TRACE
#define SAVE_DPM(i, j, x, PM, PD, PI) /* empty */
#define SAVE_DPD(i, j, x, PM, PD) /* empty */
#define SAVE_DPI(i, j, x, PM, PD) /* empty */
#define SAVE_TBM(i, j, x) /* empty */
#define SAVE_TBD(i, j, x) /* empty */
#define SAVE_TBI(i, j, x) /* empty */
#define AllocSave(LA, LB) /* empty */
#endif // TRACE
void XDropFwdTraceBackBitMem(XDPMem &Mem, unsigned Besti, unsigned Bestj, PathInfo &PI)
{
StartTimer(TraceBackBitMem);
PI.SetEmpty();
byte **TB = Mem.GetTBBit();
#if TRACETB
Log("\n");
Log("XDropFwdTraceBackBitMem Besti=%u, Bestj=%u\n", Besti, Bestj);
#endif
#if TRACE
Log("\n");
Log("TraceBackBit\n");
float TotalScore = g_BestScore;
const float Open = g_AP->OpenA;
const float Ext = g_AP->ExtA;
float **DPM = g_DPM;
float **DPD = g_DPD;
float **DPI = g_DPI;
char **TBM = g_TBM;
char **TBD = g_TBD;
char **TBI = g_TBI;
#endif
unsigned i = Besti;
unsigned j = Bestj;
char State = 'M';
for (;;)
{
#if TRACETB
Log("i=%3d j=%3d state=%c\n", (int) i, (int) j, State);
#endif
PI.AppendChar(State);
if (i == 0 && j == 0)
break;
char NextState = '?';
switch (State)
{
case 'M':
NextState = GetTBBitM(TB, i, j);
asserta(i > 0 && j > 0);
--i;
--j;
break;
case 'D':
NextState = GetTBBitD(TB, i, j);
asserta(i > 0);
--i;
break;
case 'I':
NextState = GetTBBitI(TB, i, j);
asserta(j > 0);
--j;
break;
default:
Die("TraceBackBit, invalid state %c", State);
}
State = NextState;
}
PI.Reverse();
#if TRACETB
{
Log("Path=%s\n", PI.GetPath());
unsigned M, D, I;
PI.GetCounts(M, D, I);
Log("M=%u, D=%u, I=%u\n", M, D, I);
}
#endif
EndTimer(TraceBackBitMem);
}
float XDropFwdFastMem(XDPMem &Mem, const byte *A, unsigned LA, const byte *B, unsigned LB,
const AlnParams &AP, float X, unsigned &Leni, unsigned &Lenj, PathInfo &PI)
{
#if TRACETB
Log("\n");
Log("XDropFwdFastMem\n");
Log("A %u %*.*s\n", LA, LA, LA, A);
Log("B %u %*.*s\n", LB, LB, LB, B);
#endif
asserta(LA > 0);
asserta(LB > 0);
PI.Alloc(4*g_MaxL);
const float * const *SubstMx = AP.SubstMx;
if (LA == 1 || LB == 1)
{
Leni = 1;
Lenj = 1;
float Score = SubstMx[A[0]][B[0]];
PI.SetEmpty();
PI.AppendMs(1);
return Score;
}
Mem.Alloc(LA, LB);
AllocSave(LA, LB);
GetSimple();
StartTimer(XDropFwdFastMem);
#if TRACE
Log("XDropFwdFast LA %u, LB %u\n", LA, LB);
Log("A=%*.*s\n", LA, LA, A);
Log("B=%*.*s\n", LB, LB, B);
#endif
const float Open = AP.GetLocalOpen();
const float Ext = AP.GetLocalExt();
const float AbsOpen = -Open;
const float AbsExt = -Ext;
if (AbsOpen <= 0.0f || AbsExt <= 0.0f)
Warning("XDropFwdFast(): non-positive penalty open %.1f, ext %.1f", AbsOpen, AbsExt);
byte **TB = Mem.GetTBBit();
#if TRACE
{
for (unsigned i = 0; i <= LA; ++i)
memset(TB[i], TRACEBITS_UNINIT, LB+1);
}
#endif
float *Mrow = Mem.GetDPRow1();
float *Drow = Mem.GetDPRow2();
Mrow[-1] = MINUS_INFINITY;
//SAVE_DPM(0, 0, MINUS_INFINITY, MINUS_INFINITY, MINUS_INFINITY, MINUS_INFINITY);
//SAVE_TBM(0, 0, '?');
Drow[0] = MINUS_INFINITY;
Drow[1] = MINUS_INFINITY;
//SAVE_DPD(Starti-1, Startj, MINUS_INFINITY, MINUS_INFINITY, MINUS_INFINITY, MINUS_INFINITY);
//SAVE_TBD(Starti-1, Startj, '?');
// Main loop
float BestScore = SubstMx[A[0]][B[0]];
#if TRACETB
Log("BestScore init %.1f\n", BestScore);
#endif
unsigned Besti = 0;
unsigned Bestj = 0;
unsigned prev_jlo = 0;
unsigned prev_jhi = 0;
unsigned jlo = 1;
unsigned jhi = 1;
// Inner loop does this:
// Mrow[j] = DPM[i][j+1] -> DPM[i+1][j+1]
// Drow[j] = DPD[i][j] -> DPD[i+1][j]
float M0 = BestScore;
for (unsigned i = 1; i < LA; ++i)
{
if (jlo == prev_jlo)
{
assert(jlo>0);
Mrow[jlo-1] = MINUS_INFINITY;
SAVE_DPM(i, jlo, MINUS_INFINITY, MINUS_INFINITY, MINUS_INFINITY, MINUS_INFINITY);
cmpm(i, jlo, MINUS_INFINITY);
Drow[jlo] = MINUS_INFINITY;
SAVE_DPD(i, jlo, MINUS_INFINITY, MINUS_INFINITY, MINUS_INFINITY);
cmpd(i, jlo, MINUS_INFINITY);
}
unsigned endj = min(prev_jhi+1,LB);
for (unsigned j = endj+1; j <= min(jhi+1, LB); ++j)
{
Mrow[j-1] = MINUS_INFINITY;
SAVE_DPM(i, j, MINUS_INFINITY, MINUS_INFINITY, MINUS_INFINITY, MINUS_INFINITY);
cmpm(i, j, MINUS_INFINITY);
Drow[j] = MINUS_INFINITY;
SAVE_DPD(i, j, MINUS_INFINITY, MINUS_INFINITY, MINUS_INFINITY);
cmpd(i, j, MINUS_INFINITY);
}
unsigned next_jlo = UINT_MAX;
unsigned next_jhi = UINT_MAX;
byte a = A[i];
const float *MxRow = SubstMx[a];
float I0 = MINUS_INFINITY;
cmpi(i, jlo, MINUS_INFINITY);
byte *TBrow = TB[i];
asserta(jlo>0);
asserta(jlo<=jhi);
float SavedM0 = UNINIT;
#if TRACE
Log(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
Log("FAST i=%u prev_jlo=%u prev_jhi=%u, jlo=%u jhi=%u\n",
i, prev_jlo, prev_jhi, jlo, jhi);
Log(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n");
#endif
for (unsigned j = jlo; j <= jhi; ++j)
{
byte b = B[j];
byte TraceBits = 0;
SavedM0 = M0; // SavedM0 = M0 = DPM[i][j]
#if TRACE
Log("SavedM0 = DPM[%u][%u] = %.1f\n", i, j, SavedM0);
#endif
#if DEBUG && CMP
cmpm(i, j, SavedM0);
#endif
// MATCH
{
// M0 = DPM[i][j]
// I0 = DPI[i][j]
// Drow[j] = DPD[i][j]
#if DEBUG && CMP
cmpm(i, j, M0);
#endif
cmpd(i, j, Drow[j]);
cmpi(i, j, I0);
float xM = M0;
SAVE_TBM(i+1, j+1, 'M');
if (Drow[j] > xM)
{
xM = Drow[j];
TraceBits = TRACEBITS_DM;
SAVE_TBM(i+1, j+1, 'D');
}
if (I0 > xM)
{
xM = I0;
TraceBits = TRACEBITS_IM;
SAVE_TBM(i+1, j+1, 'I');
}
M0 = Mrow[j]; // M0 = DPM[i][j+1]
cmpm(i, j+1, M0);
float s = xM + MxRow[b];
Mrow[j] = s; // Mrow[j] = DPM[i+1][j+1]
SAVE_DPM(i+1, j+1, Mrow[j], M0, Drow[j], I0);
float h = s - BestScore + X;
// Match-Match
if (h > 0)
{
next_jlo = min(next_jlo, j+1);
next_jhi = j+1;
}
// Match-Delete
if (h > AbsOpen)
next_jlo = min(next_jlo, j);
// Match-Insert potentially extends current row
if (h > AbsExt && j == jhi && jhi + 1 < LB)
{
++jhi;
unsigned new_endj = min(jhi+1, LB);
new_endj = max(new_endj, endj);
#if TRACE
Log("Fast: MI extends row to ++jhi=%u, prevjhi=%u, endj %u new_endj %u\n",
jhi, prev_jhi, endj, new_endj);
#endif
for (unsigned j2 = endj+1; j2 <= new_endj; ++j2)
{
// Nasty special case for j=j2-1, Mrow[j] has already
// been updated for current i.
if (j2-1 > j)
{
Mrow[j2-1] = MINUS_INFINITY;
SAVE_DPM(i, j2, MINUS_INFINITY, MINUS_INFINITY, MINUS_INFINITY, MINUS_INFINITY);
}
Drow[j2] = MINUS_INFINITY;
SAVE_DPD(i, j2, MINUS_INFINITY, MINUS_INFINITY, MINUS_INFINITY);
cmpm(i, j2, MINUS_INFINITY);
cmpd(i, j2, MINUS_INFINITY);
}
endj = new_endj;
}
if (s >= BestScore)
{
BestScore = s;
Besti = i;
Bestj = j;
#if TRACETB
Log("BestScore update %.1f (%u,%u)\n", BestScore, i, j);
#endif
}
}
// DELETE
if (j != jlo)
{
// SavedM0 = DPM[i][j]
// Drow[j] = DPD[i][j]
cmpm(i, j, SavedM0);
cmpd(i, j, Drow[j]);
float md = SavedM0 + Open;
Drow[j] += Ext;
SAVE_TBD(i+1, j, 'D');
if (md >= Drow[j])
{
Drow[j] = md;
TraceBits |= TRACEBITS_MD;
SAVE_TBD(i+1, j, 'M');
}
// Drow[j] = DPD[i+1][j]
SAVE_DPD(i+1, j, Drow[j], SavedM0, Drow[j]);
float h = Drow[j] - BestScore + X;
// Delete-Match
if (h > 0)
{
next_jlo = min(next_jlo, j-1);
next_jhi = max(next_jhi, j-1);
}
}
// INSERT
//if (i > Starti)
{
// SavedM0 = DPM[i][j]
// I0 = DPI[i][j]
cmpm(i, j, SavedM0);
cmpi(i, j, I0);
#if TRACESTATE
float SavedI0 = I0;
#else
#define SavedI0 0
#endif
float mi = SavedM0 + Open;
I0 += Ext;
SAVE_TBI(i, j+1, 'I');
if (mi >= I0)
{
I0 = mi;
TraceBits |= TRACEBITS_MI;
SAVE_TBI(i, j+1, 'M');
}
// I0 = DPI[i][j+1]
SAVE_DPI(i, j+1, I0, SavedM0, SavedI0);
float h = I0 - BestScore + X;
// Insert-Match
if (h > 0)
{
next_jlo = min(next_jlo, j+1);
next_jhi = j+1;
}
// Insert-Insert potentially extends current row
if (h > AbsExt && j == jhi && jhi + 1 < LB)
{
++jhi;
unsigned new_endj = min(jhi+1, LB);
new_endj = max(new_endj, endj);
#if TRACE
Log("Fast: II extends row to ++jhi=%u, prevjhi=%u, endj %u new_endj %u\n",
jhi, prev_jhi, endj, new_endj);
#endif
for (unsigned j2 = endj+1; j2 <= new_endj; ++j2)
{
cmpm(i, j2, MINUS_INFINITY);
cmpd(i, j2, MINUS_INFINITY);
Mrow[j2-1] = MINUS_INFINITY;
Drow[j2] = MINUS_INFINITY;
}
endj = new_endj;
}
}
TBrow[j] = TraceBits;
}
// Special case for end of Drow[]
if (jhi < LB)
{
const unsigned jhi1 = jhi+1;
// SavedM0 = DPM[i][jhi+1]
// Drow[jhi] = DPD[i][jhi+1]
cmpm(i, jhi1, M0);
cmpd(i, jhi1, Drow[jhi1]);
#if TRACESTATE
float SavedD = Drow[jhi1];
#else
#define SavedD 0
#endif
TBrow[jhi1] = 0;
float md = M0 + Open;
Drow[jhi1] += Ext;
SAVE_TBD(i+1, jhi1, 'D');
if (md >= Drow[jhi1])
{
Drow[jhi1] = md;
TBrow[jhi1] = TRACEBITS_MD;
SAVE_TBD(i+1, jhi1, 'M');
}
// Drow[jhi] = DPD[i+1][jhi1]
SAVE_DPD(i+1, jhi1, Drow[jhi1], M0, SavedD);
}
if (next_jlo == UINT_MAX)
break;
prev_jlo = jlo;
prev_jhi = jhi;
jlo = next_jlo;
jhi = next_jhi;
if (jlo >= LB)
jlo = LB-1;
if (jhi >= LB)
jhi = LB-1;
asserta(jlo <= jhi);
asserta(jlo >= prev_jlo);
if (jlo == prev_jlo)
{
M0 = MINUS_INFINITY;
Drow[jlo] = MINUS_INFINITY;
}
else
{
assert(jlo > prev_jlo);
M0 = Mrow[jlo-1];
}
}
EndTimer(XDropFwdFastMem);
#if TRACE
{
g_MxDPM.LogMe();
g_MxDPD.LogMe();
g_MxDPI.LogMe();
g_MxTBM.LogMe();
g_MxTBD.LogMe();
g_MxTBI.LogMe();
LogTBBit(TB, 'M', LA, LB);
LogTBBit(TB, 'D', LA, LB);
LogTBBit(TB, 'I', LA, LB);
}
#endif
#if TRACE
g_BestScore = BestScore;
g_AP = &AP;
g_A = A;
g_B = B;
#endif
if (BestScore <= 0.0f)
{
Leni = 0;
Lenj = 0;
PI.SetEmpty();
return 0.0;
}
#if TRACETB
Log("BestScore %.1f, Besti %u, Bestj %u\n", BestScore, Besti, Bestj);
#endif
XDropFwdTraceBackBitMem(Mem, Besti, Bestj, PI);
Leni = Besti + 1;
Lenj = Bestj + 1;
#if TRACETB
Log("Leni %u, LA %u, Lenj %u, LB %u\n", Leni, LA, Lenj, LB);
#endif
asserta(Leni <= LA && Lenj <= LB);
#if DEBUG
{
unsigned M, D, I;
PI.GetCounts(M, D, I);
asserta(M + D == Leni);
asserta(M + I == Lenj);
}
#endif
return BestScore;
}
| 16,403
|
C++
|
.cpp
| 689
| 20.783745
| 99
| 0.584871
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,004
|
alignhsp5.cpp
|
rcedgar_urmap/src/alignhsp5.cpp
|
#include "myutils.h"
#include "ufindex.h"
#include "seqinfo.h"
#include "alpha.h"
#include "state1.h"
#include "alignresult.h"
#include "pathinfo.h"
#include "alnparams.h"
#include <inttypes.h>
#define TRACE 0
#define BRN 1//TODO:PARAM
void LogAlnPretty(const byte *A, const byte *B, const char *Path,
bool StripTermGaps);
unsigned State1::AlignHSP5(unsigned HSPIndex)
{
UFIHSP *HSP = m_HSPs.Data[HSPIndex];
if (HSP->m_Aligned)
return UINT_MAX;
HSP->m_Aligned = true;
dpscore TotalPen = dpscore(HSP->m_Length) - HSP->m_Score;
dpscore TotalScore = HSP->m_Score;
if (TotalPen > m_MaxPenalty)
return UINT_MAX;
const unsigned StartPosQ = HSP->m_StartPosQ;
const unsigned StartPosDB = HSP->m_StartPosDB;
const unsigned HSPLength = HSP->m_Length;
const bool Plus = HSP->m_Plus;
const unsigned QL = m_Query->m_L;
const unsigned TL = m_UFI->m_SeqDataSize;
unsigned CombinedTLo = StartPosDB;
const byte *Q = (HSP->m_Plus ? m_Query->m_Seq : m_RevCompQuerySeq.Data);
const byte *T = m_UFI->m_SeqData;
m_LeftPI->SetEmpty();
m_RightPI->SetEmpty();
/***
0 StartPosQ QL-1
LeftQLo LeftQHi RightQLo RightQHi
| | | |
Q: LEFTQ qqqqq HSP qqqq RIGHTQ
T: LEFTT ttttt HSP tttt RIGHTT
| |
LeftTHi RightTLo
StartPosDB
***/
/////////////////////////////// Left /////////////////////////
// TODO:optimize by doing right first?
if (StartPosQ > 0)
{
if (StartPosDB < StartPosQ)
return UINT_MAX;
unsigned LeftQLo = 0;
unsigned LeftQHi = StartPosQ - 1;
unsigned LeftQL = LeftQHi - LeftQLo + 1;
unsigned LeftTHi = StartPosDB - 1;
unsigned LeftTL = LeftQL + BRN*GLOBAL_BAND_RADIUS;
if (LeftTL >= LeftTHi)
return UINT_MAX;
unsigned LeftTLo = LeftTHi - LeftTL + 1;
const byte *LeftQ = Q;
const byte *LeftT = T + LeftTLo;
dpscore LeftScore = (dpscore) Viterbi(LeftQ, LeftQL, LeftT, LeftTL, true, false, *m_LeftPI);
unsigned LeftICount = m_LeftPI->TrimLeftIs();
CombinedTLo = LeftTLo + LeftICount;
dpscore AllGapScore = GAP_OPEN_SCORE + (LeftQL-1)*GAP_EXT_SCORE;
if (AllGapScore > LeftScore)
LeftScore = AllGapScore;
dpscore BestPossibleScore = dpscore(LeftQL);
dpscore LeftPen = BestPossibleScore - LeftScore;
TotalScore += LeftScore;
TotalPen += LeftPen;
if (TotalPen > m_MaxPenalty)
return UINT_MAX;
} // end Left
/////////////////////////////// Right /////////////////////////
const unsigned RightQLo = StartPosQ + HSPLength;
if (RightQLo < QL)
{
unsigned RightQHi = QL - 1;
asserta(RightQHi >= RightQLo);
unsigned RightQL = RightQHi - RightQLo + 1;
unsigned RightTLo = StartPosDB + HSPLength;
unsigned RightTHi = RightTLo + RightQL + BRN*GLOBAL_BAND_RADIUS;
if (RightTHi >= TL)
RightTHi = TL - 1;
unsigned RightTL = RightTHi - RightTLo + 1;
const byte *RightQ = Q + RightQLo;
const byte *RightT = T + RightTLo;
dpscore RightScore = (dpscore) Viterbi(RightQ, RightQL, RightT, RightTL, false, true, *m_RightPI);
m_RightPI->TrimRightIs();
dpscore AllGapScore = GAP_OPEN_SCORE + (RightQL-1)*GAP_EXT_SCORE;
if (AllGapScore > RightScore)
RightScore = AllGapScore;
dpscore BestPossibleScore = dpscore(RightQL);
dpscore RightPen = BestPossibleScore - RightScore;
TotalScore += RightScore;
TotalPen += RightPen;
if (TotalPen > m_MaxPenalty)
return UINT_MAX;
} // end Right
m_PI->SetEmpty();
m_PI->AppendPath(*m_LeftPI);
m_PI->AppendMs(HSPLength);
m_PI->AppendPath(*m_RightPI);
string Path = string(m_PI->GetPath());
unsigned HitIndex = AddHitX(CombinedTLo, Plus, TotalScore, Path);
return HitIndex;
}
| 3,658
|
C++
|
.cpp
| 107
| 31.121495
| 100
| 0.672136
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,005
|
localmulti.cpp
|
rcedgar_urmap/src/localmulti.cpp
|
#include "myutils.h"
#include "pathinfo.h"
#include "alignresult.h"
#include "localaligner2.h"
#include "alpha.h"
#define TRACE 0
void LocalAligner2::AlignMulti(GoBuff<AlignResult *, 32, true, false> &ARs)
{
#if TRACE
Log("\n");
Log("LocalAligner2::AlignMulti Q>%s T>%s\n",
m_Query->m_Label, m_Target->m_Label);
#endif
StartTimer(AlignMulti);
float MinScore = (float) g_ES->GetMinUngappedRawScore(m_Query->m_L);
ARs.Size = 0;
if (m_Target->m_L < 2*m_WordLength)
{
EndTimer(AlignMulti);
return;
}
const byte *Q = m_Query->m_Seq;
const byte *T = m_Target->m_Seq;
const unsigned QL = m_Query->m_L;
const unsigned TL = m_Target->m_L;
m_TargetWords.Alloc(TL);
const unsigned TargetWordCount = TL - m_WordLength + 1;
uint32 Word = 0;
const byte *Front = T;
const byte *Back = T;
for (unsigned i = 0; i < m_WordLength-1; ++i)
{
unsigned Letter = m_CharToLetter[*Front++];
if (Letter >= m_AlphaSize)
Letter = 0;
Word = (Word*m_AlphaSize) + Letter;
}
uint32 *TargetWords = m_TargetWords.Data;
for (unsigned TargetPos = m_WordLength-1; TargetPos < TL; ++TargetPos)
{
unsigned Letter = m_CharToLetter[*Front++];
// Can't skip wildcards because target pos assumed in vector subscripts
if (Letter >= m_AlphaSize)
Letter = 0;
Word = (Word*m_AlphaSize) + Letter;
assert(Word < m_DictSize);
*TargetWords++ = Word;
Letter = m_CharToLetter[*Back++];
if (Letter >= m_AlphaSize)
Letter = 0;
Word -= Letter*m_AlphaHi;
}
asserta((unsigned) (TargetWords - m_TargetWords.Data) == TargetWordCount);
m_TargetWords.Size = TargetWordCount;
TargetWords = m_TargetWords.Data;
const uint32 *QueryPosVec = m_QueryPosVec.Data;
for (unsigned TargetPos = 0; TargetPos < TargetWordCount; )
{
uint32 TargetWord = TargetWords[TargetPos];
assert(TargetWord < m_DictSize);
unsigned N = m_QueryWordCounts[TargetWord];
#if TRACE
{
char tmp[64];
Log("TPos %u Word %*.*s %s QN %u\n",
TargetPos,
m_WordLength,
m_WordLength,
T + TargetPos,
WordToStr(TargetWord, tmp),
N);
}
#endif
for (unsigned i = 0; i < N; ++i)
{
unsigned Base = m_WordToQueryPosVecBase[TargetWord];
assert(Base+i < m_QueryPosVec.Size);
unsigned QueryPos = QueryPosVec[Base+i];
assert(QueryPos < QL);
assert(m_QueryWords.Data[QueryPos] == TargetWord);
AlignResult *AR = AlignPos(QueryPos, TargetPos);
if (AR != 0)
{
if (KeepAR(*AR, ARs))
{
ARs.Alloc(ARs.Size + 1);
ARs.Data[ARs.Size++] = AR;
}
else
{
ObjMgr::Down(AR);
AR = 0;
continue;
}
const HSPData &HSP = AR->GetHSP();
unsigned NewTargetPos = HSP.GetHij() + 1;
if (NewTargetPos > TargetPos)
TargetPos = NewTargetPos;
else
++TargetPos;
goto Skip;
}
}
++TargetPos;
Skip:;
}
EndTimer(AlignMulti);
}
| 2,830
|
C++
|
.cpp
| 108
| 22.833333
| 75
| 0.667651
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,006
|
bitvec.cpp
|
rcedgar_urmap/src/bitvec.cpp
|
#include "myutils.h"
#include "bitvec.h"
BitVec::BitVec()
{
m_Vec = 0;
m_BitCount = 0;
}
BitVec::~BitVec()
{
Free();
}
void BitVec::Alloc(uint64 BitCount)
{
asserta(m_Vec == 0);
uint64 Bytes = BitCount/8 + 1;
m_Vec = myalloc64(byte, Bytes);
memset_zero(m_Vec, Bytes);
m_BitCount = BitCount;
}
void BitVec::Zero()
{
uint64 Bytes = m_BitCount/8 + 1;
memset_zero(m_Vec, Bytes);
}
void BitVec::Free()
{
if (m_Vec != 0)
{
myfree(m_Vec);
m_Vec = 0;
m_BitCount = 0;
}
}
bool BitVec::GetBit(uint64 n) const
{
byte Byte = m_Vec[n/8];
return (Byte & (1 << n%8)) != 0;
}
void BitVec::SetBit(uint64 n)
{
m_Vec[n/8] |= (1 << (n%8));
}
void BitVec::ClearBit(uint64 n)
{
m_Vec[n/8] &= ~(1 << (n%8));
}
| 736
|
C++
|
.cpp
| 46
| 13.934783
| 35
| 0.608504
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,007
|
logaln.cpp
|
rcedgar_urmap/src/logaln.cpp
|
#include "myutils.h"
#include "seqinfo.h"
#include "pathinfo.h"
#include "alignresult.h"
#include "seqdb.h"
extern float **g_SubstMx;
void TrimTermGaps(const char *Path,
unsigned &QLo, unsigned &QHi,
unsigned &TLo, unsigned &THi,
unsigned &ColLo, unsigned &ColHi)
{
ColLo = UINT_MAX;
ColHi = UINT_MAX;
unsigned i = 0;
unsigned j = 0;
QLo = 0;
QHi = 0;
TLo = 0;
THi = 0;
for (unsigned k = 0; ; ++k)
{
char c = Path[k];
if (c == 0)
return;
if (c == 'M')
{
if (ColLo == UINT_MAX)
{
ColLo = k;
QLo = i;
TLo = j;
}
ColHi = k;
QHi = i;
THi = j;
}
if (c == 'M' || c == 'D')
++i;
if (c == 'M' || c == 'I')
++j;
}
}
void WriteAln(FILE *f, const byte *A, const byte *B, const char *Path, unsigned ColCount)
{
unsigned p = 0;
for (unsigned i = 0; i < ColCount; ++i)
{
char c = Path[i];
if (c == 0)
break;
if (c == 'S')
c = 'M';
if (c == 'M' || c == 'D')
fprintf(f, "%c", A[p++]);
else
fprintf(f, "-");
}
fprintf(f, "\n");
unsigned pa = 0;
unsigned pb = 0;
for (unsigned i = 0; i < ColCount; ++i)
{
char c = Path[i];
if (c == 0)
break;
if (c == 'S')
c = 'M';
if (c == 'M')
{
byte a = A[pa];
byte b = B[pb];
if (toupper(a) == toupper(b))
fprintf(f, "|");
else if (g_SubstMx[a][b] > 0.0f)
fprintf(f, "+");
else
fprintf(f, " ");
}
else
fprintf(f, " ");
if (c == 'M' || c == 'D')
++pa;
if (c == 'M' || c == 'I')
++pb;
}
fprintf(f, "\n");
p = 0;
for (unsigned i = 0; i < ColCount; ++i)
{
char c = Path[i];
if (c == 0)
break;
if (c == 'S')
c = 'M';
if (c == 'M' || c == 'I')
fprintf(f, "%c", B[p++]);
else
fprintf(f, "-");
}
fprintf(f, "\n");
}
void LogAln(const byte *A, const byte *B, const char *Path, unsigned ColCount)
{
WriteAln(g_fLog, A, B, Path, ColCount);
}
void LogAln(const byte *A, const byte *B, const char *Path)
{
LogAln(A, B, Path, UINT_MAX);
}
static void WriteARow(FILE *f, const byte *A, const char *Path,
unsigned &i, unsigned ColLo, unsigned ColHi)
{
fprintf(f, "%5u ", i+1);
for (unsigned k = ColLo; k <= ColHi; ++k)
{
char c = Path[k];
if (c == 'M' || c == 'D')
fprintf(f, "%c", A[i++]);
else
fprintf(f, "-");
}
fprintf(f, " %u\n", i);
}
static void LogARow(const byte *A, const char *Path,
unsigned &i, unsigned ColLo, unsigned ColHi)
{
WriteARow(g_fLog, A, Path, i, ColLo, ColHi);
}
static void WriteBRow(FILE *f, const byte *B, const char *Path,
unsigned &j, unsigned ColLo, unsigned ColHi)
{
fprintf(f, "%5u ", j+1);
for (unsigned k = ColLo; k <= ColHi; ++k)
{
char c = Path[k];
if (c == 'M' || c == 'I')
{
char b = B[j++];
if (b == '-')
b = '@';
fprintf(f, "%c", b);
}
else
fprintf(f, "-");
}
fprintf(f, " %u\n", j);
}
static void LogBRow(const byte *B, const char *Path,
unsigned &j, unsigned ColLo, unsigned ColHi)
{
WriteBRow(g_fLog, B, Path, j, ColLo, ColHi);
}
static void WriteAnnotRow(FILE *f, const byte *A, const byte *B, const char *Path,
unsigned i, unsigned j, unsigned ColLo, unsigned ColHi)
{
fprintf(f, "%5.5s ", "");
for (unsigned k = ColLo; k <= ColHi; ++k)
{
char c = Path[k];
if (c == 'M')
{
byte a = A[i++];
byte b = B[j++];
if (toupper(a) == toupper(b))
fprintf(f, "|");
else if (g_SubstMx[a][b] > 0.0f)
fprintf(f, "+");
else
fprintf(f, " ");
}
else
{
if (c == 'D')
++i;
else if (c == 'I')
++j;
else
{
Log("\n");
Log("Path=%s\n", Path);
Log("i %u, j %u, ColLo %u, ColHi %u\n", i, j, ColLo, ColHi);
Log("c=%x=%c\n", c, c);
Die("WriteAnnotRow");
}
fprintf(f, " ");
}
}
fprintf(f, "\n");
}
static void LogAnnotRow(const byte *A, const byte *B, const char *Path,
unsigned i, unsigned j, unsigned ColLo, unsigned ColHi)
{
WriteAnnotRow(g_fLog, A, B, Path, i, j, ColLo, ColHi);
}
void WriteAlnPretty(FILE *f, const byte *A, const byte *B, const char *Path,
bool StripTermGaps)
{
const unsigned BLOCK_SIZE = 80;
unsigned ALo, BLo, ColLo, ColHi;
if (StripTermGaps)
{
unsigned AHi_NotUsed, BHi_NotUsed;
TrimTermGaps(Path, ALo, AHi_NotUsed, BLo, BHi_NotUsed, ColLo, ColHi);
}
else
{
ALo = 0;
BLo = 0;
ColLo = 0;
ColHi = (unsigned) strlen(Path) - 1;
}
asserta(ColHi >= ColLo);
unsigned i = ALo;
unsigned j = BLo;
unsigned ColFrom = ColLo;
for (;;)
{
if (ColFrom > ColHi)
break;
unsigned ColTo = ColFrom + BLOCK_SIZE - 1;
if (ColTo > ColHi)
ColTo = ColHi;
unsigned i0 = i;
unsigned j0 = j;
WriteARow(f, A, Path, i, ColFrom, ColTo);
WriteAnnotRow(f, A, B, Path, i0, j0, ColFrom, ColTo);
WriteBRow(f, B, Path, j, ColFrom, ColTo);
fprintf(f, "\n");
ColFrom += BLOCK_SIZE;
}
}
void LogAlnPretty(const byte *A, const byte *B, const char *Path,
bool StripTermGaps)
{
WriteAlnPretty(g_fLog, A, B, Path, StripTermGaps);
}
void WriteAlnAR(FILE *f, const AlignResult *AR)
{
fprintf(f, "\n");
if (AR == 0)
{
fprintf(f, "WriteAlnAR(AR=NULL)\n");
return;
}
fprintf(f, "Q (%u) >%s\n", AR->m_Query->m_L, AR->m_Query->m_Label);
fprintf(f, "T (%u) >%s\n", AR->m_Target->m_L, AR->m_Target->m_Label);
const char *Path = AR->GetPath();
if (AR->m_Local)
{
const byte *Q = AR->m_Query->m_Seq + AR->m_HSP.Loi;
const byte *T = AR->m_Target->m_Seq + AR->m_HSP.Loj;
WriteAlnPretty(f, Q, T, Path, false);
}
else
{
const byte *Q = AR->m_Query->m_Seq;
const byte *T = AR->m_Target->m_Seq;
WriteAlnPretty(f, Q, T, Path, true);
}
}
void LogAlnAR(const AlignResult *AR)
{
WriteAlnAR(g_fLog, AR);
}
void WriteAlnAR_WithTermGaps(FILE *f, const AlignResult *AR)
{
fprintf(f, "\n");
if (AR == 0)
{
fprintf(f, "WriteAlnAR(AR=NULL)\n");
return;
}
fprintf(f, "Q>%s\n", AR->m_Query->m_Label);
fprintf(f, "T>%s\n", AR->m_Target->m_Label);
WriteAlnPretty(f, AR->m_Query->m_Seq, AR->m_Target->m_Seq, AR->GetPath(), false);
}
void LogAlnAR_WithTermGaps(const AlignResult *AR)
{
WriteAlnAR_WithTermGaps(g_fLog, AR);
}
void SeqDB::WriteMSAPretty(FILE *f) const
{
if (f == 0)
return;
const unsigned ColCount = GetColCount();
const unsigned SeqCount = GetSeqCount();
unsigned BLOCK_SIZE = 120;
if (BLOCK_SIZE > ColCount)
BLOCK_SIZE = ColCount;
const unsigned BlockCount = (ColCount + BLOCK_SIZE - 1)/BLOCK_SIZE;
for (unsigned BlockIndex = 0; BlockIndex < BlockCount; ++BlockIndex)
{
unsigned ColLo = BlockIndex*BLOCK_SIZE;
unsigned ColHi = ColLo + BLOCK_SIZE - 1;
if (ColHi >= ColCount)
ColHi = ColCount - 1;
unsigned n = ColHi - ColLo + 1;
fprintf(f, "\n");
for (unsigned SeqIndex = 0; SeqIndex < SeqCount; ++SeqIndex)
{
const byte *Seq = GetSeq(SeqIndex);
const char *Label = GetLabel(SeqIndex);
fprintf(f, "%*.*s ", n, n, Seq + ColLo);
for (unsigned i = n; i < BLOCK_SIZE; ++i)
fputc(' ', f);
fprintf(f, " >%s\n", Label);
}
}
}
| 6,912
|
C++
|
.cpp
| 309
| 19.404531
| 89
| 0.582142
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,008
|
samrec.cpp
|
rcedgar_urmap/src/samrec.cpp
|
#include "myutils.h"
#include "samrec.h"
#include "seqinfo.h"
#include <limits>
/***
Tabbed fields
1 QNAME String [!-?A-~]f1,255g Read label. Assumed sorted.
2 FLAG Int [0,216-1] Bitwise FLAG.
3 RNAME String \*|[!-()+-<>-~][!-~]* Target label.
4 POS Int [0,229-1] 1-based position in target.
5 MAPQ Int [0,28-1] MAPping Quality. Q = -10 log10 Pe (error=wrong locus). Totally useless.
6 CIGAR String \*|([0-9]+[MIDNSHPX=])+ CIGAR string. Bowtie does not use = or X, only uses M.
7 RNEXT String \*|=|[!-()+-<>-~][!-~]* Ref. name of the mate/next segment.
8 PNEXT Int [0,229-1] Position of the mate/next segment.
9 TLEN Int [-229+1,229-1] Template LENgth. Bowtie sets to 0 for unpaired reads.
10 SEQ String \*|[A-Za-z=.]+ Read segment SEQuence.
11 QUAL String [!-~]+ ASCII of Phred-scaled base QUALity+33.
12,13... Tags (tab-separated).
Bitwise flags:
0x1 1 template having multiple segments in sequencing
0x2 2 each segment properly aligned according to the aligner
0x4 4 segment unmapped
0x8 8 next segment in the template unmapped
0x10 16 SEQ being reverse complemented
0x20 32 SEQ of the next segment in the template being reversed
0x40 64 the first segment in the template
0x80 128 the last segment in the template
0x100 256 secondary alignment (BWA uses 0x800 instead)
0x200 512 not passing quality control
0x400 1024 PCR or optical duplicate
0x800 2048 secondary alignment (BWA only, not in SAM spec).
CIGAR
MIDNSHPX=
M 0 alignment match (can be a sequence match or mismatch)
I 1 insertion to the reference
D 2 deletion from the reference
N 3 skipped region from the reference
S 4 soft clipping (clipped sequences present in SEQ)
H 5 hard clipping (clipped sequences NOT present in SEQ)
P 6 padding (silent deletion from padded reference)
= 7 sequence match
X 8 sequence mismatch
Tags:
AS:i:-44 XS:i:-44 XN:i:0 XM:i:6 XO:i:1 XG:i:1 NM:i:7 MD:Z:25T5T34G51T0T0C0 YT:Z:UU
AS Alignment score. Can be negative. Can be greater than 0 in --local mode (but not in
--end-to-end mode).
XS Alignment score for second-best alignment. Can be negative. Can be greater than 0 in
--local mode (but not in --end-to-end mode).
YS Alignment score for opposite mate in the paired-end alignment.
XN The number of ambiguous bases in the reference covering this alignment.
XM The number of mismatches in the alignment.
NM Edit distance to the reference, including ambiguous bases but excluding clipping.
XO The number of gap opens, for both read and reference gaps, in the alignment.
MD String for mismatching positions. Regex : [0-9]+(([A-Z]|\^[A-Z]+)[0-9]+)*.
XG The number of gap extensions, for both read and reference gaps, in the alignment.
YT UU=not part of a pair. CP=pair aligned concordantly. DP=part of a pair and the pair
aligned discordantly. UP=pair failed to aligne either concordantly or discordantly.
MD A string representation of the mismatched reference bases in the alignment.
The MD field aims to achieve SNP/indel calling without looking at the reference. For example,
a string `10A5^AC6' means from the leftmost reference base in the alignment, there are 10 matches
followed by an A on the reference which is different from the aligned read base; the next 5
reference bases are matches followed by a 2bp deletion from the reference; the deleted sequence
is AC; the last 6 bases are matches. The MD field ought to match the CIGAR string.
Reverse-complemented hits.
For minus strand hit, POS is position of lowest target coordinate
in plus strand target sequence. This is the position aligned to the
first base in the rev-comp'd read / last base in the original read.
The read sequence in the SAM file is revcomp'd.
Conceptually, SAM rev-comps the read but not the target sequence.
***/
void SeqToFasta(FILE *f, const byte *Seq, unsigned L, const char *Label);
static double GetBlastnEvalue(unsigned QueryLength, double BlastnScore, double DBLength)
{
// From gapped BLASTN:
const double GAPPED_LAMBDA = 1.28;
const double GAPPED_K = 0.46;
static const double Log2 = log(2.0);
double NM = double(QueryLength*DBLength);
double BitScore = (BlastnScore*GAPPED_LAMBDA - GAPPED_K)/Log2;
double Evalue = NM/pow(2, BitScore);
// Underflow tests
if (Evalue != Evalue) // test for NaN
return 0.0;
// Probably conservative, but better safe than sorry...
if (numeric_limits<double>::has_infinity && Evalue == numeric_limits<double>::infinity())
return 0.0;
return Evalue;
}
void CigarToVecs(const string &Cigar, vector<unsigned> &Ints,
vector<char> &Chars)
{
Ints.clear();
Chars.clear();
const unsigned CL = SIZE(Cigar);
if (CL == 0)
return;
unsigned Int = 0;
asserta(isdigit(Cigar[0]) && !isdigit(Cigar[CL-1]));
for (unsigned i = 0; i < CL; ++i)
{
char c = Cigar[i];
if (isdigit(c))
Int = Int*10 + (c - '0');
else
{
asserta(i > 0 && isdigit(Cigar[i-1]));
asserta(Int > 0);
Ints.push_back(Int);
Chars.push_back(c);
Int = 0;
}
}
}
// bowtie bug: bowtie2 produces bizarre CIGARs like this:
// 271S576M291I1M2686S
// ^^^^^^
// Note: 291I 1M, very long gap followed by one or two matches.
SAMRec *SAMRec::MakeCopy() const
{
SAMRec *pr = new SAMRec;
if (pr == 0)
Die("SAMRec::MakeCopy, out of memory");
pr->FromLine(m_Line.c_str());
return pr;
}
void SAMRec::ReadSeqToFasta(FILE *f) const
{
if (f == 0)
return;
asserta(m_ReadSeq != 0);
SeqToFasta(f, (const byte *) m_ReadSeq, GetReadSeqLength(), m_ReadLabel);
}
void SAMRec::ToBlast6(FILE *f)
{
if (f == 0)
return;
if (IsUnmapped())
{
if (opt(output_no_hits))
{
fprintf(f,
"%s" // 1 Query label
"\t*" // 2 Target label
"\t0" // 3 %id
"\t0" // 4 Alignment length (cols)
"\t0" // 5 Mismatches
"\t0" // 6 Opens
"\t0" // 7 Qlo
"\t0" // 8 Qhi
"\t0" // 9 Tlo
"\t0" // 10 Thi
"\t0" // 10 Thi
"\t*" // 11 Evalue
"\t0\n", // 12 BitScore
m_ReadLabel);
}
return;
}
unsigned Pos = GetReadLo();
unsigned ReadLo = Pos + 1;
unsigned ReadHi = GetReadHi() + 1;
unsigned TargetLo = GetTargetLo() + 1;
unsigned TargetHi = GetTargetHi() + 1;
double PctId = GetPctId();
fprintf(f, "%s", m_ReadLabel); // 1
fprintf(f, "\t%s", m_TargetLabel); // 2
if (PctId == DBL_MAX)
fprintf(f, "\t*"); // 3
else
fprintf(f, "\t%.1f", PctId); // 3
fprintf(f, "\t%u", m_ColCount); // 4
fprintf(f, "\t%u", m_GapOpens); // 5
fprintf(f, "\t%u", m_GapExts); // 6
fprintf(f, "\t%u", ReadLo); // 7
fprintf(f, "\t%u", ReadHi); // 8
if (m_RStrand)
{
fprintf(f, "\t%u", TargetLo); // 9
fprintf(f, "\t%u", TargetHi); // 10
}
else
{
fprintf(f, "\t%u", TargetHi); // 9
fprintf(f, "\t%u", TargetLo); // 10
}
if (m_Score == UINT_MAX)
{
fprintf(f, "\t*"); // 11
fprintf(f, "\t*"); // 12
}
else
{
fprintf(f, "\t%.2g", GetEvalue()); // 11
fprintf(f, "\t%u", m_Score); // 12
}
fprintf(f, "\n");
}
void SAMRec::ToFile(FILE *f) const
{
if (f == 0)
return;
unsigned FieldCount = SIZE(m_Fields);
for (unsigned i = 0; i < FieldCount; ++i)
{
if (i > 0)
fputc('\t', f);
fputs(m_Fields[i].c_str(), f);
}
fputc('\n', f);
}
unsigned SAMRec::GetReadLength() const
{
return CigarToReadLength(m_Cigar);
}
double SAMRec::GetReadCovPct() const
{
return GetPct(m_Identities + m_Mismatches, GetReadLength());
}
double SAMRec::GetEvalue() const
{
double BlastnScore = m_Identities - 2.0*(m_Mismatches + m_GapOpens + m_GapExts);
unsigned L = GetReadLength();
double Evalue = GetBlastnEvalue(L, BlastnScore, opt(ka_dbsize));
return Evalue;
}
unsigned SAMRec::CigarToColCount(const string &sCigar) const
{
const char *Cigar = sCigar.c_str();
unsigned Cols = 0;
unsigned Int = 0;
for (const char *p = Cigar; ; ++p)
{
char c = *p;
if (c == 0)
break;
if (isdigit(c))
Int = Int*10 + (c - '0');
else if (isalpha(c) || c == '=')
{
asserta(Int > 0);
if (c != 'S' && c != 'H')
Cols += Int;
Int = 0;
}
else
{
Log("\n%s\n", m_Line.c_str());
Die("Unrecognized letter '%c' in CIGAR '%s'", c, Cigar);
}
}
return Cols;
}
unsigned SAMRec::CigarToReadLo(const string &sCigar) const
{
const char *Cigar = sCigar.c_str();
unsigned Cols = 0;
unsigned Int = 0;
for (const char *p = Cigar; ; ++p)
{
char c = *p;
if (c == 0)
break;
if (isdigit(c))
Int = Int*10 + (c - '0');
else if (isalpha(c) || c == '=')
{
if (c == 'S' || c == 'H')
return Int;
else
return 0;
Int = 0;
}
else
{
Log("\n%s\n", m_Line.c_str());
Die("Unrecognized letter '%c' in CIGAR '%s'", c, Cigar);
}
}
return 0;
}
unsigned SAMRec::CigarToReadSeqLength(const string &sCigar) const
{
const char *Cigar = sCigar.c_str();
unsigned ReadSeqLength = 0;
unsigned Int = 0;
for (const char *p = Cigar; ; ++p)
{
char c = *p;
if (c == 0)
break;
if (isdigit(c))
Int = Int*10 + (c - '0');
else if (isalpha(c) || c == '=')
{
switch (c)
{
case 'D':
case 'H':
break;
case 'S':
case 'M':
case 'I':
ReadSeqLength += Int;
break;
default:
Log("\n%s\n", m_Line.c_str());
Die("Unrecognized letter '%c' in CIGAR '%s'", c, Cigar);
}
Int = 0;
}
}
return ReadSeqLength;
}
unsigned SAMRec::CigarToReadLength(const string &sCigar) const
{
const char *Cigar = sCigar.c_str();
unsigned ReadLength = 0;
unsigned Int = 0;
for (const char *p = Cigar; ; ++p)
{
char c = *p;
if (c == 0)
break;
if (isdigit(c))
Int = Int*10 + (c - '0');
else if (isalpha(c) || c == '=')
{
switch (c)
{
case 'H':
case 'S':
case 'M':
case 'I':
ReadLength += Int;
break;
case 'D':
break;
default:
Log("\n%s\n", m_Line.c_str());
Die("Unrecognized letter '%c' in CIGAR '%s'", c, Cigar);
}
Int = 0;
}
}
return ReadLength;
}
unsigned SAMRec::CigarToReadSeqLo(const string &sCigar) const
{
const char *Cigar = sCigar.c_str();
unsigned Cols = 0;
unsigned Int = 0;
for (const char *p = Cigar; ; ++p)
{
char c = *p;
if (c == 0)
break;
if (isdigit(c))
Int = Int*10 + (c - '0');
else if (isalpha(c) || c == '=')
{
if (c == 'S')
return Int;
else
return 0;
Int = 0;
}
else
{
Log("\n%s\n", m_Line.c_str());
Die("Unrecognized letter '%c' in CIGAR '%s'", c, Cigar);
}
}
return 0;
}
void SAMRec::FromLine(const char *Line)
{
FromLine(string(Line));
}
void SAMRec::Clear()
{
m_Line.clear();
m_Cigar.clear();
m_CigarChars.clear();
m_CigarInts.clear();
m_RRow.Size = 0;
m_ARow.Size = 0;
m_TRow.Size = 0;
m_TSeg.Size = 0;
m_TargetLabel = 0;
m_ReadSeq = 0;
m_TargetLabel = 0;
m_Score = UINT_MAX;
m_BitFlags = 0;
m_TargetLo = UINT_MAX;
m_ReadSeqLo = UINT_MAX;
m_ReadLo = UINT_MAX;
m_ReadSeqLength = UINT_MAX;
m_Identities = UINT_MAX;
m_Mismatches = UINT_MAX;
m_Gaps = UINT_MAX;
m_GapOpens = UINT_MAX;
m_GapExts = UINT_MAX;
m_ColCount = UINT_MAX;
m_Qual = 0;
m_MD = 0;
m_Evalue = DBL_MAX;
m_RStrand = false;
m_IsHardClipped = false;
}
void SAMRec::FromLine(const string &Line)
{
Clear();
m_Line = Line;
Split(m_Line, m_Fields, '\t');
unsigned FieldCount = SIZE(m_Fields);
if (FieldCount < 11)
{
Log("\n%s\n", Line.c_str());
Die("Invalid SAM record, got %u tabbed fields must be >= 11", FieldCount);
}
m_ReadLabel = m_Fields[0].c_str();
m_BitFlags = atou(m_Fields[1]);
//// yara bug -- unmap if CIGAR is *
// if (m_Fields[5] == "*")
// m_BitFlags = 4;
m_ReadSeq = m_Fields[9].c_str();
m_ReadSeqLength = ustrlen(m_ReadSeq);
m_Mapq = UINT_MAX;
m_Mapq = atou(m_Fields[4]);
if (m_Mapq == 255)
m_Mapq = UINT_MAX;
m_TargetLabel = m_Fields[2].c_str();
m_TargetLo = atou(m_Fields[3]);
m_Cigar = m_Fields[5];
const string &sQual = m_Fields[10];
asserta(sQual == "*" || SIZE(sQual) == m_ReadSeqLength);
m_Qual = sQual.c_str();
m_MD = 0;
m_Identities = UINT_MAX;
m_Mismatches = UINT_MAX;
m_GapOpens = UINT_MAX;
m_Gaps = UINT_MAX;
m_Score = UINT_MAX;
m_RStrand = ((m_BitFlags & 16) == 0);
for (unsigned i = 11; i < FieldCount; ++i)
{
const char *f = m_Fields[i].c_str();
if (StartsWith(f, "MD:Z:"))
m_MD = f + 5;
else if (StartsWith(f, "XM:i:"))
m_Mismatches = atou(f + 5);
else if (StartsWith(f, "XO:i:"))
m_GapOpens = atou(f + 5);
else if (StartsWith(f, "XG:i:"))
m_Gaps = atou(f + 5);
else if (StartsWith(f, "AS:i:"))
m_Score = atou(f + 5);
}
if (IsUnmapped())
return;
m_ColCount = CigarToColCount(m_Cigar);
if (m_GapOpens == UINT_MAX)
m_GapOpens = CalcGapOpens();
if (m_Gaps == UINT_MAX)
m_Gaps = CalcGaps();
if (m_GapOpens != UINT_MAX && m_Gaps != UINT_MAX)
{
asserta(m_Gaps >= m_GapOpens);
m_GapExts = m_Gaps - m_GapOpens;
}
unsigned NonIdentities = UINT_MAX;
if (m_Mismatches != UINT_MAX && m_Gaps != UINT_MAX)
{
NonIdentities = m_Mismatches + m_Gaps;
m_Identities = m_ColCount - NonIdentities;
}
m_ReadLo = CigarToReadLo(m_Cigar);
m_ReadSeqLo = CigarToReadSeqLo(m_Cigar);
m_IsHardClipped = (strchr(m_Cigar.c_str(), 'H') != 0);
}
const char *SAMRec::GetRRow()
{
if (m_RRow.Size > 0)
return m_RRow.Data;
m_RRow.Alloc(m_ColCount + 16);
char *RRow = m_RRow.Data;
const unsigned ReadSeqLength = GetReadSeqLength();
asserta(m_ReadSeq[ReadSeqLength] == 0);
const unsigned CL = SIZE(m_Cigar);
unsigned Int = 0;
unsigned Col = 0;
bool FirstS = true;
unsigned ReadSeqPos = 0;
for (unsigned i = 0; i < CL; ++i)
{
char c = m_Cigar[i];
if (isdigit(c))
Int = Int*10 + (c - '0');
else
{
switch (c)
{
case 'H':
break;
case 'S':
if (FirstS)
{
ReadSeqPos = Int;
FirstS = false;
}
else
ReadSeqPos += Int;
break;
case 'M':
case 'I':
for (unsigned j = 0; j < Int; ++j)
{
if (ReadSeqPos >= ReadSeqLength)
{
Log("\n");
Log("%s\n", m_Line.c_str());
Die("ReadPos %u >= ReadSeqLength %u", ReadSeqPos, ReadSeqLength);
}
RRow[Col++] = toupper(m_ReadSeq[ReadSeqPos++]);
}
break;
case 'D':
for (unsigned j = 0; j < Int; ++j)
RRow[Col++] = '-';
break;
default:
Die("Unexpected char '%c' in CIGAR '%s'", c, m_Cigar.c_str());
}
Int = 0;
}
}
asserta(Col == m_ColCount);
RRow[Col] = 0;
m_RRow.Size = m_ColCount;
return RRow;
}
const char *SAMRec::GetTRow()
{
if (m_MD == 0)
Die("SAMRec::GetTSeg(), SAM record missing MD, cannot convert to alignment");
if (m_TSeg.Size > 0)
{
const char *TSeg = m_TSeg.Data;
asserta(TSeg != 0);
return TSeg;
}
m_TSeg.Alloc(m_ColCount+16);
char *TSeg = m_TSeg.Data;
memset(TSeg, '?', m_ColCount);
unsigned Int = 0;
const unsigned L = ustrlen(m_MD);
bool Deleting = false;
unsigned Pos = 0;
for (unsigned i = 0; i < L; ++i)
{
char c = m_MD[i];
if (isdigit(c))
{
Deleting = false;
Int = Int*10 + (c - '0');
}
else if (isalpha(c))
{
for (unsigned j = 0; j < Int; ++j)
TSeg[Pos++] = '.';
Int = 0;
TSeg[Pos++] = c;
}
else
{
asserta(c == '^');
Deleting = true;
}
}
for (unsigned j = 0; j < Int; ++j)
TSeg[Pos++] = '.';
TSeg[Pos] = 0;
const unsigned ReadSeqLength = GetReadSeqLength();
const unsigned CL = SIZE(m_Cigar);
Int = 0;
bool FirstS = true;
unsigned ReadSeqPos = 0;
unsigned TargetSeqPos = 0;
for (unsigned i = 0; i < CL; ++i)
{
char c = m_Cigar[i];
if (isdigit(c))
Int = Int*10 + (c - '0');
else
{
switch (c)
{
case 'H':
break;
case 'S':
if (FirstS)
{
ReadSeqPos = Int;
FirstS = false;
}
else
ReadSeqPos += Int;
break;
case 'M':
for (unsigned j = 0; j < Int; ++j)
{
if (ReadSeqPos >= ReadSeqLength)
{
Log("\n");
Log("%s\n", m_Line.c_str());
Die("ReadPos %u >= ReadSeqLength %u", ReadSeqPos, ReadSeqLength);
}
if (TSeg[TargetSeqPos] == '.')
TSeg[TargetSeqPos] = m_ReadSeq[ReadSeqPos];
++TargetSeqPos;
++ReadSeqPos;
}
break;
case 'I':
ReadSeqPos += Int;
break;
case 'D':
for (unsigned j = 0; j < Int; ++j)
{
char c = TSeg[TargetSeqPos++];
asserta(c != '.' && c != '?');
}
break;
default:
Die("Unexpected char '%c' in CIGAR '%s'", c, m_Cigar.c_str());
}
Int = 0;
}
}
m_TRow.Alloc(m_ColCount+16);
char *TRow = m_TRow.Data;
unsigned Col = 0;
TargetSeqPos = 0;
for (unsigned i = 0; i < CL; ++i)
{
char c = m_Cigar[i];
if (isdigit(c))
Int = Int*10 + (c - '0');
else
{
switch (c)
{
case 'H':
case 'S':
break;
case 'M':
case 'D':
for (unsigned j = 0; j < Int; ++j)
TRow[Col++] = TSeg[TargetSeqPos++];
break;
case 'I':
for (unsigned j = 0; j < Int; ++j)
TRow[Col++] = '-';
break;
default:
Die("Unexpected char '%c' in CIGAR '%s'", c, m_Cigar.c_str());
}
Int = 0;
}
}
TRow[Col] = 0;
if (Col != m_ColCount)
{
Log("RRow %s\n", GetRRow());
Log("TRow %s\n", TRow);
Die("Col %u, m_ColCount %u\n", Col, m_ColCount);
}
return TRow;
}
const char *SAMRec::GetARow()
{
if (m_ARow.Size > 0)
{
const char *ARow = m_ARow.Data;
asserta(ARow != 0);
asserta(ARow[m_ColCount] == 0);
return ARow;
}
asserta(m_ColCount > 0 && m_ColCount != UINT_MAX);
const char *RRow = GetRRow();
const char *TRow = GetTRow();
asserta(RRow[m_ColCount] == 0);
asserta(TRow[m_ColCount] == 0);
m_ARow.Alloc(m_ColCount+16);
char *ARow = m_ARow.Data;
for (unsigned Col = 0; Col < m_ColCount; ++Col)
{
if (RRow[Col] == TRow[Col])
ARow[Col] = '|';
else
ARow[Col] = ' ';
}
ARow[m_ColCount] = 0;
m_ARow.Size = m_ColCount;
return ARow;
}
unsigned SAMRec::GetInsertCount()
{
SetCigarVecs();
const unsigned N = SIZE(m_CigarChars);
unsigned n = 0;
for (unsigned i = 0; i < N; ++i)
if (m_CigarChars[i] == 'I')
n += m_CigarInts[i];
return n;
}
unsigned SAMRec::GetDeleteCount()
{
SetCigarVecs();
const unsigned N = SIZE(m_CigarChars);
unsigned n = 0;
for (unsigned i = 0; i < N; ++i)
if (m_CigarChars[i] == 'D')
n += m_CigarInts[i];
return n;
}
unsigned SAMRec::GetTargetHi()
{
return m_TargetLo + GetTargetSegLength() - 1;
}
unsigned SAMRec::GetReadSegLength()
{
unsigned DeleteCount = GetDeleteCount();
asserta(DeleteCount < m_ColCount);
unsigned L = m_ColCount - DeleteCount;
return L;
}
unsigned SAMRec::GetTargetSegLength()
{
unsigned InsertCount = GetInsertCount();
asserta(InsertCount < m_ColCount);
unsigned L = m_ColCount - InsertCount;
return L;
}
void SAMRec::PrAln(FILE *f)
{
if (f == 0)
return;
const char *RRow = GetRRow();
const char *TRow = GetTRow();
const char *ARow = GetARow();
const unsigned COLS = 80;
unsigned Rows = (m_ColCount + COLS - 1)/COLS;
unsigned QStart = (m_RStrand ? GetReadLo() : GetReadHi()) + 1;
unsigned QEnd = (m_RStrand ? GetReadHi() : GetReadLo()) + 1;
unsigned QMax = max(QStart, QEnd);
unsigned TStart = GetTargetLo() + 1;
unsigned TEnd = GetTargetHi() + 1;
unsigned MaxPos = max(QMax, TEnd);
char Tmp[16];
sprintf(Tmp, "%u", MaxPos);
unsigned ndig = (unsigned) strlen(Tmp);
Pr(f, "\n");
Pr(f, "Query >%s, length %u nt\n", m_ReadLabel, GetReadLength());
Pr(f, "Target >%s", m_TargetLabel);
Pr(f, "\n");
unsigned QPos = QStart;
unsigned TPos = TStart;
for (unsigned Row = 0; Row < Rows; ++Row)
{
unsigned ColLo = Row*COLS;
unsigned n = m_ColCount - ColLo;
if (n > COLS)
n = COLS;
Pr(f, "\n");
Pr(f, "Qry %*u %c ", ndig, QPos, pom(m_RStrand));
WriteStdioFile(f, RRow + ColLo, n);
for (unsigned i = 0; i < n; ++i)
{
unsigned Col = ColLo + i;
char q = RRow[Col];
if (q != '-')
{
if (m_RStrand)
++QPos;
else
--QPos;
}
}
Pr(f, " %u\n", m_RStrand ? QPos - 1 : QPos + 1);
Pr(f, " %*.*s ", ndig, ndig, "");
WriteStdioFile(f, ARow + ColLo, n);
Pr(f, "\n");
Pr(f, "Tgt %*u + ", ndig, TPos);
WriteStdioFile(f, TRow + ColLo, n);
for (unsigned i = 0; i < n; ++i)
{
unsigned Col = ColLo + i;
char t = TRow[Col];
if (t != '-')
++TPos;
}
Pr(f, " %u\n", TPos - 1);
}
unsigned Cols = GetColCount();
unsigned Gaps = m_GapOpens + m_GapExts;
Pr(f, "\n");
Pr(f, "Score %u", m_Score);
Pr(f, ", cols %u", Cols);
Pr(f, " cov %.1f%%", GetReadCovPct());
Pr(f, ", ids %u (%.1f%%)", m_Identities, GetPctId());
Pr(f, ", gaps %u (%.1f%%)", Gaps, GetPct(Gaps, Cols));
if (optset_ka_dbsize)
Pr(f, ", E-value %.2g", GetEvalue());
Pr(f, "\n");
}
double SAMRec::GetPctId2()
{
const char *RRow = GetRRow();
const char *TRow = GetTRow();
unsigned Cols = 0;
unsigned n = 0;
for (unsigned i = 0; i < m_ColCount; ++i)
{
if (RRow[i] == 'N' || RRow[i] == '-' || TRow[i] == '-')
continue;
++Cols;
if (RRow[i] == TRow[i])
++n;
}
return GetPct(n, Cols);
}
void SAMRec::GetColToTargetPos(vector<unsigned> &ColToTargetPos)
{
ColToTargetPos.clear();
const char *RRow = GetRRow();
const char *TRow = GetTRow();
unsigned TargetPos = m_TargetLo;
unsigned MaxTargetPos = TargetPos;
for (unsigned Col = 0; Col < m_ColCount; ++Col)
{
char t = TRow[Col];
if (t != '-')
{
// convert to 0-based
ColToTargetPos.push_back(TargetPos);
MaxTargetPos = TargetPos;
++TargetPos;
}
else
ColToTargetPos.push_back(UINT_MAX);
}
unsigned TargetHi = GetTargetHi();
asserta(MaxTargetPos == TargetHi);
asserta(SIZE(ColToTargetPos) == m_ColCount);
}
void SAMRec::GetPath(string &Path, bool ReadIsQuery)
{
Path.clear();
const char *RRow = GetRRow();
const char *TRow = GetTRow();
unsigned ColCount = GetColCount();
char ReadGapSymbol = (ReadIsQuery ? 'D' : 'I');
char TargetGapSymbol = (ReadIsQuery ? 'I' : 'D');
for (unsigned Col = 0; Col < ColCount; ++Col)
{
char r = RRow[Col];
char t = TRow[Col];
if (isalpha(t) && isalpha(t))
Path.push_back('M');
else if (r == '-')
Path.push_back(ReadGapSymbol);
else if (t == '-')
Path.push_back(TargetGapSymbol);
else
asserta(false);
}
}
void SAMRec::ValidateReadSeqLength()
{
unsigned L1 = ustrlen(m_ReadSeq);
unsigned L2 = CigarToReadSeqLength(m_Cigar);
asserta(L1 == L2);
}
void SAMRec::ValidateTRow(SeqInfo *Target)
{
const byte *T = Target->m_Seq;
unsigned TL = Target->m_L;
unsigned TLo = GetTargetLo();
unsigned THi = GetTargetHi();
if (THi < TLo || THi >= TL)
Die("Bad rec THi %u, TLo %u, TL %u >%s", THi, TLo, TL, Target->m_Label);
asserta(THi < TL);
const char *TRow = GetTRow();
unsigned TPos = TLo;
unsigned TSegLength = GetTargetSegLength();
unsigned ColCount = m_ColCount;
for (unsigned Col = 0; Col < ColCount; ++Col)
{
char c = TRow[Col];
if (c == '-')
continue;
char t = T[TPos++];
if (toupper(t) != toupper(c))
{
Log("\n");
Log("%s\n", m_Line.c_str());
Log("RRow %*.*s\n", ColCount, ColCount, GetRRow());
Log("TRow %*.*s\n", ColCount, ColCount, TRow);
Log("TSeg %*.*s\n", TSegLength, TSegLength, T + TLo);
Warning("Mismatch: Col %u, c %c, t %c\n", Col, c, t);
}
}
}
unsigned SAMRec::CalcGapOpens()
{
SetCigarVecs();
const unsigned N = SIZE(m_CigarChars);
unsigned n = 0;
for (unsigned i = 0; i < N; ++i)
{
char c = m_CigarChars[i];
if (c == 'D' || c == 'I')
++n;
}
return n;
}
unsigned SAMRec::CalcGaps()
{
SetCigarVecs();
const unsigned N = SIZE(m_CigarChars);
unsigned n = 0;
for (unsigned i = 0; i < N; ++i)
{
char c = m_CigarChars[i];
if (c == 'D' || c == 'I')
n += m_CigarInts[i];
}
return n;
}
const char *SAMRec::GetTag(const char *TagName)
{
unsigned FieldCount = SIZE(m_Fields);
for (unsigned i = 11; i < FieldCount; ++i)
{
const char *f = m_Fields[i].c_str();
if (f[0] == TagName[0] && f[1] == TagName[1])
return f + 5;
}
return "";
}
| 23,857
|
C++
|
.cpp
| 951
| 22.044164
| 97
| 0.617159
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,009
|
lockobj.cpp
|
rcedgar_urmap/src/lockobj.cpp
|
#include "myutils.h"
#define L(x) omp_lock_t g_Lock##x;
#include "lockobjs.h"
static bool Init()
{
#define L(x) omp_init_lock(&g_Lock##x);
#include "lockobjs.h"
return true;
}
static bool g_InitDone = Init();
| 215
|
C++
|
.cpp
| 10
| 19.9
| 39
| 0.69802
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| true
| false
| true
| false
|
1,538,010
|
samseqsource.cpp
|
rcedgar_urmap/src/samseqsource.cpp
|
#include "myutils.h"
#include "samseqsource.h"
#include "seqinfo.h"
#include "alpha.h"
#include "omplock.h"
bool SAMSeqSource::GetNextLo(SeqInfo *SI)
{
const char *Line = "";
for (;;)
{
bool Ok = ReadLine();
if (!Ok)
return false;
if (m_LineBuff.Data[0] != '@')
break;
}
vector<string> Fields;
Split(string(Line), Fields, '\t');
unsigned SeqIndex = m_SeqCount;
SI->Init(SeqIndex);
unsigned LabelBytes = SIZE(Fields[0]) + 1;
SI->AllocLabel(LabelBytes);
memcpy(SI->m_LabelBuffer, Fields[0].c_str(), LabelBytes);
// Seq
unsigned L = SIZE(Fields[9]);
asserta(SIZE(Fields[10]) == L);
SI->AllocSeq(L);
SI->AllocQual(L);
byte *SeqBuffer = SI->m_SeqBuffer;
char *QualBuffer = SI->m_QualBuffer;
memcpy(SeqBuffer, Fields[9].c_str(), L);
memcpy(QualBuffer, Fields[10].c_str(), L);
unsigned BitFlags = StrToUint(Fields[1]);
if (BitFlags & 16)
{
RevCompSeq(SeqBuffer, L, SeqBuffer);
RevQual(QualBuffer, L, QualBuffer);
}
return true;
}
| 976
|
C++
|
.cpp
| 40
| 22.075
| 58
| 0.683531
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,011
|
label.cpp
|
rcedgar_urmap/src/label.cpp
|
#include "myutils.h"
#include "label.h"
void StripAllAnnots(string &Label)
{
size_t n = Label.find(';');
if (n == string::npos || n == 0)
return;
Label = Label.substr(0, n);
}
void GetAllAnnots(const string &Label, string &Annots)
{
Annots.clear();
size_t n = Label.find(';');
if (n == string::npos || n == 0)
return;
unsigned L = SIZE(Label);
for (unsigned i = unsigned(n) + 1; i < L; ++i)
{
char c = Label[i];
Annots.push_back(c);
}
}
const char *GetStrField(const string &Label, const string &NameEq,
string &Value)
{
Value.clear();
vector<string> Fields;
Split(Label, Fields, ';');
const unsigned N = SIZE(Fields);
for (unsigned i = 0; i < N; ++i)
{
const string &Field = Fields[i];
if (StartsWith(Field, NameEq))
{
Value = Field.substr(NameEq.size(), string::npos);
break;
}
}
return Value.c_str();
}
void StripAnnot(string &Label, const string &NameEq)
{
if (Label.find(NameEq) == string::npos)
return;
string NewLabel;
vector<string> Fields;
Split(Label, Fields, ';');
const unsigned N = SIZE(Fields);
for (unsigned i = 0; i < N; ++i)
{
const string &Field = Fields[i];
if (Field.find(NameEq) == 0)
continue;
NewLabel += Field + ";";
}
if (NewLabel.find('=') == string::npos)
{
Label.clear();
unsigned n = SIZE(NewLabel);
for (unsigned i = 0; i + 1 < n; ++i)
Label.push_back(NewLabel[i]);
}
else
Label = NewLabel;
}
void AppendIntField(string &Label, const string &NameEq, unsigned Value)
{
Psasc(Label, "%s%u", NameEq.c_str(), Value);
}
void AppendStrField(string &Label, const string &NameEqValue)
{
Psasc(Label, "%s", NameEqValue.c_str());
}
void AppendStrField(string &Label, const string &NameEq, const string &Value)
{
Psasc(Label, "%s%s", NameEq.c_str(), Value.c_str());
}
void AppendSize(string &Label, unsigned Size)
{
AppendIntField(Label, "size=", Size);
}
void AppendTaxStr(string &Label, const string &s)
{
AppendStrField(Label, "tax=", s);
}
void StripSize(string &Label)
{
StripAnnot(Label, "size=");
}
void StripTax(string &Label)
{
StripAnnot(Label, "tax=");
StripAnnot(Label, "taxstr=");
StripAnnot(Label, "sciname=");
StripAnnot(Label, "taxlev=");
size_t n = Label.find("\tRoot;");
if (n != string::npos)
Label = Label.substr(0, n);
}
const char *GetTaxStrFromLabel(const string &Label, string &s)
{
GetStrField(Label, "tax=", s);
return s.c_str();
}
void ReplaceSizeInLabel(string &Label, unsigned NewSize)
{
StripSize(Label);
AppendSize(Label, NewSize);
}
unsigned GetIntFieldFromLabel(const string &Label, const string &NameEq, unsigned Default)
{
const unsigned n = SIZE(NameEq);
vector<string> Fields;
Split(Label, Fields, ';');
const unsigned N = SIZE(Fields);
for (unsigned i = 0; i < N; ++i)
{
const string &Field = Fields[i];
if (Field.substr(0, n) == NameEq)
{
string a = Field.substr(n, string::npos);
const char *as = a.c_str();
if (!IsUintStr(as) && Default == UINT_MAX)
Die("%s not integer >%s", NameEq.c_str(), Label.c_str());
if (!IsUintStr(as))
Die("%s invalid value >%s", NameEq.c_str(), Label.c_str());
unsigned Value = StrToUint(as);
return Value;
}
}
if (Default == UINT_MAX)
Die("%s not found in label >%s", NameEq.c_str(), Label.c_str());
return Default;
}
unsigned GetSizeFromLabel(const string &Label, unsigned Default)
{
StartTimer(GetSizeFromLabel);
// unsigned Size = GetIntFieldFromLabel(Label, "size=", Default);
unsigned Size = Default;
const char *p = strstr(Label.c_str(), ";size=");
if (p != 0)
Size = (unsigned) atoi(p+6);
else if (Default == UINT_MAX)
Die("Missing size= in >%s", Label.c_str());
EndTimer(GetSizeFromLabel);
return Size;
}
unsigned GetTaxIdFromLabel(const string &Label, unsigned Default)
{
return GetIntFieldFromLabel(Label, "tax=", Default);
}
void GetAccFromLabel(const string &Label, string &Acc)
{
Acc.clear();
const unsigned N = SIZE(Label);
for (unsigned i = 0; i < N; ++i)
{
char c = Label[i];
if (c == ' ' || c == '|' || c == ';')
{
if (Acc != "gi")
return;
}
Acc += c;
}
}
byte GetSplitRankFromLabel(const string &Label)
{
string s;
GetStrField(Label, "split=", s);
if (SIZE(s) > 1)
Die("Invalid split in label >%s", Label.c_str());
return s.c_str()[0];
}
void GetOTUNameFromLabel(const string &Label, string &OTUName)
{
GetStrField(Label, "otu=", OTUName);
if (!OTUName.empty())
return;
GetAccFromLabel(Label, OTUName);
if (OTUName.empty())
Die("Empty OTU name in label >%s", Label.c_str());
}
void GetSampleNameFromLabel(const string &Label, string &SampleName)
{
SampleName.clear();
GetStrField(Label, "sample=", SampleName);
if (!SampleName.empty())
return;
GetStrField(Label, "barcodelabel=", SampleName);
if (!SampleName.empty())
return;
if (optset_sample_delim)
{
const string &d = opt(sample_delim);
size_t n = Label.find(d);
if (n == string::npos)
Die("delim '%s' not found in >%s", d.c_str(), Label.c_str());
SampleName = Label.substr(0, n);
return;
}
unsigned L = SIZE(Label);
for (unsigned i = 0; i < L; ++i)
{
char c = Label[i];
if (!isalpha(c) && !isdigit(c) && !(c == '_'))
return;
SampleName.push_back(c);
}
}
// urtils/varsim.cpp:142
// 0 1 2 3 4 5 6 7 0 1 2 3
// Ps(Label, "R%u.%u.%u.%u.%s.%c.%u.%u", m_PairIndex, m_BC, m_MolId, PairIndex+1,
// m_RefLabel.c_str(), m_AorB, R1Pos+1, R2Pos+1);
// 4 5 6 7
void ParseVarsimLabel(const string &ReadLabel, unsigned &ReadPairIndex,
uint32 &BC, unsigned &MolId, unsigned &MolPairIndex,
string &ChrName, char &AorB, unsigned &R1Pos, unsigned &R2Pos)
{
string Label = ReadLabel;
TruncWhiteSpace(Label);
vector<string> Fields;
Split(Label, Fields, '.');
asserta(SIZE(Fields) == 8);
asserta(Label[0] == 'R');
ReadPairIndex = StrToUint(Fields[0].c_str() + 1);
BC = StrToUint(Fields[1]);
MolId = StrToUint(Fields[2]);
MolPairIndex = StrToUint(Fields[3]);
ChrName = Fields[4];
string sAorB = Fields[5];
AorB = sAorB[0];
if (AorB != 'A' && AorB != 'B')
Die("Invalid label, AorB %s", ReadLabel.c_str());
R1Pos = StrToUint(Fields[6]);
R2Pos = StrToUint(Fields[7]);
}
uint32 GetBCFromLabel(const string &ReadLabel)
{
unsigned ReadPairIndex, MolId, MolPairIndex, R1Pos, R2Pos;
char AorB;
unsigned n = SIZE(ReadLabel);
//asserta(ReadLabel[n-2] == ' ');
//char OneTwo = ReadLabel[n-1];
string TargetLabel;
uint32 BC;
ParseVarsimLabel(ReadLabel, ReadPairIndex, BC, MolId, MolPairIndex,
TargetLabel, AorB, R1Pos, R2Pos);
return BC;
}
void GetCoordsFromLabel_varsim(const string &ReadLabel,
string &TargetLabel, unsigned &Pos)
{
unsigned ReadPairIndex, MolId, MolPairIndex, R1Pos, R2Pos;
char AorB;
unsigned n = SIZE(ReadLabel);
asserta(ReadLabel[n-2] == ' ');
char OneTwo = ReadLabel[n-1];
uint32 BC;
ParseVarsimLabel(ReadLabel, ReadPairIndex, BC, MolId, MolPairIndex,
TargetLabel, AorB, R1Pos, R2Pos);
if (OneTwo == '1')
Pos = R1Pos;
else if (OneTwo == '2')
Pos = R2Pos;
else
Die("OneTwo %c", OneTwo);
}
// Sim.5;label=chr1;strand=-;pos=3411;diffs=S28TC;
// Pos is 1-based lo coord w.r.t. plus strand of reference
void GetCoordsFromLabel(const string &Label,
string &TargetLabel, unsigned &Pos, bool &Strand)
{
TargetLabel.clear();
Pos = UINT_MAX;
vector<string> Fields;
Split(Label, Fields, ';');
const unsigned n = SIZE(Fields);
vector<string> Fields2;
for (unsigned i = 1; i < n; ++i)
{
const string &Fieldi = Fields[i];
Split(Fieldi, Fields2, '=');
if (SIZE(Fields2) != 2)
continue;
const string &Name = Fields2[0];
const string &Value = Fields2[1];
if (Name == "label")
TargetLabel = Value;
else if (Name == "pos")
Pos = StrToUint(Value);
else if (Name == "strand")
{
if (Value == "+")
Strand = true;
else if (Value == "-")
Strand = false;
else
asserta(false);
}
}
if (Pos == UINT_MAX)
Die("Pos=UINT_MAX, label >%s", Label.c_str());
}
| 8,017
|
C++
|
.cpp
| 304
| 23.894737
| 90
| 0.65686
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,012
|
chainer1.cpp
|
rcedgar_urmap/src/chainer1.cpp
|
#include "myutils.h"
#include "chainer1.h"
#include "sort.h"
#define TRACE 0
#define TEST 0
#if BRUTE
#include "combo.h"
#endif
static const float MINUS_INFINITY = -9e9f;
void SortBPVecInPlace(BPData *BPVec, unsigned N);
void Chainer1::Clear()
{
m_BPs.Free();
m_ChainIndexes.Free();
m_ChainScores.Free();
m_TB.Free();
}
const unsigned *Chainer1::Chain(const unsigned *Los, const unsigned *His,
float *Scores, unsigned N, unsigned &ChainLength)
{
if (N == 0)
{
ChainLength = 0;
return 0;
}
#if TRACE
Log("Chainer1::Chain(N=%u)\n", N);
#endif
m_BPs.Alloc(2*N);
BPData *BPVec = m_BPs.Data;
BPData *BP = BPVec;
for (unsigned i = 0; i < N; ++i)
{
unsigned Lo = Los[i];
unsigned Hi = His[i];
asserta(Hi >= Lo);
BP->Index = i;
BP->IsLo = true;
BP->Pos = Lo;
BP++;
BP->Index = i;
BP->IsLo = false;
BP->Pos = Hi;
BP++;
}
#if 0 // TRACE
{
Log("BPs:\n");
Log(" Pos Index LH Score\n");
Log("------- ------- -- ------\n");
for (unsigned i = 0; i < 2*N; ++i)
{
const BPData &BP = BPVec[i];
Log("%7u", BP.Pos);
Log(" %7u", BP.Index);
Log(" %s", BP.IsLo ? "Lo" : "Hi");
Log(" %6.1f", Scores[BP.Index]);
Log("\n");
}
}
#endif
SortBPVecInPlace(BPVec, 2*N);
#if TRACE
{
Log("Sorted BPs:\n");
Log(" Pos Index LH Score\n");
Log("------- ------- -- ------\n");
for (unsigned i = 0; i < 2*N; ++i)
{
const BPData &BP = BPVec[i];
Log("%7u", BP.Pos);
Log(" %7u", BP.Index);
Log(" %s", BP.IsLo ? "Lo" : "Hi");
Log(" %6.1f", Scores[BP.Index]);
Log("\n");
}
}
#endif
m_TB.Alloc(N);
m_ChainScores.Alloc(N);
unsigned *TB = m_TB.Data;
float *ChainScores = m_ChainScores.Data;
asserta(BPVec[0].IsLo);
unsigned Index0 = BPVec[0].Index;
unsigned BestChainEnd = UINT_MAX;
TB[0] = UINT_MAX;
ChainScores[0] = MINUS_INFINITY;
for (unsigned i = 0; i < 2*N; ++i)
{
const BPData &BP = BPVec[i];
assert(BP.Index < N);
float Score = Scores[BP.Index];
if (BP.IsLo)
{
TB[BP.Index] = BestChainEnd;
if (BestChainEnd == UINT_MAX)
ChainScores[BP.Index] = Score;
else
ChainScores[BP.Index] = ChainScores[BestChainEnd] + Score;
}
else
{
if (BestChainEnd == UINT_MAX || ChainScores[BP.Index] > ChainScores[BestChainEnd])
BestChainEnd = BP.Index;
}
}
asserta(BestChainEnd < N);
#if TRACE
{
Log("\n");
Log("BestChainEnd %u, Score %.1f\n", BestChainEnd, ChainScores[BestChainEnd]);
Log("Index ChainScore TB\n");
Log("----- ---------- -----\n");
for (unsigned i = 0; i < N; ++i)
{
Log("%5u", i);
float Score = ChainScores[i];
if (Score == MINUS_INFINITY)
Log(" %10.10s", "*");
else
Log(" %10.1f", Score);
unsigned t = TB[i];
if (t == UINT_MAX)
Log(" %5.5s", "*");
else
Log(" %5u", t);
Log("\n");
}
}
#endif
m_ChainIndexes.Alloc(N);
unsigned *ChainIndexes = m_ChainIndexes.Data;
ChainLength = 0;
unsigned Index = BestChainEnd;
for (;;)
{
asserta(ChainLength < N);
ChainIndexes[N - ++ChainLength] = Index;
asserta(Index < N);
Index = TB[Index];
if (Index == UINT_MAX)
break;
}
const unsigned *ChainPtr = ChainIndexes + N - ChainLength;
#if TRACE
{
Log("\n");
Log("Chain:\n");
Log("Index Lo Hi Score\n");
Log("----- ----- ----- ------\n");
float Sum = 0.0;
for (unsigned i = 0; i < ChainLength; ++i)
{
unsigned Index = ChainPtr[i];
asserta(Index < N);
Log("%5u", Index);
Log(" %5u", Los[Index]);
Log(" %5u", His[Index]);
Log(" %6.1f", Scores[Index]);
Sum += Scores[Index];
Log("\n");
}
Log("Sum %.1f\n", Sum);
}
#endif
assert(IsValidChain(Los, His, N, ChainPtr, ChainLength));
return ChainPtr;
}
bool Chainer1::IsValidChain(const unsigned *Los, const unsigned *His, unsigned N,
const unsigned *Chain, unsigned ChainLength)
{
asserta(ChainLength > 0);
for (unsigned i = 0; i < ChainLength; ++i)
{
unsigned Index = Chain[i];
asserta(Index < N);
asserta(Los[Index] <= His[Index]);
if (i > 0)
{
unsigned PrevIndex = Chain[i-1];
if (Los[Index] <= His[PrevIndex])
return false;
}
}
return true;
}
float Chainer1::GetChainScore(const unsigned *Los, const unsigned *His,
const float *Scores, unsigned N, const unsigned *Chain, unsigned ChainLength)
{
float Sum = 0.0;
for (unsigned i = 0; i < ChainLength; ++i)
{
unsigned Index = Chain[i];
assert(Index < N);
Sum += Scores[Index];
}
return Sum;
}
#if BRUTE
static vector<unsigned> g_BestChain;
static const unsigned *g_Los;
static const unsigned *g_His;
static unsigned g_N;
static const float *g_Scores;
static float g_BestScore;
static void OnPerm(const vector<unsigned> &v)
{
unsigned n = SIZE(v);
if (!Chainer1::IsValidChain(g_Los, g_His, g_N, v.data(), n))
return;
float Sum = 0.0;
for (unsigned i = 0; i < n; ++i)
{
unsigned k = v[i];
Sum += g_Scores[k];
}
if (Sum > g_BestScore)
{
g_BestScore = Sum;
g_BestChain = v;
}
}
const unsigned *Chainer1::ChainBrute(const unsigned *Los, const unsigned *His,
float *Scores, unsigned N, unsigned &ChainLength)
{
g_BestChain.clear();
g_Los = Los;
g_His = His;
g_Scores = Scores;
g_N = N;
g_BestScore = MINUS_INFINITY;
EnumPowerSetPerms(N, OnPerm);
ChainLength = SIZE(g_BestChain);
const unsigned *ChainPtr = g_BestChain.data();
#if TRACE
{
Log("\n");
Log("ChainBrute:\n");
Log("Index Lo Hi Score\n");
Log("----- ----- ----- ------\n");
float Sum = 0.0;
for (unsigned i = 0; i < ChainLength; ++i)
{
unsigned Index = ChainPtr[i];
asserta(Index < N);
Log("%5u", Index);
Log(" %5u", Los[Index]);
Log(" %5u", His[Index]);
Log(" %6.1f", Scores[Index]);
Sum += Scores[Index];
Log("\n");
}
Log("Sum %.1f\n", Sum);
}
#endif
asserta(IsValidChain(Los, His, N, ChainPtr, ChainLength));
return ChainPtr;
}
#endif
#if TEST
const unsigned MaxTries = 100;
const unsigned MinCount = 1;
const unsigned MaxCount = 8;
const unsigned MinLen = 1;
const unsigned MaxLen = 100;
const unsigned MaxPos = 100;
const unsigned MinScore = 1;
const unsigned MaxScore = 100;
const unsigned RandSeed = 0;
static void GetRandomLoHi(unsigned MaxPos, unsigned MinLen, unsigned MaxLen,
unsigned MinScore, unsigned MaxScore, unsigned &Lo, unsigned &Hi, float &Score)
{
asserta(MinLen <= MaxLen);
asserta(MinScore <= MaxScore);
Lo = unsigned(rand()%MaxPos);
unsigned Length = MinLen + unsigned(rand()%(MaxLen - MinLen + 1));
Hi = Lo + Length - 1;
Score = float(MinScore + unsigned(rand()%(MaxScore - MinScore + 1)));
}
static unsigned GetRandomLoHis(
unsigned MinCount, unsigned MaxCount,
unsigned MaxPos,
unsigned MinLen, unsigned MaxLen,
unsigned MinScore, unsigned MaxScore,
unsigned *Los, unsigned *His, float *Scores)
{
asserta(MinCount <= MaxCount);
unsigned Count = MinCount + unsigned(rand()%(MaxCount - MinCount + 1));
for (unsigned i = 0; i < Count; ++i)
GetRandomLoHi(MaxPos, MinLen, MaxLen, MinScore, MaxScore,
Los[i], His[i], Scores[i]);
return Count;
}
void cmd_test()
{
srand(RandSeed);
Chainer1 C;
unsigned *Los = myalloc(unsigned, MaxCount);
unsigned *His = myalloc(unsigned, MaxCount);
float *Scores = myalloc(float, MaxCount);
for (unsigned Try = 0; Try < MaxTries; ++Try)
{
ProgressStep(Try, MaxTries, "Testing");
unsigned N = GetRandomLoHis(MinCount, MaxCount, MaxPos, MinLen, MaxLen, MinScore, MaxScore,
Los, His, Scores);
unsigned ChainLength;
const unsigned *Chain = C.Chain(Los, His, Scores, N, ChainLength);
float Score = Chainer1::GetChainScore(Los, His, Scores, N, Chain, ChainLength);
#if BRUTE
unsigned ChainLengthBrute;
const unsigned *ChainBrute = C.ChainBrute(Los, His, Scores, N, ChainLengthBrute);
float BruteScore = Chainer1::GetChainScore(Los, His, Scores, N, ChainBrute, ChainLengthBrute);
asserta(feq(Score, BruteScore));
Log("N %u, chain %u, brute chain %u, Score %.1f, brute %.1f\n",
N, ChainLength, ChainLengthBrute, Score, BruteScore);
#else
Log("N %u, chain %u, Score %.1f\n", N, ChainLength, Score);
#endif
}
}
#endif // TEST
| 8,019
|
C++
|
.cpp
| 321
| 22.46729
| 96
| 0.644462
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,013
|
samrec2.cpp
|
rcedgar_urmap/src/samrec2.cpp
|
#include "myutils.h"
#include "seqinfo.h"
#include "samrec2.h"
void SAMRec2::FromLine(const string &Line)
{
Split(Line, m_Fields, '\t');
asserta(SIZE(m_Fields) >= 11);
m_Flags = StrToUint(Fld(FLAG));
m_Pos = StrToUint(Fld(POS));
m_Mapq = StrToUint(Fld(MAPQ));
}
void SAMRec2::ToSeqInfo(SeqInfo *SI) const
{
const string &Label = Fld(QNAME);
const string &Seq = Fld(SEQ);
const string &Qual = Fld(QUAL);
unsigned LabelBytes = SIZE(Label) + 1;
unsigned L = SIZE(Seq);
SI->AllocSeq(L);
SI->AllocQual(L);
SI->AllocLabel(LabelBytes);
memcpy(SI->m_SeqBuffer, Seq.c_str(), L);
memcpy(SI->m_QualBuffer, Qual.c_str(), L);
memcpy(SI->m_LabelBuffer, Label.c_str(), LabelBytes);
if (IsRevComp())
RevCompSeq(SI->m_SeqBuffer, L, SI->m_SeqBuffer);
SI->m_Seq = SI->m_SeqBuffer;
SI->m_Label = SI->m_LabelBuffer;
SI->m_L = L;
}
void SAMRec2::ToFile(FILE *f) const
{
if (f == 0)
return;
const unsigned N = SIZE(m_Fields);
for (unsigned i = 0; i < N; ++i)
{
if (i > 0)
fputc('\t', f);
fputs(m_Fields[i].c_str(), f);
}
fputc('\n', f);
}
| 1,070
|
C++
|
.cpp
| 43
| 22.651163
| 54
| 0.652601
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,014
|
search1m6.cpp
|
rcedgar_urmap/src/search1m6.cpp
|
#include "myutils.h"
#include "ufindex.h"
#include "seqinfo.h"
#include "alpha.h"
#include "state1.h"
#include "omplock.h"
#include <inttypes.h>
unsigned State1::CalcMAPQ6() const
{
if (m_HitCount == 0)
return 0;
if (m_BestScore <= 0)
return 0;
unsigned QL = m_Query->m_L;
double BestPossibleScore = double(QL);
double Second = double(m_SecondBestScore);
if (Second < BestPossibleScore/2.0)
{
Second = BestPossibleScore/2.0;
if (m_BestScore <= Second)
return 0;
}
double Fract = double(m_BestScore)/double(BestPossibleScore);
double Drop = m_BestScore - Second;
if (Drop > 40)
Drop = 40;
unsigned mapq = (unsigned) (Drop*Fract*Fract);
if (mapq > 40)
mapq = 40;
return mapq;
}
void State1::Search_Lo()
{
const byte *Q = m_Query->m_Seq;
const unsigned QL = m_Query->m_L;
unsigned QWordCount = QL - (m_WordLength - 1);
m_MaxPenalty = MAX_PENALTY;
dpscore MinScorePhase1 = dpscore(QL) + XPHASE1*MISMATCH_SCORE;
dpscore MinScorePhase3 = dpscore(QL) + XPHASE3*MISMATCH_SCORE;
dpscore MinScorePhase4 = dpscore(QL) + XPHASE4*MISMATCH_SCORE;
dpscore TermHSPScorePhase3 = (dpscore(QL)*TERM_HSP_SCORE_PCT_PHASE3)/100;
m_BestHSPScore = 0;
m_AllocBuffOffset = 0;
uint64 *SlotsVec_Plus = alloc_buff(uint64, QL);
uint64 *SlotsVec_Minus = alloc_buff(uint64, QL);
byte *BlobVec_Plus = alloc_buff(byte, 5*QL);
byte *BlobVec_Minus = alloc_buff(byte, 5*QL);
SetSlotsVec(Q, QL, SlotsVec_Plus);
m_RevCompQuerySeq.Alloc(QL);
RevCompSeq(Q, QL, m_RevCompQuerySeq.Data);
const byte *QRC = m_RevCompQuerySeq.Data;
SetSlotsVec(QRC, QL, SlotsVec_Minus);
// ========================== Start Phase 1 =============================
// Extend BOTH1 seeds with stride = word length
// If gapless extension covering whole read with <= 1 diff, done.
// Save HSPs for later gapped extension.
for (uint32 QPos = 0; QPos < QWordCount; QPos += m_WordLength)
{
{/// Plus
uint64 Slot = SlotsVec_Plus[QPos];
if (Slot == UINT64_MAX)
{
BlobVec_Plus[5*QPos] = TALLY_FREE;
goto Minus1;
}
m_UFI->GetBlob(Slot, BlobVec_Plus + 5*QPos);
byte T = BlobVec_Plus[5*QPos];
if (T != TALLY_BOTH1)
goto Minus1;
uint32 SeedPosDB = *(uint32 *) (BlobVec_Plus + 5*QPos + 1);
dpscore Score = ExtendPen(QPos, SeedPosDB, true);
if (Score >= MinScorePhase1)
{
m_Mapq = CalcMAPQ6();
return;
}
}
Minus1:
{///Minus
uint64 Slot = SlotsVec_Minus[QPos];
if (Slot == UINT64_MAX)
{
BlobVec_Minus[5*QPos] = TALLY_FREE;
continue;
}
m_UFI->GetBlob(Slot, BlobVec_Minus + 5*QPos);
byte T = BlobVec_Minus[5*QPos];
if (T != TALLY_BOTH1)
continue;
uint32 SeedPosDB = *(uint32 *) (BlobVec_Minus + 5*QPos + 1);
dpscore Score = ExtendPen(QPos, SeedPosDB, false);
if (Score >= MinScorePhase1)
{
m_Mapq = CalcMAPQ6();
return;
}
}
}
// ========================== Start Phase 2 =============================
// Extend BOTH1 seeds not tried in Phase 1
for (uint32 QPos = 0; QPos < QWordCount; ++QPos)
{
if (QPos%m_WordLength == 0)
continue;
{// Plus
uint64 Slot = SlotsVec_Plus[QPos];
if (Slot == UINT64_MAX)
{
BlobVec_Plus[5*QPos] = TALLY_FREE;
goto Minus2;
}
m_UFI->GetBlob(Slot, BlobVec_Plus + 5*QPos);
byte T = BlobVec_Plus[5*QPos];
if (T != TALLY_BOTH1)
goto Minus2;
uint32 SeedPosDB = *(uint32 *) (BlobVec_Plus + 5*QPos + 1);
dpscore Score = ExtendPen(QPos, SeedPosDB, true);
if (Score >= MinScorePhase1)
{
m_Mapq = CalcMAPQ6();
return;
}
}
Minus2:
{// Minus
uint64 Slot = SlotsVec_Minus[QPos];
if (Slot == UINT64_MAX)
{
BlobVec_Minus[5*QPos] = TALLY_FREE;
continue;
}
m_UFI->GetBlob(Slot, BlobVec_Minus + 5*QPos);
byte T = BlobVec_Minus[5*QPos];
if (T != TALLY_BOTH1)
continue;
uint32 SeedPosDB = *(uint32 *) (BlobVec_Minus + 5*QPos + 1);
dpscore Score = ExtendPen(QPos, SeedPosDB, false);
if (Score >= MinScorePhase1)
{
m_Mapq = CalcMAPQ6();
return;
}
}
}
// ========================== End Phase 2 =============================
// ========================== Start Phase 3 =============================
// Extend high-scoring HSPs from Phases 1 & 2
// if (m_BestHSPScore > dpscore(QL)/2)
if (m_BestHSPScore > TermHSPScorePhase3)
{
for (unsigned i = 0; i < m_HSPCount; ++i)
AlignHSP(i);
if (m_BestScore >= MinScorePhase1)
{
m_Mapq = CalcMAPQ6();
return;
}
}
// ========================== End Phase 3 =============================
// ========================== Start Phase 4 =============================
// Extend seeds with ab<=2 except BOTH1.
// Save HSPs for later gapped extension.
uint32 *PosVec = alloc_buff(uint32, m_UFI->m_MaxIx);
unsigned TodoCount_Plus = 0;
uint32 *QPosTodoVec_Plus = alloc_buff(uint32, QL);
{//plus
for (uint32 QPos = 0; QPos < QWordCount; ++QPos)
{
byte T = BlobVec_Plus[5*QPos];
if (T == TALLY_FREE || T == TALLY_BOTH1 || TallyOther(T))
continue;
uint64 Slot = SlotsVec_Plus[QPos];
unsigned RowLength = m_UFI->GetRow_Blob(Slot, BlobVec_Plus + 5*QPos, PosVec);
if (RowLength > 2)
{
QPosTodoVec_Plus[TodoCount_Plus] = QPos;
++TodoCount_Plus;
continue;
}
for (unsigned RowIndex = 0; RowIndex < RowLength; ++RowIndex)
{
uint32 SeedPosDB = PosVec[RowIndex];
ExtendPen(QPos, SeedPosDB, true);
}
} // end for QPos
} // end plus
unsigned TodoCount_Minus = 0;
uint32 *QPosTodoVec_Minus = alloc_buff(uint32, QL);
{//minus
for (uint32 QPos = 0; QPos < QWordCount; ++QPos)
{
byte T = BlobVec_Minus[5*QPos];
if (T == TALLY_FREE || T == TALLY_BOTH1 || TallyOther(T))
continue;
uint64 Slot = SlotsVec_Minus[QPos];
unsigned RowLength = m_UFI->GetRow_Blob(Slot, BlobVec_Minus + 5*QPos, PosVec);
if (RowLength > 2)
{
QPosTodoVec_Minus[TodoCount_Minus] = QPos;
++TodoCount_Minus;
continue;
}
for (unsigned RowIndex = 0; RowIndex < RowLength; ++RowIndex)
{
uint32 SeedPosDB = PosVec[RowIndex];
ExtendPen(QPos, SeedPosDB, false);
}
} // end for QPos
} // end minus
if (m_BestScore >= MinScorePhase3)
{
m_Mapq = CalcMAPQ6();
return;
}
// ========================== End Phase 4 =============================
// ========================== Start Phase 5 =============================
// Extend all other seeds, i.e. with ab>=2
// Save HSPs for later gapped extension.
{ // plus
for (unsigned TodoIndex = 0; TodoIndex < TodoCount_Plus; ++TodoIndex)
{
uint32 QPos = QPosTodoVec_Plus[TodoIndex];
uint64 Slot = SlotsVec_Plus[QPos];
unsigned RowLength = m_UFI->GetRow_Blob(Slot, BlobVec_Plus + 5*QPos, PosVec);
for (unsigned RowIndex = 0; RowIndex < RowLength; ++RowIndex)
{
uint32 SeedPosDB = PosVec[RowIndex];
ExtendPen(QPos, SeedPosDB, true);
}
} // end for TodoIndex
} // end plus
{ // minus
for (unsigned TodoIndex = 0; TodoIndex < TodoCount_Minus; ++TodoIndex)
{
uint32 QPos = QPosTodoVec_Minus[TodoIndex];
uint64 Slot = SlotsVec_Minus[QPos];
unsigned RowLength = m_UFI->GetRow_Blob(Slot, BlobVec_Minus + 5*QPos, PosVec);
for (unsigned RowIndex = 0; RowIndex < RowLength; ++RowIndex)
{
uint32 SeedPosDB = PosVec[RowIndex];
ExtendPen(QPos, SeedPosDB, false);
}
} // end for TodoIndex
} // end minus
// ========================== End Phase 5 =============================
if (m_BestScore >= MinScorePhase4)
{
m_Mapq = CalcMAPQ6();
return;
}
// ========================== Start Phase 6 =============================
// Align HSPs found in previous phases
for (unsigned i = 0; i < m_HSPCount; ++i)
AlignHSP(i);
// ========================== End Phase 6 =============================
m_Mapq = CalcMAPQ6();
}
| 7,605
|
C++
|
.cpp
| 257
| 26.715953
| 80
| 0.617358
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,015
|
search1.cpp
|
rcedgar_urmap/src/search1.cpp
|
#include "myutils.h"
#include "ufindex.h"
#include "state1.h"
#include "seqinfo.h"
#include "omplock.h"
void State1::Search(SeqInfo *Query)
{
m_Query = Query;
Lock();
++m_QueryCount;
Unlock();
m_HitCount = 0;
m_HSPCount = 0;
m_TopHit = 0;
m_BestScore = 0;
m_SecondBestScore = 0;
m_Mapq = -1;
Search_Lo();
SetMappedPos();
// Output1();
}
void State1::Search_PE(SeqInfo *Query)
{
m_Query = Query;
m_HitCount = 0;
m_HSPCount = 0;
m_TopHit = 0;
m_BestScore = 0;
m_SecondBestScore = 0;
m_Mapq = -1;
Search_Lo();
}
| 538
|
C++
|
.cpp
| 32
| 14.90625
| 38
| 0.666667
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,016
|
scan.cpp
|
rcedgar_urmap/src/scan.cpp
|
#include "myutils.h"
#include "ufindex.h"
#include "seqinfo.h"
#include "alpha.h"
#include "state1.h"
#include "alignresult.h"
#include "pathinfo.h"
#include "alnparams.h"
#include <inttypes.h>
void LogAlnPretty(const byte *A, const byte *B, const char *Path,
bool StripTermGaps);
void State1::Scan(uint32 DBPos, unsigned DBSegLength, bool Plus, bool DoVit)
{
int SavedMaxPenalty = m_MaxPenalty;
unsigned SavedHitCount = m_HitCount;
m_MaxPenalty = 130;//@@TODO
ScanSlots(DBPos, DBSegLength, Plus);
m_MaxPenalty = SavedMaxPenalty;
if (m_HitCount > SavedHitCount)
return;
if (!DoVit)
return;
const byte *Q = (Plus ? m_Query->m_Seq : m_RevCompQuerySeq.Data);
const unsigned QL = m_Query->m_L;
const byte *T = m_UFI->m_SeqData + DBPos;
const unsigned TL = DBSegLength;
float Score = Viterbi(Q, QL, T, TL, true, true, *m_PI);
if (Score >= QL/3.0) // TODO:PARAM
{
unsigned LeftICount = m_PI->TrimLeftIs();
m_PI->TrimRightIs();
unsigned StartPosDB = DBPos + LeftICount;
AddHitX(StartPosDB, Plus, int(Score), m_PI->GetPath());
}
}
| 1,060
|
C++
|
.cpp
| 35
| 28.228571
| 76
| 0.717924
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,017
|
outputtab2.cpp
|
rcedgar_urmap/src/outputtab2.cpp
|
#include "myutils.h"
#include "state2.h"
#include "outfiles.h"
#include "omplock.h"
void State2::GetInfoStr(string &s) const
{
s.clear();
if (GetTopHit1() == 0 || GetTopHit2() == 0 || GetSecondHit1() == 0 || GetSecondHit2() == 0)
return;
unsigned TopTL = GetTemplateLength(GetTopHit1(), GetTopHit2());
unsigned SecondTL = GetTemplateLength(GetSecondHit1(), GetSecondHit2());
if (TopTL == SecondTL)
Psasc(s, "TL=%u", TopTL, SecondTL);
else
Psasc(s, "TL/%u,%u", TopTL, SecondTL);
int TopScore = GetTopHit1()->m_Score + GetTopHit2()->m_Score;
int SecondScore = GetSecondHit1()->m_Score + GetSecondHit2()->m_Score;
if (TopScore == SecondScore)
Psasc(s, "Score=%d", TopScore);
else
Psasc(s, "Score/%d,%d", TopScore, SecondScore);
}
void State2::GetPairPosStr1(const UFIHit *Hit, bool Fwd, string &s) const
{
asserta(Hit != 0);
string ChrLabel;
uint32 ChrPos;
GetChrPos(Hit, ChrLabel, ChrPos);
char OneOrTwo = (Fwd ? '1' : '2');
char Strand = pom(Hit->m_Plus);
Ps(s, "%s:%u(%c)/%c", ChrLabel.c_str(), ChrPos+1, Strand, OneOrTwo);
}
void State2::GetPairPosStr(const UFIHit *Hit1, const UFIHit *Hit2, string &s) const
{
if (Hit1 == 0 && Hit2 == 0)
{
s = "*";
return;
}
if (Hit1 != 0 && Hit2 == 0)
{
GetPairPosStr1(Hit1, true, s);
return;
}
if (Hit1 == 0 && Hit2 != 0)
{
GetPairPosStr1(Hit2, false, s);
return;
}
string ChrLabel1;
string ChrLabel2;
uint32 ChrPos1;
uint32 ChrPos2;
GetChrPos(Hit1, ChrLabel1, ChrPos1);
GetChrPos(Hit2, ChrLabel2, ChrPos2);
if (ChrLabel1 == ChrLabel2 && Hit1->m_Plus != Hit2->m_Plus)
{
char Strand = pom(Hit1->m_Plus);
Ps(s, "%s:%u-%u", ChrLabel1.c_str(), ChrPos1+1, ChrPos2+1);
return;
}
string s1;
string s2;
GetPairPosStr1(Hit1, true, s1);
GetPairPosStr1(Hit2, false, s2);
s = s1 + "," + s2;
}
void State2::OutputTab2()
{
if (g_fTab == 0)
return;
string PairLabel;
m_UD_Fwd.GetPairLabel(PairLabel);
string sTop;
GetPairPosStr(GetTopHit1(), GetTopHit2(), sTop);
string sSecond = "*";
string InfoStr;
if (GetSecondHit1() != 0)
{
asserta(GetSecondHit2() != 0);
GetPairPosStr(GetSecondHit1(), GetSecondHit2(), sSecond);
}
GetInfoStr(InfoStr);
Lock();
fputs(PairLabel.c_str(), g_fTab);
fputc('\t', g_fTab);
fputs(sTop.c_str(), g_fTab);
fputc('\t', g_fTab);
fprintf(g_fTab, "%u,%u", m_UD_Fwd.m_Mapq, m_UD_Rev.m_Mapq);
fputc('\t', g_fTab);
fputs(sSecond.c_str(), g_fTab);
if (!InfoStr.empty())
{
fputc('\t', g_fTab);
fputs(InfoStr.c_str(), g_fTab);
}
fputc('\n', g_fTab);
Unlock();
}
| 2,545
|
C++
|
.cpp
| 99
| 23.262626
| 92
| 0.658969
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,018
|
map.cpp
|
rcedgar_urmap/src/map.cpp
|
#include "myutils.h"
#include "ufindex.h"
#include "objmgr.h"
#include "seqinfo.h"
#include "fastqseqsource.h"
#include <inttypes.h>
#include "state1.h"
#include "sort.h"
#include "outfiles.h"
static void MapThread(const UFIndex &UFI, FASTQSeqSource &FSS)
{
State1 UD;
UD.SetUFI(UFI);
SeqInfo *Query = ObjMgr::GetSeqInfo();
for (;;)
{
bool Ok = FSS.GetNext(Query);
if (!Ok)
break;
UD.Search(Query);
UD.Output1();
}
}
void cmd_map()
{
const string &FileName = opt(map);
void InitGlobals(bool Nucleo);
InitGlobals(true);
unsigned Method = 6;
if (opt(veryfast))
Method = 7;
State1::SetMethod(Method);
FASTQSeqSource FSS;
FSS.Open(FileName);
UFIndex UFI;
UFI.FromFile(opt(ufi));
State1::WriteSAMHeader(g_fSAM, UFI);
if (opt(veryfast) && UFI.m_MaxIx > 3)
Warning("index not optimal for -veryfast");
unsigned ThreadCount = GetRequestedThreadCount();
Progress("%u threads\n", ThreadCount);
Progress("Mapping %s\n", FileName.c_str());
State1::m_StartSecs = GetElapsedSecs();
if (FSS.m_LR.m_gz)
Progress("Mapping unpaired %s\n", FileName.c_str());
else
ProgressFile(FSS.m_LR.m_f, "Mapping unpaired ", FileName);
#pragma omp parallel num_threads(ThreadCount)
{
MapThread(UFI, FSS);
}
if (!FSS.m_LR.m_gz)
ProgressDone();
ProgressSetMsg("Closing");
State1::HitStats();
}
| 1,327
|
C++
|
.cpp
| 56
| 21.482143
| 62
| 0.715079
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,019
|
fileseqsource.cpp
|
rcedgar_urmap/src/fileseqsource.cpp
|
#include "myutils.h"
#include "fileseqsource.h"
FileSeqSource::FileSeqSource()
{
m_StripGaps = !opt(keepgaps);
memset_zero(m_BadByteCounts, 256);
}
FileSeqSource::~FileSeqSource()
{
m_LR.Close();
}
void FileSeqSource::Open(const string &FileName)
{
m_LR.Open(FileName);
}
void FileSeqSource::Close()
{
m_LR.Close();
m_LineBuff.Free();
}
bool FileSeqSource::ReadLine()
{
return m_LR.ReadLine(m_LineBuff);
}
void FileSeqSource::BadByte(byte c)
{
++m_BadByteCounts[c];
}
void FileSeqSource::ReportBadBytes()
{
unsigned Total = 0;
for (unsigned c = 0; c < 256; ++c)
{
unsigned n = m_BadByteCounts[c];
if (n == 0)
continue;
if (Total == 0)
{
Log("\n");
Log("Invalid bytes in sequence data:\n");
Log("Byte Char N\n");
Log("---- ---- ----------\n");
}
Log("0x%02x %4c %10u\n", c, c, n);
Total += n;
}
}
| 877
|
C++
|
.cpp
| 47
| 16.255319
| 48
| 0.629405
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| true
| false
| true
| false
|
1,538,020
|
urmap_main.cpp
|
rcedgar_urmap/src/urmap_main.cpp
|
#include "myutils.h"
#include "cmd.h"
#include "alpha.h"
#include "outfiles.h"
int main(int argc, char **argv)
{
// setbuf(stdout, 0);
setbuf(stderr, 0);
MyCmdLine(argc, argv);
if (!opt(quiet))
{
PrintProgramInfo(stderr);
PrintCopyright(stderr);
}
SetLogFileName(opt(log));
LogProgramInfoAndCmdLine();
Progress_Init();
InitAlpha();
OpenOutputFiles();
CMD Cmd = GetCmd();
switch (Cmd)
{
#define A(x) case CMD_##x: { void cmd_##x(); cmd_##x(); break; }
#include "cmds.h"
default:
asserta(false);
}
ProgressSetMsg("Closing");
CloseOutputFiles();
CheckUsedOpts(opt_log_used_opts);
LogElapsedTimeAndRAM();
Progress_OnExit();
return 0;
}
| 672
|
C++
|
.cpp
| 34
| 17.588235
| 64
| 0.700475
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,021
|
setsam.cpp
|
rcedgar_urmap/src/setsam.cpp
|
#include "myutils.h"
#include "ufindex.h"
#include "seqinfo.h"
#include "alpha.h"
#include "state1.h"
#include "ufihit.h"
#include "alignresult.h"
#include "sort.h"
#include "omplock.h"
#include "cigar.h"
void State1::SetSAM_Unmapped(uint32 aFlags)
{
uint32 Flags = 0x04; // unmapped
if (aFlags & 0x01) // multiseg
Flags |= 0x01;
if (aFlags & 0x40) // first
Flags |= 0x40;
else if (aFlags & 0x80) // second
Flags |= 0x80;
if (aFlags & 0x08) // mate unmapped
Flags |= 0x08;
else if (aFlags & 0x20) // mate revcomp'd
Flags |= 0x20;
m_Mapq = 0;
unsigned QL = m_Query->m_L;
m_SAM.Alloc(3*max(QL, 200u));
char *p = m_SAM.Data;
const char *Label = m_Query->m_Label;
unsigned n = ustrlen(Label);
if (n > 2 && Label[n-2] == '/' && (Label[n-1] == '1' || Label[n-1] == '2'))
n -= 2;
for (unsigned i = 0; i < n; ++i)
{
char c = Label[i];
if (c == ' ' || c == '\t')
break;
*p++ = c;
}
*p++ = '\t';
char Tmp[16];
sprintf(Tmp, "%u", Flags);
n = ustrlen(Tmp);
for (unsigned i = 0; i < n; ++i)
*p++ = Tmp[i];
const char s[] = " * 0 0 * * 0 0 ";
n = sizeof(s) - 1;
memcpy(p, s, n);
p += n;
memcpy(p, m_Query->m_Seq, QL);
p += QL;
*p++ = '\t';
const char *Qual = m_Query->m_Qual;
if (Qual == 0)
*p++ = '*';
else
{
memcpy(p, Qual, QL);
p += QL;
}
*p++ = '\n';
*p = 0;
m_SAM.Size = unsigned(p - m_SAM.Data);
}
void State1::SetSAM(uint32 Flags, const string &MateTargetLabel,
const uint32 MateTargetPos, int TLEN)
{
if (m_TopHit == 0)
{
SetSAM_Unmapped(Flags);
return;
}
unsigned QL = m_Query->m_L;
m_SAM.Alloc(3*max(QL, 200u));
char *p = m_SAM.Data;
const char *Label = m_Query->m_Label;
unsigned n = ustrlen(Label);
if (n > 2 && Label[n-2] == '/' && (Label[n-1] == '1' || Label[n-1] == '2'))
n -= 2;
for (unsigned i = 0; i < n; ++i)
{
char c = Label[i];
if (c == ' ' || c == '\t')
break;
*p++ = c;
}
*p++ = '\t';
bool Plus = m_TopHit->m_Plus;
char Tmp[16];
sprintf(Tmp, "%u", Flags);
n = ustrlen(Tmp);
for (unsigned i = 0; i < n; ++i)
*p++ = Tmp[i];
*p++ = '\t';
//string TargetLabel;
//unsigned TargetLo;
//m_TopHit->GetStartCoord(TargetLabel, TargetLo);
if (m_MappedTargetPos == UINT32_MAX)
{
SetSAM_Unmapped(Flags);
return;
}
n = SIZE(m_MappedTargetLabel);
memcpy(p, m_MappedTargetLabel.c_str(), n);
p += n;
*p++ = '\t';
sprintf(Tmp, "%u", m_MappedTargetPos+1);
n = ustrlen(Tmp);
memcpy(p, Tmp, n);
p += n;
*p++ = '\t';
sprintf(Tmp, "%u", m_Mapq);
n = ustrlen(Tmp);
memcpy(p, Tmp, n);
p += n;
*p++ = '\t';
if (m_TopHit->m_Path.empty())
{
sprintf(Tmp, "%d", QL);
n = ustrlen(Tmp);
memcpy(p, Tmp, n);
p += n;
*p++ = 'M';
}
else
{
string CIGAR;
GetCIGAR(CIGAR);
n = ustrlen(CIGAR);
memcpy(p, CIGAR.c_str(), n);
p += n;
}
*p++ = '\t';
if (MateTargetLabel == "" || MateTargetLabel == "*")
*p++ = '*';
else if (MateTargetLabel == m_MappedTargetLabel)
*p++ = '=';
else
{
n = ustrlen(MateTargetLabel);
memcpy(p, MateTargetLabel.c_str(), n);
p += n;
}
*p++ = '\t';
if (MateTargetPos == 0 || MateTargetPos == UINT32_MAX)
*p++ = '0';
else
{
sprintf(Tmp, "%u", MateTargetPos+1);
n = ustrlen(Tmp);
memcpy(p, Tmp, n);
p += n;
}
*p++ = '\t';
sprintf(Tmp, "%d", TLEN);
n = ustrlen(Tmp);
memcpy(p, Tmp, n);
p += n;
*p++ = '\t';
const byte *Seq = (Plus ? m_Query->m_Seq : m_RevCompQuerySeq.Data);
memcpy(p, Seq, QL);
p += QL;
*p++ = '\t';
const char *Qual = m_Query->m_Qual;
if (Qual ==0)
*p++ = '*';
else
{
if (Plus)
{
memcpy(p, Qual, QL);
p += QL;
}
else
{
for (unsigned i = 1; i <= QL; ++i)
*p++ = Qual[QL-i];
}
}
*p++ = '\n';
*p = 0;
m_SAM.Size = unsigned(p - m_SAM.Data);
}
| 3,727
|
C++
|
.cpp
| 182
| 17.928571
| 76
| 0.550284
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,022
|
viterbi.cpp
|
rcedgar_urmap/src/viterbi.cpp
|
#include "myutils.h"
#include "diagbox.h"
#include "alnparams.h"
#include "tracebit.h"
#include "pathinfo.h"
#include "state1.h"
#include "xdpmem.h"
void TraceBackBitMem(XDPMem &m_XDPMem, unsigned LA, unsigned LB, char State, PathInfo &PI);
float State1::Viterbi(const byte *A, unsigned LA,
const byte *B, unsigned LB, bool Left, bool Right, PathInfo &PI)
{
if (LA == 0 || LB == 0)
{
if (LA == 0 && LB == 0)
{
PI.SetEmpty();
return 0.0f;
}
if (LA == 0 && LB > 0)
{
PI.Alloc(LB+1);
PI.AppendIs(LB);
float Score = float(GAP_OPEN_SCORE + (LB-1)*GAP_EXT_SCORE);
return Score;
}
if (LA > 0 && LB == 0)
{
PI.Alloc(LA+1);
PI.AppendDs(LA);
float Score = float(GAP_OPEN_SCORE + (LA-1)*GAP_EXT_SCORE);
return Score;
}
Die("Viterbi LA=%u LB=%u", LA, LB);
}
// Main diagonal
// d = LA - i + j = 1 .. LA+LB-1
// Left term: i=0,j=0 d=LA
// Right term: i=LA-1,j=LB-1 d=LA-(LA-1)+(LB-1) = LB
unsigned DiagLo = min(LA, LB);
unsigned DiagHi = max(LA, LB);
asserta(DiagLo <= DiagHi);
if (DiagLo > GLOBAL_BAND_RADIUS)
DiagLo -= GLOBAL_BAND_RADIUS;
else
DiagLo = 1;
DiagHi += GLOBAL_BAND_RADIUS;
unsigned MaxDiag = LA + LB - 1;
if (DiagHi > MaxDiag)
DiagHi = MaxDiag;
// Verify diagonal range includes terminals
DiagBox Box(LA, LB, DiagLo, DiagHi);
asserta(Box.InBox(0, 0));
asserta(Box.InBox(LA-1, LB-1));
m_XDPMem.Alloc(LA, LB);
PI.Alloc2(LA, LB);
float OpenA = float(GAP_OPEN_SCORE);
float ExtA = float(GAP_EXT_SCORE);
if (Left)
{
OpenA = 0;
ExtA = 0;
}
float *Mrow = m_XDPMem.GetDPRow1();
float *Drow = m_XDPMem.GetDPRow2();
byte **TB = m_XDPMem.GetTBBit();
// Use Mrow[j-1] when j=0, so...
Mrow[-1] = MINUS_INFINITY;
// ? Surely don't need to initialize all entries in vector
for (unsigned j = 0; j <= LB; ++j)
{
Mrow[j] = MINUS_INFINITY;
Drow[j] = MINUS_INFINITY;
}
// Main loop
for (unsigned i = 0; i < LA; ++i)
{
unsigned Startj, Endj;
Box.GetRange_j(i, Startj, Endj);
if (Endj == 0)
{
static bool WarningDone = false;
if (!WarningDone)
{
Warning("Endj==0");
WarningDone = true;
}
continue;
}
//float OpenB = Startj == 0 ? AP.LOpenB : AP.OpenB;
//float ExtB = Startj == 0 ? AP.LExtB : AP.ExtB;
float OpenB = float((Startj == 0 && Left) ? 0 : GAP_OPEN_SCORE);
float ExtB = float((Startj == 0 && Left) ? 0 : GAP_EXT_SCORE);
byte a = A[i];
float I0 = MINUS_INFINITY;
float M0;
if (i == 0)
M0 = 0;
else
{
if (Startj == 0)
M0 = MINUS_INFINITY;
else
M0 = Mrow[int(Startj)-1];
}
byte *TBrow = TB[i];
if (Startj > 0)
TBrow[int(Startj)-1] = TRACEBITS_IM;
for (unsigned j = Startj; j < Endj; ++j)
{
byte b = B[j];
byte TraceBits = 0;
float SavedM0 = M0;
// MATCH
{
// M0 = DPM[i][j]
// I0 = DPI[i][j]
// Drow[j] = DPD[i][j]
float xM = M0;
if (Drow[j] > xM)
{
xM = Drow[j];
TraceBits = TRACEBITS_DM;
}
if (I0 > xM)
{
xM = I0;
TraceBits = TRACEBITS_IM;
}
M0 = Mrow[j];
Mrow[j] = xM + (a == b ? 1 : MISMATCH_SCORE);
// Mrow[j] = DPM[i+1][j+1])
}
// DELETE
{
// SavedM0 = DPM[i][j]
// Drow[j] = DPD[i][j]
float md = SavedM0 + OpenB;
Drow[j] += ExtB;
if (md >= Drow[j])
{
Drow[j] = md;
TraceBits |= TRACEBITS_MD;
}
// Drow[j] = DPD[i+1][j]
}
// INSERT
{
// SavedM0 = DPM[i][j]
// I0 = DPI[i][j]
float mi = SavedM0 + OpenA;
I0 += ExtA;
if (mi >= I0)
{
I0 = mi;
TraceBits |= TRACEBITS_MI;
}
// I0 = DPI[i][j+1]
}
OpenB = float(GAP_OPEN_SCORE);
ExtB = float(GAP_EXT_SCORE);
TBrow[j] = TraceBits;
}
// Special case for end of Drow[]
{
// M0 = DPM[i][LB]
// Drow[LB] = DPD[i][LB]
TBrow[LB] = 0;
float md = M0 + GAP_OPEN_SCORE;
Drow[LB] += GAP_EXT_SCORE;
if (md >= Drow[LB])
{
Drow[LB] = md;
TBrow[LB] = TRACEBITS_MD;
}
// Drow[LB] = DPD[i+1][LB]
}
M0 = MINUS_INFINITY;
OpenA = float(GAP_OPEN_SCORE);
ExtA = float(GAP_EXT_SCORE);
}
unsigned Startj, Endj;
Box.GetRange_j(LA-1, Startj, Endj);
asserta(Endj == LB);
// Special case for last row of DPI
byte *TBrow = TB[LA];
float I1 = MINUS_INFINITY;
Mrow[int(Startj)-1] = MINUS_INFINITY;
float GapOp = float(GAP_OPEN_SCORE);
float GapEx = float(GAP_EXT_SCORE);
if (Right)
{
GapOp = 0;
GapEx = 0;
}
for (unsigned j = Startj; j < Endj; ++j)
{
// Mrow[j-1] = DPM[LA][j]
// I1 = DPI[LA][j]
TBrow[j] = 0;
// float mi = Mrow[int(j)-1] + AP.ROpenA;
// I1 += AP.RExtA;
float mi = Mrow[int(j)-1] + GapOp;
I1 += GapEx;
if (mi > I1)
{
I1 = mi;
TBrow[j] = TRACEBITS_MI;
}
}
float FinalM = Mrow[LB-1];
float FinalD = Drow[LB];
float FinalI = I1;
// FinalM = DPM[LA][LB]
// FinalD = DPD[LA][LB]
// FinalI = DPI[LA][LB]
float Score = FinalM;
byte State = 'M';
if (FinalD > Score)
{
Score = FinalD;
State = 'D';
}
if (FinalI > Score)
{
Score = FinalI;
State = 'I';
}
TraceBackBitMem(m_XDPMem, LA, LB, State, PI);
return Score;
}
#if 0
static void Test(const char *Q, const char *T, bool Left)
{
State1 UD;
PathInfo *PI = ObjMgr::GetPathInfo();
void LogAlnPretty(const byte *A, const byte *B, const char *Path,
bool StripTermGaps);
float Score = UD.Viterbi((const byte *) Q, ustrlen(Q),
(const byte *) T, ustrlen(T), Left, *PI);
unsigned M, D, I;
PI->GetCounts(M, D, I);
Log("============================= %s %.1f =====================\n",
Left ? "Left" : "Right", Score);
Log("\n");
Log("%s\n", PI->GetPath());
Log("M %d, D %u, I %u\n", M, D, I);
LogAlnPretty((const byte *) Q, (const byte *) T, PI->GetPath(), false);
}
void cmd_test()
{
opt(test);
const char *Q = "GGGGATTAC";
const char *T = "GGGGATTACA";
Test(Q, T, true);
Test(Q, T, false);
Q = "GGGGATT";
T = "GGGGATTACA";
Test(Q, T, true);
Test(Q, T, false);
Q = "GGATTACA";
T = "GGGGATTACA";
Test(Q, T, true);
Test(Q, T, false);
}
#endif // 0
| 5,974
|
C++
|
.cpp
| 265
| 19.384906
| 91
| 0.580113
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,023
|
xdropfwdsplit.cpp
|
rcedgar_urmap/src/xdropfwdsplit.cpp
|
#include "myutils.h"
#include "tracebit.h"
#include "xtype.h"
#include "hsp.h"
#include "alnparams.h"
#include "xdpmem.h"
#include "objmgr.h"
#include "pathinfo.h"
#define TRACE 0
float XDropFwdFastMem(XDPMem &Mem, const byte *A, unsigned LA, const byte *B, unsigned LB,
const AlnParams &AP, float X, unsigned &Leni, unsigned &Lenj, PathInfo &PI);
unsigned GetSubL(unsigned L)
{
if (L <= g_MaxL)
return L;
if (L < 2*g_MaxL)
return L/2;
return g_MaxL;
}
float XDropFwdSplit(XDPMem &Mem, const byte *A, unsigned LA, const byte *B, unsigned LB,
const AlnParams &AP, float X, unsigned &Leni, unsigned &Lenj, PathInfo &PI)
{
#if TRACE
Log("\n");
Log("XDropFwdSplit\n");
Log("A %5u %*.*s\n", LA, LA, LA, A);
Log("B %5u %*.*s\n", LB, LB, LB, B);
#endif
Leni = 0;
Lenj = 0;
PI.SetEmpty();
PathInfo *SubPI = ObjMgr::GetPathInfo();
float SumScore = 0.0f;
for (;;)
{
if (Leni == LA || Lenj == LB)
break;
asserta(Leni < LA);
asserta(Lenj < LB);
const byte *SubA = A + Leni;
const byte *SubB = B + Lenj;
unsigned SubLA = GetSubL(LA - Leni);
unsigned SubLB = GetSubL(LB - Lenj);
#if TRACE
Log("\n");
Log("Leni %u, Lenj %u, SubLA %u, SubLB %u\n", Leni, Lenj, SubLA, SubLB);
#endif
unsigned SubLeni, SubLenj;
float Score = XDropFwdFastMem(Mem, SubA, SubLA, SubB, SubLB, AP, X, SubLeni, SubLenj, *SubPI);
#if TRACE
Log("XDropFwdFastMem=%.1f SubLeni=%u SubLenj=%u\n", Score, SubLeni, SubLenj);
if (Score > 0.0f)
LogAln(SubA, SubB, SubPI->m_Path);
#endif
if (Score == 0.0f)
break;
SumScore += Score;
Leni += SubLeni;
Lenj += SubLenj;
PI.AppendPath(*SubPI);
if (SubLeni < SubLA && SubLenj < SubLB)
break;
asserta(SubLeni == SubLA || SubLenj == SubLB);
}
ObjMgr::Down(SubPI);
#if DEBUG
{
unsigned M, D, I;
PI.GetCounts(M, D, I);
asserta(M + D == Leni);
asserta(M + I == Lenj);
}
#endif
return SumScore;
}
| 1,889
|
C++
|
.cpp
| 75
| 22.786667
| 96
| 0.656841
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,024
|
xdropalignmem.cpp
|
rcedgar_urmap/src/xdropalignmem.cpp
|
#include "myutils.h"
#include "tracebit.h"
#include "xtype.h"
#include "hsp.h"
#include "alnparams.h"
#include "alnheuristics.h"
#include "xdpmem.h"
#include "objmgr.h"
#include "pathinfo.h"
#include "seqdb.h" // for test only
#define TRACE 0
float XDropFwdFastMem(XDPMem &Mem, const byte *A, unsigned LA, const byte *B, unsigned LB,
const AlnParams &AP, float X, unsigned &Leni, unsigned &Lenj, PathInfo &PI);
float XDropBwdFastMem(XDPMem &Mem, const byte *A, unsigned LA, const byte *B, unsigned LB,
const AlnParams &AP, float X, unsigned &Leni, unsigned &Lenj, PathInfo &PI);
float XDropFwdSplit(XDPMem &Mem, const byte *A, unsigned LA, const byte *B, unsigned LB,
const AlnParams &AP, float X, unsigned &Leni, unsigned &Lenj, PathInfo &PI);
float XDropBwdSplit(XDPMem &Mem, const byte *A, unsigned LA, const byte *B, unsigned LB,
const AlnParams &AP, float X, unsigned &Leni, unsigned &Lenj, PathInfo &PI);
static float XDropAlignMemMaxL2(XDPMem &Mem, const byte *A, unsigned LA, const byte *B, unsigned LB,
unsigned AncLoi, unsigned AncLoj, unsigned AncLen, const AlnParams &AP,
float X, HSPData &HSP, PathInfo &PI, double MaxL2)
{
#if TRACE
Log("\n");
Log("XDropAlignMemMaxL2()\n");
Log("Anchor A %*.*s %u - %u\n", AncLen, AncLen, A + AncLoi, AncLoi, AncLoi + AncLen - 1);
Log("Anchor B %*.*s %u - %u\n", AncLen, AncLen, B + AncLoj, AncLoj, AncLoj + AncLen - 1);
Log(">A;AncLoi=%u;AncLoj=%u;AncLen=%u;\n", AncLoi, AncLoj, AncLen);
Log("%*.*s\n", LA, LA, A);
Log(">B\n");
Log("%*.*s\n", LB, LB, B);
Log("\n");
#endif
if (AncLen <= 1)
{
HSP.Score = 0.0f;
PI.SetEmpty();
return 0.0f;
}
asserta(AncLoi < LA);
asserta(AncLoj < LB);
asserta(AncLoi + AncLen <= LA);
asserta(AncLoj + AncLen <= LB);
asserta(LA > 0 && LB > 0);
PI.SetEmpty();
unsigned AncHii = AncLoi + AncLen - 1;
unsigned AncHij = AncLoj + AncLen - 1;
asserta(AncHii < LA);
asserta(AncHij < LB);
PathInfo *FwdPI = ObjMgr::GetPathInfo();
PathInfo *BwdPI = ObjMgr::GetPathInfo();
const byte *FwdA = A + AncHii;
const byte *FwdB = B + AncHij;
unsigned FwdLA = LA - AncHii;
unsigned FwdLB = LB - AncHij;
unsigned BwdLeni, BwdLenj;
float BwdScore = 0.0f;
if (AncLoi > g_MaxL || AncLoj > g_MaxL)
{
BwdScore = XDropBwdSplit(Mem, A, AncLoi+1, B, AncLoj+1, AP, X, BwdLeni, BwdLenj, *BwdPI);
#if TRACE
Log("\n");
Log("XDropBwdSplit:\n");
LogAln(A + AncLoi + 1, B + AncLoj + 1, BwdPI->GetPath());
#endif
}
else
{
BwdScore = XDropBwdFastMem(Mem, A, AncLoi+1, B, AncLoj+1, AP, X, BwdLeni, BwdLenj, *BwdPI);
#if TRACE
Log("\n");
Log("XDropBwdFastMem:\n");
LogAln(A + AncLoi + 1, B + AncLoj + 1, BwdPI->GetPath());
#endif
}
#if DEBUG
{
unsigned M, D, I;
BwdPI->GetCounts(M, D, I);
asserta(M + D == BwdLeni);
asserta(M + I == BwdLenj);
}
#endif
PI.AppendPath(*BwdPI);
unsigned FwdLeni, FwdLenj;
float FwdScore = 0.0f;
if (FwdLA > g_MaxL || FwdLB > g_MaxL)
{
FwdScore = XDropFwdSplit(Mem, FwdA, FwdLA, FwdB, FwdLB, AP, X, FwdLeni, FwdLenj, *FwdPI);
#if TRACE
Log("\n");
Log("XDropFwdSplit FwdLA=%u, FwdLB=%u:\n", FwdLA, FwdLB);
LogAln(FwdA, FwdB, FwdPI->GetPath());
#endif
}
else
{
FwdScore = XDropFwdFastMem(Mem, FwdA, FwdLA, FwdB, FwdLB, AP, X, FwdLeni, FwdLenj, *FwdPI);
#if TRACE
Log("\n");
Log("XDropFwdFastMem FwdLA=%u, FwdLB=%u:\n", FwdLA, FwdLB);
Log("A>%*.*s\n", FwdLA, FwdLA, FwdA);
Log("B>%*.*s\n", FwdLB, FwdLB, FwdB);
LogAln(FwdA, FwdB, FwdPI->GetPath());
#endif
}
#if DEBUG
{
unsigned M, D, I;
FwdPI->GetCounts(M, D, I);
asserta(M + D == FwdLeni);
asserta(M + I == FwdLenj);
}
#endif
// First & last col in anchor are included in xdrop alignmnets
//for (unsigned i = 2; i < AncLen; ++i)
// *PathPtr++ = 'M';
asserta(AncLen >= 2);
PI.AppendMs(AncLen-2);
//for (const char *From = FwdPI->m_Path; *From != 0; ++From)
// *PathPtr++ = *From;
// *PathPtr = 0;
PI.AppendPath(*FwdPI);
const float * const *SubstMx = AP.SubstMx;
float AncScore = 0.0f;
for (unsigned k = 0; k < AncLen; ++k)
{
byte a = A[AncLoi+k];
byte b = B[AncLoj+k];
AncScore += SubstMx[a][b];
}
byte a = A[AncLoi];
byte b = B[AncLoj];
float DupeScore = SubstMx[a][b];
#if TRACE
Log("\n");
Log("Dupe %c%c %.1f\n", a, b, DupeScore);
#endif
if (AncLen > 1)
{
a = A[AncHii];
b = B[AncHij];
DupeScore += SubstMx[a][b];
#if TRACE
Log("Dupe += %c%c %.1f = %.1f\n", a, b, SubstMx[a][b], DupeScore);
#endif
}
HSP.Score = BwdScore + FwdScore + AncScore - DupeScore;
#if TRACE
Log("Total = Bwd(%.1f) + Fwd(%.1f) + Anchor(%.1f) - Dupe(%.1f) = %.1f\n",
BwdScore, FwdScore, AncScore, DupeScore, HSP.Score);
#endif
asserta(AncLoi + 1 >= BwdLeni && AncLoj + 1 >= BwdLenj);
HSP.Loi = AncLoi + 1 - BwdLeni;
HSP.Loj = AncLoj + 1 - BwdLenj;
HSP.Leni = BwdLeni + FwdLeni + AncLen - 2;
HSP.Lenj = BwdLenj + FwdLenj + AncLen - 2;
ObjMgr::Down(FwdPI);
ObjMgr::Down(BwdPI);
FwdPI = 0;
BwdPI = 0;
#if DEBUG
{
unsigned M, D, I;
PI.GetCounts(M, D, I);
asserta(M + D == HSP.Leni);
asserta(M + I == HSP.Lenj);
}
#endif
return HSP.Score;
}
float XDropAlignMem(XDPMem &Mem, const byte *A, unsigned LA, const byte *B, unsigned LB,
unsigned AncLoi, unsigned AncLoj, unsigned AncLen, const AlnParams &AP,
float X, HSPData &HSP, PathInfo &PI)
{
float ScoreSplit = XDropAlignMemMaxL2(Mem, A, LA, B, LB, AncLoi, AncLoj, AncLen, AP,
X, HSP, PI, g_MaxL2);
#if DEBUG
{
unsigned M, D, I;
PI.GetCounts(M, D, I);
if (ScoreSplit > 0.0f && (M + D != HSP.Leni || M + I != HSP.Lenj))
{
Log("A %5u %*.*s\n", LA, LA, LA, A);
Log("B %5u %*.*s\n", LB, LB, LB, B);
Die("PI!=HSP Score %.1f M %u + D %u != HSP.Leni %u || M %u + I %u != HSP.Lenj %u",
ScoreSplit, M, D, HSP.Leni, M, I, HSP.Lenj);
}
}
#endif
#if TRACE
Log("\n");
Log("XDropAlignMem done, Score = %.1f\n", ScoreSplit);
LogAln(A + HSP.Loi, B + HSP.Loj, PI.GetPath());
#endif
return ScoreSplit;
}
| 5,876
|
C++
|
.cpp
| 198
| 27.414141
| 100
| 0.645819
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,025
|
extendpen.cpp
|
rcedgar_urmap/src/extendpen.cpp
|
#include "myutils.h"
#include "ufindex.h"
#include "seqinfo.h"
#include "alpha.h"
#include "state1.h"
#include "ufihit.h"
// Return +score if new hit, -2 if new hsp, -1 otherwise.
int State1::ExtendPen(uint32 SeedPosQ, uint32 SeedPosDB, bool Plus)
{
if (SeedPosDB < SeedPosQ)
return -1;
uint32 DBLo = SeedPosDB - SeedPosQ;
UFIHit *Hit = OverlapsHit(DBLo, Plus);
if (Hit != 0)
return -1;
const byte *QSeq = (Plus ? m_Query->m_Seq : m_RevCompQuerySeq.Data);
const unsigned QL = m_Query->m_L;
const byte *DBSeq = m_UFI->m_SeqData + DBLo;
const int MinHSPScore = int(MIN_HSP_SCORE_PCT*QL/100.0);
// Assume seed matches
int Pen = 0;
int Score = int(m_WordLength);
int BestScore = 0;
int EndPos = int(SeedPosQ+m_WordLength) - 1;
for (int QPos = EndPos + 1; QPos < int(QL); ++QPos)
{
byte q = QSeq[QPos];
byte t = DBSeq[QPos];
if (q == t)
{
++Score;
if (Score > BestScore)
{
BestScore = Score;
EndPos = QPos;
}
}
else
{
Pen -= MISMATCH_SCORE;
if (Pen > m_MaxPenalty)
return -1;
Score += MISMATCH_SCORE;
int Drop = (BestScore - Score);
if (Drop > XDROP)
break;
}
}
int StartPos = int(SeedPosQ);
for (int QPos = StartPos-1; QPos >= 0; --QPos)
{
byte q = QSeq[QPos];
byte t = DBSeq[QPos];
if (q == t)
{
++Score;
if (Score > BestScore)
{
BestScore = Score;
StartPos = QPos;
}
}
else
{
Pen -= MISMATCH_SCORE;
if (Pen > m_MaxPenalty)
return -1;
Score += MISMATCH_SCORE;
int Drop = (BestScore - Score);
if (Drop > XDROP)
break;
}
}
if (StartPos == 0 && EndPos == int(QL) - 1)
{
AddHitX(DBLo, Plus, BestScore, "");
return BestScore;
}
else
{
if (BestScore >= MinHSPScore)
{
unsigned HSPLength = unsigned(EndPos - StartPos + 1);
AddHSPX(unsigned(StartPos), DBLo+unsigned(StartPos), Plus,
HSPLength, BestScore);
return -2;
}
}
return -1;
}
bool State1::ExtendExact(uint32 SeedPosQ, uint32 SeedPosDB, bool Plus)
{
if (SeedPosDB < SeedPosQ)
return false;
const byte *QSeq = (Plus ? m_Query->m_Seq : m_RevCompQuerySeq.Data);
const unsigned QL = m_Query->m_L;
uint32 DBLo = SeedPosDB - SeedPosQ;
const byte *DBSeq = m_UFI->m_SeqData + DBLo;
// Assume seed matches
int EndPos = int(SeedPosQ+m_WordLength) - 1;
for (int QPos = EndPos + 1; QPos < int(QL); ++QPos)
{
byte q = QSeq[QPos];
byte t = DBSeq[QPos];
if (q != t)
return false;
}
int StartPos = int(SeedPosQ);
for (int QPos = StartPos-1; QPos >= 0; --QPos)
{
byte q = QSeq[QPos];
byte t = DBSeq[QPos];
if (q != t)
return false;
}
return true;
}
| 2,625
|
C++
|
.cpp
| 117
| 19.333333
| 70
| 0.632653
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,026
|
hspfinder.cpp
|
rcedgar_urmap/src/hspfinder.cpp
|
#include "myutils.h"
#include "hspfinder.h"
#include "alpha.h"
const char *WordToStr(unsigned Word, unsigned WordLength, bool Nucleo);
#if TIMING
static bool g_InSetA = false;
static bool g_InSetB = false;
#endif
#if 0
void HSPFinder::LogHSPsDot(HSPData **HSPs, unsigned HSPCount)
{
const unsigned PIC_SIZEH = 32;
const unsigned PIC_SIZEV = 20;
if (HSPCount == 0)
return;
unsigned Mini = UINT_MAX;
unsigned Minj = UINT_MAX;
unsigned Maxi = 0;
unsigned Maxj = 0;
for (unsigned i = 0; i < HSPCount; ++i)
{
const HSPData &HSP = *HSPs[i];
Mini = min(Mini, HSP.Loi);
Maxi = max(Maxi, HSP.GetHii());
Minj = min(Minj, HSP.Loj);
Maxj = max(Maxj, HSP.GetHij());
}
asserta(Maxi >= Mini);
asserta(Maxj >= Minj);
unsigned Rangei = Maxi - Mini + 1;
unsigned Rangej = Maxj - Minj + 1;
unsigned MaxRange = max(Rangei, Rangej);
double fx = double(PIC_SIZEH)/MaxRange;
double fy = double(PIC_SIZEV)/MaxRange;
vector<string> Pic(PIC_SIZEV);
for (unsigned i = 0; i < PIC_SIZEV; ++i)
Pic[i].resize(PIC_SIZEH, ' ');
for (unsigned HSPIndex = 0; HSPIndex < HSPCount; ++HSPIndex)
{
const HSPData &HSP = *HSPs[HSPIndex];
char c = "0123456789"[HSPIndex%10];
Log("%c: ", c);
HSP.LogMe();
unsigned Len = HSP.Leni;
asserta(HSP.Lenj == Len);
for (unsigned k = 0; k < Len; ++k)
{
unsigned i = HSP.Loi + k;
unsigned j = HSP.Loj + k;
asserta(i >= Mini && i <= Maxi);
asserta(j >= Minj && j <= Maxj);
unsigned x = unsigned((i - Mini)*fx);
if (x >= PIC_SIZEH)
x = PIC_SIZEH-1;
unsigned y = unsigned((j - Minj)*fy);
if (y >= PIC_SIZEV)
y = PIC_SIZEV-1;
if (isdigit(Pic[y][x]))
Pic[y][x] = 'X';
else
Pic[y][x] = c;
}
}
Log(" ");
for (unsigned i = 0; i < PIC_SIZEH; ++i)
Log(".");
Log("\n");
for (unsigned i = 0; i < PIC_SIZEV; ++i)
Log("| %s |\n", Pic[i].c_str());
Log(" ");
for (unsigned i = 0; i < PIC_SIZEH; ++i)
Log(".");
Log("\n");
}
void HSPFinder::LogHSPs() const
{
Log("\n");
Log("Q>%s\n", m_SA->m_Label);
Log("T>%s\n", m_SB->m_Label);
Log("%u HSPs\n", m_UngappedHSPCount);
const byte *A = m_SA->m_Seq;
const byte *B = m_SB->m_Seq;
for (unsigned HSPIndex = 0; HSPIndex < m_ChainedHSPCount; ++HSPIndex)
{
const HSPData &HSP = *m_ChainedHSPs[HSPIndex];
unsigned Ids = HSP.GetIdCount(A, B);
unsigned i = HSP.Loi;
unsigned j = HSP.Loj;
const byte *Aseg = A + i;
const byte *Bseg = B + j;
unsigned n = HSP.Leni;
asserta(HSP.Lenj == n);
float FractId = float(Ids)*100.0f/float(n);
Log("\n");
Log("%5u %*.*s %.1f%%\n", i, n, n, Aseg, FractId);
Log("%5.5s ", "");
unsigned Ids2 = 0;
for (unsigned k = 0; k < n; ++k)
{
byte a = Aseg[k];
byte b = Bseg[k];
if (a == b)
{
Log("|");
++Ids2;
}
else
Log(" ");
}
Log("\n");
Log("%5u %*.*s %.1f%%\n", j, n, n, Bseg, float(Ids2)*100.0f/n);
}
}
#endif // 0
HSPFinder::HSPFinder()
{
Clear(true);
}
HSPFinder::~HSPFinder()
{
Clear();
}
void HSPFinder::Clear(bool ctor)
{
m_Nucleo = false;
m_WordLength = 0;
m_WordCount = 0;
m_CharToLetter = 0;
m_Hi = 0;
m_SA = 0;
m_SB = 0;
//m_DiagCountsSize = 0;
m_WordCountA = 0;
m_WordCountB = 0;
m_WordsASize = 0;
m_WordsBSize = 0;
m_SubstMx = 0;
if (!ctor)
{
myfree(m_WordsA);
myfree(m_WordsB);
myfree(m_WordToPosA);
myfree(m_WordCountsA);
myfree(m_DiagToPosB);
for (unsigned i = 0; i < m_HSPSize; ++i)
{
myfree(m_UngappedHSPs[i]);
myfree(m_GappedHSPs[i]);
// delete m_Paths[i];
}
myfree(m_UngappedHSPs);
myfree(m_GappedHSPs);
myfree(m_ChainedHSPs);
}
m_WordsA = 0;
m_WordsB = 0;
m_WordToPosA = 0;
m_WordCountsA = 0;
m_DiagToPosB = 0;
m_DiagToPosBSize = 0;
m_GappedHSPs = 0;
m_UngappedHSPs = 0;
m_ChainedHSPs = 0;
// m_Paths = 0;
m_HSPSize = 0;
m_GappedHSPCount = 0;
m_UngappedHSPCount = 0;
m_ChainedHSPCount = 0;
}
void HSPFinder::Init(const AlnParams &AP, const AlnHeuristics &AH)
{
m_AH = &AH;
m_AP = 0;
m_SubstMx = AP.GetSubstMx();
m_WordLength = AH.HSPFinderWordLength;
m_Nucleo = AP.Nucleo;
m_CharToLetter = (m_Nucleo ? g_CharToLetterNucleo : g_CharToLetterAmino);
m_AlphaSize = (m_Nucleo ? 4 : 20);
// WordCount = WordLength^AlphaSize
m_WordCount = 1;
for (unsigned i = 0; i < m_WordLength; ++i)
m_WordCount *= m_AlphaSize;
m_Hi = m_WordCount/m_AlphaSize;
//m_WordToPosA = myalloc<unsigned>(m_WordCount*MaxReps);
//m_WordCountsA = myalloc<unsigned>(m_WordCount);
m_WordToPosA = myalloc(unsigned, m_WordCount*MaxReps);
m_WordCountsA = myalloc(unsigned, m_WordCount);
AllocHSPCount(64);
}
const char *HSPFinder::WordToStr(unsigned Word) const
{
return ::WordToStr(Word, m_WordLength, m_Nucleo);
}
// WARNING -- can't skip wildcards because indexes used to
// compute diagonal!
unsigned HSPFinder::SeqToWords(const byte *Seq, unsigned L, uint32 *Words) const
{
if (L < m_WordLength)
return 0;
#if TIMING
if (g_InSetA)
StartTimer(WF_SeqToWordsA)
else if (g_InSetB)
StartTimer(WF_SeqToWordsB)
else
StartTimer(WF_SeqToWords)
#endif
asserta(m_WordLength > 0);
const unsigned WordCount = L - m_WordLength + 1;
uint32 Word = 0;
const byte *Front = Seq;
const byte *Back = Seq;
for (unsigned i = 0; i < m_WordLength-1; ++i)
{
unsigned Letter = m_CharToLetter[*Front++];
if (Letter >= m_AlphaSize)
Letter = 0;
Word = (Word*m_AlphaSize) + Letter;
}
for (unsigned i = m_WordLength-1; i < L; ++i)
{
unsigned Letter = m_CharToLetter[*Front++];
if (Letter >= m_AlphaSize)
Letter = 0;
Word = (Word*m_AlphaSize) + Letter;
assert(Word < m_WordCount);
*Words++ = Word;
Letter = m_CharToLetter[*Back++];
if (Letter >= m_AlphaSize)
Letter = 0;
Word -= Letter*m_Hi;
}
#if TIMING
if (g_InSetA)
EndTimer(WF_SeqToWordsA)
else if (g_InSetB)
EndTimer(WF_SeqToWordsB)
else
EndTimer(WF_SeqToWords)
#endif
return WordCount;
}
void HSPFinder::AllocLA(unsigned LA)
{
if (LA <= m_WordsASize)
return;
StartTimer(WF_AllocLA);
myfree(m_WordsA);
m_WordsASize = LA + 512;
m_WordsA = myalloc(uint32, m_WordsASize);
//memset_zero(m_WordsA, m_WordsASize);
if (opt(logmemgrows))
Log("HSPFinder::AllocLA(%u)\n", m_WordsASize);
EndTimer(WF_AllocLA);
}
void HSPFinder::AllocLB(unsigned LB)
{
if (LB <= m_WordsBSize)
return;
StartTimer(WF_AllocLB);
myfree(m_WordsB);
m_WordsBSize = LB + 32;
m_WordsB = myalloc(uint32, m_WordsBSize);
if (opt(logmemgrows))
Log("HSPFinder::AllocLB(%u)\n", m_WordsBSize);
EndTimer(WF_AllocLB);
}
void HSPFinder::AllocDiags(unsigned DiagCount)
{
if (DiagCount <= m_DiagToPosBSize)
return;
StartTimer(WF_AllocDiags);
myfree(m_DiagToPosB);
m_DiagToPosBSize = DiagCount + 1024;
m_DiagToPosB = myalloc(unsigned, m_DiagToPosBSize);
EndTimer(WF_AllocDiags);
}
void HSPFinder::SetA(SeqInfo *SI)
{
AllocLA(SI->m_L);
StartTimer(WF_SetAZero);
memset_zero(m_WordCountsA, m_WordCount);
EndTimer(WF_SetAZero);
m_SA = SI;
#if TIMING
g_InSetA = true;
#endif
m_WordCountA = SeqToWords(m_SA->m_Seq, m_SA->m_L, m_WordsA);
#if TIMING
g_InSetA = false;
#endif
StartTimer(WF_SetA2);
for (unsigned PosA = 0; PosA < m_WordCountA; ++PosA)
{
unsigned Word = m_WordsA[PosA];
assert(Word < m_WordCount);
unsigned n = m_WordCountsA[Word];
if (n == MaxReps)
continue;
m_WordToPosA[Word*MaxReps + n] = PosA;
++(m_WordCountsA[Word]);
}
EndTimer(WF_SetA2);
}
void HSPFinder::SetB(SeqInfo *SI)
{
AllocLB(SI->m_L);
m_SB = SI;
#if TIMING
g_InSetB = true;
#endif
m_WordCountB = SeqToWords(SI->m_Seq, SI->m_L, m_WordsB);
#if TIMING
g_InSetB = false;
#endif
}
unsigned HSPFinder::GetCommonWordCount() const
{
StartTimer(WF_GetCommonWordCount);
unsigned Count = 0;
for (unsigned PosB = 0; PosB < m_WordCountB; ++PosB)
{
unsigned Word = m_WordsB[PosB];
assert(Word < m_WordCount);
if (m_WordCountsA[Word] > 0)
++Count;
}
EndTimer(WF_GetCommonWordCount);
return Count;
}
unsigned HSPFinder::SeqToWord(const byte *Seq) const
{
uint32 Word = 0;
const byte *Front = Seq;
for (unsigned i = 0; i < m_WordLength; ++i)
{
unsigned Letter = m_CharToLetter[*Front++];
Word = (Word*m_AlphaSize) + Letter;
}
return Word;
}
void HSPFinder::LogMe() const
{
Log("\n");
Log("HSPFinder::LogMe()\n");
Log("LA=%u, LB=%u, LabelA=%s, LabelB=%s\n",
m_SA->m_L, m_SB->m_L, m_SA->m_Label, m_SB->m_Label);
Log("A=%*.*s\n", m_SA->m_L, m_SA->m_L, m_SA);
Log("B=%*.*s\n", m_SB->m_L, m_SB->m_L, m_SB);
Log("\n");
Log(" PosA Word\n");
Log("----- --------\n");
for (unsigned i = 0; i < m_WordCountA; ++i)
Log("%5u %8.8s\n", i, WordToStr(m_WordsA[i]));
Log("\n");
Log(" PosB Word PosAs\n");
Log("----- -------- ------\n");
for (unsigned i = 0; i < m_WordCountB; ++i)
{
unsigned Word = m_WordsB[i];
assert(Word < m_WordCount);
Log("%5u %8.8s", i, WordToStr(Word));
unsigned n = m_WordCountsA[Word];
if (n > 0)
Log(" %u:", n);
asserta(n <= MaxReps);
for (unsigned k = 0; k < n; ++k)
Log(" %u", m_WordToPosA[Word*MaxReps + k]);
Log("\n");
}
}
void HSPFinder::AllocHSPCount(unsigned HSPCount)
{
if (HSPCount < m_HSPSize)
return;
unsigned NewHSPSize = HSPCount + 32;
HSPData **NewGappedHSPs = myalloc(HSPData *, NewHSPSize);
HSPData **NewUngappedHSPs = myalloc(HSPData *, NewHSPSize);
HSPData **NewChainedHSPs = myalloc(HSPData *, NewHSPSize);
// PathData **NewPaths = myalloc(PathData *, NewHSPSize);
if (m_GappedHSPCount > 0)
{
asserta(m_GappedHSPCount <= m_HSPSize);
memcpy(NewGappedHSPs, m_GappedHSPs, m_GappedHSPCount*sizeof(NewGappedHSPs[0]));
// memcpy(NewPaths, m_Paths, m_GappedHSPCount*sizeof(NewPaths[0]));
}
if (m_UngappedHSPCount > 0)
{
asserta(m_UngappedHSPCount <= m_HSPSize);
memcpy(NewUngappedHSPs, m_UngappedHSPs,
m_UngappedHSPCount*sizeof(NewUngappedHSPs[0]));
}
if (m_ChainedHSPCount > 0)
{
asserta(m_ChainedHSPCount <= m_HSPSize);
memcpy(NewChainedHSPs, m_ChainedHSPs,
m_ChainedHSPCount*sizeof(NewChainedHSPs[0]));
}
for (unsigned i = m_GappedHSPCount; i < NewHSPSize; ++i)
{
NewGappedHSPs[i] = myalloc(HSPData, 1);
// NewPaths[i] = new PathData;
}
for (unsigned i = m_UngappedHSPCount; i < NewHSPSize; ++i)
NewUngappedHSPs[i] = myalloc(HSPData, 1);
myfree(m_GappedHSPs);
myfree(m_UngappedHSPs);
myfree(m_ChainedHSPs);
// myfree(m_Paths);
m_GappedHSPs = NewGappedHSPs;
m_UngappedHSPs = NewUngappedHSPs;
m_ChainedHSPs = NewChainedHSPs;
//m_Paths = NewPaths;
m_HSPSize = NewHSPSize;
}
float HSPFinder::GetAnchor(const HSPData &HSP, const byte *A, const byte *B,
const AlnParams &AP, unsigned &AncLoi, unsigned &AncLoj, unsigned &AncLen)
{
if (HSP.Leni != HSP.Lenj)
{
Warning("HSPFinder::GetAnchor, bad HSP");
HSP.LogMe();
AncLoi = 0;
AncLoj = 0;
AncLen = 0;
return 0.0;
}
unsigned i = HSP.Loi;
unsigned j = HSP.Loj;
unsigned L = HSP.GetLength();
unsigned Startk = UINT_MAX;
unsigned BestStartk = UINT_MAX;
unsigned Length = 0;
float AnchorScore = 0.0f;
float BestScore = 0.0f;
const float * const *SubstMx = AP.SubstMx;
for (unsigned k = 0; k < L; ++k)
{
byte a = A[i++];
byte b = B[j++];
float Score = SubstMx[a][b];
if (Score > 0)
{
if (Startk == UINT_MAX)
{
Startk = k;
AnchorScore = Score;
}
else
AnchorScore += Score;
}
else
{
if (AnchorScore > BestScore)
{
BestScore = AnchorScore;
BestStartk = Startk;
asserta(k > Startk);
Length = k - Startk;
}
Startk = UINT_MAX;
}
}
if (AnchorScore > BestScore)
{
BestScore = AnchorScore;
BestStartk = Startk;
asserta(L > Startk);
Length = L - Startk;
}
AncLoi = HSP.Loi + BestStartk;
AncLoj = HSP.Loj + BestStartk;
AncLen = Length;
return BestScore;
}
bool HSPFinder::HSPInPath(const HSPData &HSP, const char *Path)
{
Die("HSPFinder::HSPInPath not implemented");
return false;
}
float HSPFinder::ComputeGaplessHSPScore(const HSPData &HSP,
const float * const *SubstMx) const
{
unsigned Len = HSP.Leni;
asserta(HSP.Lenj == Len);
const byte *A = m_SA->m_Seq;
const byte *B = m_SB->m_Seq;
unsigned LA = m_SA->m_L;
unsigned LB = m_SB->m_L;
unsigned i = HSP.Loi;
unsigned j = HSP.Loj;
float Score = 0.0f;
for (unsigned k = 0; k < Len; ++k)
{
byte a = A[i++];
byte b = B[j++];
Score += SubstMx[a][b];
}
asserta(i <= LA);
asserta(j <= LB);
return Score;
}
void HSPFinder::Chain()
{
m_Chainer.Chain(m_UngappedHSPs, m_UngappedHSPCount,
m_ChainedHSPs, m_ChainedHSPCount);
unsigned LA = m_SA->m_L;
unsigned LB = m_SB->m_L;
for (unsigned i = 0; i < m_ChainedHSPCount; ++i)
{
const HSPData &HSP = *(m_ChainedHSPs[i]);
if (HSP.IsStaggered(LA, LB))
{
m_ChainedHSPCount = 0;
return;
}
}
}
unsigned HSPFinder::GetHSPIdCount(const HSPData &HSP) const
{
bool **Mx = (m_Nucleo ? g_MatchMxNucleo : g_MatchMxAmino);
asserta(m_CharToLetter != 0);
unsigned Count = 0;
const unsigned K = HSP.GetLength();
const unsigned Loi = HSP.Loi;
const unsigned Loj = HSP.Loj;
const byte *A = m_SA->m_Seq;
const byte *B = m_SB->m_Seq;
for (unsigned k = 0; k < K; ++k)
{
byte a = A[Loi+k];
byte b = B[Loj+k];
if (Mx[a][b])
Count++;
}
return Count;
}
/***
Check if too far from main diag to suppress staggered alignments
Heuristic:
require 75% of shorter sequence to be aligned.
i.e. termgap <25%
Alo
| LA
A XXXXXXXXXXXXXXXX-------------
B -----XXXXXXXXXXXXXXXXXXXXXXXX
| LB
BLo
***/
bool HSPFinder::IsGlobalHSP(unsigned ALo, unsigned BLo, unsigned Length, unsigned LA, unsigned LB)
{
if (LA <= LB)
{
unsigned MaxGap = LA/4 + 1;
if (ALo > BLo)
{
unsigned LeftTermGap = ALo - BLo;
if (LeftTermGap > MaxGap)
return false;
}
unsigned AR = LA - ALo;
unsigned BR = LB - BLo;
if (AR > BR)
{
unsigned RightTermGap = AR - BR;
if (RightTermGap > MaxGap)
return false;
}
}
else
{
unsigned MaxGap = LB/4 + 1;
if (BLo > ALo)
{
unsigned LeftTermGap = BLo - ALo;
if (LeftTermGap > MaxGap)
return false;
}
unsigned AR = LA - ALo;
unsigned BR = LB - BLo;
if (BR > AR)
{
unsigned RightTermGap = BR - AR;
if (RightTermGap > MaxGap)
return false;
}
}
return true;
}
| 14,186
|
C++
|
.cpp
| 589
| 21.365025
| 98
| 0.650681
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,027
|
alpha.h
|
rcedgar_urmap/src/alpha.h
|
#ifndef alpha_h
#define alpha_h
#include <limits.h>
#include <string>
using namespace std;
const unsigned INVALID_LETTER = 0xff;
const unsigned char INVALID_CHAR = '?';
const unsigned BAD_WORD = UINT_MAX;
extern unsigned char g_AminoAcidChars[];
extern unsigned char g_CharToLetterAmino[];
extern unsigned char g_CharToLetterAminoStop[];
extern unsigned char g_CharToLetterAminoGap[];
extern unsigned char g_LetterToCharAmino[];
extern unsigned char g_LetterToCharAminoGap[];
extern unsigned char g_CharToLetterNucleo[];
extern unsigned char g_CharToLetterNucleoGap[];
extern unsigned char g_CharToLetterNucleoMasked[];
extern unsigned char g_LetterToCharNucleo[];
extern unsigned char g_LetterToCharNucleoGap[];
extern unsigned char g_CodonWordToAminoLetter[];
extern unsigned char g_CodonWordToAminoChar[];
extern unsigned char g_CharToCompChar[];
extern unsigned char g_CharToCompLetter[];
extern unsigned char g_IUPAC_PairCharToChar1[256];
extern unsigned char g_IUPAC_PairCharToChar2[256];
extern unsigned char g_IUPAC_PairCharToCharCase[256];
extern bool **g_MatchMxNucleo;
extern bool **g_MatchMxAmino;
extern bool g_IsAminoChar[];
extern bool g_IsNucleoChar[];
extern bool g_IsACGTU[];
extern bool g_IsSeqChar[];
extern float g_AminoFreqs[];
extern unsigned g_CharToLetterRed[];
extern unsigned char g_LetterToCharRed[];
extern unsigned g_RedAlphaSize;
void LogRedAlphaRed();
void ReadRedAlphaFromFile(const string &FileName);
unsigned char GetAminoCharFrom3NucChars(unsigned char c1, unsigned char c2,
unsigned char c3);
const char *WordToStr(unsigned Word, unsigned WordLength, bool Nucleo);
const char *WordToStrNucleo(unsigned Word, unsigned WordLength);
const char *WordToStrAmino(unsigned Word, unsigned WordLength);
const char *WordToStrAmino2(unsigned Word, unsigned WordLength, char *Str);
static inline bool isgap(unsigned char c)
{
return c == '-' || c == '.';
}
void InitAlpha();
unsigned char IUPAC_Pair(unsigned char CharOrWildcard1, unsigned char CharOrWildcard2);
#endif // alpha_h
| 2,023
|
C++
|
.h
| 51
| 38.333333
| 87
| 0.816327
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,028
|
chainer1.h
|
rcedgar_urmap/src/chainer1.h
|
#ifndef chainer1_h
#define chainer1_h
#include "hsp.h" // for BPData
#include "gobuff.h"
#define BRUTE 0
class Chainer1
{
public:
GoBuff<BPData> m_BPs;
GoBuff<unsigned> m_ChainIndexes;
GoBuff<float> m_ChainScores;
GoBuff<unsigned> m_TB;
public:
const unsigned *Chain(const unsigned *Los, const unsigned *His,
float *Scores, unsigned N, unsigned &ChainLength);
void Clear();
static bool IsValidChain(const unsigned *Los, const unsigned *His, unsigned N,
const unsigned *Chain, unsigned ChainLength);
static float GetChainScore(const unsigned *Los, const unsigned *His, const float *Scores,
unsigned N, const unsigned *Chain, unsigned ChainLength);
#if BRUTE
const unsigned *ChainBrute(const unsigned *Los, const unsigned *His,
float *Scores, unsigned N, unsigned &ChainLength);
#endif
};
#endif // chainer1_h
| 838
|
C++
|
.h
| 26
| 30.076923
| 90
| 0.770186
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,029
|
ufihit.h
|
rcedgar_urmap/src/ufihit.h
|
#ifndef ufihit_h
#define ufihit_h
class State1;
class AlignResult;
class UFIHit
{
public:
State1 *m_UD;
unsigned m_DBStartPos;
bool m_Plus;
int m_Score;
string m_Path;
};
#endif // ufihit_h
| 200
|
C++
|
.h
| 14
| 12.571429
| 23
| 0.759563
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,030
|
mx.h
|
rcedgar_urmap/src/mx.h
|
#ifndef mx_h
#define mx_h
#include <list>
#include <limits.h>
#include <math.h>
#include "myutils.h"
const int OPT_LOG = 0x01;
const int OPT_EXP = 0x02;
const int OPT_ZERO_BASED = 0x04;
const float MINUS_INFINITY = -9e9f;
const float UNINIT = -8e8f;
struct SeqData;
template<class T> const char *TypeToStr(T t)
{
Die("Unspecialised TypeToStr() called");
ureturn(0);
}
template<> inline const char *TypeToStr<unsigned short>(unsigned short f)
{
static char s[16];
sprintf(s, "%12u", f);
return s;
}
template<> inline const char *TypeToStr<unsigned>(unsigned f)
{
static char s[16];
sprintf(s, "%12u", f);
return s;
}
template<> inline const char *TypeToStr<short>(short f)
{
static char s[16];
sprintf(s, "%12d", f);
return s;
}
template<> inline const char *TypeToStr<int>(int f)
{
static char s[16];
sprintf(s, "%5d", f);
return s;
}
template<> inline const char *TypeToStr<float>(float f)
{
static char s[16];
if (f == UNINIT)
sprintf(s, "%12.12s", "?");
else if (f < MINUS_INFINITY/2)
sprintf(s, "%12.12s", "*");
else if (f == 0.0f)
sprintf(s, "%12.12s", ".");
else if (f >= -1e5 && f <= 1e5)
sprintf(s, "%12.5f", f);
else
sprintf(s, "%12.4g", f);
return s;
}
template<> inline const char *TypeToStr<double>(double f)
{
static char s[16];
if (f < -1e9)
sprintf(s, "%12.12s", "*");
else if (f == 0.0f)
sprintf(s, "%12.12s", ".");
else if (f >= -1e-5 && f <= 1e5)
sprintf(s, "%12.5f", f);
else
sprintf(s, "%12.4g", f);
return s;
}
static inline const char *FloatToStr(float f, string &s)
{
s = TypeToStr<float>(f);
return s.c_str();
}
template<> inline const char *TypeToStr<char>(char c)
{
static char s[2];
s[0] = c;
return s;
}
template<> inline const char *TypeToStr<byte>(byte c)
{
static char s[2];
s[0] = c;
return s;
}
template<> inline const char *TypeToStr<bool>(bool tof)
{
static char s[2];
s[0] = tof ? 'T' : 'F';
return s;
}
class SeqDB;
struct MxBase
{
private:
MxBase(const MxBase &rhs);
MxBase &operator=(const MxBase &rhs);
public:
string m_Name;
unsigned m_RowCount;
unsigned m_ColCount;
unsigned m_AllocatedRowCount;
unsigned m_AllocatedColCount;
static list<MxBase *> *m_Matrices;
static unsigned m_AllocCount;
static unsigned m_ZeroAllocCount;
static unsigned m_GrowAllocCount;
static double m_TotalBytes;
static double m_MaxBytes;
static void OnCtor(MxBase *Mx);
static void OnDtor(MxBase *Mx);
MxBase()
{
m_AllocatedRowCount = 0;
m_AllocatedColCount = 0;
m_RowCount = 0;
m_ColCount = 0;
OnCtor(this);
}
virtual ~MxBase()
{
OnDtor(this);
}
public:
virtual unsigned GetTypeSize() const = 0;
virtual unsigned GetTotalBytes() const = 0;
virtual void AllocData(unsigned RowCount, unsigned ColCount) = 0;
virtual void FreeData() = 0;
virtual const char *GetAsStr(unsigned i, unsigned j) const = 0;
public:
void Clear()
{
FreeData();
m_AllocatedRowCount = 0;
m_AllocatedColCount = 0;
m_RowCount = 0;
m_ColCount = 0;
}
bool IsEmpty() const
{
return m_RowCount == 0;
}
public:
void Alloc(unsigned RowCount, unsigned ColCount, const string &Name = "");
void Alloc(const string &Name, unsigned RowCount, unsigned ColCount)
{
Alloc(RowCount, ColCount, Name);
}
unsigned GetRowCount() const { return m_RowCount; }
unsigned GetColCount() const { return m_ColCount; }
static void LogAll()
{
Log("\n");
if (m_Matrices == 0)
{
Log("MxBase::m_Matrices=0\n");
return;
}
Log("\n");
Log("AllRows AllCols Sz MB Name\n");
Log("------- ------- ---- -------- ----\n");
double TotalMB = 0;
for (list<MxBase *>::const_iterator p = m_Matrices->begin();
p != m_Matrices->end(); ++p)
{
const MxBase *Mx = *p;
if (Mx == 0)
continue;
//if (Mx->m_RowCount != 0 || ShowEmpty)
// Mx->LogMe(WithData);
unsigned ar = Mx->m_AllocatedRowCount;
if (ar == 0)
continue;
unsigned ac = Mx->m_AllocatedColCount;
unsigned sz = Mx->GetTypeSize();
double MB = (double) ar*(double) ac*(double) sz/1e6;
TotalMB += MB;
Log("%7u %7u %4u %8.2f %s\n", ar, ac, sz, MB, Mx->m_Name.c_str());
}
Log(" --------\n");
Log("%7.7s %7.7s %4.4s %8.2f\n", "", "", "", TotalMB);
}
void LogMe(bool WithData = true, int Opts = 0) const;
static void LogCounts();
};
template<class T> struct Mx : public MxBase
{
// Disable unimplemented stuff
private:
Mx(Mx &rhs);
Mx &operator=(Mx &rhs);
// const Mx &operator=(const Mx &rhs) const;
public:
T **m_Data;
Mx()
{
m_Data = 0;
}
~Mx()
{
FreeData();
}
virtual void AllocData(unsigned RowCount, unsigned ColCount)
{
if (opt(logmemgrows))
Log("MxBase::AllocData(%u,%u) %s bytes, Name=%s\n",
RowCount, ColCount, IntToStr(GetTotalBytes()), m_Name.c_str());
double dRowPtrsBytes = double(sizeof(T *))*double(RowCount);
if (dRowPtrsBytes > (double) (UINT_MAX-16))
Die("Mx::AllocData Rows=%u, sizeof(T *)=%u, row %s bytes too big",
RowCount, sizeof(T *), MemBytesToStr(dRowPtrsBytes));
double dDataBytes = double(sizeof(T))*double(RowCount)*double(ColCount);
if (dDataBytes > (double) (UINT_MAX-16))
Die("Mx::AllocData Rows=%u, Cols=%u, sizeof(T)=%u, data %s too big",
RowCount, ColCount, sizeof(T), MemBytesToStr(dDataBytes));
unsigned RowBytes = sizeof(T *)*RowCount;
unsigned DataBytes = sizeof(T)*RowCount*ColCount;
if (opt(logmemgrows))
Log("MxBase::AllocData(%u,%u) RowBytes=%u, DataBytes=%u, myalloc(%u), name %s\n",
RowCount, ColCount, RowBytes, DataBytes, RowBytes + DataBytes, m_Name.c_str());
byte *Buffer = myalloc(byte, RowBytes + DataBytes);
m_Data = (T **) Buffer;
byte *Base = Buffer + RowCount*sizeof(T *);
for (unsigned i = 0; i < RowCount; ++i)
m_Data[i] = (T *) (Base + i*ColCount*sizeof(T));
//m_Data = myalloc(T *, RowCount);
//for (unsigned i = 0; i < RowCount; ++i)
// m_Data[i] = myalloc(T, ColCount);
m_AllocatedRowCount = RowCount;
m_AllocatedColCount = ColCount;
}
virtual void FreeData()
{
//for (unsigned i = 0; i < m_AllocatedRowCount; ++i)
// myfree(m_Data[i]);
//myfree(m_Data);
myfree(m_Data);
m_Data = 0;
m_RowCount = 0;
m_ColCount = 0;
m_AllocatedRowCount = 0;
m_AllocatedColCount = 0;
}
T **GetData()
{
return (T **) m_Data;
}
T Get(unsigned i, unsigned j) const
{
assert(i < m_RowCount);
assert(j < m_ColCount);
return m_Data[i][j];
}
void Put(unsigned i, unsigned j, T x)
{
assert(i < m_RowCount);
assert(j < m_ColCount);
m_Data[i][j] = x;
}
unsigned GetTypeSize() const
{
return sizeof(T);
}
virtual unsigned GetTotalBytes() const
{
return m_AllocatedRowCount*m_AllocatedColCount*GetTypeSize() +
m_AllocatedRowCount*sizeof(T *);
}
const char *GetAsStr(unsigned i, unsigned j) const
{
return TypeToStr<T>(Get(i, j));
}
const T *const *const GetData() const
{
return (const T *const *) m_Data;
}
void Zero()
{
PutAll(0);
}
void PutAll(T v)
{
for (unsigned i = 0; i < m_RowCount; ++i)
for (unsigned j = 0; j < m_ColCount; ++j)
m_Data[i][j] = v;
}
};
#endif // mx_h
| 7,142
|
C++
|
.h
| 289
| 21.979239
| 84
| 0.647873
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,031
|
label.h
|
rcedgar_urmap/src/label.h
|
#ifndef label_h
#define label_h
const char *GetStrField(const string &Label, const string &NameEq,
string &Value);
void StripAllAnnots(string &Label);
void StripAnnot(string &Label, const string &NameEq);
void AppendIntField(string &Label, const string &NameEq, unsigned Value);
void AppendStrField(string &Label, const string &NameEqValue);
void AppendStrField(string &Label, const string &NameEq, const string &Value);
void AppendSize(string &Label, unsigned Size);
void AppendTaxStr(string &Label, const string &s);
void StripSize(string &Label);
void StripTax(string &Label);
const char *GetTaxStrFromLabel(const string &Label, string &s);
void ReplaceSizeInLabel(string &Label, unsigned NewSize);
unsigned GetIntFieldFromLabel(const string &Label, const string &NameEq, unsigned Default);
unsigned GetSizeFromLabel(const string &Label, unsigned Default);
unsigned GetTaxIdFromLabel(const string &Label, unsigned Default);
void GetAccFromLabel(const string &Label, string &Acc);
byte GetSplitRankFromLabel(const string &Label);
void GetOTUNameFromLabel(const string &Label, string &OTUName);
void GetSampleNameFromLabel(const string &Label, string &SampleName);
void GetAllAnnots(const string &Label, string &Annots);
bool IlluminaLabelPairMatch(const char *Label1, const char *Label2);
#endif // label_h
| 1,313
|
C++
|
.h
| 25
| 51.36
| 91
| 0.812597
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,032
|
seqhash.h
|
rcedgar_urmap/src/seqhash.h
|
#ifndef seqhash_h
#define seqhash_h
class SeqDB;
uint32 SeqHash32(const byte *Seq, unsigned L);
uint32 SeqHashRC32(const byte *Seq, unsigned L);
uint32 SeqHash32_EitherStrand(const byte *Seq, unsigned L);
bool SeqEq(const byte *Seq1, unsigned L1, const byte *Seq2, unsigned L2);
bool SeqEqRC(const byte *Seq1, unsigned L1, const byte *Seq2, unsigned L2);
#endif // seqhash_h
| 378
|
C++
|
.h
| 9
| 40.666667
| 75
| 0.778689
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,033
|
state1.h
|
rcedgar_urmap/src/state1.h
|
#ifndef state1_h
#define state1_h
typedef int dpscore;
#include "gobuff.h"
#include "objmgr.h"
#include "ufihit.h"
#include "ufihsp.h"
#include "xdpmem.h"
// const int MATCH_SCORE = 1;
const unsigned MAX_LOCUS_D = 64;
const unsigned LOCUS_DEGLITCH_BIG = 2000;
const int ACCEPT_MIN_MAPQ = 10;
const int SECONDARY_HIT_MAX_DELTA = 12;
const unsigned PRIME_STRIDE = 27;
const unsigned SCANK = 4;
const int MAX_TL = 1000;
class UFIndex;
class SeqInfo;
class AlignResult;
class State1
{
public:
static int MISMATCH_SCORE;
static int GAP_OPEN_SCORE;
static int GAP_EXT_SCORE;
static int MIN_HSP_SCORE_PCT;
static int TERM_HSP_SCORE_PCT_PHASE3;
static int XDROP;
static int MAX_PENALTY;
static int XPHASE1;
static int XPHASE3;
static int XPHASE4;
static unsigned GLOBAL_BAND_RADIUS;
static unsigned m_Minq;
private:
static unsigned m_Method;
public:
UFIHit *m_TopHit;
UFIHit *m_SecondHit;
uint32 m_WordLength;
uint64 m_SlotCount;
uint64 m_ShiftMask;
SeqInfo *m_Query;
GoBuff<UFIHit *> m_Hits;
GoBuff<UFIHSP *> m_HSPs;
GoBuff<char> m_SAM;
GoBuff<char> m_SUM;
unsigned m_HitCount;
unsigned m_HSPCount;
int m_MaxPenalty;
int m_BestScore;
int m_SecondBestScore;
int m_BestHSPScore;
unsigned m_Mapq;
string m_MappedTargetLabel;
uint32 m_MappedTargetPos;
GoBuff<byte> m_RevCompQuerySeq;
byte *m_AllocBuff;
unsigned m_AllocBuffSize;
unsigned m_AllocBuffOffset;
bool m_QLabel;
XDPMem m_XDPMem;
PathInfo *m_PI;
PathInfo *m_LeftPI;
PathInfo *m_RightPI;
/////////////////////////////////////
// Cached vectors
uint64 *m_SlotsVec_Plus; // QL
uint64 *m_SlotsVec_Minus; // QL
uint32 *m_PosVec; // MaxIx
byte *m_BlobVec_Plus; // 5*QL
byte *m_BlobVec_Minus; // 5*QL
byte *m_QPosPendingVec_Plus; // QL
byte *m_QPosPendingVec_Minus; // QL
unsigned m_QPosPendingCount_Plus;
unsigned m_QPosPendingCount_Minus;
/////////////////////////////////////
public:
const UFIndex *m_UFI;
static unsigned m_StartSecs;
static unsigned m_QueryCount;
static unsigned m_AcceptCount;
static unsigned m_RejectCount;
static unsigned m_NoHitCount;
public:
State1()
{
m_TopHit = 0;
m_Query = 0;
m_WordLength = 0;
m_SlotCount = 0;
m_ShiftMask = 0;
m_HitCount = 0;
m_MaxPenalty = -1;
m_QLabel = opt(qlabel);
m_AllocBuffSize = 1024*1024;
m_AllocBuff = myalloc(byte, m_AllocBuffSize);
m_AllocBuffOffset = 0;
m_PI = ObjMgr::GetPathInfo();
m_LeftPI = ObjMgr::GetPathInfo();
m_RightPI = ObjMgr::GetPathInfo();
///////////////////////////////////////////////
m_SlotsVec_Plus = 0;
m_SlotsVec_Minus = 0;
m_PosVec = 0;
m_BlobVec_Plus = 0;
m_BlobVec_Minus = 0;
m_QPosPendingVec_Plus = 0;
m_QPosPendingVec_Minus = 0;
m_QPosPendingCount_Plus = 0;
m_QPosPendingCount_Minus = 0;
///////////////////////////////////////////////
}
bool IsCorrect() const;
const UFIHit *GetSecondHit() const;
void AllocHits(unsigned n);
void AllocHSPs(unsigned n);
void SetUFI(const UFIndex &UFI);
void Search(SeqInfo *Query);
void Search_PE(SeqInfo *Query);
void Search_Lo();
void SearchPE_Pending(unsigned k);
void SearchPE_Pending5(unsigned k);
void Search1(SeqInfo *Query);
bool Search1_Lo(SeqInfo *Query);
void Output1();
void UpdateHitStats();
unsigned ExtendScan(uint32 SeedPosQ, uint32 SeedPosDB, bool Plus);
int ExtendPen(uint32 SeedPosQ, uint32 SeedPosDB, bool Plus);
bool ExtendExact(uint32 SeedPosQ, uint32 SeedPosDB, bool Plus);
unsigned CalcMAPQ6() const;
unsigned OverlapsHSP(uint32 StartPosQ, uint32 StartPosDB, bool Plus);
UFIHit *OverlapsHit(uint32 DBStartPos, bool Plus);
int GetBestScore() const { return m_BestScore; }
int GetSecondBestScore() const { return m_SecondBestScore; }
int GetSecondBestDelta() const;
const UFIHit *GetTopHit() const;
void SetSlotsVec(const byte *Seq, unsigned L, uint64 *SlotsVec) const;
void SetSlotsVecRC(const byte *Seq, unsigned L, uint64 *SlotsVec) const;
void SetTallyVec(const uint64 *Slots, unsigned N, byte *TallyVec) const;
void SetBlobVec(const uint64 *Slots, unsigned N, byte *BlobVec) const;
unsigned AddHitX(uint32 StartPosDB, bool Plus, int Score, const string &Path);
void AddHSPX(unsigned SeedPosQ, uint32 SeedPosDB, bool Plus,
unsigned Length, int Score);
unsigned AddHSPScan(unsigned SeedPosQ, uint32 SeedPosDB, bool Plus,
unsigned Length, int Score);
void SetSAM(uint32 Flags, const string &MateTargetLabel,
const uint32 MateTargetPos, int TLEN);
void SetSUM();
void SetSAM_Unmapped(uint32 Flags);
unsigned AlignHSP(unsigned HSPIndex);
unsigned AlignHSP5(unsigned HSPIndex);
void GetHitOrder(vector<unsigned> &Order) const;
const UFIHit *GetHit(unsigned Index) const;
const UFIHSP *GetHSP(unsigned Index) const;
UFIHit *GetHit(unsigned Index);
UFIHSP *GetHSP(unsigned Index);
float Viterbi(const byte *A, unsigned LA, const byte *B, unsigned LB,
bool Left, bool Right, PathInfo &PI);
void GetTopHitIndexes(vector<unsigned> &HitIndexes) const;
void GetBoth1s(SeqInfo *Query, vector<uint32> &PosVec);
uint32 GetTopHitPos() const;
void Scan(uint32 DBLo, unsigned DBSegLength, bool Plus, bool DoVit);
void ScanSlots(uint32 DBLo, unsigned DBSegLength, bool Plus);
void GetCIGAR(string &CIGAR) const;
bool PolishCIGAR(string &CIGAR) const;
void LogHit(unsigned HitIndex) const;
void LogHSP(const UFIHSP *HSP) const;
void LogHits() const;
void LogHitsSummary() const;
void LogHSPSummary() const;
void LogPos(uint32 DBPos) const;
void PrPos(FILE *f, uint32 DBPos) const;
void LogState(const string &s = "") const;
void GetPairLabel(string &Label) const;
void *AllocBuff(unsigned Bytes)
{
void *p = m_AllocBuff + m_AllocBuffOffset;
m_AllocBuffOffset += Bytes;
asserta(m_AllocBuffOffset <= m_AllocBuffSize);
return p;
}
void GetChrPos(const UFIHit *Hit, string &ChrLabel,
uint32 &ChrPos) const;
/////////////////////////////////////////
void InitPE(SeqInfo *Query);
void SetMappedPos();
//void ResetPE();
void AllocCachedVectors(unsigned QL);
unsigned GetFirstBoth1Seed(uint32 &QPos, bool &Plus, uint32 &DBPos);
unsigned GetNextBoth1Seed(unsigned k, uint32 &QPos, bool &Plus, uint32 &DBPos);
void GetBoth1Seeds(vector<unsigned> &QPosVec, vector<uint32> &DBPosVec,
vector<bool> &PlusVec, vector<uint64> &DiagVec);
unsigned GetFirstBoth1SeedEx(uint32 &QPos, bool &Plus, uint32 &DBPos);
unsigned GetNextBoth1SeedEx(unsigned k, uint32 &QPos, bool &Plus, uint32 &DBPos);
/////////////////////////////////////////
public:
static void HitStats();
static void SetMethod(unsigned Method);
static void WriteSAMHeader(FILE *f, const UFIndex &UFI);
};
#define alloc_buff(t, n) (t *) AllocBuff((n)*sizeof(t))
#endif // state1_h
| 6,649
|
C++
|
.h
| 203
| 30.522167
| 82
| 0.732564
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,034
|
samrec.h
|
rcedgar_urmap/src/samrec.h
|
#ifndef samrec_h
#define samrec_h
#include "gobuff.h"
class SeqDB;
class SeqInfo;
void CigarToVecs(const string &Cigar, vector<unsigned> &Ints,
vector<char> &Chars);
class SAMRec
{
public:
string m_Line;
vector<string> m_Fields;
const char *m_ReadLabel;
const char *m_TargetLabel;
// Read sequences
// WARNING! reverse-complemented if minus
const char *m_ReadSeq;
unsigned m_Score;
unsigned m_BitFlags;
unsigned m_Mapq;
// m_ReadLo is 0-based position.
// m_TargetLo is 1-based position.
// Target is always considered to be on plus strand as it appears in the db.
// Read may be revcomp'd. If so, m_ReadLo is relative to revcomp'd read.
// m_ReadLo is position relative to start of read or revcomp'd read.
unsigned m_TargetLo;
unsigned m_ReadLo;
// m_ReadSeqLo is start of alignment in m_ReadSeq (SAM SEQ field).
// With soft clipping, m_ReadSeqLo == m_ReadLo.
// With hard clipping, m_ReadSeqLo == 0.
unsigned m_ReadSeqLo;
unsigned m_ReadSeqLength;
unsigned m_Identities;
unsigned m_Mismatches;
unsigned m_Gaps;
unsigned m_GapOpens;
unsigned m_GapExts;
unsigned m_ColCount;
string m_Cigar;
const char *m_Qual;
const char *m_MD;
GoBuff<char> m_RRow;
GoBuff<char> m_ARow;
GoBuff<char> m_TRow;
GoBuff<char> m_TSeg;
double m_Evalue;
bool m_RStrand;
bool m_IsHardClipped;
vector<char> m_CigarChars;
vector<unsigned> m_CigarInts;
public:
void Clear();
void LogMe() const { Log("%s\n", m_Line.c_str()); }
void FromLine(const string &Line);
void FromLine(const char *Line);
void ToFile(FILE *f) const;
void ToBlast6(FILE *f);
void ReadSeqToFasta(FILE *f) const;
unsigned GetReadLo() const { return m_ReadLo; }
unsigned GetReadHi() { return m_ReadLo + GetReadSegLength() - 1; }
unsigned GetTargetLo() const { return m_TargetLo; }
unsigned GetTargetHi();
unsigned GetReadSegLength();
unsigned GetTargetSegLength();
unsigned GetInsertCount();
unsigned GetDeleteCount();
SAMRec *MakeCopy() const;
bool HardClipped() const { return m_IsHardClipped; }
void SetCigarVecs()
{
if (m_CigarInts.empty())
CigarToVecs(m_Cigar, m_CigarInts, m_CigarChars);
}
unsigned GetReadSeqLength() const
{
return m_ReadSeqLength;
}
const unsigned GetColCount() const
{
return m_ColCount;
}
bool IsUnmapped() const
{
return (m_BitFlags & 4) != 0;
}
bool IsFirst() const
{
return (m_BitFlags & 0x40) != 0;
}
bool IsSecond() const
{
return (m_BitFlags & 0x80) != 0;
}
bool IsSecondary() const
{
return (m_BitFlags & 0x100) != 0;
}
bool IsSupplementary() const
{
return (m_BitFlags & 0x800) != 0;
}
bool NotPrimary() const
{
return IsSecondary() || IsSupplementary();
}
// true=plus strand, false=revcomped
bool GetStrand() const
{
return (m_BitFlags & 16) == 0;
}
unsigned GetMapq() const { return m_Mapq; }
void PrAln(FILE *f);
void ValidateTRow(SeqInfo *Target);
void ValidateReadSeqLength();
const char *GetRRow();
const char *GetTRow();
const char *GetARow();
double GetPctId() const
{
if (m_Identities == UINT_MAX)
return DBL_MAX;
return GetPct(m_Identities, m_ColCount);
}
double GetPctId2();
double GetEvalue() const;
double GetReadCovPct() const;
unsigned GetReadLength() const;
unsigned GetTargetMidPos()
{
return (GetTargetLo() + GetTargetHi())/2;
}
const char *GetTag(const char *TagName);
unsigned CalcGapOpens();
unsigned CalcGaps();
void GetColToTargetPos(vector<unsigned> &ColToTargetPos);
void GetPath(string &Path, bool ReadIsQuery = true);
unsigned CigarToColCount(const string &Cigar) const;
unsigned CigarToReadLo(const string &Cigar) const;
unsigned CigarToReadSeqLo(const string &Cigar) const;
unsigned CigarToReadSeqLength(const string &Cigar) const;
unsigned CigarToReadLength(const string &Cigar) const;
};
#endif // samrec_h
| 3,810
|
C++
|
.h
| 143
| 24.286713
| 76
| 0.738521
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,035
|
hspfinder.h
|
rcedgar_urmap/src/hspfinder.h
|
#ifndef hspfinder_h
#define hspfinder_h
#include "alnparams.h"
#include "alnheuristics.h"
#include "chainer.h"
#include "seqinfo.h"
#include "hsp.h"
const unsigned MaxReps = 8;
const unsigned ANCLEN2 = 11;
class HSPFinder
{
public:
bool m_Nucleo;
const AlnHeuristics *m_AH;
const AlnParams *m_AP;
const float *const *m_SubstMx;
unsigned m_WordLength;
unsigned m_WordCount;
unsigned m_Hi;
unsigned m_AlphaSize;
byte *m_CharToLetter;
const SeqInfo *m_SA;
const SeqInfo *m_SB;
unsigned *m_WordToPosA;
unsigned *m_WordCountsA;
unsigned *m_DiagToPosB;
unsigned m_DiagToPosBSize;
uint32 *m_WordsA;
uint32 *m_WordsB;
unsigned m_WordCountA;
unsigned m_WordCountB;
unsigned m_WordsASize;
unsigned m_WordsBSize;
// HSPData memory is owned by m_Un/GappedHSPs.
// m_ChainedHSPs is a vector of pointers to
// memory owned by someone else.
HSPData **m_UngappedHSPs;
HSPData **m_GappedHSPs;
HSPData **m_ChainedHSPs;
// PathData **m_Paths;
unsigned m_HSPSize;
unsigned m_UngappedHSPCount;
unsigned m_GappedHSPCount;
unsigned m_ChainedHSPCount;
Chainer m_Chainer;
public:
HSPFinder();
~HSPFinder();
void Clear(bool ctor = false);
void Init(const AlnParams &AP, const AlnHeuristics &AH);
void SetA(SeqInfo *SI);
void SetB(SeqInfo *SI);
unsigned GetCommonWordCount() const;
unsigned GetGlobalHSPs(unsigned MinLength, float MinFractId, bool StaggerOk,
float &HSPFractId);
void UngappedBlast(float X, bool StaggerOk, unsigned MinLength = 0,
float MinScore = -1.0f);
void UngappedBlast2Hit(float X, unsigned MinLength = 0,
float MinScore = -1.0f);
unsigned GetAnchor2(unsigned PosA, unsigned PosB, unsigned L);
void UngappedExtendLeft(unsigned PosA, unsigned PosB, float X, unsigned &Length,
float &Score);
void UngappedExtendRight(unsigned PosA, unsigned PosB, float X, unsigned &Length,
float &Score);
float ComputeMinUngappedRawScoreForGappedBlast() const;
void AllocHSPCount(unsigned MaxHSPCount);
const char *WordToStr(unsigned Word) const;
void LogMe() const;
unsigned SeqToWord(const byte *Seq) const;
float ComputeGaplessHSPScore(const HSPData &HSP,
const float * const *SubstMx) const;
static float GetAnchor(const HSPData &HSP, const byte *A, const byte *B,
const AlnParams &AP, unsigned &Loi, unsigned &Loj, unsigned &Len);
void LogHSPs() const;
void LogHSPsDot(HSPData **HSPs, unsigned HSPCount);
void BlastOut(const HSPData *const *HSPs, unsigned HSPCount);
void WriteHSP(FILE *f, const HSPData &HSP) const;
void WriteHSP_ORF(FILE *f, const HSPData &HSP) const;
void WriteHSPs(FILE *f, const vector<HSPData> &HSPs) const;
void WriteHSPBlast6(const HSPData &HSP) const;
unsigned SeqToWords(const byte *Seq, unsigned L, uint32 *Words) const;
void AllocLA(unsigned LA);
void AllocLB(unsigned LB);
void AllocDiags(unsigned DiagCount);
unsigned GetHSPIdCount(const HSPData &HSP) const;
void Chain();
static bool IsGlobalHSP(unsigned ALo, unsigned BLo, unsigned Length, unsigned LA, unsigned LB);
static bool HSPInPath(const HSPData &HSP, const char *Path);
};
#endif // hspfinder_h
| 3,081
|
C++
|
.h
| 90
| 31.977778
| 96
| 0.777066
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,037
|
bitvec.h
|
rcedgar_urmap/src/bitvec.h
|
#ifndef bitvec_h
#define bitvec_h
class BitVec
{
public:
byte *m_Vec;
uint64 m_BitCount;
public:
BitVec();
virtual ~BitVec();
void Alloc(uint64 BitCount);
void Free();
bool GetBit(uint64 n) const;
void SetBit(uint64 n);
void ClearBit(uint64 n);
void Zero();
};
static const uint32 BV_MAGIC = MAGIC('B', 'V', '1', '0');
#endif // bitvec_h
| 354
|
C++
|
.h
| 19
| 16.789474
| 57
| 0.703927
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,038
|
getticks.h
|
rcedgar_urmap/src/getticks.h
|
#ifndef getticks_h
#define getticks_h
// ~3 x 10^9 ticks/sec
#ifdef _MSC_VER
#include <Windows.h>
typedef unsigned __int64 TICKS;
#define GetClockTicks __rdtsc
#elif __GNUC__
typedef uint64_t TICKS;
__inline__ uint64_t GetClockTicks()
{
uint32_t lo, hi;
/* We cannot use "=A", since this would use %rax on x86_64 */
__asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
return (uint64_t)hi << 32 | lo;
}
#else
#error "getticks_h, unknown compiler"
#endif
#endif // getticks_h
| 490
|
C++
|
.h
| 20
| 22.85
| 62
| 0.678186
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,039
|
ufindex.h
|
rcedgar_urmap/src/ufindex.h
|
#ifndef ufindex_h
#define ufindex_h
#include "seqdb.h"
#include "readsimbench.h"
#define TSLOT 0
class SeqInfo;
const unsigned UFI_MAGIC1 = MAGIC('U', 'F', 'I', '1');
const unsigned UFI_MAGIC2 = MAGIC('U', 'F', 'I', '2');
const unsigned UFI_MAGIC3 = MAGIC('U', 'F', 'I', '3');
const unsigned UFI_MAGIC4 = MAGIC('U', 'F', 'I', '4');
const unsigned UFI_MAGIC5 = MAGIC('U', 'F', 'I', '5');
/***
Tally = Mnnnnnnn
M My bit, 1=mine, 0=other.
nnnnn 7-bit offset of next in list, 1111111=end.
***/
static const byte TALLY_FREE = 0; // 0b00000000; // 0
static const byte TALLY_END = 127; // 0b01111111; // 127
static const byte TALLY_MY_BIT = 128; // 0b10000000; // 128
static const byte TALLY_PLUS1 = 254; // 0b11111110; // 254
static const byte TALLY_BOTH1 = 255; // 0b11111111; // 255
static const byte TALLY_MAX_NEXT = 124; // 0b01111100; // 124
static const byte TALLY_NEXT_LONG = 125; // 0b01111101; // 125
static const byte TALLY_NEXT_MASK = 127; // 0b01111111; // 127
static const byte TALLY_NEXT_LONG_MINE = 253; // 0b11111101; // 253
static const byte TALLY_NEXT_LONG_OTHER = 125; // 0b01111101; // 125
static const unsigned MAX_LINK_STEP = 0xffff;
//// http://xoshiro.di.unimi.it/splitmix64.c
//uint64_t
//splittable64(uint64_t x)
//{
// x ^= x >> 30;
// x *= UINT64_C(0xbf58476d1ce4e5b9);
// x ^= x >> 27;
// x *= UINT64_C(0x94d049bb133111eb);
// x ^= x >> 31;
// return x;
//}
static inline uint64 murmur64(uint64 h)
{
h ^= (h >> 33);
h *= 0xff51afd7ed558ccdL;
h ^= (h >> 33);
h *= 0xc4ceb9fe1a85ec53L;
h ^= (h >> 33);
return h;
}
static inline uint64 WordToSlot(uint64 Word, uint64 SlotCount)
{
uint64 h = murmur64(Word);
uint64 Slot = h%SlotCount;
return Slot;
}
static inline bool TallyEnd(byte T)
{
return T == TALLY_END;
}
static inline bool TallyMine(byte T)
{
return (T & TALLY_MY_BIT) != 0;
}
static inline bool TallyHasPos(byte T)
{
return T != TALLY_FREE && T != TALLY_NEXT_LONG_MINE;
}
static inline byte TallyOther(byte T)
{
return (T & TALLY_MY_BIT) == 0;
}
static inline byte GetTallyNext(byte T)
{
assert(T != TALLY_END);
byte Next = (T & TALLY_NEXT_MASK);
assert(Next != 0);
return Next;
}
const unsigned PADGAP = 32;
class UFIndex
{
public:
uint32 m_WordLength;
uint32 m_MaxIx;
byte *m_Blob;
uint64 m_SlotCount;
// Misc helpers
uint64 m_ShiftMask;
uint64 m_LowerCaseShiftMask;
// Sequence data
byte *m_SeqData;
uint32 m_SeqDataSize;
// Sequence directory
vector<string> m_Labels;
vector<uint32> m_SeqLengths;
vector<uint32> m_Offsets;
// Temp data needed for build
byte *m_SlotCounts;
byte *m_SlotCounts_Minus;
// Build stats
uint64 m_GenomeSize;
uint64 m_IndexedPosCount;
unsigned m_TruncatedCount;
unsigned m_StartPos;
unsigned m_EndPos;
public:
UFIndex()
{
m_WordLength = 0;
m_MaxIx = 0;
m_Blob = 0;
m_SlotCount = 0;
m_ShiftMask = 0;
m_SeqData = 0;
m_GenomeSize = 0;
m_SeqDataSize = 0;
m_IndexedPosCount = 0;
m_SlotCounts = 0;
m_SlotCounts_Minus = 0;
m_TruncatedCount = 0;
m_StartPos = UINT_MAX;
m_EndPos = UINT_MAX;
}
void SetTally(uint64 Slot, byte T)
{
#if TSLOT
if (Slot == TSLOT)
{
Log("SetTally(%" PRIx64 ") ", Slot, T);
LogTally(T);
Log("\n");
}
#endif
m_Blob[5*Slot] = T;
}
byte GetTally(uint64 Slot) const
{
byte T = m_Blob[5*Slot];
return T;
}
void SetPos(uint64 Slot, uint32 Pos)
{
#if TSLOT
if (Slot == TSLOT)
Log("SetPos(%" PRIx64 ", %x)\n", Slot, Pos);
#endif
*(uint32 *) (m_Blob + 5*Slot + 1) = Pos;
}
uint32 GetPos(uint64 Slot) const
{
uint32 Pos = *(uint32 *) (m_Blob + 5*Slot + 1);
return Pos;
}
void GetBlob(uint64 Slot, byte *ptrBlob) const
{
memcpy(ptrBlob, m_Blob + 5*Slot, 5);
}
void SetTallyNext(uint64 Slot, byte Next)
{
byte T = GetTally(Slot);
T = (T & TALLY_MY_BIT) | Next;
SetTally(Slot, T);
}
void LogMe() const;
void LogSeqDict() const;
void LogSlots(uint64 SlotLo, uint64 N) const;
void ToFile(FILE *f) const;
void ToFile(const string &FileName) const;
void FromFile(FILE *f);
void FromFile(const string &FileName);
void Validate() const;
void FreeHashTable() { myfree(m_Blob), m_Blob = 0; }
void FreeTempBuildData();
void LogSlot(uint64 Slot) const;
void ValidateSlot(uint64 Slot) const;
void GetCollisionCount(uint64 &n, uint64 &N) const;
const char *GetStr(uint32 Pos, unsigned n, string &s) const;
const char *WordToStr(uint64 Word, string &s) const;
uint64 SeqToWord(const byte *Seq) const;
uint64 GetWord(uint32 Pos) const;
void CountSlots();
void CountSlots_Minus();
//void IncCountSlots_Minus();
void MakeIndex();
void LogCountHist() const;
void CountIndexedWords(unsigned &IndexedCount,
unsigned &NotIndexedCount, unsigned &WildcardCount);
unsigned GetSeqIndex(const string &Label) const;
const byte *GetSeq(unsigned SeqIndex) const;
uint32 PosToCoord(uint32 Pos, string &Label) const;
uint32 PosToCoordL(uint32 Pos, string &Label, unsigned &L) const;
uint32 CoordToPos(const string &Label, uint32 Coord) const;
void GetUserPosStr(uint32 Pos, string &s) const;
unsigned GetSeqLength(const string &Label) const;
unsigned GetSeqLength(unsigned SeqIndex) const;
void SetShiftMask();
void ReadSeqData(const string &FastaFileName);
void UpdateSlot(uint64 Slot, uint32 Pos);
unsigned GetRow(uint64 Slot, uint32 *PosVec) const;
unsigned GetRow_Validate(uint64 Slot, uint32 *PosVec) const;
unsigned GetRow_Blob(uint64 Slot, const byte *ptrBlob, uint32 *PosVec) const;
void LogStats();
uint64 FindEndOfList(uint64 Slot) const;
unsigned FindFreeSlot(uint64 Slot);
void LogRow(uint64 Slot) const;
void TruncateSlot(uint64 Slot);
void LogTally(byte T) const;
void LogList(uint64 Slot) const;
};
#endif // ufindex_h
| 5,762
|
C++
|
.h
| 208
| 25.548077
| 78
| 0.700852
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,040
|
outfiles.h
|
rcedgar_urmap/src/outfiles.h
|
#ifndef outfiles_h
#define outfiles_h
extern FILE *g_fOut;
extern FILE *g_fSAM;
extern FILE *g_fTab;
void OpenOutputFiles();
void CloseOutputFiles();
#endif // outfiles_h
| 174
|
C++
|
.h
| 8
| 20.375
| 24
| 0.785276
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,041
|
myopts.h
|
rcedgar_urmap/src/myopts.h
|
#ifndef MY_VERSION
#define MY_VERSION "1.0"
#endif
#define PROGRAM_NAME "urmap"
#define A(x) STR_OPT(x)
#include "cmds.h"
STR_OPT(log) // Log file for informational messages.
STR_OPT(output) // Output filename
STR_OPT(output1) // Output filename
STR_OPT(output2) // Output filename
STR_OPT(report) // Output filename
STR_OPT(fastaout) // FASTA output from some commands.
STR_OPT(matched) // Query sequences that matched the database.
STR_OPT(matchedfq) // Query sequences that matched the database.
STR_OPT(notmatched) // Query sequences that did not match the database.
STR_OPT(notmatchedfq) // Query sequences that did not match the database.
STR_OPT(dbmatched) // Database sequences that matched at least one query.
STR_OPT(dbnotmatched) // Database sequences that did not match a query.
STR_OPT(samout) // Hits in SAM format.
STR_OPT(sumout) // Hits in SAM format.
STR_OPT(tabbedout) // Hits in SAM format.
STR_OPT(whitelist)
STR_OPT(readinfo)
STR_OPT(trainhits) //
STR_OPT(tabbedotus) //
STR_OPT(rocout) //
STR_OPT(otutabin) //
STR_OPT(otutabout) //
STR_OPT(biomout) //
STR_OPT(ee_cutoffs) //
STR_OPT(length_cutoffs) //
STR_OPT(barcodes) //
STR_OPT(outputdir) //
STR_OPT(filename_prefix)//
STR_OPT(filename_suffix)//
STR_OPT(knowndb) //
STR_OPT(primerdiffsdb) //
STR_OPT(copynrdb) //
STR_OPT(idfreqs) //
STR_OPT(sortedout) //
STR_OPT(newickout) //
STR_OPT(mx_suffix)
STR_OPT(sorted_mx_suffix)
STR_OPT(tree_suffix)
STR_OPT(hitsout)
STR_OPT(start_motif)
STR_OPT(end_motif)
STR_OPT(taxtree)
STR_OPT(fragout)
STR_OPT(attr)
STR_OPT(dbotus)
STR_OPT(dataotus)
STR_OPT(range)
STR_OPT(fwdprimer)
STR_OPT(revprimer)
STR_OPT(otutab_with_singles)
STR_OPT(mockhits)
STR_OPT(slots)
STR_OPT(tsout)
STR_OPT(tqout)
STR_OPT(order)
STR_OPT(matrix) // Input filename, substitution matrix in BLAST format.
STR_OPT(gapopen) // String specifying gap open penalty(ies).
STR_OPT(gapext) // String specifying gap extension penalty(ies).
STR_OPT(strand) // Strand for nt search (plus or both).
STR_OPT(ufi) // Database filename
STR_OPT(mufi) // Database filename
STR_OPT(ref) // Database filename
STR_OPT(input) // -
STR_OPT(input1) // -
STR_OPT(input2) // -
STR_OPT(reverse) // Input filename, reverse reads for merging.
STR_OPT(qmask) // Query masking (none, seg, dust, fastamino, fastnucleo, soft).
STR_OPT(dbmask) // Database masking (none, seg, dust, fastamino, fastnucleo, soft).
STR_OPT(userfields) // Fields to appear in -userout file.
STR_OPT(pattern) // Pattern for spaced alignment seeds.
STR_OPT(relabel) // Re-label input sequences in output files.
STR_OPT(prefix) // Label prefix
STR_OPT(fastqout) // Output file, FASTQ format.
STR_OPT(eetabbedout) // Output file, expected errors in tabbed text format.
STR_OPT(traindbout) //
STR_OPT(xdrop_save) // -
STR_OPT(gi2tax) // -
STR_OPT(label) // Sequence label.
STR_OPT(labels) // Input file, text format containing sequence labels.
STR_OPT(label_suffix) // Suffix appended to label of merged reads.
STR_OPT(nast_delgap) // Character to use for deletion gap in NAST output.
STR_OPT(nast_padgap) // Character to use for padding gap in NAST output.
STR_OPT(nast_termgap) // Character to use for terminal gap in NAST output.
STR_OPT(nast_locgap) // Character to use for unaligned sequence gap in NAST output.
STR_OPT(join_padgap) // Letters to use for FASTQ join padding, default NNNNNNNN.
STR_OPT(join_padgapq) // Q scores to use for FASTQ join padding, default IIIIIIII.
STR_OPT(sort) // Sort order (length, size or other)
STR_OPT(uparseout) // Output file, UPARSE tabbed format.
STR_OPT(sortedby) // Sort order (length, size, other)
STR_OPT(clusterout) // Cluster output file, tabbed text, clusternr+label.
STR_OPT(ids) //
STR_OPT(padq) //
STR_OPT(taxbench_cutoffs) //
STR_OPT(ocreport) //
STR_OPT(constax_report) //
STR_OPT(label_words) //
STR_OPT(label_word) //
STR_OPT(sample) //
STR_OPT(label_field) //
STR_OPT(mothur_shared_out) //
STR_OPT(mode) //
STR_OPT(boot_subset) //
STR_OPT(metric) //
STR_OPT(metrics) //
STR_OPT(bitvec) //
STR_OPT(diffsin) //
STR_OPT(copynrin) //
STR_OPT(groups) //
STR_OPT(field1) //
STR_OPT(field2) //
STR_OPT(script) //
STR_OPT(sample_delim) //
STR_OPT(mapout) //
STR_OPT(rank) //
STR_OPT(meta) //
STR_OPT(test_samples) //
STR_OPT(train_samples) //
STR_OPT(dbcutout) //
STR_OPT(fields) //
STR_OPT(forestout) //
STR_OPT(forestin) //
STR_OPT(poscat) //
STR_OPT(weight_rank) //
STR_OPT(lcr_probs) //
STR_OPT(featuresout) //
STR_OPT(testdb) //
STR_OPT(svgout) //
STR_OPT(htmlout) //
STR_OPT(sintaxin) //
STR_OPT(fqin) //
STR_OPT(segs) //
STR_OPT(track) //
STR_OPT(tracks) //
STR_OPT(orphans) //
STR_OPT(bits) //
UNS_OPT(stepwords, 8, 0, UINT_MAX) // -
UNS_OPT(bump, 50, 0, 100) // -
UNS_OPT(rowlen, 80, 8, UINT_MAX) // Length of alignment row for -alnout.
UNS_OPT(mincodons, 20, 1, UINT_MAX) // Min number of codons in an ORF.
UNS_OPT(orfstyle, (1+4), 0, UINT_MAX) // Options for ORF detection.
UNS_OPT(randseed, 1, 0, UINT_MAX) // Integer seed for random number generator.
UNS_OPT(minsize, 0, 0, UINT_MAX) // Min cluster size.
UNS_OPT(maxsize, 0, 0, UINT_MAX) // Min cluster size.
UNS_OPT(minuniquesize, 0, 0, UINT_MAX) // Min cluster size.
UNS_OPT(threads, 0, 0, UINT_MAX) // Number of threads (default: one per core).
UNS_OPT(maxhits, 0, 0, UINT_MAX) // Max number of hits to report for one query.
UNS_OPT(big, 100000, 0, UINT_MAX) // -
UNS_OPT(minseqlength, 8, 1, UINT_MAX) // Min sequence length (sortbysize output).
UNS_OPT(wordlength, 0, 1, UINT_MAX) // Word length for indexing.
UNS_OPT(dbstep, 0, 1, UINT_MAX) // Database step parameter.
UNS_OPT(dbaccelpct, 100, 1, 100) // Database accel parameter.
UNS_OPT(posbits, 11, 1, 100) // -
UNS_OPT(sample_size, 32, 1, UINT_MAX) // Sample size for sub-sampling.
UNS_OPT(sample_pct, 1, 1, 100) // Sample fraction for sub-sampling.
UNS_OPT(subseq_start, UINT_MAX, 1, UINT_MAX) // Start of subsequence (1-based coordinate).
UNS_OPT(subseq_end, UINT_MAX, 1, UINT_MAX) // End of subsequence (1-based coordinate).
UNS_OPT(mosaic_minseg, 16, 1, UINT_MAX) // Min segment size.
UNS_OPT(maxdqm, UINT_MAX, 0, UINT_MAX) // -
UNS_OPT(mindqt, 1, 1, UINT_MAX) // -
UNS_OPT(min_sample_size, 1, 1, UINT_MAX) // -
UNS_OPT(min_otu_size, 1, 1, UINT_MAX) // -
UNS_OPT(min_otu_samples, 1, 1, UINT_MAX) // -
UNS_OPT(min_otu_sample_pct, 0, 100, UINT_MAX) // -
UNS_OPT(min_count, 0, 0, UINT_MAX) // -
UNS_OPT(annot_mindqt, 4, 4, UINT_MAX) // -
UNS_OPT(lo, UINT_MAX, 0, UINT_MAX) // -
UNS_OPT(hi, UINT_MAX, 0, UINT_MAX) // -
UNS_OPT(minq, 10, 0, UINT_MAX) // -
UNS_OPT(min_gene_length, 1200, 1, UINT_MAX) // -
UNS_OPT(max_gene_length, 2000, 1, UINT_MAX) // -
UNS_OPT(fastq_truncqual, UINT_MAX, 0, UINT_MAX) // Truncate FASTQ read at first base with Q<=fastq_truncqual.
UNS_OPT(fastq_minqual, UINT_MAX, 0, UINT_MAX) // Discard FASTQ read if any Q < minqual
UNS_OPT(fastq_minlen, 0, 0, UINT_MAX) // Min length of FASTQ read after filtering.
UNS_OPT(fastq_minovlen, 16, 4, UINT_MAX) // Min overlap of read pair for merging.
UNS_OPT(fastq_trunclen, 0, 0, UINT_MAX) // Truncate FASTQ at this length.
UNS_OPT(fastq_maxdiffs, 5, 0, UINT_MAX) // Max number of subs allowed in overlap for merging.
UNS_OPT(fastq_maxdiffpct, 5, 0, UINT_MAX) // Max number of subs allowed in overlap for merging.
UNS_OPT(fastq_pctid, 90, 0, UINT_MAX) // Minimum alignment identity for merging
UNS_OPT(fastq_ascii, 33, 0, UINT_MAX) // ASCII base value for Q scores.
UNS_OPT(fastq_qmin, 0, 0, UINT_MAX) // Min Q score allowed by FASTQ format.
UNS_OPT(fastq_qmax, 42, 0, UINT_MAX) // Max Q score allowed by FASTQ format.
UNS_OPT(fastq_qmaxout, 42, 0, UINT_MAX) // Max Q score allowed by FASTQ format (output files).
UNS_OPT(fastq_tail, 4, 1, UINT_MAX) // Min number of bases in a FASTQ tail.
UNS_OPT(fastq_trunctail, 2, 0, UINT_MAX) // :doc Truncate tail
UNS_OPT(fastq_minmergelen, 0, 1, UINT_MAX) // Min length allowed for merged read.
UNS_OPT(fastq_maxmergelen, 0, 1, UINT_MAX) // Max length allowed for merged read.
UNS_OPT(fastq_merge_minread,0, 1, UINT_MAX) // Min length allowed for fwd or rev read
UNS_OPT(fastq_stripleft, 0, 0, UINT_MAX) // Discard this number of bases at start of FASTQ read.
UNS_OPT(fastq_stripright, 0, 0, UINT_MAX) // Discard this number of bases at end of FASTQ read.
UNS_OPT(maxns, UINT_MAX, 1, UINT_MAX) // :document
UNS_OPT(trunclen, 0, 1, UINT_MAX) // Truncate length.
UNS_OPT(padlen, 0, 1, UINT_MAX) // Pad with Ns if shorter.
UNS_OPT(stripleft, 0, 0, UINT_MAX) // Nr. positions to delete at start of sequence.
UNS_OPT(stripright, 0, 0, UINT_MAX) // Nr. positions to delete at end of sequence.
UNS_OPT(taxid, 0, 1, UINT_MAX) // :document
UNS_OPT(splits, 0, 1, UINT_MAX) // :document
UNS_OPT(sim_maxns, 8, 0, UINT_MAX) // :document
UNS_OPT(max_clade_size, 0, 0, UINT_MAX) // :document
UNS_OPT(self_words_drop, 4, 1, UINT_MAX) // :document
UNS_OPT(flank, 8, 1, UINT_MAX) // :document
UNS_OPT(target_count, 500, 1, UINT_MAX) // :document
//UNS_OPT(minampsize, 8, 1, UINT_MAX) // :document
UNS_OPT(mincount, UINT_MAX, 0, UINT_MAX) // :document
UNS_OPT(readlength, UINT_MAX, 0, UINT_MAX) // :document
UNS_OPT(tries, 6, 1, UINT_MAX) // :document
UNS_OPT(trace, 0, UINT_MAX, UINT_MAX) // :document
UNS_OPT(mindectreeleafsize, 0, UINT_MAX, UINT_MAX) // :document
UNS_OPT(seqs_per_split, 1, 0, UINT_MAX) // :document
// uchime
UNS_OPT(maxp, 2, 2, UINT_MAX) // Max number of parents to consider.
UNS_OPT(idsmoothwindow, 32, 1, UINT_MAX) // Window size for %id smoothing.
UNS_OPT(mindiffs, 3, 1, UINT_MAX) // Mininum diffs to allow on each side of cross-over.
UNS_OPT(chunks, 4, 2, UINT_MAX) // Number of chunks.
UNS_OPT(chunk_length, 0, 0, UINT_MAX) // Number of chunks.
UNS_OPT(chunk_overlap, 0, 0, UINT_MAX) // Number of chunks.
UNS_OPT(minchunk, 64, 2, UINT_MAX) // Min chunk size.
UNS_OPT(maxaccepts, 1, 0, UINT_MAX) // Max number of accepts.
UNS_OPT(maxrejects, 32, 0, UINT_MAX) // Max number of rejects.
UNS_OPT(band, 16, 0, UINT_MAX) // Min band width.
UNS_OPT(hspw, 0, 1, UINT_MAX) // Word length for HSP finding.
UNS_OPT(minhsp, 16, 1, UINT_MAX) // Min length of HSP.
UNS_OPT(idprefix, 0, 0, UINT_MAX) // Min number of identical bases at start of alignment.
UNS_OPT(idsuffix, 0, 0, UINT_MAX) // Min number of identical bases at end of alignment.
UNS_OPT(maxdiffs, UINT_MAX, 0, UINT_MAX) // Min number of diffs (subs+gaps) in the alignment.
UNS_OPT(maxsubs, UINT_MAX, 0, UINT_MAX) // Min number of substitutions in the alignment.
UNS_OPT(maxgaps, UINT_MAX, 0, UINT_MAX) // Min number of gapped columns in the alignment.
UNS_OPT(mincols, 0, 0, UINT_MAX) // Min number of columns in the alignment.
UNS_OPT(mindiffsa, UINT_MAX, 0, UINT_MAX) //
UNS_OPT(maxdiffsa, UINT_MAX, 0, UINT_MAX) //
UNS_OPT(maxseqlength, 50000, 1, UINT_MAX) // Max seqlence length (sortbylength).
UNS_OPT(topn, UINT_MAX, 1, UINT_MAX) // Output only the first topn sequences (sortbysize, sortbylength).
UNS_OPT(uparse_maxhot, 32, 1, UINT_MAX) // Max nr of candidate parents to consider.
UNS_OPT(uparse_maxdrop, 8, 0, UINT_MAX) // -
UNS_OPT(uparse_maxdball, 100, 0, UINT_MAX) // -
UNS_OPT(boots, 100, 1, UINT_MAX) // -
UNS_OPT(iters, 32, 1, UINT_MAX) // -
UNS_OPT(linebuff, (32*1024*1024), 100, UINT_MAX) // Max length of a line in an input file.
UNS_OPT(default_size, UINT_MAX, 1, UINT_MAX) // Default size for sortbysize.
UNS_OPT(long_target, 50000, 1, UINT_MAX) // -
UNS_OPT(minamp, 50, 1, UINT_MAX) // Min amplicon length (search_pcr).
UNS_OPT(maxamp, 1000, 1, UINT_MAX) // Max amplicon length (search_pcr).
UNS_OPT(secs, 0, 0, UINT_MAX) // -
UNS_OPT(fasta_cols, 80, 0, UINT_MAX) // Max length of a line when writing FASTA sequence, zero=all on one line.
UNS_OPT(readcount, 0, 1, UINT_MAX) // Nr reads to generate (readsim command).
UNS_OPT(chsim_segcount, 2, 2, UINT_MAX) // -
UNS_OPT(startcol, 0, 0, UINT_MAX) // -
UNS_OPT(endcol, 0, 0, UINT_MAX) // -
UNS_OPT(maxstartdiffs, 4, 0, UINT_MAX) // -
UNS_OPT(maxenddiffs, 4, 0, UINT_MAX) // -
UNS_OPT(fastq_filter_qiime_r, 3, 0, UINT_MAX) // -
UNS_OPT(fastq_filter_qiime_n, 0, 0, UINT_MAX) // -
UNS_OPT(fastq_filter_qiime_q, 3, 0, UINT_MAX) // -
UNS_OPT(trees, 100, 1, UINT_MAX) // Nr trees in random forest
UNS_OPT(testpct, 17, 1, UINT_MAX) //
UNS_OPT(width, UINT_MAX, 1, UINT_MAX) //
UNS_OPT(col, UINT_MAX, 1, UINT_MAX) //
UNS_OPT(node, UINT_MAX, 1, UINT_MAX) //
UNS_OPT(xt_minsize, 1000, 1, UINT_MAX) //
UNS_OPT(xt_minotus1, 10, 1, UINT_MAX) //
UNS_OPT(subs_per_read, 0, 0, UINT_MAX) //
UNS_OPT(ins_per_read, 0, 0, UINT_MAX) //
UNS_OPT(dels_per_read, 0, 0, UINT_MAX) //
UNS_OPT(indels_per_read, 0, 0, UINT_MAX) //
UNS_OPT(maxix, 32, 1, UINT_MAX) //
UNS_OPT(chunk_maxix, 16, 1, UINT_MAX) //
UNS_OPT(molcount, 1, 0, UINT_MAX) // :document
FLT_OPT(fastq_filter_qiime_p, 0.75, 0.0, 1.0) // -
FLT_OPT(minpctidqmn, 97.0, 0.0, 100.0) // -
FLT_OPT(min_cons_pct, 50.0, 0.0, 100.0) // Min conservation for consensus sequence.
FLT_OPT(weak_id, 0.0, 0.0, 1.0) // Min identity for weak hit.
FLT_OPT(weak_evalue, 10.0, 0.0, DBL_MAX) // Max E-value for weak hit.
FLT_OPT(ka_gapped_lambda, 0.0, 0.0, DBL_MAX) // Lambda for gapped alignments.
FLT_OPT(ka_ungapped_lambda, 0.0, 0.0, DBL_MAX) // Lambda for ungapped alignments.
FLT_OPT(ka_gapped_k, 0.0, 0.0, DBL_MAX) // K for gapped alignments.
FLT_OPT(ka_ungapped_k, 0.0, 0.0, DBL_MAX) // K for ungapped alignments.
FLT_OPT(ka_dbsize, 3e9, 1.0, DBL_MAX) // Effective database size.
FLT_OPT(accel, 0.8, 0.0, 1.0) // Accel parameter for UBLAST.
FLT_OPT(uparse_match, 0, -1000.0, 1000.0) // Match score for UPARSE-REF d.p.
FLT_OPT(uparse_mismatch, -1.0, -1000.0, 1000.0) // Mismatch score for UPARSE-REF d.p.
FLT_OPT(uparse_break, -3.0, -1000.0, 1000.0) // Chimeric breakpoint score for UPARSE-REF d.p.
FLT_OPT(id, 0.0, 0.0, 1.0) // Min identity (0.0 to 1.0) for search.
FLT_OPT(mid, 0.0, 0.0, 1.0) // Min match identity (0.0 to 1.0) for search.
FLT_OPT(evalue, 10.0, 0.0, DBL_MAX) // Max E-value.
FLT_OPT(minqt, 0.0, 0.0, DBL_MAX) // Min query/target length ratio.
FLT_OPT(maxqt, DBL_MAX, 0.0, DBL_MAX) // Max query/target length ratio.
FLT_OPT(minsl, 0.0, 0.0, DBL_MAX) // Min shorter/longer length ratio.
FLT_OPT(maxsl, DBL_MAX, 0.0, DBL_MAX) // Max shorter/longer length ratio.
FLT_OPT(maxid, 1.0, 0.0, 1.0) // Max identity (0.0 to 1.0) for hit.
FLT_OPT(min_sizeratio, 0.0, 0.0, DBL_MAX) // Min size ratio.
FLT_OPT(match, 1.0, 0.0, DBL_MAX) // Match score.
FLT_OPT(mismatch, -2.0, 0.0, DBL_MAX) // Mismatch score.
FLT_OPT(xdrop_u, 16.0, 0.0, DBL_MAX) // X-drop parameter for ungapped alignments.
FLT_OPT(xdrop_g, 32.0, 0.0, DBL_MAX) // X-drop parameter for gapped alignments.
FLT_OPT(xdrop_nw, 16.0, 0.0, DBL_MAX) // X-drop parameter for HSP-finding.
FLT_OPT(minh, 0.35, 0.0, DBL_MAX) // Min chimera score for yes
FLT_OPT(xn, 8.0, 0.0, DBL_MAX) // No vote wight.
FLT_OPT(dn, 1.4, 0.0, DBL_MAX) // Pseudo-count prior.
FLT_OPT(xa, 1.0, 0.0, DBL_MAX) // Abstain vote weight.
FLT_OPT(mindiv, 1.0, 0.0, 100.0) // Min chimera divergence.
FLT_OPT(uparse_annot_maxdivqm,1.0, 0.0, 100.0) // Max divergence between query and model.
FLT_OPT(maxee, DBL_MAX, 0.0, DBL_MAX) // Max expected errors in FASTQ read.
FLT_OPT(fastq_maxee_rate, DBL_MAX, 0.0, 1.0) // Max expected errors per base in FASTQ read.
FLT_OPT(abskew, 2, 0.0, 100.0) // Min abundance skew.
FLT_OPT(min_unmasked_pct, 0.0, 0.0, 100.0) // Min fraction of sequence left unmasked.
FLT_OPT(max_unmasked_pct, 100.0, 0.0, 100.0) // Max fraction of sequence left unmasked.
FLT_OPT(max_lowc_pct, 25.0, 0.0, 100.0) // Max low-complexity sequence pct
FLT_OPT(query_cov, 0.0, 0.0, 1.0) // Min fraction of query covered by alignment.
FLT_OPT(target_cov, 0.0, 0.0, 1.0) // Min fraction of target covered by alignment.
FLT_OPT(max_query_cov, 0.0, 0.0, 1.0) // Min fraction of query covered by alignment.
FLT_OPT(max_target_cov, 0.0, 0.0, 1.0) // Min fraction of target covered by alignment.
FLT_OPT(lopen, 10.0, 0.0, DBL_MAX) // Gap open penalty for local alignments.
FLT_OPT(lext, 1.0, 0.0, DBL_MAX) // Gap extend penalty for local alignments.
FLT_OPT(termid, 0.0, 0.0, 1.0) // Terminate search if identity < termid.
FLT_OPT(termdist, 1.0, 0.0, 1.0) // Terminate search if distance > termdist.
FLT_OPT(termidd, 0.0, 0.0, 1.0) // Terminate search if (maxid-id) > termidd.
FLT_OPT(sparsemx_minid, 0.0, 0.0, DBL_MAX) // Min identity to keep in sparse distance matrix.
FLT_OPT(min_timer_pct, 0.1, 0.0, 100.0) // -
FLT_OPT(fastq_stats_minpct, 1.0, 0.0, 100.0) // Cutoff for long reads in fastq_stats.
FLT_OPT(subpct, 0.0, 0.0, 100.0) // Substitution error rate (readsim)
FLT_OPT(indelpct, 0.0, 0.0, 100.0) // Indel error rate (readsim)
FLT_OPT(orient_wordx, 8.0, 0.0, DBL_MAX) // -
FLT_OPT(orient_strandx, 4.0, 0.0, DBL_MAX) // -
FLT_OPT(sintax_cutoff, 0.8, 0.0, 1.0) // -
FLT_OPT(bbc_cutoff, 0.8, 0.0, 1.0) // -
FLT_OPT(hitax_cutoff, 0.7, 0.0, 1.0) // -
FLT_OPT(uchime_ref_minpctid, 100.0, 0.0, 1.0) // Min identity with top hit for uchime_ref
FLT_OPT(logloga, -3.1, -999, 999)
FLT_OPT(loglogb, 0.7, -999, 999)
FLT_OPT(unoise_alpha, 2.0, 1.0, 999)
FLT_OPT(xtrate_pct, 1.0, 0.0, 100.0)
FLT_OPT(uncross_maxxt, 0.5, 0.0, 100.0)
FLT_OPT(uncross_minvalid, 2.0, 0.0, 100.0)
FLT_OPT(uncross_minvalidtotal, 75.0, 0.0, 100.0)
FLT_OPT(jostq, 1.5, -100.0, 100.0)
FLT_OPT(min_freq, 0.0, 0.0, 1.0)
FLT_OPT(min_otu_freq, 0.0, 0.0, 1.0)
FLT_OPT(max_otu_freq, 1.0, 0.0, 1.0)
FLT_OPT(mindist, 0.0, 0.0, 1.0)
FLT_OPT(maxdist, 1.0, 0.0, 1.0)
FLT_OPT(maj, 0.51, 0.0, 1.0)
FLT_OPT(base, 10.0, 1.0, 1000.0)
FLT_OPT(minxtscore, 0.1, 0.0, 1.0)
FLT_OPT(xt_mock_factor, 10.0, 0.0, FLT_MAX)
FLT_OPT(xt_maxf1, 0.02, 0.0, FLT_MAX)
FLT_OPT(xt_small, 0.1, 0.0, FLT_MAX)
FLT_OPT(minpurity, 0.0, 0.0, FLT_MAX)
FLT_OPT(minpuritydelta, 0.0, 0.0, FLT_MAX)
FLT_OPT(genome_size, 3.1e6, 0.0, FLT_MAX)
FLT_OPT(load_factor, 0.6, 0.0, FLT_MAX)
FLT_OPT(depth, 0.0, 0.0, FLT_MAX)
FLAG_OPT(quiet) // Show only errors and warning messages on the terminal.
FLAG_OPT(compilerinfo) // -
FLAG_OPT(quicksort) // -
FLAG_OPT(kmerid) // -
FLAG_OPT(self) // Ignore hits with same label.
FLAG_OPT(notself) // Ignore hits with different labels.
FLAG_OPT(selfid) // Ignore hits to identical sequence.
FLAG_OPT(fulldp) //
FLAG_OPT(logmemgrows) // -
FLAG_OPT(trunclabels) // Truncate sequence labels.
FLAG_OPT(notrunclabels) // Don't truncate sequence labels.
FLAG_OPT(verbose) // -
FLAG_OPT(log_query) // -
FLAG_OPT(sizein) // Count "size=N;" annotations towards cluster sizes.
FLAG_OPT(sizeout) // Add "size=N;" annotations to cluster centroid labels.
FLAG_OPT(xsize) // Delete "size=N;" annotations.
FLAG_OPT(softmask) // -
FLAG_OPT(hardmask) // Mask by replacing letters with wildcard (N or X).
FLAG_OPT(validate) // -
FLAG_OPT(logstats) // -
FLAG_OPT(uc_hitsonly) // Omit N records in uc file
FLAG_OPT(sam_hitsonly) // Omit no-hit records in SAM file
FLAG_OPT(gaforce) // Force global alignment even if HSPs are below threshold.
FLAG_OPT(random_top_hit) // Report only top hit (ties broken randomly).
FLAG_OPT(top_hit_only) // Report only top hit (ties broken systematically).
FLAG_OPT(bottom_hit_only) // Report only bottom hit (ties broken systematically).
FLAG_OPT(top_hits_only) // Report only top hits (including ties).
FLAG_OPT(nousort) // Don't use U-sort heuristic.
FLAG_OPT(fastq_allowmergestagger) // Allow 'staggered' merges.
FLAG_OPT(fastq_trimstagger) // Delete staggered bases.
FLAG_OPT(fastq_nostagger) // Don't allow staggered merges
FLAG_OPT(leftjust) // Reject hit if terminal gaps at start of alignment.
FLAG_OPT(rightjust) // Reject hit if terminal gaps at end of alignment.
FLAG_OPT(acceptall) // Accept all hits.
FLAG_OPT(log_u) // -
FLAG_OPT(log_searcher_alns) // -
FLAG_OPT(output_no_hits) // Report queries with no hits.
FLAG_OPT(fastapairs_dots) // Replace identities with dots in query sequence.
FLAG_OPT(show_termgaps) // Show terminal gaps in alnout.
FLAG_OPT(uchime_countgapends) // Count end gaps as differences.
FLAG_OPT(uchime_abno) // A=B, Q different is no vote.
FLAG_OPT(distmx_brute) // Brute-force calculation of distance matrix.
FLAG_OPT(end_of_row) // -
FLAG_OPT(label_prefix_match) // Use prefix matching for sequence labels.
FLAG_OPT(label_substr_match) // Use substring matching for sequence labels.
FLAG_OPT(label_not_matched) // Get seqs that fail to match
FLAG_OPT(cover_query) // Report sufficient hits to cover query sequence.
FLAG_OPT(mosaic) // Report mosaic hits.
FLAG_OPT(sam_softclip) // Use SAM soft clipping.
FLAG_OPT(log_used_opts) // Report all used options in log file.
FLAG_OPT(log_memuse) // -
FLAG_OPT(strict_newick) // Re-format labels to confirm with Newick specification.
FLAG_OPT(toptax) // -
FLAG_OPT(fastq_diffsout) // Annoate fastq_mergepairs alignment differences in label.
FLAG_OPT(fastq_logvaln) // Verbose mergepairs vertical alignment (log file).
FLAG_OPT(pcr_strip_primers) // Strip primers from predicted amplicons.
FLAG_OPT(fastq_eeout) //
FLAG_OPT(taxbench_nonw) //
FLAG_OPT(taxbench_point) //
FLAG_OPT(constax) //
FLAG_OPT(keepgaps) //
FLAG_OPT(self_screen) //
FLAG_OPT(interleaved) //
FLAG_OPT(kmerdist) //
FLAG_OPT(orf_plusonly) //
//FLAG_OPT(uchime_sensitive) //
FLAG_OPT(undersample_warn) //
FLAG_OPT(merge_annot) //
FLAG_OPT(merge_ambig) //
FLAG_OPT(bimera) //
FLAG_OPT(accept_denoise) //
FLAG_OPT(singletons1) //
FLAG_OPT(offby1) //
FLAG_OPT(keep_annots) //
FLAG_OPT(uncross_undet_zero) //
FLAG_OPT(noboot) //
FLAG_OPT(allxch) //
FLAG_OPT(maxskew) //
FLAG_OPT(bimeras_only) //
FLAG_OPT(fastq_filter_qiime) //
FLAG_OPT(overlap_only) //
FLAG_OPT(fastq_noguess) //
FLAG_OPT(fastq_forceq) //
FLAG_OPT(binary) //
FLAG_OPT(tax_prod) //
FLAG_OPT(ktop) //
FLAG_OPT(train) //
FLAG_OPT(wrf) //
FLAG_OPT(box) //
FLAG_OPT(preston) //
FLAG_OPT(logfreq) //
FLAG_OPT(noxtalk) //
FLAG_OPT(indy) //
FLAG_OPT(zerobased) //
FLAG_OPT(halfopen) //
FLAG_OPT(qlabel) //
FLAG_OPT(log_hits) //
FLAG_OPT(log_hit_summary) //
FLAG_OPT(paired)
FLAG_OPT(allseeds)
FLAG_OPT(ignore_label_mismatches)
FLAG_OPT(readsimv_null)
FLAG_OPT(tov)
FLAG_OPT(veryfast)
FLAG_OPT(trim_barcode)
FLAG_OPT(even_recs)
FLAG_OPT(odd_recs)
FLAG_OPT(chunks_only)
#undef FLAG_OPT
#undef UNS_OPT
#undef FLT_OPT
#undef STR_OPT
| 23,357
|
C++
|
.h
| 468
| 48.715812
| 117
| 0.665922
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,042
|
readsimbench.h
|
rcedgar_urmap/src/readsimbench.h
|
#ifndef readsimbench_h
#define readsimbench_h
struct RSBInfo
{
unsigned V;
char ab;
unsigned Index;
string TargetLabel;
bool Plus;
unsigned TargetLo;
unsigned VPos;
bool IsFwd;
bool HasV;
string Aln;
string SubErrs;
RSBInfo()
{
Clear();
}
void Clear()
{
V = UINT_MAX;
ab = '?';
Index = UINT_MAX;
TargetLabel.clear();
Plus = false;
TargetLo = UINT_MAX;
VPos = UINT_MAX;
IsFwd = false;
HasV = false;
Aln.clear();
SubErrs.clear();
}
void LogMe() const
{
Log("RSB: V=%u", V);
Log(", ab=%c", ab);
Log(", Index=%u", Index);
Log(", target=%s(%u)%c", TargetLabel.c_str(), TargetLo+1, pom(Plus));
Log(", %s", IsFwd ? "Fwd" : "Rev");
Log(", hasv=%c", yon(HasV));
Log(", aln=%s", Aln.c_str());
Log(", suberrs=%s", SubErrs.c_str());
Log("\n");
}
};
void GetCoordsFromLabel(const string &Label,
string &TargetLabel, unsigned &Pos, bool &Strand);
void GetVarIxFromLabel(const string &Label, string &VarIx);
void GetCoordsFromLabel_varsim(const string &ReadLabel,
string &TargetLabel, unsigned &Pos);
uint32 GetBCFromLabel(const string &ReadLabel);
void ParseVarsimLabel(const string &ReadLabel, unsigned &ReadPairIndex,
uint32 &BC, unsigned &MolId, unsigned &MolPairIndex,
string &ChrName, char &AorB, unsigned &R1Pos, unsigned &R2Pos);
#endif // readsimbench_h
| 1,336
|
C++
|
.h
| 56
| 21.285714
| 71
| 0.684252
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
1,538,043
|
globalaligner.h
|
rcedgar_urmap/src/globalaligner.h
|
#ifndef globalaligner_h
#define globalaligner_h
#include "aligner.h"
#include "hspfinder.h"
#include "xdpmem.h"
class PathInfo;
class ObjMgr;
class GlobalAligner : public Aligner
{
public:
HSPFinder m_HF;
PathInfo *m_PI;
XDPMem m_Mem;
bool m_IsNucleo;
bool m_FullDPAlways;
bool m_FailIfNoHSPs;
public:
GlobalAligner();
// Aligner interface
public:
virtual ALIGNER_TYPE GetType() const { return AT_Global; }
virtual AlignResult *Align();
virtual AlignResult *AlignPos(unsigned QueryPos, unsigned TargetPos);
virtual void AlignMulti(GoBuff<AlignResult *, 32, true, false> &ARs);
virtual void InitImpl();
virtual void SetQueryImpl();
virtual void SetTargetImpl();
virtual void OnQueryDoneImpl();
virtual void OnTargetDoneImpl();
public:
void Trim(AlignResult *AR);
};
bool GlobalAlign_AllOpts(XDPMem &Mem, const SeqInfo &Query, const SeqInfo &Target,
const AlnParams &AP, const AlnHeuristics &AH, HSPFinder &HF, float &HSPFractId,
PathInfo &PI, bool FullDPAlways, bool FailIfNoHSPs);
bool GlobalAlign_Easy(SeqInfo &Query, SeqInfo &Target, AlignResult &AR);
#endif // globalaligner_h
| 1,112
|
C++
|
.h
| 37
| 28.189189
| 82
| 0.786116
|
rcedgar/urmap
| 39
| 11
| 5
|
GPL-2.0
|
9/20/2024, 10:44:59 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.