/* 
   * Read potential parameters from file.
   */
   void LocalLamellarOrderingExternal::readParameters(std::istream &in) 
   {
      if (nAtomType_ == 0) {
         UTIL_THROW("nAtomType must be set before readParam");
      }
      if (!boundaryPtr_) {
         UTIL_THROW("Boundary must be set before readParam");
      }
   
      // Read parameters
      read<int>(in, "perpDirection", perpDirection_);
      if (perpDirection_ < 0 || perpDirection_ >= Dimension) {
         UTIL_THROW("Invalid index for perpendicular direction.");
      }
      read<int>(in, "parallelDirection", parallelDirection_);
      if (parallelDirection_ < 0 || parallelDirection_ >= Dimension) {
         UTIL_THROW("Invalid index for parallel direction.");
      }
      read<double>(in, "fraction", fraction_);
      prefactor_.allocate(nAtomType_);
      readDArray<double>(in, "prefactor", prefactor_, nAtomType_);
      read<double>(in, "externalParameter", externalParameter_);
      read<double>(in, "interfaceWidth", width_);
      read<int>(in, "periodicity", periodicity_);

      isInitialized_ = true;
   }
Esempio n. 2
0
   /* 
   * Read potential parameters from file.
   */
   void PeriodicExternal::readParameters(std::istream &in) 
   {
      if (nAtomType_ == 0) {
         UTIL_THROW("nAtomType must be set before readParam");
      }
      if (!boundaryPtr_) {
         UTIL_THROW("Boundary must be set before readParam");
      }
  
      // Read parameters
      prefactor_.allocate(nAtomType_);
      readDArray<double>(in, "prefactor", prefactor_, nAtomType_);

      read<double>(in, "externalParameter", externalParameter_);

      read<int>(in, "nWaveVectors", nWaveVectors_);
      read<double>(in, "C", C_);
      waveVectors_.allocate(nWaveVectors_);
      readDArray<Vector>(in, "waveVectors", waveVectors_, nWaveVectors_);

      phases_.allocate(nWaveVectors_);
      readDArray<double>(in, "phases", phases_, nWaveVectors_);
      read<Vector>(in, "shift", shift_);
      read<double>(in, "interfaceWidth", interfaceWidth_);
      read<int>(in, "periodicity", periodicity_);

      isInitialized_ = true;
   }
   void McSimulation::load(const std::string& filename)
   {
      if (isInitialized_) {
         UTIL_THROW("Error: Called load when already initialized");
      }
      if (!isRestarting_) {
         UTIL_THROW("Error: Called load without restart option");
      }

      // Load from archive
      Serializable::IArchive ar;
      std::ios_base::openmode mode = std::ios_base::in | std::ios_base::binary;
      fileMaster().openRestartIFile(filename, ar.file(), mode);
      load(ar);
      ar.file().close();

      #ifdef UTIL_MPI
      #ifdef MCMD_PERTURB
      if (system().hasPerturbation()) {
         // Read one command file, after reading multiple restart files.
         Util::Log::file() << "Set to use a single command file" 
                           << std::endl;
         setIoCommunicator();
      }
      #endif
      #endif

      isInitialized_ = true;
   }
Esempio n. 4
0
   /*
   * Remove all ghosts.
   */
   void AtomStorage::clearGhosts()
   {
      // Precondition
      if (locked_) 
         UTIL_THROW("AtomStorage is locked");

      // Clear ghosts from the map
      map_.clearGhosts(ghostSet_);

      // Transfer ghosts from the set to the reservoir
      Atom* atomPtr;
      while (ghostSet_.size() > 0) {
         atomPtr = &ghostSet_.pop();
         ghostReservoir_.push(*atomPtr);
      }

      if (ghostSet_.size() != 0) {
         UTIL_THROW("Nonzero ghostSet size at end of clearGhosts");
      }
      if (map_.nGhost() != 0) {
         UTIL_THROW("Nonzero nGhost in map at end of clearGhosts");
      }
      if (map_.nGhostDistinct() != 0) {
         UTIL_THROW("Nonzero nGhostDistinct at end of clearGhosts");
      }
   }
