Context Navigation

source: XMLIO_V2/external/include/blitz/matbops.h @ 73

Last change on this file since 73 was 73, checked in by ymipsl, 14 years ago

Property svn:eol-style set to `native`
File size: 178.6 KB

Line
1	// Generated source file. Do not edit.
2	// Created by: genmatbops.cpp Dec 10 2003 17:58:20
3
4	#ifndef BZ_MATBOPS_H
5	#define BZ_MATBOPS_H
6
7	BZ_NAMESPACE(blitz)
8
9	#ifndef BZ_MATEXPR_H
10	#error <blitz/matbops.h> must be included via <blitz/matexpr.h>
11	#endif
12
13	/****************************************************************************
14	* Addition Operators
15	****************************************************************************/
16
17	// Matrix<P_numtype1, P_struct1> + Matrix<P_numtype2, P_struct2>
18	template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
19	inline
20	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
21	_bz_MatrixRef<P_numtype2, P_struct2>,
22	_bz_Add<P_numtype1, P_numtype2 > > >
23	operator+(const Matrix<P_numtype1, P_struct1>& d1,
24	const Matrix<P_numtype2, P_struct2>& d2)
25	{
26	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
27	_bz_MatrixRef<P_numtype2, P_struct2>,
28	_bz_Add<P_numtype1, P_numtype2> > T_expr;
29
30	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
31	d2._bz_getRef()));
32	}
33
34	// Matrix<P_numtype1, P_struct1> + _bz_MatExpr<P_expr2>
35	template<class P_numtype1, class P_struct1, class P_expr2>
36	inline
37	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
38	_bz_MatExpr<P_expr2>,
39	_bz_Add<P_numtype1, typename P_expr2::T_numtype > > >
40	operator+(const Matrix<P_numtype1, P_struct1>& d1,
41	_bz_MatExpr<P_expr2> d2)
42	{
43	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
44	_bz_MatExpr<P_expr2>,
45	_bz_Add<P_numtype1, typename P_expr2::T_numtype> > T_expr;
46
47	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
48	d2));
49	}
50
51	// Matrix<P_numtype1, P_struct1> + int
52	template<class P_numtype1, class P_struct1>
53	inline
54	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
55	_bz_MatExprConstant<int>,
56	_bz_Add<P_numtype1, int > > >
57	operator+(const Matrix<P_numtype1, P_struct1>& d1,
58	int d2)
59	{
60	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
61	_bz_MatExprConstant<int>,
62	_bz_Add<P_numtype1, int> > T_expr;
63
64	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
65	_bz_MatExprConstant<int>(d2)));
66	}
67
68	// Matrix<P_numtype1, P_struct1> + float
69	template<class P_numtype1, class P_struct1>
70	inline
71	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
72	_bz_MatExprConstant<float>,
73	_bz_Add<P_numtype1, float > > >
74	operator+(const Matrix<P_numtype1, P_struct1>& d1,
75	float d2)
76	{
77	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
78	_bz_MatExprConstant<float>,
79	_bz_Add<P_numtype1, float> > T_expr;
80
81	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
82	_bz_MatExprConstant<float>(d2)));
83	}
84
85	// Matrix<P_numtype1, P_struct1> + double
86	template<class P_numtype1, class P_struct1>
87	inline
88	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
89	_bz_MatExprConstant<double>,
90	_bz_Add<P_numtype1, double > > >
91	operator+(const Matrix<P_numtype1, P_struct1>& d1,
92	double d2)
93	{
94	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
95	_bz_MatExprConstant<double>,
96	_bz_Add<P_numtype1, double> > T_expr;
97
98	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
99	_bz_MatExprConstant<double>(d2)));
100	}
101
102	// Matrix<P_numtype1, P_struct1> + long double
103	template<class P_numtype1, class P_struct1>
104	inline
105	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
106	_bz_MatExprConstant<long double>,
107	_bz_Add<P_numtype1, long double > > >
108	operator+(const Matrix<P_numtype1, P_struct1>& d1,
109	long double d2)
110	{
111	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
112	_bz_MatExprConstant<long double>,
113	_bz_Add<P_numtype1, long double> > T_expr;
114
115	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
116	_bz_MatExprConstant<long double>(d2)));
117	}
118	#ifdef BZ_HAVE_COMPLEX
119
120	// Matrix<P_numtype1, P_struct1> + complex<T2>
121	template<class P_numtype1, class P_struct1, class T2>
122	inline
123	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
124	_bz_MatExprConstant<complex<T2> > ,
125	_bz_Add<P_numtype1, complex<T2> > > >
126	operator+(const Matrix<P_numtype1, P_struct1>& d1,
127	complex<T2> d2)
128	{
129	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
130	_bz_MatExprConstant<complex<T2> > ,
131	_bz_Add<P_numtype1, complex<T2> > > T_expr;
132
133	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
134	_bz_MatExprConstant<complex<T2> > (d2)));
135	}
136	#endif // BZ_HAVE_COMPLEX
137
138
139	// _bz_MatExpr<P_expr1> + Matrix<P_numtype2, P_struct2>
140	template<class P_expr1, class P_numtype2, class P_struct2>
141	inline
142	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
143	_bz_MatrixRef<P_numtype2, P_struct2>,
144	_bz_Add<typename P_expr1::T_numtype, P_numtype2 > > >
145	operator+(_bz_MatExpr<P_expr1> d1,
146	const Matrix<P_numtype2, P_struct2>& d2)
147	{
148	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
149	_bz_MatrixRef<P_numtype2, P_struct2>,
150	_bz_Add<typename P_expr1::T_numtype, P_numtype2> > T_expr;
151
152	return _bz_MatExpr<T_expr>(T_expr(d1,
153	d2._bz_getRef()));
154	}
155
156	// _bz_MatExpr<P_expr1> + _bz_MatExpr<P_expr2>
157	template<class P_expr1, class P_expr2>
158	inline
159	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
160	_bz_MatExpr<P_expr2>,
161	_bz_Add<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
162	operator+(_bz_MatExpr<P_expr1> d1,
163	_bz_MatExpr<P_expr2> d2)
164	{
165	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
166	_bz_MatExpr<P_expr2>,
167	_bz_Add<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
168
169	return _bz_MatExpr<T_expr>(T_expr(d1,
170	d2));
171	}
172
173	// _bz_MatExpr<P_expr1> + int
174	template<class P_expr1>
175	inline
176	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
177	_bz_MatExprConstant<int>,
178	_bz_Add<typename P_expr1::T_numtype, int > > >
179	operator+(_bz_MatExpr<P_expr1> d1,
180	int d2)
181	{
182	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
183	_bz_MatExprConstant<int>,
184	_bz_Add<typename P_expr1::T_numtype, int> > T_expr;
185
186	return _bz_MatExpr<T_expr>(T_expr(d1,
187	_bz_MatExprConstant<int>(d2)));
188	}
189
190	// _bz_MatExpr<P_expr1> + float
191	template<class P_expr1>
192	inline
193	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
194	_bz_MatExprConstant<float>,
195	_bz_Add<typename P_expr1::T_numtype, float > > >
196	operator+(_bz_MatExpr<P_expr1> d1,
197	float d2)
198	{
199	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
200	_bz_MatExprConstant<float>,
201	_bz_Add<typename P_expr1::T_numtype, float> > T_expr;
202
203	return _bz_MatExpr<T_expr>(T_expr(d1,
204	_bz_MatExprConstant<float>(d2)));
205	}
206
207	// _bz_MatExpr<P_expr1> + double
208	template<class P_expr1>
209	inline
210	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
211	_bz_MatExprConstant<double>,
212	_bz_Add<typename P_expr1::T_numtype, double > > >
213	operator+(_bz_MatExpr<P_expr1> d1,
214	double d2)
215	{
216	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
217	_bz_MatExprConstant<double>,
218	_bz_Add<typename P_expr1::T_numtype, double> > T_expr;
219
220	return _bz_MatExpr<T_expr>(T_expr(d1,
221	_bz_MatExprConstant<double>(d2)));
222	}
223
224	// _bz_MatExpr<P_expr1> + long double
225	template<class P_expr1>
226	inline
227	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
228	_bz_MatExprConstant<long double>,
229	_bz_Add<typename P_expr1::T_numtype, long double > > >
230	operator+(_bz_MatExpr<P_expr1> d1,
231	long double d2)
232	{
233	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
234	_bz_MatExprConstant<long double>,
235	_bz_Add<typename P_expr1::T_numtype, long double> > T_expr;
236
237	return _bz_MatExpr<T_expr>(T_expr(d1,
238	_bz_MatExprConstant<long double>(d2)));
239	}
240	#ifdef BZ_HAVE_COMPLEX
241
242	// _bz_MatExpr<P_expr1> + complex<T2>
243	template<class P_expr1, class T2>
244	inline
245	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
246	_bz_MatExprConstant<complex<T2> > ,
247	_bz_Add<typename P_expr1::T_numtype, complex<T2> > > >
248	operator+(_bz_MatExpr<P_expr1> d1,
249	complex<T2> d2)
250	{
251	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
252	_bz_MatExprConstant<complex<T2> > ,
253	_bz_Add<typename P_expr1::T_numtype, complex<T2> > > T_expr;
254
255	return _bz_MatExpr<T_expr>(T_expr(d1,
256	_bz_MatExprConstant<complex<T2> > (d2)));
257	}
258	#endif // BZ_HAVE_COMPLEX
259
260
261	// int + Matrix<P_numtype2, P_struct2>
262	template<class P_numtype2, class P_struct2>
263	inline
264	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
265	_bz_MatrixRef<P_numtype2, P_struct2>,
266	_bz_Add<int, P_numtype2 > > >
267	operator+(int d1,
268	const Matrix<P_numtype2, P_struct2>& d2)
269	{
270	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
271	_bz_MatrixRef<P_numtype2, P_struct2>,
272	_bz_Add<int, P_numtype2> > T_expr;
273
274	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
275	d2._bz_getRef()));
276	}
277
278	// int + _bz_MatExpr<P_expr2>
279	template<class P_expr2>
280	inline
281	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
282	_bz_MatExpr<P_expr2>,
283	_bz_Add<int, typename P_expr2::T_numtype > > >
284	operator+(int d1,
285	_bz_MatExpr<P_expr2> d2)
286	{
287	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
288	_bz_MatExpr<P_expr2>,
289	_bz_Add<int, typename P_expr2::T_numtype> > T_expr;
290
291	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
292	d2));
293	}
294
295	// float + Matrix<P_numtype2, P_struct2>
296	template<class P_numtype2, class P_struct2>
297	inline
298	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>,
299	_bz_MatrixRef<P_numtype2, P_struct2>,
300	_bz_Add<float, P_numtype2 > > >
301	operator+(float d1,
302	const Matrix<P_numtype2, P_struct2>& d2)
303	{
304	typedef _bz_MatExprOp<_bz_MatExprConstant<float>,
305	_bz_MatrixRef<P_numtype2, P_struct2>,
306	_bz_Add<float, P_numtype2> > T_expr;
307
308	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1),
309	d2._bz_getRef()));
310	}
311
312	// float + _bz_MatExpr<P_expr2>
313	template<class P_expr2>
314	inline
315	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>,
316	_bz_MatExpr<P_expr2>,
317	_bz_Add<float, typename P_expr2::T_numtype > > >
318	operator+(float d1,
319	_bz_MatExpr<P_expr2> d2)
320	{
321	typedef _bz_MatExprOp<_bz_MatExprConstant<float>,
322	_bz_MatExpr<P_expr2>,
323	_bz_Add<float, typename P_expr2::T_numtype> > T_expr;
324
325	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1),
326	d2));
327	}
328
329	// double + Matrix<P_numtype2, P_struct2>
330	template<class P_numtype2, class P_struct2>
331	inline
332	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>,
333	_bz_MatrixRef<P_numtype2, P_struct2>,
334	_bz_Add<double, P_numtype2 > > >
335	operator+(double d1,
336	const Matrix<P_numtype2, P_struct2>& d2)
337	{
338	typedef _bz_MatExprOp<_bz_MatExprConstant<double>,
339	_bz_MatrixRef<P_numtype2, P_struct2>,
340	_bz_Add<double, P_numtype2> > T_expr;
341
342	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1),
343	d2._bz_getRef()));
344	}
345
346	// double + _bz_MatExpr<P_expr2>
347	template<class P_expr2>
348	inline
349	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>,
350	_bz_MatExpr<P_expr2>,
351	_bz_Add<double, typename P_expr2::T_numtype > > >
352	operator+(double d1,
353	_bz_MatExpr<P_expr2> d2)
354	{
355	typedef _bz_MatExprOp<_bz_MatExprConstant<double>,
356	_bz_MatExpr<P_expr2>,
357	_bz_Add<double, typename P_expr2::T_numtype> > T_expr;
358
359	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1),
360	d2));
361	}
362
363	// long double + Matrix<P_numtype2, P_struct2>
364	template<class P_numtype2, class P_struct2>
365	inline
366	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>,
367	_bz_MatrixRef<P_numtype2, P_struct2>,
368	_bz_Add<long double, P_numtype2 > > >
369	operator+(long double d1,
370	const Matrix<P_numtype2, P_struct2>& d2)
371	{
372	typedef _bz_MatExprOp<_bz_MatExprConstant<long double>,
373	_bz_MatrixRef<P_numtype2, P_struct2>,
374	_bz_Add<long double, P_numtype2> > T_expr;
375
376	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1),
377	d2._bz_getRef()));
378	}
379
380	// long double + _bz_MatExpr<P_expr2>
381	template<class P_expr2>
382	inline
383	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>,
384	_bz_MatExpr<P_expr2>,
385	_bz_Add<long double, typename P_expr2::T_numtype > > >
386	operator+(long double d1,
387	_bz_MatExpr<P_expr2> d2)
388	{
389	typedef _bz_MatExprOp<_bz_MatExprConstant<long double>,
390	_bz_MatExpr<P_expr2>,
391	_bz_Add<long double, typename P_expr2::T_numtype> > T_expr;
392
393	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1),
394	d2));
395	}
396	#ifdef BZ_HAVE_COMPLEX
397
398	// complex<T1> + Matrix<P_numtype2, P_struct2>
399	template<class T1, class P_numtype2, class P_struct2>
400	inline
401	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
402	_bz_MatrixRef<P_numtype2, P_struct2>,
403	_bz_Add<complex<T1> , P_numtype2 > > >
404	operator+(complex<T1> d1,
405	const Matrix<P_numtype2, P_struct2>& d2)
406	{
407	typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
408	_bz_MatrixRef<P_numtype2, P_struct2>,
409	_bz_Add<complex<T1> , P_numtype2> > T_expr;
410
411	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1),
412	d2._bz_getRef()));
413	}
414	#endif // BZ_HAVE_COMPLEX
415
416	#ifdef BZ_HAVE_COMPLEX
417
418	// complex<T1> + _bz_MatExpr<P_expr2>
419	template<class T1, class P_expr2>
420	inline
421	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
422	_bz_MatExpr<P_expr2>,
423	_bz_Add<complex<T1> , typename P_expr2::T_numtype > > >
424	operator+(complex<T1> d1,
425	_bz_MatExpr<P_expr2> d2)
426	{
427	typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
428	_bz_MatExpr<P_expr2>,
429	_bz_Add<complex<T1> , typename P_expr2::T_numtype> > T_expr;
430
431	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1),
432	d2));
433	}
434	#endif // BZ_HAVE_COMPLEX
435
436	/****************************************************************************
437	* Subtraction Operators
438	****************************************************************************/
439
440	// Matrix<P_numtype1, P_struct1> - Matrix<P_numtype2, P_struct2>
441	template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
442	inline
443	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
444	_bz_MatrixRef<P_numtype2, P_struct2>,
445	_bz_Subtract<P_numtype1, P_numtype2 > > >
446	operator-(const Matrix<P_numtype1, P_struct1>& d1,
447	const Matrix<P_numtype2, P_struct2>& d2)
448	{
449	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
450	_bz_MatrixRef<P_numtype2, P_struct2>,
451	_bz_Subtract<P_numtype1, P_numtype2> > T_expr;
452
453	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
454	d2._bz_getRef()));
455	}
456
457	// Matrix<P_numtype1, P_struct1> - _bz_MatExpr<P_expr2>
458	template<class P_numtype1, class P_struct1, class P_expr2>
459	inline
460	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
461	_bz_MatExpr<P_expr2>,
462	_bz_Subtract<P_numtype1, typename P_expr2::T_numtype > > >
463	operator-(const Matrix<P_numtype1, P_struct1>& d1,
464	_bz_MatExpr<P_expr2> d2)
465	{
466	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
467	_bz_MatExpr<P_expr2>,
468	_bz_Subtract<P_numtype1, typename P_expr2::T_numtype> > T_expr;
469
470	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
471	d2));
472	}
473
474	// Matrix<P_numtype1, P_struct1> - int
475	template<class P_numtype1, class P_struct1>
476	inline
477	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
478	_bz_MatExprConstant<int>,
479	_bz_Subtract<P_numtype1, int > > >
480	operator-(const Matrix<P_numtype1, P_struct1>& d1,
481	int d2)
482	{
483	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
484	_bz_MatExprConstant<int>,
485	_bz_Subtract<P_numtype1, int> > T_expr;
486
487	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
488	_bz_MatExprConstant<int>(d2)));
489	}
490
491	// Matrix<P_numtype1, P_struct1> - float
492	template<class P_numtype1, class P_struct1>
493	inline
494	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
495	_bz_MatExprConstant<float>,
496	_bz_Subtract<P_numtype1, float > > >
497	operator-(const Matrix<P_numtype1, P_struct1>& d1,
498	float d2)
499	{
500	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
501	_bz_MatExprConstant<float>,
502	_bz_Subtract<P_numtype1, float> > T_expr;
503
504	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
505	_bz_MatExprConstant<float>(d2)));
506	}
507
508	// Matrix<P_numtype1, P_struct1> - double
509	template<class P_numtype1, class P_struct1>
510	inline
511	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
512	_bz_MatExprConstant<double>,
513	_bz_Subtract<P_numtype1, double > > >
514	operator-(const Matrix<P_numtype1, P_struct1>& d1,
515	double d2)
516	{
517	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
518	_bz_MatExprConstant<double>,
519	_bz_Subtract<P_numtype1, double> > T_expr;
520
521	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
522	_bz_MatExprConstant<double>(d2)));
523	}
524
525	// Matrix<P_numtype1, P_struct1> - long double
526	template<class P_numtype1, class P_struct1>
527	inline
528	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
529	_bz_MatExprConstant<long double>,
530	_bz_Subtract<P_numtype1, long double > > >
531	operator-(const Matrix<P_numtype1, P_struct1>& d1,
532	long double d2)
533	{
534	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
535	_bz_MatExprConstant<long double>,
536	_bz_Subtract<P_numtype1, long double> > T_expr;
537
538	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
539	_bz_MatExprConstant<long double>(d2)));
540	}
541	#ifdef BZ_HAVE_COMPLEX
542
543	// Matrix<P_numtype1, P_struct1> - complex<T2>
544	template<class P_numtype1, class P_struct1, class T2>
545	inline
546	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
547	_bz_MatExprConstant<complex<T2> > ,
548	_bz_Subtract<P_numtype1, complex<T2> > > >
549	operator-(const Matrix<P_numtype1, P_struct1>& d1,
550	complex<T2> d2)
551	{
552	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
553	_bz_MatExprConstant<complex<T2> > ,
554	_bz_Subtract<P_numtype1, complex<T2> > > T_expr;
555
556	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
557	_bz_MatExprConstant<complex<T2> > (d2)));
558	}
559	#endif // BZ_HAVE_COMPLEX
560
561
562	// _bz_MatExpr<P_expr1> - Matrix<P_numtype2, P_struct2>
563	template<class P_expr1, class P_numtype2, class P_struct2>
564	inline
565	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
566	_bz_MatrixRef<P_numtype2, P_struct2>,
567	_bz_Subtract<typename P_expr1::T_numtype, P_numtype2 > > >
568	operator-(_bz_MatExpr<P_expr1> d1,
569	const Matrix<P_numtype2, P_struct2>& d2)
570	{
571	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
572	_bz_MatrixRef<P_numtype2, P_struct2>,
573	_bz_Subtract<typename P_expr1::T_numtype, P_numtype2> > T_expr;
574
575	return _bz_MatExpr<T_expr>(T_expr(d1,
576	d2._bz_getRef()));
577	}
578
579	// _bz_MatExpr<P_expr1> - _bz_MatExpr<P_expr2>
580	template<class P_expr1, class P_expr2>
581	inline
582	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
583	_bz_MatExpr<P_expr2>,
584	_bz_Subtract<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
585	operator-(_bz_MatExpr<P_expr1> d1,
586	_bz_MatExpr<P_expr2> d2)
587	{
588	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
589	_bz_MatExpr<P_expr2>,
590	_bz_Subtract<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
591
592	return _bz_MatExpr<T_expr>(T_expr(d1,
593	d2));
594	}
595
596	// _bz_MatExpr<P_expr1> - int
597	template<class P_expr1>
598	inline
599	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
600	_bz_MatExprConstant<int>,
601	_bz_Subtract<typename P_expr1::T_numtype, int > > >
602	operator-(_bz_MatExpr<P_expr1> d1,
603	int d2)
604	{
605	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
606	_bz_MatExprConstant<int>,
607	_bz_Subtract<typename P_expr1::T_numtype, int> > T_expr;
608
609	return _bz_MatExpr<T_expr>(T_expr(d1,
610	_bz_MatExprConstant<int>(d2)));
611	}
612
613	// _bz_MatExpr<P_expr1> - float
614	template<class P_expr1>
615	inline
616	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
617	_bz_MatExprConstant<float>,
618	_bz_Subtract<typename P_expr1::T_numtype, float > > >
619	operator-(_bz_MatExpr<P_expr1> d1,
620	float d2)
621	{
622	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
623	_bz_MatExprConstant<float>,
624	_bz_Subtract<typename P_expr1::T_numtype, float> > T_expr;
625
626	return _bz_MatExpr<T_expr>(T_expr(d1,
627	_bz_MatExprConstant<float>(d2)));
628	}
629
630	// _bz_MatExpr<P_expr1> - double
631	template<class P_expr1>
632	inline
633	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
634	_bz_MatExprConstant<double>,
635	_bz_Subtract<typename P_expr1::T_numtype, double > > >
636	operator-(_bz_MatExpr<P_expr1> d1,
637	double d2)
638	{
639	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
640	_bz_MatExprConstant<double>,
641	_bz_Subtract<typename P_expr1::T_numtype, double> > T_expr;
642
643	return _bz_MatExpr<T_expr>(T_expr(d1,
644	_bz_MatExprConstant<double>(d2)));
645	}
646
647	// _bz_MatExpr<P_expr1> - long double
648	template<class P_expr1>
649	inline
650	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
651	_bz_MatExprConstant<long double>,
652	_bz_Subtract<typename P_expr1::T_numtype, long double > > >
653	operator-(_bz_MatExpr<P_expr1> d1,
654	long double d2)
655	{
656	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
657	_bz_MatExprConstant<long double>,
658	_bz_Subtract<typename P_expr1::T_numtype, long double> > T_expr;
659
660	return _bz_MatExpr<T_expr>(T_expr(d1,
661	_bz_MatExprConstant<long double>(d2)));
662	}
663	#ifdef BZ_HAVE_COMPLEX
664
665	// _bz_MatExpr<P_expr1> - complex<T2>
666	template<class P_expr1, class T2>
667	inline
668	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
669	_bz_MatExprConstant<complex<T2> > ,
670	_bz_Subtract<typename P_expr1::T_numtype, complex<T2> > > >
671	operator-(_bz_MatExpr<P_expr1> d1,
672	complex<T2> d2)
673	{
674	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
675	_bz_MatExprConstant<complex<T2> > ,
676	_bz_Subtract<typename P_expr1::T_numtype, complex<T2> > > T_expr;
677
678	return _bz_MatExpr<T_expr>(T_expr(d1,
679	_bz_MatExprConstant<complex<T2> > (d2)));
680	}
681	#endif // BZ_HAVE_COMPLEX
682
683
684	// int - Matrix<P_numtype2, P_struct2>
685	template<class P_numtype2, class P_struct2>
686	inline
687	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
688	_bz_MatrixRef<P_numtype2, P_struct2>,
689	_bz_Subtract<int, P_numtype2 > > >
690	operator-(int d1,
691	const Matrix<P_numtype2, P_struct2>& d2)
692	{
693	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
694	_bz_MatrixRef<P_numtype2, P_struct2>,
695	_bz_Subtract<int, P_numtype2> > T_expr;
696
697	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
698	d2._bz_getRef()));
699	}
700
701	// int - _bz_MatExpr<P_expr2>
702	template<class P_expr2>
703	inline
704	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
705	_bz_MatExpr<P_expr2>,
706	_bz_Subtract<int, typename P_expr2::T_numtype > > >
707	operator-(int d1,
708	_bz_MatExpr<P_expr2> d2)
709	{
710	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
711	_bz_MatExpr<P_expr2>,
712	_bz_Subtract<int, typename P_expr2::T_numtype> > T_expr;
713
714	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
715	d2));
716	}
717
718	// float - Matrix<P_numtype2, P_struct2>
719	template<class P_numtype2, class P_struct2>
720	inline
721	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>,
722	_bz_MatrixRef<P_numtype2, P_struct2>,
723	_bz_Subtract<float, P_numtype2 > > >
724	operator-(float d1,
725	const Matrix<P_numtype2, P_struct2>& d2)
726	{
727	typedef _bz_MatExprOp<_bz_MatExprConstant<float>,
728	_bz_MatrixRef<P_numtype2, P_struct2>,
729	_bz_Subtract<float, P_numtype2> > T_expr;
730
731	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1),
732	d2._bz_getRef()));
733	}
734
735	// float - _bz_MatExpr<P_expr2>
736	template<class P_expr2>
737	inline
738	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>,
739	_bz_MatExpr<P_expr2>,
740	_bz_Subtract<float, typename P_expr2::T_numtype > > >
741	operator-(float d1,
742	_bz_MatExpr<P_expr2> d2)
743	{
744	typedef _bz_MatExprOp<_bz_MatExprConstant<float>,
745	_bz_MatExpr<P_expr2>,
746	_bz_Subtract<float, typename P_expr2::T_numtype> > T_expr;
747
748	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1),
749	d2));
750	}
751
752	// double - Matrix<P_numtype2, P_struct2>
753	template<class P_numtype2, class P_struct2>
754	inline
755	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>,
756	_bz_MatrixRef<P_numtype2, P_struct2>,
757	_bz_Subtract<double, P_numtype2 > > >
758	operator-(double d1,
759	const Matrix<P_numtype2, P_struct2>& d2)
760	{
761	typedef _bz_MatExprOp<_bz_MatExprConstant<double>,
762	_bz_MatrixRef<P_numtype2, P_struct2>,
763	_bz_Subtract<double, P_numtype2> > T_expr;
764
765	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1),
766	d2._bz_getRef()));
767	}
768
769	// double - _bz_MatExpr<P_expr2>
770	template<class P_expr2>
771	inline
772	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>,
773	_bz_MatExpr<P_expr2>,
774	_bz_Subtract<double, typename P_expr2::T_numtype > > >
775	operator-(double d1,
776	_bz_MatExpr<P_expr2> d2)
777	{
778	typedef _bz_MatExprOp<_bz_MatExprConstant<double>,
779	_bz_MatExpr<P_expr2>,
780	_bz_Subtract<double, typename P_expr2::T_numtype> > T_expr;
781
782	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1),
783	d2));
784	}
785
786	// long double - Matrix<P_numtype2, P_struct2>
787	template<class P_numtype2, class P_struct2>
788	inline
789	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>,
790	_bz_MatrixRef<P_numtype2, P_struct2>,
791	_bz_Subtract<long double, P_numtype2 > > >
792	operator-(long double d1,
793	const Matrix<P_numtype2, P_struct2>& d2)
794	{
795	typedef _bz_MatExprOp<_bz_MatExprConstant<long double>,
796	_bz_MatrixRef<P_numtype2, P_struct2>,
797	_bz_Subtract<long double, P_numtype2> > T_expr;
798
799	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1),
800	d2._bz_getRef()));
801	}
802
803	// long double - _bz_MatExpr<P_expr2>
804	template<class P_expr2>
805	inline
806	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>,
807	_bz_MatExpr<P_expr2>,
808	_bz_Subtract<long double, typename P_expr2::T_numtype > > >
809	operator-(long double d1,
810	_bz_MatExpr<P_expr2> d2)
811	{
812	typedef _bz_MatExprOp<_bz_MatExprConstant<long double>,
813	_bz_MatExpr<P_expr2>,
814	_bz_Subtract<long double, typename P_expr2::T_numtype> > T_expr;
815
816	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1),
817	d2));
818	}
819	#ifdef BZ_HAVE_COMPLEX
820
821	// complex<T1> - Matrix<P_numtype2, P_struct2>
822	template<class T1, class P_numtype2, class P_struct2>
823	inline
824	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
825	_bz_MatrixRef<P_numtype2, P_struct2>,
826	_bz_Subtract<complex<T1> , P_numtype2 > > >
827	operator-(complex<T1> d1,
828	const Matrix<P_numtype2, P_struct2>& d2)
829	{
830	typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
831	_bz_MatrixRef<P_numtype2, P_struct2>,
832	_bz_Subtract<complex<T1> , P_numtype2> > T_expr;
833
834	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1),
835	d2._bz_getRef()));
836	}
837	#endif // BZ_HAVE_COMPLEX
838
839	#ifdef BZ_HAVE_COMPLEX
840
841	// complex<T1> - _bz_MatExpr<P_expr2>
842	template<class T1, class P_expr2>
843	inline
844	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
845	_bz_MatExpr<P_expr2>,
846	_bz_Subtract<complex<T1> , typename P_expr2::T_numtype > > >
847	operator-(complex<T1> d1,
848	_bz_MatExpr<P_expr2> d2)
849	{
850	typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
851	_bz_MatExpr<P_expr2>,
852	_bz_Subtract<complex<T1> , typename P_expr2::T_numtype> > T_expr;
853
854	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1),
855	d2));
856	}
857	#endif // BZ_HAVE_COMPLEX
858
859	/****************************************************************************
860	* Multiplication Operators
861	****************************************************************************/
862
863	// Matrix<P_numtype1, P_struct1> * Matrix<P_numtype2, P_struct2>
864	template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
865	inline
866	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
867	_bz_MatrixRef<P_numtype2, P_struct2>,
868	_bz_Multiply<P_numtype1, P_numtype2 > > >
869	operator*(const Matrix<P_numtype1, P_struct1>& d1,
870	const Matrix<P_numtype2, P_struct2>& d2)
871	{
872	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
873	_bz_MatrixRef<P_numtype2, P_struct2>,
874	_bz_Multiply<P_numtype1, P_numtype2> > T_expr;
875
876	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
877	d2._bz_getRef()));
878	}
879
880	// Matrix<P_numtype1, P_struct1> * _bz_MatExpr<P_expr2>
881	template<class P_numtype1, class P_struct1, class P_expr2>
882	inline
883	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
884	_bz_MatExpr<P_expr2>,
885	_bz_Multiply<P_numtype1, typename P_expr2::T_numtype > > >
886	operator*(const Matrix<P_numtype1, P_struct1>& d1,
887	_bz_MatExpr<P_expr2> d2)
888	{
889	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
890	_bz_MatExpr<P_expr2>,
891	_bz_Multiply<P_numtype1, typename P_expr2::T_numtype> > T_expr;
892
893	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
894	d2));
895	}
896
897	// Matrix<P_numtype1, P_struct1> * int
898	template<class P_numtype1, class P_struct1>
899	inline
900	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
901	_bz_MatExprConstant<int>,
902	_bz_Multiply<P_numtype1, int > > >
903	operator*(const Matrix<P_numtype1, P_struct1>& d1,
904	int d2)
905	{
906	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
907	_bz_MatExprConstant<int>,
908	_bz_Multiply<P_numtype1, int> > T_expr;
909
910	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
911	_bz_MatExprConstant<int>(d2)));
912	}
913
914	// Matrix<P_numtype1, P_struct1> * float
915	template<class P_numtype1, class P_struct1>
916	inline
917	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
918	_bz_MatExprConstant<float>,
919	_bz_Multiply<P_numtype1, float > > >
920	operator*(const Matrix<P_numtype1, P_struct1>& d1,
921	float d2)
922	{
923	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
924	_bz_MatExprConstant<float>,
925	_bz_Multiply<P_numtype1, float> > T_expr;
926
927	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
928	_bz_MatExprConstant<float>(d2)));
929	}
930
931	// Matrix<P_numtype1, P_struct1> * double
932	template<class P_numtype1, class P_struct1>
933	inline
934	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
935	_bz_MatExprConstant<double>,
936	_bz_Multiply<P_numtype1, double > > >
937	operator*(const Matrix<P_numtype1, P_struct1>& d1,
938	double d2)
939	{
940	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
941	_bz_MatExprConstant<double>,
942	_bz_Multiply<P_numtype1, double> > T_expr;
943
944	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
945	_bz_MatExprConstant<double>(d2)));
946	}
947
948	// Matrix<P_numtype1, P_struct1> * long double
949	template<class P_numtype1, class P_struct1>
950	inline
951	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
952	_bz_MatExprConstant<long double>,
953	_bz_Multiply<P_numtype1, long double > > >
954	operator*(const Matrix<P_numtype1, P_struct1>& d1,
955	long double d2)
956	{
957	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
958	_bz_MatExprConstant<long double>,
959	_bz_Multiply<P_numtype1, long double> > T_expr;
960
961	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
962	_bz_MatExprConstant<long double>(d2)));
963	}
964	#ifdef BZ_HAVE_COMPLEX
965
966	// Matrix<P_numtype1, P_struct1> * complex<T2>
967	template<class P_numtype1, class P_struct1, class T2>
968	inline
969	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
970	_bz_MatExprConstant<complex<T2> > ,
971	_bz_Multiply<P_numtype1, complex<T2> > > >
972	operator*(const Matrix<P_numtype1, P_struct1>& d1,
973	complex<T2> d2)
974	{
975	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
976	_bz_MatExprConstant<complex<T2> > ,
977	_bz_Multiply<P_numtype1, complex<T2> > > T_expr;
978
979	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
980	_bz_MatExprConstant<complex<T2> > (d2)));
981	}
982	#endif // BZ_HAVE_COMPLEX
983
984
985	// _bz_MatExpr<P_expr1> * Matrix<P_numtype2, P_struct2>
986	template<class P_expr1, class P_numtype2, class P_struct2>
987	inline
988	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
989	_bz_MatrixRef<P_numtype2, P_struct2>,
990	_bz_Multiply<typename P_expr1::T_numtype, P_numtype2 > > >
991	operator*(_bz_MatExpr<P_expr1> d1,
992	const Matrix<P_numtype2, P_struct2>& d2)
993	{
994	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
995	_bz_MatrixRef<P_numtype2, P_struct2>,
996	_bz_Multiply<typename P_expr1::T_numtype, P_numtype2> > T_expr;
997
998	return _bz_MatExpr<T_expr>(T_expr(d1,
999	d2._bz_getRef()));
1000	}
1001
1002	// _bz_MatExpr<P_expr1> * _bz_MatExpr<P_expr2>
1003	template<class P_expr1, class P_expr2>
1004	inline
1005	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
1006	_bz_MatExpr<P_expr2>,
1007	_bz_Multiply<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
1008	operator*(_bz_MatExpr<P_expr1> d1,
1009	_bz_MatExpr<P_expr2> d2)
1010	{
1011	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
1012	_bz_MatExpr<P_expr2>,
1013	_bz_Multiply<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
1014
1015	return _bz_MatExpr<T_expr>(T_expr(d1,
1016	d2));
1017	}
1018
1019	// _bz_MatExpr<P_expr1> * int
1020	template<class P_expr1>
1021	inline
1022	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
1023	_bz_MatExprConstant<int>,
1024	_bz_Multiply<typename P_expr1::T_numtype, int > > >
1025	operator*(_bz_MatExpr<P_expr1> d1,
1026	int d2)
1027	{
1028	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
1029	_bz_MatExprConstant<int>,
1030	_bz_Multiply<typename P_expr1::T_numtype, int> > T_expr;
1031
1032	return _bz_MatExpr<T_expr>(T_expr(d1,
1033	_bz_MatExprConstant<int>(d2)));
1034	}
1035
1036	// _bz_MatExpr<P_expr1> * float
1037	template<class P_expr1>
1038	inline
1039	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
1040	_bz_MatExprConstant<float>,
1041	_bz_Multiply<typename P_expr1::T_numtype, float > > >
1042	operator*(_bz_MatExpr<P_expr1> d1,
1043	float d2)
1044	{
1045	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
1046	_bz_MatExprConstant<float>,
1047	_bz_Multiply<typename P_expr1::T_numtype, float> > T_expr;
1048
1049	return _bz_MatExpr<T_expr>(T_expr(d1,
1050	_bz_MatExprConstant<float>(d2)));
1051	}
1052
1053	// _bz_MatExpr<P_expr1> * double
1054	template<class P_expr1>
1055	inline
1056	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
1057	_bz_MatExprConstant<double>,
1058	_bz_Multiply<typename P_expr1::T_numtype, double > > >
1059	operator*(_bz_MatExpr<P_expr1> d1,
1060	double d2)
1061	{
1062	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
1063	_bz_MatExprConstant<double>,
1064	_bz_Multiply<typename P_expr1::T_numtype, double> > T_expr;
1065
1066	return _bz_MatExpr<T_expr>(T_expr(d1,
1067	_bz_MatExprConstant<double>(d2)));
1068	}
1069
1070	// _bz_MatExpr<P_expr1> * long double
1071	template<class P_expr1>
1072	inline
1073	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
1074	_bz_MatExprConstant<long double>,
1075	_bz_Multiply<typename P_expr1::T_numtype, long double > > >
1076	operator*(_bz_MatExpr<P_expr1> d1,
1077	long double d2)
1078	{
1079	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
1080	_bz_MatExprConstant<long double>,
1081	_bz_Multiply<typename P_expr1::T_numtype, long double> > T_expr;
1082
1083	return _bz_MatExpr<T_expr>(T_expr(d1,
1084	_bz_MatExprConstant<long double>(d2)));
1085	}
1086	#ifdef BZ_HAVE_COMPLEX
1087
1088	// _bz_MatExpr<P_expr1> * complex<T2>
1089	template<class P_expr1, class T2>
1090	inline
1091	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
1092	_bz_MatExprConstant<complex<T2> > ,
1093	_bz_Multiply<typename P_expr1::T_numtype, complex<T2> > > >
1094	operator*(_bz_MatExpr<P_expr1> d1,
1095	complex<T2> d2)
1096	{
1097	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
1098	_bz_MatExprConstant<complex<T2> > ,
1099	_bz_Multiply<typename P_expr1::T_numtype, complex<T2> > > T_expr;
1100
1101	return _bz_MatExpr<T_expr>(T_expr(d1,
1102	_bz_MatExprConstant<complex<T2> > (d2)));
1103	}
1104	#endif // BZ_HAVE_COMPLEX
1105
1106
1107	// int * Matrix<P_numtype2, P_struct2>
1108	template<class P_numtype2, class P_struct2>
1109	inline
1110	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
1111	_bz_MatrixRef<P_numtype2, P_struct2>,
1112	_bz_Multiply<int, P_numtype2 > > >
1113	operator*(int d1,
1114	const Matrix<P_numtype2, P_struct2>& d2)
1115	{
1116	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
1117	_bz_MatrixRef<P_numtype2, P_struct2>,
1118	_bz_Multiply<int, P_numtype2> > T_expr;
1119
1120	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
1121	d2._bz_getRef()));
1122	}
1123
1124	// int * _bz_MatExpr<P_expr2>
1125	template<class P_expr2>
1126	inline
1127	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
1128	_bz_MatExpr<P_expr2>,
1129	_bz_Multiply<int, typename P_expr2::T_numtype > > >
1130	operator*(int d1,
1131	_bz_MatExpr<P_expr2> d2)
1132	{
1133	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
1134	_bz_MatExpr<P_expr2>,
1135	_bz_Multiply<int, typename P_expr2::T_numtype> > T_expr;
1136
1137	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
1138	d2));
1139	}
1140
1141	// float * Matrix<P_numtype2, P_struct2>
1142	template<class P_numtype2, class P_struct2>
1143	inline
1144	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>,
1145	_bz_MatrixRef<P_numtype2, P_struct2>,
1146	_bz_Multiply<float, P_numtype2 > > >
1147	operator*(float d1,
1148	const Matrix<P_numtype2, P_struct2>& d2)
1149	{
1150	typedef _bz_MatExprOp<_bz_MatExprConstant<float>,
1151	_bz_MatrixRef<P_numtype2, P_struct2>,
1152	_bz_Multiply<float, P_numtype2> > T_expr;
1153
1154	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1),
1155	d2._bz_getRef()));
1156	}
1157
1158	// float * _bz_MatExpr<P_expr2>
1159	template<class P_expr2>
1160	inline
1161	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>,
1162	_bz_MatExpr<P_expr2>,
1163	_bz_Multiply<float, typename P_expr2::T_numtype > > >
1164	operator*(float d1,
1165	_bz_MatExpr<P_expr2> d2)
1166	{
1167	typedef _bz_MatExprOp<_bz_MatExprConstant<float>,
1168	_bz_MatExpr<P_expr2>,
1169	_bz_Multiply<float, typename P_expr2::T_numtype> > T_expr;
1170
1171	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1),
1172	d2));
1173	}
1174
1175	// double * Matrix<P_numtype2, P_struct2>
1176	template<class P_numtype2, class P_struct2>
1177	inline
1178	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>,
1179	_bz_MatrixRef<P_numtype2, P_struct2>,
1180	_bz_Multiply<double, P_numtype2 > > >
1181	operator*(double d1,
1182	const Matrix<P_numtype2, P_struct2>& d2)
1183	{
1184	typedef _bz_MatExprOp<_bz_MatExprConstant<double>,
1185	_bz_MatrixRef<P_numtype2, P_struct2>,
1186	_bz_Multiply<double, P_numtype2> > T_expr;
1187
1188	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1),
1189	d2._bz_getRef()));
1190	}
1191
1192	// double * _bz_MatExpr<P_expr2>
1193	template<class P_expr2>
1194	inline
1195	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>,
1196	_bz_MatExpr<P_expr2>,
1197	_bz_Multiply<double, typename P_expr2::T_numtype > > >
1198	operator*(double d1,
1199	_bz_MatExpr<P_expr2> d2)
1200	{
1201	typedef _bz_MatExprOp<_bz_MatExprConstant<double>,
1202	_bz_MatExpr<P_expr2>,
1203	_bz_Multiply<double, typename P_expr2::T_numtype> > T_expr;
1204
1205	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1),
1206	d2));
1207	}
1208
1209	// long double * Matrix<P_numtype2, P_struct2>
1210	template<class P_numtype2, class P_struct2>
1211	inline
1212	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>,
1213	_bz_MatrixRef<P_numtype2, P_struct2>,
1214	_bz_Multiply<long double, P_numtype2 > > >
1215	operator*(long double d1,
1216	const Matrix<P_numtype2, P_struct2>& d2)
1217	{
1218	typedef _bz_MatExprOp<_bz_MatExprConstant<long double>,
1219	_bz_MatrixRef<P_numtype2, P_struct2>,
1220	_bz_Multiply<long double, P_numtype2> > T_expr;
1221
1222	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1),
1223	d2._bz_getRef()));
1224	}
1225
1226	// long double * _bz_MatExpr<P_expr2>
1227	template<class P_expr2>
1228	inline
1229	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>,
1230	_bz_MatExpr<P_expr2>,
1231	_bz_Multiply<long double, typename P_expr2::T_numtype > > >
1232	operator*(long double d1,
1233	_bz_MatExpr<P_expr2> d2)
1234	{
1235	typedef _bz_MatExprOp<_bz_MatExprConstant<long double>,
1236	_bz_MatExpr<P_expr2>,
1237	_bz_Multiply<long double, typename P_expr2::T_numtype> > T_expr;
1238
1239	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1),
1240	d2));
1241	}
1242	#ifdef BZ_HAVE_COMPLEX
1243
1244	// complex<T1> * Matrix<P_numtype2, P_struct2>
1245	template<class T1, class P_numtype2, class P_struct2>
1246	inline
1247	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
1248	_bz_MatrixRef<P_numtype2, P_struct2>,
1249	_bz_Multiply<complex<T1> , P_numtype2 > > >
1250	operator*(complex<T1> d1,
1251	const Matrix<P_numtype2, P_struct2>& d2)
1252	{
1253	typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
1254	_bz_MatrixRef<P_numtype2, P_struct2>,
1255	_bz_Multiply<complex<T1> , P_numtype2> > T_expr;
1256
1257	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1),
1258	d2._bz_getRef()));
1259	}
1260	#endif // BZ_HAVE_COMPLEX
1261
1262	#ifdef BZ_HAVE_COMPLEX
1263
1264	// complex<T1> * _bz_MatExpr<P_expr2>
1265	template<class T1, class P_expr2>
1266	inline
1267	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
1268	_bz_MatExpr<P_expr2>,
1269	_bz_Multiply<complex<T1> , typename P_expr2::T_numtype > > >
1270	operator*(complex<T1> d1,
1271	_bz_MatExpr<P_expr2> d2)
1272	{
1273	typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
1274	_bz_MatExpr<P_expr2>,
1275	_bz_Multiply<complex<T1> , typename P_expr2::T_numtype> > T_expr;
1276
1277	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1),
1278	d2));
1279	}
1280	#endif // BZ_HAVE_COMPLEX
1281
1282	/****************************************************************************
1283	* Division Operators
1284	****************************************************************************/
1285
1286	// Matrix<P_numtype1, P_struct1> / Matrix<P_numtype2, P_struct2>
1287	template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
1288	inline
1289	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
1290	_bz_MatrixRef<P_numtype2, P_struct2>,
1291	_bz_Divide<P_numtype1, P_numtype2 > > >
1292	operator/(const Matrix<P_numtype1, P_struct1>& d1,
1293	const Matrix<P_numtype2, P_struct2>& d2)
1294	{
1295	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
1296	_bz_MatrixRef<P_numtype2, P_struct2>,
1297	_bz_Divide<P_numtype1, P_numtype2> > T_expr;
1298
1299	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
1300	d2._bz_getRef()));
1301	}
1302
1303	// Matrix<P_numtype1, P_struct1> / _bz_MatExpr<P_expr2>
1304	template<class P_numtype1, class P_struct1, class P_expr2>
1305	inline
1306	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
1307	_bz_MatExpr<P_expr2>,
1308	_bz_Divide<P_numtype1, typename P_expr2::T_numtype > > >
1309	operator/(const Matrix<P_numtype1, P_struct1>& d1,
1310	_bz_MatExpr<P_expr2> d2)
1311	{
1312	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
1313	_bz_MatExpr<P_expr2>,
1314	_bz_Divide<P_numtype1, typename P_expr2::T_numtype> > T_expr;
1315
1316	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
1317	d2));
1318	}
1319
1320	// Matrix<P_numtype1, P_struct1> / int
1321	template<class P_numtype1, class P_struct1>
1322	inline
1323	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
1324	_bz_MatExprConstant<int>,
1325	_bz_Divide<P_numtype1, int > > >
1326	operator/(const Matrix<P_numtype1, P_struct1>& d1,
1327	int d2)
1328	{
1329	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
1330	_bz_MatExprConstant<int>,
1331	_bz_Divide<P_numtype1, int> > T_expr;
1332
1333	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
1334	_bz_MatExprConstant<int>(d2)));
1335	}
1336
1337	// Matrix<P_numtype1, P_struct1> / float
1338	template<class P_numtype1, class P_struct1>
1339	inline
1340	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
1341	_bz_MatExprConstant<float>,
1342	_bz_Divide<P_numtype1, float > > >
1343	operator/(const Matrix<P_numtype1, P_struct1>& d1,
1344	float d2)
1345	{
1346	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
1347	_bz_MatExprConstant<float>,
1348	_bz_Divide<P_numtype1, float> > T_expr;
1349
1350	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
1351	_bz_MatExprConstant<float>(d2)));
1352	}
1353
1354	// Matrix<P_numtype1, P_struct1> / double
1355	template<class P_numtype1, class P_struct1>
1356	inline
1357	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
1358	_bz_MatExprConstant<double>,
1359	_bz_Divide<P_numtype1, double > > >
1360	operator/(const Matrix<P_numtype1, P_struct1>& d1,
1361	double d2)
1362	{
1363	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
1364	_bz_MatExprConstant<double>,
1365	_bz_Divide<P_numtype1, double> > T_expr;
1366
1367	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
1368	_bz_MatExprConstant<double>(d2)));
1369	}
1370
1371	// Matrix<P_numtype1, P_struct1> / long double
1372	template<class P_numtype1, class P_struct1>
1373	inline
1374	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
1375	_bz_MatExprConstant<long double>,
1376	_bz_Divide<P_numtype1, long double > > >
1377	operator/(const Matrix<P_numtype1, P_struct1>& d1,
1378	long double d2)
1379	{
1380	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
1381	_bz_MatExprConstant<long double>,
1382	_bz_Divide<P_numtype1, long double> > T_expr;
1383
1384	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
1385	_bz_MatExprConstant<long double>(d2)));
1386	}
1387	#ifdef BZ_HAVE_COMPLEX
1388
1389	// Matrix<P_numtype1, P_struct1> / complex<T2>
1390	template<class P_numtype1, class P_struct1, class T2>
1391	inline
1392	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
1393	_bz_MatExprConstant<complex<T2> > ,
1394	_bz_Divide<P_numtype1, complex<T2> > > >
1395	operator/(const Matrix<P_numtype1, P_struct1>& d1,
1396	complex<T2> d2)
1397	{
1398	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
1399	_bz_MatExprConstant<complex<T2> > ,
1400	_bz_Divide<P_numtype1, complex<T2> > > T_expr;
1401
1402	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
1403	_bz_MatExprConstant<complex<T2> > (d2)));
1404	}
1405	#endif // BZ_HAVE_COMPLEX
1406
1407
1408	// _bz_MatExpr<P_expr1> / Matrix<P_numtype2, P_struct2>
1409	template<class P_expr1, class P_numtype2, class P_struct2>
1410	inline
1411	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
1412	_bz_MatrixRef<P_numtype2, P_struct2>,
1413	_bz_Divide<typename P_expr1::T_numtype, P_numtype2 > > >
1414	operator/(_bz_MatExpr<P_expr1> d1,
1415	const Matrix<P_numtype2, P_struct2>& d2)
1416	{
1417	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
1418	_bz_MatrixRef<P_numtype2, P_struct2>,
1419	_bz_Divide<typename P_expr1::T_numtype, P_numtype2> > T_expr;
1420
1421	return _bz_MatExpr<T_expr>(T_expr(d1,
1422	d2._bz_getRef()));
1423	}
1424
1425	// _bz_MatExpr<P_expr1> / _bz_MatExpr<P_expr2>
1426	template<class P_expr1, class P_expr2>
1427	inline
1428	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
1429	_bz_MatExpr<P_expr2>,
1430	_bz_Divide<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
1431	operator/(_bz_MatExpr<P_expr1> d1,
1432	_bz_MatExpr<P_expr2> d2)
1433	{
1434	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
1435	_bz_MatExpr<P_expr2>,
1436	_bz_Divide<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
1437
1438	return _bz_MatExpr<T_expr>(T_expr(d1,
1439	d2));
1440	}
1441
1442	// _bz_MatExpr<P_expr1> / int
1443	template<class P_expr1>
1444	inline
1445	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
1446	_bz_MatExprConstant<int>,
1447	_bz_Divide<typename P_expr1::T_numtype, int > > >
1448	operator/(_bz_MatExpr<P_expr1> d1,
1449	int d2)
1450	{
1451	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
1452	_bz_MatExprConstant<int>,
1453	_bz_Divide<typename P_expr1::T_numtype, int> > T_expr;
1454
1455	return _bz_MatExpr<T_expr>(T_expr(d1,
1456	_bz_MatExprConstant<int>(d2)));
1457	}
1458
1459	// _bz_MatExpr<P_expr1> / float
1460	template<class P_expr1>
1461	inline
1462	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
1463	_bz_MatExprConstant<float>,
1464	_bz_Divide<typename P_expr1::T_numtype, float > > >
1465	operator/(_bz_MatExpr<P_expr1> d1,
1466	float d2)
1467	{
1468	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
1469	_bz_MatExprConstant<float>,
1470	_bz_Divide<typename P_expr1::T_numtype, float> > T_expr;
1471
1472	return _bz_MatExpr<T_expr>(T_expr(d1,
1473	_bz_MatExprConstant<float>(d2)));
1474	}
1475
1476	// _bz_MatExpr<P_expr1> / double
1477	template<class P_expr1>
1478	inline
1479	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
1480	_bz_MatExprConstant<double>,
1481	_bz_Divide<typename P_expr1::T_numtype, double > > >
1482	operator/(_bz_MatExpr<P_expr1> d1,
1483	double d2)
1484	{
1485	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
1486	_bz_MatExprConstant<double>,
1487	_bz_Divide<typename P_expr1::T_numtype, double> > T_expr;
1488
1489	return _bz_MatExpr<T_expr>(T_expr(d1,
1490	_bz_MatExprConstant<double>(d2)));
1491	}
1492
1493	// _bz_MatExpr<P_expr1> / long double
1494	template<class P_expr1>
1495	inline
1496	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
1497	_bz_MatExprConstant<long double>,
1498	_bz_Divide<typename P_expr1::T_numtype, long double > > >
1499	operator/(_bz_MatExpr<P_expr1> d1,
1500	long double d2)
1501	{
1502	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
1503	_bz_MatExprConstant<long double>,
1504	_bz_Divide<typename P_expr1::T_numtype, long double> > T_expr;
1505
1506	return _bz_MatExpr<T_expr>(T_expr(d1,
1507	_bz_MatExprConstant<long double>(d2)));
1508	}
1509	#ifdef BZ_HAVE_COMPLEX
1510
1511	// _bz_MatExpr<P_expr1> / complex<T2>
1512	template<class P_expr1, class T2>
1513	inline
1514	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
1515	_bz_MatExprConstant<complex<T2> > ,
1516	_bz_Divide<typename P_expr1::T_numtype, complex<T2> > > >
1517	operator/(_bz_MatExpr<P_expr1> d1,
1518	complex<T2> d2)
1519	{
1520	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
1521	_bz_MatExprConstant<complex<T2> > ,
1522	_bz_Divide<typename P_expr1::T_numtype, complex<T2> > > T_expr;
1523
1524	return _bz_MatExpr<T_expr>(T_expr(d1,
1525	_bz_MatExprConstant<complex<T2> > (d2)));
1526	}
1527	#endif // BZ_HAVE_COMPLEX
1528
1529
1530	// int / Matrix<P_numtype2, P_struct2>
1531	template<class P_numtype2, class P_struct2>
1532	inline
1533	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
1534	_bz_MatrixRef<P_numtype2, P_struct2>,
1535	_bz_Divide<int, P_numtype2 > > >
1536	operator/(int d1,
1537	const Matrix<P_numtype2, P_struct2>& d2)
1538	{
1539	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
1540	_bz_MatrixRef<P_numtype2, P_struct2>,
1541	_bz_Divide<int, P_numtype2> > T_expr;
1542
1543	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
1544	d2._bz_getRef()));
1545	}
1546
1547	// int / _bz_MatExpr<P_expr2>
1548	template<class P_expr2>
1549	inline
1550	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
1551	_bz_MatExpr<P_expr2>,
1552	_bz_Divide<int, typename P_expr2::T_numtype > > >
1553	operator/(int d1,
1554	_bz_MatExpr<P_expr2> d2)
1555	{
1556	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
1557	_bz_MatExpr<P_expr2>,
1558	_bz_Divide<int, typename P_expr2::T_numtype> > T_expr;
1559
1560	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
1561	d2));
1562	}
1563
1564	// float / Matrix<P_numtype2, P_struct2>
1565	template<class P_numtype2, class P_struct2>
1566	inline
1567	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>,
1568	_bz_MatrixRef<P_numtype2, P_struct2>,
1569	_bz_Divide<float, P_numtype2 > > >
1570	operator/(float d1,
1571	const Matrix<P_numtype2, P_struct2>& d2)
1572	{
1573	typedef _bz_MatExprOp<_bz_MatExprConstant<float>,
1574	_bz_MatrixRef<P_numtype2, P_struct2>,
1575	_bz_Divide<float, P_numtype2> > T_expr;
1576
1577	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1),
1578	d2._bz_getRef()));
1579	}
1580
1581	// float / _bz_MatExpr<P_expr2>
1582	template<class P_expr2>
1583	inline
1584	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>,
1585	_bz_MatExpr<P_expr2>,
1586	_bz_Divide<float, typename P_expr2::T_numtype > > >
1587	operator/(float d1,
1588	_bz_MatExpr<P_expr2> d2)
1589	{
1590	typedef _bz_MatExprOp<_bz_MatExprConstant<float>,
1591	_bz_MatExpr<P_expr2>,
1592	_bz_Divide<float, typename P_expr2::T_numtype> > T_expr;
1593
1594	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1),
1595	d2));
1596	}
1597
1598	// double / Matrix<P_numtype2, P_struct2>
1599	template<class P_numtype2, class P_struct2>
1600	inline
1601	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>,
1602	_bz_MatrixRef<P_numtype2, P_struct2>,
1603	_bz_Divide<double, P_numtype2 > > >
1604	operator/(double d1,
1605	const Matrix<P_numtype2, P_struct2>& d2)
1606	{
1607	typedef _bz_MatExprOp<_bz_MatExprConstant<double>,
1608	_bz_MatrixRef<P_numtype2, P_struct2>,
1609	_bz_Divide<double, P_numtype2> > T_expr;
1610
1611	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1),
1612	d2._bz_getRef()));
1613	}
1614
1615	// double / _bz_MatExpr<P_expr2>
1616	template<class P_expr2>
1617	inline
1618	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>,
1619	_bz_MatExpr<P_expr2>,
1620	_bz_Divide<double, typename P_expr2::T_numtype > > >
1621	operator/(double d1,
1622	_bz_MatExpr<P_expr2> d2)
1623	{
1624	typedef _bz_MatExprOp<_bz_MatExprConstant<double>,
1625	_bz_MatExpr<P_expr2>,
1626	_bz_Divide<double, typename P_expr2::T_numtype> > T_expr;
1627
1628	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1),
1629	d2));
1630	}
1631
1632	// long double / Matrix<P_numtype2, P_struct2>
1633	template<class P_numtype2, class P_struct2>
1634	inline
1635	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>,
1636	_bz_MatrixRef<P_numtype2, P_struct2>,
1637	_bz_Divide<long double, P_numtype2 > > >
1638	operator/(long double d1,
1639	const Matrix<P_numtype2, P_struct2>& d2)
1640	{
1641	typedef _bz_MatExprOp<_bz_MatExprConstant<long double>,
1642	_bz_MatrixRef<P_numtype2, P_struct2>,
1643	_bz_Divide<long double, P_numtype2> > T_expr;
1644
1645	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1),
1646	d2._bz_getRef()));
1647	}
1648
1649	// long double / _bz_MatExpr<P_expr2>
1650	template<class P_expr2>
1651	inline
1652	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>,
1653	_bz_MatExpr<P_expr2>,
1654	_bz_Divide<long double, typename P_expr2::T_numtype > > >
1655	operator/(long double d1,
1656	_bz_MatExpr<P_expr2> d2)
1657	{
1658	typedef _bz_MatExprOp<_bz_MatExprConstant<long double>,
1659	_bz_MatExpr<P_expr2>,
1660	_bz_Divide<long double, typename P_expr2::T_numtype> > T_expr;
1661
1662	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1),
1663	d2));
1664	}
1665	#ifdef BZ_HAVE_COMPLEX
1666
1667	// complex<T1> / Matrix<P_numtype2, P_struct2>
1668	template<class T1, class P_numtype2, class P_struct2>
1669	inline
1670	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
1671	_bz_MatrixRef<P_numtype2, P_struct2>,
1672	_bz_Divide<complex<T1> , P_numtype2 > > >
1673	operator/(complex<T1> d1,
1674	const Matrix<P_numtype2, P_struct2>& d2)
1675	{
1676	typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
1677	_bz_MatrixRef<P_numtype2, P_struct2>,
1678	_bz_Divide<complex<T1> , P_numtype2> > T_expr;
1679
1680	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1),
1681	d2._bz_getRef()));
1682	}
1683	#endif // BZ_HAVE_COMPLEX
1684
1685	#ifdef BZ_HAVE_COMPLEX
1686
1687	// complex<T1> / _bz_MatExpr<P_expr2>
1688	template<class T1, class P_expr2>
1689	inline
1690	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
1691	_bz_MatExpr<P_expr2>,
1692	_bz_Divide<complex<T1> , typename P_expr2::T_numtype > > >
1693	operator/(complex<T1> d1,
1694	_bz_MatExpr<P_expr2> d2)
1695	{
1696	typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
1697	_bz_MatExpr<P_expr2>,
1698	_bz_Divide<complex<T1> , typename P_expr2::T_numtype> > T_expr;
1699
1700	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1),
1701	d2));
1702	}
1703	#endif // BZ_HAVE_COMPLEX
1704
1705	/****************************************************************************
1706	* Modulus Operators
1707	****************************************************************************/
1708
1709	// Matrix<P_numtype1, P_struct1> % Matrix<P_numtype2, P_struct2>
1710	template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
1711	inline
1712	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
1713	_bz_MatrixRef<P_numtype2, P_struct2>,
1714	_bz_Mod<P_numtype1, P_numtype2 > > >
1715	operator%(const Matrix<P_numtype1, P_struct1>& d1,
1716	const Matrix<P_numtype2, P_struct2>& d2)
1717	{
1718	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
1719	_bz_MatrixRef<P_numtype2, P_struct2>,
1720	_bz_Mod<P_numtype1, P_numtype2> > T_expr;
1721
1722	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
1723	d2._bz_getRef()));
1724	}
1725
1726	// Matrix<P_numtype1, P_struct1> % _bz_MatExpr<P_expr2>
1727	template<class P_numtype1, class P_struct1, class P_expr2>
1728	inline
1729	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
1730	_bz_MatExpr<P_expr2>,
1731	_bz_Mod<P_numtype1, typename P_expr2::T_numtype > > >
1732	operator%(const Matrix<P_numtype1, P_struct1>& d1,
1733	_bz_MatExpr<P_expr2> d2)
1734	{
1735	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
1736	_bz_MatExpr<P_expr2>,
1737	_bz_Mod<P_numtype1, typename P_expr2::T_numtype> > T_expr;
1738
1739	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
1740	d2));
1741	}
1742
1743	// Matrix<P_numtype1, P_struct1> % int
1744	template<class P_numtype1, class P_struct1>
1745	inline
1746	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
1747	_bz_MatExprConstant<int>,
1748	_bz_Mod<P_numtype1, int > > >
1749	operator%(const Matrix<P_numtype1, P_struct1>& d1,
1750	int d2)
1751	{
1752	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
1753	_bz_MatExprConstant<int>,
1754	_bz_Mod<P_numtype1, int> > T_expr;
1755
1756	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
1757	_bz_MatExprConstant<int>(d2)));
1758	}
1759
1760	// _bz_MatExpr<P_expr1> % Matrix<P_numtype2, P_struct2>
1761	template<class P_expr1, class P_numtype2, class P_struct2>
1762	inline
1763	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
1764	_bz_MatrixRef<P_numtype2, P_struct2>,
1765	_bz_Mod<typename P_expr1::T_numtype, P_numtype2 > > >
1766	operator%(_bz_MatExpr<P_expr1> d1,
1767	const Matrix<P_numtype2, P_struct2>& d2)
1768	{
1769	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
1770	_bz_MatrixRef<P_numtype2, P_struct2>,
1771	_bz_Mod<typename P_expr1::T_numtype, P_numtype2> > T_expr;
1772
1773	return _bz_MatExpr<T_expr>(T_expr(d1,
1774	d2._bz_getRef()));
1775	}
1776
1777	// _bz_MatExpr<P_expr1> % _bz_MatExpr<P_expr2>
1778	template<class P_expr1, class P_expr2>
1779	inline
1780	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
1781	_bz_MatExpr<P_expr2>,
1782	_bz_Mod<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
1783	operator%(_bz_MatExpr<P_expr1> d1,
1784	_bz_MatExpr<P_expr2> d2)
1785	{
1786	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
1787	_bz_MatExpr<P_expr2>,
1788	_bz_Mod<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
1789
1790	return _bz_MatExpr<T_expr>(T_expr(d1,
1791	d2));
1792	}
1793
1794	// _bz_MatExpr<P_expr1> % int
1795	template<class P_expr1>
1796	inline
1797	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
1798	_bz_MatExprConstant<int>,
1799	_bz_Mod<typename P_expr1::T_numtype, int > > >
1800	operator%(_bz_MatExpr<P_expr1> d1,
1801	int d2)
1802	{
1803	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
1804	_bz_MatExprConstant<int>,
1805	_bz_Mod<typename P_expr1::T_numtype, int> > T_expr;
1806
1807	return _bz_MatExpr<T_expr>(T_expr(d1,
1808	_bz_MatExprConstant<int>(d2)));
1809	}
1810
1811	// int % Matrix<P_numtype2, P_struct2>
1812	template<class P_numtype2, class P_struct2>
1813	inline
1814	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
1815	_bz_MatrixRef<P_numtype2, P_struct2>,
1816	_bz_Mod<int, P_numtype2 > > >
1817	operator%(int d1,
1818	const Matrix<P_numtype2, P_struct2>& d2)
1819	{
1820	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
1821	_bz_MatrixRef<P_numtype2, P_struct2>,
1822	_bz_Mod<int, P_numtype2> > T_expr;
1823
1824	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
1825	d2._bz_getRef()));
1826	}
1827
1828	// int % _bz_MatExpr<P_expr2>
1829	template<class P_expr2>
1830	inline
1831	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
1832	_bz_MatExpr<P_expr2>,
1833	_bz_Mod<int, typename P_expr2::T_numtype > > >
1834	operator%(int d1,
1835	_bz_MatExpr<P_expr2> d2)
1836	{
1837	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
1838	_bz_MatExpr<P_expr2>,
1839	_bz_Mod<int, typename P_expr2::T_numtype> > T_expr;
1840
1841	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
1842	d2));
1843	}
1844	/****************************************************************************
1845	* Bitwise XOR Operators
1846	****************************************************************************/
1847
1848	// Matrix<P_numtype1, P_struct1> ^ Matrix<P_numtype2, P_struct2>
1849	template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
1850	inline
1851	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
1852	_bz_MatrixRef<P_numtype2, P_struct2>,
1853	_bz_BitwiseXOR<P_numtype1, P_numtype2 > > >
1854	operator^(const Matrix<P_numtype1, P_struct1>& d1,
1855	const Matrix<P_numtype2, P_struct2>& d2)
1856	{
1857	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
1858	_bz_MatrixRef<P_numtype2, P_struct2>,
1859	_bz_BitwiseXOR<P_numtype1, P_numtype2> > T_expr;
1860
1861	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
1862	d2._bz_getRef()));
1863	}
1864
1865	// Matrix<P_numtype1, P_struct1> ^ _bz_MatExpr<P_expr2>
1866	template<class P_numtype1, class P_struct1, class P_expr2>
1867	inline
1868	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
1869	_bz_MatExpr<P_expr2>,
1870	_bz_BitwiseXOR<P_numtype1, typename P_expr2::T_numtype > > >
1871	operator^(const Matrix<P_numtype1, P_struct1>& d1,
1872	_bz_MatExpr<P_expr2> d2)
1873	{
1874	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
1875	_bz_MatExpr<P_expr2>,
1876	_bz_BitwiseXOR<P_numtype1, typename P_expr2::T_numtype> > T_expr;
1877
1878	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
1879	d2));
1880	}
1881
1882	// Matrix<P_numtype1, P_struct1> ^ int
1883	template<class P_numtype1, class P_struct1>
1884	inline
1885	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
1886	_bz_MatExprConstant<int>,
1887	_bz_BitwiseXOR<P_numtype1, int > > >
1888	operator^(const Matrix<P_numtype1, P_struct1>& d1,
1889	int d2)
1890	{
1891	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
1892	_bz_MatExprConstant<int>,
1893	_bz_BitwiseXOR<P_numtype1, int> > T_expr;
1894
1895	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
1896	_bz_MatExprConstant<int>(d2)));
1897	}
1898
1899	// _bz_MatExpr<P_expr1> ^ Matrix<P_numtype2, P_struct2>
1900	template<class P_expr1, class P_numtype2, class P_struct2>
1901	inline
1902	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
1903	_bz_MatrixRef<P_numtype2, P_struct2>,
1904	_bz_BitwiseXOR<typename P_expr1::T_numtype, P_numtype2 > > >
1905	operator^(_bz_MatExpr<P_expr1> d1,
1906	const Matrix<P_numtype2, P_struct2>& d2)
1907	{
1908	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
1909	_bz_MatrixRef<P_numtype2, P_struct2>,
1910	_bz_BitwiseXOR<typename P_expr1::T_numtype, P_numtype2> > T_expr;
1911
1912	return _bz_MatExpr<T_expr>(T_expr(d1,
1913	d2._bz_getRef()));
1914	}
1915
1916	// _bz_MatExpr<P_expr1> ^ _bz_MatExpr<P_expr2>
1917	template<class P_expr1, class P_expr2>
1918	inline
1919	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
1920	_bz_MatExpr<P_expr2>,
1921	_bz_BitwiseXOR<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
1922	operator^(_bz_MatExpr<P_expr1> d1,
1923	_bz_MatExpr<P_expr2> d2)
1924	{
1925	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
1926	_bz_MatExpr<P_expr2>,
1927	_bz_BitwiseXOR<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
1928
1929	return _bz_MatExpr<T_expr>(T_expr(d1,
1930	d2));
1931	}
1932
1933	// _bz_MatExpr<P_expr1> ^ int
1934	template<class P_expr1>
1935	inline
1936	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
1937	_bz_MatExprConstant<int>,
1938	_bz_BitwiseXOR<typename P_expr1::T_numtype, int > > >
1939	operator^(_bz_MatExpr<P_expr1> d1,
1940	int d2)
1941	{
1942	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
1943	_bz_MatExprConstant<int>,
1944	_bz_BitwiseXOR<typename P_expr1::T_numtype, int> > T_expr;
1945
1946	return _bz_MatExpr<T_expr>(T_expr(d1,
1947	_bz_MatExprConstant<int>(d2)));
1948	}
1949
1950	// int ^ Matrix<P_numtype2, P_struct2>
1951	template<class P_numtype2, class P_struct2>
1952	inline
1953	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
1954	_bz_MatrixRef<P_numtype2, P_struct2>,
1955	_bz_BitwiseXOR<int, P_numtype2 > > >
1956	operator^(int d1,
1957	const Matrix<P_numtype2, P_struct2>& d2)
1958	{
1959	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
1960	_bz_MatrixRef<P_numtype2, P_struct2>,
1961	_bz_BitwiseXOR<int, P_numtype2> > T_expr;
1962
1963	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
1964	d2._bz_getRef()));
1965	}
1966
1967	// int ^ _bz_MatExpr<P_expr2>
1968	template<class P_expr2>
1969	inline
1970	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
1971	_bz_MatExpr<P_expr2>,
1972	_bz_BitwiseXOR<int, typename P_expr2::T_numtype > > >
1973	operator^(int d1,
1974	_bz_MatExpr<P_expr2> d2)
1975	{
1976	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
1977	_bz_MatExpr<P_expr2>,
1978	_bz_BitwiseXOR<int, typename P_expr2::T_numtype> > T_expr;
1979
1980	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
1981	d2));
1982	}
1983	/****************************************************************************
1984	* Bitwise And Operators
1985	****************************************************************************/
1986
1987	// Matrix<P_numtype1, P_struct1> & Matrix<P_numtype2, P_struct2>
1988	template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
1989	inline
1990	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
1991	_bz_MatrixRef<P_numtype2, P_struct2>,
1992	_bz_BitwiseAnd<P_numtype1, P_numtype2 > > >
1993	operator&(const Matrix<P_numtype1, P_struct1>& d1,
1994	const Matrix<P_numtype2, P_struct2>& d2)
1995	{
1996	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
1997	_bz_MatrixRef<P_numtype2, P_struct2>,
1998	_bz_BitwiseAnd<P_numtype1, P_numtype2> > T_expr;
1999
2000	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
2001	d2._bz_getRef()));
2002	}
2003
2004	// Matrix<P_numtype1, P_struct1> & _bz_MatExpr<P_expr2>
2005	template<class P_numtype1, class P_struct1, class P_expr2>
2006	inline
2007	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2008	_bz_MatExpr<P_expr2>,
2009	_bz_BitwiseAnd<P_numtype1, typename P_expr2::T_numtype > > >
2010	operator&(const Matrix<P_numtype1, P_struct1>& d1,
2011	_bz_MatExpr<P_expr2> d2)
2012	{
2013	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2014	_bz_MatExpr<P_expr2>,
2015	_bz_BitwiseAnd<P_numtype1, typename P_expr2::T_numtype> > T_expr;
2016
2017	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
2018	d2));
2019	}
2020
2021	// Matrix<P_numtype1, P_struct1> & int
2022	template<class P_numtype1, class P_struct1>
2023	inline
2024	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2025	_bz_MatExprConstant<int>,
2026	_bz_BitwiseAnd<P_numtype1, int > > >
2027	operator&(const Matrix<P_numtype1, P_struct1>& d1,
2028	int d2)
2029	{
2030	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2031	_bz_MatExprConstant<int>,
2032	_bz_BitwiseAnd<P_numtype1, int> > T_expr;
2033
2034	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
2035	_bz_MatExprConstant<int>(d2)));
2036	}
2037
2038	// _bz_MatExpr<P_expr1> & Matrix<P_numtype2, P_struct2>
2039	template<class P_expr1, class P_numtype2, class P_struct2>
2040	inline
2041	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
2042	_bz_MatrixRef<P_numtype2, P_struct2>,
2043	_bz_BitwiseAnd<typename P_expr1::T_numtype, P_numtype2 > > >
2044	operator&(_bz_MatExpr<P_expr1> d1,
2045	const Matrix<P_numtype2, P_struct2>& d2)
2046	{
2047	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
2048	_bz_MatrixRef<P_numtype2, P_struct2>,
2049	_bz_BitwiseAnd<typename P_expr1::T_numtype, P_numtype2> > T_expr;
2050
2051	return _bz_MatExpr<T_expr>(T_expr(d1,
2052	d2._bz_getRef()));
2053	}
2054
2055	// _bz_MatExpr<P_expr1> & _bz_MatExpr<P_expr2>
2056	template<class P_expr1, class P_expr2>
2057	inline
2058	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
2059	_bz_MatExpr<P_expr2>,
2060	_bz_BitwiseAnd<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
2061	operator&(_bz_MatExpr<P_expr1> d1,
2062	_bz_MatExpr<P_expr2> d2)
2063	{
2064	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
2065	_bz_MatExpr<P_expr2>,
2066	_bz_BitwiseAnd<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
2067
2068	return _bz_MatExpr<T_expr>(T_expr(d1,
2069	d2));
2070	}
2071
2072	// _bz_MatExpr<P_expr1> & int
2073	template<class P_expr1>
2074	inline
2075	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
2076	_bz_MatExprConstant<int>,
2077	_bz_BitwiseAnd<typename P_expr1::T_numtype, int > > >
2078	operator&(_bz_MatExpr<P_expr1> d1,
2079	int d2)
2080	{
2081	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
2082	_bz_MatExprConstant<int>,
2083	_bz_BitwiseAnd<typename P_expr1::T_numtype, int> > T_expr;
2084
2085	return _bz_MatExpr<T_expr>(T_expr(d1,
2086	_bz_MatExprConstant<int>(d2)));
2087	}
2088
2089	// int & Matrix<P_numtype2, P_struct2>
2090	template<class P_numtype2, class P_struct2>
2091	inline
2092	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
2093	_bz_MatrixRef<P_numtype2, P_struct2>,
2094	_bz_BitwiseAnd<int, P_numtype2 > > >
2095	operator&(int d1,
2096	const Matrix<P_numtype2, P_struct2>& d2)
2097	{
2098	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
2099	_bz_MatrixRef<P_numtype2, P_struct2>,
2100	_bz_BitwiseAnd<int, P_numtype2> > T_expr;
2101
2102	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
2103	d2._bz_getRef()));
2104	}
2105
2106	// int & _bz_MatExpr<P_expr2>
2107	template<class P_expr2>
2108	inline
2109	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
2110	_bz_MatExpr<P_expr2>,
2111	_bz_BitwiseAnd<int, typename P_expr2::T_numtype > > >
2112	operator&(int d1,
2113	_bz_MatExpr<P_expr2> d2)
2114	{
2115	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
2116	_bz_MatExpr<P_expr2>,
2117	_bz_BitwiseAnd<int, typename P_expr2::T_numtype> > T_expr;
2118
2119	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
2120	d2));
2121	}
2122	/****************************************************************************
2123	* Bitwise Or Operators
2124	****************************************************************************/
2125
2126	// Matrix<P_numtype1, P_struct1> \| Matrix<P_numtype2, P_struct2>
2127	template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
2128	inline
2129	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2130	_bz_MatrixRef<P_numtype2, P_struct2>,
2131	_bz_BitwiseOr<P_numtype1, P_numtype2 > > >
2132	operator\|(const Matrix<P_numtype1, P_struct1>& d1,
2133	const Matrix<P_numtype2, P_struct2>& d2)
2134	{
2135	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2136	_bz_MatrixRef<P_numtype2, P_struct2>,
2137	_bz_BitwiseOr<P_numtype1, P_numtype2> > T_expr;
2138
2139	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
2140	d2._bz_getRef()));
2141	}
2142
2143	// Matrix<P_numtype1, P_struct1> \| _bz_MatExpr<P_expr2>
2144	template<class P_numtype1, class P_struct1, class P_expr2>
2145	inline
2146	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2147	_bz_MatExpr<P_expr2>,
2148	_bz_BitwiseOr<P_numtype1, typename P_expr2::T_numtype > > >
2149	operator\|(const Matrix<P_numtype1, P_struct1>& d1,
2150	_bz_MatExpr<P_expr2> d2)
2151	{
2152	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2153	_bz_MatExpr<P_expr2>,
2154	_bz_BitwiseOr<P_numtype1, typename P_expr2::T_numtype> > T_expr;
2155
2156	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
2157	d2));
2158	}
2159
2160	// Matrix<P_numtype1, P_struct1> \| int
2161	template<class P_numtype1, class P_struct1>
2162	inline
2163	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2164	_bz_MatExprConstant<int>,
2165	_bz_BitwiseOr<P_numtype1, int > > >
2166	operator\|(const Matrix<P_numtype1, P_struct1>& d1,
2167	int d2)
2168	{
2169	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2170	_bz_MatExprConstant<int>,
2171	_bz_BitwiseOr<P_numtype1, int> > T_expr;
2172
2173	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
2174	_bz_MatExprConstant<int>(d2)));
2175	}
2176
2177	// _bz_MatExpr<P_expr1> \| Matrix<P_numtype2, P_struct2>
2178	template<class P_expr1, class P_numtype2, class P_struct2>
2179	inline
2180	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
2181	_bz_MatrixRef<P_numtype2, P_struct2>,
2182	_bz_BitwiseOr<typename P_expr1::T_numtype, P_numtype2 > > >
2183	operator\|(_bz_MatExpr<P_expr1> d1,
2184	const Matrix<P_numtype2, P_struct2>& d2)
2185	{
2186	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
2187	_bz_MatrixRef<P_numtype2, P_struct2>,
2188	_bz_BitwiseOr<typename P_expr1::T_numtype, P_numtype2> > T_expr;
2189
2190	return _bz_MatExpr<T_expr>(T_expr(d1,
2191	d2._bz_getRef()));
2192	}
2193
2194	// _bz_MatExpr<P_expr1> \| _bz_MatExpr<P_expr2>
2195	template<class P_expr1, class P_expr2>
2196	inline
2197	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
2198	_bz_MatExpr<P_expr2>,
2199	_bz_BitwiseOr<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
2200	operator\|(_bz_MatExpr<P_expr1> d1,
2201	_bz_MatExpr<P_expr2> d2)
2202	{
2203	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
2204	_bz_MatExpr<P_expr2>,
2205	_bz_BitwiseOr<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
2206
2207	return _bz_MatExpr<T_expr>(T_expr(d1,
2208	d2));
2209	}
2210
2211	// _bz_MatExpr<P_expr1> \| int
2212	template<class P_expr1>
2213	inline
2214	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
2215	_bz_MatExprConstant<int>,
2216	_bz_BitwiseOr<typename P_expr1::T_numtype, int > > >
2217	operator\|(_bz_MatExpr<P_expr1> d1,
2218	int d2)
2219	{
2220	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
2221	_bz_MatExprConstant<int>,
2222	_bz_BitwiseOr<typename P_expr1::T_numtype, int> > T_expr;
2223
2224	return _bz_MatExpr<T_expr>(T_expr(d1,
2225	_bz_MatExprConstant<int>(d2)));
2226	}
2227
2228	// int \| Matrix<P_numtype2, P_struct2>
2229	template<class P_numtype2, class P_struct2>
2230	inline
2231	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
2232	_bz_MatrixRef<P_numtype2, P_struct2>,
2233	_bz_BitwiseOr<int, P_numtype2 > > >
2234	operator\|(int d1,
2235	const Matrix<P_numtype2, P_struct2>& d2)
2236	{
2237	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
2238	_bz_MatrixRef<P_numtype2, P_struct2>,
2239	_bz_BitwiseOr<int, P_numtype2> > T_expr;
2240
2241	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
2242	d2._bz_getRef()));
2243	}
2244
2245	// int \| _bz_MatExpr<P_expr2>
2246	template<class P_expr2>
2247	inline
2248	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
2249	_bz_MatExpr<P_expr2>,
2250	_bz_BitwiseOr<int, typename P_expr2::T_numtype > > >
2251	operator\|(int d1,
2252	_bz_MatExpr<P_expr2> d2)
2253	{
2254	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
2255	_bz_MatExpr<P_expr2>,
2256	_bz_BitwiseOr<int, typename P_expr2::T_numtype> > T_expr;
2257
2258	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
2259	d2));
2260	}
2261	/****************************************************************************
2262	* Shift right Operators
2263	****************************************************************************/
2264
2265	// Matrix<P_numtype1, P_struct1> >> Matrix<P_numtype2, P_struct2>
2266	template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
2267	inline
2268	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2269	_bz_MatrixRef<P_numtype2, P_struct2>,
2270	_bz_ShiftRight<P_numtype1, P_numtype2 > > >
2271	operator>>(const Matrix<P_numtype1, P_struct1>& d1,
2272	const Matrix<P_numtype2, P_struct2>& d2)
2273	{
2274	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2275	_bz_MatrixRef<P_numtype2, P_struct2>,
2276	_bz_ShiftRight<P_numtype1, P_numtype2> > T_expr;
2277
2278	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
2279	d2._bz_getRef()));
2280	}
2281
2282	// Matrix<P_numtype1, P_struct1> >> _bz_MatExpr<P_expr2>
2283	template<class P_numtype1, class P_struct1, class P_expr2>
2284	inline
2285	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2286	_bz_MatExpr<P_expr2>,
2287	_bz_ShiftRight<P_numtype1, typename P_expr2::T_numtype > > >
2288	operator>>(const Matrix<P_numtype1, P_struct1>& d1,
2289	_bz_MatExpr<P_expr2> d2)
2290	{
2291	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2292	_bz_MatExpr<P_expr2>,
2293	_bz_ShiftRight<P_numtype1, typename P_expr2::T_numtype> > T_expr;
2294
2295	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
2296	d2));
2297	}
2298
2299	// Matrix<P_numtype1, P_struct1> >> int
2300	template<class P_numtype1, class P_struct1>
2301	inline
2302	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2303	_bz_MatExprConstant<int>,
2304	_bz_ShiftRight<P_numtype1, int > > >
2305	operator>>(const Matrix<P_numtype1, P_struct1>& d1,
2306	int d2)
2307	{
2308	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2309	_bz_MatExprConstant<int>,
2310	_bz_ShiftRight<P_numtype1, int> > T_expr;
2311
2312	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
2313	_bz_MatExprConstant<int>(d2)));
2314	}
2315
2316	// _bz_MatExpr<P_expr1> >> Matrix<P_numtype2, P_struct2>
2317	template<class P_expr1, class P_numtype2, class P_struct2>
2318	inline
2319	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
2320	_bz_MatrixRef<P_numtype2, P_struct2>,
2321	_bz_ShiftRight<typename P_expr1::T_numtype, P_numtype2 > > >
2322	operator>>(_bz_MatExpr<P_expr1> d1,
2323	const Matrix<P_numtype2, P_struct2>& d2)
2324	{
2325	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
2326	_bz_MatrixRef<P_numtype2, P_struct2>,
2327	_bz_ShiftRight<typename P_expr1::T_numtype, P_numtype2> > T_expr;
2328
2329	return _bz_MatExpr<T_expr>(T_expr(d1,
2330	d2._bz_getRef()));
2331	}
2332
2333	// _bz_MatExpr<P_expr1> >> _bz_MatExpr<P_expr2>
2334	template<class P_expr1, class P_expr2>
2335	inline
2336	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
2337	_bz_MatExpr<P_expr2>,
2338	_bz_ShiftRight<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
2339	operator>>(_bz_MatExpr<P_expr1> d1,
2340	_bz_MatExpr<P_expr2> d2)
2341	{
2342	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
2343	_bz_MatExpr<P_expr2>,
2344	_bz_ShiftRight<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
2345
2346	return _bz_MatExpr<T_expr>(T_expr(d1,
2347	d2));
2348	}
2349
2350	// _bz_MatExpr<P_expr1> >> int
2351	template<class P_expr1>
2352	inline
2353	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
2354	_bz_MatExprConstant<int>,
2355	_bz_ShiftRight<typename P_expr1::T_numtype, int > > >
2356	operator>>(_bz_MatExpr<P_expr1> d1,
2357	int d2)
2358	{
2359	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
2360	_bz_MatExprConstant<int>,
2361	_bz_ShiftRight<typename P_expr1::T_numtype, int> > T_expr;
2362
2363	return _bz_MatExpr<T_expr>(T_expr(d1,
2364	_bz_MatExprConstant<int>(d2)));
2365	}
2366
2367	// int >> Matrix<P_numtype2, P_struct2>
2368	template<class P_numtype2, class P_struct2>
2369	inline
2370	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
2371	_bz_MatrixRef<P_numtype2, P_struct2>,
2372	_bz_ShiftRight<int, P_numtype2 > > >
2373	operator>>(int d1,
2374	const Matrix<P_numtype2, P_struct2>& d2)
2375	{
2376	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
2377	_bz_MatrixRef<P_numtype2, P_struct2>,
2378	_bz_ShiftRight<int, P_numtype2> > T_expr;
2379
2380	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
2381	d2._bz_getRef()));
2382	}
2383
2384	// int >> _bz_MatExpr<P_expr2>
2385	template<class P_expr2>
2386	inline
2387	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
2388	_bz_MatExpr<P_expr2>,
2389	_bz_ShiftRight<int, typename P_expr2::T_numtype > > >
2390	operator>>(int d1,
2391	_bz_MatExpr<P_expr2> d2)
2392	{
2393	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
2394	_bz_MatExpr<P_expr2>,
2395	_bz_ShiftRight<int, typename P_expr2::T_numtype> > T_expr;
2396
2397	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
2398	d2));
2399	}
2400	/****************************************************************************
2401	* Shift left Operators
2402	****************************************************************************/
2403
2404	// Matrix<P_numtype1, P_struct1> << Matrix<P_numtype2, P_struct2>
2405	template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
2406	inline
2407	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2408	_bz_MatrixRef<P_numtype2, P_struct2>,
2409	_bz_ShiftLeft<P_numtype1, P_numtype2 > > >
2410	operator<<(const Matrix<P_numtype1, P_struct1>& d1,
2411	const Matrix<P_numtype2, P_struct2>& d2)
2412	{
2413	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2414	_bz_MatrixRef<P_numtype2, P_struct2>,
2415	_bz_ShiftLeft<P_numtype1, P_numtype2> > T_expr;
2416
2417	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
2418	d2._bz_getRef()));
2419	}
2420
2421	// Matrix<P_numtype1, P_struct1> << _bz_MatExpr<P_expr2>
2422	template<class P_numtype1, class P_struct1, class P_expr2>
2423	inline
2424	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2425	_bz_MatExpr<P_expr2>,
2426	_bz_ShiftLeft<P_numtype1, typename P_expr2::T_numtype > > >
2427	operator<<(const Matrix<P_numtype1, P_struct1>& d1,
2428	_bz_MatExpr<P_expr2> d2)
2429	{
2430	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2431	_bz_MatExpr<P_expr2>,
2432	_bz_ShiftLeft<P_numtype1, typename P_expr2::T_numtype> > T_expr;
2433
2434	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
2435	d2));
2436	}
2437
2438	// Matrix<P_numtype1, P_struct1> << int
2439	template<class P_numtype1, class P_struct1>
2440	inline
2441	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2442	_bz_MatExprConstant<int>,
2443	_bz_ShiftLeft<P_numtype1, int > > >
2444	operator<<(const Matrix<P_numtype1, P_struct1>& d1,
2445	int d2)
2446	{
2447	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2448	_bz_MatExprConstant<int>,
2449	_bz_ShiftLeft<P_numtype1, int> > T_expr;
2450
2451	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
2452	_bz_MatExprConstant<int>(d2)));
2453	}
2454
2455	// _bz_MatExpr<P_expr1> << Matrix<P_numtype2, P_struct2>
2456	template<class P_expr1, class P_numtype2, class P_struct2>
2457	inline
2458	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
2459	_bz_MatrixRef<P_numtype2, P_struct2>,
2460	_bz_ShiftLeft<typename P_expr1::T_numtype, P_numtype2 > > >
2461	operator<<(_bz_MatExpr<P_expr1> d1,
2462	const Matrix<P_numtype2, P_struct2>& d2)
2463	{
2464	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
2465	_bz_MatrixRef<P_numtype2, P_struct2>,
2466	_bz_ShiftLeft<typename P_expr1::T_numtype, P_numtype2> > T_expr;
2467
2468	return _bz_MatExpr<T_expr>(T_expr(d1,
2469	d2._bz_getRef()));
2470	}
2471
2472	// _bz_MatExpr<P_expr1> << _bz_MatExpr<P_expr2>
2473	template<class P_expr1, class P_expr2>
2474	inline
2475	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
2476	_bz_MatExpr<P_expr2>,
2477	_bz_ShiftLeft<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
2478	operator<<(_bz_MatExpr<P_expr1> d1,
2479	_bz_MatExpr<P_expr2> d2)
2480	{
2481	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
2482	_bz_MatExpr<P_expr2>,
2483	_bz_ShiftLeft<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
2484
2485	return _bz_MatExpr<T_expr>(T_expr(d1,
2486	d2));
2487	}
2488
2489	// _bz_MatExpr<P_expr1> << int
2490	template<class P_expr1>
2491	inline
2492	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
2493	_bz_MatExprConstant<int>,
2494	_bz_ShiftLeft<typename P_expr1::T_numtype, int > > >
2495	operator<<(_bz_MatExpr<P_expr1> d1,
2496	int d2)
2497	{
2498	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
2499	_bz_MatExprConstant<int>,
2500	_bz_ShiftLeft<typename P_expr1::T_numtype, int> > T_expr;
2501
2502	return _bz_MatExpr<T_expr>(T_expr(d1,
2503	_bz_MatExprConstant<int>(d2)));
2504	}
2505
2506	// int << Matrix<P_numtype2, P_struct2>
2507	template<class P_numtype2, class P_struct2>
2508	inline
2509	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
2510	_bz_MatrixRef<P_numtype2, P_struct2>,
2511	_bz_ShiftLeft<int, P_numtype2 > > >
2512	operator<<(int d1,
2513	const Matrix<P_numtype2, P_struct2>& d2)
2514	{
2515	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
2516	_bz_MatrixRef<P_numtype2, P_struct2>,
2517	_bz_ShiftLeft<int, P_numtype2> > T_expr;
2518
2519	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
2520	d2._bz_getRef()));
2521	}
2522
2523	// int << _bz_MatExpr<P_expr2>
2524	template<class P_expr2>
2525	inline
2526	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
2527	_bz_MatExpr<P_expr2>,
2528	_bz_ShiftLeft<int, typename P_expr2::T_numtype > > >
2529	operator<<(int d1,
2530	_bz_MatExpr<P_expr2> d2)
2531	{
2532	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
2533	_bz_MatExpr<P_expr2>,
2534	_bz_ShiftLeft<int, typename P_expr2::T_numtype> > T_expr;
2535
2536	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
2537	d2));
2538	}
2539	/****************************************************************************
2540	* Greater-than Operators
2541	****************************************************************************/
2542
2543	// Matrix<P_numtype1, P_struct1> > Matrix<P_numtype2, P_struct2>
2544	template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
2545	inline
2546	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2547	_bz_MatrixRef<P_numtype2, P_struct2>,
2548	_bz_Greater<P_numtype1, P_numtype2 > > >
2549	operator>(const Matrix<P_numtype1, P_struct1>& d1,
2550	const Matrix<P_numtype2, P_struct2>& d2)
2551	{
2552	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2553	_bz_MatrixRef<P_numtype2, P_struct2>,
2554	_bz_Greater<P_numtype1, P_numtype2> > T_expr;
2555
2556	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
2557	d2._bz_getRef()));
2558	}
2559
2560	// Matrix<P_numtype1, P_struct1> > _bz_MatExpr<P_expr2>
2561	template<class P_numtype1, class P_struct1, class P_expr2>
2562	inline
2563	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2564	_bz_MatExpr<P_expr2>,
2565	_bz_Greater<P_numtype1, typename P_expr2::T_numtype > > >
2566	operator>(const Matrix<P_numtype1, P_struct1>& d1,
2567	_bz_MatExpr<P_expr2> d2)
2568	{
2569	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2570	_bz_MatExpr<P_expr2>,
2571	_bz_Greater<P_numtype1, typename P_expr2::T_numtype> > T_expr;
2572
2573	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
2574	d2));
2575	}
2576
2577	// Matrix<P_numtype1, P_struct1> > int
2578	template<class P_numtype1, class P_struct1>
2579	inline
2580	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2581	_bz_MatExprConstant<int>,
2582	_bz_Greater<P_numtype1, int > > >
2583	operator>(const Matrix<P_numtype1, P_struct1>& d1,
2584	int d2)
2585	{
2586	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2587	_bz_MatExprConstant<int>,
2588	_bz_Greater<P_numtype1, int> > T_expr;
2589
2590	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
2591	_bz_MatExprConstant<int>(d2)));
2592	}
2593
2594	// Matrix<P_numtype1, P_struct1> > float
2595	template<class P_numtype1, class P_struct1>
2596	inline
2597	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2598	_bz_MatExprConstant<float>,
2599	_bz_Greater<P_numtype1, float > > >
2600	operator>(const Matrix<P_numtype1, P_struct1>& d1,
2601	float d2)
2602	{
2603	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2604	_bz_MatExprConstant<float>,
2605	_bz_Greater<P_numtype1, float> > T_expr;
2606
2607	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
2608	_bz_MatExprConstant<float>(d2)));
2609	}
2610
2611	// Matrix<P_numtype1, P_struct1> > double
2612	template<class P_numtype1, class P_struct1>
2613	inline
2614	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2615	_bz_MatExprConstant<double>,
2616	_bz_Greater<P_numtype1, double > > >
2617	operator>(const Matrix<P_numtype1, P_struct1>& d1,
2618	double d2)
2619	{
2620	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2621	_bz_MatExprConstant<double>,
2622	_bz_Greater<P_numtype1, double> > T_expr;
2623
2624	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
2625	_bz_MatExprConstant<double>(d2)));
2626	}
2627
2628	// Matrix<P_numtype1, P_struct1> > long double
2629	template<class P_numtype1, class P_struct1>
2630	inline
2631	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2632	_bz_MatExprConstant<long double>,
2633	_bz_Greater<P_numtype1, long double > > >
2634	operator>(const Matrix<P_numtype1, P_struct1>& d1,
2635	long double d2)
2636	{
2637	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2638	_bz_MatExprConstant<long double>,
2639	_bz_Greater<P_numtype1, long double> > T_expr;
2640
2641	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
2642	_bz_MatExprConstant<long double>(d2)));
2643	}
2644	#ifdef BZ_HAVE_COMPLEX
2645
2646	// Matrix<P_numtype1, P_struct1> > complex<T2>
2647	template<class P_numtype1, class P_struct1, class T2>
2648	inline
2649	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2650	_bz_MatExprConstant<complex<T2> > ,
2651	_bz_Greater<P_numtype1, complex<T2> > > >
2652	operator>(const Matrix<P_numtype1, P_struct1>& d1,
2653	complex<T2> d2)
2654	{
2655	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2656	_bz_MatExprConstant<complex<T2> > ,
2657	_bz_Greater<P_numtype1, complex<T2> > > T_expr;
2658
2659	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
2660	_bz_MatExprConstant<complex<T2> > (d2)));
2661	}
2662	#endif // BZ_HAVE_COMPLEX
2663
2664
2665	// _bz_MatExpr<P_expr1> > Matrix<P_numtype2, P_struct2>
2666	template<class P_expr1, class P_numtype2, class P_struct2>
2667	inline
2668	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
2669	_bz_MatrixRef<P_numtype2, P_struct2>,
2670	_bz_Greater<typename P_expr1::T_numtype, P_numtype2 > > >
2671	operator>(_bz_MatExpr<P_expr1> d1,
2672	const Matrix<P_numtype2, P_struct2>& d2)
2673	{
2674	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
2675	_bz_MatrixRef<P_numtype2, P_struct2>,
2676	_bz_Greater<typename P_expr1::T_numtype, P_numtype2> > T_expr;
2677
2678	return _bz_MatExpr<T_expr>(T_expr(d1,
2679	d2._bz_getRef()));
2680	}
2681
2682	// _bz_MatExpr<P_expr1> > _bz_MatExpr<P_expr2>
2683	template<class P_expr1, class P_expr2>
2684	inline
2685	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
2686	_bz_MatExpr<P_expr2>,
2687	_bz_Greater<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
2688	operator>(_bz_MatExpr<P_expr1> d1,
2689	_bz_MatExpr<P_expr2> d2)
2690	{
2691	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
2692	_bz_MatExpr<P_expr2>,
2693	_bz_Greater<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
2694
2695	return _bz_MatExpr<T_expr>(T_expr(d1,
2696	d2));
2697	}
2698
2699	// _bz_MatExpr<P_expr1> > int
2700	template<class P_expr1>
2701	inline
2702	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
2703	_bz_MatExprConstant<int>,
2704	_bz_Greater<typename P_expr1::T_numtype, int > > >
2705	operator>(_bz_MatExpr<P_expr1> d1,
2706	int d2)
2707	{
2708	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
2709	_bz_MatExprConstant<int>,
2710	_bz_Greater<typename P_expr1::T_numtype, int> > T_expr;
2711
2712	return _bz_MatExpr<T_expr>(T_expr(d1,
2713	_bz_MatExprConstant<int>(d2)));
2714	}
2715
2716	// _bz_MatExpr<P_expr1> > float
2717	template<class P_expr1>
2718	inline
2719	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
2720	_bz_MatExprConstant<float>,
2721	_bz_Greater<typename P_expr1::T_numtype, float > > >
2722	operator>(_bz_MatExpr<P_expr1> d1,
2723	float d2)
2724	{
2725	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
2726	_bz_MatExprConstant<float>,
2727	_bz_Greater<typename P_expr1::T_numtype, float> > T_expr;
2728
2729	return _bz_MatExpr<T_expr>(T_expr(d1,
2730	_bz_MatExprConstant<float>(d2)));
2731	}
2732
2733	// _bz_MatExpr<P_expr1> > double
2734	template<class P_expr1>
2735	inline
2736	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
2737	_bz_MatExprConstant<double>,
2738	_bz_Greater<typename P_expr1::T_numtype, double > > >
2739	operator>(_bz_MatExpr<P_expr1> d1,
2740	double d2)
2741	{
2742	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
2743	_bz_MatExprConstant<double>,
2744	_bz_Greater<typename P_expr1::T_numtype, double> > T_expr;
2745
2746	return _bz_MatExpr<T_expr>(T_expr(d1,
2747	_bz_MatExprConstant<double>(d2)));
2748	}
2749
2750	// _bz_MatExpr<P_expr1> > long double
2751	template<class P_expr1>
2752	inline
2753	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
2754	_bz_MatExprConstant<long double>,
2755	_bz_Greater<typename P_expr1::T_numtype, long double > > >
2756	operator>(_bz_MatExpr<P_expr1> d1,
2757	long double d2)
2758	{
2759	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
2760	_bz_MatExprConstant<long double>,
2761	_bz_Greater<typename P_expr1::T_numtype, long double> > T_expr;
2762
2763	return _bz_MatExpr<T_expr>(T_expr(d1,
2764	_bz_MatExprConstant<long double>(d2)));
2765	}
2766	#ifdef BZ_HAVE_COMPLEX
2767
2768	// _bz_MatExpr<P_expr1> > complex<T2>
2769	template<class P_expr1, class T2>
2770	inline
2771	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
2772	_bz_MatExprConstant<complex<T2> > ,
2773	_bz_Greater<typename P_expr1::T_numtype, complex<T2> > > >
2774	operator>(_bz_MatExpr<P_expr1> d1,
2775	complex<T2> d2)
2776	{
2777	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
2778	_bz_MatExprConstant<complex<T2> > ,
2779	_bz_Greater<typename P_expr1::T_numtype, complex<T2> > > T_expr;
2780
2781	return _bz_MatExpr<T_expr>(T_expr(d1,
2782	_bz_MatExprConstant<complex<T2> > (d2)));
2783	}
2784	#endif // BZ_HAVE_COMPLEX
2785
2786
2787	// int > Matrix<P_numtype2, P_struct2>
2788	template<class P_numtype2, class P_struct2>
2789	inline
2790	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
2791	_bz_MatrixRef<P_numtype2, P_struct2>,
2792	_bz_Greater<int, P_numtype2 > > >
2793	operator>(int d1,
2794	const Matrix<P_numtype2, P_struct2>& d2)
2795	{
2796	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
2797	_bz_MatrixRef<P_numtype2, P_struct2>,
2798	_bz_Greater<int, P_numtype2> > T_expr;
2799
2800	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
2801	d2._bz_getRef()));
2802	}
2803
2804	// int > _bz_MatExpr<P_expr2>
2805	template<class P_expr2>
2806	inline
2807	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
2808	_bz_MatExpr<P_expr2>,
2809	_bz_Greater<int, typename P_expr2::T_numtype > > >
2810	operator>(int d1,
2811	_bz_MatExpr<P_expr2> d2)
2812	{
2813	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
2814	_bz_MatExpr<P_expr2>,
2815	_bz_Greater<int, typename P_expr2::T_numtype> > T_expr;
2816
2817	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
2818	d2));
2819	}
2820
2821	// float > Matrix<P_numtype2, P_struct2>
2822	template<class P_numtype2, class P_struct2>
2823	inline
2824	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>,
2825	_bz_MatrixRef<P_numtype2, P_struct2>,
2826	_bz_Greater<float, P_numtype2 > > >
2827	operator>(float d1,
2828	const Matrix<P_numtype2, P_struct2>& d2)
2829	{
2830	typedef _bz_MatExprOp<_bz_MatExprConstant<float>,
2831	_bz_MatrixRef<P_numtype2, P_struct2>,
2832	_bz_Greater<float, P_numtype2> > T_expr;
2833
2834	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1),
2835	d2._bz_getRef()));
2836	}
2837
2838	// float > _bz_MatExpr<P_expr2>
2839	template<class P_expr2>
2840	inline
2841	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>,
2842	_bz_MatExpr<P_expr2>,
2843	_bz_Greater<float, typename P_expr2::T_numtype > > >
2844	operator>(float d1,
2845	_bz_MatExpr<P_expr2> d2)
2846	{
2847	typedef _bz_MatExprOp<_bz_MatExprConstant<float>,
2848	_bz_MatExpr<P_expr2>,
2849	_bz_Greater<float, typename P_expr2::T_numtype> > T_expr;
2850
2851	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1),
2852	d2));
2853	}
2854
2855	// double > Matrix<P_numtype2, P_struct2>
2856	template<class P_numtype2, class P_struct2>
2857	inline
2858	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>,
2859	_bz_MatrixRef<P_numtype2, P_struct2>,
2860	_bz_Greater<double, P_numtype2 > > >
2861	operator>(double d1,
2862	const Matrix<P_numtype2, P_struct2>& d2)
2863	{
2864	typedef _bz_MatExprOp<_bz_MatExprConstant<double>,
2865	_bz_MatrixRef<P_numtype2, P_struct2>,
2866	_bz_Greater<double, P_numtype2> > T_expr;
2867
2868	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1),
2869	d2._bz_getRef()));
2870	}
2871
2872	// double > _bz_MatExpr<P_expr2>
2873	template<class P_expr2>
2874	inline
2875	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>,
2876	_bz_MatExpr<P_expr2>,
2877	_bz_Greater<double, typename P_expr2::T_numtype > > >
2878	operator>(double d1,
2879	_bz_MatExpr<P_expr2> d2)
2880	{
2881	typedef _bz_MatExprOp<_bz_MatExprConstant<double>,
2882	_bz_MatExpr<P_expr2>,
2883	_bz_Greater<double, typename P_expr2::T_numtype> > T_expr;
2884
2885	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1),
2886	d2));
2887	}
2888
2889	// long double > Matrix<P_numtype2, P_struct2>
2890	template<class P_numtype2, class P_struct2>
2891	inline
2892	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>,
2893	_bz_MatrixRef<P_numtype2, P_struct2>,
2894	_bz_Greater<long double, P_numtype2 > > >
2895	operator>(long double d1,
2896	const Matrix<P_numtype2, P_struct2>& d2)
2897	{
2898	typedef _bz_MatExprOp<_bz_MatExprConstant<long double>,
2899	_bz_MatrixRef<P_numtype2, P_struct2>,
2900	_bz_Greater<long double, P_numtype2> > T_expr;
2901
2902	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1),
2903	d2._bz_getRef()));
2904	}
2905
2906	// long double > _bz_MatExpr<P_expr2>
2907	template<class P_expr2>
2908	inline
2909	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>,
2910	_bz_MatExpr<P_expr2>,
2911	_bz_Greater<long double, typename P_expr2::T_numtype > > >
2912	operator>(long double d1,
2913	_bz_MatExpr<P_expr2> d2)
2914	{
2915	typedef _bz_MatExprOp<_bz_MatExprConstant<long double>,
2916	_bz_MatExpr<P_expr2>,
2917	_bz_Greater<long double, typename P_expr2::T_numtype> > T_expr;
2918
2919	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1),
2920	d2));
2921	}
2922	#ifdef BZ_HAVE_COMPLEX
2923
2924	// complex<T1> > Matrix<P_numtype2, P_struct2>
2925	template<class T1, class P_numtype2, class P_struct2>
2926	inline
2927	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
2928	_bz_MatrixRef<P_numtype2, P_struct2>,
2929	_bz_Greater<complex<T1> , P_numtype2 > > >
2930	operator>(complex<T1> d1,
2931	const Matrix<P_numtype2, P_struct2>& d2)
2932	{
2933	typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
2934	_bz_MatrixRef<P_numtype2, P_struct2>,
2935	_bz_Greater<complex<T1> , P_numtype2> > T_expr;
2936
2937	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1),
2938	d2._bz_getRef()));
2939	}
2940	#endif // BZ_HAVE_COMPLEX
2941
2942	#ifdef BZ_HAVE_COMPLEX
2943
2944	// complex<T1> > _bz_MatExpr<P_expr2>
2945	template<class T1, class P_expr2>
2946	inline
2947	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
2948	_bz_MatExpr<P_expr2>,
2949	_bz_Greater<complex<T1> , typename P_expr2::T_numtype > > >
2950	operator>(complex<T1> d1,
2951	_bz_MatExpr<P_expr2> d2)
2952	{
2953	typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
2954	_bz_MatExpr<P_expr2>,
2955	_bz_Greater<complex<T1> , typename P_expr2::T_numtype> > T_expr;
2956
2957	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1),
2958	d2));
2959	}
2960	#endif // BZ_HAVE_COMPLEX
2961
2962	/****************************************************************************
2963	* Less-than Operators
2964	****************************************************************************/
2965
2966	// Matrix<P_numtype1, P_struct1> < Matrix<P_numtype2, P_struct2>
2967	template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
2968	inline
2969	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2970	_bz_MatrixRef<P_numtype2, P_struct2>,
2971	_bz_Less<P_numtype1, P_numtype2 > > >
2972	operator<(const Matrix<P_numtype1, P_struct1>& d1,
2973	const Matrix<P_numtype2, P_struct2>& d2)
2974	{
2975	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2976	_bz_MatrixRef<P_numtype2, P_struct2>,
2977	_bz_Less<P_numtype1, P_numtype2> > T_expr;
2978
2979	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
2980	d2._bz_getRef()));
2981	}
2982
2983	// Matrix<P_numtype1, P_struct1> < _bz_MatExpr<P_expr2>
2984	template<class P_numtype1, class P_struct1, class P_expr2>
2985	inline
2986	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2987	_bz_MatExpr<P_expr2>,
2988	_bz_Less<P_numtype1, typename P_expr2::T_numtype > > >
2989	operator<(const Matrix<P_numtype1, P_struct1>& d1,
2990	_bz_MatExpr<P_expr2> d2)
2991	{
2992	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
2993	_bz_MatExpr<P_expr2>,
2994	_bz_Less<P_numtype1, typename P_expr2::T_numtype> > T_expr;
2995
2996	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
2997	d2));
2998	}
2999
3000	// Matrix<P_numtype1, P_struct1> < int
3001	template<class P_numtype1, class P_struct1>
3002	inline
3003	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3004	_bz_MatExprConstant<int>,
3005	_bz_Less<P_numtype1, int > > >
3006	operator<(const Matrix<P_numtype1, P_struct1>& d1,
3007	int d2)
3008	{
3009	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3010	_bz_MatExprConstant<int>,
3011	_bz_Less<P_numtype1, int> > T_expr;
3012
3013	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
3014	_bz_MatExprConstant<int>(d2)));
3015	}
3016
3017	// Matrix<P_numtype1, P_struct1> < float
3018	template<class P_numtype1, class P_struct1>
3019	inline
3020	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3021	_bz_MatExprConstant<float>,
3022	_bz_Less<P_numtype1, float > > >
3023	operator<(const Matrix<P_numtype1, P_struct1>& d1,
3024	float d2)
3025	{
3026	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3027	_bz_MatExprConstant<float>,
3028	_bz_Less<P_numtype1, float> > T_expr;
3029
3030	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
3031	_bz_MatExprConstant<float>(d2)));
3032	}
3033
3034	// Matrix<P_numtype1, P_struct1> < double
3035	template<class P_numtype1, class P_struct1>
3036	inline
3037	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3038	_bz_MatExprConstant<double>,
3039	_bz_Less<P_numtype1, double > > >
3040	operator<(const Matrix<P_numtype1, P_struct1>& d1,
3041	double d2)
3042	{
3043	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3044	_bz_MatExprConstant<double>,
3045	_bz_Less<P_numtype1, double> > T_expr;
3046
3047	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
3048	_bz_MatExprConstant<double>(d2)));
3049	}
3050
3051	// Matrix<P_numtype1, P_struct1> < long double
3052	template<class P_numtype1, class P_struct1>
3053	inline
3054	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3055	_bz_MatExprConstant<long double>,
3056	_bz_Less<P_numtype1, long double > > >
3057	operator<(const Matrix<P_numtype1, P_struct1>& d1,
3058	long double d2)
3059	{
3060	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3061	_bz_MatExprConstant<long double>,
3062	_bz_Less<P_numtype1, long double> > T_expr;
3063
3064	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
3065	_bz_MatExprConstant<long double>(d2)));
3066	}
3067	#ifdef BZ_HAVE_COMPLEX
3068
3069	// Matrix<P_numtype1, P_struct1> < complex<T2>
3070	template<class P_numtype1, class P_struct1, class T2>
3071	inline
3072	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3073	_bz_MatExprConstant<complex<T2> > ,
3074	_bz_Less<P_numtype1, complex<T2> > > >
3075	operator<(const Matrix<P_numtype1, P_struct1>& d1,
3076	complex<T2> d2)
3077	{
3078	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3079	_bz_MatExprConstant<complex<T2> > ,
3080	_bz_Less<P_numtype1, complex<T2> > > T_expr;
3081
3082	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
3083	_bz_MatExprConstant<complex<T2> > (d2)));
3084	}
3085	#endif // BZ_HAVE_COMPLEX
3086
3087
3088	// _bz_MatExpr<P_expr1> < Matrix<P_numtype2, P_struct2>
3089	template<class P_expr1, class P_numtype2, class P_struct2>
3090	inline
3091	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
3092	_bz_MatrixRef<P_numtype2, P_struct2>,
3093	_bz_Less<typename P_expr1::T_numtype, P_numtype2 > > >
3094	operator<(_bz_MatExpr<P_expr1> d1,
3095	const Matrix<P_numtype2, P_struct2>& d2)
3096	{
3097	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
3098	_bz_MatrixRef<P_numtype2, P_struct2>,
3099	_bz_Less<typename P_expr1::T_numtype, P_numtype2> > T_expr;
3100
3101	return _bz_MatExpr<T_expr>(T_expr(d1,
3102	d2._bz_getRef()));
3103	}
3104
3105	// _bz_MatExpr<P_expr1> < _bz_MatExpr<P_expr2>
3106	template<class P_expr1, class P_expr2>
3107	inline
3108	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
3109	_bz_MatExpr<P_expr2>,
3110	_bz_Less<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
3111	operator<(_bz_MatExpr<P_expr1> d1,
3112	_bz_MatExpr<P_expr2> d2)
3113	{
3114	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
3115	_bz_MatExpr<P_expr2>,
3116	_bz_Less<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
3117
3118	return _bz_MatExpr<T_expr>(T_expr(d1,
3119	d2));
3120	}
3121
3122	// _bz_MatExpr<P_expr1> < int
3123	template<class P_expr1>
3124	inline
3125	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
3126	_bz_MatExprConstant<int>,
3127	_bz_Less<typename P_expr1::T_numtype, int > > >
3128	operator<(_bz_MatExpr<P_expr1> d1,
3129	int d2)
3130	{
3131	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
3132	_bz_MatExprConstant<int>,
3133	_bz_Less<typename P_expr1::T_numtype, int> > T_expr;
3134
3135	return _bz_MatExpr<T_expr>(T_expr(d1,
3136	_bz_MatExprConstant<int>(d2)));
3137	}
3138
3139	// _bz_MatExpr<P_expr1> < float
3140	template<class P_expr1>
3141	inline
3142	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
3143	_bz_MatExprConstant<float>,
3144	_bz_Less<typename P_expr1::T_numtype, float > > >
3145	operator<(_bz_MatExpr<P_expr1> d1,
3146	float d2)
3147	{
3148	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
3149	_bz_MatExprConstant<float>,
3150	_bz_Less<typename P_expr1::T_numtype, float> > T_expr;
3151
3152	return _bz_MatExpr<T_expr>(T_expr(d1,
3153	_bz_MatExprConstant<float>(d2)));
3154	}
3155
3156	// _bz_MatExpr<P_expr1> < double
3157	template<class P_expr1>
3158	inline
3159	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
3160	_bz_MatExprConstant<double>,
3161	_bz_Less<typename P_expr1::T_numtype, double > > >
3162	operator<(_bz_MatExpr<P_expr1> d1,
3163	double d2)
3164	{
3165	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
3166	_bz_MatExprConstant<double>,
3167	_bz_Less<typename P_expr1::T_numtype, double> > T_expr;
3168
3169	return _bz_MatExpr<T_expr>(T_expr(d1,
3170	_bz_MatExprConstant<double>(d2)));
3171	}
3172
3173	// _bz_MatExpr<P_expr1> < long double
3174	template<class P_expr1>
3175	inline
3176	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
3177	_bz_MatExprConstant<long double>,
3178	_bz_Less<typename P_expr1::T_numtype, long double > > >
3179	operator<(_bz_MatExpr<P_expr1> d1,
3180	long double d2)
3181	{
3182	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
3183	_bz_MatExprConstant<long double>,
3184	_bz_Less<typename P_expr1::T_numtype, long double> > T_expr;
3185
3186	return _bz_MatExpr<T_expr>(T_expr(d1,
3187	_bz_MatExprConstant<long double>(d2)));
3188	}
3189	#ifdef BZ_HAVE_COMPLEX
3190
3191	// _bz_MatExpr<P_expr1> < complex<T2>
3192	template<class P_expr1, class T2>
3193	inline
3194	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
3195	_bz_MatExprConstant<complex<T2> > ,
3196	_bz_Less<typename P_expr1::T_numtype, complex<T2> > > >
3197	operator<(_bz_MatExpr<P_expr1> d1,
3198	complex<T2> d2)
3199	{
3200	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
3201	_bz_MatExprConstant<complex<T2> > ,
3202	_bz_Less<typename P_expr1::T_numtype, complex<T2> > > T_expr;
3203
3204	return _bz_MatExpr<T_expr>(T_expr(d1,
3205	_bz_MatExprConstant<complex<T2> > (d2)));
3206	}
3207	#endif // BZ_HAVE_COMPLEX
3208
3209
3210	// int < Matrix<P_numtype2, P_struct2>
3211	template<class P_numtype2, class P_struct2>
3212	inline
3213	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
3214	_bz_MatrixRef<P_numtype2, P_struct2>,
3215	_bz_Less<int, P_numtype2 > > >
3216	operator<(int d1,
3217	const Matrix<P_numtype2, P_struct2>& d2)
3218	{
3219	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
3220	_bz_MatrixRef<P_numtype2, P_struct2>,
3221	_bz_Less<int, P_numtype2> > T_expr;
3222
3223	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
3224	d2._bz_getRef()));
3225	}
3226
3227	// int < _bz_MatExpr<P_expr2>
3228	template<class P_expr2>
3229	inline
3230	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
3231	_bz_MatExpr<P_expr2>,
3232	_bz_Less<int, typename P_expr2::T_numtype > > >
3233	operator<(int d1,
3234	_bz_MatExpr<P_expr2> d2)
3235	{
3236	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
3237	_bz_MatExpr<P_expr2>,
3238	_bz_Less<int, typename P_expr2::T_numtype> > T_expr;
3239
3240	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
3241	d2));
3242	}
3243
3244	// float < Matrix<P_numtype2, P_struct2>
3245	template<class P_numtype2, class P_struct2>
3246	inline
3247	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>,
3248	_bz_MatrixRef<P_numtype2, P_struct2>,
3249	_bz_Less<float, P_numtype2 > > >
3250	operator<(float d1,
3251	const Matrix<P_numtype2, P_struct2>& d2)
3252	{
3253	typedef _bz_MatExprOp<_bz_MatExprConstant<float>,
3254	_bz_MatrixRef<P_numtype2, P_struct2>,
3255	_bz_Less<float, P_numtype2> > T_expr;
3256
3257	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1),
3258	d2._bz_getRef()));
3259	}
3260
3261	// float < _bz_MatExpr<P_expr2>
3262	template<class P_expr2>
3263	inline
3264	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>,
3265	_bz_MatExpr<P_expr2>,
3266	_bz_Less<float, typename P_expr2::T_numtype > > >
3267	operator<(float d1,
3268	_bz_MatExpr<P_expr2> d2)
3269	{
3270	typedef _bz_MatExprOp<_bz_MatExprConstant<float>,
3271	_bz_MatExpr<P_expr2>,
3272	_bz_Less<float, typename P_expr2::T_numtype> > T_expr;
3273
3274	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1),
3275	d2));
3276	}
3277
3278	// double < Matrix<P_numtype2, P_struct2>
3279	template<class P_numtype2, class P_struct2>
3280	inline
3281	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>,
3282	_bz_MatrixRef<P_numtype2, P_struct2>,
3283	_bz_Less<double, P_numtype2 > > >
3284	operator<(double d1,
3285	const Matrix<P_numtype2, P_struct2>& d2)
3286	{
3287	typedef _bz_MatExprOp<_bz_MatExprConstant<double>,
3288	_bz_MatrixRef<P_numtype2, P_struct2>,
3289	_bz_Less<double, P_numtype2> > T_expr;
3290
3291	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1),
3292	d2._bz_getRef()));
3293	}
3294
3295	// double < _bz_MatExpr<P_expr2>
3296	template<class P_expr2>
3297	inline
3298	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>,
3299	_bz_MatExpr<P_expr2>,
3300	_bz_Less<double, typename P_expr2::T_numtype > > >
3301	operator<(double d1,
3302	_bz_MatExpr<P_expr2> d2)
3303	{
3304	typedef _bz_MatExprOp<_bz_MatExprConstant<double>,
3305	_bz_MatExpr<P_expr2>,
3306	_bz_Less<double, typename P_expr2::T_numtype> > T_expr;
3307
3308	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1),
3309	d2));
3310	}
3311
3312	// long double < Matrix<P_numtype2, P_struct2>
3313	template<class P_numtype2, class P_struct2>
3314	inline
3315	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>,
3316	_bz_MatrixRef<P_numtype2, P_struct2>,
3317	_bz_Less<long double, P_numtype2 > > >
3318	operator<(long double d1,
3319	const Matrix<P_numtype2, P_struct2>& d2)
3320	{
3321	typedef _bz_MatExprOp<_bz_MatExprConstant<long double>,
3322	_bz_MatrixRef<P_numtype2, P_struct2>,
3323	_bz_Less<long double, P_numtype2> > T_expr;
3324
3325	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1),
3326	d2._bz_getRef()));
3327	}
3328
3329	// long double < _bz_MatExpr<P_expr2>
3330	template<class P_expr2>
3331	inline
3332	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>,
3333	_bz_MatExpr<P_expr2>,
3334	_bz_Less<long double, typename P_expr2::T_numtype > > >
3335	operator<(long double d1,
3336	_bz_MatExpr<P_expr2> d2)
3337	{
3338	typedef _bz_MatExprOp<_bz_MatExprConstant<long double>,
3339	_bz_MatExpr<P_expr2>,
3340	_bz_Less<long double, typename P_expr2::T_numtype> > T_expr;
3341
3342	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1),
3343	d2));
3344	}
3345	#ifdef BZ_HAVE_COMPLEX
3346
3347	// complex<T1> < Matrix<P_numtype2, P_struct2>
3348	template<class T1, class P_numtype2, class P_struct2>
3349	inline
3350	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
3351	_bz_MatrixRef<P_numtype2, P_struct2>,
3352	_bz_Less<complex<T1> , P_numtype2 > > >
3353	operator<(complex<T1> d1,
3354	const Matrix<P_numtype2, P_struct2>& d2)
3355	{
3356	typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
3357	_bz_MatrixRef<P_numtype2, P_struct2>,
3358	_bz_Less<complex<T1> , P_numtype2> > T_expr;
3359
3360	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1),
3361	d2._bz_getRef()));
3362	}
3363	#endif // BZ_HAVE_COMPLEX
3364
3365	#ifdef BZ_HAVE_COMPLEX
3366
3367	// complex<T1> < _bz_MatExpr<P_expr2>
3368	template<class T1, class P_expr2>
3369	inline
3370	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
3371	_bz_MatExpr<P_expr2>,
3372	_bz_Less<complex<T1> , typename P_expr2::T_numtype > > >
3373	operator<(complex<T1> d1,
3374	_bz_MatExpr<P_expr2> d2)
3375	{
3376	typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
3377	_bz_MatExpr<P_expr2>,
3378	_bz_Less<complex<T1> , typename P_expr2::T_numtype> > T_expr;
3379
3380	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1),
3381	d2));
3382	}
3383	#endif // BZ_HAVE_COMPLEX
3384
3385	/****************************************************************************
3386	* Greater or equal (>=) operators
3387	****************************************************************************/
3388
3389	// Matrix<P_numtype1, P_struct1> >= Matrix<P_numtype2, P_struct2>
3390	template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
3391	inline
3392	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3393	_bz_MatrixRef<P_numtype2, P_struct2>,
3394	_bz_GreaterOrEqual<P_numtype1, P_numtype2 > > >
3395	operator>=(const Matrix<P_numtype1, P_struct1>& d1,
3396	const Matrix<P_numtype2, P_struct2>& d2)
3397	{
3398	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3399	_bz_MatrixRef<P_numtype2, P_struct2>,
3400	_bz_GreaterOrEqual<P_numtype1, P_numtype2> > T_expr;
3401
3402	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
3403	d2._bz_getRef()));
3404	}
3405
3406	// Matrix<P_numtype1, P_struct1> >= _bz_MatExpr<P_expr2>
3407	template<class P_numtype1, class P_struct1, class P_expr2>
3408	inline
3409	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3410	_bz_MatExpr<P_expr2>,
3411	_bz_GreaterOrEqual<P_numtype1, typename P_expr2::T_numtype > > >
3412	operator>=(const Matrix<P_numtype1, P_struct1>& d1,
3413	_bz_MatExpr<P_expr2> d2)
3414	{
3415	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3416	_bz_MatExpr<P_expr2>,
3417	_bz_GreaterOrEqual<P_numtype1, typename P_expr2::T_numtype> > T_expr;
3418
3419	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
3420	d2));
3421	}
3422
3423	// Matrix<P_numtype1, P_struct1> >= int
3424	template<class P_numtype1, class P_struct1>
3425	inline
3426	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3427	_bz_MatExprConstant<int>,
3428	_bz_GreaterOrEqual<P_numtype1, int > > >
3429	operator>=(const Matrix<P_numtype1, P_struct1>& d1,
3430	int d2)
3431	{
3432	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3433	_bz_MatExprConstant<int>,
3434	_bz_GreaterOrEqual<P_numtype1, int> > T_expr;
3435
3436	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
3437	_bz_MatExprConstant<int>(d2)));
3438	}
3439
3440	// Matrix<P_numtype1, P_struct1> >= float
3441	template<class P_numtype1, class P_struct1>
3442	inline
3443	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3444	_bz_MatExprConstant<float>,
3445	_bz_GreaterOrEqual<P_numtype1, float > > >
3446	operator>=(const Matrix<P_numtype1, P_struct1>& d1,
3447	float d2)
3448	{
3449	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3450	_bz_MatExprConstant<float>,
3451	_bz_GreaterOrEqual<P_numtype1, float> > T_expr;
3452
3453	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
3454	_bz_MatExprConstant<float>(d2)));
3455	}
3456
3457	// Matrix<P_numtype1, P_struct1> >= double
3458	template<class P_numtype1, class P_struct1>
3459	inline
3460	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3461	_bz_MatExprConstant<double>,
3462	_bz_GreaterOrEqual<P_numtype1, double > > >
3463	operator>=(const Matrix<P_numtype1, P_struct1>& d1,
3464	double d2)
3465	{
3466	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3467	_bz_MatExprConstant<double>,
3468	_bz_GreaterOrEqual<P_numtype1, double> > T_expr;
3469
3470	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
3471	_bz_MatExprConstant<double>(d2)));
3472	}
3473
3474	// Matrix<P_numtype1, P_struct1> >= long double
3475	template<class P_numtype1, class P_struct1>
3476	inline
3477	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3478	_bz_MatExprConstant<long double>,
3479	_bz_GreaterOrEqual<P_numtype1, long double > > >
3480	operator>=(const Matrix<P_numtype1, P_struct1>& d1,
3481	long double d2)
3482	{
3483	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3484	_bz_MatExprConstant<long double>,
3485	_bz_GreaterOrEqual<P_numtype1, long double> > T_expr;
3486
3487	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
3488	_bz_MatExprConstant<long double>(d2)));
3489	}
3490	#ifdef BZ_HAVE_COMPLEX
3491
3492	// Matrix<P_numtype1, P_struct1> >= complex<T2>
3493	template<class P_numtype1, class P_struct1, class T2>
3494	inline
3495	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3496	_bz_MatExprConstant<complex<T2> > ,
3497	_bz_GreaterOrEqual<P_numtype1, complex<T2> > > >
3498	operator>=(const Matrix<P_numtype1, P_struct1>& d1,
3499	complex<T2> d2)
3500	{
3501	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3502	_bz_MatExprConstant<complex<T2> > ,
3503	_bz_GreaterOrEqual<P_numtype1, complex<T2> > > T_expr;
3504
3505	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
3506	_bz_MatExprConstant<complex<T2> > (d2)));
3507	}
3508	#endif // BZ_HAVE_COMPLEX
3509
3510
3511	// _bz_MatExpr<P_expr1> >= Matrix<P_numtype2, P_struct2>
3512	template<class P_expr1, class P_numtype2, class P_struct2>
3513	inline
3514	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
3515	_bz_MatrixRef<P_numtype2, P_struct2>,
3516	_bz_GreaterOrEqual<typename P_expr1::T_numtype, P_numtype2 > > >
3517	operator>=(_bz_MatExpr<P_expr1> d1,
3518	const Matrix<P_numtype2, P_struct2>& d2)
3519	{
3520	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
3521	_bz_MatrixRef<P_numtype2, P_struct2>,
3522	_bz_GreaterOrEqual<typename P_expr1::T_numtype, P_numtype2> > T_expr;
3523
3524	return _bz_MatExpr<T_expr>(T_expr(d1,
3525	d2._bz_getRef()));
3526	}
3527
3528	// _bz_MatExpr<P_expr1> >= _bz_MatExpr<P_expr2>
3529	template<class P_expr1, class P_expr2>
3530	inline
3531	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
3532	_bz_MatExpr<P_expr2>,
3533	_bz_GreaterOrEqual<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
3534	operator>=(_bz_MatExpr<P_expr1> d1,
3535	_bz_MatExpr<P_expr2> d2)
3536	{
3537	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
3538	_bz_MatExpr<P_expr2>,
3539	_bz_GreaterOrEqual<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
3540
3541	return _bz_MatExpr<T_expr>(T_expr(d1,
3542	d2));
3543	}
3544
3545	// _bz_MatExpr<P_expr1> >= int
3546	template<class P_expr1>
3547	inline
3548	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
3549	_bz_MatExprConstant<int>,
3550	_bz_GreaterOrEqual<typename P_expr1::T_numtype, int > > >
3551	operator>=(_bz_MatExpr<P_expr1> d1,
3552	int d2)
3553	{
3554	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
3555	_bz_MatExprConstant<int>,
3556	_bz_GreaterOrEqual<typename P_expr1::T_numtype, int> > T_expr;
3557
3558	return _bz_MatExpr<T_expr>(T_expr(d1,
3559	_bz_MatExprConstant<int>(d2)));
3560	}
3561
3562	// _bz_MatExpr<P_expr1> >= float
3563	template<class P_expr1>
3564	inline
3565	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
3566	_bz_MatExprConstant<float>,
3567	_bz_GreaterOrEqual<typename P_expr1::T_numtype, float > > >
3568	operator>=(_bz_MatExpr<P_expr1> d1,
3569	float d2)
3570	{
3571	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
3572	_bz_MatExprConstant<float>,
3573	_bz_GreaterOrEqual<typename P_expr1::T_numtype, float> > T_expr;
3574
3575	return _bz_MatExpr<T_expr>(T_expr(d1,
3576	_bz_MatExprConstant<float>(d2)));
3577	}
3578
3579	// _bz_MatExpr<P_expr1> >= double
3580	template<class P_expr1>
3581	inline
3582	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
3583	_bz_MatExprConstant<double>,
3584	_bz_GreaterOrEqual<typename P_expr1::T_numtype, double > > >
3585	operator>=(_bz_MatExpr<P_expr1> d1,
3586	double d2)
3587	{
3588	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
3589	_bz_MatExprConstant<double>,
3590	_bz_GreaterOrEqual<typename P_expr1::T_numtype, double> > T_expr;
3591
3592	return _bz_MatExpr<T_expr>(T_expr(d1,
3593	_bz_MatExprConstant<double>(d2)));
3594	}
3595
3596	// _bz_MatExpr<P_expr1> >= long double
3597	template<class P_expr1>
3598	inline
3599	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
3600	_bz_MatExprConstant<long double>,
3601	_bz_GreaterOrEqual<typename P_expr1::T_numtype, long double > > >
3602	operator>=(_bz_MatExpr<P_expr1> d1,
3603	long double d2)
3604	{
3605	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
3606	_bz_MatExprConstant<long double>,
3607	_bz_GreaterOrEqual<typename P_expr1::T_numtype, long double> > T_expr;
3608
3609	return _bz_MatExpr<T_expr>(T_expr(d1,
3610	_bz_MatExprConstant<long double>(d2)));
3611	}
3612	#ifdef BZ_HAVE_COMPLEX
3613
3614	// _bz_MatExpr<P_expr1> >= complex<T2>
3615	template<class P_expr1, class T2>
3616	inline
3617	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
3618	_bz_MatExprConstant<complex<T2> > ,
3619	_bz_GreaterOrEqual<typename P_expr1::T_numtype, complex<T2> > > >
3620	operator>=(_bz_MatExpr<P_expr1> d1,
3621	complex<T2> d2)
3622	{
3623	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
3624	_bz_MatExprConstant<complex<T2> > ,
3625	_bz_GreaterOrEqual<typename P_expr1::T_numtype, complex<T2> > > T_expr;
3626
3627	return _bz_MatExpr<T_expr>(T_expr(d1,
3628	_bz_MatExprConstant<complex<T2> > (d2)));
3629	}
3630	#endif // BZ_HAVE_COMPLEX
3631
3632
3633	// int >= Matrix<P_numtype2, P_struct2>
3634	template<class P_numtype2, class P_struct2>
3635	inline
3636	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
3637	_bz_MatrixRef<P_numtype2, P_struct2>,
3638	_bz_GreaterOrEqual<int, P_numtype2 > > >
3639	operator>=(int d1,
3640	const Matrix<P_numtype2, P_struct2>& d2)
3641	{
3642	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
3643	_bz_MatrixRef<P_numtype2, P_struct2>,
3644	_bz_GreaterOrEqual<int, P_numtype2> > T_expr;
3645
3646	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
3647	d2._bz_getRef()));
3648	}
3649
3650	// int >= _bz_MatExpr<P_expr2>
3651	template<class P_expr2>
3652	inline
3653	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
3654	_bz_MatExpr<P_expr2>,
3655	_bz_GreaterOrEqual<int, typename P_expr2::T_numtype > > >
3656	operator>=(int d1,
3657	_bz_MatExpr<P_expr2> d2)
3658	{
3659	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
3660	_bz_MatExpr<P_expr2>,
3661	_bz_GreaterOrEqual<int, typename P_expr2::T_numtype> > T_expr;
3662
3663	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
3664	d2));
3665	}
3666
3667	// float >= Matrix<P_numtype2, P_struct2>
3668	template<class P_numtype2, class P_struct2>
3669	inline
3670	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>,
3671	_bz_MatrixRef<P_numtype2, P_struct2>,
3672	_bz_GreaterOrEqual<float, P_numtype2 > > >
3673	operator>=(float d1,
3674	const Matrix<P_numtype2, P_struct2>& d2)
3675	{
3676	typedef _bz_MatExprOp<_bz_MatExprConstant<float>,
3677	_bz_MatrixRef<P_numtype2, P_struct2>,
3678	_bz_GreaterOrEqual<float, P_numtype2> > T_expr;
3679
3680	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1),
3681	d2._bz_getRef()));
3682	}
3683
3684	// float >= _bz_MatExpr<P_expr2>
3685	template<class P_expr2>
3686	inline
3687	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>,
3688	_bz_MatExpr<P_expr2>,
3689	_bz_GreaterOrEqual<float, typename P_expr2::T_numtype > > >
3690	operator>=(float d1,
3691	_bz_MatExpr<P_expr2> d2)
3692	{
3693	typedef _bz_MatExprOp<_bz_MatExprConstant<float>,
3694	_bz_MatExpr<P_expr2>,
3695	_bz_GreaterOrEqual<float, typename P_expr2::T_numtype> > T_expr;
3696
3697	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1),
3698	d2));
3699	}
3700
3701	// double >= Matrix<P_numtype2, P_struct2>
3702	template<class P_numtype2, class P_struct2>
3703	inline
3704	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>,
3705	_bz_MatrixRef<P_numtype2, P_struct2>,
3706	_bz_GreaterOrEqual<double, P_numtype2 > > >
3707	operator>=(double d1,
3708	const Matrix<P_numtype2, P_struct2>& d2)
3709	{
3710	typedef _bz_MatExprOp<_bz_MatExprConstant<double>,
3711	_bz_MatrixRef<P_numtype2, P_struct2>,
3712	_bz_GreaterOrEqual<double, P_numtype2> > T_expr;
3713
3714	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1),
3715	d2._bz_getRef()));
3716	}
3717
3718	// double >= _bz_MatExpr<P_expr2>
3719	template<class P_expr2>
3720	inline
3721	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>,
3722	_bz_MatExpr<P_expr2>,
3723	_bz_GreaterOrEqual<double, typename P_expr2::T_numtype > > >
3724	operator>=(double d1,
3725	_bz_MatExpr<P_expr2> d2)
3726	{
3727	typedef _bz_MatExprOp<_bz_MatExprConstant<double>,
3728	_bz_MatExpr<P_expr2>,
3729	_bz_GreaterOrEqual<double, typename P_expr2::T_numtype> > T_expr;
3730
3731	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1),
3732	d2));
3733	}
3734
3735	// long double >= Matrix<P_numtype2, P_struct2>
3736	template<class P_numtype2, class P_struct2>
3737	inline
3738	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>,
3739	_bz_MatrixRef<P_numtype2, P_struct2>,
3740	_bz_GreaterOrEqual<long double, P_numtype2 > > >
3741	operator>=(long double d1,
3742	const Matrix<P_numtype2, P_struct2>& d2)
3743	{
3744	typedef _bz_MatExprOp<_bz_MatExprConstant<long double>,
3745	_bz_MatrixRef<P_numtype2, P_struct2>,
3746	_bz_GreaterOrEqual<long double, P_numtype2> > T_expr;
3747
3748	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1),
3749	d2._bz_getRef()));
3750	}
3751
3752	// long double >= _bz_MatExpr<P_expr2>
3753	template<class P_expr2>
3754	inline
3755	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>,
3756	_bz_MatExpr<P_expr2>,
3757	_bz_GreaterOrEqual<long double, typename P_expr2::T_numtype > > >
3758	operator>=(long double d1,
3759	_bz_MatExpr<P_expr2> d2)
3760	{
3761	typedef _bz_MatExprOp<_bz_MatExprConstant<long double>,
3762	_bz_MatExpr<P_expr2>,
3763	_bz_GreaterOrEqual<long double, typename P_expr2::T_numtype> > T_expr;
3764
3765	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1),
3766	d2));
3767	}
3768	#ifdef BZ_HAVE_COMPLEX
3769
3770	// complex<T1> >= Matrix<P_numtype2, P_struct2>
3771	template<class T1, class P_numtype2, class P_struct2>
3772	inline
3773	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
3774	_bz_MatrixRef<P_numtype2, P_struct2>,
3775	_bz_GreaterOrEqual<complex<T1> , P_numtype2 > > >
3776	operator>=(complex<T1> d1,
3777	const Matrix<P_numtype2, P_struct2>& d2)
3778	{
3779	typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
3780	_bz_MatrixRef<P_numtype2, P_struct2>,
3781	_bz_GreaterOrEqual<complex<T1> , P_numtype2> > T_expr;
3782
3783	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1),
3784	d2._bz_getRef()));
3785	}
3786	#endif // BZ_HAVE_COMPLEX
3787
3788	#ifdef BZ_HAVE_COMPLEX
3789
3790	// complex<T1> >= _bz_MatExpr<P_expr2>
3791	template<class T1, class P_expr2>
3792	inline
3793	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
3794	_bz_MatExpr<P_expr2>,
3795	_bz_GreaterOrEqual<complex<T1> , typename P_expr2::T_numtype > > >
3796	operator>=(complex<T1> d1,
3797	_bz_MatExpr<P_expr2> d2)
3798	{
3799	typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
3800	_bz_MatExpr<P_expr2>,
3801	_bz_GreaterOrEqual<complex<T1> , typename P_expr2::T_numtype> > T_expr;
3802
3803	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1),
3804	d2));
3805	}
3806	#endif // BZ_HAVE_COMPLEX
3807
3808	/****************************************************************************
3809	* Less or equal (<=) operators
3810	****************************************************************************/
3811
3812	// Matrix<P_numtype1, P_struct1> <= Matrix<P_numtype2, P_struct2>
3813	template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
3814	inline
3815	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3816	_bz_MatrixRef<P_numtype2, P_struct2>,
3817	_bz_LessOrEqual<P_numtype1, P_numtype2 > > >
3818	operator<=(const Matrix<P_numtype1, P_struct1>& d1,
3819	const Matrix<P_numtype2, P_struct2>& d2)
3820	{
3821	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3822	_bz_MatrixRef<P_numtype2, P_struct2>,
3823	_bz_LessOrEqual<P_numtype1, P_numtype2> > T_expr;
3824
3825	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
3826	d2._bz_getRef()));
3827	}
3828
3829	// Matrix<P_numtype1, P_struct1> <= _bz_MatExpr<P_expr2>
3830	template<class P_numtype1, class P_struct1, class P_expr2>
3831	inline
3832	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3833	_bz_MatExpr<P_expr2>,
3834	_bz_LessOrEqual<P_numtype1, typename P_expr2::T_numtype > > >
3835	operator<=(const Matrix<P_numtype1, P_struct1>& d1,
3836	_bz_MatExpr<P_expr2> d2)
3837	{
3838	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3839	_bz_MatExpr<P_expr2>,
3840	_bz_LessOrEqual<P_numtype1, typename P_expr2::T_numtype> > T_expr;
3841
3842	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
3843	d2));
3844	}
3845
3846	// Matrix<P_numtype1, P_struct1> <= int
3847	template<class P_numtype1, class P_struct1>
3848	inline
3849	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3850	_bz_MatExprConstant<int>,
3851	_bz_LessOrEqual<P_numtype1, int > > >
3852	operator<=(const Matrix<P_numtype1, P_struct1>& d1,
3853	int d2)
3854	{
3855	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3856	_bz_MatExprConstant<int>,
3857	_bz_LessOrEqual<P_numtype1, int> > T_expr;
3858
3859	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
3860	_bz_MatExprConstant<int>(d2)));
3861	}
3862
3863	// Matrix<P_numtype1, P_struct1> <= float
3864	template<class P_numtype1, class P_struct1>
3865	inline
3866	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3867	_bz_MatExprConstant<float>,
3868	_bz_LessOrEqual<P_numtype1, float > > >
3869	operator<=(const Matrix<P_numtype1, P_struct1>& d1,
3870	float d2)
3871	{
3872	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3873	_bz_MatExprConstant<float>,
3874	_bz_LessOrEqual<P_numtype1, float> > T_expr;
3875
3876	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
3877	_bz_MatExprConstant<float>(d2)));
3878	}
3879
3880	// Matrix<P_numtype1, P_struct1> <= double
3881	template<class P_numtype1, class P_struct1>
3882	inline
3883	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3884	_bz_MatExprConstant<double>,
3885	_bz_LessOrEqual<P_numtype1, double > > >
3886	operator<=(const Matrix<P_numtype1, P_struct1>& d1,
3887	double d2)
3888	{
3889	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3890	_bz_MatExprConstant<double>,
3891	_bz_LessOrEqual<P_numtype1, double> > T_expr;
3892
3893	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
3894	_bz_MatExprConstant<double>(d2)));
3895	}
3896
3897	// Matrix<P_numtype1, P_struct1> <= long double
3898	template<class P_numtype1, class P_struct1>
3899	inline
3900	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3901	_bz_MatExprConstant<long double>,
3902	_bz_LessOrEqual<P_numtype1, long double > > >
3903	operator<=(const Matrix<P_numtype1, P_struct1>& d1,
3904	long double d2)
3905	{
3906	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3907	_bz_MatExprConstant<long double>,
3908	_bz_LessOrEqual<P_numtype1, long double> > T_expr;
3909
3910	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
3911	_bz_MatExprConstant<long double>(d2)));
3912	}
3913	#ifdef BZ_HAVE_COMPLEX
3914
3915	// Matrix<P_numtype1, P_struct1> <= complex<T2>
3916	template<class P_numtype1, class P_struct1, class T2>
3917	inline
3918	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3919	_bz_MatExprConstant<complex<T2> > ,
3920	_bz_LessOrEqual<P_numtype1, complex<T2> > > >
3921	operator<=(const Matrix<P_numtype1, P_struct1>& d1,
3922	complex<T2> d2)
3923	{
3924	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
3925	_bz_MatExprConstant<complex<T2> > ,
3926	_bz_LessOrEqual<P_numtype1, complex<T2> > > T_expr;
3927
3928	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
3929	_bz_MatExprConstant<complex<T2> > (d2)));
3930	}
3931	#endif // BZ_HAVE_COMPLEX
3932
3933
3934	// _bz_MatExpr<P_expr1> <= Matrix<P_numtype2, P_struct2>
3935	template<class P_expr1, class P_numtype2, class P_struct2>
3936	inline
3937	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
3938	_bz_MatrixRef<P_numtype2, P_struct2>,
3939	_bz_LessOrEqual<typename P_expr1::T_numtype, P_numtype2 > > >
3940	operator<=(_bz_MatExpr<P_expr1> d1,
3941	const Matrix<P_numtype2, P_struct2>& d2)
3942	{
3943	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
3944	_bz_MatrixRef<P_numtype2, P_struct2>,
3945	_bz_LessOrEqual<typename P_expr1::T_numtype, P_numtype2> > T_expr;
3946
3947	return _bz_MatExpr<T_expr>(T_expr(d1,
3948	d2._bz_getRef()));
3949	}
3950
3951	// _bz_MatExpr<P_expr1> <= _bz_MatExpr<P_expr2>
3952	template<class P_expr1, class P_expr2>
3953	inline
3954	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
3955	_bz_MatExpr<P_expr2>,
3956	_bz_LessOrEqual<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
3957	operator<=(_bz_MatExpr<P_expr1> d1,
3958	_bz_MatExpr<P_expr2> d2)
3959	{
3960	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
3961	_bz_MatExpr<P_expr2>,
3962	_bz_LessOrEqual<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
3963
3964	return _bz_MatExpr<T_expr>(T_expr(d1,
3965	d2));
3966	}
3967
3968	// _bz_MatExpr<P_expr1> <= int
3969	template<class P_expr1>
3970	inline
3971	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
3972	_bz_MatExprConstant<int>,
3973	_bz_LessOrEqual<typename P_expr1::T_numtype, int > > >
3974	operator<=(_bz_MatExpr<P_expr1> d1,
3975	int d2)
3976	{
3977	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
3978	_bz_MatExprConstant<int>,
3979	_bz_LessOrEqual<typename P_expr1::T_numtype, int> > T_expr;
3980
3981	return _bz_MatExpr<T_expr>(T_expr(d1,
3982	_bz_MatExprConstant<int>(d2)));
3983	}
3984
3985	// _bz_MatExpr<P_expr1> <= float
3986	template<class P_expr1>
3987	inline
3988	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
3989	_bz_MatExprConstant<float>,
3990	_bz_LessOrEqual<typename P_expr1::T_numtype, float > > >
3991	operator<=(_bz_MatExpr<P_expr1> d1,
3992	float d2)
3993	{
3994	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
3995	_bz_MatExprConstant<float>,
3996	_bz_LessOrEqual<typename P_expr1::T_numtype, float> > T_expr;
3997
3998	return _bz_MatExpr<T_expr>(T_expr(d1,
3999	_bz_MatExprConstant<float>(d2)));
4000	}
4001
4002	// _bz_MatExpr<P_expr1> <= double
4003	template<class P_expr1>
4004	inline
4005	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
4006	_bz_MatExprConstant<double>,
4007	_bz_LessOrEqual<typename P_expr1::T_numtype, double > > >
4008	operator<=(_bz_MatExpr<P_expr1> d1,
4009	double d2)
4010	{
4011	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
4012	_bz_MatExprConstant<double>,
4013	_bz_LessOrEqual<typename P_expr1::T_numtype, double> > T_expr;
4014
4015	return _bz_MatExpr<T_expr>(T_expr(d1,
4016	_bz_MatExprConstant<double>(d2)));
4017	}
4018
4019	// _bz_MatExpr<P_expr1> <= long double
4020	template<class P_expr1>
4021	inline
4022	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
4023	_bz_MatExprConstant<long double>,
4024	_bz_LessOrEqual<typename P_expr1::T_numtype, long double > > >
4025	operator<=(_bz_MatExpr<P_expr1> d1,
4026	long double d2)
4027	{
4028	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
4029	_bz_MatExprConstant<long double>,
4030	_bz_LessOrEqual<typename P_expr1::T_numtype, long double> > T_expr;
4031
4032	return _bz_MatExpr<T_expr>(T_expr(d1,
4033	_bz_MatExprConstant<long double>(d2)));
4034	}
4035	#ifdef BZ_HAVE_COMPLEX
4036
4037	// _bz_MatExpr<P_expr1> <= complex<T2>
4038	template<class P_expr1, class T2>
4039	inline
4040	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
4041	_bz_MatExprConstant<complex<T2> > ,
4042	_bz_LessOrEqual<typename P_expr1::T_numtype, complex<T2> > > >
4043	operator<=(_bz_MatExpr<P_expr1> d1,
4044	complex<T2> d2)
4045	{
4046	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
4047	_bz_MatExprConstant<complex<T2> > ,
4048	_bz_LessOrEqual<typename P_expr1::T_numtype, complex<T2> > > T_expr;
4049
4050	return _bz_MatExpr<T_expr>(T_expr(d1,
4051	_bz_MatExprConstant<complex<T2> > (d2)));
4052	}
4053	#endif // BZ_HAVE_COMPLEX
4054
4055
4056	// int <= Matrix<P_numtype2, P_struct2>
4057	template<class P_numtype2, class P_struct2>
4058	inline
4059	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
4060	_bz_MatrixRef<P_numtype2, P_struct2>,
4061	_bz_LessOrEqual<int, P_numtype2 > > >
4062	operator<=(int d1,
4063	const Matrix<P_numtype2, P_struct2>& d2)
4064	{
4065	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
4066	_bz_MatrixRef<P_numtype2, P_struct2>,
4067	_bz_LessOrEqual<int, P_numtype2> > T_expr;
4068
4069	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
4070	d2._bz_getRef()));
4071	}
4072
4073	// int <= _bz_MatExpr<P_expr2>
4074	template<class P_expr2>
4075	inline
4076	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
4077	_bz_MatExpr<P_expr2>,
4078	_bz_LessOrEqual<int, typename P_expr2::T_numtype > > >
4079	operator<=(int d1,
4080	_bz_MatExpr<P_expr2> d2)
4081	{
4082	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
4083	_bz_MatExpr<P_expr2>,
4084	_bz_LessOrEqual<int, typename P_expr2::T_numtype> > T_expr;
4085
4086	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
4087	d2));
4088	}
4089
4090	// float <= Matrix<P_numtype2, P_struct2>
4091	template<class P_numtype2, class P_struct2>
4092	inline
4093	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>,
4094	_bz_MatrixRef<P_numtype2, P_struct2>,
4095	_bz_LessOrEqual<float, P_numtype2 > > >
4096	operator<=(float d1,
4097	const Matrix<P_numtype2, P_struct2>& d2)
4098	{
4099	typedef _bz_MatExprOp<_bz_MatExprConstant<float>,
4100	_bz_MatrixRef<P_numtype2, P_struct2>,
4101	_bz_LessOrEqual<float, P_numtype2> > T_expr;
4102
4103	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1),
4104	d2._bz_getRef()));
4105	}
4106
4107	// float <= _bz_MatExpr<P_expr2>
4108	template<class P_expr2>
4109	inline
4110	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>,
4111	_bz_MatExpr<P_expr2>,
4112	_bz_LessOrEqual<float, typename P_expr2::T_numtype > > >
4113	operator<=(float d1,
4114	_bz_MatExpr<P_expr2> d2)
4115	{
4116	typedef _bz_MatExprOp<_bz_MatExprConstant<float>,
4117	_bz_MatExpr<P_expr2>,
4118	_bz_LessOrEqual<float, typename P_expr2::T_numtype> > T_expr;
4119
4120	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1),
4121	d2));
4122	}
4123
4124	// double <= Matrix<P_numtype2, P_struct2>
4125	template<class P_numtype2, class P_struct2>
4126	inline
4127	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>,
4128	_bz_MatrixRef<P_numtype2, P_struct2>,
4129	_bz_LessOrEqual<double, P_numtype2 > > >
4130	operator<=(double d1,
4131	const Matrix<P_numtype2, P_struct2>& d2)
4132	{
4133	typedef _bz_MatExprOp<_bz_MatExprConstant<double>,
4134	_bz_MatrixRef<P_numtype2, P_struct2>,
4135	_bz_LessOrEqual<double, P_numtype2> > T_expr;
4136
4137	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1),
4138	d2._bz_getRef()));
4139	}
4140
4141	// double <= _bz_MatExpr<P_expr2>
4142	template<class P_expr2>
4143	inline
4144	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>,
4145	_bz_MatExpr<P_expr2>,
4146	_bz_LessOrEqual<double, typename P_expr2::T_numtype > > >
4147	operator<=(double d1,
4148	_bz_MatExpr<P_expr2> d2)
4149	{
4150	typedef _bz_MatExprOp<_bz_MatExprConstant<double>,
4151	_bz_MatExpr<P_expr2>,
4152	_bz_LessOrEqual<double, typename P_expr2::T_numtype> > T_expr;
4153
4154	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1),
4155	d2));
4156	}
4157
4158	// long double <= Matrix<P_numtype2, P_struct2>
4159	template<class P_numtype2, class P_struct2>
4160	inline
4161	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>,
4162	_bz_MatrixRef<P_numtype2, P_struct2>,
4163	_bz_LessOrEqual<long double, P_numtype2 > > >
4164	operator<=(long double d1,
4165	const Matrix<P_numtype2, P_struct2>& d2)
4166	{
4167	typedef _bz_MatExprOp<_bz_MatExprConstant<long double>,
4168	_bz_MatrixRef<P_numtype2, P_struct2>,
4169	_bz_LessOrEqual<long double, P_numtype2> > T_expr;
4170
4171	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1),
4172	d2._bz_getRef()));
4173	}
4174
4175	// long double <= _bz_MatExpr<P_expr2>
4176	template<class P_expr2>
4177	inline
4178	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>,
4179	_bz_MatExpr<P_expr2>,
4180	_bz_LessOrEqual<long double, typename P_expr2::T_numtype > > >
4181	operator<=(long double d1,
4182	_bz_MatExpr<P_expr2> d2)
4183	{
4184	typedef _bz_MatExprOp<_bz_MatExprConstant<long double>,
4185	_bz_MatExpr<P_expr2>,
4186	_bz_LessOrEqual<long double, typename P_expr2::T_numtype> > T_expr;
4187
4188	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1),
4189	d2));
4190	}
4191	#ifdef BZ_HAVE_COMPLEX
4192
4193	// complex<T1> <= Matrix<P_numtype2, P_struct2>
4194	template<class T1, class P_numtype2, class P_struct2>
4195	inline
4196	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
4197	_bz_MatrixRef<P_numtype2, P_struct2>,
4198	_bz_LessOrEqual<complex<T1> , P_numtype2 > > >
4199	operator<=(complex<T1> d1,
4200	const Matrix<P_numtype2, P_struct2>& d2)
4201	{
4202	typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
4203	_bz_MatrixRef<P_numtype2, P_struct2>,
4204	_bz_LessOrEqual<complex<T1> , P_numtype2> > T_expr;
4205
4206	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1),
4207	d2._bz_getRef()));
4208	}
4209	#endif // BZ_HAVE_COMPLEX
4210
4211	#ifdef BZ_HAVE_COMPLEX
4212
4213	// complex<T1> <= _bz_MatExpr<P_expr2>
4214	template<class T1, class P_expr2>
4215	inline
4216	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
4217	_bz_MatExpr<P_expr2>,
4218	_bz_LessOrEqual<complex<T1> , typename P_expr2::T_numtype > > >
4219	operator<=(complex<T1> d1,
4220	_bz_MatExpr<P_expr2> d2)
4221	{
4222	typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
4223	_bz_MatExpr<P_expr2>,
4224	_bz_LessOrEqual<complex<T1> , typename P_expr2::T_numtype> > T_expr;
4225
4226	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1),
4227	d2));
4228	}
4229	#endif // BZ_HAVE_COMPLEX
4230
4231	/****************************************************************************
4232	* Equality operators
4233	****************************************************************************/
4234
4235	// Matrix<P_numtype1, P_struct1> == Matrix<P_numtype2, P_struct2>
4236	template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
4237	inline
4238	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
4239	_bz_MatrixRef<P_numtype2, P_struct2>,
4240	_bz_Equal<P_numtype1, P_numtype2 > > >
4241	operator==(const Matrix<P_numtype1, P_struct1>& d1,
4242	const Matrix<P_numtype2, P_struct2>& d2)
4243	{
4244	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
4245	_bz_MatrixRef<P_numtype2, P_struct2>,
4246	_bz_Equal<P_numtype1, P_numtype2> > T_expr;
4247
4248	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
4249	d2._bz_getRef()));
4250	}
4251
4252	// Matrix<P_numtype1, P_struct1> == _bz_MatExpr<P_expr2>
4253	template<class P_numtype1, class P_struct1, class P_expr2>
4254	inline
4255	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
4256	_bz_MatExpr<P_expr2>,
4257	_bz_Equal<P_numtype1, typename P_expr2::T_numtype > > >
4258	operator==(const Matrix<P_numtype1, P_struct1>& d1,
4259	_bz_MatExpr<P_expr2> d2)
4260	{
4261	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
4262	_bz_MatExpr<P_expr2>,
4263	_bz_Equal<P_numtype1, typename P_expr2::T_numtype> > T_expr;
4264
4265	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
4266	d2));
4267	}
4268
4269	// Matrix<P_numtype1, P_struct1> == int
4270	template<class P_numtype1, class P_struct1>
4271	inline
4272	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
4273	_bz_MatExprConstant<int>,
4274	_bz_Equal<P_numtype1, int > > >
4275	operator==(const Matrix<P_numtype1, P_struct1>& d1,
4276	int d2)
4277	{
4278	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
4279	_bz_MatExprConstant<int>,
4280	_bz_Equal<P_numtype1, int> > T_expr;
4281
4282	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
4283	_bz_MatExprConstant<int>(d2)));
4284	}
4285
4286	// Matrix<P_numtype1, P_struct1> == float
4287	template<class P_numtype1, class P_struct1>
4288	inline
4289	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
4290	_bz_MatExprConstant<float>,
4291	_bz_Equal<P_numtype1, float > > >
4292	operator==(const Matrix<P_numtype1, P_struct1>& d1,
4293	float d2)
4294	{
4295	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
4296	_bz_MatExprConstant<float>,
4297	_bz_Equal<P_numtype1, float> > T_expr;
4298
4299	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
4300	_bz_MatExprConstant<float>(d2)));
4301	}
4302
4303	// Matrix<P_numtype1, P_struct1> == double
4304	template<class P_numtype1, class P_struct1>
4305	inline
4306	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
4307	_bz_MatExprConstant<double>,
4308	_bz_Equal<P_numtype1, double > > >
4309	operator==(const Matrix<P_numtype1, P_struct1>& d1,
4310	double d2)
4311	{
4312	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
4313	_bz_MatExprConstant<double>,
4314	_bz_Equal<P_numtype1, double> > T_expr;
4315
4316	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
4317	_bz_MatExprConstant<double>(d2)));
4318	}
4319
4320	// Matrix<P_numtype1, P_struct1> == long double
4321	template<class P_numtype1, class P_struct1>
4322	inline
4323	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
4324	_bz_MatExprConstant<long double>,
4325	_bz_Equal<P_numtype1, long double > > >
4326	operator==(const Matrix<P_numtype1, P_struct1>& d1,
4327	long double d2)
4328	{
4329	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
4330	_bz_MatExprConstant<long double>,
4331	_bz_Equal<P_numtype1, long double> > T_expr;
4332
4333	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
4334	_bz_MatExprConstant<long double>(d2)));
4335	}
4336	#ifdef BZ_HAVE_COMPLEX
4337
4338	// Matrix<P_numtype1, P_struct1> == complex<T2>
4339	template<class P_numtype1, class P_struct1, class T2>
4340	inline
4341	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
4342	_bz_MatExprConstant<complex<T2> > ,
4343	_bz_Equal<P_numtype1, complex<T2> > > >
4344	operator==(const Matrix<P_numtype1, P_struct1>& d1,
4345	complex<T2> d2)
4346	{
4347	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
4348	_bz_MatExprConstant<complex<T2> > ,
4349	_bz_Equal<P_numtype1, complex<T2> > > T_expr;
4350
4351	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
4352	_bz_MatExprConstant<complex<T2> > (d2)));
4353	}
4354	#endif // BZ_HAVE_COMPLEX
4355
4356
4357	// _bz_MatExpr<P_expr1> == Matrix<P_numtype2, P_struct2>
4358	template<class P_expr1, class P_numtype2, class P_struct2>
4359	inline
4360	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
4361	_bz_MatrixRef<P_numtype2, P_struct2>,
4362	_bz_Equal<typename P_expr1::T_numtype, P_numtype2 > > >
4363	operator==(_bz_MatExpr<P_expr1> d1,
4364	const Matrix<P_numtype2, P_struct2>& d2)
4365	{
4366	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
4367	_bz_MatrixRef<P_numtype2, P_struct2>,
4368	_bz_Equal<typename P_expr1::T_numtype, P_numtype2> > T_expr;
4369
4370	return _bz_MatExpr<T_expr>(T_expr(d1,
4371	d2._bz_getRef()));
4372	}
4373
4374	// _bz_MatExpr<P_expr1> == _bz_MatExpr<P_expr2>
4375	template<class P_expr1, class P_expr2>
4376	inline
4377	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
4378	_bz_MatExpr<P_expr2>,
4379	_bz_Equal<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
4380	operator==(_bz_MatExpr<P_expr1> d1,
4381	_bz_MatExpr<P_expr2> d2)
4382	{
4383	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
4384	_bz_MatExpr<P_expr2>,
4385	_bz_Equal<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
4386
4387	return _bz_MatExpr<T_expr>(T_expr(d1,
4388	d2));
4389	}
4390
4391	// _bz_MatExpr<P_expr1> == int
4392	template<class P_expr1>
4393	inline
4394	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
4395	_bz_MatExprConstant<int>,
4396	_bz_Equal<typename P_expr1::T_numtype, int > > >
4397	operator==(_bz_MatExpr<P_expr1> d1,
4398	int d2)
4399	{
4400	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
4401	_bz_MatExprConstant<int>,
4402	_bz_Equal<typename P_expr1::T_numtype, int> > T_expr;
4403
4404	return _bz_MatExpr<T_expr>(T_expr(d1,
4405	_bz_MatExprConstant<int>(d2)));
4406	}
4407
4408	// _bz_MatExpr<P_expr1> == float
4409	template<class P_expr1>
4410	inline
4411	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
4412	_bz_MatExprConstant<float>,
4413	_bz_Equal<typename P_expr1::T_numtype, float > > >
4414	operator==(_bz_MatExpr<P_expr1> d1,
4415	float d2)
4416	{
4417	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
4418	_bz_MatExprConstant<float>,
4419	_bz_Equal<typename P_expr1::T_numtype, float> > T_expr;
4420
4421	return _bz_MatExpr<T_expr>(T_expr(d1,
4422	_bz_MatExprConstant<float>(d2)));
4423	}
4424
4425	// _bz_MatExpr<P_expr1> == double
4426	template<class P_expr1>
4427	inline
4428	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
4429	_bz_MatExprConstant<double>,
4430	_bz_Equal<typename P_expr1::T_numtype, double > > >
4431	operator==(_bz_MatExpr<P_expr1> d1,
4432	double d2)
4433	{
4434	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
4435	_bz_MatExprConstant<double>,
4436	_bz_Equal<typename P_expr1::T_numtype, double> > T_expr;
4437
4438	return _bz_MatExpr<T_expr>(T_expr(d1,
4439	_bz_MatExprConstant<double>(d2)));
4440	}
4441
4442	// _bz_MatExpr<P_expr1> == long double
4443	template<class P_expr1>
4444	inline
4445	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
4446	_bz_MatExprConstant<long double>,
4447	_bz_Equal<typename P_expr1::T_numtype, long double > > >
4448	operator==(_bz_MatExpr<P_expr1> d1,
4449	long double d2)
4450	{
4451	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
4452	_bz_MatExprConstant<long double>,
4453	_bz_Equal<typename P_expr1::T_numtype, long double> > T_expr;
4454
4455	return _bz_MatExpr<T_expr>(T_expr(d1,
4456	_bz_MatExprConstant<long double>(d2)));
4457	}
4458	#ifdef BZ_HAVE_COMPLEX
4459
4460	// _bz_MatExpr<P_expr1> == complex<T2>
4461	template<class P_expr1, class T2>
4462	inline
4463	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
4464	_bz_MatExprConstant<complex<T2> > ,
4465	_bz_Equal<typename P_expr1::T_numtype, complex<T2> > > >
4466	operator==(_bz_MatExpr<P_expr1> d1,
4467	complex<T2> d2)
4468	{
4469	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
4470	_bz_MatExprConstant<complex<T2> > ,
4471	_bz_Equal<typename P_expr1::T_numtype, complex<T2> > > T_expr;
4472
4473	return _bz_MatExpr<T_expr>(T_expr(d1,
4474	_bz_MatExprConstant<complex<T2> > (d2)));
4475	}
4476	#endif // BZ_HAVE_COMPLEX
4477
4478
4479	// int == Matrix<P_numtype2, P_struct2>
4480	template<class P_numtype2, class P_struct2>
4481	inline
4482	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
4483	_bz_MatrixRef<P_numtype2, P_struct2>,
4484	_bz_Equal<int, P_numtype2 > > >
4485	operator==(int d1,
4486	const Matrix<P_numtype2, P_struct2>& d2)
4487	{
4488	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
4489	_bz_MatrixRef<P_numtype2, P_struct2>,
4490	_bz_Equal<int, P_numtype2> > T_expr;
4491
4492	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
4493	d2._bz_getRef()));
4494	}
4495
4496	// int == _bz_MatExpr<P_expr2>
4497	template<class P_expr2>
4498	inline
4499	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
4500	_bz_MatExpr<P_expr2>,
4501	_bz_Equal<int, typename P_expr2::T_numtype > > >
4502	operator==(int d1,
4503	_bz_MatExpr<P_expr2> d2)
4504	{
4505	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
4506	_bz_MatExpr<P_expr2>,
4507	_bz_Equal<int, typename P_expr2::T_numtype> > T_expr;
4508
4509	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
4510	d2));
4511	}
4512
4513	// float == Matrix<P_numtype2, P_struct2>
4514	template<class P_numtype2, class P_struct2>
4515	inline
4516	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>,
4517	_bz_MatrixRef<P_numtype2, P_struct2>,
4518	_bz_Equal<float, P_numtype2 > > >
4519	operator==(float d1,
4520	const Matrix<P_numtype2, P_struct2>& d2)
4521	{
4522	typedef _bz_MatExprOp<_bz_MatExprConstant<float>,
4523	_bz_MatrixRef<P_numtype2, P_struct2>,
4524	_bz_Equal<float, P_numtype2> > T_expr;
4525
4526	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1),
4527	d2._bz_getRef()));
4528	}
4529
4530	// float == _bz_MatExpr<P_expr2>
4531	template<class P_expr2>
4532	inline
4533	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>,
4534	_bz_MatExpr<P_expr2>,
4535	_bz_Equal<float, typename P_expr2::T_numtype > > >
4536	operator==(float d1,
4537	_bz_MatExpr<P_expr2> d2)
4538	{
4539	typedef _bz_MatExprOp<_bz_MatExprConstant<float>,
4540	_bz_MatExpr<P_expr2>,
4541	_bz_Equal<float, typename P_expr2::T_numtype> > T_expr;
4542
4543	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1),
4544	d2));
4545	}
4546
4547	// double == Matrix<P_numtype2, P_struct2>
4548	template<class P_numtype2, class P_struct2>
4549	inline
4550	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>,
4551	_bz_MatrixRef<P_numtype2, P_struct2>,
4552	_bz_Equal<double, P_numtype2 > > >
4553	operator==(double d1,
4554	const Matrix<P_numtype2, P_struct2>& d2)
4555	{
4556	typedef _bz_MatExprOp<_bz_MatExprConstant<double>,
4557	_bz_MatrixRef<P_numtype2, P_struct2>,
4558	_bz_Equal<double, P_numtype2> > T_expr;
4559
4560	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1),
4561	d2._bz_getRef()));
4562	}
4563
4564	// double == _bz_MatExpr<P_expr2>
4565	template<class P_expr2>
4566	inline
4567	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>,
4568	_bz_MatExpr<P_expr2>,
4569	_bz_Equal<double, typename P_expr2::T_numtype > > >
4570	operator==(double d1,
4571	_bz_MatExpr<P_expr2> d2)
4572	{
4573	typedef _bz_MatExprOp<_bz_MatExprConstant<double>,
4574	_bz_MatExpr<P_expr2>,
4575	_bz_Equal<double, typename P_expr2::T_numtype> > T_expr;
4576
4577	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1),
4578	d2));
4579	}
4580
4581	// long double == Matrix<P_numtype2, P_struct2>
4582	template<class P_numtype2, class P_struct2>
4583	inline
4584	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>,
4585	_bz_MatrixRef<P_numtype2, P_struct2>,
4586	_bz_Equal<long double, P_numtype2 > > >
4587	operator==(long double d1,
4588	const Matrix<P_numtype2, P_struct2>& d2)
4589	{
4590	typedef _bz_MatExprOp<_bz_MatExprConstant<long double>,
4591	_bz_MatrixRef<P_numtype2, P_struct2>,
4592	_bz_Equal<long double, P_numtype2> > T_expr;
4593
4594	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1),
4595	d2._bz_getRef()));
4596	}
4597
4598	// long double == _bz_MatExpr<P_expr2>
4599	template<class P_expr2>
4600	inline
4601	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>,
4602	_bz_MatExpr<P_expr2>,
4603	_bz_Equal<long double, typename P_expr2::T_numtype > > >
4604	operator==(long double d1,
4605	_bz_MatExpr<P_expr2> d2)
4606	{
4607	typedef _bz_MatExprOp<_bz_MatExprConstant<long double>,
4608	_bz_MatExpr<P_expr2>,
4609	_bz_Equal<long double, typename P_expr2::T_numtype> > T_expr;
4610
4611	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1),
4612	d2));
4613	}
4614	#ifdef BZ_HAVE_COMPLEX
4615
4616	// complex<T1> == Matrix<P_numtype2, P_struct2>
4617	template<class T1, class P_numtype2, class P_struct2>
4618	inline
4619	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
4620	_bz_MatrixRef<P_numtype2, P_struct2>,
4621	_bz_Equal<complex<T1> , P_numtype2 > > >
4622	operator==(complex<T1> d1,
4623	const Matrix<P_numtype2, P_struct2>& d2)
4624	{
4625	typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
4626	_bz_MatrixRef<P_numtype2, P_struct2>,
4627	_bz_Equal<complex<T1> , P_numtype2> > T_expr;
4628
4629	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1),
4630	d2._bz_getRef()));
4631	}
4632	#endif // BZ_HAVE_COMPLEX
4633
4634	#ifdef BZ_HAVE_COMPLEX
4635
4636	// complex<T1> == _bz_MatExpr<P_expr2>
4637	template<class T1, class P_expr2>
4638	inline
4639	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
4640	_bz_MatExpr<P_expr2>,
4641	_bz_Equal<complex<T1> , typename P_expr2::T_numtype > > >
4642	operator==(complex<T1> d1,
4643	_bz_MatExpr<P_expr2> d2)
4644	{
4645	typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
4646	_bz_MatExpr<P_expr2>,
4647	_bz_Equal<complex<T1> , typename P_expr2::T_numtype> > T_expr;
4648
4649	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1),
4650	d2));
4651	}
4652	#endif // BZ_HAVE_COMPLEX
4653
4654	/****************************************************************************
4655	* Not-equal operators
4656	****************************************************************************/
4657
4658	// Matrix<P_numtype1, P_struct1> != Matrix<P_numtype2, P_struct2>
4659	template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
4660	inline
4661	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
4662	_bz_MatrixRef<P_numtype2, P_struct2>,
4663	_bz_NotEqual<P_numtype1, P_numtype2 > > >
4664	operator!=(const Matrix<P_numtype1, P_struct1>& d1,
4665	const Matrix<P_numtype2, P_struct2>& d2)
4666	{
4667	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
4668	_bz_MatrixRef<P_numtype2, P_struct2>,
4669	_bz_NotEqual<P_numtype1, P_numtype2> > T_expr;
4670
4671	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
4672	d2._bz_getRef()));
4673	}
4674
4675	// Matrix<P_numtype1, P_struct1> != _bz_MatExpr<P_expr2>
4676	template<class P_numtype1, class P_struct1, class P_expr2>
4677	inline
4678	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
4679	_bz_MatExpr<P_expr2>,
4680	_bz_NotEqual<P_numtype1, typename P_expr2::T_numtype > > >
4681	operator!=(const Matrix<P_numtype1, P_struct1>& d1,
4682	_bz_MatExpr<P_expr2> d2)
4683	{
4684	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
4685	_bz_MatExpr<P_expr2>,
4686	_bz_NotEqual<P_numtype1, typename P_expr2::T_numtype> > T_expr;
4687
4688	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
4689	d2));
4690	}
4691
4692	// Matrix<P_numtype1, P_struct1> != int
4693	template<class P_numtype1, class P_struct1>
4694	inline
4695	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
4696	_bz_MatExprConstant<int>,
4697	_bz_NotEqual<P_numtype1, int > > >
4698	operator!=(const Matrix<P_numtype1, P_struct1>& d1,
4699	int d2)
4700	{
4701	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
4702	_bz_MatExprConstant<int>,
4703	_bz_NotEqual<P_numtype1, int> > T_expr;
4704
4705	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
4706	_bz_MatExprConstant<int>(d2)));
4707	}
4708
4709	// Matrix<P_numtype1, P_struct1> != float
4710	template<class P_numtype1, class P_struct1>
4711	inline
4712	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
4713	_bz_MatExprConstant<float>,
4714	_bz_NotEqual<P_numtype1, float > > >
4715	operator!=(const Matrix<P_numtype1, P_struct1>& d1,
4716	float d2)
4717	{
4718	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
4719	_bz_MatExprConstant<float>,
4720	_bz_NotEqual<P_numtype1, float> > T_expr;
4721
4722	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
4723	_bz_MatExprConstant<float>(d2)));
4724	}
4725
4726	// Matrix<P_numtype1, P_struct1> != double
4727	template<class P_numtype1, class P_struct1>
4728	inline
4729	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
4730	_bz_MatExprConstant<double>,
4731	_bz_NotEqual<P_numtype1, double > > >
4732	operator!=(const Matrix<P_numtype1, P_struct1>& d1,
4733	double d2)
4734	{
4735	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
4736	_bz_MatExprConstant<double>,
4737	_bz_NotEqual<P_numtype1, double> > T_expr;
4738
4739	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
4740	_bz_MatExprConstant<double>(d2)));
4741	}
4742
4743	// Matrix<P_numtype1, P_struct1> != long double
4744	template<class P_numtype1, class P_struct1>
4745	inline
4746	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
4747	_bz_MatExprConstant<long double>,
4748	_bz_NotEqual<P_numtype1, long double > > >
4749	operator!=(const Matrix<P_numtype1, P_struct1>& d1,
4750	long double d2)
4751	{
4752	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
4753	_bz_MatExprConstant<long double>,
4754	_bz_NotEqual<P_numtype1, long double> > T_expr;
4755
4756	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
4757	_bz_MatExprConstant<long double>(d2)));
4758	}
4759	#ifdef BZ_HAVE_COMPLEX
4760
4761	// Matrix<P_numtype1, P_struct1> != complex<T2>
4762	template<class P_numtype1, class P_struct1, class T2>
4763	inline
4764	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
4765	_bz_MatExprConstant<complex<T2> > ,
4766	_bz_NotEqual<P_numtype1, complex<T2> > > >
4767	operator!=(const Matrix<P_numtype1, P_struct1>& d1,
4768	complex<T2> d2)
4769	{
4770	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
4771	_bz_MatExprConstant<complex<T2> > ,
4772	_bz_NotEqual<P_numtype1, complex<T2> > > T_expr;
4773
4774	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
4775	_bz_MatExprConstant<complex<T2> > (d2)));
4776	}
4777	#endif // BZ_HAVE_COMPLEX
4778
4779
4780	// _bz_MatExpr<P_expr1> != Matrix<P_numtype2, P_struct2>
4781	template<class P_expr1, class P_numtype2, class P_struct2>
4782	inline
4783	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
4784	_bz_MatrixRef<P_numtype2, P_struct2>,
4785	_bz_NotEqual<typename P_expr1::T_numtype, P_numtype2 > > >
4786	operator!=(_bz_MatExpr<P_expr1> d1,
4787	const Matrix<P_numtype2, P_struct2>& d2)
4788	{
4789	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
4790	_bz_MatrixRef<P_numtype2, P_struct2>,
4791	_bz_NotEqual<typename P_expr1::T_numtype, P_numtype2> > T_expr;
4792
4793	return _bz_MatExpr<T_expr>(T_expr(d1,
4794	d2._bz_getRef()));
4795	}
4796
4797	// _bz_MatExpr<P_expr1> != _bz_MatExpr<P_expr2>
4798	template<class P_expr1, class P_expr2>
4799	inline
4800	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
4801	_bz_MatExpr<P_expr2>,
4802	_bz_NotEqual<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
4803	operator!=(_bz_MatExpr<P_expr1> d1,
4804	_bz_MatExpr<P_expr2> d2)
4805	{
4806	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
4807	_bz_MatExpr<P_expr2>,
4808	_bz_NotEqual<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
4809
4810	return _bz_MatExpr<T_expr>(T_expr(d1,
4811	d2));
4812	}
4813
4814	// _bz_MatExpr<P_expr1> != int
4815	template<class P_expr1>
4816	inline
4817	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
4818	_bz_MatExprConstant<int>,
4819	_bz_NotEqual<typename P_expr1::T_numtype, int > > >
4820	operator!=(_bz_MatExpr<P_expr1> d1,
4821	int d2)
4822	{
4823	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
4824	_bz_MatExprConstant<int>,
4825	_bz_NotEqual<typename P_expr1::T_numtype, int> > T_expr;
4826
4827	return _bz_MatExpr<T_expr>(T_expr(d1,
4828	_bz_MatExprConstant<int>(d2)));
4829	}
4830
4831	// _bz_MatExpr<P_expr1> != float
4832	template<class P_expr1>
4833	inline
4834	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
4835	_bz_MatExprConstant<float>,
4836	_bz_NotEqual<typename P_expr1::T_numtype, float > > >
4837	operator!=(_bz_MatExpr<P_expr1> d1,
4838	float d2)
4839	{
4840	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
4841	_bz_MatExprConstant<float>,
4842	_bz_NotEqual<typename P_expr1::T_numtype, float> > T_expr;
4843
4844	return _bz_MatExpr<T_expr>(T_expr(d1,
4845	_bz_MatExprConstant<float>(d2)));
4846	}
4847
4848	// _bz_MatExpr<P_expr1> != double
4849	template<class P_expr1>
4850	inline
4851	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
4852	_bz_MatExprConstant<double>,
4853	_bz_NotEqual<typename P_expr1::T_numtype, double > > >
4854	operator!=(_bz_MatExpr<P_expr1> d1,
4855	double d2)
4856	{
4857	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
4858	_bz_MatExprConstant<double>,
4859	_bz_NotEqual<typename P_expr1::T_numtype, double> > T_expr;
4860
4861	return _bz_MatExpr<T_expr>(T_expr(d1,
4862	_bz_MatExprConstant<double>(d2)));
4863	}
4864
4865	// _bz_MatExpr<P_expr1> != long double
4866	template<class P_expr1>
4867	inline
4868	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
4869	_bz_MatExprConstant<long double>,
4870	_bz_NotEqual<typename P_expr1::T_numtype, long double > > >
4871	operator!=(_bz_MatExpr<P_expr1> d1,
4872	long double d2)
4873	{
4874	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
4875	_bz_MatExprConstant<long double>,
4876	_bz_NotEqual<typename P_expr1::T_numtype, long double> > T_expr;
4877
4878	return _bz_MatExpr<T_expr>(T_expr(d1,
4879	_bz_MatExprConstant<long double>(d2)));
4880	}
4881	#ifdef BZ_HAVE_COMPLEX
4882
4883	// _bz_MatExpr<P_expr1> != complex<T2>
4884	template<class P_expr1, class T2>
4885	inline
4886	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
4887	_bz_MatExprConstant<complex<T2> > ,
4888	_bz_NotEqual<typename P_expr1::T_numtype, complex<T2> > > >
4889	operator!=(_bz_MatExpr<P_expr1> d1,
4890	complex<T2> d2)
4891	{
4892	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
4893	_bz_MatExprConstant<complex<T2> > ,
4894	_bz_NotEqual<typename P_expr1::T_numtype, complex<T2> > > T_expr;
4895
4896	return _bz_MatExpr<T_expr>(T_expr(d1,
4897	_bz_MatExprConstant<complex<T2> > (d2)));
4898	}
4899	#endif // BZ_HAVE_COMPLEX
4900
4901
4902	// int != Matrix<P_numtype2, P_struct2>
4903	template<class P_numtype2, class P_struct2>
4904	inline
4905	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
4906	_bz_MatrixRef<P_numtype2, P_struct2>,
4907	_bz_NotEqual<int, P_numtype2 > > >
4908	operator!=(int d1,
4909	const Matrix<P_numtype2, P_struct2>& d2)
4910	{
4911	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
4912	_bz_MatrixRef<P_numtype2, P_struct2>,
4913	_bz_NotEqual<int, P_numtype2> > T_expr;
4914
4915	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
4916	d2._bz_getRef()));
4917	}
4918
4919	// int != _bz_MatExpr<P_expr2>
4920	template<class P_expr2>
4921	inline
4922	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
4923	_bz_MatExpr<P_expr2>,
4924	_bz_NotEqual<int, typename P_expr2::T_numtype > > >
4925	operator!=(int d1,
4926	_bz_MatExpr<P_expr2> d2)
4927	{
4928	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
4929	_bz_MatExpr<P_expr2>,
4930	_bz_NotEqual<int, typename P_expr2::T_numtype> > T_expr;
4931
4932	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
4933	d2));
4934	}
4935
4936	// float != Matrix<P_numtype2, P_struct2>
4937	template<class P_numtype2, class P_struct2>
4938	inline
4939	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>,
4940	_bz_MatrixRef<P_numtype2, P_struct2>,
4941	_bz_NotEqual<float, P_numtype2 > > >
4942	operator!=(float d1,
4943	const Matrix<P_numtype2, P_struct2>& d2)
4944	{
4945	typedef _bz_MatExprOp<_bz_MatExprConstant<float>,
4946	_bz_MatrixRef<P_numtype2, P_struct2>,
4947	_bz_NotEqual<float, P_numtype2> > T_expr;
4948
4949	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1),
4950	d2._bz_getRef()));
4951	}
4952
4953	// float != _bz_MatExpr<P_expr2>
4954	template<class P_expr2>
4955	inline
4956	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<float>,
4957	_bz_MatExpr<P_expr2>,
4958	_bz_NotEqual<float, typename P_expr2::T_numtype > > >
4959	operator!=(float d1,
4960	_bz_MatExpr<P_expr2> d2)
4961	{
4962	typedef _bz_MatExprOp<_bz_MatExprConstant<float>,
4963	_bz_MatExpr<P_expr2>,
4964	_bz_NotEqual<float, typename P_expr2::T_numtype> > T_expr;
4965
4966	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<float>(d1),
4967	d2));
4968	}
4969
4970	// double != Matrix<P_numtype2, P_struct2>
4971	template<class P_numtype2, class P_struct2>
4972	inline
4973	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>,
4974	_bz_MatrixRef<P_numtype2, P_struct2>,
4975	_bz_NotEqual<double, P_numtype2 > > >
4976	operator!=(double d1,
4977	const Matrix<P_numtype2, P_struct2>& d2)
4978	{
4979	typedef _bz_MatExprOp<_bz_MatExprConstant<double>,
4980	_bz_MatrixRef<P_numtype2, P_struct2>,
4981	_bz_NotEqual<double, P_numtype2> > T_expr;
4982
4983	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1),
4984	d2._bz_getRef()));
4985	}
4986
4987	// double != _bz_MatExpr<P_expr2>
4988	template<class P_expr2>
4989	inline
4990	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<double>,
4991	_bz_MatExpr<P_expr2>,
4992	_bz_NotEqual<double, typename P_expr2::T_numtype > > >
4993	operator!=(double d1,
4994	_bz_MatExpr<P_expr2> d2)
4995	{
4996	typedef _bz_MatExprOp<_bz_MatExprConstant<double>,
4997	_bz_MatExpr<P_expr2>,
4998	_bz_NotEqual<double, typename P_expr2::T_numtype> > T_expr;
4999
5000	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<double>(d1),
5001	d2));
5002	}
5003
5004	// long double != Matrix<P_numtype2, P_struct2>
5005	template<class P_numtype2, class P_struct2>
5006	inline
5007	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>,
5008	_bz_MatrixRef<P_numtype2, P_struct2>,
5009	_bz_NotEqual<long double, P_numtype2 > > >
5010	operator!=(long double d1,
5011	const Matrix<P_numtype2, P_struct2>& d2)
5012	{
5013	typedef _bz_MatExprOp<_bz_MatExprConstant<long double>,
5014	_bz_MatrixRef<P_numtype2, P_struct2>,
5015	_bz_NotEqual<long double, P_numtype2> > T_expr;
5016
5017	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1),
5018	d2._bz_getRef()));
5019	}
5020
5021	// long double != _bz_MatExpr<P_expr2>
5022	template<class P_expr2>
5023	inline
5024	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<long double>,
5025	_bz_MatExpr<P_expr2>,
5026	_bz_NotEqual<long double, typename P_expr2::T_numtype > > >
5027	operator!=(long double d1,
5028	_bz_MatExpr<P_expr2> d2)
5029	{
5030	typedef _bz_MatExprOp<_bz_MatExprConstant<long double>,
5031	_bz_MatExpr<P_expr2>,
5032	_bz_NotEqual<long double, typename P_expr2::T_numtype> > T_expr;
5033
5034	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<long double>(d1),
5035	d2));
5036	}
5037	#ifdef BZ_HAVE_COMPLEX
5038
5039	// complex<T1> != Matrix<P_numtype2, P_struct2>
5040	template<class T1, class P_numtype2, class P_struct2>
5041	inline
5042	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
5043	_bz_MatrixRef<P_numtype2, P_struct2>,
5044	_bz_NotEqual<complex<T1> , P_numtype2 > > >
5045	operator!=(complex<T1> d1,
5046	const Matrix<P_numtype2, P_struct2>& d2)
5047	{
5048	typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
5049	_bz_MatrixRef<P_numtype2, P_struct2>,
5050	_bz_NotEqual<complex<T1> , P_numtype2> > T_expr;
5051
5052	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1),
5053	d2._bz_getRef()));
5054	}
5055	#endif // BZ_HAVE_COMPLEX
5056
5057	#ifdef BZ_HAVE_COMPLEX
5058
5059	// complex<T1> != _bz_MatExpr<P_expr2>
5060	template<class T1, class P_expr2>
5061	inline
5062	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
5063	_bz_MatExpr<P_expr2>,
5064	_bz_NotEqual<complex<T1> , typename P_expr2::T_numtype > > >
5065	operator!=(complex<T1> d1,
5066	_bz_MatExpr<P_expr2> d2)
5067	{
5068	typedef _bz_MatExprOp<_bz_MatExprConstant<complex<T1> > ,
5069	_bz_MatExpr<P_expr2>,
5070	_bz_NotEqual<complex<T1> , typename P_expr2::T_numtype> > T_expr;
5071
5072	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<complex<T1> > (d1),
5073	d2));
5074	}
5075	#endif // BZ_HAVE_COMPLEX
5076
5077	/****************************************************************************
5078	* Logical AND operators
5079	****************************************************************************/
5080
5081	// Matrix<P_numtype1, P_struct1> && Matrix<P_numtype2, P_struct2>
5082	template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
5083	inline
5084	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
5085	_bz_MatrixRef<P_numtype2, P_struct2>,
5086	_bz_LogicalAnd<P_numtype1, P_numtype2 > > >
5087	operator&&(const Matrix<P_numtype1, P_struct1>& d1,
5088	const Matrix<P_numtype2, P_struct2>& d2)
5089	{
5090	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
5091	_bz_MatrixRef<P_numtype2, P_struct2>,
5092	_bz_LogicalAnd<P_numtype1, P_numtype2> > T_expr;
5093
5094	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
5095	d2._bz_getRef()));
5096	}
5097
5098	// Matrix<P_numtype1, P_struct1> && _bz_MatExpr<P_expr2>
5099	template<class P_numtype1, class P_struct1, class P_expr2>
5100	inline
5101	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
5102	_bz_MatExpr<P_expr2>,
5103	_bz_LogicalAnd<P_numtype1, typename P_expr2::T_numtype > > >
5104	operator&&(const Matrix<P_numtype1, P_struct1>& d1,
5105	_bz_MatExpr<P_expr2> d2)
5106	{
5107	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
5108	_bz_MatExpr<P_expr2>,
5109	_bz_LogicalAnd<P_numtype1, typename P_expr2::T_numtype> > T_expr;
5110
5111	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
5112	d2));
5113	}
5114
5115	// Matrix<P_numtype1, P_struct1> && int
5116	template<class P_numtype1, class P_struct1>
5117	inline
5118	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
5119	_bz_MatExprConstant<int>,
5120	_bz_LogicalAnd<P_numtype1, int > > >
5121	operator&&(const Matrix<P_numtype1, P_struct1>& d1,
5122	int d2)
5123	{
5124	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
5125	_bz_MatExprConstant<int>,
5126	_bz_LogicalAnd<P_numtype1, int> > T_expr;
5127
5128	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
5129	_bz_MatExprConstant<int>(d2)));
5130	}
5131
5132	// _bz_MatExpr<P_expr1> && Matrix<P_numtype2, P_struct2>
5133	template<class P_expr1, class P_numtype2, class P_struct2>
5134	inline
5135	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
5136	_bz_MatrixRef<P_numtype2, P_struct2>,
5137	_bz_LogicalAnd<typename P_expr1::T_numtype, P_numtype2 > > >
5138	operator&&(_bz_MatExpr<P_expr1> d1,
5139	const Matrix<P_numtype2, P_struct2>& d2)
5140	{
5141	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
5142	_bz_MatrixRef<P_numtype2, P_struct2>,
5143	_bz_LogicalAnd<typename P_expr1::T_numtype, P_numtype2> > T_expr;
5144
5145	return _bz_MatExpr<T_expr>(T_expr(d1,
5146	d2._bz_getRef()));
5147	}
5148
5149	// _bz_MatExpr<P_expr1> && _bz_MatExpr<P_expr2>
5150	template<class P_expr1, class P_expr2>
5151	inline
5152	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
5153	_bz_MatExpr<P_expr2>,
5154	_bz_LogicalAnd<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
5155	operator&&(_bz_MatExpr<P_expr1> d1,
5156	_bz_MatExpr<P_expr2> d2)
5157	{
5158	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
5159	_bz_MatExpr<P_expr2>,
5160	_bz_LogicalAnd<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
5161
5162	return _bz_MatExpr<T_expr>(T_expr(d1,
5163	d2));
5164	}
5165
5166	// _bz_MatExpr<P_expr1> && int
5167	template<class P_expr1>
5168	inline
5169	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
5170	_bz_MatExprConstant<int>,
5171	_bz_LogicalAnd<typename P_expr1::T_numtype, int > > >
5172	operator&&(_bz_MatExpr<P_expr1> d1,
5173	int d2)
5174	{
5175	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
5176	_bz_MatExprConstant<int>,
5177	_bz_LogicalAnd<typename P_expr1::T_numtype, int> > T_expr;
5178
5179	return _bz_MatExpr<T_expr>(T_expr(d1,
5180	_bz_MatExprConstant<int>(d2)));
5181	}
5182
5183	// int && Matrix<P_numtype2, P_struct2>
5184	template<class P_numtype2, class P_struct2>
5185	inline
5186	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
5187	_bz_MatrixRef<P_numtype2, P_struct2>,
5188	_bz_LogicalAnd<int, P_numtype2 > > >
5189	operator&&(int d1,
5190	const Matrix<P_numtype2, P_struct2>& d2)
5191	{
5192	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
5193	_bz_MatrixRef<P_numtype2, P_struct2>,
5194	_bz_LogicalAnd<int, P_numtype2> > T_expr;
5195
5196	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
5197	d2._bz_getRef()));
5198	}
5199
5200	// int && _bz_MatExpr<P_expr2>
5201	template<class P_expr2>
5202	inline
5203	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
5204	_bz_MatExpr<P_expr2>,
5205	_bz_LogicalAnd<int, typename P_expr2::T_numtype > > >
5206	operator&&(int d1,
5207	_bz_MatExpr<P_expr2> d2)
5208	{
5209	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
5210	_bz_MatExpr<P_expr2>,
5211	_bz_LogicalAnd<int, typename P_expr2::T_numtype> > T_expr;
5212
5213	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
5214	d2));
5215	}
5216	/****************************************************************************
5217	* Logical OR operators
5218	****************************************************************************/
5219
5220	// Matrix<P_numtype1, P_struct1> \|\| Matrix<P_numtype2, P_struct2>
5221	template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
5222	inline
5223	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
5224	_bz_MatrixRef<P_numtype2, P_struct2>,
5225	_bz_LogicalOr<P_numtype1, P_numtype2 > > >
5226	operator\|\|(const Matrix<P_numtype1, P_struct1>& d1,
5227	const Matrix<P_numtype2, P_struct2>& d2)
5228	{
5229	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
5230	_bz_MatrixRef<P_numtype2, P_struct2>,
5231	_bz_LogicalOr<P_numtype1, P_numtype2> > T_expr;
5232
5233	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
5234	d2._bz_getRef()));
5235	}
5236
5237	// Matrix<P_numtype1, P_struct1> \|\| _bz_MatExpr<P_expr2>
5238	template<class P_numtype1, class P_struct1, class P_expr2>
5239	inline
5240	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
5241	_bz_MatExpr<P_expr2>,
5242	_bz_LogicalOr<P_numtype1, typename P_expr2::T_numtype > > >
5243	operator\|\|(const Matrix<P_numtype1, P_struct1>& d1,
5244	_bz_MatExpr<P_expr2> d2)
5245	{
5246	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
5247	_bz_MatExpr<P_expr2>,
5248	_bz_LogicalOr<P_numtype1, typename P_expr2::T_numtype> > T_expr;
5249
5250	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
5251	d2));
5252	}
5253
5254	// Matrix<P_numtype1, P_struct1> \|\| int
5255	template<class P_numtype1, class P_struct1>
5256	inline
5257	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
5258	_bz_MatExprConstant<int>,
5259	_bz_LogicalOr<P_numtype1, int > > >
5260	operator\|\|(const Matrix<P_numtype1, P_struct1>& d1,
5261	int d2)
5262	{
5263	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
5264	_bz_MatExprConstant<int>,
5265	_bz_LogicalOr<P_numtype1, int> > T_expr;
5266
5267	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
5268	_bz_MatExprConstant<int>(d2)));
5269	}
5270
5271	// _bz_MatExpr<P_expr1> \|\| Matrix<P_numtype2, P_struct2>
5272	template<class P_expr1, class P_numtype2, class P_struct2>
5273	inline
5274	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
5275	_bz_MatrixRef<P_numtype2, P_struct2>,
5276	_bz_LogicalOr<typename P_expr1::T_numtype, P_numtype2 > > >
5277	operator\|\|(_bz_MatExpr<P_expr1> d1,
5278	const Matrix<P_numtype2, P_struct2>& d2)
5279	{
5280	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
5281	_bz_MatrixRef<P_numtype2, P_struct2>,
5282	_bz_LogicalOr<typename P_expr1::T_numtype, P_numtype2> > T_expr;
5283
5284	return _bz_MatExpr<T_expr>(T_expr(d1,
5285	d2._bz_getRef()));
5286	}
5287
5288	// _bz_MatExpr<P_expr1> \|\| _bz_MatExpr<P_expr2>
5289	template<class P_expr1, class P_expr2>
5290	inline
5291	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
5292	_bz_MatExpr<P_expr2>,
5293	_bz_LogicalOr<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
5294	operator\|\|(_bz_MatExpr<P_expr1> d1,
5295	_bz_MatExpr<P_expr2> d2)
5296	{
5297	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
5298	_bz_MatExpr<P_expr2>,
5299	_bz_LogicalOr<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
5300
5301	return _bz_MatExpr<T_expr>(T_expr(d1,
5302	d2));
5303	}
5304
5305	// _bz_MatExpr<P_expr1> \|\| int
5306	template<class P_expr1>
5307	inline
5308	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
5309	_bz_MatExprConstant<int>,
5310	_bz_LogicalOr<typename P_expr1::T_numtype, int > > >
5311	operator\|\|(_bz_MatExpr<P_expr1> d1,
5312	int d2)
5313	{
5314	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
5315	_bz_MatExprConstant<int>,
5316	_bz_LogicalOr<typename P_expr1::T_numtype, int> > T_expr;
5317
5318	return _bz_MatExpr<T_expr>(T_expr(d1,
5319	_bz_MatExprConstant<int>(d2)));
5320	}
5321
5322	// int \|\| Matrix<P_numtype2, P_struct2>
5323	template<class P_numtype2, class P_struct2>
5324	inline
5325	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
5326	_bz_MatrixRef<P_numtype2, P_struct2>,
5327	_bz_LogicalOr<int, P_numtype2 > > >
5328	operator\|\|(int d1,
5329	const Matrix<P_numtype2, P_struct2>& d2)
5330	{
5331	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
5332	_bz_MatrixRef<P_numtype2, P_struct2>,
5333	_bz_LogicalOr<int, P_numtype2> > T_expr;
5334
5335	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
5336	d2._bz_getRef()));
5337	}
5338
5339	// int \|\| _bz_MatExpr<P_expr2>
5340	template<class P_expr2>
5341	inline
5342	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
5343	_bz_MatExpr<P_expr2>,
5344	_bz_LogicalOr<int, typename P_expr2::T_numtype > > >
5345	operator\|\|(int d1,
5346	_bz_MatExpr<P_expr2> d2)
5347	{
5348	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
5349	_bz_MatExpr<P_expr2>,
5350	_bz_LogicalOr<int, typename P_expr2::T_numtype> > T_expr;
5351
5352	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
5353	d2));
5354	}
5355	/****************************************************************************
5356	* Minimum Operators
5357	****************************************************************************/
5358
5359	// Matrix<P_numtype1, P_struct1> min Matrix<P_numtype2, P_struct2>
5360	template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
5361	inline
5362	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
5363	_bz_MatrixRef<P_numtype2, P_struct2>,
5364	_bz_Min<P_numtype1, P_numtype2 > > >
5365	min(const Matrix<P_numtype1, P_struct1>& d1,
5366	const Matrix<P_numtype2, P_struct2>& d2)
5367	{
5368	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
5369	_bz_MatrixRef<P_numtype2, P_struct2>,
5370	_bz_Min<P_numtype1, P_numtype2> > T_expr;
5371
5372	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
5373	d2._bz_getRef()));
5374	}
5375
5376	// Matrix<P_numtype1, P_struct1> min _bz_MatExpr<P_expr2>
5377	template<class P_numtype1, class P_struct1, class P_expr2>
5378	inline
5379	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
5380	_bz_MatExpr<P_expr2>,
5381	_bz_Min<P_numtype1, typename P_expr2::T_numtype > > >
5382	min(const Matrix<P_numtype1, P_struct1>& d1,
5383	_bz_MatExpr<P_expr2> d2)
5384	{
5385	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
5386	_bz_MatExpr<P_expr2>,
5387	_bz_Min<P_numtype1, typename P_expr2::T_numtype> > T_expr;
5388
5389	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
5390	d2));
5391	}
5392
5393	// Matrix<P_numtype1, P_struct1> min int
5394	template<class P_numtype1, class P_struct1>
5395	inline
5396	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
5397	_bz_MatExprConstant<int>,
5398	_bz_Min<P_numtype1, int > > >
5399	min(const Matrix<P_numtype1, P_struct1>& d1,
5400	int d2)
5401	{
5402	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
5403	_bz_MatExprConstant<int>,
5404	_bz_Min<P_numtype1, int> > T_expr;
5405
5406	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
5407	_bz_MatExprConstant<int>(d2)));
5408	}
5409
5410	// _bz_MatExpr<P_expr1> min Matrix<P_numtype2, P_struct2>
5411	template<class P_expr1, class P_numtype2, class P_struct2>
5412	inline
5413	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
5414	_bz_MatrixRef<P_numtype2, P_struct2>,
5415	_bz_Min<typename P_expr1::T_numtype, P_numtype2 > > >
5416	min(_bz_MatExpr<P_expr1> d1,
5417	const Matrix<P_numtype2, P_struct2>& d2)
5418	{
5419	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
5420	_bz_MatrixRef<P_numtype2, P_struct2>,
5421	_bz_Min<typename P_expr1::T_numtype, P_numtype2> > T_expr;
5422
5423	return _bz_MatExpr<T_expr>(T_expr(d1,
5424	d2._bz_getRef()));
5425	}
5426
5427	// _bz_MatExpr<P_expr1> min _bz_MatExpr<P_expr2>
5428	template<class P_expr1, class P_expr2>
5429	inline
5430	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
5431	_bz_MatExpr<P_expr2>,
5432	_bz_Min<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
5433	min(_bz_MatExpr<P_expr1> d1,
5434	_bz_MatExpr<P_expr2> d2)
5435	{
5436	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
5437	_bz_MatExpr<P_expr2>,
5438	_bz_Min<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
5439
5440	return _bz_MatExpr<T_expr>(T_expr(d1,
5441	d2));
5442	}
5443
5444	// _bz_MatExpr<P_expr1> min int
5445	template<class P_expr1>
5446	inline
5447	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
5448	_bz_MatExprConstant<int>,
5449	_bz_Min<typename P_expr1::T_numtype, int > > >
5450	min(_bz_MatExpr<P_expr1> d1,
5451	int d2)
5452	{
5453	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
5454	_bz_MatExprConstant<int>,
5455	_bz_Min<typename P_expr1::T_numtype, int> > T_expr;
5456
5457	return _bz_MatExpr<T_expr>(T_expr(d1,
5458	_bz_MatExprConstant<int>(d2)));
5459	}
5460
5461	// int min Matrix<P_numtype2, P_struct2>
5462	template<class P_numtype2, class P_struct2>
5463	inline
5464	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
5465	_bz_MatrixRef<P_numtype2, P_struct2>,
5466	_bz_Min<int, P_numtype2 > > >
5467	min(int d1,
5468	const Matrix<P_numtype2, P_struct2>& d2)
5469	{
5470	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
5471	_bz_MatrixRef<P_numtype2, P_struct2>,
5472	_bz_Min<int, P_numtype2> > T_expr;
5473
5474	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
5475	d2._bz_getRef()));
5476	}
5477
5478	// int min _bz_MatExpr<P_expr2>
5479	template<class P_expr2>
5480	inline
5481	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
5482	_bz_MatExpr<P_expr2>,
5483	_bz_Min<int, typename P_expr2::T_numtype > > >
5484	min(int d1,
5485	_bz_MatExpr<P_expr2> d2)
5486	{
5487	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
5488	_bz_MatExpr<P_expr2>,
5489	_bz_Min<int, typename P_expr2::T_numtype> > T_expr;
5490
5491	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
5492	d2));
5493	}
5494	/****************************************************************************
5495	* Maximum Operators
5496	****************************************************************************/
5497
5498	// Matrix<P_numtype1, P_struct1> max Matrix<P_numtype2, P_struct2>
5499	template<class P_numtype1, class P_struct1, class P_numtype2, class P_struct2>
5500	inline
5501	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
5502	_bz_MatrixRef<P_numtype2, P_struct2>,
5503	_bz_Max<P_numtype1, P_numtype2 > > >
5504	max(const Matrix<P_numtype1, P_struct1>& d1,
5505	const Matrix<P_numtype2, P_struct2>& d2)
5506	{
5507	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
5508	_bz_MatrixRef<P_numtype2, P_struct2>,
5509	_bz_Max<P_numtype1, P_numtype2> > T_expr;
5510
5511	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
5512	d2._bz_getRef()));
5513	}
5514
5515	// Matrix<P_numtype1, P_struct1> max _bz_MatExpr<P_expr2>
5516	template<class P_numtype1, class P_struct1, class P_expr2>
5517	inline
5518	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
5519	_bz_MatExpr<P_expr2>,
5520	_bz_Max<P_numtype1, typename P_expr2::T_numtype > > >
5521	max(const Matrix<P_numtype1, P_struct1>& d1,
5522	_bz_MatExpr<P_expr2> d2)
5523	{
5524	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
5525	_bz_MatExpr<P_expr2>,
5526	_bz_Max<P_numtype1, typename P_expr2::T_numtype> > T_expr;
5527
5528	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
5529	d2));
5530	}
5531
5532	// Matrix<P_numtype1, P_struct1> max int
5533	template<class P_numtype1, class P_struct1>
5534	inline
5535	_bz_MatExpr<_bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
5536	_bz_MatExprConstant<int>,
5537	_bz_Max<P_numtype1, int > > >
5538	max(const Matrix<P_numtype1, P_struct1>& d1,
5539	int d2)
5540	{
5541	typedef _bz_MatExprOp<_bz_MatrixRef<P_numtype1, P_struct1>,
5542	_bz_MatExprConstant<int>,
5543	_bz_Max<P_numtype1, int> > T_expr;
5544
5545	return _bz_MatExpr<T_expr>(T_expr(d1._bz_getRef(),
5546	_bz_MatExprConstant<int>(d2)));
5547	}
5548
5549	// _bz_MatExpr<P_expr1> max Matrix<P_numtype2, P_struct2>
5550	template<class P_expr1, class P_numtype2, class P_struct2>
5551	inline
5552	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
5553	_bz_MatrixRef<P_numtype2, P_struct2>,
5554	_bz_Max<typename P_expr1::T_numtype, P_numtype2 > > >
5555	max(_bz_MatExpr<P_expr1> d1,
5556	const Matrix<P_numtype2, P_struct2>& d2)
5557	{
5558	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
5559	_bz_MatrixRef<P_numtype2, P_struct2>,
5560	_bz_Max<typename P_expr1::T_numtype, P_numtype2> > T_expr;
5561
5562	return _bz_MatExpr<T_expr>(T_expr(d1,
5563	d2._bz_getRef()));
5564	}
5565
5566	// _bz_MatExpr<P_expr1> max _bz_MatExpr<P_expr2>
5567	template<class P_expr1, class P_expr2>
5568	inline
5569	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
5570	_bz_MatExpr<P_expr2>,
5571	_bz_Max<typename P_expr1::T_numtype, typename P_expr2::T_numtype > > >
5572	max(_bz_MatExpr<P_expr1> d1,
5573	_bz_MatExpr<P_expr2> d2)
5574	{
5575	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
5576	_bz_MatExpr<P_expr2>,
5577	_bz_Max<typename P_expr1::T_numtype, typename P_expr2::T_numtype> > T_expr;
5578
5579	return _bz_MatExpr<T_expr>(T_expr(d1,
5580	d2));
5581	}
5582
5583	// _bz_MatExpr<P_expr1> max int
5584	template<class P_expr1>
5585	inline
5586	_bz_MatExpr<_bz_MatExprOp<_bz_MatExpr<P_expr1>,
5587	_bz_MatExprConstant<int>,
5588	_bz_Max<typename P_expr1::T_numtype, int > > >
5589	max(_bz_MatExpr<P_expr1> d1,
5590	int d2)
5591	{
5592	typedef _bz_MatExprOp<_bz_MatExpr<P_expr1>,
5593	_bz_MatExprConstant<int>,
5594	_bz_Max<typename P_expr1::T_numtype, int> > T_expr;
5595
5596	return _bz_MatExpr<T_expr>(T_expr(d1,
5597	_bz_MatExprConstant<int>(d2)));
5598	}
5599
5600	// int max Matrix<P_numtype2, P_struct2>
5601	template<class P_numtype2, class P_struct2>
5602	inline
5603	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
5604	_bz_MatrixRef<P_numtype2, P_struct2>,
5605	_bz_Max<int, P_numtype2 > > >
5606	max(int d1,
5607	const Matrix<P_numtype2, P_struct2>& d2)
5608	{
5609	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
5610	_bz_MatrixRef<P_numtype2, P_struct2>,
5611	_bz_Max<int, P_numtype2> > T_expr;
5612
5613	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
5614	d2._bz_getRef()));
5615	}
5616
5617	// int max _bz_MatExpr<P_expr2>
5618	template<class P_expr2>
5619	inline
5620	_bz_MatExpr<_bz_MatExprOp<_bz_MatExprConstant<int>,
5621	_bz_MatExpr<P_expr2>,
5622	_bz_Max<int, typename P_expr2::T_numtype > > >
5623	max(int d1,
5624	_bz_MatExpr<P_expr2> d2)
5625	{
5626	typedef _bz_MatExprOp<_bz_MatExprConstant<int>,
5627	_bz_MatExpr<P_expr2>,
5628	_bz_Max<int, typename P_expr2::T_numtype> > T_expr;
5629
5630	return _bz_MatExpr<T_expr>(T_expr(_bz_MatExprConstant<int>(d1),
5631	d2));
5632	}
5633
5634	BZ_NAMESPACE_END
5635
5636	#endif // BZ_MATBOPS_H

Note: See TracBrowser for help on using the repository browser.

Download in other formats: