Particle *Optimizer::selectParticleUsingMinimumStates( const std::vector<Particle *>& results) { const vector<Word*>* wordSet = _wordsGenerator->getTrainingAllSet(); std::vector<std::set<int>> stateCountVec; // For each result check how many states it uses. for (unsigned int i = 0; i < results.size(); i++) { Particle* result = results[i]; const DFA* dfa = result->getBestDFA(); std::set<int> s; unsigned int wordCount = wordSet->size(); vector<int> stateVector(wordCount); // Pre compute all words. Save results in stateVector for(unsigned int i = 0; i < wordCount; i++){ Word* word = (*wordSet)[i]; stateVector[i] = dfa ->compute(*word); s.insert(dfa->compute(*word)); } stateCountVec.push_back(s); } int minIndex = 0; unsigned int minCount = stateCountVec[minIndex].size(); for (unsigned int i = 0; i < stateCountVec.size(); i++) { if (minCount > stateCountVec[i].size()) { minIndex = i; minCount = stateCountVec[i].size(); } } return results[minIndex]; }
void Optimizer::computeRelation() { logger::log(Verbose(OPTIMIZER_V), "Computing Relation"); const vector<Word*>* trainingSet = _wordsGenerator->getTrainingAllSet(); unsigned int wordCount = trainingSet->size(); vector<int> stateVector(wordCount); // Pre compute all words. Save results in stateVector for(unsigned int i = 0; i < wordCount; i++){ Word* word = (*trainingSet)[i]; stateVector[i] = tool->compute(*word); } // For all distinct pairs for(unsigned int i = 0; i < wordCount-1; i++){ for(unsigned int j = i+1; j < wordCount; j++){ bool inRelation = stateVector[i] == stateVector[j]; int result = inRelation ? 1:0; _toolRelationResults.push_back(result); } } }
double NLEQInterface::solve(const vector<double>& yin) { if (yin.size() == 0) { return 0; } // Set up a dummy Jacobian, actual Jacobian is computed // by NLEQ using finite differences // double* Jacobian = new double[1]; ierr = 0; IWK[31 - 1] = maxIterations; // Max iterations // Set up default scaling factors for (int i = 0; i < n; i++) { XScal[i] = 1.0; } for (int i = 0; i < nOpts; i++) { iopt[i] = 0; } iopt[31 - 1] = 3; // Set for Highly nonlinear problem // Initialise all array elements to 0.0 for (int i = 0; i < LIWK; i++) { IWK[i] = 0; } IWK[31 - 1] = maxIterations; // Max iterations for (int i = 0; i < LWRK; i++) { RWK[i] = 0.0; } RWK[22 - 1] = 1E-20; // Minimal allowed damping factor // For some reason NLEQ modifies the tolerance value, use a local copy instead double tmpTol = relativeTolerance; // set up the thread local variables, only this thread // access them. if (*threadModel) { throw(Exception("thread local storage model is set, this should never occur here.")); } *threadModel = model; vector<double> stateVector(n); model->getStateVector(&stateVector[0]); NLEQ1( &n, &ModelFunction, NULL, &stateVector[0], XScal, &tmpTol, iopt, &ierr, &LIWK, IWK, &LWRK, RWK); // done, clear it. *threadModel = 0; if (ierr == 2) // retry { for (int i = 0; i < nOpts; i++) { iopt[i] = 0; } iopt[31 - 1] = 3; // Set for Highly nonlinear problem iopt[0] = 1; // Try again but tell NLEQ not to reinitialize tmpTol = relativeTolerance; } if(ierr > 0 ) { if (isWarning(ierr)) { Log(Logger::LOG_WARNING) << ErrorForStatus(ierr); } else { string err = ErrorForStatus(ierr); Log(Logger::LOG_ERROR)<<"Error :"<<err; throw NLEQException(err); } } return computeSumsOfSquares(); }