C++ Index::docCount方法代码示例

// keywordToDocs '+indexPath+' "'+query+'"','r'
int main(int argc, const char* argv[]) 
{
	if (argc == 2) {
		if (!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help")) {
			cout << endl << "Usage:" << endl << endl <<
				"keywordToDocs indexPath \"query\"" << endl << endl <<
				"Returns a list of doc numbers that contain the query" <<
				endl << endl;
			return(0);
		}
	}
	Index *ind = IndexManager::openIndex(argv[1]);

	ArrayAccumulator accumulator(ind->docCount());
	RetrievalMethod *myMethod = new TFIDFRetMethod(*ind, accumulator); 
	IndexedRealVector results; 
    StringQuery *q = new StringQuery(argv[2]); // construct a TextQuery
    QueryRep * qr = myMethod->computeQueryRep(*q); // compute the query representation 
    // now score all documents    
    myMethod->scoreCollection(*qr, results);
    results.Sort(); // sorting results, assume a higher score means more relevant
    IndexedRealVector::iterator it;
    it = results.begin();
    while ((it != results.end())) {
         cout << (*it).ind  // this is the document ID 
              << endl;
         it++;
    }
}

/// A retrieval evaluation program
int AppMain(int argc, char *argv[]) {
  

  //Step 1: Open the index file
  Index  *ind;

  try {
    ind  = IndexManager::openIndex(LocalParameter::databaseIndex);
  } 
  catch (Exception &ex) {
    ex.writeMessage();
    throw Exception("RelEval", "Can't open index, check parameter index");
  }

  //Step 2: Open the query file
  DocStream *qryStream;
  try {
    qryStream = new lemur::parse::BasicDocStream(LocalParameter::queryStream);
  } 
  catch (Exception &ex) {
    ex.writeMessage(cerr);
    throw Exception("RetEval", 
                    "Can't open query file, check parameter textQuery");
  }

  //Step 3: Create the result file
  ofstream result(LocalParameter::resultFile.c_str());
  ResultFile resultFile(1);
  resultFile.openForWrite(result, *ind);


  // go through each query
  
  qryStream->startDocIteration();
  while (qryStream->hasMore()) {
    Document *qryDoc = qryStream->nextDoc();
    const char *queryID = qryDoc->getID();
    cout << "query: "<< queryID <<endl;

    double *queryArr = new double[ind->termCountUnique()+1];  //the array that contains the weights of query terms; for orignial query 
    ComputeQryArr(qryDoc,queryArr, ind); 

    IndexedRealVector results(ind->docCount());
    results.clear();

    Retrieval(queryArr,results,ind);

    results.Sort();
    resultFile.writeResults(queryID, &results, LocalParameter::resultCount);

    delete queryArr;
  }



  result.close();
  delete qryStream;
  delete ind;
  return 0;
}

int AppMain(int argc, char *argv[]) {

  Index  *ind;

  try {
    ind = IndexManager::openIndex(RetrievalParameter::databaseIndex);
  } 
  catch (Exception &ex) {
    ex.writeMessage();
    throw Exception("QueryClarity", 
                    "Can't open index, check parameter index");
  }

  lemur::retrieval::ArrayAccumulator accumulator(ind->docCount());
  IndexedRealVector res(ind->docCount());
  ofstream os(LocalParameter::expandedQuery.c_str());

  lemur::retrieval::SimpleKLRetMethod *model;
  model =  new lemur::retrieval::SimpleKLRetMethod(*ind, SimpleKLParameter::smoothSupportFile, 
                                 accumulator);
  model->setDocSmoothParam(SimpleKLParameter::docPrm);
  model->setQueryModelParam(SimpleKLParameter::qryPrm);
  DocStream *qryStream;
  try {
    qryStream = new lemur::parse::BasicDocStream(RetrievalParameter::textQuerySet);
  } catch (Exception &ex) {
    ex.writeMessage(cerr);
    throw Exception("QueryClarity", "Can't open query file");
  }
  qryStream->startDocIteration();
  TextQuery *q;
  while (qryStream->hasMore()) {
    Document *d = qryStream->nextDoc();
    q = new TextQuery(*d);
    QueryRep *qr = model->computeQueryRep(*q);
    res.clear();
    QueryClarity(qr, q->id(), &res, model, os);     
    delete qr;
    delete q;
  }
  os.close();
  delete model;
  delete qryStream;
  delete ind;
  return 0;
}

