void UseEmplaceCheck::check(const MatchFinder::MatchResult &Result) {
const auto *Call = Result.Nodes.getNodeAs<CXXMemberCallExpr>("call");
const auto *InnerCtorCall = Result.Nodes.getNodeAs<CXXConstructExpr>("ctor");
auto FunctionNameSourceRange = CharSourceRange::getCharRange(
Call->getExprLoc(), Call->getArg(0)->getExprLoc());
auto Diag = diag(Call->getExprLoc(), "use emplace_back instead of push_back");
if (FunctionNameSourceRange.getBegin().isMacroID())
return;
Diag << FixItHint::CreateReplacement(FunctionNameSourceRange,
"emplace_back(");
auto CallParensRange = InnerCtorCall->getParenOrBraceRange();
// Finish if there is no explicit constructor call.
if (CallParensRange.getBegin().isInvalid())
return;
// Range for constructor name and opening brace.
auto CtorCallSourceRange = CharSourceRange::getTokenRange(
InnerCtorCall->getExprLoc(), CallParensRange.getBegin());
Diag << FixItHint::CreateRemoval(CtorCallSourceRange)
<< FixItHint::CreateRemoval(CharSourceRange::getTokenRange(
CallParensRange.getEnd(), CallParensRange.getEnd()));
}
std::string LineShape::asString() const
{
std::ostringstream os;
os << Shape::asString() << " LineShape: name = " << title << " "
<< Shape2DUtils::asString(getBegin()) << "->" << Shape2DUtils::asString(getEnd());
return os.str();
}
void ReadsLayout::statOverlaps(size_t listIndex, double &s, double &ss, unsigned int * distr) {
if (getNext(listIndex) != 0) {
cout << "string ReadsLayout::statOverlaps(size_t i, double &s,double &ss) problem\n";
sendBugReportPlease(cerr);
}
s = ss = 0.0;
unsigned int pos = 0;
unsigned int ov;
size_t index = getBegin(listIndex);
index = getNext(index);
pos = R->getReadsLength();
while (index != 0) {
ov = pos - getPosition(index) + 1;
distr[ov]++;
s += ov;
ss += (ov * ov);
pos += R->getReadsLength() - ov;
index = getNext(index);
}
}
int main() {
int count = 0;
int total = 0;
int largest = INT_MIN;
Element i;
Vector vector = createVector();
V_Iterator it = getEnd(&vector);
while( (scanf("%d",&i) == 1 ) ) {
if(vector.size == 0 )
prepend(&vector,i);
else {
insertAfter(&it,i);
moveNext(&it);
}
if( i > largest) largest = i;
}
printf( "Valor máximo: %d\n", largest);
it = getBegin(&vector);
while( it.index < vector.size ) {
i = getElement(&it);
// if( largest % i == 0 ) {
total += i;
count++;
// }
moveNext(&it);
}
if(count != 0)
printf( "Média: %d\n", (total/count));
}
void LineShape::draw(wxDC& dc)
{
if (isSelected()) {
dc.SetPen(wxPen(WXSTRING("RED"), lineWidth, wxSOLID));
} else {
dc.SetPen(wxPen(WXSTRING("BLACK"), lineWidth, wxSOLID));
}
dc.DrawLine(node1->getCentre().x, node1->getCentre().y, node2->getCentre().x,
node2->getCentre().y);
if (arrowHeadSize > 0) {
drawHead(dc);
}
if (title == "" && node1->getTitle() != "" && node2->getTitle() != "") {
title = node1->getTitle() + " to " + node2->getTitle();
}
Size textSize = dc.GetTextExtent(WXSTRING(title));
Point textPoint = getBegin();
// double angle = getAngle();
double angle = Shape2DUtils::getAngle(node1->getCentre(), node2->getCentre());
double dX = (getLength() / 2 - textSize.x / 2) * sin(angle);
double dY = (getLength() / 2 - textSize.x / 2) * cos(angle);
textPoint.x += dX;
textPoint.y -= dY;
double degreeAngle = angle * (180.0 / PI);
double rotationAngle = 90 - degreeAngle;
dc.DrawRotatedText(WXSTRING(title), textPoint, rotationAngle);
}
int main() {
int count = 0;
int total = 0;
int largest = INT_MIN;
Element i;
LinkedList list = NULL;
LL_Iterator it;
printf("Digite números para adicionar à lista (CTRL+D para sair): ");
while( (scanf("%d",&i) == 1 ) ) {
list = prepend(list, i);
if( i > largest) largest = i;
}
printf( "Valor máximo: %d\n", largest);
it = getBegin(list);
while( it != NULL ) {
i = getElement(it);
//if( largest % i == 0 ) {
total += i;
count++;
//}
it = moveNext(it);
}
if(count != 0)
printf( "Média: %d\n", (total/count));
}
TEST_F(PQueueTest, Sequence) {
using Data = MoveOnly<MoveOnly<int>>;
auto rd = getRand();
pqueue<Data, std::deque, std::less<Data>, InsertBefore> q;
// 並び順のチェック
auto fnCheck = [&q]() {
int check = 0;
for(auto itr=getBegin(q) ; itr!=getEnd(q) ; ++itr) {
EXPECT_LE(check, (*itr).getValue());
check = (*itr).getValue();
}
};
// ランダムな値を追加
auto fnAddrand = [&](int n) {
for(int i=0 ; i<n ; i++)
q.push(Data(rd.getUniformMin(0)));
};
fnAddrand(512);
fnCheck();
// 先頭の半分を削除して、再度チェック
for(int i=0 ; i<256 ; i++)
q.pop_front();
fnAddrand(256);
fnCheck();
EXPECT_EQ(512, q.size());
}
void TrackList::ClearPendingTracks( ListOfTracks *pAdded )
// NOFAIL-GUARANTEE
{
for (const auto &pTrack: mPendingUpdates)
pTrack->SetOwner( {}, {} );
mPendingUpdates.clear();
mUpdaters.clear();
if (pAdded)
pAdded->clear();
for (auto it = ListOfTracks::begin(), stop = ListOfTracks::end();
it != stop;) {
if (it->get()->GetId() == TrackId{}) {
if (pAdded)
pAdded->push_back( *it );
(*it)->SetOwner( {}, {} );
it = erase( it );
}
else
++it;
}
if (!empty())
RecalcPositions(getBegin());
}
void ReadsLayout::print(size_t index, ostream &out, bool dir, unsigned int start, unsigned int maxD, Pairing *P) {
if (getNext(index) != 0) {
cerr << "void ReadsLayout::print(size_t index) problem\n";
sendBugReportPlease(cerr);
}
if (!dir)
index = reverseComplement(index);
size_t p = getBegin(index);
size_t tmp;
do {
unsigned int position=getPosition(p);
if (position > maxD)
break;
if (position < start)
{
tmp = p;
p = getNext(p);
continue;
}
unsigned int pairedRead=0;
unsigned int pairedNode=0;
int lib=0;
if (P->getNLibrary() != 0)
{
pairedRead = P->getPairing(p);
pairedNode = getNodeId(pairedRead);
lib = P->getPeLibraryID(p);
}
if (getDirection(p))
out << '>';
else
out << '<';
for (int i = 0; i < getPosition(p) % 120; i++)
out << " ";
if (getDirection(p))
out << getDirectRead(p) << " " << p << ' ' << lib << ' ' << pairedNode << '\n';
else
out << getReverseRead(p) << " " << p << ' ' << lib << ' ' << pairedNode << '\n';
tmp = p;
p = getNext(p);
} while (tmp != index);
out << flush;
if (!dir) //back to initial direction
index = reverseComplement(index);
}
/**
* Altera o valor do e-nésimo elemento da lista, contando a partir
* do 0. Tem complexidade O(n).
*/
void setNth(LinkedList list, int n, Element newElement) {
LL_Iterator it = getBegin(list);
int i;
for( it = 0; i < n; i++) {
moveNext(it);
}
setValue(it,newElement);
}
/**
* Retorna o e-nésimo elemento da lista, contando a partir do 0.
* Tem complexidade O(n).
*/
Element getNth(LinkedList list, int n) {
LL_Iterator it = getBegin(list);
int i;
for( it = 0; i < n; i++) {
moveNext(it);
}
return getValue(it);
}
/**
* Altera o valor do e-nésimo elemento da lista, contando a partir
* do 0. Tem complexidade O(n).
*/
void setNth(List list, int n, ItemType newItem) {
Iterator it = getBegin(list);
int i;
for( it = 0; i < n; i++) {
moveNext(it);
}
setValue(it,newItem);
}
/**
* Retorna o e-nésimo elemento da lista, contando a partir do 0.
* Tem complexidade O(n).
*/
ItemType getNth(List list, int n) {
Iterator it = getBegin(list);
int i;
for( i = 0; i < n; i++) {
moveNext(it);
}
return getValue(it);
}
uint Aligner::mapOnRightEndGreedy(const string &read, vector<uNumber>& path, const pair<kmer, uint>& overlap , uint errors){
// cout<<"moreg"<<endl;
string unitig,readLeft(read.substr(overlap.second)),nextUnitig;
// auto rangeUnitigs(getBeginOpti(overlap.first,path.back()));
auto rangeUnitigs(getBegin(overlap.first));
uint miniMiss(errors+1), miniMissIndice(9);
bool ended(false);
// int offset(0);
kmer nextOverlap(0);
// cout<<"go"<<endl;
// for(uint i(0); i<rangeUnitigs2.size(); ++i){
// cout<<(rangeUnitigs2[i].first)<<endl;
// }
// cout<<"true"<<endl;
for(uint i(0); i<rangeUnitigs.size(); ++i){
unitig=(rangeUnitigs[i].first);
// bool stop(false);
// if(rangeUnitigs[i].first!=rangeUnitigs2[i].first){
// cout<<read<<endl;
// cout<<"lol2"<<endl;
// cout<<rangeUnitigs[i].first<<endl<<rangeUnitigs2[i].first<<endl;
// cout<<rangeUnitigs[i].second<<" "<<rangeUnitigs2[i].second<<endl;
// stop=true;
// }
// if(stop){cin.get();}
// cout<<unitig<<endl;
// cout<<rangeUnitigs[i].first<<endl;
//case the rest of the read is too small
if(readLeft.size()<=unitig.size()){
uint miss(missmatchNumber(unitig.substr(0,readLeft.size()), readLeft, errors));
if(miss<miniMiss){
miniMiss=miss;
miniMissIndice=i;
ended=true;
// offset=unitig.size()-readLeft.size()-k+1;
}
}else{
//case the read is big enough we want to recover a true overlap
uint miss(missmatchNumber(unitig, read.substr(overlap.second,unitig.size()), errors));
if(miss<miniMiss){
if(miss<miniMiss){
kmer overlapNum(str2num(unitig.substr(unitig.size()-k+1,k-1)));
miniMiss=miss;
miniMissIndice=i;
nextUnitig=unitig;
nextOverlap=overlapNum;
}
}
}
}
// cout<<"end"<<endl;
if(miniMiss<=errors){
path.push_back(rangeUnitigs[miniMissIndice].second);
if (ended){return miniMiss;}
miniMiss+=mapOnRightEndGreedy(read , path, {nextOverlap,overlap.second+(nextUnitig.size()-k+1)}, errors-miniMiss);
}
return miniMiss;
}
std::string LineShape::asDebugString() const
{
std::ostringstream os;
os << "LineShape:\n";
os << Shape::asDebugString() << "\n";
os << "name = " << (title.size() == 0 ? "\"\"" : title) << ", "
<< Shape2DUtils::asString(getBegin()) << "->" << Shape2DUtils::asString(getEnd());
return os.str();
}
/**
* Retorna o número de elementos da lista. Tem complexidade O(n).
*/
int getSize(List list) {
Iterator it = getBegin(list);
int size = 0;
while( it != NULL) {
moveNext(it);
size++;
}
return size;
}
TEST_F(PQueueTest, InsertAfter) {
spn::pqueue<MyPair, std::deque, std::less<MyPair>, InsertAfter> myA;
for(int i=0 ; i<20 ; i++)
myA.push(MyPair{0, i*100});
int check = myA.front().b;
for(auto itr=getBegin(myA) ; itr!=getEnd(myA) ; ++itr) {
EXPECT_LE(check, (*itr).b);
check = (*itr).b;
}
}
void ReadsLayout::statOverlaps2(size_t listIndex,
unsigned int &nOverlap,
unsigned int &nSample,
double &mean,
unsigned int* distr)
{
unsigned int pos = 0;
unsigned int oh; //over hanging
unsigned int mult;
size_t index = getBegin(listIndex);
mean=0.0;
nOverlap=nSample=0;
index = getNext(index);
pos = R->getReadsLength();
unsigned int rl=R->getReadsLength();
while (index != 0) {
mult=1;
oh = rl - (pos - getPosition(index) + 1);
while(oh==0)
{
mult++;
index = getNext(index);
if (index == 0)
break;
pos += oh;
oh = rl - (pos - getPosition(index) + 1);
}
if (mult > 1)
{
nOverlap+=mult-1;
mult = (mult * mult) - mult;
distr[0] += mult;
nSample += mult;
if (index == 0)
break;
}
distr[oh]++;
mean+=oh;
nSample++;
nOverlap++;
pos += oh;
index = getNext(index);
}
if (nSample==0)
mean=0.0;
else
mean/=nSample;
}
uint Aligner::checkEndExhaustive(const string& read, pair<kmer, uint>& overlap, vector<uNumber>& path, uint errors){
string readLeft(read.substr(overlap.second+k-1)),unitig;
vector<uNumber> path2keep;
if(readLeft.empty()){
path.push_back(0);
return 0;
}
auto rangeUnitigs(getBegin(overlap.first));
uint minMiss(errors+1),indiceMinMiss(9);
bool ended(false);
int offset(-2);
if(partial & rangeUnitigs.empty()){
//if(!path.empty()){
return 0;
//}
}
for(uint i(0); i<rangeUnitigs.size(); ++i){
unitig=(rangeUnitigs[i].first);
if(unitig.size()-k+1>=readLeft.size()){
uint miss(missmatchNumber(unitig.substr(k-1,readLeft.size()),readLeft, errors));
if(miss<minMiss){
minMiss=miss;
indiceMinMiss=i;
ended=true;
offset=readLeft.size()+k-1;
}
}else{
uint miss(missmatchNumber(unitig.substr(k-1),readLeft.substr(0,unitig.size()-k+1), errors));
if(miss<minMiss){
kmer overlapNum(str2num(unitig.substr(unitig.size()-k+1,k-1)));
vector<uNumber> possiblePath;
miss+=mapOnRightEndExhaustive(read, possiblePath, {overlapNum,overlap.second+(unitig.size()-k+1)},errors-miss);
if(miss<minMiss){
path2keep=possiblePath;
minMiss=miss;
indiceMinMiss=i;
ended=false;
}
}
}
}
if(minMiss<=errors){
if(ended){
path.push_back(rangeUnitigs[indiceMinMiss].second);
path.push_back(offset);
}else{
path.push_back(rangeUnitigs[indiceMinMiss].second);
path.insert(path.end(), path2keep.begin(),path2keep.end());
}
}
return minMiss;
}
Track *TrackList::DoAddToHead(const std::shared_ptr<Track> &t)
{
Track *pTrack = t.get();
push_front(ListOfTracks::value_type(t));
auto n = getBegin();
pTrack->SetOwner(shared_from_this(), n);
pTrack->SetId( TrackId{ ++sCounter } );
RecalcPositions(n);
AdditionEvent(n);
return front().get();
}
uint Aligner::checkPair(const pair<kmer, uint>& overlap1, const pair<kmer, uint>& overlap2, const string& read, uNumber& number, uint errorsAllowed){
if(overlap2.second-overlap1.second<k){
int32_t positionget1, positionget2;
auto rangeUnitigs1(getBegin(overlap1.first));
auto rangeUnitigs2(getEnd(overlap2.first));
for(uint i(0); i<rangeUnitigs1.size(); ++i){
positionget1=rangeUnitigs1[i].second;
for(uint j(0); j<rangeUnitigs2.size(); ++j){
positionget2=rangeUnitigs2[j].second;
if(positionget2==positionget1){
number=positionget1;
return 0;
}
}
}
return errorsAllowed+1;
}
string unitig,subRead(read.substr(overlap1.second+k-1,overlap2.second-overlap1.second-(k-1)));
auto rangeUnitigs1(getBegin(overlap1.first));
auto rangeUnitigs2(getEnd(overlap2.first));
uint minMissMatch(errorsAllowed+1),indice(0);
int32_t positionget1, positionget2;
for(uint i(0); i<rangeUnitigs1.size(); ++i){
positionget1=rangeUnitigs1[i].second;
for(uint j(0); j<rangeUnitigs2.size(); ++j){
positionget2=rangeUnitigs2[j].second;
if(positionget2==positionget1){
unitig=getUnitig(rangeUnitigs1[i].second);
if(unitig.size()-2*(k-1)==subRead.size()){
uint missmatch(missmatchNumber(unitig.substr(k-1,subRead.size()), subRead, errorsAllowed));
if(missmatch<minMissMatch){
minMissMatch=missmatch;
indice=i;
}
}
}
}
}
if(minMissMatch<=errorsAllowed){number=(rangeUnitigs1[indice].second);}
return minMissMatch;
}
pair<uint,uint> Aligner::mapOnRight(const string &read, vector<uNumber>& path, const pair<kmer, uint>& overlap, const vector<pair<kmer,uint>>& listOverlap, bool& ended,uint start, uint errors){
string unitig, readLeft(read.substr(overlap.second+k-1)),nextUnitig;
if(readLeft.empty()){cout<<"should not appears"<<endl;exit(0);return {start,0};}
auto rangeUnitigs(getBegin(overlap.first));
uint miniMiss(errors+1),miniMissIndice(9);
uint next(start);
kmer nextOverlapNum(0);
for(uint i(0); i<rangeUnitigs.size(); ++i){
unitig=(rangeUnitigs[i].first);
//case the rest of the read is too small
if(readLeft.size() <= unitig.size()-k+1){
uint miss(missmatchNumber(unitig.substr(k-1,readLeft.size()), readLeft, errors));
if(miss<miniMiss){
ended=true;
miniMiss=miss;
miniMissIndice=i;
}
}else{
//case the read is big enough we want to recover a true overlap
uint miss(missmatchNumber(unitig.substr(k-1), readLeft.substr(0,unitig.size()-k+1), errors));
if(miss<miniMiss){
kmer overlapNum(str2num(unitig.substr(unitig.size()-k+1,k-1)));
if(miss<miniMiss){
ended=false;
miniMiss=miss;
miniMissIndice=i;
nextOverlapNum=overlapNum;
nextUnitig=unitig;
next=start;
for(uint j(start+1); j<listOverlap.size(); ++j){
if(overlapNum==listOverlap[j].first and listOverlap[j].second==overlap.second+unitig.size()-k+1){
next=j;
}
}
}
}
}
}
if(ended){
path.push_back(rangeUnitigs[miniMissIndice].second);
return {start,miniMiss};
}
if(miniMiss<=errors){
path.push_back(rangeUnitigs[miniMissIndice].second);
if(next>start){
return {next,miniMiss};
}
auto res(mapOnRight(read , path, {nextOverlapNum,overlap.second+(nextUnitig.size()-k+1)},listOverlap,ended,start, errors-miniMiss));
return {res.first,res.second+miniMiss};
}
return {start,errors+1};
}
void TrackList::Permute(const std::vector<TrackNodePointer> &permutation)
{
for (const auto iter : permutation) {
ListOfTracks::value_type track = *iter.first;
erase(iter.first);
Track *pTrack = track.get();
pTrack->SetOwner(shared_from_this(),
{ insert(ListOfTracks::end(), track), this });
}
auto n = getBegin();
RecalcPositions(n);
PermutationEvent();
}
bool FVisitor::VisitDecl(clang::Decl* Declaration)
{
// Any declaration with a name: label, namespace alias, namespace, template, type, various forms of "using", value.
auto SourceRange = Declaration->getSourceRange();
auto Begin = SourceRange.getBegin();
auto DecomposedLoc = SourceManager.getDecomposedLoc(Begin);
auto Line = SourceManager.getLineNumber(DecomposedLoc.first, DecomposedLoc.second);
auto Col = SourceManager.getColumnNumber(DecomposedLoc.first, DecomposedLoc.second);
auto Filename = SourceManager.getFilename(Begin);
auto Data= Filename.data();
DeclToFilename.Add(Declaration, Data);
return true;
}
bool LineShape::occupies(const Point& aPoint) const
{
Point triangle[] = {top, right, left};
if (Shape2DUtils::isInsidePolygon(triangle, 3, aPoint)) {
return true;
}
bool result = Shape2DUtils::isOnLine(getBegin(), getEnd(), aPoint, 2);
if (result == true) {
}
return result;
}
bool ReadsLayout::isUniDirectional(size_t index) const {
size_t p = getBegin(index);
bool direction = getDirection(p);
do {
if (getDirection(p) != direction)
return false;
p = getNext(p);
} while (p != 0);
return true;
}
void ReadsLayout::getVcoverage(size_t listIndex, bool direction, vector<unsigned int> &cov)
{
unsigned int pos;
unsigned int sequenceLength=getSequenceLength(listIndex);
int rl=R->getReadsLength();
size_t index;
cov.clear();
cov.assign(sequenceLength,0);
vector<unsigned int> tmp;
tmp.assign(sequenceLength,0);
if (direction)
{
index = getBegin(listIndex);
while (index != 0)
{
pos = getPosition(index);
cov[pos - 1]++;
index = getNext(index);
}
}
else
{
index = listIndex;
sequenceLength-= (rl-1);
while (index != 0)
{
pos = getPosition(index);
pos=sequenceLength-pos;
cov[pos]++;
index = getPrevious(index);
}
}
tmp[0]=cov[0];
for (size_t i=1; i<cov.size(); i++)
{
cov[i]=cov[i]+cov[i-1];
tmp[i]=cov[i];
}
for (size_t i=rl; i<cov.size(); i++)
cov[i]-=tmp[i-rl];
}
uint Aligner::mapOnRightEndExhaustive(const string &read, vector<uNumber>& path, const pair<kmer, uint>& overlap , uint errors){
string unitig,readLeft(read.substr(overlap.second+k-1));
vector<uNumber> path2keep;
if(readLeft.empty()){path.push_back(0);return 0;}
auto rangeUnitigs(getBegin(overlap.first));
uint miniMiss(errors+1), miniMissIndice(9);
bool ended(false);
for(uint i(0); i<rangeUnitigs.size(); ++i){
unitig=(rangeUnitigs[i].first);
//case the rest of the read is too small
if(readLeft.size()<= unitig.size()-k+1){
uint miss(missmatchNumber(unitig.substr(k-1,readLeft.size()), readLeft, errors));
if(miss<miniMiss){
miniMiss=miss;
miniMissIndice=i;
ended=true;
}
}else{
//case the read is big enough we want to recover a true overlap
uint miss(missmatchNumber(unitig.substr(k-1), readLeft.substr(0,unitig.size()-k+1), errors));
if(miss<miniMiss){
kmer overlapNum(str2num(unitig.substr(unitig.size()-k+1,k-1)));
vector<uNumber> possiblePath;
miss+=mapOnRightEndExhaustive(read , possiblePath, {overlapNum,overlap.second+(unitig.size()-k+1)}, errors-miss);
if(miss<miniMiss){
path2keep=possiblePath;
miniMiss=miss;
miniMissIndice=i;
ended=false;
}
}
}
}
if(miniMiss<=errors){
if(ended){
path.push_back(rangeUnitigs[miniMissIndice].second);
path.push_back(readLeft.size()+k-1);
}else{
path.push_back(rangeUnitigs[miniMissIndice].second);
path.insert(path.end(), path2keep.begin(),path2keep.end());
}
successMR++;
}
return miniMiss;
}
int KateCodeFoldingNode::cmpPos(KateCodeFoldingTree *tree, uint line,uint col) {
KateTextCursor cur(line,col);
KateTextCursor start,end;
kdDebug(13000)<<"KateCodeFoldingNode::cmpPos (1)"<<endl;
bool startValid=getBegin(tree, &start);
kdDebug(13000)<<"KateCodeFoldingNode::cmpPos (2)"<<endl;
bool endValid=getEnd(tree, &end);
kdDebug(13000)<<"KateCodeFoldingNode::cmpPos (3)"<<endl;
if ((!endValid) && startValid) {
return ((start>cur)?-1:0);
}
if ((!startValid) && endValid) {
return ((cur>end)?1:0);
}
//here both have to be valid, both invalid must not happen
Q_ASSERT(startValid && endValid);
return ( (cur<start)?(-1):( (cur>end) ? 1:0));
}
uint Aligner::mapOnRightEndGreedy(const string &read, vector<uNumber>& path, const pair<kmer, uint>& overlap , uint errors){
string unitig,readLeft(read.substr(overlap.second)),nextUnitig;
auto rangeUnitigs(getBegin(overlap.first));
uint miniMiss(errors+1), miniMissIndice(9);
bool ended(false);
// int offset(0);
kmer nextOverlap(0);
for(uint i(0); i<rangeUnitigs.size(); ++i){
unitig=(rangeUnitigs[i].first);
//case the rest of the read is too small
if(readLeft.size()<= unitig.size()){
uint miss(missmatchNumber(unitig.substr(0,readLeft.size()), readLeft, errors));
if(miss<miniMiss){
miniMiss=miss;
miniMissIndice=i;
ended=true;
// offset=unitig.size()-readLeft.size()-k+1;
}
}else{
//case the read is big enough we want to recover a true overlap
uint miss(missmatchNumber(unitig, read.substr(overlap.second,unitig.size()), errors));
if(miss<miniMiss){
if(miss<miniMiss){
kmer overlapNum(str2num(unitig.substr(unitig.size()-k+1,k-1)));
miniMiss=miss;
miniMissIndice=i;
nextUnitig=unitig;
nextOverlap=overlapNum;
}
}
}
}
if(miniMiss<errors){
path.push_back(rangeUnitigs[miniMissIndice].second);
if (ended){
// path.push_back(offset);
// path.push_back(rangeUnitigs[miniMissIndice].second);
return miniMiss;
}
miniMiss+=mapOnRightEndGreedy(read , path, {nextOverlap,overlap.second+(nextUnitig.size()-k+1)}, errors-miniMiss);
}
return miniMiss;
}
