mt
 All Classes Files Functions Enumerations Groups Pages
basic_scalar_utility.h
Go to the documentation of this file.
1 /***************************************************************************
2  * Copyright (C) 2006 by Adolfo Rodriguez *
3  * adolfo.rodriguez@upc.edu *
4  * *
5  * This program is free software; you can redistribute it and/or modify *
6  * it under the terms of the GNU General Public License as published by *
7  * the Free Software Foundation; either version 2 of the License, or *
8  * (at your option) any later version. *
9  * *
10  * This program is distributed in the hope that it will be useful, *
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13  * GNU General Public License for more details. *
14  * *
15  * You should have received a copy of the GNU General Public License *
16  * along with this program; if not, write to the *
17  * Free Software Foundation, Inc., *
18  * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19  ***************************************************************************/
20 
22 
23 // HEADER GUARD
24 #ifndef MT_BASIC_SCALAR_UTILITY_H
25 #define MT_BASIC_SCALAR_UTILITY_H
26 
27 // MT LIBRARY HEADERS
28 #include <mt/basic_scalar.h>
29 
31 
32 namespace mt
33 {
34 
36 
41 
42 // ADDITION
43 
44 template<class T>
45 BasicScalar<T> operator+(const BasicScalar<T>& s,
46  const float& x);
47 
48 template<class T>
49 BasicScalar<T> operator+(const float& x,
50  const BasicScalar<T>& s);
51 
52 template<class T>
53 BasicScalar<T> operator+(const BasicScalar<T>& s,
54  const double& x);
55 
56 template<class T>
57 BasicScalar<T> operator+(const double& x,
58  const BasicScalar<T>& s);
59 
60 template<class T>
61 BasicScalar<T> operator+(const BasicScalar<T>& s,
62  const int& x);
63 
64 template<class T>
65 BasicScalar<T> operator+(const int& x,
66  const BasicScalar<T>& s);
67 
68 
69 // SUBSTRACTION
70 
71 template<class T>
72 BasicScalar<T> operator-(const BasicScalar<T>& s,
73  const float& x);
74 
75 template<class T>
76 BasicScalar<T> operator-(const float& x,
77  const BasicScalar<T>& s);
78 
79 template<class T>
80 BasicScalar<T> operator-(const BasicScalar<T>& s,
81  const double& x);
82 
83 template<class T>
84 BasicScalar<T> operator-(const double& x,
85  const BasicScalar<T>& s);
86 
87 template<class T>
88 BasicScalar<T> operator-(const BasicScalar<T>& s,
89  const int& x);
90 
91 template<class T>
92 BasicScalar<T> operator-(const int& x,
93  const BasicScalar<T>& s);
94 
95 
96 // MULTIPLICATION
97 
98 template<class T>
99 BasicScalar<T> operator*(const BasicScalar<T>& s,
100  const float& x);
101 
102 template<class T>
103 BasicScalar<T> operator*(const float& x,
104  const BasicScalar<T>& s);
105 
106 template<class T>
107 BasicScalar<T> operator*(const BasicScalar<T>& s,
108  const double& x);
109 
110 template<class T>
111 BasicScalar<T> operator*(const double& x,
112  const BasicScalar<T>& s);
113 
114 template<class T>
115 BasicScalar<T> operator*(const BasicScalar<T>& s,
116  const int& x);
117 
118 template<class T>
119 BasicScalar<T> operator*(const int& x,
120  const BasicScalar<T>& s);
121 
122 
123 // DIVISION
124 
125 template<class T>
126 BasicScalar<T> operator/(const BasicScalar<T>& s,
127  const float& x);
128 
129 template<class T>
130 BasicScalar<T> operator/(const float& x,
131  const BasicScalar<T>& s);
132 
133 template<class T>
134 BasicScalar<T> operator/(const BasicScalar<T>& s,
135  const double& x);
136 
137 template<class T>
138 BasicScalar<T> operator/(const double& x,
139  const BasicScalar<T>& s);
140 
141 template<class T>
142 BasicScalar<T> operator/(const BasicScalar<T>& s,
143  const int& x);
144 
145 template<class T>
146 BasicScalar<T> operator/(const int& x,
147  const BasicScalar<T>& s);
148 
149 
151 
152 // ADDITION
153 
154 template<class T> inline
155 BasicScalar<T> operator+(const BasicScalar<T>& s,
156  const float& x)
157 {
158  return s + BasicScalar<T>(x);
159 }
160 
161 
162 template<class T> inline
163 BasicScalar<T> operator+(const float& x,
164  const BasicScalar<T>& s)
165 {
166  return s + BasicScalar<T>(x);
167 }
168 
169 
170 template<class T> inline
171 BasicScalar<T> operator+(const BasicScalar<T>& s,
172  const double& x)
173 {
174  return s + BasicScalar<T>(x);
175 }
176 
177 
178 template<class T> inline
179 BasicScalar<T> operator+(const double& x,
180  const BasicScalar<T>& s)
181 {
182  return s + BasicScalar<T>(x);
183 }
184 
185 
186 template<class T> inline
187 BasicScalar<T> operator+(const BasicScalar<T>& s,
188  const int& x)
189 {
190  return s + BasicScalar<T>(x);
191 }
192 
193 
194 template<class T> inline
195 BasicScalar<T> operator+(const int& x,
196  const BasicScalar<T>& s)
197 {
198  return s + BasicScalar<T>(x);
199 }
200 
201 
202 // SUBSTRACTION
203 
204 template<class T> inline
205 BasicScalar<T> operator-(const BasicScalar<T>& s,
206  const float& x)
207 {
208  return s - BasicScalar<T>(x);
209 }
210 
211 
212 template<class T> inline
213 BasicScalar<T> operator-(const float& x,
214  const BasicScalar<T>& s)
215 {
216  return BasicScalar<T>(x) - s;
217 }
218 
219 
220 template<class T> inline
221 BasicScalar<T> operator-(const BasicScalar<T>& s,
222  const double& x)
223 {
224  return s - BasicScalar<T>(x);
225 }
226 
227 
228 template<class T> inline
229 BasicScalar<T> operator-(const double& x,
230  const BasicScalar<T>& s)
231 {
232  return BasicScalar<T>(x) - s;
233 }
234 
235 
236 template<class T> inline
237 BasicScalar<T> operator-(const BasicScalar<T>& s,
238  const int& x)
239 {
240  return s - BasicScalar<T>(x);
241 }
242 
243 
244 template<class T> inline
245 BasicScalar<T> operator-(const int& x,
246  const BasicScalar<T>& s)
247 {
248  return BasicScalar<T>(x) - s;
249 }
250 
251 
252 // MULTIPLICATION
253 
254 template<class T> inline
255 BasicScalar<T> operator*(const BasicScalar<T>& s,
256  const float& x)
257 {
258  return s * BasicScalar<T>(x);
259 }
260 
261 
262 template<class T> inline
263 BasicScalar<T> operator*(const float& x,
264  const BasicScalar<T>& s)
265 {
266  return s * BasicScalar<T>(x);
267 }
268 
269 
270 template<class T> inline
271 BasicScalar<T> operator*(const BasicScalar<T>& s,
272  const double& x)
273 {
274  return s * BasicScalar<T>(x);
275 }
276 
277 
278 template<class T> inline
279 BasicScalar<T> operator*(const double& x,
280  const BasicScalar<T>& s)
281 {
282  return s * BasicScalar<T>(x);
283 }
284 
285 
286 template<class T> inline
287 BasicScalar<T> operator*(const BasicScalar<T>& s,
288  const int& x)
289 {
290  return s * BasicScalar<T>(x);
291 }
292 
293 
294 template<class T> inline
295 BasicScalar<T> operator*(const int& x,
296  const BasicScalar<T>& s)
297 {
298  return s * BasicScalar<T>(x);
299 }
300 
301 
302 // DIVISION
303 
304 template<class T> inline
305 BasicScalar<T> operator/(const BasicScalar<T>& s,
306  const float& x)
307 {
308  return s / BasicScalar<T>(x);
309 }
310 
311 
312 template<class T> inline
313 BasicScalar<T> operator/(const float& x,
314  const BasicScalar<T>& s)
315 {
316  return BasicScalar<T>(x) / s;
317 }
318 
319 
320 template<class T> inline
321 BasicScalar<T> operator/(const BasicScalar<T>& s,
322  const double& x)
323 {
324  return s / BasicScalar<T>(x);
325 }
326 
327 
328 template<class T> inline
329 BasicScalar<T> operator/(const double& x,
330  const BasicScalar<T>& s)
331 {
332  return BasicScalar<T>(x) / s;
333 }
334 
335 
336 template<class T> inline
337 BasicScalar<T> operator/(const BasicScalar<T>& s,
338  const int& x)
339 {
340  return s / BasicScalar<T>(x);
341 }
342 
343 
344 template<class T> inline
345 BasicScalar<T> operator/(const int& x,
346  const BasicScalar<T>& s)
347 {
348  return BasicScalar<T>(x) / s;
349 }
350 
351 
352 } // mt
353 
354 #endif // MT_BASIC_SCALAR_UTILITY_H