isolating_interval.h

很多二维 三维几何计算算法 C++ 类库

    default:
      return This();
    };
  }

  This second_overlap_interval(const This &o) const
  {
    CGAL_Polynomial_assertion(lb() <= ub());
    CGAL_Polynomial_assertion(o.lb() <= o.ub());
    Order ord= order(o);
    switch(ord) {
    case CONTAINS:
      return This(o.lb(), o.ub());
    case BELOW:
      return This(o.lb(), ub());
    case ABOVE:
      return This(o.ub(), ub());
    default:
      return This();
    };
  }

  This third_overlap_interval(const This &o) const
  {
    CGAL_Polynomial_assertion(lb() <= ub());
    CGAL_Polynomial_assertion(o.lb() <= o.ub());
    Order ord= order(o);
    switch(ord) {
    case CONTAINS:
      return This(o.ub(), ub());
    default:
      return This();
    };
  }

  /*std::pair<This, This> split_with(const This &o) const {
    bool I_would_like_to_get_rid_of_this;
    CGAL_precondition(0);
    Order ord= order(o);
    typedef std::pair<This, This> IP;
    switch(ord){
    case STRICTLY_BELOW:
    return IP(*this, endpoint_interval(UPPER));
    case STRICTLY_ABOVE:
    return IP(endpoint_interval(LOWER, *this));
    case BELOW:
    return IP(This(lb(), o.lb()), This(ub(), o.ub()));
    case CONTAINS:
    return IP(This(lb(), o.lb()), This();
    }
    }*/

  //! Split this and o into 3 parts
  /*!
    this and o must overlap and this must be below or containing o.
    Then the three regions created by the 4 endpoints are returned.
  */
  /*
    void subintervals(const This &o, This &a, This &b, This &c) const {
    bool I_would_like_to_get_rid_of_this;

    Order ord= order(o);
    switch (ord){
    case BELOW:
    a=This(lb(), o.lb());
    b=This(o.lb(), ub());
    c=This(ub(), o.ub());
    break;
    case CONTAINS:
    a=This(lb, o.lb());
    b=o;
    c=This(o.ub(), ub());
    break;
    case CONTAINED:
    a=This(o.lb, lb());
    b=*this;
    c=This(ub(), o.ub());
    break;
    case ABOVE:
    a=This(o.lb(), lb());
    b=This(lb(), o.ub());
    c=This(o.ub(), ub());
    break;
    case STRICTLY_BELOW:
    a=*this;
    b=This(ub(), o.lb());
    c=o;
    break;
    case STRICTLY_ABOVE:
    a=o;
    b=This(o.ub(), lb());
    c=*this;
    break;
    default:
    CGAL_assertion(0);
    }
    CGAL_postcondition(a.ub()==b.lb());
    CGAL_postcondition(b.ub()==c.lb());
    }*/

  /**/
  bool operator<(const This &o) const
  {
    CGAL_Polynomial_assertion(lb() <= ub());
    CGAL_Polynomial_assertion(o.lb() <= o.ub());
    if (ub() < o.lb()) return true;
    return (ub() == o.lb() && (!is_singular() || !o.is_singular()));
    /*
      if (ub() == o.lb() && (!is_singular() || !o.is_singular())) return true;
      else return false;
    */
  }
  bool operator>(const This &o) const
  {
    CGAL_Polynomial_assertion(lb() <= ub());
    CGAL_Polynomial_assertion(o.lb() <= o.ub());
    return o < *this;
  }
  bool operator>=(const This &o) const
  {
    CGAL_Polynomial_assertion(lb() <= ub());
    CGAL_Polynomial_assertion(o.lb() <= o.ub());
    return *this >0 || *this==o;
  }
  bool operator<=(const This &o) const
  {
    CGAL_Polynomial_assertion(lb() <= ub());
    CGAL_Polynomial_assertion(o.lb() <= o.ub());
    return *this < 0 || *this==o;
  }
  bool operator==(const This &o) const
  {
    CGAL_Polynomial_assertion(lb() <= ub());
    CGAL_Polynomial_assertion(o.lb() <= o.ub());
    return lb()==o.lb() && ub()==o.ub();
  }
  bool operator!=(const This &o) const
  {
    CGAL_Polynomial_assertion(lb() <= ub());
    CGAL_Polynomial_assertion(o.lb() <= o.ub());
    return lb()!=o.lb() || ub()!=o.ub();
  }

  //! Approximate the width with doubles.
  double approximate_width() const
  {
    CGAL_Polynomial_assertion(lb() <= ub());
    return (std::max)(to_double(ub()) - to_double(lb()), 0.0);
  }

  double approximate_relative_width() const
  {
    CGAL_Polynomial_assertion(lb() <= ub());
    return approximate_width()/(std::max)(to_double(abs(ub())), to_double(abs(lb())));
  }

  bool contains(const This &o) {
    CGAL_Polynomial_assertion(lb() <= ub());
    return lb() <= o.lb() && ub() >= o.ub();
  }

  bool contains(const NT &o) {
    return lb() <= o && ub() >= o;
  }

  template <class OStream>
  void write(OStream &out) const
  {
    if (is_singular()) {
      out << lb();
    }
    else {
      out << "(" << lb() << "..." << ub() << ")";
    }
    if (0) print();
  }
  void print() const ;

  This operator-() const
  {
    CGAL_Polynomial_assertion(lb() <= ub());
    return This(-ub(), -lb());
  }

  //! return an interval
  std::pair<double, double> double_interval() const
  {
    CGAL_Polynomial_assertion(lb() <= ub());
    std::pair<double, double>
      lbi= CGAL_POLYNOMIAL_TO_INTERVAL(lb()),
      ubi= CGAL_POLYNOMIAL_TO_INTERVAL(ub());
    return std::pair<double, double>(lbi.first, ubi.second);
  }

  const NT& lower_bound() const
  {
    CGAL_Polynomial_assertion(lb() <= ub());
    //    bool not_recommended;
    return lb();
  }
  const NT& upper_bound() const
  {
    CGAL_Polynomial_assertion(lb() <= ub());
    //    bool not_recommended;
    return ub();
  }

  void set_upper(const NT& u) {
    CGAL_Polynomial_assertion(lb() <= ub());
    b_.second = u;
  }

  void set_lower(const NT& l) {
    CGAL_Polynomial_assertion(lb() <= ub());
    b_.first = l;
  }

  /*std::pair<NT, NT> () const {
    return std::pair<NT,NT>(b_.first, b_.second);
    }*/

  //! find the min interval containing both.
  /*This operator||(const This &o){
    return This((std::min)(lb(), o.lb()), (std::max)(ub(), o.ub()));
    }*/

  //! Union
  This operator||(const This &o) const
  {
    CGAL_Polynomial_assertion(lb() <= ub());
    return This((std::min)(lb(), o.lb()), (std::max)(ub(), o.ub()));
  }

  NT middle() const
  {
    CGAL_Polynomial_assertion(lb() <= ub());
    return NT(0.5)*(ub()+lb());
  }

  const std::pair<NT,NT>& to_pair() const {
    return b_;
  }

