コード例 #1
0
//------------------------------------------------------------------------------
// queryRunwayByChannel() -- find all airports within search area with 'chan'
// channel ILS components.
//------------------------------------------------------------------------------
int AirportLoader::queryRunwayByChannel(const int chan)
{
   double mr2(FLT_MAX);
   if (mrng > 0.0f) mr2 = mrng*mrng;
   
   // compute range**2 to ref point and select all that have range less
   // than maxRange
   nql = 0;
   for (int i = 0; i < nrl; i++) {
      AirportKey* k = static_cast<AirportKey*>(rl[i]);
      k->rng2 = range2(k->lat,k->lon);
      if (k->rng2 < mr2) {
         for (RunwayKey* rwk = k->runways; rwk != 0; rwk = rwk->next) {
            if ( chkRwIlsChan( rwk, chan ) ) {
               ql[nql++] = rwk;
            }
         }
      }
   }

   // sort and limit by range
   rangeSort2();

   // limit number of result records
   if (qlimit > 0 && nql > qlimit) nql = qlimit;

   return nql;
}
コード例 #2
0
TEST(ConsistentHashMapTest, TestGetRange) {
  TestMap test_map;
  typedef std::pair<string, Range<size_t>> node_range_type;
  const string node1("node1");
  test_map.insert(0, node1);
  size_t range = numeric_limits<size_t>::max() / test_map.num_partitions();
  vector<size_t> expected_parts;
  for (unsigned int i = 0; i < test_map.num_partitions(); i++) {
    expected_parts.push_back(range*i);
  }
  vector<size_t> actual_parts = test_map.get_partitions();
  EXPECT_THAT(actual_parts, ContainerEq(expected_parts));

  Range<size_t> range1(0, range - 1);
  Range<size_t> range2(range, range*2 - 1);
  Range<size_t> range3(range*2, range*3 - 1);
  Range<size_t> range4(range*3, numeric_limits<size_t>::max());
  node_range_type range1_node1 = std::make_pair(node1, range1);
  node_range_type range2_node1 = std::make_pair(node1, range2);
  node_range_type range3_node1 = std::make_pair(node1, range3);
  node_range_type range4_node1 = std::make_pair(node1, range4);
  node_range_type tmp;
  EXPECT_TRUE(test_map.get_range(range/2, &tmp).ok());
  EXPECT_EQ(range1_node1, tmp);
  EXPECT_TRUE(test_map.get_range(range + range/2, &tmp).ok());
  EXPECT_EQ(range2_node1, tmp);
  EXPECT_TRUE(test_map.get_range(range*2 + range/2, &tmp).ok());
  EXPECT_EQ(range3_node1, tmp);
  EXPECT_TRUE(test_map.get_range(range*3 + range/2, &tmp).ok());
  EXPECT_EQ(range4_node1, tmp);
}
コード例 #3
0
//------------------------------------------------------------------------------
// queryAirport() -- find airports within search area with minimum runway
// length and airport type.
//------------------------------------------------------------------------------
int AirportLoader::queryAirport(const Airport::AirportType type, const float minRwLen)
{
   double mr2(FLT_MAX);
   if (mrng > 0.0f) mr2 = mrng*mrng;
   
   // compute range**2 to ref point and select all that have range less
   // than maxRange
   nql = 0;
   for (int i = 0; i < nrl; i++) {
      AirportKey* k = static_cast<AirportKey*>(rl[i]);
      if ( type == k->type || type == Airport::ANY ) {
         k->rng2 = range2(k->lat,k->lon);
         if (k->rng2 < mr2) {
            if ( chkRwLen( k, minRwLen ) ) {
               ql[nql++] = k;
            }
         }
      }
   }

   // sort and limit by range
   rangeSort2();

   // limit number of result records
   if (qlimit > 0 && nql > qlimit) nql = qlimit;

   return nql;
}
コード例 #4
0
//------------------------------------------------------------------------------
// queryByFreq() -- find all airports within search area with 'freq' frequency
// ILS components.
//------------------------------------------------------------------------------
int AirportLoader::queryByFreq(const float freq)
{
   double mr2(FLT_MAX);
   if (mrng > 0.0f) mr2 = mrng*mrng;
   
   // compute range**2 to ref point and select all that have range less
   // than maxRange
   nql = 0;
   for (int i = 0; i < nrl; i++) {
      Key* k = rl[i];
      k->rng2 = range2(k->lat,k->lon);
      if (k->rng2 < mr2) {
         if ( chkIlsFreq(static_cast<AirportKey*>(k), freq ) ) {
            ql[nql++] = k;
         }
      }
   }

   // sort and limit by range
   rangeSort2();

   // limit number of result records
   if (qlimit > 0 && nql > qlimit) nql = qlimit;

   return nql;
}
コード例 #5
0
ファイル: yield_1.cpp プロジェクト: BossKwei/temp
// Driver code
int main()
{
    int i; //For really large numbers

    for (; (i=range2(1, 5));)
        printf("control at main :%d\n", i);

    return 0;
}
コード例 #6
0
TEST_F(SimplifiedBackwardsTextIteratorTest, characterAt) {
  const char* bodyContent =
      "<a id=host><b id=one>one</b> not appeared <b id=two>two</b></a>";
  const char* shadowContent =
      "three <content select=#two></content> <content select=#one></content> "
      "zero";
  setBodyContent(bodyContent);
  setShadowContent(shadowContent, "host");

  Element* host = document().getElementById("host");

  EphemeralRangeTemplate<EditingStrategy> range1(
      EphemeralRangeTemplate<EditingStrategy>::rangeOfContents(*host));
  SimplifiedBackwardsTextIteratorAlgorithm<EditingStrategy> backIter1(
      range1.startPosition(), range1.endPosition());
  const char* message1 =
      "|backIter1| should emit 'one' and 'two' in reverse order.";
  EXPECT_EQ('o', backIter1.characterAt(0)) << message1;
  EXPECT_EQ('w', backIter1.characterAt(1)) << message1;
  EXPECT_EQ('t', backIter1.characterAt(2)) << message1;
  backIter1.advance();
  EXPECT_EQ('e', backIter1.characterAt(0)) << message1;
  EXPECT_EQ('n', backIter1.characterAt(1)) << message1;
  EXPECT_EQ('o', backIter1.characterAt(2)) << message1;

  EphemeralRangeTemplate<EditingInFlatTreeStrategy> range2(
      EphemeralRangeTemplate<EditingInFlatTreeStrategy>::rangeOfContents(
          *host));
  SimplifiedBackwardsTextIteratorAlgorithm<EditingInFlatTreeStrategy> backIter2(
      range2.startPosition(), range2.endPosition());
  const char* message2 =
      "|backIter2| should emit 'three ', 'two', ' ', 'one' and ' zero' in "
      "reverse order.";
  EXPECT_EQ('o', backIter2.characterAt(0)) << message2;
  EXPECT_EQ('r', backIter2.characterAt(1)) << message2;
  EXPECT_EQ('e', backIter2.characterAt(2)) << message2;
  EXPECT_EQ('z', backIter2.characterAt(3)) << message2;
  EXPECT_EQ(' ', backIter2.characterAt(4)) << message2;
  backIter2.advance();
  EXPECT_EQ('e', backIter2.characterAt(0)) << message2;
  EXPECT_EQ('n', backIter2.characterAt(1)) << message2;
  EXPECT_EQ('o', backIter2.characterAt(2)) << message2;
  backIter2.advance();
  EXPECT_EQ(' ', backIter2.characterAt(0)) << message2;
  backIter2.advance();
  EXPECT_EQ('o', backIter2.characterAt(0)) << message2;
  EXPECT_EQ('w', backIter2.characterAt(1)) << message2;
  EXPECT_EQ('t', backIter2.characterAt(2)) << message2;
  backIter2.advance();
  EXPECT_EQ(' ', backIter2.characterAt(0)) << message2;
  EXPECT_EQ('e', backIter2.characterAt(1)) << message2;
  EXPECT_EQ('e', backIter2.characterAt(2)) << message2;
  EXPECT_EQ('r', backIter2.characterAt(3)) << message2;
  EXPECT_EQ('h', backIter2.characterAt(4)) << message2;
  EXPECT_EQ('t', backIter2.characterAt(5)) << message2;
}
コード例 #7
0
// rangeSort: first compute range and then uses rangeSort2() to sort.
int Database::rangeSort()
{
   // compute ranges
   for (int i = 0; i < nql; i++) {
      Key* k = ql[i];
      k->rng2 = range2(k->lat,k->lon);
   }

   return rangeSort2();
}
コード例 #8
0
void ofApp::setup()
{
    ofxNet::IPAddressRange range0;
    ofxNet::IPAddressRange range1(Poco::Net::IPAddress("192.168.0.1"));
    ofxNet::IPAddressRange range2(Poco::Net::IPAddress("192.168.0.33"), 23);
    ofxNet::IPAddressRange range3("2001:0db8:85a3::8a2e:0370:7334/64");
    ofxNet::IPAddressRange range4("192.168.5.219/28");
    ofxNet::IPAddressRange range5("2001:0db8:85a3::8a2e:0370:7334");
    ofxNet::IPAddressRange range6("0.0.0.0/31");

    std::cout << toString(range0);
    std::cout << "-----" << std::endl;
    std::cout << toString(range1);
    std::cout << "-----" << std::endl;
    std::cout << toString(range2);
    std::cout << "-----" << std::endl;
    std::cout << toString(range3);
    std::cout << "-----" << std::endl;
    std::cout << toString(range4);
    std::cout << "-----" << std::endl;
    std::cout << toString(range5);
    std::cout << "-----" << std::endl;

    Poco::Net::IPAddress test0("192.168.0.1");
    Poco::Net::IPAddress test1("2001:0db8:85a3::8a2e:0370:7334");
    Poco::Net::IPAddress test2("127.0.0.2");
    Poco::Net::IPAddress test3("10.10.10.2");
    Poco::Net::IPAddress test4("::FFFF");
    Poco::Net::IPAddress test5("0.0.0.1");

    std::cout << toString(range0, test0) << std::endl;
    std::cout << toString(range0, test1) << std::endl;
    std::cout << toString(range0, test2) << std::endl;
    std::cout << toString(range0, test3) << std::endl;
    std::cout << toString(range0, test4) << std::endl;
    std::cout << toString(range0, test4) << std::endl;

    std::cout << toString(range0, test5) << std::endl;
    std::cout << toString(range6, test5) << std::endl;

    ofxNet::IPAddressRange a("192.168.5.219/28");
    ofxNet::IPAddressRange b("192.168.5.219/27");

    std::cout << toString(a, b) << std::endl;
    std::cout << toString(b, a) << std::endl;

}
コード例 #9
0
ファイル: test-various.cpp プロジェクト: mkaguilera/yesquel
void test3(){
  SimplePrng p;
  int i;
  Int v;
  double d1;
  double *ptr1, *ptr2;
  int inrange = 0;
  Int range1(5000);
  Int range2(9000);
  Int maxv(-1);
  int res1, res2;
  Int tmpint;

  for (int j=1; j < TEST3_NOPS; ++j){
    // insert elements
    for (i = 0; i < TEST3_NINSERT; ++i){
      v = Int(p.next() % TEST3_RANGE);
      if (maxv.val < v.val) maxv = v;
      if (range1.val <= v.val && v.val <= range2.val)
        ++inrange; // count number to be deleted
      test3_sl.insert(v, (double)v.val);
      //test3_sl.insert(&v, new double(v));
    }

    // copy skiplist
    SkipList<Int,double> sl2(test3_sl);

    Int todel;
    int n1, n2;
    // delete elements
    for (i = 0; i < TEST3_NDELETE; ++i){
      todel = Int(p.next() % TEST3_RANGE);
      n1 = 0;
      while (!test3_sl.lookupRemove(todel,0, d1)){
        assert((int)d1 == todel.val);
        ++n1;
      }
      n2 = sl2.delRange(todel, 1, todel, 1, 0, 0);
      assert(n1 == n2);
    }

    // check elements
    for (i=0; i < TEST3_RANGE; ++i){
      tmpint.val = i;
      res1 = test3_sl.lookup(tmpint, ptr1);
      res2 = sl2.lookup(tmpint, ptr2);
      assert (res1==res2);
      if (res1==0) assert(*ptr1==*ptr2);
    }
    SkipListNode<Int,double> *it1, *it2;
    it1 = test3_sl.getFirst();
    it2 = sl2.getFirst();
    while (it1 != test3_sl.getLast()){
      assert(it2 != test3_sl.getLast());
      assert(it1->key.val == it2->key.val);
      assert(it1->value == it2->value);
      it1 = test3_sl.getNext(it1);
      it2 = test3_sl.getNext(it2);
    }
    assert(it2 == sl2.getLast());

    // clear lists
    test3_sl.clear(0, 0);
    sl2.clear(0, 0);
  }
}
コード例 #10
0
ファイル: diffoperations.cpp プロジェクト: Axure/TeXstudio
void diffChange(LatexDocument *doc,int ln,int col,bool theirs){
	LatexEditorView *edView=doc->getEditorView();
	QDocumentCursor cursor(doc);
	cursor.moveTo(ln,col);
	
	QList<int> fids;
	fids<<edView->deleteFormat<<edView->insertFormat<<edView->replaceFormat;
	foreach(int fid,fids){
		QFormatRange fr;
		if (cursor.hasSelection()) fr= cursor.line().getOverlayAt((cursor.columnNumber()+cursor.anchorColumnNumber()) / 2,fid);
		else fr = cursor.line().getOverlayAt(cursor.columnNumber(),fid);
		if (fr.length>0 ) {
			QDocumentCursor range=diffSearchBoundaries(doc,ln,col,fid);
			cursor.moveTo(range.lineNumber(),range.columnNumber());
			
			QVariant var=cursor.line().getCookie(QDocumentLine::DIFF_LIST_COOCKIE);
			if(var.isValid()){
				DiffList diffList=var.value<DiffList>();
				//QString word=cursor.line().text().mid(fr.offset,fr.length);
				DiffOp op;
				
				QList<DiffOp>::iterator i;
				for (i = diffList.begin(); i != diffList.end(); ++i){
					op=*i;
					if(op.start<=cursor.columnNumber() && op.start+op.length>=cursor.columnNumber()){
						break;
					}
				}
				QStringList splitText;
				if(i!=diffList.end()){
					QString txt;
					QString altText;
					int ln2;
					QDocumentCursor range2(doc);
					if(theirs){
						switch(op.type){
						case DiffOp::Delete:
							range.beginBoundary(ln2,col);
							range.endBoundary(ln,col);
							if(ln2-ln==0){
								range2=diffSearchBoundaries(doc,ln,col,edView->insertFormat);
								diffChangeOpType(range2,DiffOp::Inserted);
							}
							range.removeSelectedText();
							diffList.erase(i);
							cursor.line().setCookie(QDocumentLine::DIFF_LIST_COOCKIE,QVariant::fromValue<DiffList>(diffList));
							break;
						case DiffOp::Insert:
							//op.type=DiffOp::Inserted;
							//*i=op;
							range.endBoundary(ln,col);
							range.beginBoundary(ln2,col);
							
							diffChangeOpType(range,DiffOp::Inserted);
							if((ln2-ln==0)&&(col>0)){
								range2=diffSearchBoundaries(doc,ln2,col-1,edView->deleteFormat);
								range2.removeSelectedText();
								diffChangeOpType(range2,DiffOp::Deleted);
							}
							break;
						case DiffOp::Replace:
							altText=diffCollectText(range);
							txt=range.selectedText();
							range.removeSelectedText();
							range.insertText(altText);
							op.type=DiffOp::Replaced;
							op.text=txt;
							splitText=txt.split("\n");
							op.length=splitText.first().length();
							*i=op;
							cursor.line().setCookie(QDocumentLine::DIFF_LIST_COOCKIE,QVariant::fromValue<DiffList>(diffList));
							break;
						default:
							;
						} // end theirs
					}else{
						switch(op.type){
						case DiffOp::Delete:
							//op.type=DiffOp::NotDeleted;
							//*i=op;
							range.beginBoundary(ln2,col);
							range.endBoundary(ln,col);
							if(ln2-ln==0){
								range2=diffSearchBoundaries(doc,ln,col,edView->insertFormat);
								range2.removeSelectedText();
							}
							diffChangeOpType(range,DiffOp::NotDeleted);
							break;
						case DiffOp::Insert:
							range.endBoundary(ln,col);
							range.beginBoundary(ln2,col);
							if((ln2-ln==0)&&(col>0)){
								range2=diffSearchBoundaries(doc,ln2,col-1,edView->deleteFormat);
								diffChangeOpType(range2,DiffOp::NotDeleted);
							}
							range.removeSelectedText();
							diffList.erase(i);
							cursor.line().setCookie(QDocumentLine::DIFF_LIST_COOCKIE,QVariant::fromValue<DiffList>(diffList));
							if(range.line().text().isEmpty())
								range.eraseLine();
							//if(removeLine)
							//    cursor.deletePreviousChar();
							break;
						case DiffOp::Replace:
							//op.type=DiffOp::NotReplaced;
							//*i=op;
							diffChangeOpType(range,DiffOp::NotReplaced);
							break;
						default:
							;
						}
					} // end mine
					
				}
			}
			return;
		} // if fr.length>0
	}
コード例 #11
0
ファイル: ChapelRange.c プロジェクト: chapel-lang/pychapel
/* ChapelRange.chpl:140 */
static void _build_range2(int64_t bound, _ref_range_int64_t_boundedLow_F _retArg, int64_t _ln, c_string _fn) {
  range_int64_t_boundedLow_F wrap_call_tmp;
  wrap_call_tmp = range2(bound, bound, INT64(1), INT64(0), false, _ln, _fn);
  *(_retArg) = wrap_call_tmp;
  return;
}
コード例 #12
0
TEST_F(SimplifiedBackwardsTextIteratorTest, copyTextTo) {
  const char* bodyContent =
      "<a id=host><b id=one>one</b> not appeared <b id=two>two</b></a>";
  const char* shadowContent =
      "three <content select=#two></content> <content select=#one></content> "
      "zero";
  setBodyContent(bodyContent);
  setShadowContent(shadowContent, "host");

  Element* host = document().getElementById("host");
  const char* message =
      "|backIter%d| should have emitted '%s' in reverse order.";

  EphemeralRangeTemplate<EditingStrategy> range1(
      EphemeralRangeTemplate<EditingStrategy>::rangeOfContents(*host));
  SimplifiedBackwardsTextIteratorAlgorithm<EditingStrategy> backIter1(
      range1.startPosition(), range1.endPosition());
  BackwardsTextBuffer output1;
  backIter1.copyTextTo(&output1, 0, 2);
  EXPECT_EQ("wo", String(output1.data(), output1.size()))
      << String::format(message, 1, "wo").utf8().data();
  backIter1.copyTextTo(&output1, 2, 1);
  EXPECT_EQ("two", String(output1.data(), output1.size()))
      << String::format(message, 1, "two").utf8().data();
  backIter1.advance();
  backIter1.copyTextTo(&output1, 0, 1);
  EXPECT_EQ("etwo", String(output1.data(), output1.size()))
      << String::format(message, 1, "etwo").utf8().data();
  backIter1.copyTextTo(&output1, 1, 2);
  EXPECT_EQ("onetwo", String(output1.data(), output1.size()))
      << String::format(message, 1, "onetwo").utf8().data();

  EphemeralRangeTemplate<EditingInFlatTreeStrategy> range2(
      EphemeralRangeTemplate<EditingInFlatTreeStrategy>::rangeOfContents(
          *host));
  SimplifiedBackwardsTextIteratorAlgorithm<EditingInFlatTreeStrategy> backIter2(
      range2.startPosition(), range2.endPosition());
  BackwardsTextBuffer output2;
  backIter2.copyTextTo(&output2, 0, 2);
  EXPECT_EQ("ro", String(output2.data(), output2.size()))
      << String::format(message, 2, "ro").utf8().data();
  backIter2.copyTextTo(&output2, 2, 3);
  EXPECT_EQ(" zero", String(output2.data(), output2.size()))
      << String::format(message, 2, " zero").utf8().data();
  backIter2.advance();
  backIter2.copyTextTo(&output2, 0, 1);
  EXPECT_EQ("e zero", String(output2.data(), output2.size()))
      << String::format(message, 2, "e zero").utf8().data();
  backIter2.copyTextTo(&output2, 1, 2);
  EXPECT_EQ("one zero", String(output2.data(), output2.size()))
      << String::format(message, 2, "one zero").utf8().data();
  backIter2.advance();
  backIter2.copyTextTo(&output2, 0, 1);
  EXPECT_EQ(" one zero", String(output2.data(), output2.size()))
      << String::format(message, 2, " one zero").utf8().data();
  backIter2.advance();
  backIter2.copyTextTo(&output2, 0, 2);
  EXPECT_EQ("wo one zero", String(output2.data(), output2.size()))
      << String::format(message, 2, "wo one zero").utf8().data();
  backIter2.copyTextTo(&output2, 2, 1);
  EXPECT_EQ("two one zero", String(output2.data(), output2.size()))
      << String::format(message, 2, "two one zero").utf8().data();
  backIter2.advance();
  backIter2.copyTextTo(&output2, 0, 3);
  EXPECT_EQ("ee two one zero", String(output2.data(), output2.size()))
      << String::format(message, 2, "ee two one zero").utf8().data();
  backIter2.copyTextTo(&output2, 3, 3);
  EXPECT_EQ("three two one zero", String(output2.data(), output2.size()))
      << String::format(message, 2, "three two one zero").utf8().data();
}