Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Normal
Revision Log

matbops.h@ 1020

Visit:

Last change on this file since 1020 was 221, checked in by ansari, 27 years ago
Creation module DPC/Blitz (blitz 0.4) Reza 09/04/99
File size: 218.0 KB

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

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

Context Navigation

source: Sophya/trunk/SophyaExt/Blitz/blitz/matbops.h@ 1020

Download in other formats: