SPAR/AIModule/BWTA/vendors/CGAL/CGAL/CORE/Expr.h

Go to the documentation of this file.

/****************************************************************************
 * Core Library Version 1.7, August 2004
 * Copyright (c) 1995-2004 Exact Computation Project
 * All rights reserved.
 *
 * This file is part of CORE (http://cs.nyu.edu/exact/core/); you may
 * redistribute it under the terms of the Q Public License version 1.0.
 * See the file LICENSE.QPL distributed with CORE.
 *
 * Licensees holding a valid commercial license may use this file in
 * accordance with the commercial license agreement provided with the
 * software.
 *
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 *
 * File: Expr.h
 * Synopsis: a class of Expression in Level 3
 * 
 * Written by 
 *       Koji Ouchi <ouchi@simulation.nyu.edu>
 *       Chee Yap <yap@cs.nyu.edu>
 *       Igor Pechtchanski <pechtcha@cs.nyu.edu>
 *       Vijay Karamcheti <vijayk@cs.nyu.edu>
 *       Chen Li <chenli@cs.nyu.edu>
 *       Zilin Du <zilin@cs.nyu.edu>
 *       Sylvain Pion <pion@cs.nyu.edu> 
 *       Vikram Sharma<sharma@cs.nyu.edu>
 *
 * WWW URL: http://cs.nyu.edu/exact/
 * Email: exact@cs.nyu.edu
 *
 * $URL: svn+ssh://scm.gforge.inria.fr/svn/cgal/branches/CGAL-3.5-branch/Core/include/CGAL/CORE/Expr.h $
 * $Id: Expr.h 37555 2007-03-27 11:33:02Z afabri $
 ***************************************************************************/

#ifndef _CORE_EXPR_H_
#define _CORE_EXPR_H_

#include <CGAL/CORE/ExprRep.h>

CORE_BEGIN_NAMESPACE

typedef RCImpl<ExprRep> RCExpr;
class Expr : public RCExpr {
public:


  Expr() : RCExpr(new ConstDoubleRep()) {}
  Expr(int i) : RCExpr(new ConstDoubleRep(i)) {}
  Expr(short i) : RCExpr(new ConstDoubleRep(i)) {}
  Expr(unsigned int ui) : RCExpr(new ConstDoubleRep(ui)) {}

  Expr(long l) : RCExpr(new ConstRealRep(Real(l))) {}
  Expr(unsigned long ul) : RCExpr(new ConstRealRep(Real(ul))) {}


  Expr(float f) : RCExpr(NULL) { // check for valid numbers
    // (i.e., not infinite and not NaN)
    if (!finite(f)) {
      std::cerr << " ERROR : constructed an invalid float! " << std::endl;
      if (AbortFlag)
        abort();
      InvalidFlag = -1;
    }
    rep = new ConstDoubleRep(f);
  }
  Expr(double d) : RCExpr(NULL) { // check for valid numbers
    // (i.e., not infinite and not NaN)
    if (!finite(d)) {
      std::cerr << " ERROR : constructed an invalid double! " << std::endl;
      if (AbortFlag)
        abort();
      InvalidFlag = -2;
    }
    rep = new ConstDoubleRep(d);
  }

  Expr(const BigInt& I) : RCExpr(new ConstRealRep(Real(I))) {}
  Expr(const BigRat& R) : RCExpr(new ConstRealRep(Real(R))) {}

  Expr(const BigFloat& F) : RCExpr(new ConstRealRep(Real(F))) {}


  Expr(const char *s, const extLong& p = defInputDigits)
      : RCExpr(new ConstRealRep(Real(s, p))) {}

  Expr(const std::string& s, const extLong& p = defInputDigits)
      : RCExpr(new ConstRealRep(Real(s, p))) {}

  Expr(const Real &r) : RCExpr(new ConstRealRep(r)) {}


  template <class NT>
  Expr(const Polynomial<NT>& p, int n = 0)
      : RCExpr(new ConstPolyRep<NT>(p, n)) {}

  template <class NT>
  Expr(const Polynomial<NT>& p, const BFInterval& I)
      : RCExpr(new ConstPolyRep<NT>(p, I)) {}

  Expr(ExprRep* p) : RCExpr(p) {}



  Expr(const Expr& rhs) : RCExpr(rhs) {
    rep->incRef();
  }

