0024428: Implementation of LGPL license

[occt.git] / src / Precision / Precision.lxx

// Created on: 1993-03-08
// Created by: Remi LEQUETTE
// Copyright (c) 1993-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and / or modify it
// under the terms of the GNU Lesser General Public version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.

//=======================================================================
//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
}