void create_primary_chain_from_list(node *head_node, vector<pair<int, int> >& chain, node *next_node, node *previous_node, int readlen) { bool repeat_sequence; int range1, range2; int max_reference_delta; node *current_node = new node; current_node->ref_ind = head_node->ref_ind; current_node->read_ind = head_node->read_ind; current_node->next = head_node->next; while(next_node != NULL) { //cout << "Chain Ref = " << next_node->ref_ind << ", Read = " << next_node->read_ind << endl; //cout << "\t\t\tCurrent Node Ref = " << current_node->ref_ind << ", Read = " << current_node->read_ind << endl; repeat_sequence = false; range1 = next_node->read_ind - current_node->read_ind;//read range2 = next_node->ref_ind - current_node->ref_ind;//reference max_reference_delta = min(1.30 * readlen - current_node->read_ind, SEEDTUPLEDIST); if(range2 > max_reference_delta) //if(range2 > readlen * 1.30 - current_node->read_ind)// || range2 > 1000) { break; } if(range1 < 0) { previous_node = next_node; next_node = next_node->next; continue; } else if(range2 == 0 || range1 == 0) { //create_primary_chain_from_list(current_node, chain, next_node->next, next_node, readlen); previous_node->next = next_node->next; delete next_node; next_node = previous_node->next;//NULL; //return; } else { float diff = (1.0 * range1) / range2; //if(diff > 0.90 && diff < 1.10) // hack if(diff > 0.70 && diff < 1.30) { current_node->ref_ind = next_node->ref_ind; current_node->read_ind = next_node->read_ind; current_node->next = next_node->next; //if(range1 == range2) { chain.push_back(make_pair(next_node->ref_ind, next_node->read_ind)); //cout << "Chain Ref = " << next_node->ref_ind << ", Read = " << next_node->read_ind << endl; //create_primary_chain_from_list(next_node, chain, next_node->next, next_node, readlen); previous_node->next = next_node->next; delete next_node; next_node = NULL; } /*else { chain.push_back(make_pair(next_node->ref_ind, next_node->read_ind)); //create_primary_chain_from_list(next_node, chain, next_node->next, next_node, readlen); previous_node->next = next_node->next; delete next_node; next_node = NULL; } */ next_node = previous_node->next; //return; } else { previous_node = next_node; next_node = next_node->next; } } } delete current_node; current_node = NULL; }
virtual pair<BSONObj, BSONObj> rangeFor( const BSONObj& chunkDoc, const BSONObj& min, const BSONObj& max ) const { return make_pair( min, max ); }
/* load grammar file and save as map <string, vector<list<string> > > * */ void Parser:: inputGrammar(char* input_path){ /* inputGrammar save as map<string, vector<list<string> >> */ Nonterminal* head; string head_symbol; string terminal; vector<list<string> > body; // open file ifstream input_file(input_path, ios::in); if( !input_file ){ cout << "Grammar.txt could not be opend" << endl; exit(1); } // read input line by line for ( string line; getline(input_file, line); ){ //spilit the '\n' line.substr(0, line.length()-1); // is Nonterminal if ( isalpha(line[0]) ){ if( !body.empty() ){ grammar.insert(make_pair(head_symbol, body)); } head_symbol = line; head = new Nonterminal( head_symbol ); // non_terminals vector non_terminals.push_back(head); // non_terminals map for search non_terminals_map.insert(make_pair(line, head)); body.clear(); }// is terminal else{ list<string> right_hand_side; // convert string to char* for split char* tokenPtr = new char[line.length() + 1]; strcpy(tokenPtr, line.c_str() ); // splite by white space tokenPtr = strtok(tokenPtr, " \t"); // whike has next token while( tokenPtr != NULL ){ terminal = tokenPtr; right_hand_side.push_back(terminal); // get next token tokenPtr = strtok(NULL, " \t"); } delete [] tokenPtr; body.push_back(right_hand_side); } } // insert last production to produce grammar grammar.insert(make_pair(head_symbol, body)); }
void Junction::addJunctionController(Controller *controller, const std::string &controlType) { junctionControllerVector.push_back(make_pair(controller, controlType)); }
void KeyFrame::UpdateConnections() { map<KeyFrame*,int> KFcounter; vector<MapPoint*> vpMP; { boost::mutex::scoped_lock lockMPs(mMutexFeatures); vpMP = mvpMapPoints; } //For all map points in keyframe check in which other keyframes are they seen //Increase counter for those keyframes for(vector<MapPoint*>::iterator vit=vpMP.begin(), vend=vpMP.end(); vit!=vend; vit++) { MapPoint* pMP = *vit; if(!pMP) continue; if(pMP->isBad()) continue; map<KeyFrame*,size_t> observations = pMP->GetObservations(); for(map<KeyFrame*,size_t>::iterator mit=observations.begin(), mend=observations.end(); mit!=mend; mit++) { if(mit->first->mnId==mnId) continue; KFcounter[mit->first]++; } } if(KFcounter.empty()) return; //If the counter is greater than threshold add connection //In case no keyframe counter is over threshold add the one with maximum counter int nmax=0; KeyFrame* pKFmax=NULL; int th = 15; vector<pair<int,KeyFrame*> > vPairs; vPairs.reserve(KFcounter.size()); for(map<KeyFrame*,int>::iterator mit=KFcounter.begin(), mend=KFcounter.end(); mit!=mend; mit++) { if(mit->second>nmax) { nmax=mit->second; pKFmax=mit->first; } if(mit->second>=th) { vPairs.push_back(make_pair(mit->second,mit->first)); (mit->first)->AddConnection(this,mit->second); } } if(vPairs.empty()) { vPairs.push_back(make_pair(nmax,pKFmax)); pKFmax->AddConnection(this,nmax); } sort(vPairs.begin(),vPairs.end()); list<KeyFrame*> lKFs; list<int> lWs; for(size_t i=0; i<vPairs.size();i++) { lKFs.push_front(vPairs[i].second); lWs.push_front(vPairs[i].first); } { boost::mutex::scoped_lock lockCon(mMutexConnections); // mspConnectedKeyFrames = spConnectedKeyFrames; mConnectedKeyFrameWeights = KFcounter; mvpOrderedConnectedKeyFrames = vector<KeyFrame*>(lKFs.begin(),lKFs.end()); mvOrderedWeights = vector<int>(lWs.begin(), lWs.end()); if(mbFirstConnection && mnId!=0) { mpParent = mvpOrderedConnectedKeyFrames.front(); mpParent->AddChild(this); mbFirstConnection = false; } } }
/** @brief 메모리 블럭의 크기와 갯수를 읽어 initMessageBlockManager 에 넘겨준다. */ int readMBconfig(void) { filename_t fileName(Config::instance()->process.memconf); FILE *fp = NULL; fp = fopen( fileName, "rt" ); if( fp == NULL ) { PAS_ERROR1( "Memory Pool Config File: [%s] not found", fileName.toStr() ); return -1; } // 맵을 사용하는 이유는, 키값에는 블럭사이즈, Value 값에는 최대 사이즈를 넣으면 되고 // 만일 config 파일에 중복된 값(예:16K, 16K)이 있을 경우 뒷부분은 자동으로 무시되므로 // map 을 사용하는 것이 가장 적당하다고 판단된다. mapint mapSizes; int lineCount = 0; int maxBlockSize =0; while( !feof(fp) ) { char line[1024] = "\0"; char *pResult = fgets( line, sizeof(line), fp ); if( pResult == NULL ) break; lineCount++; StrSplit MBSpliter( 2, sizeof(line) ); MBSpliter.split( line ); // skip comment if( MBSpliter.fldVal(0)[0] == '#' ) continue; // 정상적인 데이터가 아니면 패스 if( MBSpliter.numFlds() != 2 ) { PAS_ERROR2( "Memory Pool Config File: Error in line [%d], file[%s]", lineCount, fileName.toStr() ); return -1; } char *pLeftItem = MBSpliter.fldVal( 0 ); char *pRightItem = MBSpliter.fldVal( 1 ); int nLeftLength = strlen( pLeftItem ); int nBlockSize = 0; int nMaxCount = strtol( pRightItem, NULL, 10 ); if( pLeftItem[nLeftLength-1] == 'K' || pLeftItem[nLeftLength-1] == 'k' ) { pLeftItem[nLeftLength-1] = '\0'; nBlockSize = strtol( pLeftItem, NULL, 10 ); nBlockSize = nBlockSize * 1024; } else if( pLeftItem[nLeftLength-1] == 'M' || pLeftItem[nLeftLength-1] == 'm' ) { pLeftItem[nLeftLength-1] = '\0'; nBlockSize = strtol( pLeftItem, NULL, 10 ); nBlockSize = nBlockSize * 1024 * 1024; } // 단위값이 잘 못 입력된 경우 무시한다. else { PAS_ERROR2( "Memory Pool Config File: Error in line [%d], file[%s]", lineCount, fileName.toStr()); return -1; } if (nBlockSize < maxBlockSize) { PAS_ERROR2( "Memory Pool Config File: Block Size must be bigger than the previous size. Error in line [%d], file[%s]", lineCount, fileName.toStr()); return -1; } maxBlockSize = nBlockSize; mapSizes.insert( make_pair(nBlockSize, nMaxCount) ); } fclose( fp ); initMessageBlockManager( mapSizes ); return 0; }
void SimpleXML::addAttrib(const string& aName, const string& aData) throw(SimpleXMLException) { if(current == &root) throw SimpleXMLException("No tag is currently selected"); current->attribs.push_back(make_pair(aName, aData)); }
int ReadMifOneElement(ifstream& fMifFile, vector<pair<double, double> >& vCoorXYLst) { int iLineLoop, iPntLoop; int iLineNum = 0; int iPntNum = 0; string strTok = " "; string strPline = "Pline"; string strLine = "Line"; string strMultiple = "Multiple"; double dX, dY; char acLine[1024]; vector<string> vFirstLineOfEle; vCoorXYLst.clear(); do { memset(acLine, 0, 1024 ); fMifFile.getline(acLine, 1024); } while( strcmp(acLine,"") == 0); vFirstLineOfEle.clear(); vFirstLineOfEle = SplitString(acLine, strTok, ""); if( 0 == vFirstLineOfEle.size()) { //log return RET_FAILED; } // 修改适应不同的mif样式表述 gaojian 2014-01-17 while (vFirstLineOfEle[0] != strPline && vFirstLineOfEle[0] != strLine) { if (fMifFile.eof()) { return RET_FAILED; } do { memset(acLine, 0, 1024 ); fMifFile.getline(acLine, 1024); if (fMifFile.eof()) { return RET_FAILED; } } while( strcmp(acLine,"") == 0); vFirstLineOfEle.clear(); vFirstLineOfEle = SplitString(acLine, strTok, ""); if( 0 == vFirstLineOfEle.size()) { //log return RET_FAILED; } } if( vFirstLineOfEle[0] == strPline ) { if( vFirstLineOfEle[1] == strMultiple) { iLineNum = StringToInt(vFirstLineOfEle[2]); for( iLineLoop = 0; iLineLoop < iLineNum; iLineLoop++ ) { memset(acLine, 0, 1024 ); fMifFile.getline(acLine, 1024); vFirstLineOfEle.clear(); vFirstLineOfEle = SplitString(acLine, strTok, ""); iPntNum = StringToInt(vFirstLineOfEle[0]); for( iPntLoop = 0; iPntLoop < iPntNum; iPntLoop++ ) { memset(acLine, 0, 1024 ); fMifFile.getline(acLine, 1024); vFirstLineOfEle.clear(); vFirstLineOfEle = SplitString(acLine, strTok, ""); dX = StringToDouble(vFirstLineOfEle[0]); dY = StringToDouble(vFirstLineOfEle[1]); vCoorXYLst.push_back(make_pair(dX,dY)); } } } else { iPntNum = StringToInt(vFirstLineOfEle[1]); for( iPntLoop = 0; iPntLoop < iPntNum; iPntLoop++ ) { memset(acLine, 0, 1024 ); fMifFile.getline(acLine, 1024); vFirstLineOfEle.clear(); vFirstLineOfEle = SplitString(acLine, strTok, ""); dX = StringToDouble(vFirstLineOfEle[0]); dY = StringToDouble(vFirstLineOfEle[1]); vCoorXYLst.push_back(make_pair(dX,dY)); } } } else if( vFirstLineOfEle[0] == strLine ) { dX = StringToDouble(vFirstLineOfEle[1]); dY = StringToDouble(vFirstLineOfEle[2]); vCoorXYLst.push_back(make_pair(dX,dY)); dX = StringToDouble(vFirstLineOfEle[3]); dY = StringToDouble(vFirstLineOfEle[4]); vCoorXYLst.push_back(make_pair(dX,dY)); } else { //log return RET_FAILED; } fMifFile.getline(acLine, 1024); return RET_SUCCESS; }
bool MeshTopologyTests::testEntityConstraints() { bool success = true; // make two simple meshes MeshTopologyPtr mesh2D = makeRectMesh(0.0, 0.0, 2.0, 1.0, 2, 1); MeshTopologyPtr mesh3D = makeHexMesh(0.0, 0.0, 0.0, 2.0, 4.0, 3.0, 2, 2, 1); unsigned vertexDim = 0; unsigned edgeDim = 1; unsigned faceDim = 2; // first, check that unconstrained edges and faces are unconstrained set< unsigned > boundaryEdges; set< unsigned > internalEdges; for (unsigned cellIndex=0; cellIndex<mesh2D->cellCount(); cellIndex++) { CellPtr cell = mesh2D->getCell(cellIndex); unsigned sideCount = cell->getSideCount(); for (unsigned sideOrdinal=0; sideOrdinal<sideCount; sideOrdinal++) { unsigned edgeIndex = cell->entityIndex(edgeDim, sideOrdinal); unsigned numCells = mesh2D->getActiveCellCount(edgeDim,edgeIndex); if (numCells == 1) // boundary edge { boundaryEdges.insert(edgeIndex); } else if (numCells == 2) { internalEdges.insert(edgeIndex); } else { success = false; cout << "testEntityConstraints: In initial 2D mesh, edge " << edgeIndex << " has active cell count of " << numCells << ".\n"; } } } if (internalEdges.size() != 1) { success = false; cout << "testEntityConstraints: In initial 2D mesh, there are " << internalEdges.size() << " internal edges (expected 1).\n"; } for (set<unsigned>::iterator edgeIt=internalEdges.begin(); edgeIt != internalEdges.end(); edgeIt++) { unsigned edgeIndex = *edgeIt; unsigned constrainingEntityIndex = mesh2D->getConstrainingEntity(edgeDim,edgeIndex).first; if (constrainingEntityIndex != edgeIndex) { success = false; cout << "testEntityConstraints: In initial 2D mesh, internal edge is constrained by a different edge.\n"; } } set<unsigned> boundaryFaces; set<unsigned> internalFaces; map<unsigned, vector<unsigned> > faceToEdges; for (unsigned cellIndex=0; cellIndex<mesh3D->cellCount(); cellIndex++) { CellPtr cell = mesh3D->getCell(cellIndex); unsigned sideCount = cell->getSideCount(); for (unsigned sideOrdinal=0; sideOrdinal<sideCount; sideOrdinal++) { unsigned faceIndex = cell->entityIndex(faceDim, sideOrdinal); unsigned numCells = mesh3D->getActiveCellCount(faceDim,faceIndex); if (numCells == 1) // boundary face { boundaryFaces.insert(faceIndex); } else if (numCells == 2) { internalFaces.insert(faceIndex); } else { success = false; cout << "testEntityConstraints: In initial 3D mesh, face " << faceIndex << " has active cell count of " << numCells << ".\n"; } if (faceToEdges.find(faceIndex) == faceToEdges.end()) { CellTopoPtr faceTopo = cell->topology()->getSubcell(faceDim, sideOrdinal); unsigned numEdges = faceTopo->getSubcellCount(edgeDim); vector<unsigned> edgeIndices(numEdges); for (unsigned edgeOrdinal=0; edgeOrdinal<numEdges; edgeOrdinal++) { edgeIndices[edgeOrdinal] = mesh3D->getFaceEdgeIndex(faceIndex, edgeOrdinal); } } } } if (internalFaces.size() != 4) { success = false; cout << "testEntityConstraints: In initial 3D mesh, there are " << internalFaces.size() << " internal faces (expected 4).\n"; } for (set<unsigned>::iterator faceIt=internalFaces.begin(); faceIt != internalFaces.end(); faceIt++) { unsigned faceIndex = *faceIt; unsigned constrainingEntityIndex = mesh3D->getConstrainingEntity(faceDim,faceIndex).first; if (constrainingEntityIndex != faceIndex) { success = false; cout << "testEntityConstraints: In initial 3D mesh, internal face is constrained by a different face.\n"; } } // now, make a single refinement in each mesh: unsigned cellToRefine2D = 0, cellToRefine3D = 3; mesh2D->refineCell(cellToRefine2D, RefinementPattern::regularRefinementPatternQuad(), mesh2D->cellCount()); mesh3D->refineCell(cellToRefine3D, RefinementPattern::regularRefinementPatternHexahedron(), mesh3D->cellCount()); // printMeshInfo(mesh2D); // figure out which faces/edges were refined and add the corresponding map<unsigned,pair<IndexType,unsigned> > expectedEdgeConstraints2D; set<unsigned> refinedEdges; for (set<unsigned>::iterator edgeIt=boundaryEdges.begin(); edgeIt != boundaryEdges.end(); edgeIt++) { set<unsigned> children = mesh2D->getChildEntitiesSet(edgeDim, *edgeIt); if (children.size() > 0) { refinedEdges.insert(*edgeIt); boundaryEdges.insert(children.begin(), children.end()); } } for (set<unsigned>::iterator edgeIt=internalEdges.begin(); edgeIt != internalEdges.end(); edgeIt++) { set<unsigned> children = mesh2D->getChildEntitiesSet(edgeDim, *edgeIt); if (children.size() > 0) { refinedEdges.insert(*edgeIt); internalEdges.insert(children.begin(), children.end()); for (set<unsigned>::iterator childIt = children.begin(); childIt != children.end(); childIt++) { unsigned childIndex = *childIt; expectedEdgeConstraints2D[childIndex] = make_pair(*edgeIt, edgeDim); } } } // 1 quad refined: expect 4 refined edges if (refinedEdges.size() != 4) { success = false; cout << "After initial refinement, 2D mesh has " << refinedEdges.size() << " refined edges (expected 4).\n"; } checkConstraints(mesh2D, edgeDim, expectedEdgeConstraints2D); set<unsigned> refinedFaces; map<unsigned,pair<IndexType,unsigned> > expectedFaceConstraints3D; map<unsigned,pair<IndexType,unsigned> > expectedEdgeConstraints3D; for (set<unsigned>::iterator faceIt=boundaryFaces.begin(); faceIt != boundaryFaces.end(); faceIt++) { set<unsigned> children = mesh3D->getChildEntitiesSet(faceDim, *faceIt); if (children.size() > 0) { refinedFaces.insert(*faceIt); boundaryFaces.insert(children.begin(), children.end()); } } for (set<unsigned>::iterator faceIt=internalFaces.begin(); faceIt != internalFaces.end(); faceIt++) { vector<unsigned> children = mesh3D->getChildEntities(faceDim, *faceIt); if (children.size() > 0) { refinedFaces.insert(*faceIt); internalFaces.insert(children.begin(), children.end()); for (unsigned childOrdinal = 0; childOrdinal < children.size(); childOrdinal++) { unsigned childIndex = children[childOrdinal]; expectedFaceConstraints3D[childIndex] = make_pair(*faceIt, faceDim); unsigned numEdges = 4; unsigned internalEdgeCount = 0; // for each child of a quad, we expect to have 2 internal edges for (unsigned edgeOrdinal=0; edgeOrdinal<numEdges; edgeOrdinal++) { unsigned edgeIndex = mesh3D->getFaceEdgeIndex(childIndex, edgeOrdinal); unsigned activeCellCount = mesh3D->getActiveCellCount(edgeDim, edgeIndex); if (activeCellCount==2) { internalEdgeCount++; expectedEdgeConstraints3D[edgeIndex] = make_pair(*faceIt, faceDim); } else if (activeCellCount==1) // hanging edge { if (! mesh3D->entityHasParent(edgeDim, edgeIndex)) { cout << "Hanging edge with edgeIndex " << edgeIndex << " (in face " << childIndex << ") does not have a parent edge.\n"; cout << "Edge vertices:\n"; mesh3D->printEntityVertices(edgeDim, edgeIndex); cout << "Face vertices:\n"; mesh3D->printEntityVertices(faceDim, childIndex); success = false; } else { unsigned edgeParentIndex = mesh3D->getEntityParent(edgeDim, edgeIndex); expectedEdgeConstraints3D[edgeIndex] = make_pair(edgeParentIndex, edgeDim); } } else { cout << "Unexpected number of active cells: " << activeCellCount << endl; } } if (internalEdgeCount != 2) { cout << "Expected internalEdgeCount to be 2; was " << internalEdgeCount << endl; success = false; } } } } // 1 hex refined: expect 6 refined faces if (refinedFaces.size() != 6) { success = false; cout << "After initial refinement, 3D mesh has " << refinedFaces.size() << " refined faces (expected 6).\n"; } if (! checkConstraints(mesh3D, faceDim, expectedFaceConstraints3D, "refined 3D mesh") ) { cout << "Failed face constraint check for refined 3D mesh." << endl; success = false; } if (! checkConstraints(mesh3D, edgeDim, expectedEdgeConstraints3D, "refined 3D mesh") ) { cout << "Failed edge constraint check for refined 3D mesh." << endl; success = false; } // now, we refine one of the children of the refined cells in each mesh, to produce a 2-level constraint set<unsigned> edgeChildren2D; set<unsigned> cellsForEdgeChildren2D; for (map<unsigned,pair<IndexType,unsigned> >::iterator edgeConstraint=expectedEdgeConstraints2D.begin(); edgeConstraint != expectedEdgeConstraints2D.end(); edgeConstraint++) { edgeChildren2D.insert(edgeConstraint->first); unsigned cellIndex = mesh2D->getActiveCellIndices(edgeDim, edgeConstraint->first).begin()->first; cellsForEdgeChildren2D.insert(cellIndex); // cout << "cellsForEdgeChildren2D: " << cellIndex << endl; } // one of these has (1,0) as one of its vertices. Let's figure out which one: unsigned vertexIndex; if (! mesh2D->getVertexIndex(makeVertex(1, 0), vertexIndex) ) { cout << "Error: vertex not found.\n"; success = false; } vector< pair<unsigned,unsigned> > cellsForVertex = mesh2D->getActiveCellIndices(vertexDim, vertexIndex); if (cellsForVertex.size() != 2) { cout << "cellsForVertex should have 2 entries; has " << cellsForVertex.size() << endl; success = false; } unsigned childCellForVertex, childCellConstrainedEdge; set<unsigned> childNewlyConstrainingEdges; // the two interior edges that we break for (vector< pair<unsigned,unsigned> >::iterator cellIt=cellsForVertex.begin(); cellIt != cellsForVertex.end(); cellIt++) { // cout << "cellsForVertex: " << cellIt->first << endl; if ( cellsForEdgeChildren2D.find( cellIt->first ) != cellsForEdgeChildren2D.end() ) { // found match childCellForVertex = cellIt->first; // now, figure out which of the "edgeChildren2D" is shared by this cell: CellPtr cell = mesh2D->getCell(childCellForVertex); unsigned numEdges = cell->getSideCount(); for (unsigned edgeOrdinal=0; edgeOrdinal<numEdges; edgeOrdinal++) { unsigned edgeIndex = cell->entityIndex(edgeDim, edgeOrdinal); if (edgeChildren2D.find(edgeIndex) != edgeChildren2D.end()) { childCellConstrainedEdge = edgeIndex; } else if ( mesh2D->getActiveCellCount(edgeDim, edgeIndex) == 2 ) { childNewlyConstrainingEdges.insert(edgeIndex); } } } } if (childNewlyConstrainingEdges.size() != 2) { cout << "Expected 2 newly constraining edges after 2nd refinement of 2D mesh, but found " << childNewlyConstrainingEdges.size() << endl; success = false; } // refine the cell that matches (1,0): mesh2D->refineCell(childCellForVertex, RefinementPattern::regularRefinementPatternQuad(), mesh2D->cellCount()); // now, fix the expected edge constraints, then check them... set<unsigned> childEdges = mesh2D->getChildEntitiesSet(edgeDim, childCellConstrainedEdge); if (childEdges.size() != 2) { cout << "Expected 2 child edges, but found " << childEdges.size() << ".\n"; success = false; } for (set<unsigned>::iterator edgeIt = childEdges.begin(); edgeIt != childEdges.end(); edgeIt++) { expectedEdgeConstraints2D[*edgeIt] = expectedEdgeConstraints2D[childCellConstrainedEdge]; } expectedEdgeConstraints2D.erase(childCellConstrainedEdge); for (set<unsigned>::iterator edgeIt = childNewlyConstrainingEdges.begin(); edgeIt != childNewlyConstrainingEdges.end(); edgeIt++) { set<unsigned> newChildEdges = mesh2D->getChildEntitiesSet(edgeDim, *edgeIt); for (set<unsigned>::iterator newEdgeIt = newChildEdges.begin(); newEdgeIt != newChildEdges.end(); newEdgeIt++) { expectedEdgeConstraints2D[*newEdgeIt] = make_pair(*edgeIt,edgeDim); } } if (! checkConstraints(mesh2D, edgeDim, expectedEdgeConstraints2D, "twice-refined 2D mesh") ) { cout << "Failed constraint check for twice-refined 2D mesh." << endl; success = false; } // now, do a second level of refinement for 3D mesh // one of these has (1,2,0) as one of its vertices. Let's figure out which one: if (! mesh3D->getVertexIndex(makeVertex(1, 2, 0), vertexIndex) ) { cout << "Error: vertex not found.\n"; success = false; } cellsForVertex = mesh3D->getActiveCellIndices(vertexDim, vertexIndex); if (cellsForVertex.size() != 4) { cout << "cellsForVertex should have 4 entries; has " << cellsForVertex.size() << endl; success = false; } vector<unsigned> justCellsForVertex; for (vector< pair<unsigned,unsigned> >::iterator entryIt = cellsForVertex.begin(); entryIt != cellsForVertex.end(); entryIt++) { justCellsForVertex.push_back(entryIt->first); } vector<unsigned> childCellIndices = mesh3D->getCell(cellToRefine3D)->getChildIndices(mesh3D); std::sort(childCellIndices.begin(), childCellIndices.end()); vector<unsigned> matches(childCellIndices.size() + cellsForVertex.size()); vector<unsigned>::iterator matchEnd = std::set_intersection(justCellsForVertex.begin(), justCellsForVertex.end(), childCellIndices.begin(), childCellIndices.end(), matches.begin()); matches.resize(matchEnd-matches.begin()); if (matches.size() != 1) { cout << "matches should have exactly one entry, but has " << matches.size(); success = false; } unsigned childCellIndex = matches[0]; CellPtr childCell = mesh3D->getCell(childCellIndex); set<unsigned> childInteriorUnconstrainedFaces; set<unsigned> childInteriorConstrainedFaces; unsigned faceCount = childCell->getSideCount(); for (unsigned faceOrdinal=0; faceOrdinal<faceCount; faceOrdinal++) { unsigned faceIndex = childCell->entityIndex(faceDim, faceOrdinal); if (mesh3D->getActiveCellCount(faceDim, faceIndex) == 1) { // that's an interior constrained face, or a boundary face if (expectedFaceConstraints3D.find(faceIndex) != expectedFaceConstraints3D.end()) { // constrained face childInteriorConstrainedFaces.insert(faceIndex); } } else if (mesh3D->getActiveCellCount(faceDim, faceIndex) == 2) { // an interior unconstrained face childInteriorUnconstrainedFaces.insert(faceIndex); } else { cout << "Error: unexpected active cell count. Expected 1 or 2, but was " << mesh3D->getActiveCellCount(faceDim, faceIndex) << endl; success = false; } } // Camellia::print("childInteriorUnconstrainedFaces", childInteriorUnconstrainedFaces); // Camellia::print("childInteriorConstrainedFaces", childInteriorConstrainedFaces); mesh3D->refineCell(childCellIndex, RefinementPattern::regularRefinementPatternHexahedron(), mesh3D->cellCount()); // update expected face and edge constraints // set<unsigned> edgeConstraintsToDrop; for (set<unsigned>::iterator faceIt=childInteriorConstrainedFaces.begin(); faceIt != childInteriorConstrainedFaces.end(); faceIt++) { unsigned faceIndex = *faceIt; set<unsigned> newChildFaces = mesh3D->getChildEntitiesSet(faceDim, faceIndex); for (set<unsigned>::iterator newChildIt=newChildFaces.begin(); newChildIt != newChildFaces.end(); newChildIt++) { unsigned newChildIndex = *newChildIt; expectedFaceConstraints3D[newChildIndex] = expectedFaceConstraints3D[faceIndex]; // cout << "Expecting two-level face constraint: face " << newChildIndex << " constrained by face " << expectedFaceConstraints3D[newChildIndex].first << endl; } unsigned numEdges = mesh3D->getSubEntityCount(faceDim, faceIndex, edgeDim); set<IndexType> childEdgesOnParentBoundary; for (unsigned edgeOrdinal=0; edgeOrdinal<numEdges; edgeOrdinal++) { unsigned edgeIndex = mesh3D->getSubEntityIndex(faceDim, faceIndex, edgeDim, edgeOrdinal); set<unsigned> newChildEdges = mesh3D->getChildEntitiesSet(edgeDim, edgeIndex); for (set<unsigned>::iterator newChildIt=newChildEdges.begin(); newChildIt != newChildEdges.end(); newChildIt++) { unsigned newChildIndex = *newChildIt; expectedEdgeConstraints3D[newChildIndex] = expectedEdgeConstraints3D[edgeIndex]; // cout << "Expecting two-level edge constraint: edge " << newChildIndex << " constrained by "; // cout << typeString(expectedEdgeConstraints3D[newChildIndex].second) << " " << expectedEdgeConstraints3D[newChildIndex].first << endl; childEdgesOnParentBoundary.insert(newChildIndex); // edgeConstraintsToDrop.insert(edgeIndex); } } for (set<unsigned>::iterator newChildIt=newChildFaces.begin(); newChildIt != newChildFaces.end(); newChildIt++) { unsigned newChildFaceIndex = *newChildIt; int numEdges = mesh3D->getSubEntityCount(faceDim, newChildFaceIndex, edgeDim); for (unsigned edgeOrdinal=0; edgeOrdinal<numEdges; edgeOrdinal++) { unsigned newChildEdgeIndex = mesh3D->getSubEntityIndex(faceDim, newChildFaceIndex, edgeDim, edgeOrdinal); if (childEdgesOnParentBoundary.find(newChildEdgeIndex) == childEdgesOnParentBoundary.end()) { expectedEdgeConstraints3D[newChildEdgeIndex] = expectedFaceConstraints3D[faceIndex]; } } } expectedFaceConstraints3D.erase(faceIndex); } // for (set<unsigned>::iterator edgeToDropIt=edgeConstraintsToDrop.begin(); edgeToDropIt != edgeConstraintsToDrop.end(); edgeToDropIt++) { // expectedEdgeConstraints3D.erase(*edgeToDropIt); // } for (set<unsigned>::iterator faceIt=childInteriorUnconstrainedFaces.begin(); faceIt != childInteriorUnconstrainedFaces.end(); faceIt++) { unsigned faceIndex = *faceIt; set<unsigned> newChildFaces = mesh3D->getChildEntitiesSet(faceDim, faceIndex); for (set<unsigned>::iterator newChildIt=newChildFaces.begin(); newChildIt != newChildFaces.end(); newChildIt++) { unsigned newChildIndex = *newChildIt; expectedFaceConstraints3D[newChildIndex] = make_pair(faceIndex, faceDim); } expectedFaceConstraints3D.erase(faceIndex); unsigned numEdges = mesh3D->getSubEntityCount(faceDim, faceIndex, edgeDim); set<IndexType> childEdgesOnParentBoundary; for (unsigned edgeOrdinal=0; edgeOrdinal<numEdges; edgeOrdinal++) { unsigned edgeIndex = mesh3D->getSubEntityIndex(faceDim, faceIndex, edgeDim, edgeOrdinal); set<unsigned> newChildEdges = mesh3D->getChildEntitiesSet(edgeDim, edgeIndex); for (set<unsigned>::iterator newChildIt=newChildEdges.begin(); newChildIt != newChildEdges.end(); newChildIt++) { unsigned newChildIndex = *newChildIt; if (expectedEdgeConstraints3D.find(newChildIndex) == expectedEdgeConstraints3D.end()) // only impose edge constraint if there is not one already present { expectedEdgeConstraints3D[newChildIndex] = make_pair(edgeIndex,edgeDim); } childEdgesOnParentBoundary.insert(newChildIndex); } } for (set<unsigned>::iterator newChildIt=newChildFaces.begin(); newChildIt != newChildFaces.end(); newChildIt++) { unsigned newChildFaceIndex = *newChildIt; int numEdges = mesh3D->getSubEntityCount(faceDim, newChildFaceIndex, edgeDim); for (unsigned edgeOrdinal=0; edgeOrdinal<numEdges; edgeOrdinal++) { unsigned newChildEdgeIndex = mesh3D->getSubEntityIndex(faceDim, newChildFaceIndex, edgeDim, edgeOrdinal); if (childEdgesOnParentBoundary.find(newChildEdgeIndex) == childEdgesOnParentBoundary.end()) { if (expectedEdgeConstraints3D.find(newChildEdgeIndex) == expectedEdgeConstraints3D.end()) // only impose edge constraint if there is not one already present { expectedEdgeConstraints3D[newChildEdgeIndex] = make_pair(faceIndex, faceDim); } } } } } if (! checkConstraints(mesh3D, edgeDim, expectedEdgeConstraints3D, "twice-refined 3D mesh") ) { cout << "Failed edge constraint check for twice-refined 3D mesh." << endl; success = false; } if (! checkConstraints(mesh3D, faceDim, expectedFaceConstraints3D, "twice-refined 3D mesh") ) { cout << "Failed face constraint check for twice-refined 3D mesh." << endl; success = false; } return success; }
void AddConnection::bfs(int x1, int y1, int x2, int y2, Component*** a, BFSOut &outx) { int** vis = new int*[1400];for (int i = 0;i < 1400;i++)vis[i] = new int[780]; for (int i = 0;i < 1400;i++)for (int j = 0;j < 780;j++)vis[i][j] = 0; int** ifc = new int*[780];for (int i = 0;i < 780;i++)ifc[i] = new int[1400]; int** oth = new int*[780];for (int i = 0;i < 780;i++)oth[i] = new int[1400]; for (int i = 0;i < 780;i++) for (int j = 0;j < 1400;j++) { if (a[i][j] != NULL) if (a[i][j]->getSourcePin()!=NULL) { if (a[y1][x1 - 15]->getSourcePin()==NULL) { if (((a[i][j]))->getSourcePin() == (a[y1][x1 - 15])->GetOutputPin()) ifc[i][j] = 0; else ifc[i][j] = 1; oth[i][j] = 0; } } else { ifc[i][j] = 0;oth[i][j] = 1; } else { ifc[i][j] = 0;oth[i][j] = 0; } } queue< pair<int, int> > qu; qu.push(make_pair(x1, y1)); while (!qu.empty()) { pair<int, int> pr = qu.front(); vis[pr.first][pr.second] = 1; qu.pop(); if (isvalid(pr.first + 15, pr.second, vis, ifc, oth, pr.first, pr.second, x2, y2, x1,y1)) { qu.push(make_pair(pr.first + 15, pr.second)); outx.arr[pr.first + 15][pr.second] = make_pair(pr.first, pr.second); vis[pr.first + 15][pr.second] = 1; if (qu.back().first == x2 && qu.back().second == y2) break; } if (isvalid(pr.first, pr.second + 15, vis, ifc, oth, pr.first, pr.second, x2, y2, x1,y1)) { qu.push(make_pair(pr.first, pr.second + 15)); outx.arr[pr.first][pr.second + 15] = make_pair(pr.first, pr.second); vis[pr.first][pr.second + 15] = 1; if (qu.back().first == x2 && qu.back().second == y2) break; } if (isvalid(pr.first - 15, pr.second, vis, ifc, oth, pr.first, pr.second, x2, y2, x1,y1)) { qu.push(make_pair(pr.first - 15, pr.second)); outx.arr[pr.first - 15][pr.second] = make_pair(pr.first, pr.second); vis[pr.first - 15][pr.second] = 1; if (qu.back().first == x2 && qu.back().second == y2) break; } if (isvalid(pr.first, pr.second - 15, vis, ifc, oth, pr.first, pr.second, x2, y2, x1,y1)) { qu.push(make_pair(pr.first, pr.second - 15)); outx.arr[pr.first][pr.second - 15] = make_pair(pr.first, pr.second); vis[pr.first][pr.second - 15] = 1; if (qu.back().first == x2 && qu.back().second == y2) break; } } if (vis[x2][y2] == 1) outx.check = true; else outx.check = false; for (int i = 0; i < 780; i++) { delete[]vis[i]; delete[]ifc[i]; delete[]oth[i]; } delete[]vis; delete[]ifc; delete[]oth; }
pair<ll,ll> query(int l, int r) { return make_pair(((__int128)p[r - l] * a[l] - a[r] + moda) % moda, ((__int128)q[r - l] * b[l] - b[r] + modb) % modb); }
bool AddConnection::ReadActionParameters() { //Get a Pointer to the Input / Output Interfaces Output* pOut = pManager->GetOutput(); Input* pIn = pManager->GetInput(); pOut->FlushKeyQueue(); pOut->ClearStatusBar(); //Print Action Message pOut->PrintMsg("Adding Connection : Click to add the first edge "); pOut->UpdateBuffer(); if ( pManager->GetComponent( UI.u_GfxInfo.x1 , UI.u_GfxInfo.y1 )==NULL) do { if (pIn->GetKeyPressed() == ESCAPE) return false; if (pIn->GetPointClicked(Cx, Cy) == LEFT_CLICK&& (pManager->GetArr()[Cy][Cx])!=NULL) { if (((pManager->GetArr()[Cy][Cx])->GetOutputPinCoordinates().first != 0 && (pManager->GetArr()[Cy][Cx])->GetOutputPinCoordinates().second != 0)) { GInfo.x1 = (pManager->GetArr()[Cy][Cx])->GetOutputPinCoordinates().first; GInfo.y1 = (pManager->GetArr()[Cy][Cx])->GetOutputPinCoordinates().second; break; } else { pOut->ClearStatusBar(); pOut->PrintMsg("Please choose a vaild Gate or Switch "); pOut->UpdateBuffer(); } } } while (true); else { GInfo.x1 = (pManager->GetComponent( UI.u_GfxInfo.x1,UI.u_GfxInfo.y1))->GetOutputPinCoordinates( ).first; GInfo.y1 = (pManager->GetComponent(UI.u_GfxInfo.x1,UI.u_GfxInfo.y1))->GetOutputPinCoordinates( ).second; } pOut->ClearStatusBar(); pOut->PrintMsg("Adding Connection : Click to add the second edge "); pOut->UpdateBuffer(); do { if (pIn->GetKeyPressed() == ESCAPE) return false; if (pIn->GetPointClicked(Cx, Cy) == LEFT_CLICK && (pManager->GetArr()[Cy][Cx]) != NULL) { pOut->Magnetize(Cx, Cy); if (pManager->GetArr()[Cy][Cx]->GetInputPinCoordinates(make_pair(Cx, Cy)) != NULL) { GInfo.x2 = (pManager->GetComponent( Cx , Cy ))->GetInputPinCoordinates( make_pair( Cx , Cy ) )->first; GInfo.y2 = (pManager->GetComponent( Cx , Cy ))->GetInputPinCoordinates( make_pair( Cx , Cy ) )->second; break; } else { pOut->ClearStatusBar(); pOut->PrintMsg("You choosed an invalid Component, please choose a Gate or Led !!"); pOut->UpdateBuffer(); } } } while (true); bfs(GInfo.x1, GInfo.y1, GInfo.x2, GInfo.y2, pManager->GetArr(), outx); if (outx.check) return true; else { pManager->GetOutput()->ClearStatusBar(); pManager->GetOutput()->PrintMsg("There is no valid path"); pManager->GetOutput()->UpdateBuffer(); return false; } }
bool ResourceLoader::loadAnimData(AnimationData& aData, const pugi::xml_document &animXmlDoc, const SpriteSheet* sheet) { pugi::xml_node animationsXml = animXmlDoc.first_child(); aData.sheetName = animationsXml.attribute("spriteSheet").as_string(); // Iterate through all animations for (auto& animXml : animationsXml.children()) { string name = animXml.attribute("name").value(); int frameNum = (int)std::distance(animXml.children().begin(), animXml.children().end()); AnimationData::anim& a = aData.animations.emplace(make_pair(name, AnimationData::anim(frameNum))).first->second; a.name = name; a.loops = animXml.attribute("loops").as_uint(); // Iterate through cells in the current animation int cellIndex = 0; for (auto& cellXml : animXml.children()) { AnimationData::frame& f = a.frames[cellIndex]; f.delay = max(1, cellXml.attribute("delay").as_int() * 30900); std::multimap<int, AnimationData::sprite> zList; // Iterate through sprites in the current cell for (auto& spriteXml : cellXml.children()) { int z = spriteXml.attribute("z").as_int(); std::pair<int, AnimationData::sprite> smap(z, {}); auto& s = smap.second; string spriteName = spriteXml.attribute("name").as_string(); const auto& it = sheet->sprites.find(spriteName); if (it == sheet->sprites.end()) { // Couldn't find the requested sprite! std::cerr << "ERROR: couldn't find sprite \"" << spriteName << "\" in sheet \"" << sheet->imageName << "\"\n"; return false; } // Get draw rect from sprite object, and offset data from anim file s.draw = { it->second.left, it->second.top, it->second.width, it->second.height }; s.offset.x = spriteXml.attribute("x").as_float() - (int)(s.draw.width / 2.0f); s.offset.y = spriteXml.attribute("y").as_float() - (int)(s.draw.height / 2.0f); // Does it need to be flipped? if (spriteXml.attribute("flipH").as_bool()) { s.flipH = true; } if (spriteXml.attribute("flipV").as_bool()) { s.flipV = true; } // Use an associative container to keep the sprites in this frame in z-order zList.insert(smap); } // Create our vertex array from the collected rect data f.sprites.resize(zList.size() * 4); int i = 0; for (auto z : zList) { auto& s = z.second; f.sprites[i].texCoords = { s.draw.left, s.draw.top }; f.sprites[i].position = { s.offset.x, s.offset.y }; f.sprites[i + 1].texCoords = { s.draw.left + s.draw.width, s.draw.top }; f.sprites[i + 1].position = { s.draw.width + s.offset.x, s.offset.y }; f.sprites[i + 2].texCoords = { s.draw.left + s.draw.width, s.draw.top + s.draw.height }; f.sprites[i + 2].position = { s.draw.width + s.offset.x, s.draw.height + s.offset.y }; f.sprites[i + 3].texCoords = { s.draw.left, s.draw.top + s.draw.height }; f.sprites[i + 3].position = { s.offset.x, s.draw.height + s.offset.y }; if (s.flipH) { std::swap(f.sprites[i].position, f.sprites[i + 1].position); std::swap(f.sprites[i + 2].position, f.sprites[i + 3].position); } if (s.flipV) { std::swap(f.sprites[i].position, f.sprites[i + 3].position); std::swap(f.sprites[i + 1].position, f.sprites[i + 2].position); } i += 4; } cellIndex++; } } return true; }
void refine_kmer_index(vector<pair<int, int> >& kmer_index, vector<pair<int, vector<pair<int, int> > > >& primary_chain, string read, int dir, vector<reference_index>& refindex, int index) { int first, second, range1, range2; int i = 0, k = 0, start, min_len; int pre_str_pos, pre_ref_pos; int first_index, last_index; int ret_val1, ret_val2; int min_index = 0; int readlen = read.length(); node *head = new node; head->ref_ind = kmer_index[i].first; head->read_ind = kmer_index[i].second; head->next = NULL; node *current_node = head; //cout << "\nIndex = " << index << " ********************Starting New Analysis******************** = " // << kmer_index.size() << endl << endl; int ref_dif, read_dif; int next_ref_dif, next_read_dif; int prev_ref_dif, prev_read_dif; bool ref_repeat_flag = false; bool read_repeat_flag = false; int best_index, max_length = 0; int ref_start, read_start, l, x; for(i = 1; i < kmer_index.size(); i++) { //cout << i << ") Current Ref = " << current_node->ref_ind << ", Read = " << current_node->read_ind << endl; ref_dif = (kmer_index[i].first - current_node->ref_ind); read_dif = (kmer_index[i].second - current_node->read_ind); node *next_node = new node; next_node->ref_ind = kmer_index[i].first; next_node->read_ind = kmer_index[i].second; next_node->next = NULL; //cout << "Considering " << k << ") Reference = " << next_node->ref_ind << ", Read = " << next_node->read_ind << endl; current_node->next = next_node; current_node = next_node; k += 1; max_length = 0; ref_repeat_flag = false; read_repeat_flag = false; } if(i < kmer_index.size()) { node *next_node = new node; next_node->ref_ind = kmer_index[i].first; next_node->read_ind = kmer_index[i].second; next_node->next = NULL; //cout << "\t" << k << ") Reference = " << next_node->ref_ind << ", Read = " << next_node->read_ind << endl; current_node->next = next_node; current_node = next_node; } /////////////////////////////////////////////////////////////////////////////////////////////////////////// node *tmp_node; current_node = head; while(current_node != NULL) { //cout << "\nStarting Chain Creation: " << endl; //cout << "Ref = " << current_node->ref_ind << ", And Read = " << current_node->read_ind << endl; //if(current_node->read_ind < readlen / 2) { vector<pair<int, int> > chain; chain.push_back(make_pair(current_node->ref_ind, current_node->read_ind)); create_primary_chain_from_list(current_node, chain, current_node->next, current_node, readlen); if(chain.size() > 1) { primary_chain.push_back(make_pair(index * MULTIPLIER + dir, chain)); //cout << "Size of Chain is = " << chain.size() << endl; } } tmp_node = current_node; current_node = current_node->next; delete tmp_node; tmp_node = NULL; //cout << "$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$" << endl << endl; } }
Table* read_from_userprofile() { ifstream myfile ("userprofile.csv"); if (myfile.is_open()) { Table::ColumnList columns; String userID; getline( myfile, userID, ',' ); columns.push_back(make_pair(userID, Table::varchar)); String latitude; getline( myfile, latitude, ',' ); columns.push_back(make_pair(latitude, Table::floating)); String longitude; getline( myfile, longitude, ',' ); columns.push_back(make_pair(longitude, Table::integer)); String smoker; getline( myfile, smoker, ','); columns.push_back(make_pair(smoker, Table::varchar)); String drink_level; getline( myfile, drink_level, ','); columns.push_back(make_pair(drink_level, Table::varchar)); String dress_preference; getline( myfile, dress_preference, ',' ); columns.push_back(make_pair(dress_preference, Table::varchar)); String ambience; getline( myfile, ambience, ',' ); columns.push_back(make_pair(ambience, Table::varchar)); String transport; getline( myfile, transport, ',' ); columns.push_back(make_pair(transport, Table::varchar)); String marital_status; getline( myfile, marital_status, ',' ); columns.push_back(make_pair(marital_status, Table::varchar)); String hijos; getline( myfile, hijos, ','); columns.push_back(make_pair(hijos, Table::varchar)); String birth_year; getline( myfile, birth_year, ',' ); columns.push_back(make_pair(birth_year, Table::integer)); String interest; getline( myfile, interest, ',' ); columns.push_back(make_pair(interest, Table::varchar)); String personality; getline( myfile, personality, ',' ); columns.push_back(make_pair(personality, Table::varchar)); String religion; getline( myfile, religion, ',' ); columns.push_back(make_pair(religion, Table::varchar)); String activity; getline( myfile, activity, ',' ); columns.push_back(make_pair(activity, Table::varchar)); String color; getline( myfile, color, ',' ); columns.push_back(make_pair(color, Table::varchar)); String weight; getline( myfile, weight, ',' ); columns.push_back(make_pair(weight, Table::integer)); String budget; getline( myfile, budget, ',' ); columns.push_back(make_pair(budget, Table::varchar)); String height; getline( myfile, height, '\n' ); columns.push_back(make_pair(height, Table::floating)); Table* geo = new Table(columns); // Create geo using the defined columns while ( myfile.good() ) { vector<pair<string, string> > entries; // Entries for the record to be placed in the table string userID; getline( myfile, userID, ',' ); pair <string,string> pair0 ("userID",userID); // value init entries.push_back(pair0); string latitude; getline( myfile, latitude, ',' ); pair <string,string> pair1 ("latitude",latitude); // value init entries.push_back(pair1); string longitude; getline( myfile, longitude, ',' ); pair <string,string> pair2 ("longitude",longitude); // value init entries.push_back(pair2); string smoker; getline( myfile, smoker, ',' ); pair <string,string> pair3 ("smoker",smoker); // value init entries.push_back(pair3); string drink_level; getline( myfile, drink_level, ',' ); pair <string,string> pair4 ("drink_level",drink_level); // value init entries.push_back(pair4); string dress_preference; getline( myfile, dress_preference, ',' ); pair <string,string> pair5 ("dress_preference",dress_preference); // value init entries.push_back(pair5); string ambience; getline( myfile, ambience, ',' ); pair <string,string> pair6 ("ambience",ambience); // value init entries.push_back(pair6); string transport; getline( myfile, transport, ',' ); pair <string,string> pair7 ("transport",transport); // value init entries.push_back(pair7); string marital_status; getline( myfile, marital_status, ',' ); pair <string,string> pair8 ("marital_status",marital_status); // value init entries.push_back(pair8); string hijos; getline( myfile, hijos, ',' ); pair <string,string> pair9 ("hijos",hijos); // value init entries.push_back(pair9); string birth_year; getline( myfile, birth_year, ',' ); pair <string,string> pair10 ("birth_year",birth_year); // value init entries.push_back(pair10); string interest; getline( myfile, interest, ',' ); pair <string,string> pair11 ("interest",interest); // value init entries.push_back(pair11); string personality; getline( myfile, personality, ',' ); pair <string,string> pair12 ("personality",personality); // value init entries.push_back(pair12); string religion; getline( myfile, religion, ',' ); pair <string,string> pair13 ("religion",religion); // value init entries.push_back(pair13); string activity; getline( myfile, activity, ',' ); pair <string,string> pair14 ("activity",activity); // value init entries.push_back(pair14); string color; getline( myfile, color, ',' ); pair <string,string> pair15 ("color",color); // value init entries.push_back(pair15); string weight; getline( myfile, weight, ',' ); pair <string,string> pair16 ("weight",weight); // value init entries.push_back(pair16); string budget; getline( myfile, budget, ',' ); pair <string,string> pair17 ("budget",budget); // value init entries.push_back(pair17); string height; getline( myfile, height, '\n' ); pair <string,string> pair18 ("height",height); // value init entries.push_back(pair18); Record add(entries); // Create record to add to table geo->insert(add); // Insert add record into geo } myfile.close(); return geo; } }
void InsertSplits(const NetParameter& param, NetParameter* param_split) { // Initialize by copying from the input NetParameter. param_split->CopyFrom(param); param_split->clear_layer(); map<string, pair<int_tp, int_tp> > blob_name_to_last_top_idx; map<pair<int_tp, int_tp>, pair<int_tp, int_tp> > bottom_idx_to_source_top_idx; map<pair<int_tp, int_tp>, int_tp> top_idx_to_bottom_count; map<pair<int_tp, int_tp>, float> top_idx_to_loss_weight; map<pair<int_tp, int_tp>, int_tp> top_idx_to_bottom_split_idx; map<int_tp, string> layer_idx_to_layer_name; for (int_tp i = 0; i < param.layer_size(); ++i) { const LayerParameter& layer_param = param.layer(i); layer_idx_to_layer_name[i] = layer_param.name(); for (int_tp j = 0; j < layer_param.bottom_size(); ++j) { const string& blob_name = layer_param.bottom(j); if (blob_name_to_last_top_idx.find(blob_name) == blob_name_to_last_top_idx.end()) { LOG(FATAL) << "Unknown bottom blob '" << blob_name << "' (layer '" << layer_param.name() << "', bottom index " << j << ")"; } const pair<int_tp, int_tp>& bottom_idx = make_pair(i, j); const pair<int_tp, int_tp>& top_idx = blob_name_to_last_top_idx[blob_name]; bottom_idx_to_source_top_idx[bottom_idx] = top_idx; ++top_idx_to_bottom_count[top_idx]; } for (int_tp j = 0; j < layer_param.top_size(); ++j) { const string& blob_name = layer_param.top(j); blob_name_to_last_top_idx[blob_name] = make_pair(i, j); } // a use of a top blob as a loss should be handled similarly to the use of // a top blob as a bottom blob to another layer. const int_tp last_loss = std::min(layer_param.loss_weight_size(), layer_param.top_size()); for (int_tp j = 0; j < last_loss; ++j) { const string& blob_name = layer_param.top(j); const pair<int_tp, int_tp>& top_idx = blob_name_to_last_top_idx[blob_name]; top_idx_to_loss_weight[top_idx] = layer_param.loss_weight(j); if (top_idx_to_loss_weight[top_idx]) { ++top_idx_to_bottom_count[top_idx]; } } } for (int_tp i = 0; i < param.layer_size(); ++i) { LayerParameter* layer_param = param_split->add_layer(); layer_param->CopyFrom(param.layer(i)); // Replace any shared bottom blobs with split layer outputs. for (int_tp j = 0; j < layer_param->bottom_size(); ++j) { const pair<int_tp, int_tp>& top_idx = bottom_idx_to_source_top_idx[make_pair(i, j)]; const int_tp split_count = top_idx_to_bottom_count[top_idx]; if (split_count > 1) { const string& layer_name = layer_idx_to_layer_name[top_idx.first]; const string& blob_name = layer_param->bottom(j); layer_param->set_bottom(j, SplitBlobName(layer_name, blob_name, top_idx.second, top_idx_to_bottom_split_idx[top_idx]++)); while (layer_param->bottom_quantizer_size() <= j) { layer_param->add_bottom_quantizer(); } // Need to preserve the original blob name for quantization purposes if (!layer_param->bottom_quantizer(j).has_name()) { layer_param->mutable_bottom_quantizer(j)->set_name(blob_name); } } } // Create split layer for any top blobs used by other layer as bottom // blobs more than once. for (int_tp j = 0; j < layer_param->top_size(); ++j) { const pair<int_tp, int_tp>& top_idx = make_pair(i, j); const int_tp split_count = top_idx_to_bottom_count[top_idx]; if (split_count > 1) { const string& layer_name = layer_idx_to_layer_name[i]; const string& blob_name = layer_param->top(j); LayerParameter* split_layer_param = param_split->add_layer(); const float loss_weight = top_idx_to_loss_weight[top_idx]; const QuantizerParameter* ref_quant_param = nullptr; if (layer_param->bottom_quantizer_size() > j) { ref_quant_param = &(layer_param->bottom_quantizer(j)); } ConfigureSplitLayer(layer_name, blob_name, j, split_count, loss_weight, split_layer_param, layer_param->top_data_type(), layer_param->top_data_type(), ref_quant_param); if (loss_weight) { layer_param->clear_loss_weight(); top_idx_to_bottom_split_idx[top_idx]++; } } } } }
Table* read_from_geoplaces2() { ifstream myfile ("geoplaces2.csv"); if (myfile.is_open()) { Table::ColumnList columns; String placeID; getline( myfile, placeID, ',' ); columns.push_back(make_pair(placeID, Table::integer)); String latitude; getline( myfile, latitude, ',' ); columns.push_back(make_pair(latitude, Table::floating)); String longitude; getline( myfile, longitude, ',' ); columns.push_back(make_pair(longitude, Table::floating)); String the_geom_meter; getline( myfile, the_geom_meter, ',' ); columns.push_back(make_pair(the_geom_meter, Table::varchar)); String name; getline( myfile, name, ',' ); columns.push_back(make_pair(name, Table::varchar)); String address; getline( myfile, address, ',' ); columns.push_back(make_pair(address, Table::varchar)); String city; getline( myfile, city, ',' ); columns.push_back(make_pair(city, Table::varchar)); String state; getline( myfile, state, ',' ); columns.push_back(make_pair(state, Table::varchar)); String country; getline( myfile, country, ',' ); columns.push_back(make_pair(country, Table::varchar)); String fax; getline( myfile, fax, ',' ); columns.push_back(make_pair(fax, Table::varchar)); String zip; getline( myfile, zip, ',' ); columns.push_back(make_pair(zip, Table::varchar)); String alcohol; getline( myfile, alcohol, ',' ); columns.push_back(make_pair(alcohol, Table::varchar)); String smoking_area; getline( myfile, smoking_area, ',' ); columns.push_back(make_pair(smoking_area, Table::varchar)); String dress_code; getline( myfile, dress_code, ',' ); columns.push_back(make_pair(dress_code, Table::varchar)); String accessibility; getline( myfile, accessibility, ',' ); columns.push_back(make_pair(accessibility, Table::varchar)); String price; getline( myfile, price, ',' ); columns.push_back(make_pair(price, Table::varchar)); String url; getline( myfile, url, ',' ); columns.push_back(make_pair(url, Table::varchar)); String Rambience; getline( myfile, Rambience, ',' ); columns.push_back(make_pair(Rambience, Table::varchar)); String franchise; getline( myfile, franchise, ',' ); columns.push_back(make_pair(franchise, Table::varchar)); String area; getline( myfile, area, ',' ); columns.push_back(make_pair(area, Table::varchar)); String other_services; getline( myfile, other_services, '\n' ); columns.push_back(make_pair(other_services, Table::varchar)); Table* geo = new Table(columns); // Create geo using the defined columns while ( myfile.good() ) { vector<pair<string, string> > entries; // Entries for the record to be placed in the table string placeID; getline( myfile, placeID, ',' ); pair <string,string> pair0 ("placeID",placeID); // value init entries.push_back(pair0); string latitude; getline( myfile, latitude, ',' ); pair <string,string> pair1 ("latitude",latitude); // value init entries.push_back(pair1); string longitude; getline( myfile, longitude, ',' ); pair <string,string> pair2 ("longitude",longitude); // value init entries.push_back(pair2); string the_geom_meter; getline( myfile, the_geom_meter, ',' ); pair <string,string> pair3 ("the_geom_meter",the_geom_meter); // value init entries.push_back(pair3); string name; getline( myfile, name, ',' ); pair <string,string> pair4 ("name",name); // value init entries.push_back(pair4); string address; getline( myfile, address, ',' ); pair <string,string> pair5 ("address",address); // value init entries.push_back(pair5); string city; getline( myfile, city, ',' ); pair <string,string> pair6 ("city",city); // value init entries.push_back(pair6); string state; getline( myfile, state, ',' ); pair <string,string> pair7 ("state",state); // value init entries.push_back(pair7); string country; getline( myfile, country, ',' ); pair <string,string> pair8 ("country",country); // value init entries.push_back(pair8); string fax; getline( myfile, fax, ',' ); pair <string,string> pair9 ("fax",fax); // value init entries.push_back(pair9); string zip; getline( myfile, zip, ',' ); pair <string,string> pair10 ("zip",zip); // value init entries.push_back(pair10); string alcohol; getline( myfile, alcohol, ',' ); pair <string,string> pair11 ("alcohol",alcohol); // value init entries.push_back(pair11); string smoking_area; getline( myfile, smoking_area, ',' ); pair <string,string> pair12 ("smoking_area",smoking_area); // value init entries.push_back(pair12); string dress_code; getline( myfile, dress_code, ',' ); pair <string,string> pair13 ("dress_code",dress_code); // value init entries.push_back(pair13); string accessibility; getline( myfile, accessibility, ',' ); pair <string,string> pair14 ("accessibility",accessibility); // value init entries.push_back(pair14); string price; getline( myfile, price, ',' ); pair <string,string> pair15 ("price",price); // value init entries.push_back(pair15); string url; getline( myfile, url, ',' ); pair <string,string> pair16 ("url",url); // value init entries.push_back(pair16); string Rambience; getline( myfile, Rambience, ',' ); pair <string,string> pair17 ("Rambience",Rambience); // value init entries.push_back(pair17); string franchise; getline( myfile, franchise, ',' ); pair <string,string> pair18 ("franchise",franchise); // value init entries.push_back(pair18); string area; getline( myfile, area, ',' ); pair <string,string> pair19 ("area",area); // value init entries.push_back(pair19); string other_services; getline( myfile, other_services, '\n' ); pair <string,string> pair20 ("other_services",other_services); // value init entries.push_back(pair20); Record add(entries); // Create record to add to table geo->insert(add); // Insert add record into geo } myfile.close(); return geo; } }
void BatchWriteExec::executeBatch( const BatchedCommandRequest& clientRequest, BatchedCommandResponse* clientResponse ) { LOG( 4 ) << "starting execution of write batch of size " << static_cast<int>( clientRequest.sizeWriteOps() ) << " for " << clientRequest.getNS() << endl; BatchWriteOp batchOp; batchOp.initClientRequest( &clientRequest ); // Current batch status bool refreshedTargeter = false; int rounds = 0; int numCompletedOps = 0; int numRoundsWithoutProgress = 0; while ( !batchOp.isFinished() ) { // // Get child batches to send using the targeter // // Targeting errors can be caused by remote metadata changing (the collection could have // been dropped and recreated, for example with a new shard key). If a remote metadata // change occurs *before* a client sends us a batch, we need to make sure that we don't // error out just because we're staler than the client - otherwise mongos will be have // unpredictable behavior. // // (If a metadata change happens *during* or *after* a client sends us a batch, however, // we make no guarantees about delivery.) // // For this reason, we don't record targeting errors until we've refreshed our targeting // metadata at least once *after* receiving the client batch - at that point, we know: // // 1) our new metadata is the same as the metadata when the client sent a batch, and so // targeting errors are real. // OR // 2) our new metadata is a newer version than when the client sent a batch, and so // the metadata must have changed after the client batch was sent. We don't need to // deliver in this case, since for all the client knows we may have gotten the batch // exactly when the metadata changed. // OwnedPointerVector<TargetedWriteBatch> childBatchesOwned; vector<TargetedWriteBatch*>& childBatches = childBatchesOwned.mutableVector(); // If we've already had a targeting error, we've refreshed the metadata once and can // record target errors definitively. bool recordTargetErrors = refreshedTargeter; Status targetStatus = batchOp.targetBatch( *_targeter, recordTargetErrors, &childBatches ); if ( !targetStatus.isOK() ) { // Don't do anything until a targeter refresh _targeter->noteCouldNotTarget(); refreshedTargeter = true; ++_stats->numTargetErrors; dassert( childBatches.size() == 0u ); } // // Send all child batches // size_t numSent = 0; size_t numToSend = childBatches.size(); bool remoteMetadataChanging = false; while ( numSent != numToSend ) { // Collect batches out on the network, mapped by endpoint OwnedHostBatchMap ownedPendingBatches; OwnedHostBatchMap::MapType& pendingBatches = ownedPendingBatches.mutableMap(); // // Send side // // Get as many batches as we can at once for ( vector<TargetedWriteBatch*>::iterator it = childBatches.begin(); it != childBatches.end(); ++it ) { // // Collect the info needed to dispatch our targeted batch // TargetedWriteBatch* nextBatch = *it; // If the batch is NULL, we sent it previously, so skip if ( nextBatch == NULL ) continue; // Figure out what host we need to dispatch our targeted batch ConnectionString shardHost; Status resolveStatus = _resolver->chooseWriteHost( nextBatch->getEndpoint() .shardName, &shardHost ); if ( !resolveStatus.isOK() ) { ++_stats->numResolveErrors; // Record a resolve failure // TODO: It may be necessary to refresh the cache if stale, or maybe just // cancel and retarget the batch WriteErrorDetail error; buildErrorFrom( resolveStatus, &error ); LOG( 4 ) << "unable to send write batch to " << shardHost.toString() << causedBy( resolveStatus.toString() ) << endl; batchOp.noteBatchError( *nextBatch, error ); // We're done with this batch // Clean up when we can't resolve a host delete *it; *it = NULL; --numToSend; continue; } // If we already have a batch for this host, wait until the next time OwnedHostBatchMap::MapType::iterator pendingIt = pendingBatches.find( shardHost ); if ( pendingIt != pendingBatches.end() ) continue; // // We now have all the info needed to dispatch the batch // BatchedCommandRequest request( clientRequest.getBatchType() ); batchOp.buildBatchRequest( *nextBatch, &request ); // Internally we use full namespaces for request/response, but we send the // command to a database with the collection name in the request. NamespaceString nss( request.getNS() ); request.setNS( nss.coll() ); LOG( 4 ) << "sending write batch to " << shardHost.toString() << ": " << request.toString() << endl; _dispatcher->addCommand( shardHost, nss.db(), request ); // Indicate we're done by setting the batch to NULL // We'll only get duplicate hostEndpoints if we have broadcast and non-broadcast // endpoints for the same host, so this should be pretty efficient without // moving stuff around. *it = NULL; // Recv-side is responsible for cleaning up the nextBatch when used pendingBatches.insert( make_pair( shardHost, nextBatch ) ); } // Send them all out _dispatcher->sendAll(); numSent += pendingBatches.size(); // // Recv side // while ( _dispatcher->numPending() > 0 ) { // Get the response ConnectionString shardHost; BatchedCommandResponse response; Status dispatchStatus = _dispatcher->recvAny( &shardHost, &response ); // Get the TargetedWriteBatch to find where to put the response dassert( pendingBatches.find( shardHost ) != pendingBatches.end() ); TargetedWriteBatch* batch = pendingBatches.find( shardHost )->second; if ( dispatchStatus.isOK() ) { TrackedErrors trackedErrors; trackedErrors.startTracking( ErrorCodes::StaleShardVersion ); LOG( 4 ) << "write results received from " << shardHost.toString() << ": " << response.toString() << endl; // Dispatch was ok, note response batchOp.noteBatchResponse( *batch, response, &trackedErrors ); // Note if anything was stale const vector<ShardError*>& staleErrors = trackedErrors.getErrors( ErrorCodes::StaleShardVersion ); if ( staleErrors.size() > 0 ) { noteStaleResponses( staleErrors, _targeter ); ++_stats->numStaleBatches; } // Remember if the shard is actively changing metadata right now if ( isShardMetadataChanging( staleErrors ) ) { remoteMetadataChanging = true; } // Remember that we successfully wrote to this shard // NOTE: This will record lastOps for shards where we actually didn't update // or delete any documents, which preserves old behavior but is conservative _stats->noteWriteAt( shardHost, response.isLastOpSet() ? response.getLastOp() : OpTime(), response.isElectionIdSet() ? response.getElectionId() : OID()); } else { // Error occurred dispatching, note it stringstream msg; msg << "write results unavailable from " << shardHost.toString() << causedBy( dispatchStatus.toString() ); WriteErrorDetail error; buildErrorFrom( Status( ErrorCodes::RemoteResultsUnavailable, msg.str() ), &error ); LOG( 4 ) << "unable to receive write results from " << shardHost.toString() << causedBy( dispatchStatus.toString() ) << endl; batchOp.noteBatchError( *batch, error ); } } } ++rounds; ++_stats->numRounds; // If we're done, get out if ( batchOp.isFinished() ) break; // MORE WORK TO DO // // Refresh the targeter if we need to (no-op if nothing stale) // bool targeterChanged = false; Status refreshStatus = _targeter->refreshIfNeeded( &targeterChanged ); if ( !refreshStatus.isOK() ) { // It's okay if we can't refresh, we'll just record errors for the ops if // needed. warning() << "could not refresh targeter" << causedBy( refreshStatus.reason() ) << endl; } // // Ensure progress is being made toward completing the batch op // int currCompletedOps = batchOp.numWriteOpsIn( WriteOpState_Completed ); if ( currCompletedOps == numCompletedOps && !targeterChanged && !remoteMetadataChanging ) { ++numRoundsWithoutProgress; } else { numRoundsWithoutProgress = 0; } numCompletedOps = currCompletedOps; if ( numRoundsWithoutProgress > kMaxRoundsWithoutProgress ) { stringstream msg; msg << "no progress was made executing batch write op in " << clientRequest.getNS() << " after " << kMaxRoundsWithoutProgress << " rounds (" << numCompletedOps << " ops completed in " << rounds << " rounds total)"; WriteErrorDetail error; buildErrorFrom( Status( ErrorCodes::NoProgressMade, msg.str() ), &error ); batchOp.abortBatch( error ); break; } } batchOp.buildClientResponse( clientResponse ); LOG( 4 ) << "finished execution of write batch" << ( clientResponse->isErrDetailsSet() ? " with write errors" : "") << ( clientResponse->isErrDetailsSet() && clientResponse->isWriteConcernErrorSet() ? " and" : "" ) << ( clientResponse->isWriteConcernErrorSet() ? " with write concern error" : "" ) << " for " << clientRequest.getNS() << endl; }
WalletModel::SendCoinsReturn WalletModel::sendCoins(const QList<SendCoinsRecipient> &recipients) { qint64 total = 0; QSet<QString> setAddress; QString hex; if(recipients.empty()) { return OK; } // Pre-check input data for validity foreach(const SendCoinsRecipient &rcp, recipients) { if(!validateAddress(rcp.address)) { return InvalidAddress; } setAddress.insert(rcp.address); if(rcp.amount <= 0) { return InvalidAmount; } total += rcp.amount; } if(recipients.size() > setAddress.size()) { return DuplicateAddress; } if(total > getBalance()) { return AmountExceedsBalance; } if((total + nTransactionFee) > getBalance()) { return SendCoinsReturn(AmountWithFeeExceedsBalance, nTransactionFee); } { LOCK2(cs_main, wallet->cs_wallet); // Sendmany std::vector<std::pair<CScript, int64> > vecSend; foreach(const SendCoinsRecipient &rcp, recipients) { CScript scriptPubKey; scriptPubKey.SetDestination(CBitcoinAddress(rcp.address.toStdString()).Get()); vecSend.push_back(make_pair(scriptPubKey, rcp.amount)); } CWalletTx wtx; CReserveKey keyChange(wallet); int64 nFeeRequired = 0; std::string strFailReason; bool fCreated = wallet->CreateTransaction(vecSend, wtx, keyChange, nFeeRequired, strFailReason); if(!fCreated) { if((total + nFeeRequired) > wallet->GetBalance()) { return SendCoinsReturn(AmountWithFeeExceedsBalance, nFeeRequired); } emit message(tr("Send Coins"), QString::fromStdString(strFailReason), CClientUIInterface::MSG_ERROR); return TransactionCreationFailed; } if(!uiInterface.ThreadSafeAskFee(nFeeRequired)) { return Aborted; } if(!wallet->CommitTransaction(wtx, keyChange)) { return TransactionCommitFailed; } hex = QString::fromStdString(wtx.GetHash().GetHex()); }
WalletModel::SendCoinsReturn WalletModel::sendCoins(const QList<SendCoinsRecipient> &recipients, const CCoinControl *coinControl) { qint64 total = 0; QSet<QString> setAddress; QString hex; if(recipients.empty()) { return OK; } // Pre-check input data for validity foreach(const SendCoinsRecipient &rcp, recipients) { if(!validateAddress(rcp.address)) { return InvalidAddress; } setAddress.insert(rcp.address); if(rcp.amount < MIN_TXOUT_AMOUNT) { return InvalidAmount; } total += rcp.amount; } if(recipients.size() > setAddress.size()) { return DuplicateAddress; } // we do not use getBalance() here, because some coins could be locked or coin control could be active int64 nBalance = 0; std::vector<COutput> vCoins; wallet->AvailableCoins(vCoins, true, coinControl); BOOST_FOREACH(const COutput& out, vCoins) nBalance += out.tx->vout[out.i].nValue; if(total > nBalance) { return AmountExceedsBalance; } if((total + nTransactionFee) > nBalance) { return SendCoinsReturn(AmountWithFeeExceedsBalance, nTransactionFee); } { LOCK2(cs_main, wallet->cs_wallet); // Sendmany std::vector<std::pair<CScript, int64> > vecSend; foreach(const SendCoinsRecipient &rcp, recipients) { CScript scriptPubKey; scriptPubKey.SetDestination(CBitcoinAddress(rcp.address.toStdString()).Get()); vecSend.push_back(make_pair(scriptPubKey, rcp.amount)); } CWalletTx wtx; CReserveKey keyChange(wallet); int64 nFeeRequired = 0; bool fCreated = wallet->CreateTransaction(vecSend, wtx, keyChange, nFeeRequired, coinControl); if(!fCreated) { if((total + nFeeRequired) > nBalance) { return SendCoinsReturn(AmountWithFeeExceedsBalance, nFeeRequired); } return TransactionCreationFailed; } if(!ThreadSafeAskFee(nFeeRequired, tr("Sending...").toStdString())) { return Aborted; } if(!wallet->CommitTransaction(wtx, keyChange)) { return TransactionCommitFailed; } hex = QString::fromStdString(wtx.GetHash().GetHex()); }
void SimpleXML::addChildAttrib(const string& aName, const string& aData) throw(SimpleXMLException) { checkChildSelected(); (*currentChild)->attribs.push_back(make_pair(aName, aData)); }
//get candicate query id,category StrToIntMap indexEngine::search(const std::string& userQuery ,queryProperty& qProperty) { std::string nstr = userQuery; if(0 != userQuery.length()) { Normalize::normalize(nstr); qProperty.cqIdList.clear(); qProperty.cQuery.clear(); qProperty.cCategory.clear(); qProperty.rsKeywords.clear(); StrToIntMap termsMap; StrToIntMapIter termsMapIter; tokenTerms(nstr,termsMap); IdToQListIter termsQidIter; //get candicate query id for(termsMapIter = termsMap.begin(); termsMapIter != termsMap.end(); ++termsMapIter) { termsQidIter = terms2qIDs_.find(termsMapIter->second); if(terms2qIDs_.end() != termsQidIter) { qProperty.cqIdList.insert(make_pair(termsMapIter->second,termsQidIter->second)); } } IdToQueryIter queryIter; //get candicate query data for(termsQidIter = qProperty.cqIdList.begin(); termsQidIter != qProperty.cqIdList.end(); ++termsQidIter) { for(std::size_t i = 0; i < termsQidIter->second.size(); ++i) { queryIter = queryIdata_.find(termsQidIter->second[i]); if(queryIdata_.end() != queryIter) { if(queryIter->second.text.size() > 30) continue; qProperty.cQuery.insert(make_pair(termsQidIter->second[i],queryIter->second)); } } } GetProperty(userQuery,qProperty.cCategory,qProperty.rsKeywords); // std::cout << "termsmap.size" << termsMap.size() << "\tcandicateqid.size()" // << candicateQid.size() <<"\tcandicate query.size()" // << candicateQuery.size()<< std::endl; //get candicate category /* std::string str = userQuery; Normalize::normalize(str); std::size_t qID = hash_query(str); QueryCateMapIter cateIter; cateIter = query2Cate_.find(qID); if(query2Cate_.end() != cateIter) { candicateCate.insert(make_pair(qID,cateIter->second)); }*/ return termsMap; } LOG(INFO) << "User query terms num:" << qProperty.cqIdList.size() << "\tCandicate query num:" << qProperty.cQuery.size() << "\tCandicate category num:" << qProperty.cCategory.size(); }
void MP2:: expectation(CorpusCache& cache){ double& alpha=alpha_; double alphaCount=0; for(auto& sp: cache){ vector<vector<double>> target_probs(sp.m,vector<double>(sp.l,0.0)); alpha/=sp.n*sp.l; for(int j=0;j<sp.m;j++){ for(int jlen=0;jlen<sp.l;jlen++){ for(int i=0;i<sp.n;i++){ for(int ilen=0;ilen<sp.l;ilen++){ if(sp(i,ilen,j,jlen)!=(void*)0){ target_probs[j][jlen]+= (sp(i,ilen,j,jlen)->prob*alpha); if(sp(i,ilen,j,jlen)->prob>1){ cerr<<"wth prob>1 : " <<sp(i,ilen,j,jlen)->prob<<endl; } } } } //cout<<target_probs[j][jlen]<<" "; } //cout<<endl; } //cout<<endl; for(int j=0;j<sp.m;j++){ for(int jlen=0;jlen<sp.l;jlen++){ if(target_probs[j][jlen]>1) cerr<<"error :"<<target_probs[j][jlen]<<endl; } } vector<double> forward(sp.m,0.0),backward(sp.m,0.0); //forward[i] is the posterior probability of target words of 1...i+1 for(int i=0;i<sp.l&&i<sp.m;i++) forward[i]=target_probs[0][i]; for(int i=1;i<(int)forward.size();i++){ for(int j=1;j<=sp.l&&i-j>=0;j++){ forward[i]+=forward[i-j]*target_probs[i-j+1][j-1]; } } //backward[i] is the posterior probability of target words of i+1...m for(int i=0;i<sp.l&&i<sp.m;i++) backward[sp.m-i-1]=target_probs[sp.m-i-1][i]; for(int i=sp.m-2;i>=0;i--){ for(int j=1;j<=sp.l&&i+j<sp.m;j++){ backward[i]+=target_probs[i][j-1]*backward[i+j]; } } //viterbi vector<pair<double,int> > viterbi(sp.m,pair<double,int>(0.0,0)); for(int i=0;i<sp.l&&i<sp.m;i++) viterbi[i]=pair<double,int>(target_probs[0][i],-1); for(int i=1;i<(int)forward.size();i++){ for(int j=1;j<=sp.l&&i-j>=0;j++){ if(viterbi[i-j].first*target_probs[i-j+1][j-1]>viterbi[i].first) viterbi[i]= make_pair(viterbi[i-j].first*target_probs[i-j+1][j-1],i-j); } } int pos=sp.m-1; string sequence=""; while(pos>=0){ sequence=to_string(pos)+" "+sequence; pos=viterbi[pos].second; } //cout<<"best seg:"<<sequence<<endl; //make sure forward[sp.m-1]==backward[0]; assert(backward[0]>0); if(abs(forward[sp.m-1]-backward[0])>=1e-5*backward[0]) cerr<<forward[sp.m-1]<<", "<<backward[0]<<endl; assert(abs(forward[sp.m-1]-backward[0])<1e-5*backward[0]); //cerr<<"backward[0]:"<<backward[0]<<endl; //collect fractional count for each phrase pair //fraccount=forward[j]*backward[j+jlen]*p(t|s)/backward[0]; for(int j=0;j<sp.m;j++){ for(int jlen=0;jlen<sp.l&&j+jlen+1<=sp.m;jlen++){ double segprob=0; double before=1; double after=1; if(j>0)before=forward[j-1]; if(j+jlen+1<sp.m)after=backward[j+jlen+1]; segprob=before*after*target_probs[j][jlen]/backward[0]; if(segprob>1||segprob<=0){ //cerr<<"segprob "<<segprob<<","<<j<<","<<jlen<<endl; } if(segprob<=0)continue; for(int i=0;i<sp.n;i++){ for(int ilen=0;ilen<sp.l&&ilen+i+1<=sp.n;ilen++){ if(sp(i,ilen,j,jlen)!=(void*)0){ double count=sp(i,ilen,j,jlen)->prob*segprob*alpha /target_probs[j][jlen]; sp(i,ilen,j,jlen)->count+=count; alphaCount+=count; if(count>1) cerr<<i<<","<<ilen<<","<<j <<","<<jlen<<" ["<<sp.m<<","<<sp.n<<"]" <<",count "<<count<<endl; } } } } } alpha*=sp.n*sp.l; } //cerr<<alphaCount<<","<<cache.size()<<endl; alpha=alphaCount/(alphaCount+cache.size()); }
void indexEngine::indexing(const std::string& corpus_pth) { ifstream ifOrigin_data; //file stream to load data from corpus ifOrigin_data.open(corpus_pth.c_str()); if(!ifOrigin_data.is_open()) //std::cerr << "Open corpus files failed!" << std::endl; LOG(ERROR) << "Open indexing corpus files error!"; std::string sLine = ""; std::string sData = ""; vector<string> splitDat; while(getline(ifOrigin_data,sLine)) { splitDat.clear(); //normalize Normalize::normalize(sLine); //get detail data from original corpus for(unsigned int i = 0; i < 3; ++i) { std::size_t pos = sLine.find('\t'); if(std::string::npos != pos) { sData = sLine.substr(0,pos); sLine.assign(sLine,pos+1,sLine.length()-1); splitDat.push_back(sData); } } splitDat.push_back(sLine); //check data if(4 != splitDat.size()) continue; QueryData qDat; qDat.text = splitDat[0]; //query text qDat.hits = atoi(splitDat[2].c_str()); //query times qDat.counts = atoi(splitDat[3].c_str());//results numbers //get term id StrToIntMap termsVector; tokenTerms(qDat.text,termsVector); std::size_t queryID = izenelib::util::izene_hashing(qDat.text); vector<std::size_t> queryIdVector; vector<std::size_t> termsIdVector; IdToQListIter termsQueryIter; queryIdVector.push_back(queryID); StrToIntMapIter termsIter; //assign hash id for every terms for(termsIter = termsVector.begin(); termsIter != termsVector.end(); ++termsIter) { termsIdVector.push_back(termsIter->second); //find terms in dictornary,termsID.v termsQueryIter = terms2qIDs_.find(termsIter->second); if(termsQueryIter != terms2qIDs_.end()) { termsQueryIter->second.push_back(queryID); } else { terms2qIDs_.insert(make_pair(termsIter->second,queryIdVector)); } } //complete data for one query qDat.tid = termsIdVector; boost::unordered_map<std::size_t,QueryData>::iterator queryIter; queryIdata_.insert(make_pair(queryID,qDat)); //flush to disk file /* ofQueryDat << queryID << "\t" <<qDat.text << "\t" << qDat.hits << "\t" << qDat.counts; for(unsigned int i = 0; i < qDat.tid.size(); ++i) { ofQueryDat << "\t" << qDat.tid[i]; //cout << "terms id :" << qDat.tid[i] << ","; } ofQueryDat << std::endl; //merge the searching times boost::unordered_map<std::size_t,QueryData>::iterator queryIter; queryIter = queryIdata_.find(queryID); if(queryIdata_.end() != queryIter && queryIter->second.text == qDat.text) { std::cout << "queryIter->seoncd.text:" << queryIter->second.text << "\t qDat.text:" << qDat.text << std::endl; std::cout << "queryID:" << queryID << "\tqueryIter->first:" << queryIter->first << std::endl; std::cout << "\t text:" << qDat.text << std::endl; queryIter->second.hits += qDat.hits; std::cout << "test--hits:" << queryIter->second.hits << "\t qdat.hits:" << qDat.hits << std::endl; } else queryIdata_.insert(make_pair(queryID,qDat)); queryIdata_.insert(make_pair(queryID,qDat));*/ } ifOrigin_data.close();//file stream close //ofQueryDat.close(); }
// TokenAnalyze的初始化工作 void TokenAnalyze::initialize() { /********** 初始化保留字字典 **********/ // 共有13个 reservedWord.insert(make_pair("const",CONSTTK)); reservedWord.insert(make_pair("int",INTTK)); reservedWord.insert(make_pair("char",CHARTK)); reservedWord.insert(make_pair("void",VOIDTK)); reservedWord.insert(make_pair("main",MAINTK)); reservedWord.insert(make_pair("if",IFTK)); reservedWord.insert(make_pair("else",ELSETK)); reservedWord.insert(make_pair("do",DOTK)); reservedWord.insert(make_pair("while",WHILETK)); reservedWord.insert(make_pair("for",FORTK)); reservedWord.insert(make_pair("scanf",SCANFTK)); reservedWord.insert(make_pair("printf",PRINTFTK)); reservedWord.insert(make_pair("return",RETURNTK)); /**********************************************/ /*********** 初始化符号 **************/ ssym.insert(make_pair("+",PLUS)); ssym.insert(make_pair("-",MINU)); ssym.insert(make_pair("*",MULT)); ssym.insert(make_pair("/",DIV)); ssym.insert(make_pair("<",LSS)); ssym.insert(make_pair("<=",LEQ)); ssym.insert(make_pair(">",GRE)); ssym.insert(make_pair(">=",GEQ)); ssym.insert(make_pair("==",EQL)); ssym.insert(make_pair("!=",NEQ)); ssym.insert(make_pair("=",ASSIGN)); ssym.insert(make_pair(";",SEMICN)); ssym.insert(make_pair(",",COMMA)); ssym.insert(make_pair("(",LPARENT)); ssym.insert(make_pair(")",RPARENT)); ssym.insert(make_pair("[",LBRACK)); ssym.insert(make_pair("]",RBRACK)); ssym.insert(make_pair("{",LBRACE)); ssym.insert(make_pair("}",RBRACE)); /***************************************/ /******************又要费一次事,这个就是结构没有设计好啊********************/ token_typename.insert(make_pair(IDEN,"IDEN")); token_typename.insert(make_pair(INTCON,"INTCON")); token_typename.insert(make_pair(CHARCON,"CHARCON")); token_typename.insert(make_pair(STRCON,"STRCON")); token_typename.insert(make_pair(CONSTTK,"CONSTTK")); token_typename.insert(make_pair(INTTK,"INTTK")); token_typename.insert(make_pair(CHARTK,"CHARTK")); token_typename.insert(make_pair(VOIDTK,"VOIDTK")); token_typename.insert(make_pair(MAINTK,"MAINTK")); token_typename.insert(make_pair(IFTK,"IFTK")); token_typename.insert(make_pair(ELSETK,"ELSETK")); token_typename.insert(make_pair(DOTK,"DOTK")); token_typename.insert(make_pair(WHILETK,"WHILETK")); token_typename.insert(make_pair(FORTK,"FORTK")); token_typename.insert(make_pair(SCANFTK,"SCANFTK")); token_typename.insert(make_pair(PRINTFTK,"PRINTFTK")); token_typename.insert(make_pair(RETURNTK,"RETURNTK")); token_typename.insert(make_pair(PLUS,"PLUS")); token_typename.insert(make_pair(MINU,"MINU")); token_typename.insert(make_pair(MULT,"MULT")); token_typename.insert(make_pair(DIV,"DIV")); token_typename.insert(make_pair(LSS,"LSS")); token_typename.insert(make_pair(LEQ,"LEQ")); token_typename.insert(make_pair(GRE,"GRE")); token_typename.insert(make_pair(GEQ,"GEQ")); token_typename.insert(make_pair(EQL,"EQL")); token_typename.insert(make_pair(NEQ,"NEQ")); token_typename.insert(make_pair(ASSIGN,"ASSIGN")); token_typename.insert(make_pair(SEMICN,"SEMICN")); token_typename.insert(make_pair(COMMA,"COMMA")); token_typename.insert(make_pair(LPARENT,"LPARENT")); token_typename.insert(make_pair(RPARENT,"RPARENT")); token_typename.insert(make_pair(LBRACK,"LBRACK")); token_typename.insert(make_pair(RBRACK,"RBRACK")); token_typename.insert(make_pair(LBRACE,"LBRACE")); token_typename.insert(make_pair(RBRACE,"RBRACE")); }
bool indexEngine::open() { if(0 == dict_pth_.length()) return false; std::string termId_pth = dict_pth_ + "/termId.v"; std::string queryDat_pth = dict_pth_ + "/queryDat.v"; ifstream finTermsId; ifstream finQueryDat; std::string sLine = ""; std::string s = ""; //open term id dictionary if exist , load data finTermsId.open(termId_pth.c_str()); if(finTermsId.is_open()) { vector<std::size_t> queryIdVector; vector<std::string> context; std::size_t termID; //std::size_t queryID; while(getline(finTermsId,sLine)) { queryIdVector.clear(); context.clear(); if(0 >= sLine.length()) continue; boost::split(context,sLine,boost::is_any_of("\t")); if(2 > context.size()) continue; termID = boost::lexical_cast<std::size_t>(context[0]); for(std::size_t it = 1; it < context.size()-1; ++it) { std::size_t id = boost::lexical_cast<std::size_t>(context[it]); queryIdVector.push_back(id); } terms2qIDs_.insert(make_pair(termID,queryIdVector)); } } // std::cout << "读入terms的大小:" << terms2qIDs_.size() << std::endl; finTermsId.close(); //open query data exist if exist , load data finQueryDat.open(queryDat_pth.c_str()); if(finQueryDat.is_open()) { QueryData qDat; std::size_t queryID; std::size_t tID; sLine = ""; s = ""; vector<std::size_t> termsIdVector; vector<std::string> context; while(getline(finQueryDat,sLine)) { termsIdVector.clear(); qDat.tid.clear(); context.clear(); if(0>= sLine.length()) continue; boost::split(context,sLine,boost::is_any_of("\t")); if( 5 > context.size()) continue; queryID = boost::lexical_cast<std::size_t>(context[0]); qDat.text = context[1]; qDat.hits = boost::lexical_cast<std::size_t>(context[2]); qDat.counts = boost::lexical_cast<std::size_t>(context[3]); for(vector<std::string>::iterator it = context.begin()+4; it != context.end(); ++it) { tID = boost::lexical_cast<std::size_t>(*it); termsIdVector.push_back(tID); } qDat.tid = termsIdVector; queryIdata_.insert(make_pair(queryID,qDat)); } } // std::cout << "读入query id 的大小:" << queryIdata_.size() << std::endl; finQueryDat.close(); //load forbid keywords list ifstream finForbid; std::string forbid_pth = dict_pth_ + "/forbidden.v"; finForbid.open(forbid_pth.c_str()); if(finForbid.is_open()) { sLine = ""; forbidList_.clear(); while(getline(finForbid,sLine)) { if(0 == sLine.size()) continue; forbidList_.insert(sLine); } } finForbid.close(); //load rskeywords form TaoBao ifstream finRskeywords; string rs_pth = dict_pth_ + "/HotRskeywords.v"; finRskeywords.open(rs_pth.c_str()); if(finRskeywords.is_open()) { vector<std::string> context; vector<std::string> rskeywords; sLine = ""; std::size_t hsId; while(getline(finRskeywords,sLine)) { rskeywords.clear(); if(0 >= sLine.length()) continue; boost::split(context,sLine,boost::is_any_of("\t")); if(2 > context.size()) continue; hsId = boost::lexical_cast<std::size_t>(context[0]); boost::unordered_map<std::size_t,vector<std::string> >::iterator rsIter; //std::cout << "key:" << context[0] << "\t hash:" << hsId << std::endl; rsIter = rsKeyTaoBao_.find(hsId); if(rsIter != rsKeyTaoBao_.end()) continue; for(std::size_t i = 1; i < context.size(); ++i) if(context[i].size() != 0) rskeywords.push_back(context[i]); rsKeyTaoBao_.insert(make_pair(hsId,rskeywords)); } } finRskeywords.close(); std::cout << "load rskeywords size:" << rsKeyTaoBao_.size() << std::endl; //load category dictonary ifstream finQuery2Cate; string cate_pth = dict_pth_ + "/query2Cate.v"; finQuery2Cate.open(cate_pth.c_str()); if(finQuery2Cate.is_open()) { vector<std::string> context; vector<std::string> cate; sLine = ""; std::size_t qID; while(getline(finQuery2Cate,sLine)) { cate.clear(); context.clear(); if(0 >= sLine.length()) continue; std::size_t pos = sLine.find('\t'); if(std::string::npos == pos) { continue; } else { string ss = sLine.substr(0,pos); sLine.assign(sLine,pos+1,sLine.length()-1); qID = boost::lexical_cast<std::size_t>(ss); if( std::string::npos != sLine.find(",")) { boost::split(context,sLine,boost::is_any_of(",")); // if(1 > context.size()) // continue; for(std::size_t id = 0; id < context.size(); ++id) cate.push_back(context[id]); } else cate.push_back(sLine); } query2Cate_.insert(make_pair(qID,cate)); } } finQuery2Cate.close(); std::cout << "读入的category size:" << query2Cate_.size() << std::endl; LOG(INFO) << "Load terms dictionary size:" << terms2qIDs_.size() << "\tLoad keywords size:" << queryIdata_.size() << "\tLoad category size:" << query2Cate_.size() << "\tLoad forbidden keywords size:" << forbidList_.size(); if(0 == terms2qIDs_.size() || 0 == queryIdata_.size()) { isNeedflush = true; return true; } else return false; // load dictionary successfully! }
/** * Module execution function. Saves interesting files recorded on the * blackboard to a user-specified output directory. * * @returns TskModule::OK on success if all files saved, TskModule::FAIL if one or more files were not saved */ TSK_MODULE_EXPORT TskModule::Status report() { TskModule::Status status = TskModule::OK; const std::string MSG_PREFIX = "SaveInterestingFilesModule::report : "; try { if (outputFolderPath.empty()) { // Initialization failed. The reason why was already logged in initialize(). return TskModule::FAIL; } // Get the interesting file set hits from the blackboard and sort them by set name. FileSets fileSets; FileSetHits fileSetHits; std::vector<TskBlackboardArtifact> fileSetHitArtifacts = TskServices::Instance().getBlackboard().getArtifacts(TSK_INTERESTING_FILE_HIT); for (std::vector<TskBlackboardArtifact>::iterator fileHit = fileSetHitArtifacts.begin(); fileHit != fileSetHitArtifacts.end(); ++fileHit) { // Find the set name attrbute of the artifact. bool setNameFound = false; std::vector<TskBlackboardAttribute> attrs = (*fileHit).getAttributes(); for (std::vector<TskBlackboardAttribute>::iterator attr = attrs.begin(); attr != attrs.end(); ++attr) { if ((*attr).getAttributeTypeID() == TSK_SET_NAME) { setNameFound = true; // Save the set name and description, using a map to ensure that these values are saved once per file set. fileSets.insert(make_pair((*attr).getValueString(), (*attr).getContext())); // Drop the artifact into a multimap to allow for retrieval of all of the file hits for a file set as an // iterator range. fileSetHits.insert(make_pair((*attr).getValueString(), (*fileHit))); } } if (!setNameFound) { // Log the error and try the next artifact. std::stringstream msg; msg << MSG_PREFIX << "failed to find TSK_SET_NAME attribute for TSK_INTERESTING_FILE_HIT artifact with id '" << (*fileHit).getArtifactID() << "', skipping artifact"; LOGERROR(msg.str()); } } // Save the interesting files to the output directory, file set by file set. for (map<std::string, std::string>::const_iterator fileSet = fileSets.begin(); fileSet != fileSets.end(); ++fileSet) { // Get the file hits for the file set as an iterator range. FileSetHitsRange fileSetHitsRange = fileSetHits.equal_range((*fileSet).first); // Save the files corresponding to the file hit artifacts. saveFiles((*fileSet).first, (*fileSet).second, fileSetHitsRange); } } catch (TskException &ex) { status = TskModule::FAIL; std::stringstream msg; msg << MSG_PREFIX << "TskException: " << ex.message(); LOGERROR(msg.str()); } catch (Poco::Exception &ex) { status = TskModule::FAIL; std::stringstream msg; msg << MSG_PREFIX << "Poco::Exception: " << ex.displayText(); LOGERROR(msg.str()); } catch (std::exception &ex) { status = TskModule::FAIL; std::stringstream msg; msg << MSG_PREFIX << "std::exception: " << ex.what(); LOGERROR(msg.str()); } catch (...) { status = TskModule::FAIL; LOGERROR(MSG_PREFIX + "unrecognized exception"); } return status; }
Table* read_from_rating_final() { ifstream myfile ("rating_final.csv"); if (myfile.is_open()) { Table::ColumnList columns; String placeID; getline( myfile, placeID, ',' ); columns.push_back(make_pair(placeID, Table::varchar)); String latitude; getline( myfile, latitude, ',' ); columns.push_back(make_pair(latitude, Table::integer)); String longitude; getline( myfile, longitude, ',' ); columns.push_back(make_pair(longitude, Table::integer)); String the_geom_meter; getline( myfile, the_geom_meter, ',' ); columns.push_back(make_pair(the_geom_meter, Table::integer)); String name; getline( myfile, name, '\n' ); columns.push_back(make_pair(name, Table::integer)); Table* geo = new Table(columns); // Create geo using the defined columns while ( myfile.good() ) { vector<pair<string, string> > entries; // Entries for the record to be placed in the table string placeID; getline( myfile, placeID, ',' ); pair <string,string> pair0 ("userID",placeID); // value init entries.push_back(pair0); string latitude; getline( myfile, latitude, ',' ); pair <string,string> pair1 ("placeID",latitude); // value init entries.push_back(pair1); string longitude; getline( myfile, longitude, ',' ); pair <string,string> pair2 ("rating",longitude); // value init entries.push_back(pair2); string the_geom_meter; getline( myfile, the_geom_meter, ',' ); pair <string,string> pair3 ("food_rating",the_geom_meter); // value init entries.push_back(pair3); string name; getline( myfile, name, '\n' ); pair <string,string> pair4 ("service_rating",name); // value init entries.push_back(pair4); Record add(entries); // Create record to add to table geo->insert(add); // Insert add record into geo } myfile.close(); return geo; } }
/* create parsing tree * */ void Parser:: createParsingTree(vector<Token*> tokens){ stack<string> stateStack; stack<Token*> inputStack; stateStack.push("S"); int treeIndex = 0; string treeValue; int order = 0; int find_return; // push input to a stack inputStack.push( new Token("$", "SP", 0) ); for(vector<Token*>::reverse_iterator itr = tokens.rbegin(); itr != tokens.rend(); ++itr ){ inputStack.push( (*itr) ); } // loop while state stack not empty while( !stateStack.empty() ){ // preprocessing if( stateStack.top().compare("@") == 0 ){ --treeIndex; stateStack.pop(); continue; } // skip epsilon if( stateStack.top().compare("epsilon") == 0){ stateStack.pop(); continue; } treeValue = stateStack.top(); // terminal insert to tree if( isTerminal( stateStack.top() ) ){ parsingTree.insert( make_pair( order++ ,Node(treeIndex, treeValue, inputStack.top() -> getSymbol(), inputStack.top() -> getCatergory() ) ) ); } // non_terminal insert to tree else{ parsingTree.insert( make_pair( order++ ,Node(treeIndex, treeValue, inputStack.top() -> getSymbol(), " " ) ) ); } // stack Pop and Push if( isTerminal(stateStack.top())){ stateStack.pop(); inputStack.pop(); } // not found in parsin table else if( (find_return = findTable(stateStack.top(), (*inputStack.top()) ) ) == -1 ){ cout << "Line: " << inputStack.top() -> getLineNumber() << " Parsing Error!" << endl; exit(1); } else{ // reduce map<string, vector<list<string> > > :: iterator itr = grammar.find( stateStack.top() ); stateStack.pop(); treeIndex += 1; // for corret tree index stateStack.push("@"); for(list<string>:: reverse_iterator itr2 = itr->second[find_return].rbegin(); \ itr2 != itr->second[find_return].rend(); ++itr2 ){ stateStack.push( (*itr2) ); } } } outputParingTree(); }
void read_vs_reference(string& read, string& read_name, int dir, vector<reference_index>& refindex, vector<pair<int, vector<pair<int, int> > > >& primary_chain) { time_t start, end; vector<pair<long, int> > kmer_list; //unordered_map<long, int> kmer_list; //unordered_map<long, int> kmer_map; //vector<pair<int, vector<pair<int, int> > > > primary_chain; //cout << "\t readseq: " << read_name << " with length = " << read.length() // << " comparing to " << refindex.size() << " references" << endl; time(&start); bool flag = true; long hash_key = 0; int map_val; int readlen = read.length(); long prehashval = -1; int prehashcnt = 0; for(int k = 0; k < read.length(); k++) { if(flag == true) { if(k + KMER > read.length()) break; for(int l = k, end = k, i = KMER - 2; l < end + KMER - 1; l++, k++, i--) { map_val = map_value(read.at(l)); if(map_val == -1) break; hash_key += base_power_kmer[i][map_val]; //cout << "For character " << read.at(k) << ", at position = " << k << // ", the hash_key = " << hash_key << endl; } } map_val = map_value(read.at(k)); if(map_val == -1) { //cout << "Encountered invalid character N ########################" << endl; flag = true; hash_key = 0; continue; } else flag = false; hash_key = hash_key * BASE + map_val; /* if(kmer_map.find(hash_key) == kmer_map.end()) { kmer_map[hash_key] = 1;//k - KMER + 1; kmer_list.push_back(make_pair(hash_key, k - KMER + 1)); } else { kmer_map[hash_key] += 1;//-1;//need work here if(kmer_list[kmer_list.size() - 1].first != hash_key) kmer_list.push_back(make_pair(hash_key, k - KMER + 1)); else kmer_list[kmer_list.size() - 1].second = k - KMER + 1; } //cout << "For character " << read.at(k) << ", at position = " << k << // ", the hash_key = " << hash_key << endl; */ if(prehashval != hash_key) { kmer_list.push_back(make_pair(hash_key, k - KMER + 1)); prehashval = hash_key; prehashcnt = 1; } else { if(prehashcnt > 2)//suppress same character repeat kmer_list[kmer_list.size() - 1].second = k - KMER + 1; else kmer_list.push_back(make_pair(hash_key, k - KMER + 1)); prehashcnt += 1; } map_val = map_value(read.at(k - KMER + 1)); hash_key -= base_power_kmer[KMER - 1][map_val]; } { cout << "Starting KMER Chain Analysis for " << dir << endl; vector<vector<pair<int, int> > > kmer_index; for(int i = 0; i < refindex.size(); i++) { vector<pair<int, int> > kmer_pair; kmer_index.push_back(kmer_pair); } int interval = 1, index, reflen; int kmer_ref_loc, kmer_read_loc; for(int k = 0; k < kmer_list.size(); k++) { if(basic_index.index[kmer_list[k].first] == -1) continue; //vector<int> pos = basic_index.position[basic_index.index[kmer_list[k].first]]; int ref_location; //for(int i = 0; i < pos.size(); i++) for(vector<int>::iterator it = basic_index.position[basic_index.index[kmer_list[k].first]].begin(); it != basic_index.position[basic_index.index[kmer_list[k].first]].end(); ++it) { ref_location = *it; if(ref_location < 0)//if(pos[i] < 0) { index = abs(ref_location) - 1;//abs(pos[i]) - 1; reflen = refindex[index].ref.length(); continue; } kmer_ref_loc = ref_location;// pos[i]; kmer_read_loc = kmer_list[k].second; if(CIRCULAR == 0 || kmer_ref_loc - kmer_read_loc / 1.3 >= 0 && kmer_ref_loc + (readlen - kmer_read_loc) / 1.3 < reflen) { //cout << "index = " << index << endl; //assert(index >= 0 && index < refindex.size()); kmer_index[index].push_back(make_pair(kmer_ref_loc, kmer_read_loc)); } } } for(int index = 0; index < refindex.size(); index++) { if(kmer_index[index].size() == 0) continue; sort(kmer_index[index].begin(), kmer_index[index].end(), compare_function); /*for(int i = 0; i < kmer_index[index].size(); i++) { cout << "first = " << kmer_index[index][i].first << ", and second = " << kmer_index[index][i].second << endl; }*/ refine_kmer_index(kmer_index[index], primary_chain, read, dir, refindex, index); kmer_index[index].clear(); } } if(SINGLE == 1) { kmer_list.clear(); return; } { cout << "Starting Reverse Analysis for " << FR << endl; vector<vector<pair<int, int> > > kmer_index; kmer_index.clear(); for(int i = 0; i < refindex.size(); i++) { vector<pair<int, int> > kmer_pair; kmer_index.push_back(kmer_pair); } int interval = 1, index, reflen; int kmer_ref_loc, kmer_read_loc; for(int k = 0; k < kmer_list.size(); k++) { if(basic_index.revind[kmer_list[k].first] == -1) continue; //vector<int> pos = basic_index.position[basic_index.revind[kmer_list[k].first]]; int ref_location; //for(int i = 0; i < pos.size(); i++) for(vector<int>::iterator it = basic_index.position[basic_index.revind[kmer_list[k].first]].begin(); it != basic_index.position[basic_index.revind[kmer_list[k].first]].end(); ++it) { ref_location = *it; if(ref_location < 0)//if(pos[i] < 0) { index = abs(ref_location) - 1;//index = abs(pos[i]) - 1; reflen = refindex[index].rev.length(); continue; } kmer_ref_loc = reflen - KMER - ref_location; //kmer_ref_loc = reflen - KMER - pos[i]; kmer_read_loc = readlen - KMER - kmer_list[k].second; if(CIRCULAR == 0 || kmer_ref_loc - kmer_read_loc / 1.3 >= 0 && kmer_ref_loc + (readlen - kmer_read_loc) / 1.3 < reflen) { //cout << "index = " << index << endl; //assert(index >= 0 && index < refindex.size()); kmer_index[index].push_back(make_pair(kmer_ref_loc, kmer_read_loc)); } } } for(int index = 0; index < refindex.size(); index++) { if(kmer_index[index].size() == 0) continue; sort(kmer_index[index].begin(), kmer_index[index].end(), compare_function); /*for(int i = 0; i < kmer_index[index].size(); i++) { cout << "first = " << kmer_index[index][i].first << ", and second = " << kmer_index[index][i].second << endl; }*/ refine_kmer_index(kmer_index[index], primary_chain, read, FR, refindex, index); kmer_index[index].clear(); } } time(&end); //cout << "Total time taken inside read_vs_reference = " << difftime(end, start) << endl; //cout << "size of the candidate idices = " << primary_chain.size() << endl << endl; //kmer_map.clear(); kmer_list.clear(); return; }