  Expr& operator=(const Expr& rhs) {
    if (this != &rhs) {
      rep->decRef();
      rep = rhs.rep;
      rep->incRef();
    }
    return *this;
  }
  ~Expr() {
    rep->decRef();
  }



  Expr& operator+=(const Expr& e) {
    *this = new AddRep(rep, e.rep);
    return *this;
  }
  Expr& operator-=(const Expr& e) {
    *this = new SubRep(rep, e.rep);
    return *this;
  }
  Expr& operator*=(const Expr& e) {
    *this = new MultRep(rep, e.rep);
    return *this;
  }
  Expr& operator/=(const Expr& e) {
    if ((e.rep)->getSign() == 0) {
      std::cerr << " ERROR : division by zero ! " << std::endl;
      if (AbortFlag)
        abort();
      InvalidFlag = -3;
    }
    *this = new DivRep(rep, e.rep);
    return *this;
  }



  Expr operator+() const {
    return Expr(*this);
  }
  Expr operator-() const {
    return Expr(new NegRep(rep));
  }
  Expr& operator++() {
    *this += 1;
    return *this;
  }
  Expr operator++(int) {
    Expr t(*this);
    *this += 1;
    return t;
  }
  Expr& operator--() {
    *this -= 1;
    return *this;
  }
  Expr operator--(int) {
    Expr t(*this);
    *this -= 1;
    return t;
  }



  void fromString(const char* s, const extLong& prec = defInputDigits) {
    *this = Expr(s, prec);
  }

  std::string toString(long prec=defOutputDigits, bool sci=false) const {
    return rep->toString(prec, sci);
  }
  //



  int intValue() const {
    return approx(64, 1024).intValue();
  }
  long longValue() const {
    return approx(64, 1024).longValue();
  }
  float floatValue() const {
    return approx(53, 1024).floatValue();
  }

  double doubleValue() const {
    return approx(53, 1024).doubleValue();
  }

  void doubleInterval(double & lb, double & ub) const;
  BigInt BigIntValue() const {
    return rep->BigIntValue();
  }
  BigRat BigRatValue() const {
    return rep->BigRatValue();
  }

  BigFloat BigFloatValue() const {
    return rep->BigFloatValue();
  }




  const Real & approx(const extLong& relPrec = defRelPrec,
                      const extLong& absPrec = defAbsPrec) const {
    return rep->getAppValue(relPrec, absPrec);
  }


  //CONSTANTS:
  static const Expr& getZero();
  static const Expr& getOne();

  static bool hasExactDivision() {
    return true;
  }

  int sign() const {
    return rep->getSign();
  }
  bool isZero() const {
    return sign() == 0;
  }
  Expr abs() const {
    return (sign() >= 0) ? +(*this) : -(*this);
  }

  int cmp(const Expr& e) const {
    return rep == e.rep ? 0 : SubRep(rep, e.rep).getSign();
  }

  ExprRep* Rep() const {
    return rep;
  }
  long getExponent() const {
    return BigFloatValue().exp();
  }
  BigInt getMantissa() const {
    return BigFloatValue().m();
  }

public:


  void  debug(int mode = TREE_MODE, int level = DETAIL_LEVEL,
              int depthLimit = INT_MAX) const;

  enum {LIST_MODE, TREE_MODE, SIMPLE_LEVEL, DETAIL_LEVEL};
};// class Expr

#define CORE_EXPR_ZERO Expr::getZero()

inline std::ostream& operator<<(std::ostream& o, const Expr& e) {
  o << *(const_cast<ExprRep*>(&e.getRep()));
  return o;
}
inline std::istream& operator>>(std::istream& i, Expr& e) {
  Real rVal;
  i >> rVal; // precision is = defInputDigits
  if (i)
    e = rVal;           // only assign when reading is successful.
  return i;
}

BigInt floor(const Expr&, Expr&);
Expr pow(const Expr&, unsigned long);

