Added the Solid 3.5 sources to the blender source tree.
[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 #include <cassert>
28 #include <iostream>
29 #include <algorithm>
30
31 namespace MT {
32
33         template <typename Scalar>
34         class Interval {
35         public:
36                 Interval() {}
37                 
38
39 #if _MSC_VER <= 1200
40         explicit Interval(const Scalar& x) 
41                     : m_lb(x), m_ub(x)
42             {}
43         
44  
45                 Interval(const Scalar& lb, const Scalar& ub) 
46                         : m_lb(lb), m_ub(ub)
47                 {
48                         assert(lb <= ub);
49                 }
50 #else
51                 template <typename Scalar2>
52                 explicit Interval(const Scalar2& x) 
53                         : m_lb(x), m_ub(x)
54                 {}
55                 
56                 template <typename Scalar2>
57                 Interval(const Scalar2& lb, const Scalar2& ub) 
58                         : m_lb(lb), m_ub(ub)
59                 {
60                         assert(lb <= ub);
61                 }
62                 
63                 template <typename Scalar2>
64                 Interval(const Interval<Scalar2>& z) 
65                 { 
66                         *this = z; 
67                 }
68                 
69                 template <typename Scalar2>
70                 Interval<Scalar>& operator=(const Interval<Scalar2>& z) 
71                 { 
72                         m_lb = Scalar(z.lower()); 
73                         m_ub = Scalar(z.upper()); 
74                         return *this;
75                 }
76 #endif
77       
78                 
79
80                 Scalar&       lower()       { return m_lb; }
81                 const Scalar& lower() const { return m_lb; }
82                 
83                 Scalar&       upper()       { return m_ub; }
84                 const Scalar& upper() const { return m_ub; }
85                  
86                 Scalar center() const { return (m_lb + m_ub) * Scalar(0.5); } 
87                 Scalar extent() const { return (m_ub - m_lb) * Scalar(0.5); } 
88
89         
90         protected:
91                 Scalar m_lb, m_ub;
92         };
93
94         template <typename Scalar>
95         inline Interval<Scalar> 
96         operator+(const Interval<Scalar>& z1, const Interval<Scalar>& z2)
97         {
98                 return Interval<Scalar>(z1.lower() + z2.lower(), 
99                                                                 z1.upper() + z2.upper());
100         }
101
102         template <typename Scalar>
103         inline Interval<Scalar> 
104         operator-(const Interval<Scalar>& z1, const Interval<Scalar>& z2)
105         {
106                 return Interval<Scalar>(z1.lower() - z2.upper(), 
107                                                                 z1.upper() - z2.lower());
108         }
109         
110         template <typename Scalar>
111         inline std::ostream& 
112         operator<<(std::ostream& os, const Interval<Scalar>& z)
113         {
114                 return os << '[' << x.lower() << ", " << x.upper() << ']';
115         }
116
117         template <typename Scalar>
118         inline Scalar 
119         median(const Interval<Scalar>& z) 
120         {
121                 return (z.lower() + z.upper()) * Scalar(0.5);
122         }
123         
124         template <typename Scalar>
125         inline Scalar 
126         width(const Interval<Scalar>& z) 
127         {
128                 return z.upper() - z.lower();
129         }
130         
131         template <typename Scalar>
132         inline bool 
133         overlap(const Interval<Scalar>& z1, const Interval<Scalar>& z2) 
134         {
135                 return z1.lower() <= z2.upper() && z2.lower() <= z1.upper();
136         }
137
138         template <typename Scalar>
139         inline bool 
140         in(const Interval<Scalar>& z1, const Interval<Scalar>& z2) 
141         {
142                 return z2.lower() <= z1.lower() && z1.upper() <= z2.upper();
143         }
144
145         template <typename Scalar>
146         inline bool 
147         in(Scalar x, const Interval<Scalar>& z) 
148         {
149                 return z.lower() <= x && x <= z.upper();
150         }
151         
152         template <typename Scalar>
153         inline Interval<Scalar> 
154         widen(const Interval<Scalar>& z, const Scalar& x) 
155         {
156                 return Interval<Scalar>(z.lower() - x, z.upper() + x);
157         }       
158                 
159         template<typename Scalar>
160         inline Interval<Scalar>
161         hull(const Interval<Scalar>& z1, const Interval<Scalar>& z2)
162         {
163                 return Interval<Scalar>(GEN_min(z1.lower(), z2.lower()), 
164                                                                 GEN_max(z1.upper(), z2.upper()));
165         }       
166    
167    template<typename Scalar>
168         inline Interval<Scalar>
169         operator+(Scalar x, const Interval<Scalar>& z)
170         {
171                 return Interval<Scalar>(x + z.lower(), x + z.upper());
172         }
173 }
174
175 #endif