Logo ROOT   6.08/07
Reference Guide
BinaryOperators.h
Go to the documentation of this file.
1 // @(#)root/smatrix:$Id$
2 // Authors: T. Glebe, L. Moneta 2005
3 
4 #ifndef ROOT_Math_BinaryOperators
5 #define ROOT_Math_BinaryOperators
6 //======================================================
7 //
8 // ATTENTION: This file was automatically generated,
9 // do not edit!
10 //
11 // author: Thorsten Glebe
12 // HERA-B Collaboration
13 // Max-Planck-Institut fuer Kernphysik
14 // Saupfercheckweg 1
15 // 69117 Heidelberg
16 // Germany
17 // E-mail: T.Glebe@mpi-hd.mpg.de
18 //
19 //======================================================
20 
21 #ifndef ROOT_Math_BinaryOpPolicy
22 #include "Math/BinaryOpPolicy.h"
23 #endif
24 #include "Math/Expression.h"
25 
26 namespace ROOT {
27 
28  namespace Math {
29 
30 
31 
32 template <class T, unsigned int D> class SVector;
33 template <class T, unsigned int D1, unsigned int D2, class R> class SMatrix;
34 
35 
36 //==============================================================================
37 // AddOp
38 //==============================================================================
39 /**
40  Addition Operation Class
41 
42  @ingroup Expression
43  */
44 template <class T>
45 class AddOp {
46 public:
47  static inline T apply(const T& lhs, const T& rhs) {
48  return lhs + rhs;
49  }
50 };
51 
52 
53 /**
54  Addition of two vectors v3 = v1+v2
55  returning a vector expression
56 
57  @ingroup VectFunction
58 */
59 //==============================================================================
60 // operator+ (SVector, binary)
61 //==============================================================================
62 template < class T, unsigned int D>
63 inline VecExpr<BinaryOp<AddOp<T>, SVector<T,D>, SVector<T,D>, T>, T, D>
64  operator+(const SVector<T,D>& lhs, const SVector<T,D>& rhs) {
65  typedef BinaryOp<AddOp<T>, SVector<T,D>, SVector<T,D>, T> AddOpBinOp;
66 
67  return VecExpr<AddOpBinOp,T,D>(AddOpBinOp(AddOp<T>(),lhs,rhs));
68 }
69 
70 
71 //==============================================================================
72 // operator+ (SVector, binary)
73 //==============================================================================
74 template <class A, class T, unsigned int D>
75 inline VecExpr<BinaryOp<AddOp<T>, VecExpr<A,T,D>, SVector<T,D>, T>, T, D>
76  operator+(const VecExpr<A,T,D>& lhs, const SVector<T,D>& rhs) {
77  typedef BinaryOp<AddOp<T>, VecExpr<A,T,D>, SVector<T,D>, T> AddOpBinOp;
78 
79  return VecExpr<AddOpBinOp,T,D>(AddOpBinOp(AddOp<T>(),lhs,rhs));
80 }
81 
82 
83 //==============================================================================
84 // operator+ (SVector, binary)
85 //==============================================================================
86 template < class A, class T, unsigned int D>
87 inline VecExpr<BinaryOp<AddOp<T>, SVector<T,D>, VecExpr<A,T,D>, T>, T, D>
88  operator+(const SVector<T,D>& lhs, const VecExpr<A,T,D>& rhs) {
89  typedef BinaryOp<AddOp<T>, SVector<T,D>, VecExpr<A,T,D>, T> AddOpBinOp;
90 
91  return VecExpr<AddOpBinOp,T,D>(AddOpBinOp(AddOp<T>(),lhs,rhs));
92 }
93 
94 
95 //==============================================================================
96 // operator+ (SVector, binary)
97 //==============================================================================
98 template <class A, class B, class T, unsigned int D>
99 inline VecExpr<BinaryOp<AddOp<T>, VecExpr<A,T,D>, VecExpr<B,T,D>, T>, T, D>
100  operator+(const VecExpr<A,T,D>& lhs, const VecExpr<B,T,D>& rhs) {
101  typedef BinaryOp<AddOp<T>, VecExpr<A,T,D>, VecExpr<B,T,D>, T> AddOpBinOp;
102 
103  return VecExpr<AddOpBinOp,T,D>(AddOpBinOp(AddOp<T>(),lhs,rhs));
104 }
105 
106 
107 /**
108  Addition of a scalar to a each vector element: v2(i) = v1(i) + a
109  returning a vector expression
110 
111  @ingroup VectFunction
112 */
113 //==============================================================================
114 // operator+ (SVector, binary, Constant)
115 //==============================================================================
116 template <class A, class T, unsigned int D>
117 inline VecExpr<BinaryOpCopyR<AddOp<T>, SVector<T,D>, Constant<A>, T>, T, D>
118  operator+(const SVector<T,D>& lhs, const A& rhs) {
119  typedef BinaryOpCopyR<AddOp<T>, SVector<T,D>, Constant<A>, T> AddOpBinOp;
120 
121  return VecExpr<AddOpBinOp,T,D>(AddOpBinOp(AddOp<T>(),lhs,Constant<A>(rhs)));
122 }
123 
124 /**
125  Addition of a scalar to each vector element v2(i) = a + v1(i)
126  returning a vector expression
127 
128  @ingroup VectFunction
129 */
130 //==============================================================================
131 // operator+ (SVector, binary, Constant)
132 //==============================================================================
133 template <class A, class T, unsigned int D>
134 inline VecExpr<BinaryOpCopyL<AddOp<T>, Constant<A>, SVector<T,D>, T>, T, D>
135  operator+(const A& lhs, const SVector<T,D>& rhs) {
136  typedef BinaryOpCopyL<AddOp<T>, Constant<A>, SVector<T,D>, T> AddOpBinOp;
137 
138  return VecExpr<AddOpBinOp,T,D>(AddOpBinOp(AddOp<T>(),Constant<A>(lhs),rhs));
139 }
140 
141 
142 //==============================================================================
143 // operator+ (SVector, binary, Constant)
144 //==============================================================================
145 template <class A, class B, class T, unsigned int D>
146 inline VecExpr<BinaryOpCopyR<AddOp<T>, VecExpr<B,T,D>, Constant<A>, T>, T, D>
147  operator+(const VecExpr<B,T,D>& lhs, const A& rhs) {
148  typedef BinaryOpCopyR<AddOp<T>, VecExpr<B,T,D>, Constant<A>, T> AddOpBinOp;
149 
150  return VecExpr<AddOpBinOp,T,D>(AddOpBinOp(AddOp<T>(),lhs,Constant<A>(rhs)));
151 }
152 
153 //==============================================================================
154 // operator+ (SVector, binary, Constant)
155 //==============================================================================
156 template <class A, class B, class T, unsigned int D>
157 inline VecExpr<BinaryOpCopyL<AddOp<T>, Constant<A>, VecExpr<B,T,D>, T>, T, D>
158  operator+(const A& lhs, const VecExpr<B,T,D>& rhs) {
159  typedef BinaryOpCopyL<AddOp<T>, Constant<A>, VecExpr<B,T,D>, T> AddOpBinOp;
160 
161  return VecExpr<AddOpBinOp,T,D>(AddOpBinOp(AddOp<T>(),Constant<A>(lhs),rhs));
162 }
163 
164 
165 /**
166  Addition of two matrices C = A+B
167  returning a matrix expression
168 
169  @ingroup MatrixFunctions
170 */
171 //==============================================================================
172 // operator+ (SMatrix, binary)
173 //==============================================================================
174 template < class T, unsigned int D, unsigned int D2, class R1, class R2>
175 inline Expr<BinaryOp<AddOp<T>, SMatrix<T,D,D2,R1>, SMatrix<T,D,D2,R2>, T>, T, D, D2, typename AddPolicy<T,D,D2,R1,R2>::RepType >
176  operator+(const SMatrix<T,D,D2,R1>& lhs, const SMatrix<T,D,D2,R2>& rhs) {
177  typedef BinaryOp<AddOp<T>, SMatrix<T,D,D2,R1>, SMatrix<T,D,D2,R2>, T> AddOpBinOp;
178 
179  return Expr<AddOpBinOp,T,D,D2,typename AddPolicy<T,D,D2,R1,R2>::RepType>(AddOpBinOp(AddOp<T>(),lhs,rhs));
180 }
181 
182 
183 //==============================================================================
184 // operator+ (SMatrix, binary)
185 //==============================================================================
186 template <class A, class T, unsigned int D, unsigned int D2, class R1, class R2>
187 inline Expr<BinaryOp<AddOp<T>, Expr<A,T,D,D2,R1>, SMatrix<T,D,D2,R2>, T>, T, D, D2, typename AddPolicy<T,D,D2,R1,R2>::RepType>
188  operator+(const Expr<A,T,D,D2,R1>& lhs, const SMatrix<T,D,D2,R2>& rhs) {
189  typedef BinaryOp<AddOp<T>, Expr<A,T,D,D2,R1>, SMatrix<T,D,D2,R2>, T> AddOpBinOp;
190 
191  return Expr<AddOpBinOp,T,D,D2,typename AddPolicy<T,D,D2,R1,R2>::RepType>(AddOpBinOp(AddOp<T>(),lhs,rhs));
192 }
193 
194 
195 //==============================================================================
196 // operator+ (SMatrix, binary)
197 //==============================================================================
198 template < class A, class T, unsigned int D, unsigned int D2, class R1, class R2>
199 inline Expr<BinaryOp<AddOp<T>, SMatrix<T,D,D2,R1>, Expr<A,T,D,D2,R2>, T>, T, D, D2,typename AddPolicy<T,D,D2,R1,R2>::RepType>
200  operator+(const SMatrix<T,D,D2,R1>& lhs, const Expr<A,T,D,D2,R2>& rhs) {
201  typedef BinaryOp<AddOp<T>, SMatrix<T,D,D2,R1>, Expr<A,T,D,D2,R2>, T> AddOpBinOp;
202 
203  return Expr<AddOpBinOp,T,D,D2,typename AddPolicy<T,D,D2,R1,R2>::RepType>(AddOpBinOp(AddOp<T>(),lhs,rhs));
204 }
205 
206 
207 //==============================================================================
208 // operator+ (SMatrix, binary)
209 //==============================================================================
210 template <class A, class B, class T, unsigned int D, unsigned int D2, class R1, class R2>
211 inline Expr<BinaryOp<AddOp<T>, Expr<A,T,D,D2,R1>, Expr<B,T,D,D2,R2>, T>, T, D, D2, typename AddPolicy<T,D,D2,R1,R2>::RepType >
212  operator+(const Expr<A,T,D,D2,R1>& lhs, const Expr<B,T,D,D2,R2>& rhs) {
213  typedef BinaryOp<AddOp<T>, Expr<A,T,D,D2,R1>, Expr<B,T,D,D2,R2>, T> AddOpBinOp;
214 
215  return Expr<AddOpBinOp,T,D,D2,typename AddPolicy<T,D,D2,R1,R2>::RepType>(AddOpBinOp(AddOp<T>(),lhs,rhs));
216 }
217 
218 
219 /**
220  Addition element by element of matrix and a scalar C(i,j) = A(i,j) + s
221  returning a matrix expression
222 
223  @ingroup MatrixFunctions
224 */
225 //=============================================================================
226 // operator+ (SMatrix, binary, Constant)
227 //=============================================================================
228 template <class A, class T, unsigned int D, unsigned int D2, class R>
229 inline Expr<BinaryOpCopyR<AddOp<T>, SMatrix<T,D,D2,R>, Constant<A>, T>, T, D, D2, R>
230  operator+(const SMatrix<T,D,D2,R>& lhs, const A& rhs) {
231  typedef BinaryOpCopyR<AddOp<T>, SMatrix<T,D,D2,R>, Constant<A>, T> AddOpBinOp;
232 
233  return Expr<AddOpBinOp,T,D,D2,R>(AddOpBinOp(AddOp<T>(),lhs,Constant<A>(rhs)));
234 }
235 
236 /**
237  Addition element by element of matrix and a scalar C(i,j) = s + A(i,j)
238  returning a matrix expression
239 
240  @ingroup MatrixFunctions
241 */
242 //==============================================================================
243 // operator+ (SMatrix, binary, Constant)
244 //==============================================================================
245 template <class A, class T, unsigned int D, unsigned int D2, class R>
246 inline Expr<BinaryOpCopyL<AddOp<T>, Constant<A>, SMatrix<T,D,D2,R>, T>, T, D, D2, R>
247  operator+(const A& lhs, const SMatrix<T,D,D2,R>& rhs) {
248  typedef BinaryOpCopyL<AddOp<T>, Constant<A>, SMatrix<T,D,D2,R>, T> AddOpBinOp;
249 
250  return Expr<AddOpBinOp,T,D,D2,R>(AddOpBinOp(AddOp<T>(),
251  Constant<A>(lhs),rhs));
252 }
253 
254 
255 //==============================================================================
256 // operator+ (SMatrix, binary, Constant)
257 //==============================================================================
258 template <class A, class B, class T, unsigned int D, unsigned int D2, class R>
259 inline Expr<BinaryOpCopyR<AddOp<T>, Expr<B,T,D,D2,R>, Constant<A>, T>, T, D, D2, R>
260  operator+(const Expr<B,T,D,D2,R>& lhs, const A& rhs) {
261  typedef BinaryOpCopyR<AddOp<T>, Expr<B,T,D,D2,R>, Constant<A>, T> AddOpBinOp;
262 
263  return Expr<AddOpBinOp,T,D,D2,R>(AddOpBinOp(AddOp<T>(),
264  lhs,Constant<A>(rhs)));
265 }
266 
267 //==============================================================================
268 // operator+ (SMatrix, binary, Constant)
269 //==============================================================================
270 template <class A, class B, class T, unsigned int D, unsigned int D2, class R>
271 inline Expr<BinaryOpCopyL<AddOp<T>, Constant<A>, Expr<B,T,D,D2,R>, T>, T, D, D2, R>
272  operator+(const A& lhs, const Expr<B,T,D,D2,R>& rhs) {
273  typedef BinaryOpCopyL<AddOp<T>, Constant<A>, Expr<B,T,D,D2,R>, T> AddOpBinOp;
274 
275  return Expr<AddOpBinOp,T,D,D2,R>(AddOpBinOp(AddOp<T>(),
276  Constant<A>(lhs),rhs));
277 }
278 
279 
280 //==============================================================================
281 // MinOp
282 //==============================================================================
283 /**
284  Subtraction Operation Class
285 
286  @ingroup Expression
287  */
288 template <class T>
289 class MinOp {
290 public:
291  static inline T apply(const T& lhs, const T& rhs) {
292  return lhs - rhs;
293  }
294 };
295 
296 
297 /**
298  Vector Subtraction: v3 = v1 - v2
299  returning a vector expression
300 
301  @ingroup VectFunction
302 */
303 //==============================================================================
304 // operator- (SVector, binary)
305 //==============================================================================
306 template < class T, unsigned int D>
307 inline VecExpr<BinaryOp<MinOp<T>, SVector<T,D>, SVector<T,D>, T>, T, D>
308  operator-(const SVector<T,D>& lhs, const SVector<T,D>& rhs) {
309  typedef BinaryOp<MinOp<T>, SVector<T,D>, SVector<T,D>, T> MinOpBinOp;
310 
311  return VecExpr<MinOpBinOp,T,D>(MinOpBinOp(MinOp<T>(),lhs,rhs));
312 }
313 
314 
315 //==============================================================================
316 // operator- (SVector, binary)
317 //==============================================================================
318 template <class A, class T, unsigned int D>
319 inline VecExpr<BinaryOp<MinOp<T>, VecExpr<A,T,D>, SVector<T,D>, T>, T, D>
320  operator-(const VecExpr<A,T,D>& lhs, const SVector<T,D>& rhs) {
321  typedef BinaryOp<MinOp<T>, VecExpr<A,T,D>, SVector<T,D>, T> MinOpBinOp;
322 
323  return VecExpr<MinOpBinOp,T,D>(MinOpBinOp(MinOp<T>(),lhs,rhs));
324 }
325 
326 
327 //==============================================================================
328 // operator- (SVector, binary)
329 //==============================================================================
330 template < class A, class T, unsigned int D>
331 inline VecExpr<BinaryOp<MinOp<T>, SVector<T,D>, VecExpr<A,T,D>, T>, T, D>
332  operator-(const SVector<T,D>& lhs, const VecExpr<A,T,D>& rhs) {
333  typedef BinaryOp<MinOp<T>, SVector<T,D>, VecExpr<A,T,D>, T> MinOpBinOp;
334 
335  return VecExpr<MinOpBinOp,T,D>(MinOpBinOp(MinOp<T>(),lhs,rhs));
336 }
337 
338 
339 //==============================================================================
340 // operator- (SVector, binary)
341 //==============================================================================
342 template <class A, class B, class T, unsigned int D>
343 inline VecExpr<BinaryOp<MinOp<T>, VecExpr<A,T,D>, VecExpr<B,T,D>, T>, T, D>
344  operator-(const VecExpr<A,T,D>& lhs, const VecExpr<B,T,D>& rhs) {
345  typedef BinaryOp<MinOp<T>, VecExpr<A,T,D>, VecExpr<B,T,D>, T> MinOpBinOp;
346 
347  return VecExpr<MinOpBinOp,T,D>(MinOpBinOp(MinOp<T>(),lhs,rhs));
348 }
349 
350 
351 /**
352  Subtraction of a scalar from each vector element: v2(i) = v1(i) - a
353  returning a vector expression
354 
355  @ingroup VectFunction
356 */
357 //==============================================================================
358 // operator- (SVector, binary, Constant)
359 //==============================================================================
360 template <class A, class T, unsigned int D>
361 inline VecExpr<BinaryOpCopyR<MinOp<T>, SVector<T,D>, Constant<A>, T>, T, D>
362  operator-(const SVector<T,D>& lhs, const A& rhs) {
363  typedef BinaryOpCopyR<MinOp<T>, SVector<T,D>, Constant<A>, T> MinOpBinOp;
364 
365  return VecExpr<MinOpBinOp,T,D>(MinOpBinOp(MinOp<T>(),lhs,Constant<A>(rhs)));
366 }
367 
368 /**
369  Subtraction scalar vector (for each vector element) v2(i) = a - v1(i)
370  returning a vector expression
371 
372  @ingroup VectFunction
373 */
374 //==============================================================================
375 // operator- (SVector, binary, Constant)
376 //==============================================================================
377 template <class A, class T, unsigned int D>
378 inline VecExpr<BinaryOpCopyL<MinOp<T>, Constant<A>, SVector<T,D>, T>, T, D>
379  operator-(const A& lhs, const SVector<T,D>& rhs) {
380  typedef BinaryOpCopyL<MinOp<T>, Constant<A>, SVector<T,D>, T> MinOpBinOp;
381 
382  return VecExpr<MinOpBinOp,T,D>(MinOpBinOp(MinOp<T>(),Constant<A>(lhs),rhs));
383 }
384 
385 
386 //==============================================================================
387 // operator- (SVector, binary, Constant)
388 //==============================================================================
389 template <class A, class B, class T, unsigned int D>
390 inline VecExpr<BinaryOpCopyR<MinOp<T>, VecExpr<B,T,D>, Constant<A>, T>, T, D>
391  operator-(const VecExpr<B,T,D>& lhs, const A& rhs) {
392  typedef BinaryOpCopyR<MinOp<T>, VecExpr<B,T,D>, Constant<A>, T> MinOpBinOp;
393 
394  return VecExpr<MinOpBinOp,T,D>(MinOpBinOp(MinOp<T>(),lhs,Constant<A>(rhs)));
395 }
396 
397 //==============================================================================
398 // operator- (SVector, binary, Constant)
399 //==============================================================================
400 template <class A, class B, class T, unsigned int D>
401 inline VecExpr<BinaryOpCopyL<MinOp<T>, Constant<A>, VecExpr<B,T,D>, T>, T, D>
402  operator-(const A& lhs, const VecExpr<B,T,D>& rhs) {
403  typedef BinaryOpCopyL<MinOp<T>, Constant<A>, VecExpr<B,T,D>, T> MinOpBinOp;
404 
405  return VecExpr<MinOpBinOp,T,D>(MinOpBinOp(MinOp<T>(),Constant<A>(lhs),rhs));
406 }
407 
408 
409 /**
410  Subtraction of two matrices C = A-B
411  returning a matrix expression
412 
413  @ingroup MatrixFunctions
414 */
415 //==============================================================================
416 // operator- (SMatrix, binary)
417 //==============================================================================
418 template < class T, unsigned int D, unsigned int D2, class R1, class R2>
419 inline Expr<BinaryOp<MinOp<T>, SMatrix<T,D,D2,R1>, SMatrix<T,D,D2,R2>, T>, T, D, D2, typename AddPolicy<T,D,D2,R1,R2>::RepType>
420  operator-(const SMatrix<T,D,D2,R1>& lhs, const SMatrix<T,D,D2,R2>& rhs) {
421  typedef BinaryOp<MinOp<T>, SMatrix<T,D,D2,R1>, SMatrix<T,D,D2,R2>, T> MinOpBinOp;
422 
423  return Expr<MinOpBinOp,T,D,D2,typename AddPolicy<T,D,D2,R1,R2>::RepType>(MinOpBinOp(MinOp<T>(),lhs,rhs));
424 }
425 
426 
427 //==============================================================================
428 // operator- (SMatrix, binary)
429 //==============================================================================
430 template <class A, class T, unsigned int D, unsigned int D2, class R1, class R2>
431 inline Expr<BinaryOp<MinOp<T>, Expr<A,T,D,D2,R1>, SMatrix<T,D,D2,R2>, T>, T, D, D2,typename AddPolicy<T,D,D2,R1,R2>::RepType>
432  operator-(const Expr<A,T,D,D2,R1>& lhs, const SMatrix<T,D,D2,R2>& rhs) {
433  typedef BinaryOp<MinOp<T>, Expr<A,T,D,D2,R1>, SMatrix<T,D,D2,R2>, T> MinOpBinOp;
434 
435  return Expr<MinOpBinOp,T,D,D2,typename AddPolicy<T,D,D2,R1,R2>::RepType>(MinOpBinOp(MinOp<T>(),lhs,rhs));
436 }
437 
438 
439 //==============================================================================
440 // operator- (SMatrix, binary)
441 //==============================================================================
442 template < class A, class T, unsigned int D, unsigned int D2, class R1, class R2>
443 inline Expr<BinaryOp<MinOp<T>, SMatrix<T,D,D2,R1>, Expr<A,T,D,D2,R2>, T>, T, D, D2, typename AddPolicy<T,D,D2,R1,R2>::RepType>
444  operator-(const SMatrix<T,D,D2,R1>& lhs, const Expr<A,T,D,D2,R2>& rhs) {
445  typedef BinaryOp<MinOp<T>, SMatrix<T,D,D2,R1>, Expr<A,T,D,D2,R2>, T> MinOpBinOp;
446 
447  return Expr<MinOpBinOp,T,D,D2,typename AddPolicy<T,D,D2,R1,R2>::RepType>(MinOpBinOp(MinOp<T>(),lhs,rhs));
448 }
449 
450 
451 //==============================================================================
452 // operator- (SMatrix, binary)
453 //==============================================================================
454 template <class A, class B, class T, unsigned int D, unsigned int D2, class R1, class R2>
455 inline Expr<BinaryOp<MinOp<T>, Expr<A,T,D,D2,R1>, Expr<B,T,D,D2,R2>, T>, T, D, D2,typename AddPolicy<T,D,D2,R1,R2>::RepType>
456  operator-(const Expr<A,T,D,D2,R1>& lhs, const Expr<B,T,D,D2,R2>& rhs) {
457  typedef BinaryOp<MinOp<T>, Expr<A,T,D,D2,R1>, Expr<B,T,D,D2,R2>, T> MinOpBinOp;
458 
459  return Expr<MinOpBinOp,T,D,D2,typename AddPolicy<T,D,D2,R1,R2>::RepType>(MinOpBinOp(MinOp<T>(),lhs,rhs));
460 }
461 
462 
463 /**
464  Subtraction of a scalar and a matrix (element wise) B(i,j) = A(i,j) - s
465  returning a matrix expression
466 
467  @ingroup MatrixFunctions
468 */
469 //==============================================================================
470 // operator- (SMatrix, binary, Constant)
471 //==============================================================================
472 template <class A, class T, unsigned int D, unsigned int D2, class R>
473 inline Expr<BinaryOpCopyR<MinOp<T>, SMatrix<T,D,D2,R>, Constant<A>, T>, T, D, D2, R>
474  operator-(const SMatrix<T,D,D2,R>& lhs, const A& rhs) {
475  typedef BinaryOpCopyR<MinOp<T>, SMatrix<T,D,D2,R>, Constant<A>, T> MinOpBinOp;
476 
477  return Expr<MinOpBinOp,T,D,D2,R>(MinOpBinOp(MinOp<T>(),
478  lhs,Constant<A>(rhs)));
479 }
480 
481 /**
482  Subtraction of a scalar and a matrix (element wise) B(i,j) = s - A(i,j)
483  returning a matrix expression
484 
485  @ingroup MatrixFunctions
486 */
487 //==============================================================================
488 // operator- (SMatrix, binary, Constant)
489 //==============================================================================
490 template <class A, class T, unsigned int D, unsigned int D2, class R>
491 inline Expr<BinaryOpCopyL<MinOp<T>, Constant<A>, SMatrix<T,D,D2,R>, T>, T, D, D2, R>
492  operator-(const A& lhs, const SMatrix<T,D,D2,R>& rhs) {
493  typedef BinaryOpCopyL<MinOp<T>, Constant<A>, SMatrix<T,D,D2,R>, T> MinOpBinOp;
494 
495  return Expr<MinOpBinOp,T,D,D2,R>(MinOpBinOp(MinOp<T>(),Constant<A>(lhs),rhs));
496 }
497 
498 //==============================================================================
499 // operator- (SMatrix, binary, Constant)
500 //==============================================================================
501 template <class A, class B, class T, unsigned int D, unsigned int D2, class R>
502 inline Expr<BinaryOpCopyR<MinOp<T>, Expr<B,T,D,D2,R>, Constant<A>, T>, T, D, D2, R>
503  operator-(const Expr<B,T,D,D2,R>& lhs, const A& rhs) {
504  typedef BinaryOpCopyR<MinOp<T>, Expr<B,T,D,D2,R>, Constant<A>, T> MinOpBinOp;
505 
506  return Expr<MinOpBinOp,T,D,D2,R>(MinOpBinOp(MinOp<T>(),lhs,Constant<A>(rhs)));
507 }
508 
509 //==============================================================================
510 // operator- (SMatrix, binary, Constant)
511 //==============================================================================
512 template <class A, class B, class T, unsigned int D, unsigned int D2, class R>
513 inline Expr<BinaryOpCopyL<MinOp<T>, Constant<A>, Expr<B,T,D,D2,R>, T>, T, D, D2, R>
514  operator-(const A& lhs, const Expr<B,T,D,D2,R>& rhs) {
515  typedef BinaryOpCopyL<MinOp<T>, Constant<A>, Expr<B,T,D,D2,R>, T> MinOpBinOp;
516 
517  return Expr<MinOpBinOp,T,D,D2,R>(MinOpBinOp(MinOp<T>(),
518  Constant<A>(lhs),rhs));
519 }
520 
521 
522 /**
523  Multiplication (element-wise) Operation Class
524 
525  @ingroup Expression
526  */
527 //==============================================================================
528 // MulOp
529 //==============================================================================
530 template <class T>
531 class MulOp {
532 public:
533  static inline T apply(const T& lhs, const T& rhs) {
534  return lhs * rhs;
535  }
536 };
537 
538 /**
539  Element by element vector product v3(i) = v1(i)*v2(i)
540  returning a vector expression.
541  Note this is NOT the Dot, Cross or Tensor product.
542 
543  @ingroup VectFunction
544 */
545 //==============================================================================
546 // operator* (SVector, binary)
547 //==============================================================================
548 template < class T, unsigned int D>
549 inline VecExpr<BinaryOp<MulOp<T>, SVector<T,D>, SVector<T,D>, T>, T, D>
550  operator*(const SVector<T,D>& lhs, const SVector<T,D>& rhs) {
551  typedef BinaryOp<MulOp<T>, SVector<T,D>, SVector<T,D>, T> MulOpBinOp;
552 
553  return VecExpr<MulOpBinOp,T,D>(MulOpBinOp(MulOp<T>(),lhs,rhs));
554 }
555 
556 
557 //==============================================================================
558 // operator* (SVector, binary)
559 //==============================================================================
560 // template <class A, class T, unsigned int D, class R>
561 // inline VecExpr<BinaryOp<MulOp<T>, VecExpr<A,T,D>, SVector<T,D>, T>, T, D>
562 // operator*(const VecExpr<A,T,D,1,R>& lhs, const SVector<T,D>& rhs) {
563 // typedef BinaryOp<MulOp<T>, VecExpr<A,T,D,1,R>, SVector<T,D>, T> MulOpBinOp;
564 // return VecExpr<MulOpBinOp,T,D>(MulOpBinOp(MulOp<T>(),lhs,rhs));
565 // }
566 template <class A, class T, unsigned int D>
567 inline VecExpr<BinaryOp<MulOp<T>, Expr<A,T,D>, SVector<T,D>, T>, T, D>
568  operator*(const VecExpr<A,T,D>& lhs, const SVector<T,D>& rhs) {
569  typedef BinaryOp<MulOp<T>, VecExpr<A,T,D>, SVector<T,D>, T> MulOpBinOp;
570  return VecExpr<MulOpBinOp,T,D>(MulOpBinOp(MulOp<T>(),lhs,rhs));
571 }
572 
573 
574 //==============================================================================
575 // operator* (SVector, binary)
576 //==============================================================================
577 template < class A, class T, unsigned int D>
578 inline VecExpr<BinaryOp<MulOp<T>, SVector<T,D>, VecExpr<A,T,D>, T>, T, D>
579  operator*(const SVector<T,D>& lhs, const VecExpr<A,T,D>& rhs) {
580  typedef BinaryOp<MulOp<T>, SVector<T,D>, VecExpr<A,T,D>, T> MulOpBinOp;
581  return VecExpr<MulOpBinOp,T,D>(MulOpBinOp(MulOp<T>(),lhs,rhs));
582 }
583 
584 
585 //==============================================================================
586 // operator* (SVector, binary)
587 //==============================================================================
588 template <class A, class B, class T, unsigned int D>
589 inline VecExpr<BinaryOp<MulOp<T>, VecExpr<A,T,D>, VecExpr<B,T,D>, T>, T, D>
590  operator*(const VecExpr<A,T,D>& lhs, const VecExpr<B,T,D>& rhs) {
591  typedef BinaryOp<MulOp<T>, VecExpr<A,T,D>, VecExpr<B,T,D>, T> MulOpBinOp;
592  return VecExpr<MulOpBinOp,T,D>(MulOpBinOp(MulOp<T>(),lhs,rhs));
593 }
594 
595 
596 //==============================================================================
597 // operator* (SVector, binary, Constant)
598 //==============================================================================
599 template <class A, class T, unsigned int D>
600 inline VecExpr<BinaryOpCopyR<MulOp<T>, SVector<T,D>, Constant<A>, T>, T, D>
601  operator*(const SVector<T,D>& lhs, const A& rhs) {
602  typedef BinaryOpCopyR<MulOp<T>, SVector<T,D>, Constant<A>, T> MulOpBinOp;
603 
604  return VecExpr<MulOpBinOp,T,D>(MulOpBinOp(MulOp<T>(),lhs,Constant<A>(rhs)));
605 }
606 
607 //==============================================================================
608 // operator* (SVector, binary, Constant)
609 //==============================================================================
610 template <class A, class T, unsigned int D>
611 inline VecExpr<BinaryOpCopyL<MulOp<T>, Constant<A>, SVector<T,D>, T>, T, D>
612  operator*(const A& lhs, const SVector<T,D>& rhs) {
613  typedef BinaryOpCopyL<MulOp<T>, Constant<A>, SVector<T,D>, T> MulOpBinOp;
614 
615  return VecExpr<MulOpBinOp,T,D>(MulOpBinOp(MulOp<T>(),Constant<A>(lhs),rhs));
616 }
617 
618 
619 //==============================================================================
620 // operator* (SVector, binary, Constant)
621 //==============================================================================
622 template <class A, class B, class T, unsigned int D>
623 inline VecExpr<BinaryOpCopyR<MulOp<T>, VecExpr<B,T,D>, Constant<A>, T>, T, D>
624  operator*(const VecExpr<B,T,D>& lhs, const A& rhs) {
625  typedef BinaryOpCopyR<MulOp<T>, VecExpr<B,T,D>, Constant<A>, T> MulOpBinOp;
626 
627  return VecExpr<MulOpBinOp,T,D>(MulOpBinOp(MulOp<T>(),lhs,Constant<A>(rhs)));
628 }
629 
630 //==============================================================================
631 // operator* (SVector, binary, Constant)
632 //==============================================================================
633 template <class A, class B, class T, unsigned int D>
634 inline VecExpr<BinaryOpCopyL<MulOp<T>, Constant<A>, VecExpr<B,T,D>, T>, T, D>
635  operator*(const A& lhs, const VecExpr<B,T,D>& rhs) {
636  typedef BinaryOpCopyL<MulOp<T>, Constant<A>, VecExpr<B,T,D>, T> MulOpBinOp;
637 
638  return VecExpr<MulOpBinOp,T,D>(MulOpBinOp(MulOp<T>(),Constant<A>(lhs),rhs));
639 }
640 
641 /**
642  Element by element matrix multiplication C(i,j) = A(i,j)*B(i,j)
643  returning a matrix expression. This is not a matrix-matrix multiplication and works only
644  for matrices of the same dimensions.
645 
646  @ingroup MatrixFunctions
647 */
648 // Times: Function for element - wise multiplication
649 //==============================================================================
650 // Times (SMatrix, binary)
651 //==============================================================================
652 template < class T, unsigned int D, unsigned int D2, class R1, class R2>
653 inline Expr<BinaryOp<MulOp<T>, SMatrix<T,D,D2,R1>, SMatrix<T,D,D2,R2>, T>, T, D, D2, typename AddPolicy<T,D,D2,R1,R2>::RepType>
654  Times(const SMatrix<T,D,D2,R1>& lhs, const SMatrix<T,D,D2,R2>& rhs) {
655  typedef BinaryOp<MulOp<T>, SMatrix<T,D,D2,R1>, SMatrix<T,D,D2,R2>, T> MulOpBinOp;
656 
657  return Expr<MulOpBinOp,T,D,D2,typename AddPolicy<T,D,D2,R1,R2>::RepType>(MulOpBinOp(MulOp<T>(),lhs,rhs));
658 }
659 
660 
661 //==============================================================================
662 // Times (SMatrix, binary)
663 //==============================================================================
664 template <class A, class T, unsigned int D, unsigned int D2, class R1, class R2>
665 inline Expr<BinaryOp<MulOp<T>, Expr<A,T,D,D2,R1>, SMatrix<T,D,D2,R2>, T>, T, D, D2, typename AddPolicy<T,D,D2,R1,R2>::RepType>
666  Times(const Expr<A,T,D,D2,R1>& lhs, const SMatrix<T,D,D2,R2>& rhs) {
667  typedef BinaryOp<MulOp<T>, Expr<A,T,D,D2,R1>, SMatrix<T,D,D2,R2>, T> MulOpBinOp;
668 
669  return Expr<MulOpBinOp,T,D,D2,typename AddPolicy<T,D,D2,R1,R2>::RepType>(MulOpBinOp(MulOp<T>(),lhs,rhs));
670 }
671 
672 
673 //==============================================================================
674 // Times (SMatrix, binary)
675 //==============================================================================
676 template < class A, class T, unsigned int D, unsigned int D2, class R1, class R2>
677 inline Expr<BinaryOp<MulOp<T>, SMatrix<T,D,D2,R1>, Expr<A,T,D,D2,R2>, T>, T, D, D2, typename AddPolicy<T,D,D2,R1,R2>::RepType>
678  Times(const SMatrix<T,D,D2,R1>& lhs, const Expr<A,T,D,D2,R2>& rhs) {
679  typedef BinaryOp<MulOp<T>, SMatrix<T,D,D2,R1>, Expr<A,T,D,D2,R2>, T> MulOpBinOp;
680 
681  return Expr<MulOpBinOp,T,D,D2,typename AddPolicy<T,D,D2,R1,R2>::RepType>(MulOpBinOp(MulOp<T>(),lhs,rhs));
682 }
683 
684 
685 //==============================================================================
686 // Times (SMatrix, binary)
687 //==============================================================================
688 template <class A, class B, class T, unsigned int D, unsigned int D2, class R1, class R2>
689 inline Expr<BinaryOp<MulOp<T>, Expr<A,T,D,D2,R1>, Expr<B,T,D,D2,R2>, T>, T, D, D2, typename AddPolicy<T,D,D2,R1,R2>::RepType>
690  Times(const Expr<A,T,D,D2,R1>& lhs, const Expr<B,T,D,D2,R2>& rhs) {
691  typedef BinaryOp<MulOp<T>, Expr<A,T,D,D2,R1>, Expr<B,T,D,D2,R2>, T> MulOpBinOp;
692 
693  return Expr<MulOpBinOp,T,D,D2,typename AddPolicy<T,D,D2,R1,R2>::RepType>(MulOpBinOp(MulOp<T>(),lhs,rhs));
694 }
695 
696 
697 /**
698  Multiplication (element wise) of a matrix and a scalar, B(i,j) = A(i,j) * s
699  returning a matrix expression
700 
701  @ingroup MatrixFunctions
702 */
703 //=============================================================================
704 // operator* (SMatrix, binary, Constant)
705 //=============================================================================
706 template <class A, class T, unsigned int D, unsigned int D2, class R>
707 inline Expr<BinaryOpCopyR<MulOp<T>, SMatrix<T,D,D2,R>, Constant<A>, T>, T, D, D2, R>
708  operator*(const SMatrix<T,D,D2,R>& lhs, const A& rhs) {
709  typedef BinaryOpCopyR<MulOp<T>, SMatrix<T,D,D2,R>, Constant<A>, T> MulOpBinOp;
710 
711  return Expr<MulOpBinOp,T,D,D2,R>(MulOpBinOp(MulOp<T>(),
712  lhs,Constant<A>(rhs)));
713 }
714 
715 /**
716  Multiplication (element wise) of a matrix and a scalar, B(i,j) = s * A(i,j)
717  returning a matrix expression
718 
719  @ingroup MatrixFunctions
720 */
721 //=============================================================================
722 // operator* (SMatrix, binary, Constant)
723 //=============================================================================
724 template <class A, class T, unsigned int D, unsigned int D2, class R>
725 inline Expr<BinaryOpCopyL<MulOp<T>, Constant<A>, SMatrix<T,D,D2,R>, T>, T, D, D2, R>
726  operator*(const A& lhs, const SMatrix<T,D,D2,R>& rhs) {
727  typedef BinaryOpCopyL<MulOp<T>, Constant<A>, SMatrix<T,D,D2,R>, T> MulOpBinOp;
728 
729  return Expr<MulOpBinOp,T,D,D2,R>(MulOpBinOp(MulOp<T>(),
730  Constant<A>(lhs),rhs));
731 }
732 
733 
734 //==============================================================================
735 // operator* (SMatrix, binary, Constant)
736 //==============================================================================
737 template <class A, class B, class T, unsigned int D, unsigned int D2, class R>
738 inline Expr<BinaryOpCopyR<MulOp<T>, Expr<B,T,D,D2,R>, Constant<A>, T>, T, D, D2, R>
739  operator*(const Expr<B,T,D,D2,R>& lhs, const A& rhs) {
740  typedef BinaryOpCopyR<MulOp<T>, Expr<B,T,D,D2,R>, Constant<A>, T> MulOpBinOp;
741 
742  return Expr<MulOpBinOp,T,D,D2,R>(MulOpBinOp(MulOp<T>(),
743  lhs,Constant<A>(rhs)));
744 }
745 
746 //==============================================================================
747 // operator* (SMatrix, binary, Constant)
748 //==============================================================================
749 template <class A, class B, class T, unsigned int D, unsigned int D2, class R>
750 inline Expr<BinaryOpCopyL<MulOp<T>, Constant<A>, Expr<B,T,D,D2,R>, T>, T, D, D2, R>
751  operator*(const A& lhs, const Expr<B,T,D,D2,R>& rhs) {
752  typedef BinaryOpCopyL<MulOp<T>, Constant<A>, Expr<B,T,D,D2,R>, T> MulOpBinOp;
753 
754  return Expr<MulOpBinOp,T,D,D2,R>(MulOpBinOp(MulOp<T>(),
755  Constant<A>(lhs),rhs));
756 }
757 
758 
759 //=============================================================================
760 // DivOp
761 //=============================================================================
762 /**
763  Division (element-wise) Operation Class
764 
765  @ingroup Expression
766  */
767 template <class T>
768 class DivOp {
769 public:
770  static inline T apply(const T& lhs, const T& rhs) {
771  return lhs / rhs;
772  }
773 };
774 
775 /**
776  Element by element division of vectors of the same dimension: v3(i) = v1(i)/v2(i)
777  returning a vector expression
778 
779  @ingroup VectFunction
780  */
781 //==============================================================================
782 // operator/ (SVector, binary)
783 //==============================================================================
784 template < class T, unsigned int D>
785 inline VecExpr<BinaryOp<DivOp<T>, SVector<T,D>, SVector<T,D>, T>, T, D>
786  operator/(const SVector<T,D>& lhs, const SVector<T,D>& rhs) {
787  typedef BinaryOp<DivOp<T>, SVector<T,D>, SVector<T,D>, T> DivOpBinOp;
788 
789  return VecExpr<DivOpBinOp,T,D>(DivOpBinOp(DivOp<T>(),lhs,rhs));
790 }
791 
792 
793 //==============================================================================
794 // operator/ (SVector, binary)
795 //==============================================================================
796 template <class A, class T, unsigned int D>
797 inline VecExpr<BinaryOp<DivOp<T>, VecExpr<A,T,D>, SVector<T,D>, T>, T, D>
798  operator/(const VecExpr<A,T,D>& lhs, const SVector<T,D>& rhs) {
799  typedef BinaryOp<DivOp<T>, VecExpr<A,T,D>, SVector<T,D>, T> DivOpBinOp;
800  return VecExpr<DivOpBinOp,T,D>(DivOpBinOp(DivOp<T>(),lhs,rhs));
801 }
802 
803 
804 //==============================================================================
805 // operator/ (SVector, binary)
806 //==============================================================================
807 template < class A, class T, unsigned int D>
808 inline VecExpr<BinaryOp<DivOp<T>, SVector<T,D>, VecExpr<A,T,D>, T>, T, D>
809  operator/(const SVector<T,D>& lhs, const VecExpr<A,T,D>& rhs) {
810  typedef BinaryOp<DivOp<T>, SVector<T,D>, VecExpr<A,T,D>, T> DivOpBinOp;
811 
812  return VecExpr<DivOpBinOp,T,D>(DivOpBinOp(DivOp<T>(),lhs,rhs));
813 }
814 
815 
816 //=============================================================================
817 // operator/ (SVector, binary)
818 //=============================================================================
819 template <class A, class B, class T, unsigned int D>
820 inline VecExpr<BinaryOp<DivOp<T>, VecExpr<A,T,D>, VecExpr<B,T,D>, T>, T, D>
821  operator/(const VecExpr<A,T,D>& lhs, const VecExpr<B,T,D>& rhs) {
822  typedef BinaryOp<DivOp<T>, VecExpr<A,T,D>, VecExpr<B,T,D>, T> DivOpBinOp;
823 
824  return VecExpr<DivOpBinOp,T,D>(DivOpBinOp(DivOp<T>(),lhs,rhs));
825 }
826 
827 
828 /**
829  Division of the vector element by a scalar value: v2(i) = v1(i)/a
830  returning a vector expression
831 
832  @ingroup VectFunction
833 */
834 //==============================================================================
835 // operator/ (SVector, binary, Constant)
836 //==============================================================================
837 template <class A, class T, unsigned int D>
838 inline VecExpr<BinaryOpCopyR<DivOp<T>, SVector<T,D>, Constant<A>, T>, T, D>
839  operator/(const SVector<T,D>& lhs, const A& rhs) {
840  typedef BinaryOpCopyR<DivOp<T>, SVector<T,D>, Constant<A>, T> DivOpBinOp;
841 
842  return VecExpr<DivOpBinOp,T,D>(DivOpBinOp(DivOp<T>(),lhs,Constant<A>(rhs)));
843 }
844 
845 /**
846  Division of a scalar value by the vector element: v2(i) = a/v1(i)
847  returning a vector expression
848 
849  @ingroup VectFunction
850 */
851 //==============================================================================
852 // operator/ (SVector, binary, Constant)
853 //==============================================================================
854 template <class A, class T, unsigned int D>
855 inline VecExpr<BinaryOpCopyL<DivOp<T>, Constant<A>, SVector<T,D>, T>, T, D>
856  operator/(const A& lhs, const SVector<T,D>& rhs) {
857  typedef BinaryOpCopyL<DivOp<T>, Constant<A>, SVector<T,D>, T> DivOpBinOp;
858 
859  return VecExpr<DivOpBinOp,T,D>(DivOpBinOp(DivOp<T>(),Constant<A>(lhs),rhs));
860 }
861 
862 
863 //==============================================================================
864 // operator/ (SVector, binary, Constant)
865 //==============================================================================
866 template <class A, class B, class T, unsigned int D>
867 inline VecExpr<BinaryOpCopyR<DivOp<T>, VecExpr<B,T,D>, Constant<A>, T>, T, D>
868  operator/(const VecExpr<B,T,D>& lhs, const A& rhs) {
869  typedef BinaryOpCopyR<DivOp<T>, VecExpr<B,T,D>, Constant<A>, T> DivOpBinOp;
870 
871  return VecExpr<DivOpBinOp,T,D>(DivOpBinOp(DivOp<T>(),lhs,Constant<A>(rhs)));
872 }
873 
874 //==============================================================================
875 // operator/ (SVector, binary, Constant)
876 //==============================================================================
877 template <class A, class B, class T, unsigned int D>
878 inline VecExpr<BinaryOpCopyL<DivOp<T>, Constant<A>, VecExpr<B,T,D>, T>, T, D>
879  operator/(const A& lhs, const VecExpr<B,T,D>& rhs) {
880  typedef BinaryOpCopyL<DivOp<T>, Constant<A>, VecExpr<B,T,D>, T> DivOpBinOp;
881 
882  return VecExpr<DivOpBinOp,T,D>(DivOpBinOp(DivOp<T>(),Constant<A>(lhs),rhs));
883 }
884 
885 
886 /**
887  Division (element wise) of two matrices of the same dimensions: C(i,j) = A(i,j) / B(i,j)
888  returning a matrix expression
889 
890  @ingroup MatrixFunctions
891 */
892 //==============================================================================
893 // Div (SMatrix, binary)
894 //==============================================================================
895 template < class T, unsigned int D, unsigned int D2, class R1, class R2>
896 inline Expr<BinaryOp<DivOp<T>, SMatrix<T,D,D2,R1>, SMatrix<T,D,D2,R2>, T>, T, D, D2, typename AddPolicy<T,D,D2,R1,R2>::RepType>
897  Div(const SMatrix<T,D,D2,R1>& lhs, const SMatrix<T,D,D2,R2>& rhs) {
898  typedef BinaryOp<DivOp<T>, SMatrix<T,D,D2,R1>, SMatrix<T,D,D2,R2>, T> DivOpBinOp;
899 
900  return Expr<DivOpBinOp,T,D,D2,typename AddPolicy<T,D,D2,R1,R2>::RepType>(DivOpBinOp(DivOp<T>(),lhs,rhs));
901 }
902 
903 
904 //==============================================================================
905 // Div (SMatrix, binary)
906 //==============================================================================
907 template <class A, class T, unsigned int D, unsigned int D2, class R1, class R2>
908 inline Expr<BinaryOp<DivOp<T>, Expr<A,T,D,D2,R1>, SMatrix<T,D,D2,R2>, T>, T, D, D2, typename AddPolicy<T,D,D2,R1,R2>::RepType>
909  Div(const Expr<A,T,D,D2,R1>& lhs, const SMatrix<T,D,D2,R2>& rhs) {
910  typedef BinaryOp<DivOp<T>, Expr<A,T,D,D2,R1>, SMatrix<T,D,D2,R2>, T> DivOpBinOp;
911 
912  return Expr<DivOpBinOp,T,D,D2,typename AddPolicy<T,D,D2,R1,R2>::RepType>(DivOpBinOp(DivOp<T>(),lhs,rhs));
913 }
914 
915 
916 //==============================================================================
917 // Div (SMatrix, binary)
918 //==============================================================================
919 template < class A, class T, unsigned int D, unsigned int D2, class R1, class R2>
920 inline Expr<BinaryOp<DivOp<T>, SMatrix<T,D,D2,R1>, Expr<A,T,D,D2,R2>, T>, T, D, D2, typename AddPolicy<T,D,D2,R1,R2>::RepType>
921  Div(const SMatrix<T,D,D2,R1>& lhs, const Expr<A,T,D,D2,R2>& rhs) {
922  typedef BinaryOp<DivOp<T>, SMatrix<T,D,D2,R1>, Expr<A,T,D,D2,R2>, T> DivOpBinOp;
923 
924  return Expr<DivOpBinOp,T,D,D2,typename AddPolicy<T,D,D2,R1,R2>::RepType>(DivOpBinOp(DivOp<T>(),lhs,rhs));
925 }
926 
927 
928 //==============================================================================
929 // Div (SMatrix, binary)
930 //==============================================================================
931 template <class A, class B, class T, unsigned int D, unsigned int D2, class R1, class R2>
932 inline Expr<BinaryOp<DivOp<T>, Expr<A,T,D,D2,R1>, Expr<B,T,D,D2,R2>, T>, T, D, D2,typename AddPolicy<T,D,D2,R1,R2>::RepType>
933  Div(const Expr<A,T,D,D2,R1>& lhs, const Expr<B,T,D,D2,R2>& rhs) {
934  typedef BinaryOp<DivOp<T>, Expr<A,T,D,D2,R1>, Expr<B,T,D,D2,R2>, T> DivOpBinOp;
935 
936  return Expr<DivOpBinOp,T,D,D2,typename AddPolicy<T,D,D2,R1,R2>::RepType>(DivOpBinOp(DivOp<T>(),lhs,rhs));
937 }
938 
939 
940 /**
941  Division (element wise) of a matrix and a scalar, B(i,j) = A(i,j) / s
942  returning a matrix expression
943 
944  @ingroup MatrixFunctions
945 */
946 //=============================================================================
947 // operator/ (SMatrix, binary, Constant)
948 //=============================================================================
949 template <class A, class T, unsigned int D, unsigned int D2, class R>
950 inline Expr<BinaryOpCopyR<DivOp<T>, SMatrix<T,D,D2,R>, Constant<A>, T>, T, D, D2, R>
951  operator/(const SMatrix<T,D,D2,R>& lhs, const A& rhs) {
952  typedef BinaryOpCopyR<DivOp<T>, SMatrix<T,D,D2,R>, Constant<A>, T> DivOpBinOp;
953 
954  return Expr<DivOpBinOp,T,D,D2,R>(DivOpBinOp(DivOp<T>(),
955  lhs,Constant<A>(rhs)));
956 }
957 
958 /**
959  Division (element wise) of a matrix and a scalar, B(i,j) = s / A(i,j)
960  returning a matrix expression
961 
962  @ingroup MatrixFunctions
963 */
964 //==============================================================================
965 // operator/ (SMatrix, binary, Constant)
966 //==============================================================================
967 template <class A, class T, unsigned int D, unsigned int D2, class R>
968 inline Expr<BinaryOpCopyL<DivOp<T>, Constant<A>, SMatrix<T,D,D2,R>, T>, T, D, D2, R>
969  operator/(const A& lhs, const SMatrix<T,D,D2,R>& rhs) {
970  typedef BinaryOpCopyL<DivOp<T>, Constant<A>, SMatrix<T,D,D2,R>, T> DivOpBinOp;
971 
972  return Expr<DivOpBinOp,T,D,D2,R>(DivOpBinOp(DivOp<T>(),
973  Constant<A>(lhs),rhs));
974 }
975 
976 
977 //==============================================================================
978 // operator/ (SMatrix, binary, Constant)
979 //==============================================================================
980 template <class A, class B, class T, unsigned int D, unsigned int D2, class R>
981 inline Expr<BinaryOpCopyR<DivOp<T>, Expr<B,T,D,D2,R>, Constant<A>, T>, T, D, D2, R>
982  operator/(const Expr<B,T,D,D2,R>& lhs, const A& rhs) {
983  typedef BinaryOpCopyR<DivOp<T>, Expr<B,T,D,D2,R>, Constant<A>, T> DivOpBinOp;
984 
985  return Expr<DivOpBinOp,T,D,D2,R>(DivOpBinOp(DivOp<T>(),
986  lhs,Constant<A>(rhs)));
987 }
988 
989 //==============================================================================
990 // operator/ (SMatrix, binary, Constant)
991 //==============================================================================
992 template <class A, class B, class T, unsigned int D, unsigned int D2, class R>
993 inline Expr<BinaryOpCopyL<DivOp<T>, Constant<A>, Expr<B,T,D,D2,R>, T>, T, D, D2,R>
994  operator/(const A& lhs, const Expr<B,T,D,D2,R>& rhs) {
995  typedef BinaryOpCopyL<DivOp<T>, Constant<A>, Expr<B,T,D,D2,R>, T> DivOpBinOp;
996 
997  return Expr<DivOpBinOp,T,D,D2,R>(DivOpBinOp(DivOp<T>(),Constant<A>(lhs),rhs));
998 }
999 
1000 
1001 
1002  } // namespace Math
1003 
1004 } // namespace ROOT
1005 
1006 
1007 #endif /*ROOT_Math_BinaryOperators */
ROOT::Math::Constant
Constant expression class A class representing constant expressions (literals) in the parse tree...
Definition: Expression.h:400
ROOT::Math::MulOp
Multiplication (element-wise) Operation Class.
Definition: BinaryOperators.h:531
ROOT
This namespace contains pre-defined functions to be used in conjuction with TExecutor::Map and TExecu...
Definition: StringConv.hxx:21
ROOT::Math::DivOp
Division (element-wise) Operation Class.
Definition: BinaryOperators.h:768
ROOT::Math::Chebyshev::T
double T(double x)
Definition: ChebyshevPol.h:34
ROOT::Math::BinaryOpCopyL
Binary Operation class with value storage for the left argument.
Definition: Expression.h:277
ROOT::Math::Times
Expr< BinaryOp< MulOp< T >, SMatrix< T, D, D2, R1 >, SMatrix< T, D, D2, R2 >, T >, T, D, D2, typename AddPolicy< T, D, D2, R1, R2 >::RepType > Times(const SMatrix< T, D, D2, R1 > &lhs, const SMatrix< T, D, D2, R2 > &rhs)
Element by element matrix multiplication C(i,j) = A(i,j)*B(i,j) returning a matrix expression...
Definition: BinaryOperators.h:654
ROOT::Math::MinOp
Subtraction Operation Class.
Definition: BinaryOperators.h:289
ROOT::Math::Cephes::A
static double A[]
Definition: SpecFuncCephes.cxx:170
ROOT::Math::operator+
DisplacementVector2D< CoordSystem1, U > operator+(DisplacementVector2D< CoordSystem1, U > v1, const DisplacementVector2D< CoordSystem2, U > &v2)
Addition of DisplacementVector2D vectors.
Definition: DisplacementVector2D.h:443
ROOT::Math::MulOp::apply
static T apply(const T &lhs, const T &rhs)
Definition: BinaryOperators.h:533
ROOT::Math::operator-
DisplacementVector2D< CoordSystem1, U > operator-(DisplacementVector2D< CoordSystem1, U > v1, DisplacementVector2D< CoordSystem2, U > const &v2)
Difference between two DisplacementVector2D vectors.
Definition: DisplacementVector2D.h:456
ROOT::Math::SMatrix
SMatrix: a generic fixed size D1 x D2 Matrix class.
Definition: BinaryOperators.h:33
ROOT::Math::MatRepStd
Expression wrapper class for Matrix objects.
Definition: Expression.h:134
ROOT::Math::BinaryOpCopyR
Binary Operation class with value storage for the right argument.
Definition: Expression.h:318
ROOT::Math::AddOp::apply
static T apply(const T &lhs, const T &rhs)
Definition: BinaryOperators.h:47
ROOT::Math::BinaryOp
BinaryOperation class A class representing binary operators in the parse tree.
Definition: Expression.h:234
ROOT::Math::AddOp
Addition Operation Class.
Definition: BinaryOperators.h:45
ROOT::Math::MinOp::apply
static T apply(const T &lhs, const T &rhs)
Definition: BinaryOperators.h:291
ROOT::Math::operator/
VecExpr< BinaryOp< DivOp< T >, SVector< T, D >, SVector< T, D >, T >, T, D > operator/(const SVector< T, D > &lhs, const SVector< T, D > &rhs)
Element by element division of vectors of the same dimension: v3(i) = v1(i)/v2(i) returning a vector ...
Definition: BinaryOperators.h:786
ROOT::Math::Div
Expr< BinaryOp< DivOp< T >, SMatrix< T, D, D2, R1 >, SMatrix< T, D, D2, R2 >, T >, T, D, D2, typename AddPolicy< T, D, D2, R1, R2 >::RepType > Div(const SMatrix< T, D, D2, R1 > &lhs, const SMatrix< T, D, D2, R2 > &rhs)
Division (element wise) of two matrices of the same dimensions: C(i,j) = A(i,j) / B(i...
Definition: BinaryOperators.h:897
ROOT::Math::DivOp::apply
static T apply(const T &lhs, const T &rhs)
Definition: BinaryOperators.h:770
Math
Namespace for new Math classes and functions.
ROOT::Math::VecExpr
Expression wrapper class for Vector objects.
Definition: Expression.h:64
R
TRandom3 R
a TMatrixD.
Definition: testIO.cxx:28
ROOT::Math::operator*
AxisAngle operator*(RotationX const &r1, AxisAngle const &r2)
Multiplication of an axial rotation by an AxisAngle.
Definition: AxisAngleXother.cxx:182
ROOT::Math::SVector
SVector: a generic fixed size Vector class.
Definition: BinaryOperators.h:32