예제 #1
0
	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;
	}
예제 #2
0
 int partition(vector<string> &nuts, vector<string> &bolts, int s, int e, Comparator compare) {
     for(int i = s; i <= e; i++) {
         if(compare.cmp(nuts[s], bolts[i]) == 0) {
             swap(bolts[s], bolts[i]);
             break;
         }
     }
     int p = s+1, i = s+1;
     while(i <= e) {
         if(compare.cmp(nuts[s], bolts[i]) == 1) {
             swap(bolts[p], bolts[i]);
             p++;
         }
         i++;
     }
     swap(bolts[s], bolts[--p]);
     swap(nuts[s], nuts[p]);
     i = s; 
     int j = p+1;
     while(i <= p-1 && j <= e) {
         if(compare.cmp(nuts[i], bolts[p]) == 1) {
             swap(nuts[i], nuts[j]);
             j++;
         } else {
             i++;
         }
     }
     return p;
 }
예제 #3
0
파일: main.cpp 프로젝트: zxwbj/danei
int main (void) {
//int x = 123, y = 456;
	double x = 1.23, y = 4.56;
//Comparator<int> comp (x, y);
	Comparator<double> comp (x, y);
	cout << comp.max () << ' ' << comp.min ()
		<< endl;
	cout << ::max (x, y) << ' ' << ::min (x, y)
		<< endl;
	return 0;
}
예제 #4
0
/**
 * 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
예제 #5
0
int main(){
	Comparator comp(3,4);
	Comparator comp1(25.1f,45.6f);
	Comparator comp2('v','c');
	Comparator comp3("happy","sad");
	
	cout<< "\nUse of copy constructor" << endl;
	cout << "-----------------------" << endl;
	
	Comparator compCopy = comp;
	compCopy.check();
	return 0;
}
 void sort(vector<string> &nuts, vector<string> &bolts, int left, int right, Comparator compare) {
     if (left >= right) return;
     
     fprintf(stderr, "%d %d ", left, right);
     
     int ni, nj, bi, bj, m;
     ni = bi = left; nj = bj = right;
     m = (left + right) >> 1;
     
     // recover bolts
     int bp = 0;
     while (bi < bj) {
         while (bi < bj && compare.cmp(nuts[m], bolts[bi]) < 0) bi ++;
         while (bi < bj && compare.cmp(nuts[m], bolts[bj]) > 0) bj --;
         
         if (compare.cmp(nuts[m], bolts[bi]) == 0) bp = bj; else
         if (compare.cmp(nuts[m], bolts[bj]) == 0) bp = bi;
         
         if (bi < bj) {
             swap(bolts, bi, bj);
             bi ++; bj --;
         }
         // print(bolts);
     }
     // printf("%d %d\n", bi, bp);
     while (compare.cmp(nuts[m], bolts[bi]) < 0) bi ++;
     fprintf(stderr, "%d %d ", bi, bp);
     if (bp < bi) { swap(bolts, bp, bi - 1); bp = bi - 1; } else
     if (bp > bi) { swap(bolts, bp, bi); bp = bi; }
     // print(bolts);
     
     // recover nuts
     swap(nuts, m, bp);
     m = bp;
     int np = 0;
     while (ni < m) {
         while (ni < m && compare.cmp(nuts[ni], bolts[m]) > 0) ni ++;
         while (ni < m && compare.cmp(nuts[nj], bolts[m]) < 0) nj --;
         
         if (ni < m) {
             swap(nuts, ni, nj);
             ni ++; nj --;
         }
     }
     // print(nuts);
     
     fprintf(stderr, "%d|", m);
     sort(nuts, bolts, left, m - 1, compare);
     sort(nuts, bolts, m + 1, right, compare);
 }
예제 #7
0
파일: clstmpl.cpp 프로젝트: huaweili/esd
/*
template<typename T>
Comparator<T>::Comparator (T x, T y) :
	m_x (x), m_y (y) {}
template<typename T>
T Comparator<T>::max (void) const {
	return m_x < m_y ? m_y : m_x;
}
template<typename T>
T Comparator<T>::min (void) const {
	return m_x < m_y ? m_x : m_y;
}
*/
int main (void) {
	Comparator<int> ci (123, 456);
	cout << ci.max() << ' ' << ci.min() << endl;
	Comparator<double> cd (1.23, 4.56);
	cout << cd.max() << ' ' << cd.min() << endl;
	Comparator<string> cs ("hello", "world");
	cout << cs.max() << ' ' << cs.min() << endl;
	Comparator<char const*> cp("hello","world");
	cout << cp.max() << ' ' << cp.min() << endl;
	return 0;
}
예제 #8
0
void ContainerTest::outputExpectedSmaller() {
    std::stringstream out;

    std::vector<int> a{1, 2, 3, 4};
    std::vector<int> b{1, 2, 3};

    {
        Error e(&out);
        Comparator<Compare::Container<std::vector<int>>> compare;
        CORRADE_VERIFY(!compare(a, b));
        compare.printErrorMessage(e, "a", "b");
    }

    CORRADE_COMPARE(out.str(), "Containers a and b have different size, actual 4 but 3 expected. Actual has 4 on position 3.\n");
}
예제 #9
0
void ContainerTest::output() {
    std::stringstream out;

    std::vector<int> a{1, 9, 3, 4};
    std::vector<int> b{1, 2, 3, 4};

    {
        Error e(&out);
        Comparator<Compare::Container<std::vector<int>>> compare;
        CORRADE_VERIFY(!compare(a, b));
        compare.printErrorMessage(e, "a", "b");
    }

    CORRADE_COMPARE(out.str(), "Containers a and b have different contents. Actual 9 but 2 expected on position 1.\n");
}
예제 #10
0
void sort_template(xptr_sequence *xs, int off, int len)
{
	Comparator comp;
    // Insertion sort on smallest arrays
    if (len < 7) {
        for (int i=off; i<len+off; i++)
            for (int j=i; j>off && comp.on_less(xs, j,j-1)<0; j--)
                xs->swap(j, j-1);
        return;
    }

    // Choose a partition element, v
    int m = off + (len >> 1);  // Small arrays, middle element
    if (len > 7) {
        int l = off;
        int n = off + len - 1;
        if (len > 40) {        // Big arrays, pseudomedian of 9
            int s = len/8;
            l = comp.med3(xs, l,     l+s, l+2*s);
            m = comp.med3(xs, m-s,   m,   m+s);
            n = comp.med3(xs, n-2*s, n-s, n);
        }
        m = comp.med3(xs, l, m, n);   // Mid-size, med of 3
    }
    xptr v = xs->get(m);

    // Establish Invariant: v* (<v)* (>v)* v*
    int a = off, b = a, c = off + len - 1, d = c;
    while(true) {
        while (b <= c && comp.on_less_lt(xs, b, v)<=0) {
            if (xs->get(b) == v)
                xs->swap(a++, b);
            b++;
        }
        while (c >= b && comp.on_less_rt(xs,v,c)<=0) {
            if (xs->get(c) == v)
                xs->swap(c, d--);
            c--;
        }
        if (b > c)
            break;
        xs->swap(b++, c--);
    }

    // Swap partition elements back to middle
    int s, n = off + len;
    s = s_min(a-off, b-a  );  xs->vecswap( off, b-s, s);
    s = s_min(d-c,   n-d-1);  xs->vecswap( b,   n-s, s);

    // Recursively sort non-partition-elements
    if ((s = b-a) > 1)
        sort_template<Comparator>(xs, off, s);
    if ((s = d-c) > 1)
        sort_template<Comparator>(xs, n-s, s);
}
예제 #11
0
 void quicksort(vector<string>& nuts, vector<string>& bolts, int begin, int end, Comparator cmp) {
     if (begin >= end) return;
     int pivot_pos;
     int left = 0;
     for (int i = begin; i <= end; ++i) {
         int res = cmp.cmp(nuts[begin], bolts[i]);
         if (res == 0) {
             // find the corresponding place for bolt
             pivot_pos = i;
         } else if (res == 1) {
             // find number of smaller bolts
             ++left;
         }
     }
     // put pivot into position
     swap(nuts, begin, begin+left);
     swap(bolts, pivot_pos, begin+left);
     pivot_pos = begin + left;
     // do mutual quicksort
     int i = begin, j = end;
     while (i < pivot_pos && pivot_pos < j) {
         while (i < pivot_pos && cmp.cmp(nuts[pivot_pos], bolts[i]) == 1) ++i;
         while (j > pivot_pos && cmp.cmp(nuts[pivot_pos], bolts[j]) == -1) --j;
         if (i < j) {
             swap(bolts, i, j);
             ++i;
             --j;
         }
     }
     i = begin, j = end;
     while (i < pivot_pos && pivot_pos < j) {
         while (i < pivot_pos && cmp.cmp(nuts[i], bolts[pivot_pos]) == -1) ++i;
         while (j > pivot_pos && cmp.cmp(nuts[j], bolts[pivot_pos]) == 1) --j;
         if (i < j) {
             swap(nuts, i, j);
             ++i;
             --j;
         }
     }
     quicksort(nuts, bolts, begin, pivot_pos-1, cmp);
     quicksort(nuts, bolts, pivot_pos+1, end, cmp);
 }