protected:
  std::pair<NT,NT> b_;

  NT midpoint(const NT& a, const NT& b) const
  {
    return NT(0.5)*(a+b);
  }

  const NT &lb() const
  {
    return b_.first;
  }
  const NT &ub() const
  {
    return b_.second;
  }

  /*static NT infinity() {
    if (std::numeric_limits<NT>::has_infinity){
    return std::numeric_limits<NT>::infinity();
    } else if (std::numeric_limits<NT>::is_bounded){
    return (std::numeric_limits<NT>::max)();
    } else {
    return NT(1000000000);
    }
    }*/
};

template <class NT>
void Isolating_interval<NT>::print() const
{
  write(std::cout);
  std::cout << std::endl;
}


template <class OStream, class NT>
OStream &operator<<(OStream &out, const Isolating_interval<NT> &ii)
{
  ii.write(out);
  return out;
}


/*template <class NT>
  std::pair<double, double> to_interval(const Isolating_interval<NT> &ii){
  return ii.to_interval();
  }*/

CGAL_POLYNOMIAL_END_INTERNAL_NAMESPACE

#ifdef CGAL_POLYNOMIAL_USE_CGAL

CGAL_BEGIN_NAMESPACE
template <class NT>
std::pair<double, double> to_interval(const typename CGAL_POLYNOMIAL_NS::internal::Isolating_interval<NT> &ii)
{
  return ii.double_interval();
}


CGAL_END_NAMESPACE
#endif
#endif