int AppMain(int argc, char *argv[]) {
  ofstream ofs;
  Index * dbIndex;
  try {
    dbIndex = IndexManager::openIndex(LocalParameter::index);
  } 
  catch (Exception &ex) {
    ex.writeMessage();
    throw Exception("GenL2Norm", "Can't open index, check parameter index");
  }
  // pre-compute IDF values
  double *idfV = new double[dbIndex->termCountUnique()+1];
  TERMID_T i;
  for (i=1; i<=dbIndex->termCountUnique(); i++) {
    idfV[i] = log((dbIndex->docCount()+1)/(0.5+dbIndex->docCount(i)));
  }
  ofs.open(LocalParameter::L2File.c_str(), ios::out | std::ios::binary);
  for (i = 1; i <= dbIndex->docCount(); i++) {
    TermInfoList *qList = dbIndex->termInfoList(i);
    TermInfo *qInfo;
    qList->startIteration();
    TERMID_T idx;
    COUNT_T dtf;
    double norm = 0, tmp;
    while (qList->hasMore()) {
      qInfo = qList->nextEntry();
      idx = qInfo->termID();
      dtf = qInfo->count();
      tmp = dtf * idfV[idx];
      norm += tmp * tmp;
    }
    delete qList;
    //  docNorms[docID] = sqrt(norm);
    norm = sqrt(norm);
    if (norm == 0) norm = 1;
    ofs << i << " " << norm << endl;
  }
  ofs.close();
  delete[](idfV);
  delete dbIndex;
  return 0;
}

int AppMain(int argc, char * argv[]) {
  if (argc > 2) {
    cerr << "Usage: OfflineCluster <parameter file>" << endl;
    return -1;
  }
  COUNT_T i;
  Index *myIndex;
  try {
    myIndex  = IndexManager::openIndex(ClusterParam::databaseIndex);
  } catch (Exception &ex) {
    ex.writeMessage();
    throw Exception("OfflineCluster", 
                    "Can't open index, check parameter index");
  }
  // construct cluster method.
  lemur::cluster::OfflineCluster* clusterDB;
  clusterDB = new lemur::cluster::OfflineCluster(*myIndex,
                                                 ClusterParam::simType,
                                                 ClusterParam::clusterType,
                                                 ClusterParam::docMode);
  // crank through the collection
  COUNT_T numDocs = myIndex->docCount();
  if (numDocs > 100) numDocs = 100;
  vector <DOCID_T> toCluster;
  for (i = 1; i <= numDocs; i++) {
    toCluster.push_back(i);
  }

  cout << "Using kmeans on " << numDocs << " documents..." << endl;
  vector <lemur::cluster::Cluster *> *clusters;
  clusters = clusterDB->kMeans(toCluster, ClusterParam::numParts,
                               ClusterParam::maxIters);

  for (i = 0; i < clusters->size(); i++) {
    (*clusters)[i]->print();
    delete((*clusters)[i]);
  }
  delete(clusters);
  cout << "Using bisecting kmeans on " << numDocs << " documents..." << endl;
  clusters = clusterDB->bisecting_kMeans(toCluster, ClusterParam::numParts,
                                         ClusterParam::numIters,
                                         ClusterParam::maxIters);
  for (i = 0; i < clusters->size(); i++) {
    (*clusters)[i]->print();
    delete((*clusters)[i]);
  }
  delete(clusters);
  delete clusterDB;
  delete myIndex;
  return 0;
}