0027931: Coding rules, Precision.hxx - eliminate dead code within PRECISION_OBSOLETE...
[occt.git] / src / Precision / Precision.lxx
1 // Created on: 1993-03-08
2 // Created by: Remi LEQUETTE
3 // Copyright (c) 1993-1999 Matra Datavision
4 // Copyright (c) 1999-2014 OPEN CASCADE SAS
5 //
6 // This file is part of Open CASCADE Technology software library.
7 //
8 // This library is free software; you can redistribute it and/or modify it under
9 // the terms of the GNU Lesser General Public License version 2.1 as published
10 // by the Free Software Foundation, with special exception defined in the file
11 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
12 // distribution for complete text of the license and disclaimer of any warranty.
13 //
14 // Alternatively, this file may be used under the terms of Open CASCADE
15 // commercial license or contractual agreement.
16
17 //=======================================================================
18 //function : Angular
19 //purpose  : 
20 //=======================================================================
21
22 inline Standard_Real  Precision::Angular()
23 {
24 #ifdef PRECISION_OBSOLETE
25   static const Standard_Real Precision_Angular        = 1.e-12;
26   return Precision_Angular;
27 #else
28   return 1.e-12;
29 #endif
30 }
31
32
33 //=======================================================================
34 //function : Confusion
35 //purpose  : 
36 //=======================================================================
37
38 inline Standard_Real  Precision::Confusion()
39 {
40 #ifdef PRECISION_OBSOLETE
41   static const Standard_Real Precision_Confusion      = 1.e-7;
42   return Precision_Confusion;
43 #else
44   return 1.e-7;
45 #endif
46 }
47
48
49 //=======================================================================
50 //function : SquareConfusion
51 //purpose  : 
52 //=======================================================================
53 inline Standard_Real Precision::SquareConfusion()
54 {
55   return Confusion() * Confusion();
56 }
57
58
59 //=======================================================================
60 //function : Intersection
61 //purpose  : 
62 //=======================================================================
63
64 inline Standard_Real  Precision::Intersection()
65 {
66 #ifdef PRECISION_OBSOLETE
67   static const Standard_Real Precision_Intersection   = Precision::Confusion() / 100.;
68   return Precision_Intersection;
69 #else
70   return Confusion() * 0.01;
71 #endif
72 }
73
74
75 //=======================================================================
76 //function : Approximation
77 //purpose  : 
78 //=======================================================================
79
80 inline Standard_Real  Precision::Approximation()
81 {
82 #ifdef PRECISION_OBSOLETE
83   static const Standard_Real Precision_Approximation  = Precision::Confusion() * 10.;
84   return Precision_Approximation;
85 #else
86   return Confusion() * 10.;
87 #endif
88 }
89
90
91 //=======================================================================
92 //function : Parametric
93 //purpose  : 
94 //=======================================================================
95
96 inline Standard_Real  Precision::Parametric(const Standard_Real P,
97                                             const Standard_Real T)
98 {
99   return P / T;
100 }
101
102
103 //=======================================================================
104 //function : PConfusion
105 //purpose  : 
106 //=======================================================================
107
108 inline Standard_Real  Precision::PConfusion(const Standard_Real T)
109 {
110   return Parametric(Confusion(),T);
111 }
112
113
114 //=======================================================================
115 //function : PIntersection
116 //purpose  : 
117 //=======================================================================
118
119 inline Standard_Real  Precision::PIntersection(const Standard_Real T)
120 {
121   return Parametric(Intersection(),T);
122 }
123
124
125 //=======================================================================
126 //function : PApproximation
127 //purpose  : 
128 //=======================================================================
129
130 inline Standard_Real  Precision::PApproximation(const Standard_Real T)
131 {
132   return Parametric(Approximation(),T);
133 }
134
135 //=======================================================================
136 //function : Parametric
137 //purpose  : 
138 //=======================================================================
139
140 inline Standard_Real  Precision::Parametric(const Standard_Real P)
141 {
142 #ifdef PRECISION_OBSOLETE
143   static const Standard_Real Precision_DefTangent     = 1.e+2;
144   return Parametric(P,Precision_DefTangent);
145 #else
146   return Parametric(P, 100.);
147 #endif
148 }
149
150
151 //=======================================================================
152 //function : PConfusion
153 //purpose  : 
154 //=======================================================================
155
156 inline Standard_Real  Precision::PConfusion()
157 {
158   return Parametric(Confusion());
159 }
160
161
162 //=======================================================================
163 //function : PIntersection
164 //purpose  : 
165 //=======================================================================
166
167 inline Standard_Real  Precision::PIntersection()
168 {
169   return Parametric(Intersection());
170 }
171
172
173 //=======================================================================
174 //function : PApproximation
175 //purpose  : 
176 //=======================================================================
177
178 inline Standard_Real  Precision::PApproximation()
179 {
180   return Parametric(Approximation());
181 }
182
183 //=======================================================================
184 //function : IsInfinite
185 //purpose  : 
186 //=======================================================================
187
188 inline Standard_Boolean  Precision::IsInfinite(const Standard_Real R)
189 {
190   return Abs(R) >= (0.5*Precision::Infinite());
191 }
192
193 //=======================================================================
194 //function : IsPositiveInfinite
195 //purpose  : 
196 //=======================================================================
197
198 inline Standard_Boolean  Precision::IsPositiveInfinite(const Standard_Real R)
199 {
200   return R >= (0.5*Precision::Infinite());
201 }
202
203 //=======================================================================
204 //function : IsNegativeInfinite
205 //purpose  : 
206 //=======================================================================
207
208 inline Standard_Boolean  Precision::IsNegativeInfinite(const Standard_Real R)
209 {
210   return R <= -(0.5*Precision::Infinite());
211 }
212
213
214 //=======================================================================
215 //function : Infinite
216 //purpose  : 
217 //=======================================================================
218
219 inline Standard_Real  Precision::Infinite()
220 {
221 #ifdef PRECISION_OBSOLETE
222   static const Standard_Real Precision_Infinite       = 1.e+100;
223   static const Standard_Real Precision_InfiniteValue  = 2 * Precision_Infinite;
224   return Precision_InfiniteValue;
225 #else
226   return 2.e+100;
227 #endif
228 }
229