mirror of https://github.com/CGAL/cgal
191 lines
6.3 KiB
C++
191 lines
6.3 KiB
C++
/******************************************************************
|
|
* Core Library Version 1.6, June 2003
|
|
* Copyright (c) 1995-2002 Exact Computation Project
|
|
*
|
|
* File: CoreDefs.h
|
|
* Synopsis:
|
|
* This contains useful Core Library global parameters which
|
|
* users may modify at runtime or compile time
|
|
* For each parameter, we provide corresponding methods to
|
|
* modify or examine the values.
|
|
*
|
|
* Written by
|
|
* Chen Li <chenli@cs.nyu.edu>
|
|
* Chee Yap <yap@cs.nyu.edu>
|
|
* Zilin Du <zilin@cs.nyu.edu>
|
|
*
|
|
* WWW URL: http://cs.nyu.edu/exact/
|
|
* Email: exact@cs.nyu.edu
|
|
*
|
|
* $Id$
|
|
*****************************************************************/
|
|
|
|
#ifndef CORE_DEFS_H
|
|
#define CORE_DEFS_H
|
|
|
|
#include <CORE/CoreImpl.h>
|
|
#include <CORE/extLong.h>
|
|
|
|
CORE_BEGIN_NAMESPACE
|
|
|
|
//////////////////////////////////////////////////////////////
|
|
// defined constants
|
|
//////////////////////////////////////////////////////////////
|
|
|
|
/// default accuracy level
|
|
#define DEFAULT_CORE_LEVEL 3
|
|
|
|
/// short hand for positive infinity
|
|
#define CORE_INFTY (CORE_posInfty)
|
|
|
|
//////////////////////////////////////////////////////////////
|
|
// global precision parameters
|
|
//////////////////////////////////////////////////////////////
|
|
|
|
/// Abort Flag -- default value is true
|
|
/** The normal behavior is to abort when an invalid expression
|
|
* is constructed. This flag can be used to turn off this abort.
|
|
* In any case, an error message will be printed */
|
|
extern bool AbortFlag;
|
|
|
|
/// Invalid Flag -- initiallly value is non-negative
|
|
/** If the Abort Flag is false, then the Invalid flag will be set to
|
|
* a negative value whenever an invalid expression is constructed.
|
|
* It is the user's responsibility to check this flag and to make
|
|
* it non-negative again. */
|
|
extern int InvalidFlag;
|
|
|
|
/// Escape Precision in bits
|
|
extern extLong EscapePrec;
|
|
|
|
/// current ur when EscapePrec triggered
|
|
/** this flag becomes negative when default EscapePrec is applied */
|
|
extern long EscapePrecFlag;
|
|
|
|
/// Escape Precision Warning Flag
|
|
/** this flag is true by default, and will cause a warning to be printed
|
|
when EscapePrec is reached */
|
|
extern bool EscapePrecWarning;
|
|
|
|
|
|
|
|
// These following two values determine the precision of computing
|
|
// approximations in Expr.
|
|
|
|
/// default Relative Precision in bits
|
|
extern extLong defRelPrec;
|
|
/// default Absolute Precision in bits
|
|
extern extLong defAbsPrec;
|
|
|
|
/// default # of decimal digits for conversion from a BF to string.
|
|
/** This value cannot be CORE_INFTY.
|
|
See also defOutputDigits.
|
|
*/
|
|
/* QUESTION: the following comment seems to contradict the above comment:
|
|
"controls the printout precision of std::cout for BigFloat"
|
|
Perhaps, we should merge defOutputDigits and defBigFloatOutputDigits?
|
|
*/
|
|
extern long defBigFloatOutputDigits;
|
|
|
|
/// default input precision in digits for converting a string to a Real or Expr
|
|
/** This value can be CORE_INFTY */
|
|
extern extLong defInputDigits;
|
|
|
|
/// controls the printout precision of std::cout for Real and Expr
|
|
/** This value cannot be CORE_INFTY
|
|
See also defBigFloatOutputDigits.
|
|
(it really should be an int, as in std::cout.setprecision(int)). */
|
|
extern long defOutputDigits;
|
|
|
|
/// default input precision in digits for converting a string to a BigFloat
|
|
/** This value cannot be CORE_INFTY. */
|
|
extern long defBigFloatInputDigits;
|
|
|
|
/// default BigFloat Division Relative Precision
|
|
extern extLong defBFdivRelPrec;
|
|
|
|
/// default BigFloat Sqrt Absolute Precision
|
|
extern extLong defBFsqrtAbsPrec;
|
|
|
|
//////////////////////////////////////////////////////////////
|
|
// Mode parameters: incremental, progressive, filters
|
|
//////////////////////////////////////////////////////////////
|
|
|
|
/// floating point filter flag
|
|
extern bool fpFilterFlag;
|
|
/// if true, evaluation of expressions would be incremental
|
|
extern bool incrementalEvalFlag;
|
|
/// progressive evaluation flag
|
|
extern bool progressiveEvalFlag;
|
|
/// rational reduction flag
|
|
extern bool rationalReduceFlag;
|
|
/// default initial (bit) precision for AddSub Progressive Evaluation
|
|
extern long defInitialProgressivePrec;
|
|
|
|
//////////////////////////////////////////////////////////////
|
|
// methods for setting global precision parameters
|
|
// including: scientific vs. positional format
|
|
// All the set methods return the previous global value if any
|
|
//////////////////////////////////////////////////////////////
|
|
|
|
/// set default composite precision [defAbsPrec, defRelPrec]
|
|
/** It determines the precision to which an Expr evaluates its
|
|
(exact, implicit) constant value. */
|
|
CORE_INLINE void setDefaultPrecision(const extLong &r, const extLong &a);
|
|
|
|
/// set default relative precision
|
|
CORE_INLINE extLong setDefaultRelPrecision(const extLong &r);
|
|
|
|
/// set default absolute precision
|
|
CORE_INLINE extLong setDefaultAbsPrecision(const extLong &a);
|
|
|
|
|
|
/// set default input digits (for Expr, Real)
|
|
/** it controls the absolute error */
|
|
CORE_INLINE extLong setDefaultInputDigits(const extLong &d);
|
|
|
|
/// set default output digits (for Expr, Real)
|
|
CORE_INLINE long setDefaultOutputDigits(long d = defOutputDigits,
|
|
std::ostream& o = std::cout);
|
|
|
|
/// set default input digits for BigFloat
|
|
CORE_INLINE long setDefaultBFInputDigits(long d);
|
|
|
|
/// set default output digits for BigFloat
|
|
CORE_INLINE long setDefaultBFOutputDigits(long d);
|
|
|
|
/// turn floating-point filter on/off
|
|
CORE_INLINE bool setFpFilterFlag(bool f);
|
|
|
|
/// turn incremental evaluation flag on/off
|
|
CORE_INLINE bool setIncrementalEvalFlag(bool f);
|
|
|
|
/// turn progressive evaluation flag on/off
|
|
CORE_INLINE bool setProgressiveEvalFlag(bool f);
|
|
|
|
/// set initial bit precision for progressive evaluation:
|
|
CORE_INLINE long setDefInitialProgressivePrec(long n);
|
|
|
|
/// turn rational reduction flag on/off
|
|
CORE_INLINE bool setRationalReduceFlag(bool f);
|
|
|
|
/// CORE_init(..) is the CORE initialization function.
|
|
/** We recommend calling it before anything else. Originally motivated
|
|
by need to get around gnu's compiler bug in which the variable
|
|
"defAbsPrec" was not properly initialized. But it has other uses,
|
|
e.g., overriding the default std::cout precision to our own */
|
|
CORE_INLINE void CORE_init(long d);
|
|
|
|
/// change to scientific output format
|
|
CORE_INLINE void setScientificFormat(std::ostream& o = std::cout);
|
|
|
|
/// change to positional output format
|
|
CORE_INLINE void setPositionalFormat(std::ostream& o = std::cout);
|
|
|
|
#ifdef CORE_ENABLE_INLINES
|
|
#include <CORE/CoreDefs.inl>
|
|
#endif
|
|
|
|
CORE_END_NAMESPACE
|
|
#endif
|