Making the C++ stuff work for the MipsPro 7.3 compiler.
[blender-staging.git] / extern / solid / include / MT / Interval.h
1 /*
2  * SOLID - Software Library for Interference Detection
3  * 
4  * Copyright (C) 2001-2003  Dtecta.  All rights reserved.
5  *
6  * This library may be distributed under the terms of the Q Public License
7  * (QPL) as defined by Trolltech AS of Norway and appearing in the file
8  * LICENSE.QPL included in the packaging of this file.
9  *
10  * This library may be distributed and/or modified under the terms of the
11  * GNU General Public License (GPL) version 2 as published by the Free Software
12  * Foundation and appearing in the file LICENSE.GPL included in the
13  * packaging of this file.
14  *
15  * This library is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
16  * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
17  *
18  * Commercial use or any other use of this library not covered by either 
19  * the QPL or the GPL requires an additional license from Dtecta. 
20  * Please contact info@dtecta.com for enquiries about the terms of commercial
21  * use of this library.
22  */
23
24 #ifndef INTERVAL_H
25 #define INTERVAL_H
26
27 #if defined (__sgi)
28 #include <assert.h>
29 #else
30 #include <cassert>
31 #endif
32
33 #include <iostream>
34 #include <algorithm>
35
36 namespace MT {
37
38         template <typename Scalar>
39         class Interval {
40         public:
41                 Interval() {}
42                 
43
44 #if _MSC_VER <= 1200
45         explicit Interval(const Scalar& x) 
46                     : m_lb(x), m_ub(x)
47             {}
48         
49  
50                 Interval(const Scalar& lb, const Scalar& ub) 
51                         : m_lb(lb), m_ub(ub)
52                 {
53                         assert(lb <= ub);
54                 }
55 #else
56                 template <typename Scalar2>
57                 explicit Interval(const Scalar2& x) 
58                         : m_lb(x), m_ub(x)
59                 {}
60                 
61                 template <typename Scalar2>
62                 Interval(const Scalar2& lb, const Scalar2& ub) 
63                         : m_lb(lb), m_ub(ub)
64                 {
65                         assert(lb <= ub);
66                 }
67                 
68                 template <typename Scalar2>
69                 Interval(const Interval<Scalar2>& z) 
70                 { 
71                         *this = z; 
72                 }
73                 
74                 template <typename Scalar2>
75                 Interval<Scalar>& operator=(const Interval<Scalar2>& z) 
76                 { 
77                         m_lb = Scalar(z.lower()); 
78                         m_ub = Scalar(z.upper()); 
79                         return *this;
80                 }
81 #endif
82       
83                 
84
85                 Scalar&       lower()       { return m_lb; }
86                 const Scalar& lower() const { return m_lb; }
87                 
88                 Scalar&       upper()       { return m_ub; }
89                 const Scalar& upper() const { return m_ub; }
90                  
91                 Scalar center() const { return (m_lb + m_ub) * Scalar(0.5); } 
92                 Scalar extent() const { return (m_ub - m_lb) * Scalar(0.5); } 
93
94         
95         protected:
96                 Scalar m_lb, m_ub;
97         };
98
99         template <typename Scalar>
100         inline Interval<Scalar> 
101         operator+(const Interval<Scalar>& z1, const Interval<Scalar>& z2)
102         {
103                 return Interval<Scalar>(z1.lower() + z2.lower(), 
104                                                                 z1.upper() + z2.upper());
105         }
106
107         template <typename Scalar>
108         inline Interval<Scalar> 
109         operator-(const Interval<Scalar>& z1, const Interval<Scalar>& z2)
110         {
111                 return Interval<Scalar>(z1.lower() - z2.upper(), 
112                                                                 z1.upper() - z2.lower());
113         }
114         
115         template <typename Scalar>
116         inline std::ostream& 
117         operator<<(std::ostream& os, const Interval<Scalar>& z)
118         {
119                 return os << '[' << z.lower() << ", " << z.upper() << ']';
120         }
121
122         template <typename Scalar>
123         inline Scalar 
124         median(const Interval<Scalar>& z) 
125         {
126                 return (z.lower() + z.upper()) * Scalar(0.5);
127         }
128         
129         template <typename Scalar>
130         inline Scalar 
131         width(const Interval<Scalar>& z) 
132         {
133                 return z.upper() - z.lower();
134         }
135         
136         template <typename Scalar>
137         inline bool 
138         overlap(const Interval<Scalar>& z1, const Interval<Scalar>& z2) 
139         {
140                 return z1.lower() <= z2.upper() && z2.lower() <= z1.upper();
141         }
142
143         template <typename Scalar>
144         inline bool 
145         in(const Interval<Scalar>& z1, const Interval<Scalar>& z2) 
146         {
147                 return z2.lower() <= z1.lower() && z1.upper() <= z2.upper();
148         }
149
150         template <typename Scalar>
151         inline bool 
152         in(Scalar x, const Interval<Scalar>& z) 
153         {
154                 return z.lower() <= x && x <= z.upper();
155         }
156         
157         template <typename Scalar>
158         inline Interval<Scalar> 
159         widen(const Interval<Scalar>& z, const Scalar& x) 
160         {
161                 return Interval<Scalar>(z.lower() - x, z.upper() + x);
162         }       
163                 
164         template<typename Scalar>
165         inline Interval<Scalar>
166         hull(const Interval<Scalar>& z1, const Interval<Scalar>& z2)
167         {
168                 return Interval<Scalar>(GEN_min(z1.lower(), z2.lower()), 
169                                                                 GEN_max(z1.upper(), z2.upper()));
170         }       
171    
172    template<typename Scalar>
173         inline Interval<Scalar>
174         operator+(Scalar x, const Interval<Scalar>& z)
175         {
176                 return Interval<Scalar>(x + z.lower(), x + z.upper());
177         }
178 }
179
180 #endif