inline Expr operator+(const Expr& e1, const Expr& e2) {
  return Expr(new AddRep(e1.Rep(), e2.Rep()));
}
inline Expr operator-(const Expr& e1, const Expr& e2) {
  return Expr(new SubRep(e1.Rep(), e2.Rep()));
}
inline Expr operator*(const Expr& e1, const Expr& e2) {
  return Expr(new MultRep(e1.Rep(), e2.Rep()));
}
inline Expr operator/(const Expr& e1, const Expr& e2) {
  if (e2.sign() == 0) {
    std::cerr << " ERROR : division by zero ! " << std::endl;
    if (AbortFlag)
      abort();
    InvalidFlag = -4;
  }
  return Expr(new DivRep(e1.Rep(), e2.Rep()));
}
inline Expr operator%(const Expr& e1, const Expr& e2) {
  Expr result;
  floor(e1/e2, result);
  return result;
}


inline bool operator==(const Expr& e1, const Expr& e2) {
  return e1.cmp(e2) == 0;
}
inline bool operator!=(const Expr& e1, const Expr& e2) {
  return e1.cmp(e2) != 0;
}
inline bool operator< (const Expr& e1, const Expr& e2) {
  return e1.cmp(e2) < 0;
}
inline bool operator<=(const Expr& e1, const Expr& e2) {
  return e1.cmp(e2) <= 0;
}
inline bool operator> (const Expr& e1, const Expr& e2) {
  return e1.cmp(e2) > 0;
}
inline bool operator>=(const Expr& e1, const Expr& e2) {
  return e1.cmp(e2) >= 0;
}

inline int sign(const Expr& e) {
  return e.sign();
}
inline bool isZero(const Expr& e) {
  return e.isZero();
}

inline int cmp(const Expr& e1, const Expr& e2) {
  return e1.cmp(e2);
}
inline Expr abs(const Expr& x) {
  return x.abs();
}
inline Expr fabs(const Expr& x) {
  return abs(x);
}
inline BigInt floor(const Expr& e) {
  Expr tmp;
  return floor(e, tmp);
}
inline BigInt ceil(const Expr& e) {
  return -floor(-e);
}
inline long floorLg(const Expr& e) {
  Expr tmp;
  return floorLg(floor(e));
}
inline long ceilLg(const Expr& e) {
  Expr tmp;
  return ceilLg(ceil(e));
}
inline Expr power(const Expr& e, unsigned long p) {
  return pow(e, p);
}


// NOTE:  The name "isDivisible" is not consistent
//              with the analogous "divisible" predicate in BigInt!
inline bool isDivisible(const Expr& e1, const Expr& e2) {
  Expr result;
  floor(e1/e2, result);
  return (result.sign() == 0);
}

inline Expr sqrt(const Expr& e) {
  if (e.sign() < 0) {
    std::cerr << " ERROR : sqrt of negative value ! " << std::endl;
    if (AbortFlag)
      abort();
    InvalidFlag = -5;
  }
  return Expr(new SqrtRep(e.Rep()));
}

//Following two have been added to make NT=Expr work for Polynomial<NT>
inline Expr gcd(const Expr& /*a*/, const Expr& /*b*/) {
  return Expr(1);
}
inline Expr div_exact(const Expr& x, const  Expr& y) {
  return x/y - x%y;
}

template <class NT>
inline Expr rootOf(const Polynomial<NT>& p, int n = 0) {
  return Expr(p, n);
}

template <class NT>
inline Expr rootOf(const Polynomial<NT>& p, const BFInterval& I) {
  return Expr(p, I);
}
template <class NT>
inline Expr rootOf(const Polynomial<NT>& p, const BigFloat& x,
                const BigFloat& y) {
  return Expr(p, BFInterval(x, y) );
}
template <class NT>
inline Expr rootOf(const Polynomial<NT>& p, double x, double y) {
  return Expr(p, BFInterval(BigFloat(x), BigFloat(y)) );
}
template <class NT>
inline Expr rootOf(const Polynomial<NT>& p, int x, int y) {
  return Expr(p, BFInterval(BigFloat(x), BigFloat(y)) );
}


template <class NT>
inline Expr radical(const NT& n, int m) {
  assert(n>=0 && m>=1);
  if (n == 0 || n == 1 || m == 1)
    return Expr(n);
  Polynomial<NT> Q(m);
  Q.setCoeff(0, -n);
  Q.setCoeff(m, 1);
  return Expr(Q, 0);
}

// We include this file here and not from inside Poly.h,
// because otherwise VC++.net2003 can't compile Expr.cpp
#include <CGAL/CORE/poly/Poly.tcc>

CORE_END_NAMESPACE
#endif // _CORE_EXPR_H_