JDMainWin::JDMainWin(const QString &name, const QString &jid, int acc, QWidget *p) : QDialog(p, Qt::Window) , model_(0) , commands_(0) , refreshInProgres_(false) , yourJid_(name) { setAttribute(Qt::WA_DeleteOnClose); ui_.setupUi(this); setWindowTitle(tr("Jabber Disk - %1").arg(name)); model_ = new JDModel(jid, this); ui_.lv_disk->setModel(model_); commands_ = new JDCommands(acc, jid, this); ui_.pb_send->setShortcut(QKeySequence("Ctrl+Return")); connect(commands_, SIGNAL(incomingMessage(QString,JDCommands::Command)), SLOT(incomingMessage(QString,JDCommands::Command))); connect(commands_, SIGNAL(outgoingMessage(QString)), SLOT(outgoingMessage(QString))); connect(ui_.pb_refresh, SIGNAL(clicked()), SLOT(refresh())); connect(ui_.pb_send, SIGNAL(clicked()), SLOT(doSend())); connect(ui_.pb_clear, SIGNAL(clicked()), SLOT(clearLog())); connect(ui_.lv_disk, SIGNAL(newIndex(QModelIndex)), SLOT(indexChanged(QModelIndex))); connect(ui_.lv_disk, SIGNAL(contextMenu(QModelIndex)), SLOT(indexContextMenu(QModelIndex))); connect(model_, SIGNAL(moveItem(QString,QString)), SLOT(moveItem(QString,QString))); show(); QTimer::singleShot(0, this, SLOT(refresh())); }
int_array Utils::Sort(int_array &array_Renamed) { int_array index = initialIndex((int)array_Renamed.size()); int_array newIndex(array_Renamed.size()); int_array helpIndex; int numEqual; quickSort(array_Renamed, index, 0, (int)array_Renamed.size() - 1); // Make sort stable int i = 0; while (i < index.size()) { numEqual = 1; for (int j = i + 1; ((j < index.size()) && (array_Renamed[index[i]] == array_Renamed[index[j]])); j++) { numEqual++; } if (numEqual > 1) { helpIndex = int_array(numEqual); for (int j = 0; j < numEqual; j++) { helpIndex[j] = i + j; } quickSort(index, helpIndex, 0, numEqual - 1); for (int j = 0; j < numEqual; j++) { newIndex[i + j] = index[helpIndex[j]]; } i += numEqual; } else { newIndex[i] = index[i]; i++; } } return newIndex; }
void API_Create_Table(string tablename,FieldTree *T) { // try{ //catalog meta data Table tbl(tablename); tbl.initializeTable(T); tbl.createTable(); string primaryIdxName=tablename+"PRIMARY_INDEX"; Index newIndex(primaryIdxName); IndexStruct Idx; Idx.attr_name = tbl.getPrimaryKey(); Idx.index_name = primaryIdxName; Idx.table_name = tablename; newIndex.initializeIndex(&Idx); newIndex.createIndex(); //End of catalog do //IndexManager do IndexInfo idxInfo; idxInfo.indexname = Idx.table_name + "PRIMARY_INDEX"; idxInfo.attr_size=tbl.getPrimaryKeySize(); idxInfo.maxKeyNum=(BLOCKSIZE-INDEX_BLOCK_INFO-4)/(4+idxInfo.attr_size); Create_Index_Init(idxInfo); //End of IndexManager do /* } catch(...){ cout<<"Failed to Create Table."<<endl; }*/ }
int CatalogManager::creatTable(string tableName, int attrNum, string *attrName, int* attrType){ int id = bufferManager->newPage(); page* thisPage = bufferManager->findPage(id); string content = ""; char temp[64]; sprintf(temp,"%d",id); string pageID(temp); content= "[{\"TableName\": \"" + tableName+"\",\"pageID\": \"" + pageID+"\"}]"; jsonReader.parse(content,jsonContent); for (int i = 0; i < attrNum; i++){ char* newNumber; sprintf(newNumber,"%d",attrType[i]); char* index; sprintf(index,"%d",i); if ((attrType[i]>=10)&&(attrType[i]<20)){ sprintf(temp,"%d",i); string pkPosition(temp); jsonContent.append("{\"AttrName\": \"" + attrName[i]+"\",\"AttrType\": \"" + newNumber+"\",\"PrimaryKey\": \"" + pkPosition+"\",\"index\": \"" + string(index)+"\"}"); newIndex(tableName, attrName[i], attrName[i]); }else jsonContent.append("{\"AttrName\": \"" + attrName[i]+"\",\"AttrType\": \"" + newNumber+"\",\"index\": \"" + string(index)+"\"}"); } save(id); return id; }
void ImageStackDirectoryDatasource::convertToOneDimension() { auto oldProjectionProperties = metaDataNodes; metaDataNodes.clear(); auto oldImageLocations = imageLocations; imageLocations.clear(); for ( auto it = oldProjectionProperties.begin(); it != oldProjectionProperties.end(); ++it ) { HyperStackIndex oldIndex = it->first; HyperStackIndex newIndex(oldIndex[0]); metaDataNodes[newIndex] = oldProjectionProperties[oldIndex]; imageLocations[newIndex] = oldImageLocations[oldIndex]; } }
int_array Utils::stableSort(double_array &array_Renamed) { int_array index = initialIndex((int)array_Renamed.size()); if (array_Renamed.size() > 1) { int_array newIndex(array_Renamed.size()); int_array helpIndex; int numEqual; //array_Renamed = array_Renamed.clone(); replaceMissingWithMAX_VALUE(array_Renamed); quickSort(array_Renamed, index, 0, (int)array_Renamed.size() - 1); // Make sort stable int i = 0; while (i < index.size()) { numEqual = 1; for (int j = i + 1; ((j < index.size()) && Utils::eq(array_Renamed[index[i]], array_Renamed[index[j]])); j++) { numEqual++; } if (numEqual > 1) { helpIndex = int_array(numEqual); for (int j = 0; j < numEqual; j++) { helpIndex[j] = i + j; } quickSort(index, helpIndex, 0, numEqual - 1); for (int j = 0; j < numEqual; j++) { newIndex[i + j] = index[helpIndex[j]]; } i += numEqual; } else { newIndex[i] = index[i]; i++; } } return newIndex; } else { return index; } }
static void AddDependency( CVertInfo *dependencies, int sideLength, CVertIndex const &nodeIndex, CVertIndex const &dependency, int iMaxPower, bool bCheckNeighborDependency, bool bAddReverseDependency ) { int iNodeIndex = VertIndex( nodeIndex, iMaxPower ); CVertInfo *pNode = &dependencies[iNodeIndex]; int iDep = GetFreeDependency( pNode->m_Dependencies, sizeof(pNode->m_Dependencies)/sizeof(pNode->m_Dependencies[0]) ); pNode->m_Dependencies[iDep].m_iVert = dependency; pNode->m_Dependencies[iDep].m_iNeighbor = -1; if( bAddReverseDependency ) { CVertInfo *pDep = &dependencies[VertIndex( dependency, iMaxPower )]; iDep = GetFreeDependency( pDep->m_ReverseDependencies, CVertInfo::NUM_REVERSE_DEPENDENCIES ); pDep->m_ReverseDependencies[iDep].m_iVert = nodeIndex; pDep->m_ReverseDependencies[iDep].m_iNeighbor = -1; } // Edge verts automatically add a dependency for the neighbor. // Internal verts wind up in here twice anyway so it doesn't need to if( bCheckNeighborDependency ) { int iConnection = GetEdgeIndexFromPoint( nodeIndex, iMaxPower ); if( iConnection != -1 ) { Assert( !pNode->m_Dependencies[1].IsValid() ); CVertIndex delta( nodeIndex.x - dependency.x, nodeIndex.y - dependency.y ); CVertIndex newIndex( nodeIndex.x + delta.x, nodeIndex.y + delta.y ); int fullSideLength = (1 << iMaxPower) + 1; pNode->m_Dependencies[1].m_iVert = WrapVertIndex( CVertIndex( newIndex.x, newIndex.y ), fullSideLength ); pNode->m_Dependencies[1].m_iNeighbor = iConnection; } } }
static MLogHeader *newMLogHeader(int s) { MLogHeader *ah; int l; if (lindex==NULL) newIndex(); if (freeHdrs) { ah=freeHdrs; freeHdrs=ah->area[0]; ah->cur=0; if (debug) printf("--- newMLogHeader() reuse: %p\n",ah); } else { l=sizeof(MLogHeader)+((s-1)*sizeof(void*)); ah=(MLogHeader*)malloc(l); memset(ah,0,l); ah->max=s; if (debug) if (debug) printf("--- newMLogHeader() new: %p\n",ah); } ah->cur=0; return ah; }
// Base code for adding, removing, moving and duplicating instruments. Returns new number of instruments on success, INSTRUMENTINDEX_INVALID otherwise. // The new instrument vector can contain INSTRUMENTINDEX_INVALID for adding new (empty) instruments. // newOrder indices are zero-based, i.e. newOrder[0] will define the contents of the first instrument slot. INSTRUMENTINDEX CModDoc::ReArrangeInstruments(const std::vector<INSTRUMENTINDEX> &newOrder, deleteInstrumentSamples removeSamples) //-------------------------------------------------------------------------------------------------------------------------------- { if(newOrder.size() > m_SndFile.GetModSpecifications().instrumentsMax || GetNumInstruments() == 0) { return INSTRUMENTINDEX_INVALID; } CriticalSection cs; const INSTRUMENTINDEX oldNumInstruments = m_SndFile.GetNumInstruments(), newNumInstruments = static_cast<INSTRUMENTINDEX>(newOrder.size()); std::vector<ModInstrument> instrumentHeaders(oldNumInstruments + 1); std::vector<INSTRUMENTINDEX> newIndex(oldNumInstruments + 1, 0); // One of the new indexes for the old instrument for(INSTRUMENTINDEX i = 0; i < newNumInstruments; i++) { const INSTRUMENTINDEX origSlot = newOrder[i]; if(origSlot > 0 && origSlot <= oldNumInstruments) { if(m_SndFile.Instruments[origSlot] != nullptr) instrumentHeaders[origSlot] = *m_SndFile.Instruments[origSlot]; newIndex[origSlot] = i + 1; } } // Delete unused instruments first. for(INSTRUMENTINDEX i = 1; i <= oldNumInstruments; i++) { if(newIndex[i] == 0) { m_SndFile.DestroyInstrument(i, removeSamples); } } m_SndFile.m_nInstruments = newNumInstruments; // Now, create new instrument list. for(INSTRUMENTINDEX i = 0; i < newNumInstruments; i++) { ModInstrument *ins = m_SndFile.AllocateInstrument(i + 1); if(ins == nullptr) { continue; } const INSTRUMENTINDEX origSlot = newOrder[i]; if(origSlot > 0 && origSlot <= oldNumInstruments) { // Copy an original instrument. *ins = instrumentHeaders[origSlot]; } } // Free unused instruments for(INSTRUMENTINDEX i = newNumInstruments + 1; i <= oldNumInstruments; i++) { m_SndFile.DestroyInstrument(i, doNoDeleteAssociatedSamples); } PrepareUndoForAllPatterns(false, "Rearrange Instrumens"); GetInstrumentUndo().RearrangeInstruments(newIndex); std::vector<ModCommand::INSTR> indices(newIndex.size(), 0); for(size_t i = 0; i < newIndex.size(); i++) { indices[i] = newIndex[i]; } m_SndFile.Patterns.ForEachModCommand(RewriteInstrumentReferencesInPatterns(indices)); return GetNumInstruments(); }
// Base code for adding, removing, moving and duplicating samples. Returns new number of samples on success, SAMPLEINDEX_INVALID otherwise. // The new sample vector can contain SAMPLEINDEX_INVALID for adding new (empty) samples. // newOrder indices are zero-based, i.e. newOrder[0] will define the contents of the first sample slot. SAMPLEINDEX CModDoc::ReArrangeSamples(const std::vector<SAMPLEINDEX> &newOrder) //----------------------------------------------------------------------------- { if(newOrder.size() > m_SndFile.GetModSpecifications().samplesMax) { return SAMPLEINDEX_INVALID; } CriticalSection cs; const SAMPLEINDEX oldNumSamples = m_SndFile.GetNumSamples(), newNumSamples = static_cast<SAMPLEINDEX>(newOrder.size()); std::vector<int> sampleCount(oldNumSamples + 1, 0); std::vector<ModSample> sampleHeaders(oldNumSamples + 1); std::vector<SAMPLEINDEX> newIndex(oldNumSamples + 1, 0); // One of the new indexes for the old sample std::vector<std::string> sampleNames(oldNumSamples + 1); std::vector<mpt::PathString> samplePaths(oldNumSamples + 1); for(SAMPLEINDEX i = 0; i < newNumSamples; i++) { const SAMPLEINDEX origSlot = newOrder[i]; if(origSlot > 0 && origSlot <= oldNumSamples) { sampleCount[origSlot]++; sampleHeaders[origSlot] = m_SndFile.GetSample(origSlot); if(!newIndex[origSlot]) newIndex[origSlot] = i + 1; } } // First, delete all samples that will be removed anyway. for(SAMPLEINDEX i = 1; i < sampleCount.size(); i++) { if(sampleCount[i] == 0) { m_SndFile.DestroySample(i); GetSampleUndo().ClearUndo(i); } sampleNames[i] = m_SndFile.m_szNames[i]; samplePaths[i] = m_SndFile.GetSamplePath(i); } // Remove sample data references from now unused slots. for(SAMPLEINDEX i = newNumSamples + 1; i <= oldNumSamples; i++) { m_SndFile.GetSample(i).pSample = nullptr; m_SndFile.GetSample(i).nLength = 0; strcpy(m_SndFile.m_szNames[i], ""); } // Now, create new sample list. m_SndFile.m_nSamples = std::max(m_SndFile.m_nSamples, newNumSamples); // Avoid assertions when using GetSample()... for(SAMPLEINDEX i = 0; i < newNumSamples; i++) { const SAMPLEINDEX origSlot = newOrder[i]; ModSample &target = m_SndFile.GetSample(i + 1); if(origSlot > 0 && origSlot <= oldNumSamples) { // Copy an original sample. target = sampleHeaders[origSlot]; if(--sampleCount[origSlot] > 0 && sampleHeaders[origSlot].pSample != nullptr) { // This sample slot is referenced multiple times, so we have to copy the actual sample. target.pSample = ModSample::AllocateSample(target.nLength, target.GetBytesPerSample()); if(target.pSample != nullptr) { memcpy(target.pSample, sampleHeaders[origSlot].pSample, target.GetSampleSizeInBytes()); target.PrecomputeLoops(m_SndFile, false); } else { Reporting::Error("Cannot duplicate sample - out of memory!"); } } strcpy(m_SndFile.m_szNames[i + 1], sampleNames[origSlot].c_str()); m_SndFile.SetSamplePath(i + 1, samplePaths[origSlot]); } else { // Invalid sample reference. target.Initialize(m_SndFile.GetType()); target.pSample = nullptr; strcpy(m_SndFile.m_szNames[i + 1], ""); m_SndFile.ResetSamplePath(i + 1); } } GetSampleUndo().RearrangeSamples(newIndex); for(CHANNELINDEX c = 0; c < CountOf(m_SndFile.m_PlayState.Chn); c++) { ModChannel &chn = m_SndFile.m_PlayState.Chn[c]; for(SAMPLEINDEX i = 1; i <= oldNumSamples; i++) { if(chn.pModSample == &m_SndFile.GetSample(i)) { chn.pModSample = &m_SndFile.GetSample(newIndex[i]); if(i == 0 || i > newNumSamples) { chn.Reset(ModChannel::resetTotal, m_SndFile, c); } break; } } } m_SndFile.m_nSamples = newNumSamples; if(m_SndFile.GetNumInstruments()) { // Instrument mode: Update sample maps. for(INSTRUMENTINDEX i = 0; i <= m_SndFile.GetNumInstruments(); i++) { ModInstrument *ins = m_SndFile.Instruments[i]; if(ins == nullptr) { continue; } GetInstrumentUndo().RearrangeSamples(i, newIndex); for(auto &sample : ins->Keyboard) { if(sample < newIndex.size()) sample = newIndex[sample]; else sample = 0; } } } else { PrepareUndoForAllPatterns(false, "Rearrange Samples"); std::vector<ModCommand::INSTR> indices(newIndex.size(), 0); for(size_t i = 0; i < newIndex.size(); i++) { indices[i] = newIndex[i]; } m_SndFile.Patterns.ForEachModCommand(RewriteInstrumentReferencesInPatterns(indices)); } return GetNumSamples(); }
void Foam::multiSolver::buildDictionary ( dictionary& outputDict, const dictionary& inputDict, const word& solverDomainName ) { outputDict.remove("sameAs"); outputDict.remove("multiLoad"); wordList alreadyMerged(0); wordList mergeMe(0); if (inputDict.found("default")) { if (outputDict.found("multiLoad")) { mergeMe = wordList(outputDict.lookup("multiLoad")); outputDict.remove("multiLoad"); } if (outputDict.found("sameAs")) { label newIndex(mergeMe.size()); mergeMe.setSize(newIndex + 1); mergeMe[newIndex] = word(outputDict.lookup("sameAs")); outputDict.remove("sameAs"); } } // We load solverDomain last, but we need its sameAs / multiLoad now if (inputDict.found(solverDomainName)) { const dictionary& solverDict(inputDict.subDict(solverDomainName)); if (solverDict.found("multiLoad")) { mergeMe.append(wordList(solverDict.lookup("multiLoad"))); } if (solverDict.found("sameAs")) { label newIndex(mergeMe.size()); mergeMe.setSize(newIndex + 1); mergeMe[newIndex] = word(solverDict.lookup("sameAs")); } } label mergeI(-1); while ((mergeI + 1) < mergeMe.size()) { mergeI++; bool skipMe(false); forAll(alreadyMerged, alreadyI) { if (mergeMe[mergeI] == alreadyMerged[alreadyI]) { skipMe = true; break; } } if (skipMe) { break; } outputDict.merge(inputDict.subDict(mergeMe[mergeI])); // Add to alreadyMerged label mergedIndex(alreadyMerged.size()); alreadyMerged.setSize(mergedIndex + 1); alreadyMerged[mergedIndex] = mergeMe[mergeI]; // Recursive search if (outputDict.found("multiLoad")) { mergeMe.append(wordList(outputDict.lookup("multiLoad"))); outputDict.remove("multiLoad"); } if (outputDict.found("sameAs")) { label newMergeMeIndex(mergeMe.size()); mergeMe.setSize(newMergeMeIndex + 1); mergeMe[newMergeMeIndex] = word(outputDict.lookup("sameAs")); outputDict.remove("sameAs"); } } // Merge the solverDomain name, even if it already has merged if (inputDict.found(solverDomainName)) { outputDict.merge(inputDict.subDict(solverDomainName)); // These have been handled already outputDict.remove("sameAs"); outputDict.remove("multiLoad"); } }
/** * Seta o valor de uma célula da matriz. Se já existir apenas altera o valor. */ void setCell(SparseMatrix* matrix, long x, long y, long value) { Cell* cell = getCell(matrix, x, y); // Se existir, a célula troca o valor if (cell != NULL) { cell->_value = value; return; } // Verifica os índices máximos da matriz, e os troca se preciso if (x > matrix->_maximumX) { matrix->_maximumX = x; } if (y > matrix->_maximumY) { matrix->_maximumY = y; } // Cria uma nova célula cell = newCell(x, y, value); // Verifica se o índice (linha) atual existe Index* index = matrix->_firstIndex; Index* cellIndex = NULL; while (index != NULL) { // Se a linha for igual, existe if (index->_value == y) { cellIndex = index; break; } index = index->_nextIndex; } // Se o índice não existir, cria um novo if (cellIndex == NULL) { cellIndex = newIndex(y); } // Adiciona o índice a matriz // Se o primeiro for vazio, tá certo if (matrix->_firstIndex == NULL) { matrix->_firstIndex = cellIndex; } // Senão insere o novo índice na ordem else { Index* currentIndex = matrix->_firstIndex; Index* previousIndex = matrix->_firstIndex; while (true) { // Se for maior, vai para frente, senão insere if (currentIndex == NULL || cellIndex->_value < currentIndex->_value) { previousIndex->_nextIndex = cellIndex; cellIndex->_nextIndex = currentIndex; break; } else { previousIndex = currentIndex; currentIndex = currentIndex->_nextIndex; } } } // Insere a célula if (cellIndex->_cell == NULL) { cellIndex->_cell = cell; } else { Cell* currentCell = cellIndex->_cell; Cell* previousCell = currentCell; while (true) { // Se o índice x for maior, vai para frente, senão insere if (currentCell == NULL || cell->_x < currentCell->_x) { previousCell->_nextCell = cell; cell->_nextCell = currentCell; break; } else { previousCell = currentCell; currentCell = currentCell->_nextCell; } } } }
bool ChainedIndex::insertRecord(const FRec& rec) { bool inserted = true; filereader file; file.open(fileName, 'x'); long firstIndexOffset = hash(rec.num) * sizeof(ChNode); ChNode firstIndexRecord; file.seek(firstIndexOffset, BEGIN); file.read_raw((char *) &firstIndexRecord, sizeof(ChNode)); // if it is first record of the chain if (firstIndexRecord.key != INVALID_KEY) { long curIndexOffset = firstIndexOffset; ChNode curIndexRecord = firstIndexRecord; do { file.seek(curIndexOffset, BEGIN); file.read_raw((char *) &curIndexRecord, sizeof(ChNode)); if (curIndexRecord.key == rec.num) { inserted = false; file.close(); return inserted; } curIndexOffset = curIndexRecord.nextOffset; } while (curIndexOffset != INVALID_OFFSET); // we dont have duplicate // write the database record int newRecOffset = dbFile.insert(rec); int prevIndexOffset = file.offset() - sizeof(ChNode); // write new index record file.seek(0, END); int newIndexOffset = file.offset(); ChNode newIndex(rec.num, newRecOffset); file.write_raw((char*) &newIndex, sizeof(ChNode)); // write the cur index record curIndexRecord.nextOffset = newIndexOffset; file.seek(prevIndexOffset, BEGIN); file.write_raw((char*) &curIndexRecord, sizeof(ChNode)); } else { // its the first record of the chain int newRecOffset = dbFile.insert(rec); // write the database record // write the prev index record firstIndexRecord.key = rec.num; firstIndexRecord.recOffset = newRecOffset; file.seek(firstIndexOffset, BEGIN); file.write_raw((char*) &firstIndexRecord, sizeof(ChNode)); } file.close(); return inserted; }
//[[Rcpp::export]] Rcpp::List tree_compressor(std::vector< std::vector<unsigned int> > children, bool onebased = true) { // Returns information to compress tree // // Args: // children: a list of integer vectors of children pointers // onebased: bool indicating if the children is given by one-base or zero-base // default is true // // Returns: // List containing // indices : a list of integer vectors that specifies the index of new data // parent : an integer vector of new parent // children: a list of integer vectors of new children std::vector< std::vector<int> > newIndices; std::vector<int> newParent; std::vector< std::vector<int> > newChildren; std::vector<int> newLeaf; // convert to zeo-based indices if (onebased) { for (unsigned int i = 0; i < children.size(); i++) for (unsigned int j = 0; j < children[i].size(); j++) children[i][j]--; } bool check = ValidateChildren(children); if (!check) Rcpp::stop("Invalid 'children' input"); // make a list that maps current id to new id // note the difference from the newIndices, which // map the new id to current id // assume the first entry is the top node std::vector<int> newIndex(children.size()); newIndex[0] = 0; int maxID = 0; AssignNewIndex(0, maxID, children, newIndex); // compile newIndices newParent, newChildren int newN = maxID + 1; newIndices.resize(newN); newParent.resize(newN); newChildren.resize(newN); unsigned int index; unsigned int childID; for (unsigned int i = 0; i < newIndex.size(); i++) { index = newIndex[i]; newIndices[index].push_back(i + 1); for (unsigned int j = 0; j < children[i].size(); j++) { childID = newIndex[children[i][j]]; // new child ID if (index != childID) { // index may equal to childID, since the two may have been combined // if they differ, then they are parernt and child newChildren[index].push_back(childID + 1); newParent[childID] = index + 1; } } } // first entry is the root newParent[0] = 0; // compile newleaf for (int i = 0; i < newN; i++) if (newChildren[i].size() == 0) newLeaf.push_back(i + 1); // compile newIndex for (unsigned int i = 0; i < newIndex.size(); i++) newIndex[i]++; Rcpp::List out = Rcpp::List::create( Rcpp::Named("indices") = newIndices, Rcpp::Named("indexmap") = newIndex, Rcpp::Named("parent") = newParent, Rcpp::Named("children") = newChildren, Rcpp::Named("leaf") = newLeaf ); return out; }
bool Solver::readFile(const char *filename){ int m; const int buffSize = 256; char line[buffSize]; std::ifstream in(filename); if (!in.is_open()) { std::cout << "FILE NOT FOUND!" << std::endl; exit(-1); } //skip the words for (int i = 0; i < 10; ++i) in.getline(line, buffSize); in.getline(line, buffSize); sscanf(line, "Fleet Size (k):%d\n", &numFleet); in.getline(line, buffSize); in.getline(line, buffSize); sscanf(line, "Alpha:%lf\n", &alpha); in.getline(line, buffSize); sscanf(line, "Drones Per Vehicle (l):%d\n", &numDrone); in.getline(line, buffSize); sscanf(line, "Drone Flight Duration (t_drone):%lf\n", &tDrone); in.getline(line, buffSize); sscanf(line, "Truck Capacity (cap_truck):%d\n", &truckCap); in.getline(line, buffSize); sscanf(line, "Depot ID(s) (d):%d\n", &depotIndex); in.getline(line, buffSize); sscanf(line, "N:%d\n", &numCustomer); in.getline(line, buffSize); sscanf(line, "M:%d\n", &m); droned = new bool[numCustomer]; bestDroned = new bool[numCustomer]; bestNextArray = new int[numCustomer]; bestPreArray = new int[numCustomer]; for (int i = 0; i < numCustomer; ++i) { droned[i] = false; } // droneDplyAtNode = new DroneDeployment[numCustomer]; dist = new double*[numCustomer]; dist[0] = new double[numCustomer * numCustomer]; for (int i = 1; i < numCustomer; ++i) dist[i] = dist[i - 1] + numCustomer; nextNode = new int*[numCustomer]; nextNode[0] = new int[numCustomer * numCustomer]; for (int i = 1; i < numCustomer; ++i) { nextNode[i] = nextNode[i - 1] + numCustomer; } cost = new double*[numCustomer]; cost[0] = new double[numCustomer * numCustomer]; for (int i = 1; i < numCustomer; ++i) cost[i] = cost[i - 1] + numCustomer; pathLength = new int*[numCustomer]; pathLength[0] = new int[numCustomer * numCustomer]; for (int i = 1; i < numCustomer; ++i) pathLength[i] = pathLength[i - 1] + numCustomer; for (int i = 0; i < numCustomer; ++i) { for (int j = 0; j < numCustomer; ++j) { dist[i][j] = cost[i][j] = INF; nextNode[i][j] = 0; pathLength[i][j] = 0; } } for (int i = 0; i < numCustomer; ++i) { dist[i][i] = cost[i][i] = 0; } for (int i = 0; i < 4; ++i) in.getline(line, buffSize); for (int i = 0; i < m; ++i){ int a, b; double c; in.getline(line, buffSize); sscanf(line, "%d,%d,%lf,false\n", &a, &b, &c); a = newIndex(a); b = newIndex(b); dist[a][b] = dist[b][a] = cost[a][b] = cost[b][a] = c; // dist[b][a] = c; // cost[a][b] = c; // cost[b][a] = c; nextNode[a][b] = b; nextNode[b][a] = a; pathLength[a][b] = pathLength[b][a] = 1; } for (int k = 0; k < numCustomer; ++k) { for (int i = 0; i < numCustomer; ++i) { for (int j = 0; j < numCustomer; ++j) { if (cost[i][j] > cost[i][k] + cost[k][j]) { cost[i][j] = cost[i][k] + cost[k][j]; nextNode[i][j] = nextNode[i][k]; pathLength[i][j] = pathLength[i][k] + pathLength[k][j]; } } } } nodes = new Coordinate[numCustomer]; for (int i = 0; i < 4; ++i) in.getline(line, buffSize); for (int i = 1; i <= numCustomer; ++i) { double x, y; in.getline(line, buffSize); sscanf(line, "%lf,%lf\n", &x, &y); nodes[newIndex(i)].set(x, y); } for (int i = 1; i < numCustomer; ++i) { nodes[i].set(nodes[i].getX() - nodes[0].getX(), nodes[i].getY() - nodes[0].getY()); } nodes[0].set(0, 0); in.close(); createNodeInfo(); // for (int i = 0; i < numCustomer; ++i) { // for (int j = 0; j < numCustomer; ++j) { // std::cout << cost[i][j] << " "; // } // std::cout << std::endl; // } return true; }