int32 Vector::scan(char* key, uint32 sz, uint32* index, Comparator* c) { Comparator* cUse = NULL; int32 ret = 0; if (!c && !m_comp) return FAILURE; if (!c) cUse = m_comp; else cUse = c; for (uint32 j = 0; j < getCount(); j++) { VectorSlot* vs = (VectorSlot*) m_pvDB[j]; if (vs) { ret = cUse->compare(vs->dbData.toString(), vs->dbData.getCount(), key, sz); if (ret == SUCCESS) { if (index) *index = j; return SUCCESS; } } } return FAILURE; }
/** * Compares two solutions. * @param solution1 Object representing the first <code>Solution</code>. * @param solution2 Object representing the second <code>Solution</code>. * @return -1, or 0, or 1, or 2 if solution1 is dominates solution2, solution1 * and solution2 are equals, or solution1 is greater than solution2, * respectively. */ int EqualSolutions::compare(Solution * solution1, Solution * solution2) { if (solution1==NULL) return 1; else if (solution2 == NULL) return -1; int dominate1 ; // dominate1 indicates if some objective of solution1 // dominates the same objective in solution2. dominate2 int dominate2 ; // is the complementary of dominate1. dominate1 = 0 ; dominate2 = 0 ; int flag; double value1, value2; for (int i = 0; i < solution1->getNumberOfObjectives(); i++) { Comparator * c = new ObjectiveComparator(i); flag = c->compare(solution1,solution2); delete c; value1 = solution1->getObjective(i); value2 = solution2->getObjective(i); if (value1 < value2) { flag = -1; } else if (value1 > value2) { flag = 1; } else { flag = 0; } if (flag == -1) { dominate1 = 1; } if (flag == 1) { dominate2 = 1; } } if (dominate1== 0 && dominate2 ==0) { return 0; //No one dominate the other } if (dominate1 == 1) { return -1; // solution1 dominate } else if (dominate2 == 1) { return 1; // solution2 dominate } return 2; } // compare
long binarySearch(const S searched, const std::size_t searchLength, const T& searchedFor, const Comparator<T>& comp) { std::size_t low(0); std::size_t high(searchedLength); while( low < high ) { std::size_t mid(low + ((high - low) >> 1)); switch(comp.compare(searched[mid], searcedFor)) { case ORDER_INCREASING: low = mid + 1; break; case ORDER_DECREASING: high = mid; break; case ORDER_SAME: return static_cast<long>(mid); } } return -1 - static_cast<long>(low); }
/* * Runs the GDE3 algorithm. * @return a <code>SolutionSet</code> that is a set of non dominated solutions * as a result of the algorithm execution */ SolutionSet * GDE3::execute() { int populationSize; int maxIterations; int evaluations; int iterations; SolutionSet * population; SolutionSet * offspringPopulation; Distance * distance; Comparator * dominance; Operator * crossoverOperator; Operator * selectionOperator; distance = new Distance(); dominance = new DominanceComparator(); Solution ** parent; //Read the parameters populationSize = *(int *) getInputParameter("populationSize"); maxIterations = *(int *) getInputParameter("maxIterations"); //Initialize the variables population = new SolutionSet(populationSize); evaluations = 0; iterations = 0; //Read the operators crossoverOperator = operators_["crossover"]; selectionOperator = operators_["selection"]; // Create the initial solutionSet Solution * newSolution; for (int i = 0; i < populationSize; i++) { newSolution = new Solution(problem_); problem_->evaluate(newSolution); problem_->evaluateConstraints(newSolution); evaluations++; population->add(newSolution); } //for // Generations ... while (iterations < maxIterations) { // Create the offSpring solutionSet offspringPopulation = new SolutionSet(populationSize * 2); for (int i = 0; i < populationSize; i++){ // Obtain parents. Two parameters are required: the population and the // index of the current individual void ** object1 = new void*[2]; object1[0] = population; object1[1] = &i; parent = (Solution **) (selectionOperator->execute(object1)); delete[] object1; Solution * child ; // Crossover. Two parameters are required: the current individual and the // array of parents void ** object2 = new void*[2]; object2[0] = population->get(i); object2[1] = parent; child = (Solution *) (crossoverOperator->execute(object2)); delete[] object2; delete[] parent; problem_->evaluate(child) ; problem_->evaluateConstraints(child); evaluations++ ; // Dominance test int result ; result = dominance->compare(population->get(i), child) ; if (result == -1) { // Solution i dominates child offspringPopulation->add(new Solution(population->get(i))); delete child; } // if else if (result == 1) { // child dominates offspringPopulation->add(child) ; } // else if else { // the two solutions are non-dominated offspringPopulation->add(child) ; offspringPopulation->add(new Solution(population->get(i))); } // else } // for // Ranking the offspring population Ranking * ranking = new Ranking(offspringPopulation); int remain = populationSize; int index = 0; SolutionSet * front = NULL; for (int i = 0; i < populationSize; i++) { delete population->get(i); } population->clear(); // Obtain the next front front = ranking->getSubfront(index); while ((remain > 0) && (remain >= front->size())){ //Assign crowding distance to individuals distance->crowdingDistanceAssignment(front,problem_->getNumberOfObjectives()); //Add the individuals of this front for (int k = 0; k < front->size(); k++ ) { population->add(new Solution(front->get(k))); } // for //Decrement remain remain = remain - front->size(); //Obtain the next front index++; if (remain > 0) { front = ranking->getSubfront(index); } // if } // while // remain is less than front(index).size, insert only the best one if (remain > 0) { // front contains individuals to insert while (front->size() > remain) { distance->crowdingDistanceAssignment(front,problem_->getNumberOfObjectives()); Comparator * crowdingComparator = new CrowdingComparator(); int indexWorst = front->indexWorst(crowdingComparator); delete crowdingComparator; delete front->get(indexWorst); front->remove(indexWorst); } for (int k = 0; k < front->size(); k++) { population->add(new Solution(front->get(k))); } remain = 0; } // if delete ranking; delete offspringPopulation; iterations ++ ; } // while delete dominance; delete distance; // Return the first non-dominated front Ranking * ranking = new Ranking(population); SolutionSet * result = new SolutionSet(ranking->getSubfront(0)->size()); for (int i=0;i<ranking->getSubfront(0)->size();i++) { result->add(new Solution(ranking->getSubfront(0)->get(i))); } delete ranking; delete population; return result; } // execute