예제 #12
0
    // All the smaller elements should be in the left side of the pivot,
    // and all the bigger elements should in the right side of the pivot.
    int partition(vector<string>& arr,
                  int left, int right, const string& pivot,
                  Comparator& compare) {
        for (int i = left; i < right; ) {
            if (compare.cmp(arr[i], pivot) == SMALLER ||  // Smaller.
                    (compare.cmp(arr[i], pivot) == REVERSE &&
                     compare.cmp(pivot, arr[i]) == BIGGER)) {
                swap(arr[left++], arr[i++]);
            } else if (compare.cmp(arr[i], pivot) == BIGGER ||  // Bigger.
                       (compare.cmp(arr[i], pivot) == REVERSE &&
                        compare.cmp(pivot, arr[i]) == SMALLER)) {
                ++i;
            } else {  // Equal.
                swap(arr[i], arr[right]);
            }
        }
        // Put the pivot to the partition index.
        swap(arr[left], arr[right]);

        // Return the partition index of an array.
        return left;
    }
예제 #13
0
    int partition(vector<string> &str, string pivot, Comparator compare, int l, int u){

        int mid = l; // middle
        for (int i = l + 1; i <= u; i++) {
            if (compare.cmp(str[i], pivot) == -1 || 
                compare.cmp(pivot, str[i]) == 1) {
                // str[i] smaller than pivot
                mid++;
                swap(str, i, mid);
            } else if (compare.cmp(str[i], pivot) == 0 || 
                       compare.cmp(pivot, str[i]) == 0) {
                // swap nuts[l]/bolts[l] with pivot
				// l位置放pivot
                swap(str, i, l);
                i--;
            }
        }
        // move pivot to proper index
        swap(str, mid, l);

        return mid;
 
    }