Esempio n. 5
0
   /*
   * Load state from an archive.
   */
   void ClusterHistogram::loadParameters(Serializable::IArchive& ar)
   {
      // Load interval and outputFileName
      Analyzer::loadParameters(ar);

      loadParameter<int>(ar,"speciesId", speciesId_);
      if (speciesId_ < 0) {
         UTIL_THROW("Negative speciesId");
      }
      if (speciesId_ >= system().simulation().nSpecies()) {
         UTIL_THROW("speciesId > nSpecies");
      }

      loadParameter<int>(ar, "atomTypeId", atomTypeId_);
      if (atomTypeId_ < 0) {
         UTIL_THROW("Negative atomTypeId");
      }

      loadParameter<double>(ar, "cutoff", cutoff_);
      if (cutoff_ < 0) {
         UTIL_THROW("Negative cutoff");
      }

      identifier_.initialize(speciesId_, atomTypeId_, cutoff_);
      loadParameter<int>(ar, "histMin", histMin_);
      loadParameter<int>(ar, "histMax", histMax_);
      ar >> hist_;

      ar >> nSample_;

      isInitialized_ = true;
   }
   /*
   * Load internal state from an archive.
   */
   void McSimulation::loadParameters(Serializable::IArchive &ar)
   {
      if (isInitialized_) {
         UTIL_THROW("Error: Called readParam when already initialized");
      }
      #ifdef UTIL_MPI
      if (hasIoCommunicator()) {
         UTIL_THROW("Error: Has a param communicator in loadParameters");
      }
      #endif

      Simulation::loadParameters(ar);
      loadParamComposite(ar, system());
      loadParamComposite(ar, *mcMoveManagerPtr_);
      loadParamComposite(ar, analyzerManager());
      loadParameter<int>(ar, "saveInterval", saveInterval_);
      if (saveInterval_ > 0) {
         loadParameter<std::string>(ar, "saveFileName", saveFileName_);
      }

      system().loadConfig(ar);
      ar >> iStep_;
      isValid();
      isInitialized_ = true;
   }
