Example #1
0
// FIXME It actually performs intersection which is inconsistent with intersect
bool sqr_inverse(interval& z, interval& x, interval& gap) {

	bool has_gap = false;

	const interval x_1 = sqrt(z);

	const interval x_2 = -x_1;

	interval x_image;

	if (disjoint(x, x_2)) {

		x_image = x_1;
	}
	else if (disjoint(x, x_1)) {

		x_image = x_2;
	}
	else {

		gap = interval(x_2.sup(), x_1.inf());

		has_gap = gap.diameter() > IMPROVEMENT_TOL; // FIXME GAP_SQRT_TOL ?

		x_image = hull_of(x_1, x_2);
	}

	x.intersect(x_image);

	z.intersect(sqr(x));

	return has_gap;
}
inline bool RuleIntroductionSolver::isIntroducedRuleSatisfied(const Hypergraph::Vertices& trueAtoms, const Hypergraph::Vertices& falseAtoms) const
{
	assert(heads.find(introducedRule) != heads.end());
	assert(positiveBody.find(introducedRule) != positiveBody.end());
	assert(negativeBody.find(introducedRule) != negativeBody.end());
	return !disjoint(heads.at(introducedRule), trueAtoms) || !disjoint(positiveBody.at(introducedRule), falseAtoms) || !disjoint(negativeBody.at(introducedRule), trueAtoms);
}
Example #3
0
void RdfDB::bindVariables (ResultSet* rs, const POS* graph, const BasicGraphPattern* toMatch) {
    if (graph == NULL) graph = DefaultGraph;
    graphmap_type::const_iterator vi;
    size_t matched = 0;

    /* Look in each candidate graph. */
    if (graph->isConstant()) {
        if ((vi = graphs.find(graph)) != graphs.end()) {
            vi->second->bindVariables(rs, graph, toMatch, vi->first);
            ++matched;
        }
    } else {
        ResultSet island(rs->getPOSFactory());
        delete *(island.begin());
        island.erase(island.begin());
        for (vi = graphs.begin(); vi != graphs.end(); vi++)
            if (vi->first != DefaultGraph) {
                ResultSet disjoint(rs->getPOSFactory());
                vi->second->bindVariables(&disjoint, graph, toMatch, vi->first);
                for (ResultSetIterator row = disjoint.begin() ; row != disjoint.end(); ) {
                    island.insert(island.end(), (*row)->duplicate(&island, island.end()));
                    delete *row;
                    row = disjoint.erase(row);
                }
                ++matched;
            }
        rs->joinIn(&island, false);
    }
    if (matched == 0)
        for (ResultSetIterator it = rs->begin(); it != rs->end(); ) {
            delete *it;
            it = rs->erase(it);
        }
}
Example #4
0
File: 496.c Project: gs0622/uva
void compare(char *a, char *b)
{
    if (equal(a, b)) printf("A equals B\n");
    else if (contain(a, b)) printf("B is a proper subset of A\n");
    else if (contain(b, a)) printf("A is a proper subset of B\n");
    else if (disjoint(a, b)) printf("A and B are disjoint\n");
    else printf("I'm confused!\n");
}
typename mpfr_bin_ieee754_flavor<T>::representation
mpfr_bin_ieee754_flavor<T>::intersection(mpfr_bin_ieee754_flavor<T>::representation const& x,
                                      mpfr_bin_ieee754_flavor<T>::representation const& y)
{
    if (!is_valid(x) || !is_valid(y))
        return empty();

    if (disjoint(x, y))
        return empty();
    else
        return representation(std::max(x.first, y.first),
                              std::min(x.second, y.second));
}
void interval_set_operators_4_bicremental_types()
{
    typedef IntervalSet<T> IntervalSetT;
    typedef typename IntervalSetT::interval_type IntervalT;
    T v0 = make<T>(0);
    T v1 = make<T>(1);
    T v3 = make<T>(3);
    T v5 = make<T>(5);
    T v7 = make<T>(7);
    T v8 = make<T>(8);
    IntervalSet<T> left, left2, right, all, all2, section, complement, naught;
    left.add(IntervalT::closed(v0,v1)).add(IntervalT::closed(v3,v5));
    (right += IntervalT::closed(v3,v5)) += IntervalT::closed(v7,v8);

    BOOST_CHECK_EQUAL( disjoint(left, right), false );

    (all += left) += right;
    (section += left) &= right;
    (complement += all) -= section;
    (all2 += section) += complement; 

    BOOST_CHECK_EQUAL( disjoint(section, complement), true );
    BOOST_CHECK_EQUAL( all, all2 );

    BOOST_CHECK_EQUAL( icl::contains(all, left), true );
    BOOST_CHECK_EQUAL( icl::contains(all, right), true );
    BOOST_CHECK_EQUAL( icl::contains(all, complement), true );

    BOOST_CHECK_EQUAL( icl::contains(left, section), true );
    BOOST_CHECK_EQUAL( icl::contains(right, section), true );

    BOOST_CHECK_EQUAL( within(left, all), true );
    BOOST_CHECK_EQUAL( within(right, all), true );
    BOOST_CHECK_EQUAL( within(complement, all), true );
    BOOST_CHECK_EQUAL( within(section, left), true );
    BOOST_CHECK_EQUAL( within(section, right), true );
}
void interval_set_mixed_disjoint_4_bicremental_types()
{         
    typedef interval_set<T> IntervalSetT;
    typedef typename IntervalSetT::interval_type IntervalT;

    T v0 = make<T>(0);    
    T v2 = make<T>(2);
    T v3 = make<T>(3);
    T v4 = make<T>(4);    
    T v6 = make<T>(6);
   
    IntervalT I0_2D = IntervalT::right_open(v0,v2);
    IntervalT I2_3D = IntervalT::right_open(v2,v3);
    IntervalT I3_4D = IntervalT::right_open(v3,v4);
    IntervalT I4_4I = IntervalT::closed(v4,v4);
    IntervalT C4_6D = IntervalT::open(v4,v6);
    IntervalT I6_6I = IntervalT::closed(v6,v6);

    //--------------------------------------------------------------------------
    //split_A: [0  2)          [4 4]      [6 6]
    //split_B:       [2 3)[3 4)     (4  6)
    split_interval_set<T> split_A, split_B;

    split_A.add(I0_2D).add(I4_4I).add(I6_6I);
    split_B.add(I2_3D).add(I3_4D).add(C4_6D);

    separate_interval_set<T> sep_A(split_A), sep_B(split_B);
    interval_set<T> join_A(split_A), join_B(split_B);

    BOOST_CHECK_EQUAL( disjoint(split_A, split_B), true );
    BOOST_CHECK_EQUAL( disjoint(split_A, sep_B),   true );
    BOOST_CHECK_EQUAL( disjoint(split_A, join_B),  true );

    BOOST_CHECK_EQUAL( disjoint(sep_A,   split_B), true );
    BOOST_CHECK_EQUAL( disjoint(sep_A,   sep_B),   true );
    BOOST_CHECK_EQUAL( disjoint(sep_A,   join_B),  true );

    BOOST_CHECK_EQUAL( disjoint(join_A,  split_B), true );
    BOOST_CHECK_EQUAL( disjoint(join_A,  sep_B),   true );
    BOOST_CHECK_EQUAL( disjoint(join_A,  join_B),  true );
}
Example #8
0
// expand index set by s1.
// it is assumed that s1 is disjoint from the current index set.
void DoubleCRT::addPrimes(const IndexSet& s1)
{
  if (empty(s1)) return; // nothing to do
  assert( disjoint(s1,map.getIndexSet()) ); // s1 is disjoint from *this

  ZZX poly;
  toPoly(poly); // recover in coefficient representation

  map.insert(s1);  // add new rows to the map
  if (dryRun) return;

  // fill in new rows
  for (long i = s1.first(); i <= s1.last(); i = s1.next(i)) {
    context.ithModulus(i).FFT(map[i], poly); // reduce mod p_i and store FFT image
  }
}
  ExecStatus
  EqInt<VY>::propagate(Space& home, const ModEventDelta& med) {
    // Add assigned views to value set
    if (IntView::me(med) == ME_INT_VAL)
      add(home);

    GECODE_ME_CHECK(y.gq(home, vs.size()));
    GECODE_ME_CHECK(y.lq(home, x.size() + vs.size()));

    if (x.size() == 0) 
      return home.ES_SUBSUMED(*this);

    // All values must be in the value set
    if (y.max() == vs.size())
      return all_in_valset(home);

    // Compute positions of disjoint views and eliminate subsumed views
    Region r(home);
    int* dis; int n_dis;
    disjoint(home,r,dis,n_dis);

    // The number might have changed due to elimination of subsumed views
    GECODE_ME_CHECK(y.lq(home, x.size() + vs.size()));

    if (x.size() == 0) {
      assert(y.val() == vs.size());
      return home.ES_SUBSUMED(*this);
    }

    GECODE_ES_CHECK(prune_upper(home,g));

    // No lower bound pruning possible
    if (n_dis == 0)
      return ES_NOFIX;

    // Only if the propagator is at fixpoint here, continue with
    // propagating the lower bound
    if (IntView::me(Propagator::modeventdelta()) != ME_INT_NONE)
      return ES_NOFIX;

    // Do lower bound-based pruning
    GECODE_ES_CHECK(prune_lower(home,dis,n_dis));

    return ES_NOFIX;
  }
