// Created on: 1993-03-08
// Created by: Remi LEQUETTE
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2012 OPEN CASCADE SAS
//
// The content of this file is subject to the Open CASCADE Technology Public
// License Version 6.5 (the "License"). You may not use the content of this file
// except in compliance with the License. Please obtain a copy of the License
// at http://www.opencascade.org and read it completely before using this file.
//
// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
//
// The Original Code and all software distributed under the License is
// distributed on an "AS IS" basis, without warranty of any kind, and the
// Initial Developer hereby disclaims all such warranties, including without
// limitation, any warranties of merchantability, fitness for a particular
// purpose or non-infringement. Please see the License for the specific terms
// and conditions governing the rights and limitations under the License.



//=======================================================================
//function : Angular
//purpose  : 
//=======================================================================

inline Standard_Real  Precision::Angular()
{
#ifdef PRECISION_OBSOLETE
  static const Standard_Real Precision_Angular        = 1.e-12;
  return Precision_Angular;
#else
  return 1.e-12;
#endif
}


//=======================================================================
//function : Confusion
//purpose  : 
//=======================================================================

inline Standard_Real  Precision::Confusion()
{
#ifdef PRECISION_OBSOLETE
  static const Standard_Real Precision_Confusion      = 1.e-7;
  return Precision_Confusion;
#else
  return 1.e-7;
#endif
}


//=======================================================================
//function : SquareConfusion
//purpose  : 
//=======================================================================
inline Standard_Real Precision::SquareConfusion()
{
  return Confusion() * Confusion();
}


//=======================================================================
//function : Intersection
//purpose  : 
//=======================================================================

inline Standard_Real  Precision::Intersection()
{
#ifdef PRECISION_OBSOLETE
  static const Standard_Real Precision_Intersection   = Precision::Confusion() / 100.;
  return Precision_Intersection;
#else
  return Confusion() * 0.01;
#endif
}


//=======================================================================
//function : Approximation
//purpose  : 
//=======================================================================

inline Standard_Real  Precision::Approximation()
{
#ifdef PRECISION_OBSOLETE
  static const Standard_Real Precision_Approximation  = Precision::Confusion() * 10.;
  return Precision_Approximation;
#else
  return Confusion() * 10.;
#endif
}


//=======================================================================
//function : Parametric
//purpose  : 
//=======================================================================

inline Standard_Real  Precision::Parametric(const Standard_Real P,
					    const Standard_Real T)
{
  return P / T;
}


//=======================================================================
//function : PConfusion
//purpose  : 
//=======================================================================

inline Standard_Real  Precision::PConfusion(const Standard_Real T)
{
  return Parametric(Confusion(),T);
}


//=======================================================================
//function : PIntersection
//purpose  : 
//=======================================================================

inline Standard_Real  Precision::PIntersection(const Standard_Real T)
{
  return Parametric(Intersection(),T);
}


//=======================================================================
//function : PApproximation
//purpose  : 
//=======================================================================

inline Standard_Real  Precision::PApproximation(const Standard_Real T)
{
  return Parametric(Approximation(),T);
}

//=======================================================================
//function : Parametric
//purpose  : 
//=======================================================================

inline Standard_Real  Precision::Parametric(const Standard_Real P)
{
#ifdef PRECISION_OBSOLETE
  static const Standard_Real Precision_DefTangent     = 1.e+2;
  return Parametric(P,Precision_DefTangent);
#else
  return Parametric(P, 100.);
#endif
}


//=======================================================================
//function : PConfusion
//purpose  : 
//=======================================================================

inline Standard_Real  Precision::PConfusion()
{
  return Parametric(Confusion());
}


//=======================================================================
//function : PIntersection
//purpose  : 
//=======================================================================

inline Standard_Real  Precision::PIntersection()
{
  return Parametric(Intersection());
}


//=======================================================================
//function : PApproximation
//purpose  : 
//=======================================================================

inline Standard_Real  Precision::PApproximation()
{
  return Parametric(Approximation());
}

//=======================================================================
//function : IsInfinite
//purpose  : 
//=======================================================================

inline Standard_Boolean  Precision::IsInfinite(const Standard_Real R)
{
  return Abs(R) >= (0.5*Precision::Infinite());
}

//=======================================================================
//function : IsPositiveInfinite
//purpose  : 
//=======================================================================

inline Standard_Boolean  Precision::IsPositiveInfinite(const Standard_Real R)
{
  return R >= (0.5*Precision::Infinite());
}

//=======================================================================
//function : IsNegativeInfinite
//purpose  : 
//=======================================================================

inline Standard_Boolean  Precision::IsNegativeInfinite(const Standard_Real R)
{
  return R <= -(0.5*Precision::Infinite());
}


//=======================================================================
//function : Infinite
//purpose  : 
//=======================================================================

inline Standard_Real  Precision::Infinite()
{
#ifdef PRECISION_OBSOLETE
  static const Standard_Real Precision_Infinite       = 1.e+100;
  static const Standard_Real Precision_InfiniteValue  = 2 * Precision_Infinite;
  return Precision_InfiniteValue;
#else
  return 2.e+100;
#endif
}