TEST(tagged, float_32) {
ASSERT_EQ(sizeof(uint32_t), sizeof(float32_t));
value_t one = new_float_32(1.0);
ASSERT_TRUE(get_float_32_value(one) == 1.0);
value_t zero = new_float_32(0.0);
ASSERT_TRUE(get_float_32_value(zero) == 0.0);
value_t minus_one = new_float_32(-1.0);
ASSERT_TRUE(get_float_32_value(minus_one) == -1.0);
ASSERT_VALEQ(equal(), value_ordering_compare(one, one));
ASSERT_VALEQ(equal(), value_ordering_compare(zero, zero));
ASSERT_VALEQ(equal(), value_ordering_compare(minus_one, minus_one));
ASSERT_VALEQ(less_than(), value_ordering_compare(minus_one, zero));
ASSERT_VALEQ(less_than(), value_ordering_compare(zero, one));
ASSERT_VALEQ(greater_than(), value_ordering_compare(zero, minus_one));
ASSERT_VALEQ(greater_than(), value_ordering_compare(one, zero));
value_t nan = float_32_nan();
ASSERT_VALEQ(unordered(), value_ordering_compare(nan, nan));
ASSERT_VALEQ(unordered(), value_ordering_compare(nan, one));
ASSERT_VALEQ(unordered(), value_ordering_compare(nan, zero));
ASSERT_VALEQ(unordered(), value_ordering_compare(zero, nan));
ASSERT_VALEQ(unordered(), value_ordering_compare(one, nan));
ASSERT_SAME(nan, nan);
value_t inf = float_32_infinity();
value_t minf = float_32_minus_infinity();
ASSERT_VALEQ(unordered(), value_ordering_compare(nan, inf));
ASSERT_VALEQ(unordered(), value_ordering_compare(inf, nan));
ASSERT_VALEQ(unordered(), value_ordering_compare(nan, minf));
ASSERT_VALEQ(unordered(), value_ordering_compare(minf, nan));
ASSERT_VALEQ(less_than(), value_ordering_compare(one, inf));
ASSERT_VALEQ(greater_than(), value_ordering_compare(inf, one));
ASSERT_VALEQ(greater_than(), value_ordering_compare(one, minf));
ASSERT_VALEQ(less_than(), value_ordering_compare(minf, one));
ASSERT_VALEQ(equal(), value_ordering_compare(inf, inf));
ASSERT_VALEQ(greater_than(), value_ordering_compare(inf, minf));
ASSERT_VALEQ(less_than(), value_ordering_compare(minf, inf));
ASSERT_TRUE(is_float_32_nan(nan));
ASSERT_FALSE(is_float_32_nan(minus_one));
ASSERT_FALSE(is_float_32_nan(zero));
ASSERT_FALSE(is_float_32_nan(one));
ASSERT_FALSE(is_float_32_nan(inf));
ASSERT_FALSE(is_float_32_nan(minf));
ASSERT_FALSE(is_float_32_finite(nan));
ASSERT_TRUE(is_float_32_finite(minus_one));
ASSERT_TRUE(is_float_32_finite(zero));
ASSERT_TRUE(is_float_32_finite(one));
ASSERT_FALSE(is_float_32_finite(inf));
ASSERT_FALSE(is_float_32_finite(minf));
}
void disperse(const std::vector<Element>& collection,
const std::string& name, Handler&& handler, Args&&... args)
{
const auto call = synchronize(FORWARD_HANDLER(handler),
collection.size(), name);
for (const auto& element: collection)
unordered(BIND_ELEMENT(args, element, call));
}
static void
test_unordered(
unsigned int nparticle
, unsigned int nspecies
, unsigned int repeat
)
{
typedef typename test_suite_type::particle_type particle_type;
typedef typename test_suite_type::particle_group_type particle_group_type;
typedef typename particle_group_type::size_type size_type;
typedef typename test_suite_type::all_type all_type;
BOOST_TEST_MESSAGE(" " << "all of " << nparticle << " particles");
BOOST_TEST_MESSAGE(" " << repeat << " iterations");
std::shared_ptr<particle_type> particle = std::make_shared<particle_type>(nparticle, nspecies);
std::shared_ptr<particle_group_type> group = std::make_shared<all_type>(particle);
{
BOOST_CHECK_EQUAL( *group->size(), nparticle );
}
halmd::cache<> size_cache = group->size();
halmd::cache<> unordered_cache = group->unordered();
halmd::accumulator<double> elapsed;
for (size_type i = 0; i < repeat; ++i) {
std::vector<size_type> reverse_tag = make_random_tag(nparticle);
BOOST_CHECK( size_cache == group->size() );
BOOST_CHECK( unordered_cache == group->unordered() );
BOOST_CHECK( set_reverse_tag(
*particle
, reverse_tag.begin()) == reverse_tag.end()
);
{
halmd::scoped_timer<halmd::timer> t(elapsed);
BOOST_CHECK( unordered_cache == group->unordered() );
}
std::vector<size_type> unordered(nparticle);
BOOST_CHECK( get_unordered(
*group
, unordered.begin()) == unordered.end()
);
BOOST_CHECK_EQUAL_COLLECTIONS(
unordered.begin()
, unordered.end()
, boost::make_counting_iterator(size_type(0))
, boost::make_counting_iterator(nparticle)
);
}
BOOST_TEST_MESSAGE( " " << mean(elapsed) * 1e3 << " ± " << error_of_mean(elapsed) * 1e3 << " ms per iteration" );
}
TEST(tagged, relation) {
ASSERT_TRUE(test_relation(less_than(), reLessThan));
ASSERT_TRUE(test_relation(less_than(), reLessThan | reEqual));
ASSERT_FALSE(test_relation(less_than(), reEqual));
ASSERT_FALSE(test_relation(less_than(), reGreaterThan));
ASSERT_FALSE(test_relation(less_than(), reGreaterThan | reEqual));
ASSERT_FALSE(test_relation(less_than(), reUnordered));
ASSERT_FALSE(test_relation(equal(), reLessThan));
ASSERT_TRUE(test_relation(equal(), reLessThan | reEqual));
ASSERT_TRUE(test_relation(equal(), reEqual));
ASSERT_FALSE(test_relation(equal(), reGreaterThan));
ASSERT_TRUE(test_relation(equal(), reGreaterThan | reEqual));
ASSERT_FALSE(test_relation(equal(), reUnordered));
ASSERT_FALSE(test_relation(greater_than(), reLessThan));
ASSERT_FALSE(test_relation(greater_than(), reLessThan | reEqual));
ASSERT_FALSE(test_relation(greater_than(), reEqual));
ASSERT_TRUE(test_relation(greater_than(), reGreaterThan));
ASSERT_TRUE(test_relation(greater_than(), reGreaterThan | reEqual));
ASSERT_FALSE(test_relation(greater_than(), reUnordered));
ASSERT_FALSE(test_relation(unordered(), reLessThan));
ASSERT_FALSE(test_relation(unordered(), reLessThan | reEqual));
ASSERT_FALSE(test_relation(unordered(), reEqual));
ASSERT_FALSE(test_relation(unordered(), reGreaterThan));
ASSERT_FALSE(test_relation(unordered(), reGreaterThan | reEqual));
ASSERT_TRUE(test_relation(unordered(), reUnordered));
}
static value_t custom_tagged_ordering_compare(value_t a, value_t b) {
CHECK_DOMAIN(vdCustomTagged, a);
CHECK_DOMAIN(vdCustomTagged, b);
custom_tagged_phylum_t a_phylum = get_custom_tagged_phylum(a);
custom_tagged_phylum_t b_phylum = get_custom_tagged_phylum(b);
if (a_phylum != b_phylum)
return compare_signed_integers(a_phylum, b_phylum);
phylum_behavior_t *behavior = get_custom_tagged_phylum_behavior(a_phylum);
value_t (*ordering_compare)(value_t a, value_t b) = behavior->ordering_compare;
if (ordering_compare == NULL) {
return unordered();
} else {
return ordering_compare(a, b);
}
}
bool SpansCell::adjust(bool condition)
{
NearSpansUnorderedPtr unordered(_unordered);
if (length != -1)
unordered->totalLength -= length; // subtract old length
if (condition)
{
length = end() - start();
unordered->totalLength += length; // add new length
if (!unordered->max || doc() > unordered->max->doc() || (doc() == unordered->max->doc()) && (end() > unordered->max->end()))
unordered->max = shared_from_this();
}
unordered->more = condition;
return condition;
}
static value_t object_ordering_compare(value_t a, value_t b) {
CHECK_DOMAIN(vdHeapObject, a);
CHECK_DOMAIN(vdHeapObject, b);
heap_object_family_t a_family = get_heap_object_family(a);
heap_object_family_t b_family = get_heap_object_family(b);
if (a_family != b_family)
// This may cause us to return a valid result even when a and b are not
// comparable.
return compare_signed_integers(a_family, b_family);
family_behavior_t *behavior = get_heap_object_family_behavior(a);
value_t (*ordering_compare)(value_t a, value_t b) = behavior->ordering_compare;
if (ordering_compare == NULL) {
return unordered();
} else {
return ordering_compare(a, b);
}
}
value_t value_ordering_compare(value_t a, value_t b) {
value_domain_t a_domain = get_value_domain(a);
value_domain_t b_domain = get_value_domain(b);
if (a_domain != b_domain) {
int a_ordinal = get_value_domain_ordinal(a_domain);
int b_ordinal = get_value_domain_ordinal(b_domain);
return compare_signed_integers(a_ordinal, b_ordinal);
} else {
switch (a_domain) {
case vdInteger:
return integer_ordering_compare(a, b);
case vdHeapObject:
return object_ordering_compare(a, b);
case vdCustomTagged:
return custom_tagged_ordering_compare(a, b);
default:
return unordered();
}
}
}