예제 #14
0
파일: main.cpp 프로젝트: biji1/md5matcher
int	main(int ac, char** av)
{
  // checking args
  if (ac != 3)
    {
      std::cerr << "Usage: " << av[0] << " <file1> <file2>" << std::endl;
      std::cerr << "<file1>: list of hashes" << std::endl;
      std::cerr << "<file2>: list of words" << std::endl;
      return -1;
    }

  // getting datas
  Parser			parser;
  std::string			file1 = av[1], file2 = av[2];
  std::vector<std::string>&	hashes = parser.GetLines(file1);
  std::vector<std::string>&	words = parser.GetLines(file2);

  // get matches with time
  Comparator	comparator;
  clock_t	begin, end;

  begin = clock();
  comparator.ShowMatches(hashes, words);
  end = clock();

  double elapsed = double(end - begin) / CLOCKS_PER_SEC;
  std::cout.precision(5);
  std::cout << "time elapsed: " << elapsed << " second(s)" << std::endl;

  // cleaning
  hashes.clear();
  delete &hashes;
  words.clear();
  delete &words;

  return 0;
}
 /**
  * @param nuts: a vector of integers
  * @param bolts: a vector of integers
  * @param compare: a instance of Comparator
  * @return: nothing
  */
 void sortNutsAndBoltsN2(vector<string> &nuts, vector<string> &bolts, Comparator compare) {
     int n = nuts.size();
     int m = bolts.size();
     
     for (int i = 0; i < n - 1; i ++) {
         int j = i;
         while (j < m && compare.cmp(nuts[i], bolts[j])) j ++;
         string temp = bolts[j];
         bolts[j] = bolts[i];
         bolts[i] = temp;
     }
     
     for (int i = 0; i < n; i ++) {
         printf("%s ", bolts[i].c_str());
     }
 }
예제 #16
0
 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);
 }
