arma_version.hpp		arma_version.hpp
	skipping to change at line 18		skipping to change at line 18
	// Lesser General Public License (LGPL) as published		// Lesser General Public License (LGPL) as published
	// by the Free Software Foundation, either version 3		// by the Free Software Foundation, either version 3
	// of the License or (at your option) any later version.		// of the License or (at your option) any later version.
	// (see http://www.opensource.org/licenses for more info)		// (see http://www.opensource.org/licenses for more info)
	//! \addtogroup arma_version		//! \addtogroup arma_version
	//! @{		//! @{
	#define ARMA_VERSION_MAJOR 3		#define ARMA_VERSION_MAJOR 3
	#define ARMA_VERSION_MINOR 0		#define ARMA_VERSION_MINOR 0
	#define ARMA_VERSION_PATCH 0		#define ARMA_VERSION_PATCH 1
	#define ARMA_VERSION_NAME "Antarctic Chilli Ranch"		#define ARMA_VERSION_NAME "Antarctic Chilli Ranch"
	struct arma_version		struct arma_version
	{		{
	static const unsigned int major = ARMA_VERSION_MAJOR;		static const unsigned int major = ARMA_VERSION_MAJOR;
	static const unsigned int minor = ARMA_VERSION_MINOR;		static const unsigned int minor = ARMA_VERSION_MINOR;
	static const unsigned int patch = ARMA_VERSION_PATCH;		static const unsigned int patch = ARMA_VERSION_PATCH;
	static		static
	inline		inline
End of changes. 1 change blocks.
	1 lines changed or deleted		1 lines changed or added

	armadillo		armadillo
	skipping to change at line 51		skipping to change at line 51
	#if defined(ARMA_HAVE_GETTIMEOFDAY)		#if defined(ARMA_HAVE_GETTIMEOFDAY)
	#include <sys/time.h>		#include <sys/time.h>
	#undef ARMA_USE_BOOST_DATE		#undef ARMA_USE_BOOST_DATE
	#endif		#endif
	#if defined(ARMA_USE_BOOST_DATE)		#if defined(ARMA_USE_BOOST_DATE)
	#include <boost/date_time/posix_time/posix_time.hpp>		#include <boost/date_time/posix_time/posix_time.hpp>
	#endif		#endif
			#if defined(ARMA_USE_TBB_ALLOC)
			#include <tbb/scalable_allocator.h>
			#endif
	#if defined(ARMA_USE_MKL_ALLOC)		#if defined(ARMA_USE_MKL_ALLOC)
	#include <mkl_service.h>		#include <mkl_service.h>
	#endif		#endif
	#if defined(ARMA_HAVE_STD_TR1)		#if defined(ARMA_HAVE_STD_TR1)
	// TODO: add handling of this functionality when use of C++11 is enabled		// TODO: add handling of this functionality when use of C++11 is enabled
	#include <tr1/cmath>		#include <tr1/cmath>
	#include <tr1/complex>		#include <tr1/complex>
	#elif defined(ARMA_USE_BOOST)		#elif defined(ARMA_USE_BOOST)
	#include <boost/math/complex.hpp>		#include <boost/math/complex.hpp>
End of changes. 1 change blocks.
	0 lines changed or deleted		4 lines changed or added

	unwrap.hpp		unwrap.hpp
	skipping to change at line 17		skipping to change at line 17
	// and/or modify it under the terms of the GNU		// and/or modify it under the terms of the GNU
	// Lesser General Public License (LGPL) as published		// Lesser General Public License (LGPL) as published
	// by the Free Software Foundation, either version 3		// by the Free Software Foundation, either version 3
	// of the License or (at your option) any later version.		// of the License or (at your option) any later version.
	// (see http://www.opensource.org/licenses for more info)		// (see http://www.opensource.org/licenses for more info)
	//! \addtogroup unwrap		//! \addtogroup unwrap
	//! @{		//! @{
	template<typename T1>		template<typename T1>
	class unwrap		struct unwrap_default
	{		{
	public:
	typedef typename T1::elem_type eT;		typedef typename T1::elem_type eT;
	inline unwrap(const T1& A) // TODO: change this to Base ?		inline unwrap_default(const T1& A) // TODO: change this to Base ?
	: M(A)		: M(A)
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	const Mat<eT> M;		const Mat<eT> M;
	};		};
			template<typename T1>
			struct unwrap_Mat_fixed
			{
			typedef typename T1::elem_type eT;
			inline explicit unwrap_Mat_fixed(const T1& A)
			: M(A)
			{
			arma_extra_debug_sigprint();
			}
			const Mat<eT>& M;
			};
			template<typename T1, bool condition>
			struct unwrap_redirect {};
			template<typename T1>
			struct unwrap_redirect<T1, false> { typedef unwrap_default<T1> result; };
			template<typename T1>
			struct unwrap_redirect<T1, true> { typedef unwrap_Mat_fixed<T1> result; };
			template<typename T1>
			class unwrap : public unwrap_redirect<T1, is_Mat_fixed<T1>::value >::result
			{
			public:
			inline unwrap(const T1& A)
			: unwrap_redirect< T1, is_Mat_fixed<T1>::value >::result(A)
			{
			}
			};
	template<typename eT>		template<typename eT>
	class unwrap< Mat<eT> >		class unwrap< Mat<eT> >
	{		{
	public:		public:
	inline unwrap(const Mat<eT>& A)		inline unwrap(const Mat<eT>& A)
	: M(A)		: M(A)
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	skipping to change at line 74		skipping to change at line 106
	inline unwrap(const Col<eT>& A)		inline unwrap(const Col<eT>& A)
	: M(A)		: M(A)
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	const Col<eT>& M;		const Col<eT>& M;
	};		};
			template<typename eT>
			class unwrap< subview_col<eT> >
			{
			public:
			inline unwrap(const subview_col<eT>& A)
			: M( const_cast<eT*>( A.colptr(0) ), A.n_rows, 1, false, false )
			{
			arma_extra_debug_sigprint();
			}
			const Mat<eT> M;
			};
	template<typename out_eT, typename T1, typename T2, typename glue_type>		template<typename out_eT, typename T1, typename T2, typename glue_type>
	class unwrap< mtGlue<out_eT, T1, T2, glue_type> >		class unwrap< mtGlue<out_eT, T1, T2, glue_type> >
	{		{
	public:		public:
	inline unwrap(const mtGlue<out_eT, T1, T2, glue_type>& A)		inline unwrap(const mtGlue<out_eT, T1, T2, glue_type>& A)
	: M(A)		: M(A)
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	skipping to change at line 120		skipping to change at line 166
	typedef typename T1::elem_type eT;		typedef typename T1::elem_type eT;
	inline		inline
	unwrap_check(const T1& A, const Mat<eT>&)		unwrap_check(const T1& A, const Mat<eT>&)
	: M(A)		: M(A)
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline
	~unwrap_check()
	{
	arma_extra_debug_sigprint();
	}
	const Mat<eT> M;		const Mat<eT> M;
	};		};
	template<typename eT>		template<typename eT>
	class unwrap_check< Mat<eT> >		class unwrap_check< Mat<eT> >
	{		{
	public:		public:
	inline		inline
	unwrap_check(const Mat<eT>& A, const Mat<eT>& B)		unwrap_check(const Mat<eT>& A, const Mat<eT>& B)
	skipping to change at line 147		skipping to change at line 187
	, M ( (&A == &B) ? (*M_local) : A )		, M ( (&A == &B) ? (*M_local) : A )
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline		inline
	~unwrap_check()		~unwrap_check()
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	if(M_local)		if(M_local) { delete M_local; }
	{
	delete M_local;
	}
	}		}
	// the order below is important		// the order below is important
	const Mat<eT>* M_local;		const Mat<eT>* M_local;
	const Mat<eT>& M;		const Mat<eT>& M;
	};		};
	template<typename eT>		template<typename eT>
	class unwrap_check< Row<eT> >		class unwrap_check< Row<eT> >
	{		{
	skipping to change at line 176		skipping to change at line 213
	, M ( (&A == reinterpret_cast<const Row<eT>*>(&B)) ? (*M_local) : A )		, M ( (&A == reinterpret_cast<const Row<eT>*>(&B)) ? (*M_local) : A )
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline		inline
	~unwrap_check()		~unwrap_check()
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	if(M_local)		if(M_local) { delete M_local; }
	{
	delete M_local;
	}
	}		}
	// the order below is important		// the order below is important
	const Row<eT>* M_local;		const Row<eT>* M_local;
	const Row<eT>& M;		const Row<eT>& M;
	};		};
	template<typename eT>		template<typename eT>
	class unwrap_check< Col<eT> >		class unwrap_check< Col<eT> >
	{		{
	skipping to change at line 205		skipping to change at line 239
	, M ( (&A == reinterpret_cast<const Col<eT>*>(&B)) ? (*M_local) : A )		, M ( (&A == reinterpret_cast<const Col<eT>*>(&B)) ? (*M_local) : A )
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline		inline
	~unwrap_check()		~unwrap_check()
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	if(M_local)		if(M_local) { delete M_local; }
	{
	delete M_local;
	}
	}		}
	// the order below is important		// the order below is important
	const Col<eT>* M_local;		const Col<eT>* M_local;
	const Col<eT>& M;		const Col<eT>& M;
	};		};
			template<typename eT>
			class unwrap_check< subview_col<eT> >
			{
			public:
			inline
			unwrap_check(const subview_col<eT>& A, const Mat<eT>& B)
			: M( const_cast<eT*>( A.colptr(0) ), A.n_rows, 1, (&(A.m) == &B), false
			)
			{
			arma_extra_debug_sigprint();
			}
			const Mat<eT> M;
			};
	//		//
	//		//
	//		//
	template<typename T1>		template<typename T1>
	class unwrap_check_mixed		class unwrap_check_mixed
	{		{
	public:		public:
	typedef typename T1::elem_type eT1;		typedef typename T1::elem_type eT1;
	template<typename eT2>		template<typename eT2>
	inline		inline
	unwrap_check_mixed(const T1& A, const Mat<eT2>&)		unwrap_check_mixed(const T1& A, const Mat<eT2>&)
	: M(A)		: M(A)
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline
	~unwrap_check_mixed()
	{
	arma_extra_debug_sigprint();
	}
	const Mat<eT1> M;		const Mat<eT1> M;
	};		};
	template<typename eT1>		template<typename eT1>
	class unwrap_check_mixed< Mat<eT1> >		class unwrap_check_mixed< Mat<eT1> >
	{		{
	public:		public:
	template<typename eT2>		template<typename eT2>
	inline		inline
	skipping to change at line 264		skipping to change at line 304
	, M ( (void_ptr(&A) == void_ptr(&B)) ? (*M_local) : A )		, M ( (void_ptr(&A) == void_ptr(&B)) ? (*M_local) : A )
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline		inline
	~unwrap_check_mixed()		~unwrap_check_mixed()
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	if(M_local)		if(M_local) { delete M_local; }
	{
	delete M_local;
	}
	}		}
	// the order below is important		// the order below is important
	const Mat<eT1>* M_local;		const Mat<eT1>* M_local;
	const Mat<eT1>& M;		const Mat<eT1>& M;
	};		};
	template<typename eT1>		template<typename eT1>
	class unwrap_check_mixed< Row<eT1> >		class unwrap_check_mixed< Row<eT1> >
	{		{
	skipping to change at line 294		skipping to change at line 331
	, M ( (void_ptr(&A) == void_ptr(&B)) ? (*M_local) : A )		, M ( (void_ptr(&A) == void_ptr(&B)) ? (*M_local) : A )
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline		inline
	~unwrap_check_mixed()		~unwrap_check_mixed()
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	if(M_local)		if(M_local) { delete M_local; }
	{
	delete M_local;
	}
	}		}
	// the order below is important		// the order below is important
	const Row<eT1>* M_local;		const Row<eT1>* M_local;
	const Row<eT1>& M;		const Row<eT1>& M;
	};		};
	template<typename eT1>		template<typename eT1>
	class unwrap_check_mixed< Col<eT1> >		class unwrap_check_mixed< Col<eT1> >
	{		{
	skipping to change at line 324		skipping to change at line 358
	, M ( (void_ptr(&A) == void_ptr(&B)) ? (*M_local) : A )		, M ( (void_ptr(&A) == void_ptr(&B)) ? (*M_local) : A )
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline		inline
	~unwrap_check_mixed()		~unwrap_check_mixed()
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	if(M_local)		if(M_local) { delete M_local; }
	{
	delete M_local;
	}
	}		}
	// the order below is important		// the order below is important
	const Col<eT1>* M_local;		const Col<eT1>* M_local;
	const Col<eT1>& M;		const Col<eT1>& M;
	};		};
	//		//
	template<typename T1>		template<typename T1>
	class partial_unwrap		struct partial_unwrap_default
	{		{
	public:
	typedef typename T1::elem_type eT;		typedef typename T1::elem_type eT;
	inline partial_unwrap(const T1& A) // TODO: change this to Base ?		inline partial_unwrap_default(const T1& A)
	: M(A)		: M(A)
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline		arma_hot arma_inline eT get_val() const { return eT(1); }
	~partial_unwrap()
			static const bool do_trans = false;
			static const bool do_times = false;
			const Mat<eT> M;
			};
			template<typename T1>
			struct partial_unwrap_Mat_fixed
			{
			typedef typename T1::elem_type eT;
			inline explicit partial_unwrap_Mat_fixed(const T1& A)
			: M(A)
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline eT get_val() const { return eT(1); }		arma_hot arma_inline eT get_val() const { return eT(1); }
	static const bool do_trans = false;		static const bool do_trans = false;
	static const bool do_times = false;		static const bool do_times = false;
	const Mat<eT> M;		const Mat<eT>& M;
			};
			template<typename T1, bool condition>
			struct partial_unwrap_redirect {};
			template<typename T1>
			struct partial_unwrap_redirect<T1, false> { typedef partial_unwrap_default<
			T1> result; };
			template<typename T1>
			struct partial_unwrap_redirect<T1, true> { typedef partial_unwrap_Mat_fixe
			d<T1> result; };
			template<typename T1>
			class partial_unwrap : public partial_unwrap_redirect<T1, is_Mat_fixed<T1>:
			:value >::result
			{
			public:
			inline partial_unwrap(const T1& A)
			: partial_unwrap_redirect< T1, is_Mat_fixed<T1>::value >::result(A)
			{
			}
	};		};
	template<typename eT>		template<typename eT>
	class partial_unwrap< Mat<eT> >		class partial_unwrap< Mat<eT> >
	{		{
	public:		public:
	inline		inline
	partial_unwrap(const Mat<eT>& A)		partial_unwrap(const Mat<eT>& A)
	: M(A)		: M(A)
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline
	~partial_unwrap()
	{
	arma_extra_debug_sigprint();
	}
	inline eT get_val() const { return eT(1); }		inline eT get_val() const { return eT(1); }
	static const bool do_trans = false;		static const bool do_trans = false;
	static const bool do_times = false;		static const bool do_times = false;
	const Mat<eT>& M;		const Mat<eT>& M;
	};		};
	template<typename eT>		template<typename eT>
	class partial_unwrap< Row<eT> >		class partial_unwrap< Row<eT> >
	{		{
	public:		public:
	inline		inline
	partial_unwrap(const Row<eT>& A)		partial_unwrap(const Row<eT>& A)
	: M(A)		: M(A)
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline
	~partial_unwrap()
	{
	arma_extra_debug_sigprint();
	}
	inline eT get_val() const { return eT(1); }		inline eT get_val() const { return eT(1); }
	static const bool do_trans = false;		static const bool do_trans = false;
	static const bool do_times = false;		static const bool do_times = false;
	const Mat<eT>& M;		const Mat<eT>& M;
	};		};
	template<typename eT>		template<typename eT>
	class partial_unwrap< Col<eT> >		class partial_unwrap< Col<eT> >
	{		{
	public:		public:
	inline		inline
	partial_unwrap(const Col<eT>& A)		partial_unwrap(const Col<eT>& A)
	: M(A)		: M(A)
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
			inline eT get_val() const { return eT(1); }
			static const bool do_trans = false;
			static const bool do_times = false;
			const Mat<eT>& M;
			};
			template<typename eT>
			class partial_unwrap< subview_col<eT> >
			{
			public:
	inline		inline
	~partial_unwrap()		partial_unwrap(const subview_col<eT>& A)
			: M( const_cast<eT*>( A.colptr(0) ), A.n_rows, 1, false, false )
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline eT get_val() const { return eT(1); }		inline eT get_val() const { return eT(1); }
	static const bool do_trans = false;		static const bool do_trans = false;
	static const bool do_times = false;		static const bool do_times = false;
	const Mat<eT>& M;		const Mat<eT> M;
	};		};
	template<typename T1>		template<typename T1>
	class partial_unwrap< Op<T1, op_htrans> >		struct partial_unwrap_htrans_default
	{		{
	public:
	typedef typename T1::elem_type eT;		typedef typename T1::elem_type eT;
	inline		inline partial_unwrap_htrans_default(const Op<T1, op_htrans>& A)
	partial_unwrap(const Op<T1,op_htrans>& A)
	: M(A.m)		: M(A.m)
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline		arma_hot arma_inline eT get_val() const { return eT(1); }
	~partial_unwrap()
			static const bool do_trans = true;
			static const bool do_times = false;
			const Mat<eT> M;
			};
			template<typename T1>
			struct partial_unwrap_htrans_Mat_fixed
			{
			typedef typename T1::elem_type eT;
			inline explicit partial_unwrap_htrans_Mat_fixed(const Op<T1, op_htrans>&
			A)
			: M(A.m)
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline eT get_val() const { return eT(1); }		arma_hot arma_inline eT get_val() const { return eT(1); }
	static const bool do_trans = true;		static const bool do_trans = true;
	static const bool do_times = false;		static const bool do_times = false;
	const Mat<eT> M;		const Mat<eT>& M;
			};
			template<typename T1, bool condition>
			struct partial_unwrap_htrans_redirect {};
			template<typename T1>
			struct partial_unwrap_htrans_redirect<T1, false> { typedef partial_unwrap_h
			trans_default<T1> result; };
			template<typename T1>
			struct partial_unwrap_htrans_redirect<T1, true> { typedef partial_unwrap_h
			trans_Mat_fixed<T1> result; };
			template<typename T1>
			class partial_unwrap< Op<T1, op_htrans> > : public partial_unwrap_htrans_re
			direct<T1, is_Mat_fixed<T1>::value >::result
			{
			public:
			inline partial_unwrap(const Op<T1, op_htrans>& A)
			: partial_unwrap_htrans_redirect< T1, is_Mat_fixed<T1>::value >::result
			(A)
			{
			}
	};		};
	template<typename eT>		template<typename eT>
	class partial_unwrap< Op< Mat<eT>, op_htrans> >		class partial_unwrap< Op< Mat<eT>, op_htrans> >
	{		{
	public:		public:
	inline		inline
	partial_unwrap(const Op< Mat<eT>, op_htrans>& A)		partial_unwrap(const Op< Mat<eT>, op_htrans>& A)
	: M(A.m)		: M(A.m)
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline		arma_inline eT get_val() const { return eT(1); }
	~partial_unwrap()
	{
	arma_extra_debug_sigprint();
	}
	inline eT get_val() const { return eT(1); }
	static const bool do_trans = true;		static const bool do_trans = true;
	static const bool do_times = false;		static const bool do_times = false;
	const Mat<eT>& M;		const Mat<eT>& M;
	};		};
	template<typename eT>		template<typename eT>
	class partial_unwrap< Op< Row<eT>, op_htrans> >		class partial_unwrap< Op< Row<eT>, op_htrans> >
	{		{
	public:		public:
	inline		inline
	partial_unwrap(const Op< Row<eT>, op_htrans>& A)		partial_unwrap(const Op< Row<eT>, op_htrans>& A)
	: M(A.m)		: M(A.m)
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline		arma_inline eT get_val() const { return eT(1); }
	~partial_unwrap()
	{
	arma_extra_debug_sigprint();
	}
	inline eT get_val() const { return eT(1); }
	static const bool do_trans = true;		static const bool do_trans = true;
	static const bool do_times = false;		static const bool do_times = false;
	const Mat<eT>& M;		const Mat<eT>& M;
	};		};
	template<typename eT>		template<typename eT>
	class partial_unwrap< Op< Col<eT>, op_htrans> >		class partial_unwrap< Op< Col<eT>, op_htrans> >
	{		{
	public:		public:
	inline		inline
	partial_unwrap(const Op< Col<eT>, op_htrans>& A)		partial_unwrap(const Op< Col<eT>, op_htrans>& A)
	: M(A.m)		: M(A.m)
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
			arma_inline eT get_val() const { return eT(1); }
			static const bool do_trans = true;
			static const bool do_times = false;
			const Mat<eT>& M;
			};
			template<typename eT>
			class partial_unwrap< Op< subview_col<eT>, op_htrans> >
			{
			public:
	inline		inline
	~partial_unwrap()		partial_unwrap(const Op< subview_col<eT>, op_htrans>& A)
			: M( const_cast<eT*>( A.m.colptr(0) ), A.m.n_rows, 1, false, false )
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline eT get_val() const { return eT(1); }		arma_inline eT get_val() const { return eT(1); }
	static const bool do_trans = true;		static const bool do_trans = true;
	static const bool do_times = false;		static const bool do_times = false;
	const Mat<eT>& M;		const Mat<eT> M;
	};		};
	template<typename T1>		template<typename T1>
	class partial_unwrap< Op<T1, op_htrans2> >		struct partial_unwrap_htrans2_default
	{		{
	public:
	typedef typename T1::elem_type eT;		typedef typename T1::elem_type eT;
	inline		inline partial_unwrap_htrans2_default(const Op<T1, op_htrans2>& A)
	partial_unwrap(const Op<T1,op_htrans2>& A)
	: val(A.aux)		: val(A.aux)
	, M (A.m)		, M (A.m)
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline		arma_inline eT get_val() const { return val; }
	~partial_unwrap()
			static const bool do_trans = true;
			static const bool do_times = true;
			const eT val;
			const Mat<eT> M;
			};
			template<typename T1>
			struct partial_unwrap_htrans2_Mat_fixed
			{
			typedef typename T1::elem_type eT;
			inline explicit partial_unwrap_htrans2_Mat_fixed(const Op<T1, op_htrans2>
			& A)
			: val(A.aux)
			, M (A.m)
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline eT get_val() const { return val; }		arma_inline eT get_val() const { return val; }
	static const bool do_trans = true;		static const bool do_trans = true;
	static const bool do_times = true;		static const bool do_times = true;
	const eT val;		const eT val;
	const Mat<eT> M;		const Mat<eT>& M;
			};
			template<typename T1, bool condition>
			struct partial_unwrap_htrans2_redirect {};
			template<typename T1>
			struct partial_unwrap_htrans2_redirect<T1, false> { typedef partial_unwrap_
			htrans2_default<T1> result; };
			template<typename T1>
			struct partial_unwrap_htrans2_redirect<T1, true> { typedef partial_unwrap_
			htrans2_Mat_fixed<T1> result; };
			template<typename T1>
			class partial_unwrap< Op<T1, op_htrans2> > : public partial_unwrap_htrans2_
			redirect<T1, is_Mat_fixed<T1>::value >::result
			{
			public:
			inline partial_unwrap(const Op<T1, op_htrans2>& A)
			: partial_unwrap_htrans2_redirect< T1, is_Mat_fixed<T1>::value >::resul
			t(A)
			{
			}
	};		};
	template<typename eT>		template<typename eT>
	class partial_unwrap< Op< Mat<eT>, op_htrans2> >		class partial_unwrap< Op< Mat<eT>, op_htrans2> >
	{		{
	public:		public:
	inline		inline
	partial_unwrap(const Op< Mat<eT>, op_htrans2>& A)		partial_unwrap(const Op< Mat<eT>, op_htrans2>& A)
	: val(A.aux)		: val(A.aux)
	, M (A.m)		, M (A.m)
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline
	~partial_unwrap()
	{
	arma_extra_debug_sigprint();
	}
	inline eT get_val() const { return val; }		inline eT get_val() const { return val; }
	static const bool do_trans = true;		static const bool do_trans = true;
	static const bool do_times = true;		static const bool do_times = true;
	const eT val;		const eT val;
	const Mat<eT>& M;		const Mat<eT>& M;
	};		};
	template<typename eT>		template<typename eT>
	skipping to change at line 619		skipping to change at line 741
	public:		public:
	inline		inline
	partial_unwrap(const Op< Row<eT>, op_htrans2>& A)		partial_unwrap(const Op< Row<eT>, op_htrans2>& A)
	: val(A.aux)		: val(A.aux)
	, M (A.m)		, M (A.m)
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline
	~partial_unwrap()
	{
	arma_extra_debug_sigprint();
	}
	inline eT get_val() const { return val; }		inline eT get_val() const { return val; }
	static const bool do_trans = true;		static const bool do_trans = true;
	static const bool do_times = true;		static const bool do_times = true;
	const eT val;		const eT val;
	const Mat<eT>& M;		const Mat<eT>& M;
	};		};
	template<typename eT>		template<typename eT>
	skipping to change at line 647		skipping to change at line 763
	public:		public:
	inline		inline
	partial_unwrap(const Op< Col<eT>, op_htrans2>& A)		partial_unwrap(const Op< Col<eT>, op_htrans2>& A)
	: val(A.aux)		: val(A.aux)
	, M (A.m)		, M (A.m)
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline
	~partial_unwrap()
	{
	arma_extra_debug_sigprint();
	}
	inline eT get_val() const { return val; }		inline eT get_val() const { return val; }
	static const bool do_trans = true;		static const bool do_trans = true;
	static const bool do_times = true;		static const bool do_times = true;
	const eT val;		const eT val;
	const Mat<eT>& M;		const Mat<eT>& M;
	};		};
	template<typename T1>		template<typename eT>
	class partial_unwrap< eOp<T1, eop_scalar_times> >		class partial_unwrap< Op< subview_col<eT>, op_htrans2> >
	{		{
	public:		public:
	typedef typename T1::elem_type eT;
	inline		inline
	partial_unwrap(const eOp<T1,eop_scalar_times>& A)		partial_unwrap(const Op< subview_col<eT>, op_htrans2>& A)
	: val(A.aux)		: val( A.aux )
	, M (A.P.Q)		, M ( const_cast<eT*>( A.m.colptr(0) ), A.m.n_rows, 1, false, false )
	{
	arma_extra_debug_sigprint();
	}
	inline
	~partial_unwrap()
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline eT get_val() const { return val; }		inline eT get_val() const { return val; }
	static const bool do_trans = false;		static const bool do_trans = true;
	static const bool do_times = true;		static const bool do_times = true;
	const eT val;		const eT val;
	const Mat<eT> M;		const Mat<eT> M;
	};		};
	template<typename eT>		template<typename T1>
	class partial_unwrap< eOp<Mat<eT>, eop_scalar_times> >		struct partial_unwrap_scalar_times_default
	{		{
	public:		typedef typename T1::elem_type eT;
	inline		inline partial_unwrap_scalar_times_default(const eOp<T1, eop_scalar_times
	partial_unwrap(const eOp<Mat<eT>,eop_scalar_times>& A)		>& A)
	: val(A.aux)		: val(A.aux)
	, M (A.P.Q)		, M (A.P.Q)
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline		arma_hot arma_inline eT get_val() const { return val; }
	~partial_unwrap()
	{
	arma_extra_debug_sigprint();
	}
	inline eT get_val() const { return val; }
	static const bool do_trans = false;		static const bool do_trans = false;
	static const bool do_times = true;		static const bool do_times = true;
	const eT val;		const eT val;
			const Mat<eT> M;
			};
			template<typename T1>
			struct partial_unwrap_scalar_times_Mat_fixed
			{
			typedef typename T1::elem_type eT;
			inline explicit partial_unwrap_scalar_times_Mat_fixed(const eOp<T1, eop_s
			calar_times>& A)
			: val(A.aux)
			, M (A.P.Q)
			{
			arma_extra_debug_sigprint();
			}
			arma_hot arma_inline eT get_val() const { return val; }
			static const bool do_trans = false;
			static const bool do_times = true;
			const eT val;
	const Mat<eT>& M;		const Mat<eT>& M;
	};		};
			template<typename T1, bool condition>
			struct partial_unwrap_scalar_times_redirect {};
			template<typename T1>
			struct partial_unwrap_scalar_times_redirect<T1, false> { typedef partial_un
			wrap_scalar_times_default<T1> result; };
			template<typename T1>
			struct partial_unwrap_scalar_times_redirect<T1, true> { typedef partial_un
			wrap_scalar_times_Mat_fixed<T1> result; };
			template<typename T1>
			class partial_unwrap< eOp<T1, eop_scalar_times> > : public partial_unwrap_s
			calar_times_redirect<T1, is_Mat_fixed<T1>::value >::result
			{
			typedef typename T1::elem_type eT;
			public:
			inline partial_unwrap(const eOp<T1, eop_scalar_times>& A)
			: partial_unwrap_scalar_times_redirect< T1, is_Mat_fixed<T1>::value >::
			result(A)
			{
			}
			};
	template<typename eT>		template<typename eT>
	class partial_unwrap< eOp<Row<eT>, eop_scalar_times> >		class partial_unwrap< eOp<Mat<eT>, eop_scalar_times> >
	{		{
	public:		public:
	inline		inline
	partial_unwrap(const eOp<Row<eT>,eop_scalar_times>& A)		partial_unwrap(const eOp<Mat<eT>,eop_scalar_times>& A)
	: val(A.aux)		: val(A.aux)
	, M (A.P.Q)		, M (A.P.Q)
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
			inline eT get_val() const { return val; }
			static const bool do_trans = false;
			static const bool do_times = true;
			const eT val;
			const Mat<eT>& M;
			};
			template<typename eT>
			class partial_unwrap< eOp<Row<eT>, eop_scalar_times> >
			{
			public:
	inline		inline
	~partial_unwrap()		partial_unwrap(const eOp<Row<eT>,eop_scalar_times>& A)
			: val(A.aux)
			, M (A.P.Q)
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline eT get_val() const { return val; }		inline eT get_val() const { return val; }
	static const bool do_trans = false;		static const bool do_trans = false;
	static const bool do_times = true;		static const bool do_times = true;
	const eT val;		const eT val;
	skipping to change at line 761		skipping to change at line 914
	public:		public:
	inline		inline
	partial_unwrap(const eOp<Col<eT>,eop_scalar_times>& A)		partial_unwrap(const eOp<Col<eT>,eop_scalar_times>& A)
	: val(A.aux)		: val(A.aux)
	, M (A.P.Q)		, M (A.P.Q)
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline
	~partial_unwrap()
	{
	arma_extra_debug_sigprint();
	}
	inline eT get_val() const { return val; }		inline eT get_val() const { return val; }
	static const bool do_trans = false;		static const bool do_trans = false;
	static const bool do_times = true;		static const bool do_times = true;
	const eT val;		const eT val;
	const Mat<eT>& M;		const Mat<eT>& M;
	};		};
	//		//
	template<typename T1>		template<typename T1>
	class partial_unwrap_check		struct partial_unwrap_check_default
	{		{
	public:
	typedef typename T1::elem_type eT;		typedef typename T1::elem_type eT;
	arma_hot inline		inline partial_unwrap_check_default(const T1& A, const Mat<eT>&)
	partial_unwrap_check(const T1& A, const Mat<eT>&)
	: M(A)		: M(A)
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
			arma_hot arma_inline eT get_val() const { return eT(1); }
			static const bool do_trans = false;
			static const bool do_times = false;
			const Mat<eT> M;
			};
			template<typename T1>
			struct partial_unwrap_check_Mat_fixed
			{
			typedef typename T1::elem_type eT;
			inline explicit partial_unwrap_check_Mat_fixed(const T1& A, const Mat<eT>
			& B)
			: M_local( (&A == &B) ? new Mat<eT>(A) : 0 )
			, M ( (&A == &B) ? (*M_local) : A )
			{
			arma_extra_debug_sigprint();
			}
	inline		inline
	~partial_unwrap_check()		~partial_unwrap_check_Mat_fixed()
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
			if(M_local) { delete M_local; }
	}		}
	arma_hot arma_inline eT get_val() const { return eT(1); }		arma_hot arma_inline eT get_val() const { return eT(1); }
	static const bool do_trans = false;		static const bool do_trans = false;
	static const bool do_times = false;		static const bool do_times = false;
	const Mat<eT> M;		const Mat<eT>* M_local;
			const Mat<eT>& M;
			};
			template<typename T1, bool condition>
			struct partial_unwrap_check_redirect {};
			template<typename T1>
			struct partial_unwrap_check_redirect<T1, false> { typedef partial_unwrap_ch
			eck_default<T1> result; };
			template<typename T1>
			struct partial_unwrap_check_redirect<T1, true> { typedef partial_unwrap_ch
			eck_Mat_fixed<T1> result; };
			template<typename T1>
			class partial_unwrap_check : public partial_unwrap_check_redirect<T1, is_Ma
			t_fixed<T1>::value >::result
			{
			typedef typename T1::elem_type eT;
			public:
			inline partial_unwrap_check(const T1& A, const Mat<eT>& B)
			: partial_unwrap_check_redirect< T1, is_Mat_fixed<T1>::value >::result(
			A, B)
			{
			}
	};		};
	template<typename eT>		template<typename eT>
	class partial_unwrap_check< Mat<eT> >		class partial_unwrap_check< Mat<eT> >
	{		{
	public:		public:
	arma_hot inline		arma_hot inline
	partial_unwrap_check(const Mat<eT>& A, const Mat<eT>& B)		partial_unwrap_check(const Mat<eT>& A, const Mat<eT>& B)
	: M_local ( (&A == &B) ? new Mat<eT>(A) : 0 )		: M_local ( (&A == &B) ? new Mat<eT>(A) : 0 )
	, M ( (&A == &B) ? (*M_local) : A )		, M ( (&A == &B) ? (*M_local) : A )
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline		inline
	~partial_unwrap_check()		~partial_unwrap_check()
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	if(M_local)		if(M_local) { delete M_local; }
	{
	delete M_local;
	}
	}		}
	arma_hot arma_inline eT get_val() const { return eT(1); }		arma_hot arma_inline eT get_val() const { return eT(1); }
	static const bool do_trans = false;		static const bool do_trans = false;
	static const bool do_times = false;		static const bool do_times = false;
	// the order below is important		// the order below is important
	const Mat<eT>* M_local;		const Mat<eT>* M_local;
	const Mat<eT>& M;		const Mat<eT>& M;
	skipping to change at line 858		skipping to change at line 1043
	, M ( (&A == &B) ? (*M_local) : A )		, M ( (&A == &B) ? (*M_local) : A )
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline		inline
	~partial_unwrap_check()		~partial_unwrap_check()
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	if(M_local)		if(M_local) { delete M_local; }
	{
	delete M_local;
	}
	}		}
	arma_hot arma_inline eT get_val() const { return eT(1); }		arma_hot arma_inline eT get_val() const { return eT(1); }
	static const bool do_trans = false;		static const bool do_trans = false;
	static const bool do_times = false;		static const bool do_times = false;
	// the order below is important		// the order below is important
	const Mat<eT>* M_local;		const Mat<eT>* M_local;
	const Mat<eT>& M;		const Mat<eT>& M;
	skipping to change at line 892		skipping to change at line 1074
	, M ( (&A == &B) ? (*M_local) : A )		, M ( (&A == &B) ? (*M_local) : A )
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline		inline
	~partial_unwrap_check()		~partial_unwrap_check()
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	if(M_local)		if(M_local) { delete M_local; }
	{
	delete M_local;
	}
	}		}
	arma_hot arma_inline eT get_val() const { return eT(1); }		arma_hot arma_inline eT get_val() const { return eT(1); }
	static const bool do_trans = false;		static const bool do_trans = false;
	static const bool do_times = false;		static const bool do_times = false;
	// the order below is important		// the order below is important
	const Mat<eT>* M_local;		const Mat<eT>* M_local;
	const Mat<eT>& M;		const Mat<eT>& M;
	};		};
	template<typename T1>		template<typename eT>
	class partial_unwrap_check< Op<T1, op_htrans> >		class partial_unwrap_check< subview_col<eT> >
	{		{
	public:		public:
			arma_hot inline
			partial_unwrap_check(const subview_col<eT>& A, const Mat<eT>& B)
			: M( const_cast<eT*>( A.colptr(0) ), A.n_rows, 1, (&(A.m) == &B), false
			)
			{
			arma_extra_debug_sigprint();
			}
			arma_hot arma_inline eT get_val() const { return eT(1); }
			static const bool do_trans = false;
			static const bool do_times = false;
			const Mat<eT> M;
			};
			template<typename T1>
			struct partial_unwrap_check_htrans_default
			{
	typedef typename T1::elem_type eT;		typedef typename T1::elem_type eT;
	arma_hot inline		inline partial_unwrap_check_htrans_default(const Op<T1, op_htrans>& A, co
	partial_unwrap_check(const Op<T1,op_htrans>& A, const Mat<eT>&)		nst Mat<eT>&)
	: M(A.m)		: M(A.m)
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
			arma_hot arma_inline eT get_val() const { return eT(1); }
			static const bool do_trans = true;
			static const bool do_times = false;
			const Mat<eT> M;
			};
			template<typename T1>
			struct partial_unwrap_check_htrans_Mat_fixed
			{
			typedef typename T1::elem_type eT;
			inline explicit partial_unwrap_check_htrans_Mat_fixed(const Op<T1, op_htr
			ans>& A, const Mat<eT>& B)
			: M_local( (&(A.m) == &B) ? new Mat<eT>(A.m) : 0 )
			, M ( (&(A.m) == &B) ? (*M_local) : A.m )
			{
			arma_extra_debug_sigprint();
			}
	inline		inline
	~partial_unwrap_check()		~partial_unwrap_check_htrans_Mat_fixed()
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
			if(M_local) { delete M_local; }
	}		}
	arma_hot arma_inline eT get_val() const { return eT(1); }		arma_hot arma_inline eT get_val() const { return eT(1); }
	static const bool do_trans = true;		static const bool do_trans = true;
	static const bool do_times = false;		static const bool do_times = false;
	const Mat<eT> M;		const Mat<eT>* M_local;
			const Mat<eT>& M;
			};
			template<typename T1, bool condition>
			struct partial_unwrap_check_htrans_redirect {};
			template<typename T1>
			struct partial_unwrap_check_htrans_redirect<T1, false> { typedef partial_un
			wrap_check_htrans_default<T1> result; };
			template<typename T1>
			struct partial_unwrap_check_htrans_redirect<T1, true> { typedef partial_un
			wrap_check_htrans_Mat_fixed<T1> result; };
			template<typename T1>
			class partial_unwrap_check< Op<T1, op_htrans> > : public partial_unwrap_che
			ck_htrans_redirect<T1, is_Mat_fixed<T1>::value >::result
			{
			typedef typename T1::elem_type eT;
			public:
			inline partial_unwrap_check(const Op<T1, op_htrans>& A, const Mat<eT>& B)
			: partial_unwrap_check_htrans_redirect< T1, is_Mat_fixed<T1>::value >::
			result(A, B)
			{
			}
	};		};
	template<typename eT>		template<typename eT>
	class partial_unwrap_check< Op< Mat<eT>, op_htrans> >		class partial_unwrap_check< Op< Mat<eT>, op_htrans> >
	{		{
	public:		public:
	arma_hot inline		arma_hot inline
	partial_unwrap_check(const Op< Mat<eT>, op_htrans>& A, const Mat<eT>& B)		partial_unwrap_check(const Op< Mat<eT>, op_htrans>& A, const Mat<eT>& B)
	: M_local ( (&A.m == &B) ? new Mat<eT>(A.m) : 0 )		: M_local ( (&A.m == &B) ? new Mat<eT>(A.m) : 0 )
	, M ( (&A.m == &B) ? (*M_local) : A.m )		, M ( (&A.m == &B) ? (*M_local) : A.m )
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline		inline
	~partial_unwrap_check()		~partial_unwrap_check()
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	if(M_local)		if(M_local) { delete M_local; }
	{
	delete M_local;
	}
	}		}
	arma_hot arma_inline eT get_val() const { return eT(1); }		arma_hot arma_inline eT get_val() const { return eT(1); }
	static const bool do_trans = true;		static const bool do_trans = true;
	static const bool do_times = false;		static const bool do_times = false;
	// the order below is important		// the order below is important
	const Mat<eT>* M_local;		const Mat<eT>* M_local;
	const Mat<eT>& M;		const Mat<eT>& M;
	skipping to change at line 988		skipping to change at line 1225
	, M ( (&A.m == &B) ? (*M_local) : A.m )		, M ( (&A.m == &B) ? (*M_local) : A.m )
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline		inline
	~partial_unwrap_check()		~partial_unwrap_check()
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	if(M_local)		if(M_local) { delete M_local; }
	{
	delete M_local;
	}
	}		}
	arma_hot arma_inline eT get_val() const { return eT(1); }		arma_hot arma_inline eT get_val() const { return eT(1); }
	static const bool do_trans = true;		static const bool do_trans = true;
	static const bool do_times = false;		static const bool do_times = false;
	// the order below is important		// the order below is important
	const Mat<eT>* M_local;		const Mat<eT>* M_local;
	const Mat<eT>& M;		const Mat<eT>& M;
	skipping to change at line 1022		skipping to change at line 1256
	, M ( (&A.m == &B) ? (*M_local) : A.m )		, M ( (&A.m == &B) ? (*M_local) : A.m )
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline		inline
	~partial_unwrap_check()		~partial_unwrap_check()
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	if(M_local)		if(M_local) { delete M_local; }
	{
	delete M_local;
	}
	}		}
	arma_hot arma_inline eT get_val() const { return eT(1); }		arma_hot arma_inline eT get_val() const { return eT(1); }
	static const bool do_trans = true;		static const bool do_trans = true;
	static const bool do_times = false;		static const bool do_times = false;
	// the order below is important		// the order below is important
	const Mat<eT>* M_local;		const Mat<eT>* M_local;
	const Mat<eT>& M;		const Mat<eT>& M;
	};		};
	template<typename T1>		template<typename eT>
	class partial_unwrap_check< Op<T1, op_htrans2> >		class partial_unwrap_check< Op< subview_col<eT>, op_htrans> >
	{		{
	public:		public:
			arma_hot inline
			partial_unwrap_check(const Op< subview_col<eT>, op_htrans>& A, const Mat<
			eT>& B)
			: M( const_cast<eT*>( A.m.colptr(0) ), A.m.n_rows, 1, (&(A.m.m) == &B),
			false )
			{
			arma_extra_debug_sigprint();
			}
			arma_hot arma_inline eT get_val() const { return eT(1); }
			static const bool do_trans = true;
			static const bool do_times = false;
			const Mat<eT> M;
			};
			template<typename T1>
			struct partial_unwrap_check_htrans2_default
			{
	typedef typename T1::elem_type eT;		typedef typename T1::elem_type eT;
	arma_hot inline		inline partial_unwrap_check_htrans2_default(const Op<T1, op_htrans2>& A,
	partial_unwrap_check(const Op<T1,op_htrans2>& A, const Mat<eT>&)		const Mat<eT>&)
	: val(A.aux)		: val(A.aux)
	, M (A.m)		, M (A.m)
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
			arma_hot arma_inline eT get_val() const { return val; }
			static const bool do_trans = true;
			static const bool do_times = true;
			const eT val;
			const Mat<eT> M;
			};
			template<typename T1>
			struct partial_unwrap_check_htrans2_Mat_fixed
			{
			typedef typename T1::elem_type eT;
			inline explicit partial_unwrap_check_htrans2_Mat_fixed(const Op<T1, op_ht
			rans2>& A, const Mat<eT>& B)
			: val (A.aux)
			, M_local( (&(A.m) == &B) ? new Mat<eT>(A.m) : 0 )
			, M ( (&(A.m) == &B) ? (*M_local) : A.m )
			{
			arma_extra_debug_sigprint();
			}
	inline		inline
	~partial_unwrap_check()		~partial_unwrap_check_htrans2_Mat_fixed()
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
			if(M_local) { delete M_local; }
	}		}
	arma_hot arma_inline eT get_val() const { return val; }		arma_hot arma_inline eT get_val() const { return val; }
	static const bool do_trans = true;		static const bool do_trans = true;
	static const bool do_times = true;		static const bool do_times = true;
	const eT val;		const eT val;
	const Mat<eT> M;		const Mat<eT>* M_local;
			const Mat<eT>& M;
			};
			template<typename T1, bool condition>
			struct partial_unwrap_check_htrans2_redirect {};
			template<typename T1>
			struct partial_unwrap_check_htrans2_redirect<T1, false> { typedef partial_u
			nwrap_check_htrans2_default<T1> result; };
			template<typename T1>
			struct partial_unwrap_check_htrans2_redirect<T1, true> { typedef partial_u
			nwrap_check_htrans2_Mat_fixed<T1> result; };
			template<typename T1>
			class partial_unwrap_check< Op<T1, op_htrans2> > : public partial_unwrap_ch
			eck_htrans2_redirect<T1, is_Mat_fixed<T1>::value >::result
			{
			typedef typename T1::elem_type eT;
			public:
			inline partial_unwrap_check(const Op<T1, op_htrans2>& A, const Mat<eT>& B
			)
			: partial_unwrap_check_htrans2_redirect< T1, is_Mat_fixed<T1>::value >:
			:result(A, B)
			{
			}
	};		};
	template<typename eT>		template<typename eT>
	class partial_unwrap_check< Op< Mat<eT>, op_htrans2> >		class partial_unwrap_check< Op< Mat<eT>, op_htrans2> >
	{		{
	public:		public:
	arma_hot inline		arma_hot inline
	partial_unwrap_check(const Op< Mat<eT>, op_htrans2>& A, const Mat<eT>& B)		partial_unwrap_check(const Op< Mat<eT>, op_htrans2>& A, const Mat<eT>& B)
	: val (A.aux)		: val (A.aux)
	skipping to change at line 1087		skipping to change at line 1381
	, M ( (&A.m == &B) ? (*M_local) : A.m )		, M ( (&A.m == &B) ? (*M_local) : A.m )
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline		inline
	~partial_unwrap_check()		~partial_unwrap_check()
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	if(M_local)		if(M_local) { delete M_local; }
	{
	delete M_local;
	}
	}		}
	arma_hot arma_inline eT get_val() const { return val; }		arma_hot arma_inline eT get_val() const { return val; }
	static const bool do_trans = true;		static const bool do_trans = true;
	static const bool do_times = true;		static const bool do_times = true;
	// the order below is important		// the order below is important
	const eT val;		const eT val;
	const Mat<eT>* M_local;		const Mat<eT>* M_local;
	skipping to change at line 1123		skipping to change at line 1414
	, M ( (&A.m == &B) ? (*M_local) : A.m )		, M ( (&A.m == &B) ? (*M_local) : A.m )
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline		inline
	~partial_unwrap_check()		~partial_unwrap_check()
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	if(M_local)		if(M_local) { delete M_local; }
	{
	delete M_local;
	}
	}		}
	arma_hot arma_inline eT get_val() const { return val; }		arma_hot arma_inline eT get_val() const { return val; }
	static const bool do_trans = true;		static const bool do_trans = true;
	static const bool do_times = true;		static const bool do_times = true;
	// the order below is important		// the order below is important
	const eT val;		const eT val;
	const Mat<eT>* M_local;		const Mat<eT>* M_local;
	const Mat<eT>& M;		const Mat<eT>& M;
	};		};
	template<typename eT>		template<typename eT>
	class partial_unwrap_check< Op< Col<eT>, op_htrans2> >		class partial_unwrap_check< Op< Col<eT>, op_htrans2> >
	{		{
	public:		public:
	arma_hot inline		arma_hot inline
	partial_unwrap_check(const Op< Mat<eT>, op_htrans2>& A, const Mat<eT>& B)		partial_unwrap_check(const Op< Col<eT>, op_htrans2>& A, const Mat<eT>& B)
	: val (A.aux)		: val (A.aux)
	, M_local ( (&A.m == &B) ? new Mat<eT>(A.m) : 0 )		, M_local ( (&A.m == &B) ? new Mat<eT>(A.m) : 0 )
	, M ( (&A.m == &B) ? (*M_local) : A.m )		, M ( (&A.m == &B) ? (*M_local) : A.m )
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline		inline
	~partial_unwrap_check()		~partial_unwrap_check()
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	if(M_local)		if(M_local) { delete M_local; }
	{
	delete M_local;
	}
	}		}
	arma_hot arma_inline eT get_val() const { return val; }		arma_hot arma_inline eT get_val() const { return val; }
	static const bool do_trans = true;		static const bool do_trans = true;
	static const bool do_times = true;		static const bool do_times = true;
	// the order below is important		// the order below is important
	const eT val;		const eT val;
	const Mat<eT>* M_local;		const Mat<eT>* M_local;
	const Mat<eT>& M;		const Mat<eT>& M;
	};		};
	template<typename T1>		template<typename eT>
	class partial_unwrap_check< eOp<T1, eop_scalar_times> >		class partial_unwrap_check< Op< subview_col<eT>, op_htrans2> >
	{		{
	public:		public:
			arma_hot inline
			partial_unwrap_check(const Op< subview_col<eT>, op_htrans2>& A, const Mat
			<eT>& B)
			: val( A.aux )
			, M ( const_cast<eT*>( A.m.colptr(0) ), A.m.n_rows, 1, (&(A.m.m) == &B
			), false )
			{
			arma_extra_debug_sigprint();
			}
			arma_hot arma_inline eT get_val() const { return val; }
			static const bool do_trans = true;
			static const bool do_times = true;
			const eT val;
			const Mat<eT> M;
			};
			template<typename T1>
			struct partial_unwrap_check_scalar_times_default
			{
	typedef typename T1::elem_type eT;		typedef typename T1::elem_type eT;
	arma_hot inline		inline partial_unwrap_check_scalar_times_default(const eOp<T1, eop_scalar
	partial_unwrap_check(const eOp<T1,eop_scalar_times>& A, const Mat<eT>&)		_times>& A, const Mat<eT>&)
	: val(A.aux)		: val(A.aux)
	, M (A.P.Q)		, M (A.P.Q)
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
			arma_hot arma_inline eT get_val() const { return val; }
			static const bool do_trans = false;
			static const bool do_times = true;
			const eT val;
			const Mat<eT> M;
			};
			template<typename T1>
			struct partial_unwrap_check_scalar_times_Mat_fixed
			{
			typedef typename T1::elem_type eT;
			inline explicit partial_unwrap_check_scalar_times_Mat_fixed(const eOp<T1,
			eop_scalar_times>& A, const Mat<eT>& B)
			: val ( A.aux )
			, M_local( (&(A.P.Q) == &B) ? new Mat<eT>(A.P.Q) : 0 )
			, M ( (&(A.P.Q) == &B) ? (*M_local) : A.P.Q )
			{
			arma_extra_debug_sigprint();
			}
	inline		inline
	~partial_unwrap_check()		~partial_unwrap_check_scalar_times_Mat_fixed()
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
			if(M_local) { delete M_local; }
	}		}
	arma_hot arma_inline eT get_val() const { return val; }		arma_hot arma_inline eT get_val() const { return val; }
	static const bool do_trans = false;		static const bool do_trans = false;
	static const bool do_times = true;		static const bool do_times = true;
	const eT val;		const eT val;
	const Mat<eT> M;		const Mat<eT>* M_local;
			const Mat<eT>& M;
			};
			template<typename T1, bool condition>
			struct partial_unwrap_check_scalar_times_redirect {};
			template<typename T1>
			struct partial_unwrap_check_scalar_times_redirect<T1, false> { typedef part
			ial_unwrap_check_scalar_times_default<T1> result; };
			template<typename T1>
			struct partial_unwrap_check_scalar_times_redirect<T1, true> { typedef part
			ial_unwrap_check_scalar_times_Mat_fixed<T1> result; };
			template<typename T1>
			class partial_unwrap_check< eOp<T1, eop_scalar_times> > : public partial_un
			wrap_check_scalar_times_redirect<T1, is_Mat_fixed<T1>::value >::result
			{
			typedef typename T1::elem_type eT;
			public:
			inline partial_unwrap_check(const eOp<T1, eop_scalar_times>& A, const Mat
			<eT>& B)
			: partial_unwrap_check_scalar_times_redirect< T1, is_Mat_fixed<T1>::val
			ue >::result(A, B)
			{
			}
	};		};
	template<typename eT>		template<typename eT>
	class partial_unwrap_check< eOp<Mat<eT>, eop_scalar_times> >		class partial_unwrap_check< eOp<Mat<eT>, eop_scalar_times> >
	{		{
	public:		public:
	arma_hot inline		arma_hot inline
	partial_unwrap_check(const eOp<Mat<eT>,eop_scalar_times>& A, const Mat<eT		partial_unwrap_check(const eOp<Mat<eT>,eop_scalar_times>& A, const Mat<eT
	>&)		>& B)
	: val(A.aux)		: val (A.aux)
	, M (A.P.Q)		, M_local( (&(A.P.Q) == &B) ? new Mat<eT>(A.P.Q) : 0 )
			, M ( (&(A.P.Q) == &B) ? *M_local : A.P.Q )
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline		inline
	~partial_unwrap_check()		~partial_unwrap_check()
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
			if(M_local) { delete M_local; }
	}		}
	arma_hot arma_inline eT get_val() const { return val; }		arma_hot arma_inline eT get_val() const { return val; }
	static const bool do_trans = false;		static const bool do_trans = false;
	static const bool do_times = true;		static const bool do_times = true;
	const eT val;		const eT val;
			const Mat<eT>* M_local;
	const Mat<eT>& M;		const Mat<eT>& M;
	};		};
	template<typename eT>		template<typename eT>
	class partial_unwrap_check< eOp<Row<eT>, eop_scalar_times> >		class partial_unwrap_check< eOp<Row<eT>, eop_scalar_times> >
	{		{
	public:		public:
	arma_hot inline		arma_hot inline
	partial_unwrap_check(const eOp<Row<eT>,eop_scalar_times>& A, const Mat<eT >&)		partial_unwrap_check(const eOp<Row<eT>,eop_scalar_times>& A, const Mat<eT >& B)
	: val(A.aux)		: val(A.aux)
	, M (A.P.Q)		, M_local( (&(A.P.Q) == &B) ? new Mat<eT>(A.P.Q) : 0 )
			, M ( (&(A.P.Q) == &B) ? *M_local : A.P.Q )
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline		inline
	~partial_unwrap_check()		~partial_unwrap_check()
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
			if(M_local) { delete M_local; }
	}		}
	arma_hot arma_inline eT get_val() const { return val; }		arma_hot arma_inline eT get_val() const { return val; }
	static const bool do_trans = false;		static const bool do_trans = false;
	static const bool do_times = true;		static const bool do_times = true;
	const eT val;		const eT val;
			const Mat<eT>* M_local;
	const Mat<eT>& M;		const Mat<eT>& M;
	};		};
	template<typename eT>		template<typename eT>
	class partial_unwrap_check< eOp<Col<eT>, eop_scalar_times> >		class partial_unwrap_check< eOp<Col<eT>, eop_scalar_times> >
	{		{
	public:		public:
	arma_hot inline		arma_hot inline
	partial_unwrap_check(const eOp<Col<eT>,eop_scalar_times>& A, const Mat<eT		partial_unwrap_check(const eOp<Col<eT>,eop_scalar_times>& A, const Mat<eT
	>&)		>& B)
	: val(A.aux)		: val ( A.aux )
	, M (A.P.Q)		, M_local( (&(A.P.Q) == &B) ? new Mat<eT>(A.P.Q) : 0 )
			, M ( (&(A.P.Q) == &B) ? *M_local : A.P.Q )
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
	}		}
	inline		inline
	~partial_unwrap_check()		~partial_unwrap_check()
	{		{
	arma_extra_debug_sigprint();		arma_extra_debug_sigprint();
			if(M_local) { delete M_local; }
	}		}
	arma_hot arma_inline eT get_val() const { return val; }		arma_hot arma_inline eT get_val() const { return val; }
	static const bool do_trans = false;		static const bool do_trans = false;
	static const bool do_times = true;		static const bool do_times = true;
	const eT val;		const eT val;
			const Mat<eT>* M_local;
	const Mat<eT>& M;		const Mat<eT>& M;
	};		};
			template<typename eT>
			class partial_unwrap_check< eOp<subview_col<eT>, eop_scalar_times> >
			{
			public:
			arma_hot inline
			partial_unwrap_check(const eOp<subview_col<eT>,eop_scalar_times>& A, cons
			t Mat<eT>& B)
			: val( A.aux )
			, M ( const_cast<eT*>( A.P.Q.colptr(0) ), A.P.Q.n_rows, 1, (&(A.P.Q.m)
			== &B), false )
			{
			arma_extra_debug_sigprint();
			}
			arma_hot arma_inline eT get_val() const { return val; }
			static const bool do_trans = false;
			static const bool do_times = true;
			const eT val;
			const Mat<eT> M;
			};
	//! @}		//! @}
End of changes. 110 change blocks.
	225 lines changed or deleted		661 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/