Example #10
0
  ExecStatus
  LqInt<VY>::propagate(Space& home, const ModEventDelta& med) {
    // Add assigned views to value set
    if (IntView::me(med) == ME_INT_VAL)
      add(home);

    GECODE_ME_CHECK(y.gq(home, vs.size()));

    if (x.size() == 0)
      return home.ES_SUBSUMED(*this);

    // All values must be in the value set
    if (y.max() == vs.size())
      return all_in_valset(home);

    if (x.size() + vs.size() <= y.min())
      return home.ES_SUBSUMED(*this);
      
    // Compute positions of disjoint views
    Region r(home);
    int* dis; int n_dis;
    disjoint(home,r,dis,n_dis);

    // Some views might have been eliminated as they are subsumed
    if (x.size() == 0)
      return home.ES_SUBSUMED(*this);

    // No lower bound pruning possible
    if (n_dis == 0)
      return ES_NOFIX;

    // Do lower bound-based pruning
    GECODE_ES_CHECK(prune_lower(home,dis,n_dis));

    return ES_NOFIX;
  }
Example #11
0
	bool pool::is_same_species(const genome& g1, const genome& g2){
		double dd = this->speciating_parameters.delta_disjoint * disjoint(g1, g2);
		double dw = this->speciating_parameters.delta_weights * weights(g1, g2);
		return dd + dw < this->speciating_parameters.delta_threshold;
	}
Example #12
0
inline bool RuleIntroductionSolver::doesIntroducedRuleDisappear(const Hypergraph::Vertices& trueAtoms) const
{
	assert(negativeBody.find(introducedRule) != negativeBody.end());
	return !disjoint(negativeBody.at(introducedRule), trueAtoms);
}
Example #13
0
bool samespecies(Genome* g1, Genome* g2)
{
	return disjoint(g1, g2) * DeltaDisjoint + weightdiff(g1, g2) * DeltaWeights < DeltaThreshold;
}