TEST(Comparator, CompareTwoNonEqualFiles)
{
    Comparator comparator;
    ASSERT_FALSE(comparator.compareFiles(FILES_NON_EQUAL_1, FILES_NON_EQUAL_2));
}
int main(int argc, char *argv[])
{
	const char *filename = "serialized.bin";

	/* ============================================================= */
	/*                            WRITING                            */
	/* ============================================================= */

	std::cout << "-------------------------------------" << std::endl;
	std::cout << " Binary file writer test" << std::endl;
	std::cout << "-------------------------------------" << std::endl;

	std::cout << "Opening " << filename << " for writing" << std::endl;
	BinaryFileWriter bfw(filename);
	//FlippingBinaryFileWriter bfw(filename);

	// Create and initialize the two objects
	SimpleObject so1(10, 20.0);
	ListObject lo1;
	lo1.init();

	std::cout << std::endl << "Writing SimpleObject:" << std::endl;
	so1.print();

	if (AS_FAILED(bfw.write(&so1)))
	{
		std::cout << "Could not write SimpleObject in file " << filename << std::endl;
		return 1;
	}

	std::cout << std::endl << "Writing ListObject:" << std::endl;
	lo1.print();
	if (AS_FAILED(bfw.write(&lo1)))
	{
		std::cout << "Could not write ListObject in file " << filename << std::endl;
		return 1;
	}

	std::cout << "Serialization successful" << std::endl << std::endl;



	/* ============================================================= */
	/*                            READING                            */
	/* ============================================================= */

	std::cout << "-------------------------------------" << std::endl;
	std::cout << " Binary file reader test" << std::endl;
	std::cout << "-------------------------------------" << std::endl;

	std::cout << "Opening " << filename << " for reading" << std::endl;
	BinaryFileReader bfr(filename);
	//FlippingBinaryFileReader bfr(filename);

	SimpleObject *so2;
	ListObject *lo2;

	std::cout << std::endl << "Reading SimpleObject:" << std::endl;
	if (AS_FAILED(bfr.read((ISerializable**)&so2)))
	{
		std::cout << "Could not read SimpleObject from file " << filename << std::endl;
		return 1;
	};
	so2->print();

	std::cout << std::endl << "Reading ListObject:" << std::endl;
	if (AS_FAILED(bfr.read((ISerializable**)&lo2)))
	{
		std::cout << "Could not read SimpleObject from file " << filename << std::endl;
		return 1;
	};
	lo2->print();

	//if (lo2->isSubclassOf<ISerializable>())
	//	std::cout << "all your base are belong to use" << std::endl;
	std::cout << "Deserialization successful" << std::endl;

	// Checking that written and read objects are equal
	if (so1.equals(so2))
		std::cout << "Simple objects are identical" << std::endl;
	else
	{
		Comparator c;
		c.printMembersEquality(&so1, so2);
	}
	if (lo1.equals(lo2))
		std::cout << "List objects are identical" << std::endl;
	else
	{
		Comparator c;
		c.printMembersEquality(&lo1, lo2);
	}

	return 0;
}
예제 #19
0
int main(void){
	Comparator<int> ci (123,456);
	cout << ci.max() << endl;
	return 0;
}
TEST(Comparator, CompareTwoEqualFiles)
{
    Comparator comparator;
    ASSERT_TRUE(comparator.compareFiles(FILES_EQUAL_1, FILES_EQUAL_2));
}
    virtual void SetUp() {
      comparator.addUnitIncrementListener(&listener);

      comparator.setThreshold(50);
      comparator.setHysteresis(5);
    }
예제 #22
0
/*
 * 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
예제 #23
0
파일: plot_QCD.C 프로젝트: Andrej-CMS/cmssw
//const char* file2 = "DQM_V0001_R000000001__RelValQCD__FlatPt_15_3000_Fast__ParticleFlow.root";
  const char* file1 = "DQM_V0001_R000000001__A__B__C.root";
  const char* file2 = "DQM_V0001_R000000001__A__B__C.root";

  float ptMin = 0;
  float ptMax = 9999;
 
  Styles styles;
  Style* style1 = styles.spred;
  Style* style2 = styles.spblue;
  Comparator::Mode mode = Comparator::SCALE;

  string outdir = "Plots";

  Comparator comp(file1,
		  dir1.c_str(),
		  file2,
		  dir2.c_str());
  comp.SetStyles(style1, style2, "Particle Flow Met", "Calo Met");

  TCanvas c0("c0", "legend", 400, 200);
  Styles::FormatPad( &c0, false ); 
  comp.Legend().Draw();
  Styles::SavePlot("legend", outdir.c_str() );

  comp.SetAxis(1, -200,200);
  TCanvas c1a("c1a", "DeltaMET");
  Styles::FormatPad( &c1a, false); 
  comp.DrawSlice("delta_et_VS_et_", 0, 1000, mode);
  Styles::SavePlot("deltaMET", outdir.c_str() );

  comp.SetAxis(1, -500,500);