C++ (Cpp) IntervalSet::emptyの例

コード例 #1

ファイル: interval_tests.cpp プロジェクト: 447327642/mesos

TEST(IntervalTest, EmptyInterval)
{
  Interval<int> i1 = (Bound<int>::closed(1), Bound<int>::open(0));

  EXPECT_EQ(1, i1.lower());
  EXPECT_EQ(0, i1.upper());

  Interval<int> i2 = (Bound<int>::open(1), Bound<int>::closed(0));

  EXPECT_EQ(2, i2.lower());
  EXPECT_EQ(1, i2.upper());

  Interval<int> i3 = (Bound<int>::open(0), Bound<int>::open(0));

  EXPECT_EQ(1, i3.lower());
  EXPECT_EQ(0, i3.upper());

  Interval<int> i4 = (Bound<int>::closed(3), Bound<int>::closed(2));

  EXPECT_EQ(3, i4.lower());
  EXPECT_EQ(3, i4.upper());

  IntervalSet<int> set;

  set += i1;

  EXPECT_TRUE(set.empty());
  EXPECT_EQ(0u, set.intervalCount());

  set += i2;

  EXPECT_TRUE(set.empty());
  EXPECT_EQ(0u, set.intervalCount());

  set += i3;

  EXPECT_TRUE(set.empty());
  EXPECT_EQ(0u, set.intervalCount());

  set += i4;

  EXPECT_TRUE(set.empty());
  EXPECT_EQ(0u, set.intervalCount());

  set += (Bound<int>::closed(2), Bound<int>::closed(2));

  EXPECT_TRUE(set.contains(2));
  EXPECT_EQ(1u, set.size());
  EXPECT_EQ(1u, set.intervalCount());

  set += (Bound<int>::closed(0), Bound<int>::open(1));

  EXPECT_TRUE(set.contains(0));
  EXPECT_TRUE(set.contains(2));
  EXPECT_EQ(2u, set.size());
  EXPECT_EQ(2u, set.intervalCount());
}

コード例 #2

ファイル: interval_sets.hpp プロジェクト: WolfgangSt/itl

bool is_disjoint
(
          interval_base_set<SubType,DomainT,Interval,Compare,Alloc>& object,
    const IntervalSet              <DomainT,Interval,Compare,Alloc>& operand
)
{
    typedef interval_base_set<SubType,DomainT,Interval,Compare,Alloc> object_type;
    typedef IntervalSet              <DomainT,Interval,Compare,Alloc> operand_type;
    object_type intersection;

    if(operand.empty())
        return true;

    typename operand_type::const_iterator common_lwb;
    typename operand_type::const_iterator common_upb;

    if(!Set::common_range(common_lwb, common_upb, operand, object))
        return true;

    typename operand_type::const_iterator it = common_lwb;
    while(it != common_upb)
    {
        object.add_intersection(intersection, *it++);
        if(!intersection.empty())
            return false;
    }

    return true; 
}

コード例 #3

ファイル: interval_tests.cpp プロジェクト: 447327642/mesos

TEST(IntervalTest, Intersection)
{
  IntervalSet<int> set;

  set += (Bound<int>::closed(1), Bound<int>::closed(3));

  EXPECT_TRUE(set.contains(1));
  EXPECT_EQ(1u, set.intervalCount());
  EXPECT_EQ(3u, set.size());

  set &= (Bound<int>::open(1), Bound<int>::open(5));

  EXPECT_FALSE(set.contains(1));
  EXPECT_EQ(1u, set.intervalCount());
  EXPECT_EQ(2u, set.size());

  IntervalSet<int> set2;

  set2 += 6;

  set &= set2;

  EXPECT_TRUE(set.empty());
  EXPECT_EQ(0u, set.intervalCount());
}

コード例 #4

ファイル: interval_sets.hpp プロジェクト: WolfgangSt/itl

typename IntervalSet<DomainT,Interval,Compare,Alloc>::interval_type 
enclosure(const IntervalSet<DomainT,Interval,Compare,Alloc>& object)
{
    typedef IntervalSet<DomainT,Interval,Compare,Alloc> IntervalSetT;
    typedef typename IntervalSetT::interval_type interval_type;
    return 
        object.empty() ? neutron<interval_type>::value()
        : (*object.begin()).span(*object.rbegin());
}

コード例 #5

ファイル: chichiri.cpp プロジェクト: lwu/chichiri

pair<DataType, DataType> get_range(IntervalSet& interval, int dimIndex)
{
	assert(!interval.empty());

	int beginIndex = *interval.begin();
	IntervalSet::iterator end = interval.end();
	--end;
	int endIndex = *end;

	assert(beginIndex >= 0 && beginIndex < (int)g_data.size());
	assert(endIndex >= 0 && endIndex < (int)g_data.size());

	return make_pair(
		g_data[beginIndex].first[dimIndex], 
		g_data[endIndex].first[dimIndex]);
}

コード例 #6

ファイル: interval_tests.cpp プロジェクト: 447327642/mesos

TEST(IntervalTest, Subtraction)
{
  IntervalSet<int> set;

  set += (Bound<int>::closed(1), Bound<int>::closed(10));

  EXPECT_EQ(1u, set.intervalCount());
  EXPECT_EQ(10u, set.size());

  set -= 5;

  EXPECT_FALSE(set.contains(5));
  EXPECT_EQ(2u, set.intervalCount());
  EXPECT_EQ(9u, set.size());

  set -= (Bound<int>::closed(2), Bound<int>::closed(8));

  EXPECT_FALSE(set.contains(2));
  EXPECT_FALSE(set.contains(8));
  EXPECT_EQ(2u, set.intervalCount());
  EXPECT_EQ(3u, set.size());

  set -= (Bound<int>::open(0), Bound<int>::open(2));

  EXPECT_FALSE(set.contains(1));
  EXPECT_EQ(1u, set.intervalCount());
  EXPECT_EQ(2u, set.size());

  IntervalSet<int> set2;

  set2 += (Bound<int>::open(5), Bound<int>::closed(10));

  set -= set2;

  EXPECT_TRUE(set.empty());
  EXPECT_EQ(0u, set.intervalCount());
}