Esempio n. 7
0
   /*
   * Load state from an archive.
   */
   void StructureFactor::loadParameters(Serializable::IArchive& ar)
   {
      Analyzer::loadParameters(ar);
      ar & nAtomType_;
      loadParameter<int>(ar, "nMode", nMode_);
      loadDMatrix<double>(ar, "modes", modes_, nMode_, nAtomType_);
      loadParameter<int>(ar, "nWave", nWave_);
      loadDArray<IntVector>(ar, "waveIntVectors", waveIntVectors_, nWave_);
      ar & structureFactors_;
      ar & nSample_;

      // Validate
      if (nAtomType_ != system().simulation().nAtomType()) {
         UTIL_THROW("Inconsistent values of nAtomType_");
      }
      if (modes_.capacity1() != nMode_) {
         UTIL_THROW("Inconsistent capacity1 for modes array");
      }
      if (modes_.capacity2() != nAtomType_) {
         UTIL_THROW("Inconsistent capacity2 for modes array");
      }
      if (waveIntVectors_.capacity() != nWave_) {
         UTIL_THROW("Inconsistent capacity for waveIntVector");
      }

      // Allocate temporary data structures
      waveVectors_.allocate(nWave_);
      fourierModes_.allocate(nWave_, nMode_);

      isInitialized_ = true;
   }
   /*
   * Read and execute commands from a specified command file.
   */
   void McSimulation::readCommands(std::istream &in)
   {
      if (!isInitialized_) {
         UTIL_THROW("McSimulation is not initialized");
      }

      std::string    command;
      std::string    filename;
      std::ifstream  inputFile;
      std::ofstream  outputFile;

      #ifndef UTIL_MPI
      std::istream&     inBuffer = in;
      #else
      std::stringstream inBuffer;
      std::string       line;
      #endif

      bool readNext = true;
      while (readNext) {

         // iffdef UTIL_MPI, read a line and copy to stringstream inBuffer
         // ifndef UTIL_MPI, inBuffer is simply a reference to istream in.

         #ifdef UTIL_MPI
         // Read a command line, and broadcast if necessary.
         if (!hasIoCommunicator() || isIoProcessor()) {
            getNextLine(in, line);
         }
         if (hasIoCommunicator()) {
            bcast<std::string>(communicator(), line, 0);
         }

         // Copy the command line to inBuffer.
         inBuffer.clear();
         for (unsigned i=0; i < line.size(); ++i) {
            inBuffer.put(line[i]);
         }
         #endif

         inBuffer >> command;
         Log::file() << command;

         if (isRestarting_) {

            if (command == "RESTART") {
               int endStep;
               inBuffer >> endStep;
               Log::file() << "  " << iStep_ << " to " 
                           << endStep << std::endl;
               simulate(endStep, isRestarting_);
               isRestarting_ = false;
            } else {
               UTIL_THROW("Missing RESTART command");
            }

         } else {
Esempio n. 9
0
void ScoreFeatureManager::configure(const std::vector<std::string> args)
{
  bool domainAdded = false;
  bool sparseDomainAdded = false;

  for (size_t i = 0; i < args.size(); ++i) {
  	if (args[i] == "--IgnoreSentenceId") {
      m_includeSentenceId = true;
    } else if (args[i].substr(0,8) == "--Domain") {
      string type = args[i].substr(8);
      ++i;
      UTIL_THROW_IF(i == args.size(), ScoreFeatureArgumentException, "Missing domain file");
      string domainFile = args[i];
      UTIL_THROW_IF(domainAdded, ScoreFeatureArgumentException,
                    "Only allowed one domain feature");
      if (type == "Subset") {
        m_features.push_back(ScoreFeaturePtr(new SubsetDomainFeature(domainFile)));
      } else if (type == "Ratio") {
        m_features.push_back(ScoreFeaturePtr(new RatioDomainFeature(domainFile)));
      } else if (type == "Indicator") {
        m_features.push_back(ScoreFeaturePtr(new IndicatorDomainFeature(domainFile)));
      } else {
        UTIL_THROW(ScoreFeatureArgumentException, "Unknown domain feature type " << type);
      }
      domainAdded = true;
      m_includeSentenceId = true;
    } else if (args[i].substr(0,14) == "--SparseDomain") {
      string type = args[i].substr(14);
      ++i;
      UTIL_THROW_IF(i == args.size(), ScoreFeatureArgumentException, "Missing domain file");
      string domainFile = args[i];
      UTIL_THROW_IF(sparseDomainAdded, ScoreFeatureArgumentException,
                    "Only allowed one sparse domain feature");
      if (type == "Subset") {
        m_features.push_back(ScoreFeaturePtr(new SparseSubsetDomainFeature(domainFile)));
      } else if (type == "Ratio") {
        m_features.push_back(ScoreFeaturePtr(new SparseRatioDomainFeature(domainFile)));
      } else if (type == "Indicator") {
        m_features.push_back(ScoreFeaturePtr(new SparseIndicatorDomainFeature(domainFile)));
      } else {
        UTIL_THROW(ScoreFeatureArgumentException, "Unknown domain feature type " << type);
      }
      sparseDomainAdded = true;
      m_includeSentenceId = true;
    } else if(args[i] == "--GHKMFeatureSparse"){
    	//MARIA
    	m_features.push_back(ScoreFeaturePtr(new InternalStructFeatureSparse()));
    } else if(args[i] == "--GHKMFeatureDense"){
    	//MARIA
    	m_features.push_back(ScoreFeaturePtr(new InternalStructFeatureDense()));
    } else {
      UTIL_THROW(ScoreFeatureArgumentException,"Unknown score argument " << args[i]);
    	}

  }

}
Esempio n. 10
0
 /* 
 * Set nAtomType
 */
 void PeriodicExternal::setNAtomType(int nAtomType) 
 {  
    if (nAtomType <= 0) {
       UTIL_THROW("nAtomType <= 0");
    }
    if (nAtomType > MaxAtomType) {
       UTIL_THROW("nAtomType > PeriodicExternal::MaxAtomType");
    }
    nAtomType_ = nAtomType;
 }
 /* 
 * Set nAtomType
 */
 void LocalLamellarOrderingExternal::setNAtomType(int nAtomType) 
 {  
    if (nAtomType <= 0) {
       UTIL_THROW("nAtomType <= 0");
    }
    if (nAtomType > MaxAtomType) {
       UTIL_THROW("nAtomType > LocalLamellarOrderingExternal::MaxAtomType");
    }
    nAtomType_ = nAtomType;
 }
Esempio n. 12
0
 /* 
 * Set nAtomType
 */
 void OrthoBoxExternal::setNAtomType(int nAtomType) 
 {  
    if (nAtomType <= 0) {
       UTIL_THROW("nAtomType <= 0");
    }
    if (nAtomType > MaxAtomType) {
       UTIL_THROW("nAtomType > OrthoBoxExternal::MaxAtomType");
    }
    nAtomType_ = nAtomType;
 }
Esempio n. 13
0
 /* 
 * Set nAtomType
 */
 void NucleationExternal::setNAtomType(int nAtomType) 
 {  
    if (nAtomType <= 0) {
       UTIL_THROW("nAtomType <= 0");
    }
    if (nAtomType > MaxAtomType) {
       UTIL_THROW("nAtomType > NucleationExternal::MaxAtomType");
    }
    nAtomType_ = nAtomType;
 }
Esempio n. 14
0
 /*
 * Clear memory block (reset to empty state).
 */
 void MemoryIArchive::clear()
 {
    if (!isAllocated()) {
       UTIL_THROW("Archive is not allocated");
    }
    if (!ownsData_) {  
       UTIL_THROW("Archive does not own data");
    }
    cursor_ = begin(); 
    end_ = begin();
 }
Esempio n. 15
0
void OnDiskWrapper::BeginLoad(const std::string &filePath)
{
  if (!OpenForLoad(filePath)) {
    UTIL_THROW(util::FileOpenException, "Couldn't open for loading: " << filePath);
  }

  if (!m_vocab.Load(*this))
    UTIL_THROW(util::FileOpenException, "Couldn't load vocab");

  UINT64 rootFilePos = GetMisc("RootNodeOffset");
  m_rootSourceNode = new PhraseNode(rootFilePos, *this);
}
Esempio n. 16
0
 /*
 * Finalize receiving block, check consistency.
 */
 void Buffer::endRecvBlock()
 {
    if (recvSize_ != 0) {
       UTIL_THROW("Error: Recv counter != 0 at end of block");
    }
    if (recvPtr_ != recvBlockEnd_) {
       UTIL_THROW("Error: Inconsistent recv cursor at end of block");
    }
    recvBlockBegin_ = 0;
    recvBlockEnd_ = 0;
    recvSize_ = 0;
    recvType_ = NONE;
 }
Esempio n. 17
0
 /*
 * Clear accumulators.
 */
 void McMuExchange::setup()
 {
    nMolecule_ = system().nMolecule(speciesId_);
    if (nMolecule_ > accumulators_.capacity()) {
       UTIL_THROW("nMolecule > capacity");
    }
    if (nMolecule_ <= 0) {
       UTIL_THROW("nMolecule <= 0");
    }
    for (int iMol = 0; iMol < nMolecule_; ++iMol) {
       accumulators_[iMol].clear();
    }
 }
Esempio n. 18
0
 /*
 * Read saveInterval and saveFileName.
 */
 void Integrator::readParameters(std::istream& in)
 {
    read<int>(in, "saveInterval", saveInterval_);
    if (saveInterval_ > 0) {
       if (Analyzer::baseInterval > 0) {
          if (saveInterval_ % Analyzer::baseInterval != 0) {
             UTIL_THROW("saveInterval is not a multiple of baseInterval");
          }
       } else {
          UTIL_THROW("Analyzer::baseInterval is not positive");
       }
       read<std::string>(in, "saveFileName", saveFileName_);
    }
 }
Esempio n. 19
0
   /*
   * Return address for a new ghost Atom.
   */ 
   Atom* AtomStorage::newGhostPtr()
   {
      // Preconditions
      if (newGhostPtr_ != 0) 
         UTIL_THROW("Unregistered newGhostPtr_ still active");
      if (locked_ ) 
         UTIL_THROW("AtomStorage is locked");
      if (ghostReservoir_.size() == 0) 
         UTIL_THROW("Atom to pop from empty atomReservoir");

      newGhostPtr_ = &ghostReservoir_.pop();
      newGhostPtr_->clear();
      newGhostPtr_->setIsGhost(true);
      return newGhostPtr_;
   }
Esempio n. 20
0
 /*
 * Reset cursor to beginning, prepare to reread.
 */
 void MemoryIArchive::reset()
 {
    if (!isAllocated()) {
       UTIL_THROW("Archive is not allocated");
    }  
    cursor_ = begin(); 
 }
Esempio n. 21
0
void ConstrainedDecoding::Load()
{
  const StaticData &staticData = StaticData::Instance();
  bool addBeginEndWord = (staticData.GetSearchAlgorithm() == ChartDecoding) || (staticData.GetSearchAlgorithm() == ChartIncremental);

  InputFileStream constraintFile(m_path);
  std::string line;
  long sentenceID = staticData.GetStartTranslationId() - 1;
  while (getline(constraintFile, line)) {
    vector<string> vecStr = Tokenize(line, "\t");

    Phrase phrase(0);
    if (vecStr.size() == 1) {
      sentenceID++;
      phrase.CreateFromString(Output, staticData.GetOutputFactorOrder(), vecStr[0], staticData.GetFactorDelimiter(), NULL);
    } else if (vecStr.size() == 2) {
      sentenceID = Scan<long>(vecStr[0]);
      phrase.CreateFromString(Output, staticData.GetOutputFactorOrder(), vecStr[1], staticData.GetFactorDelimiter(), NULL);
    } else {
      UTIL_THROW(util::Exception, "Reference file not loaded");
    }

    if (addBeginEndWord) {
      phrase.InitStartEndWord();
    }
    m_constraints.insert(make_pair(sentenceID,phrase));

  }
}
Esempio n. 22
0
   /*
   * Allocate and initialize all containers (private).
   */
   void AtomStorage::allocate()
   {
      // Precondition
      if (isInitialized_) {
         UTIL_THROW("AtomStorage can only be initialized once");
      }

      atoms_.allocate(atomCapacity_);
      atomReservoir_.allocate(atomCapacity_);
      atomSet_.allocate(atoms_);
      int i;
      for (i = atomCapacity_ - 1; i >=0; --i) {
          atomReservoir_.push(atoms_[i]);
      }

      ghosts_.allocate(ghostCapacity_);
      ghostReservoir_.allocate(ghostCapacity_);
      ghostSet_.allocate(ghosts_);
      for (i = ghostCapacity_ - 1; i >=0; --i) {
          ghostReservoir_.push(ghosts_[i]);
      }

      map_.allocate(totalAtomCapacity_);
      snapshot_.allocate(atomCapacity_);

      isInitialized_ = true;
   }
Esempio n. 23
0
   /*
   * Determine whether an atom exchange and reneighboring is needed.
   */
   bool Integrator::isExchangeNeeded(double skin) 
   {
     
      if (!atomStorage().isCartesian()) {
         UTIL_THROW("Error: Coordinates not Cartesian in isExchangeNeeded");
      } 

      // Calculate maximum square displacment on this node
      double maxSqDisp = atomStorage().maxSqDisplacement(); 
      int    needed = 0;
      if (sqrt(maxSqDisp) > 0.5*skin) {
         needed = 1; 
      }
      timer_.stamp(CHECK);

      #if UTIL_MPI
      int neededAll;
      domain().communicator().Allreduce(&needed, &neededAll, 
                                        1, MPI::INT, MPI::MAX);
      timer_.stamp(ALLREDUCE);
      return bool(neededAll);
      #else
      return bool(needed);
      #endif
   }
Esempio n. 24
0
   /*
   * Determine whether an atom exchange and reneighboring is needed.
   */
   bool Integrator::isExchangeNeeded(double skin) 
   {
     
      if (!atomStorage().isCartesian()) {
         UTIL_THROW("Error: Coordinates not Cartesian in isExchangeNeeded");
      } 

      // Calculate maximum square displacment on this node
      double maxSqDisp = atomStorage().maxSqDisplacement(); 
      timer_.stamp(CHECK);

      // Decide on master node if maximum exceeds threshhold.
      int needed;

      #if UTIL_MPI
      double maxSqDispAll;                    // global maximum
      domain().communicator().Reduce(&maxSqDisp, &maxSqDispAll, 1, 
                          MPI::DOUBLE, MPI::MAX, 0);
      if (domain().communicator().Get_rank() == 0) {
         needed = 0;
         if (sqrt(maxSqDispAll) > 0.5*skin) {
            needed = 1; 
         }
      }
      domain().communicator().Bcast(&needed, 1, MPI::INT, 0);
      timer_.stamp(ALLREDUCE);
      #else
      if (sqrt(maxSqDisp) > 0.5*skin) {
         needed = 1; 
      }
      #endif

      return bool(needed);
   }
GlobalLexicalModelUnlimited::GlobalLexicalModelUnlimited(const std::string &line)
  :StatelessFeatureFunction(0, line)
{
  UTIL_THROW(util::Exception,
             "GlobalLexicalModelUnlimited hasn't been refactored for new feature function framework yet"); // TODO need to update arguments to key=value

  const vector<string> modelSpec = Tokenize(line);

  for (size_t i = 0; i < modelSpec.size(); i++ ) {
    bool ignorePunctuation = true, biasFeature = false, restricted = false;
    size_t context = 0;
    string filenameSource, filenameTarget;
    vector< string > factors;
    vector< string > spec = Tokenize(modelSpec[i]," ");

    // read optional punctuation and bias specifications
    if (spec.size() > 0) {
      if (spec.size() != 2 && spec.size() != 3 && spec.size() != 4 && spec.size() != 6) {
        std::cerr << "Format of glm feature is <factor-src>-<factor-tgt> [ignore-punct] [use-bias] "
                  <<  "[context-type] [filename-src filename-tgt]";
        //return false;
      }

      factors = Tokenize(spec[0],"-");
      if (spec.size() >= 2)
        ignorePunctuation = Scan<size_t>(spec[1]);
      if (spec.size() >= 3)
        biasFeature = Scan<size_t>(spec[2]);
      if (spec.size() >= 4)
        context = Scan<size_t>(spec[3]);
      if (spec.size() == 6) {
        filenameSource = spec[4];
        filenameTarget = spec[5];
        restricted = true;
      }
    } else
      factors = Tokenize(modelSpec[i],"-");

    if ( factors.size() != 2 ) {
      std::cerr << "Wrong factor definition for global lexical model unlimited: " << modelSpec[i];
      //return false;
    }

    const vector<FactorType> inputFactors = Tokenize<FactorType>(factors[0],",");
    const vector<FactorType> outputFactors = Tokenize<FactorType>(factors[1],",");
    throw runtime_error("GlobalLexicalModelUnlimited should be reimplemented as a stateful feature");
    GlobalLexicalModelUnlimited* glmu = NULL; // new GlobalLexicalModelUnlimited(inputFactors, outputFactors, biasFeature, ignorePunctuation, context);

    if (restricted) {
      cerr << "loading word translation word lists from " << filenameSource << " and " << filenameTarget << endl;
      if (!glmu->Load(filenameSource, filenameTarget)) {
        std::cerr << "Unable to load word lists for word translation feature from files "
                  << filenameSource
                  << " and "
                  << filenameTarget;
        //return false;
      }
    }
  }
}
LanguageModelKen<lm::ngram::ProbingModel>& InMemoryPerSentenceOnDemandLM::GetPerThreadLM() const
{

  LanguageModelKen<lm::ngram::ProbingModel> *lm;
  lm = m_perThreadLM.get();
  if (lm == NULL) {
    lm = new LanguageModelKen<lm::ngram::ProbingModel>();

    string* filename = m_tmpFilename.get();
    if (filename == NULL) {
      UTIL_THROW(util::Exception, "Can't get a thread-specific LM because no temporary filename has been set for this thread\n");
    } else {
      lm->LoadModel(*filename, util::POPULATE_OR_READ);
    }

    VERBOSE(1, filename);
    VERBOSE(1, "\tLM initialized\n");

    m_perThreadLM.reset(lm);
  }
  assert(lm);

  return *lm;

}
FFState* CoveredReferenceFeature::EvaluateWhenApplied(
  const ChartHypothesis& /* cur_hypo */,
  int /* featureID - used to index the state in the previous hypotheses */,
  ScoreComponentCollection* accumulator) const
{
  UTIL_THROW(util::Exception, "Not implemented");
}
Esempio n. 28
0
 /* 
 * Set the nBondType_ member
 */
 void HarmonicBond::setNBondType(int nBondType)
 {  
    if (nBondType > MaxNBondType) {
       UTIL_THROW("nBondType > HarmonicBond::MaxNBondType");
    }
    nBondType_ = nBondType;
 }
Esempio n. 29
0
 /* 
 * Set the nAngleType_ member.
 */
 void CosineSqAngle::setNAngleType(int nAngleType)
 {  
    if (nAngleType > MaxNAngleType) {
       UTIL_THROW("nAngleType > CosineSqAngle::MaxNAngleType");
    }
    nAngleType_ = nAngleType;
 }
Esempio n. 30
0
const TargetPhraseCollectionWithSourcePhrase* PhraseDictionary::
GetTargetPhraseCollectionLegacy(InputType const& src,WordsRange const& range) const
{
  UTIL_THROW(util::Exception, "Legacy method not implemented");
  //Phrase phrase = src.GetSubString(range);
  //return GetTargetPhraseCollection(phrase);
}