www.pudn.com > Image_segment.rar > Functions.cpp

//Copyright (c) 2004-2005, Baris Sumengen 
//All rights reserved. 
// 
// CIMPL Matrix Performance Library 
// 
//Redistribution and use in source and binary 
//forms, with or without modification, are 
//permitted provided that the following 
//conditions are met: 
// 
//    * No commercial use is allowed.  
//    This software can only be used 
//    for non-commercial purposes. This  
//    distribution is mainly intended for 
//    academic research and teaching. 
//    * Redistributions of source code must 
//    retain the above copyright notice, this 
//    list of conditions and the following 
//    disclaimer. 
//    * Redistributions of binary form must 
//    mention the above copyright notice, this 
//    list of conditions and the following 
//    disclaimer in a clearly visible part  
//    in associated product manual,  
//    readme, and web site of the redistributed  
//    software. 
//    * Redistributions in binary form must 
//    reproduce the above copyright notice, 
//    this list of conditions and the 
//    following disclaimer in the 
//    documentation and/or other materials 
//    provided with the distribution. 
//    * The name of Baris Sumengen may not be 
//    used to endorse or promote products 
//    derived from this software without 
//    specific prior written permission. 
// 
//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT 
//HOLDERS AND CONTRIBUTORS "AS IS" AND ANY 
//EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT 
//NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
//MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
//PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
//CONTRIBUTORS BE LIABLE FOR ANY 
//DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
//EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
//(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
//OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 
//DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
//HOWEVER CAUSED AND ON ANY THEORY OF 
//LIABILITY, WHETHER IN CONTRACT, STRICT 
//LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
//OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
//OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
//POSSIBILITY OF SUCH DAMAGE. 
 
 
 
#include "./Functions.h" 
#include "mkl_vml.h" 
 
 
namespace MathCore 
{ 
 
	// Inverts elements 
	Vector Inv(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vsInv(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
 
 
	Vector Inv(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vdInv(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Inv(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vsInv(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
 
	Matrix Inv(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vdInv(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
 
 
	Vector& InvI(Vector& m) 
	{ 
		vsInv(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
 
	Vector& InvI(Vector& m) 
	{ 
		vdInv(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
 
	Matrix& InvI(Matrix& m) 
	{ 
		vsInv(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
 
	Matrix& InvI(Matrix& m) 
	{ 
		vdInv(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
 
 
	// Division of elements 
	Vector Div(Vector& m1, Vector& m2) 
	{ 
		if(m1.Length() != m2.Length()) 
		{ 
			cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl; 
			Utility::RunTimeError("Vector lengths are not the same!"); 
		} 
		 
		Vector temp(m1.Length()); 
		vsDiv(m1.Length(), m1.Data(), m2.Data(), temp.Data()); 
		return temp; 
	} 
 
	Vector Div(Vector& m1, Vector& m2) 
	{ 
		if(m1.Length() != m2.Length()) 
		{ 
			cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl; 
			Utility::RunTimeError("Vector lengths are not the same!"); 
		} 
		 
		Vector temp(m1.Length()); 
		vdDiv(m1.Length(), m1.Data(), m2.Data(), temp.Data()); 
		return temp; 
	} 
 
	Matrix Div(Matrix& m1, Matrix& m2) 
	{ 
		if(m1.Rows() != m2.Rows() || m1.Columns() != m2.Columns()) 
		{ 
			cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl; 
			Utility::RunTimeError("Matrix dimensions does not match!"); 
		} 
		 
		Matrix temp(m1.Rows(), m1.Columns()); 
		vsDiv(m1.Length(), m1.Data(), m2.Data(), temp.Data()); 
		return temp; 
	} 
 
	Matrix Div(Matrix& m1, Matrix& m2) 
	{ 
		if(m1.Rows() != m2.Rows() || m1.Columns() != m2.Columns()) 
		{ 
			cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl; 
			Utility::RunTimeError("Matrix dimensions does not match!"); 
		} 
		 
		Matrix temp(m1.Rows(), m1.Columns()); 
		vdDiv(m1.Length(), m1.Data(), m2.Data(), temp.Data()); 
		return temp; 
	} 
 
 
	Vector& DivI(Vector& m1, Vector& m2) 
	{ 
		if(m1.Length() != m2.Length()) 
		{ 
			cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl; 
			Utility::RunTimeError("Vector lengths are not the same!"); 
		} 
		 
		vsDiv(m1.Length(), m1.Data(), m2.Data(), m1.Data()); 
		return m1; 
	} 
 
	Vector& DivI(Vector& m1, Vector& m2) 
	{ 
		if(m1.Length() != m2.Length()) 
		{ 
			cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl; 
			Utility::RunTimeError("Vector lengths are not the same!"); 
		} 
		 
		vdDiv(m1.Length(), m1.Data(), m2.Data(), m1.Data()); 
		return m1; 
	} 
 
	Matrix& DivI(Matrix& m1, Matrix& m2) 
	{ 
		if(m1.Rows() != m2.Rows() || m1.Columns() != m2.Columns()) 
		{ 
			cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl; 
			Utility::RunTimeError("Matrix dimensions does not match!"); 
		} 
		 
		vsDiv(m1.Length(), m1.Data(), m2.Data(), m1.Data()); 
		return m1; 
	} 
 
	Matrix& DivI(Matrix& m1, Matrix& m2) 
	{ 
		if(m1.Rows() != m2.Rows() || m1.Columns() != m2.Columns()) 
		{ 
			cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl; 
			Utility::RunTimeError("Matrix dimensions does not match!"); 
		} 
		 
		vdDiv(m1.Length(), m1.Data(), m2.Data(), m1.Data()); 
		return m1; 
	} 
 
 
	// Square root of elements 
	Vector Sqrt(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vsSqrt(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
 
	Vector Sqrt(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vdSqrt(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
 
	Matrix Sqrt(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vsSqrt(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
 
	Matrix Sqrt(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vdSqrt(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
 
 
	Vector& SqrtI(Vector& m) 
	{ 
		vsSqrt(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
 
	Vector& SqrtI(Vector& m) 
	{ 
		vdSqrt(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
 
	Matrix& SqrtI(Matrix& m) 
	{ 
		vsSqrt(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
 
	Matrix& SqrtI(Matrix& m) 
	{ 
		vdSqrt(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
 
 
	// Inverse Square root of elements 
	Vector InvSqrt(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vsInvSqrt(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
 
	Vector InvSqrt(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vdInvSqrt(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
 
	Matrix InvSqrt(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vsInvSqrt(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
 
	Matrix InvSqrt(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vdInvSqrt(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
 
 
	Vector& InvSqrtI(Vector& m) 
	{ 
		vsInvSqrt(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
 
	Vector& InvSqrtI(Vector& m) 
	{ 
		vdInvSqrt(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
 
	Matrix& InvSqrtI(Matrix& m) 
	{ 
		vsInvSqrt(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
 
	Matrix& InvSqrtI(Matrix& m) 
	{ 
		vdInvSqrt(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
 
 
	// Cube root of elements 
	Vector Cbrt(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vsCbrt(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Vector Cbrt(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vdCbrt(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Cbrt(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vsCbrt(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Cbrt(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vdCbrt(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	 
	Vector& CbrtI(Vector& m) 
	{ 
		vsCbrt(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Vector& CbrtI(Vector& m) 
	{ 
		vdCbrt(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& CbrtI(Matrix& m) 
	{ 
		vsCbrt(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& CbrtI(Matrix& m) 
	{ 
		vdCbrt(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
 
	// Cube root of elements 
	Vector InvCbrt(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vsInvCbrt(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Vector InvCbrt(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vdInvCbrt(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix InvCbrt(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vsInvCbrt(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix InvCbrt(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vdInvCbrt(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	 
	Vector& InvCbrtI(Vector& m) 
	{ 
		vsInvCbrt(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Vector& InvCbrtI(Vector& m) 
	{ 
		vdInvCbrt(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& InvCbrtI(Matrix& m) 
	{ 
		vsInvCbrt(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& InvCbrtI(Matrix& m) 
	{ 
		vdInvCbrt(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	 
	// Pow of elements 
	Vector Pow(Vector& m1, Vector& m2) 
	{ 
		if(m1.Length() != m2.Length()) 
		{ 
			cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl; 
			Utility::RunTimeError("Vector lengths are not the same!"); 
		} 
		 
		Vector temp(m1.Length()); 
		vsPow(m1.Length(), m1.Data(), m2.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Vector Pow(Vector& m1, Vector& m2) 
	{ 
		if(m1.Length() != m2.Length()) 
		{ 
			cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl; 
			Utility::RunTimeError("Vector lengths are not the same!"); 
		} 
		 
		Vector temp(m1.Length()); 
		vdPow(m1.Length(), m1.Data(), m2.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Pow(Matrix& m1, Matrix& m2) 
	{ 
		if(m1.Rows() != m2.Rows() || m1.Columns() != m2.Columns()) 
		{ 
			cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl; 
			Utility::RunTimeError("Matrix dimensions does not match!"); 
		} 
		 
		Matrix temp(m1.Rows(), m1.Columns()); 
		vsPow(m1.Length(), m1.Data(), m2.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Pow(Matrix& m1, Matrix& m2) 
	{ 
		if(m1.Rows() != m2.Rows() || m1.Columns() != m2.Columns()) 
		{ 
			cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl; 
			Utility::RunTimeError("Matrix dimensions does not match!"); 
		} 
		 
		Matrix temp(m1.Rows(), m1.Columns()); 
		vdPow(m1.Length(), m1.Data(), m2.Data(), temp.Data()); 
		return temp; 
	} 
	 
	 
	Vector& PowI(Vector& m1, Vector& m2) 
	{ 
		if(m1.Length() != m2.Length()) 
		{ 
			cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl; 
			Utility::RunTimeError("Vector lengths are not the same!"); 
		} 
		 
		vsPow(m1.Length(), m1.Data(), m2.Data(), m1.Data()); 
		return m1; 
	} 
	 
	Vector& PowI(Vector& m1, Vector& m2) 
	{ 
		if(m1.Length() != m2.Length()) 
		{ 
			cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl; 
			Utility::RunTimeError("Vector lengths are not the same!"); 
		} 
		 
		vdPow(m1.Length(), m1.Data(), m2.Data(), m1.Data()); 
		return m1; 
	} 
	 
	Matrix& PowI(Matrix& m1, Matrix& m2) 
	{ 
		if(m1.Rows() != m2.Rows() || m1.Columns() != m2.Columns()) 
		{ 
			cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl; 
			Utility::RunTimeError("Matrix dimensions does not match!"); 
		} 
		 
		vsPow(m1.Length(), m1.Data(), m2.Data(), m1.Data()); 
		return m1; 
	} 
	 
	Matrix& PowI(Matrix& m1, Matrix& m2) 
	{ 
		if(m1.Rows() != m2.Rows() || m1.Columns() != m2.Columns()) 
		{ 
			cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl; 
			Utility::RunTimeError("Matrix dimensions does not match!"); 
		} 
		 
		vdPow(m1.Length(), m1.Data(), m2.Data(), m1.Data()); 
		return m1; 
	} 
	 
	 
	// Pow of vector elements to a constant 
	Vector Powx(Vector& m1, const float m2) 
	{ 
		Vector temp(m1.Length()); 
		vsPowx(m1.Length(), m1.Data(), m2, temp.Data()); 
		return temp; 
	} 
	 
	Vector Powx(Vector& m1, const double m2) 
	{ 
		Vector temp(m1.Length()); 
		vdPowx(m1.Length(), m1.Data(), m2, temp.Data()); 
		return temp; 
	} 
	 
	Matrix Powx(Matrix& m1, const float m2) 
	{ 
		Matrix temp(m1.Rows(), m1.Columns()); 
		vsPowx(m1.Length(), m1.Data(), m2, temp.Data()); 
		return temp; 
	} 
	 
	Matrix Powx(Matrix& m1, const double m2) 
	{ 
		Matrix temp(m1.Rows(), m1.Columns()); 
		vdPowx(m1.Length(), m1.Data(), m2, temp.Data()); 
		return temp; 
	} 
	 
	 
	Vector& PowxI(Vector& m1, const float m2) 
	{ 
		vsPowx(m1.Length(), m1.Data(), m2, m1.Data()); 
		return m1; 
	} 
	 
	Vector& PowxI(Vector& m1, const double m2) 
	{ 
		vdPowx(m1.Length(), m1.Data(), m2, m1.Data()); 
		return m1; 
	} 
	 
	Matrix& PowxI(Matrix& m1, const float m2) 
	{ 
		vsPowx(m1.Length(), m1.Data(), m2, m1.Data()); 
		return m1; 
	} 
	 
	Matrix& PowxI(Matrix& m1, const double m2) 
	{ 
		vdPowx(m1.Length(), m1.Data(), m2, m1.Data()); 
		return m1; 
	} 
	 
	 
	 
	 
	// Exponent of elements 
	Vector Exp(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vsExp(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Vector Exp(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vdExp(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Exp(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vsExp(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Exp(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vdExp(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	 
	Vector& ExpI(Vector& m) 
	{ 
		vsExp(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Vector& ExpI(Vector& m) 
	{ 
		vdExp(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& ExpI(Matrix& m) 
	{ 
		vsExp(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& ExpI(Matrix& m) 
	{ 
		vdExp(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	 
	 
	// Ln of elements 
	Vector Ln(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vsLn(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Vector Ln(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vdLn(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Ln(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vsLn(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Ln(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vdLn(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	 
	Vector& LnI(Vector& m) 
	{ 
		vsLn(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Vector& LnI(Vector& m) 
	{ 
		vdLn(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& LnI(Matrix& m) 
	{ 
		vsLn(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& LnI(Matrix& m) 
	{ 
		vdLn(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	 
	// Log10 of elements 
	Vector Log10(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vsLog10(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Vector Log10(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vdLog10(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Log10(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vsLog10(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Log10(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vdLog10(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	 
	Vector& Log10I(Vector& m) 
	{ 
		vsLog10(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Vector& Log10I(Vector& m) 
	{ 
		vdLog10(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& Log10I(Matrix& m) 
	{ 
		vsLog10(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& Log10I(Matrix& m) 
	{ 
		vdLog10(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	 
	 
	// Cos of elements 
	Vector Cos(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vsCos(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Vector Cos(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vdCos(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Cos(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vsCos(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Cos(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vdCos(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	 
	Vector& CosI(Vector& m) 
	{ 
		vsCos(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Vector& CosI(Vector& m) 
	{ 
		vdCos(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& CosI(Matrix& m) 
	{ 
		vsCos(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& CosI(Matrix& m) 
	{ 
		vdCos(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	 
	// Sin of elements 
	Vector Sin(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vsSin(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Vector Sin(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vdSin(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Sin(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vsSin(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Sin(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vdSin(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	 
	Vector& SinI(Vector& m) 
	{ 
		vsSin(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Vector& SinI(Vector& m) 
	{ 
		vdSin(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& SinI(Matrix& m) 
	{ 
		vsSin(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& SinI(Matrix& m) 
	{ 
		vdSin(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	 
	// Tan of elements 
	Vector Tan(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vsTan(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Vector Tan(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vdTan(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Tan(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vsTan(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Tan(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vdTan(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	 
	Vector& TanI(Vector& m) 
	{ 
		vsTan(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Vector& TanI(Vector& m) 
	{ 
		vdTan(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& TanI(Matrix& m) 
	{ 
		vsTan(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& TanI(Matrix& m) 
	{ 
		vdTan(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	 
	// Acos of elements 
	Vector Acos(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vsAcos(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Vector Acos(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vdAcos(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Acos(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vsAcos(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Acos(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vdAcos(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	 
	Vector& AcosI(Vector& m) 
	{ 
		vsAcos(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Vector& AcosI(Vector& m) 
	{ 
		vdAcos(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& AcosI(Matrix& m) 
	{ 
		vsAcos(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& AcosI(Matrix& m) 
	{ 
		vdAcos(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	 
	// Asin of elements 
	Vector Asin(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vsAsin(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Vector Asin(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vdAsin(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Asin(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vsAsin(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Asin(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vdAsin(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	 
	Vector& AsinI(Vector& m) 
	{ 
		vsAsin(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Vector& AsinI(Vector& m) 
	{ 
		vdAsin(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& AsinI(Matrix& m) 
	{ 
		vsAsin(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& AsinI(Matrix& m) 
	{ 
		vdAsin(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	 
	// Atan of elements 
	Vector Atan(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vsAtan(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Vector Atan(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vdAtan(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Atan(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vsAtan(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Atan(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vdAtan(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	 
	Vector& AtanI(Vector& m) 
	{ 
		vsAtan(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Vector& AtanI(Vector& m) 
	{ 
		vdAtan(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& AtanI(Matrix& m) 
	{ 
		vsAtan(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& AtanI(Matrix& m) 
	{ 
		vdAtan(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	 
	// Atan2 of elements 
	Vector Atan2(Vector& m1, Vector& m2) 
	{ 
		if(m1.Length() != m2.Length()) 
		{ 
			cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl; 
			Utility::RunTimeError("Vector lengths are not the same!"); 
		} 
		 
		Vector temp(m1.Length()); 
		vsAtan2(m1.Length(), m1.Data(), m2.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Vector Atan2(Vector& m1, Vector& m2) 
	{ 
		if(m1.Length() != m2.Length()) 
		{ 
			cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl; 
			Utility::RunTimeError("Vector lengths are not the same!"); 
		} 
		 
		Vector temp(m1.Length()); 
		vdAtan2(m1.Length(), m1.Data(), m2.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Atan2(Matrix& m1, Matrix& m2) 
	{ 
		if(m1.Rows() != m2.Rows() || m1.Columns() != m2.Columns()) 
		{ 
			cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl; 
			Utility::RunTimeError("Matrix dimensions does not match!"); 
		} 
		 
		Matrix temp(m1.Rows(), m1.Columns()); 
		vsAtan2(m1.Length(), m1.Data(), m2.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Atan2(Matrix& m1, Matrix& m2) 
	{ 
		if(m1.Rows() != m2.Rows() || m1.Columns() != m2.Columns()) 
		{ 
			cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl; 
			Utility::RunTimeError("Matrix dimensions does not match!"); 
		} 
		 
		Matrix temp(m1.Rows(), m1.Columns()); 
		vdAtan2(m1.Length(), m1.Data(), m2.Data(), temp.Data()); 
		return temp; 
	} 
	 
	 
	Vector& Atan2I(Vector& m1, Vector& m2) 
	{ 
		if(m1.Length() != m2.Length()) 
		{ 
			cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl; 
			Utility::RunTimeError("Vector lengths are not the same!"); 
		} 
		 
		vsAtan2(m1.Length(), m1.Data(), m2.Data(), m1.Data()); 
		return m1; 
	} 
	 
	Vector& Atan2I(Vector& m1, Vector& m2) 
	{ 
		if(m1.Length() != m2.Length()) 
		{ 
			cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl; 
			Utility::RunTimeError("Vector lengths are not the same!"); 
		} 
		 
		vdAtan2(m1.Length(), m1.Data(), m2.Data(), m1.Data()); 
		return m1; 
	} 
	 
	Matrix& Atan2I(Matrix& m1, Matrix& m2) 
	{ 
		if(m1.Rows() != m2.Rows() || m1.Columns() != m2.Columns()) 
		{ 
			cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl; 
			Utility::RunTimeError("Matrix dimensions does not match!"); 
		} 
		 
		vsAtan2(m1.Length(), m1.Data(), m2.Data(), m1.Data()); 
		return m1; 
	} 
	 
	Matrix& Atan2I(Matrix& m1, Matrix& m2) 
	{ 
		if(m1.Rows() != m2.Rows() || m1.Columns() != m2.Columns()) 
		{ 
			cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl; 
			Utility::RunTimeError("Matrix dimensions does not match!"); 
		} 
		 
		vdAtan2(m1.Length(), m1.Data(), m2.Data(), m1.Data()); 
		return m1; 
	} 
	 
	 
	 
	 
	// Cosh of elements 
	Vector Cosh(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vsCosh(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Vector Cosh(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vdCosh(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Cosh(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vsCosh(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Cosh(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vdCosh(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	 
	Vector& CoshI(Vector& m) 
	{ 
		vsCosh(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Vector& CoshI(Vector& m) 
	{ 
		vdCosh(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& CoshI(Matrix& m) 
	{ 
		vsCosh(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& CoshI(Matrix& m) 
	{ 
		vdCosh(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	 
	// Sinh of elements 
	Vector Sinh(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vsSinh(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Vector Sinh(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vdSinh(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Sinh(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vsSinh(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Sinh(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vdSinh(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	 
	Vector& SinhI(Vector& m) 
	{ 
		vsSinh(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Vector& SinhI(Vector& m) 
	{ 
		vdSinh(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& SinhI(Matrix& m) 
	{ 
		vsSinh(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& SinhI(Matrix& m) 
	{ 
		vdSinh(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	 
	// Tanh of elements 
	Vector Tanh(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vsTanh(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Vector Tanh(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vdTanh(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Tanh(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vsTanh(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Tanh(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vdTanh(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	 
	Vector& TanhI(Vector& m) 
	{ 
		vsTanh(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Vector& TanhI(Vector& m) 
	{ 
		vdTanh(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& TanhI(Matrix& m) 
	{ 
		vsTanh(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& TanhI(Matrix& m) 
	{ 
		vdTanh(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	 
	// Acosh of elements 
	Vector Acosh(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vsAcosh(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Vector Acosh(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vdAcosh(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Acosh(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vsAcosh(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Acosh(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vdAcosh(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	 
	Vector& AcoshI(Vector& m) 
	{ 
		vsAcosh(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Vector& AcoshI(Vector& m) 
	{ 
		vdAcosh(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& AcoshI(Matrix& m) 
	{ 
		vsAcosh(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& AcoshI(Matrix& m) 
	{ 
		vdAcosh(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	 
	// Asinh of elements 
	Vector Asinh(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vsAsinh(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Vector Asinh(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vdAsinh(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Asinh(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vsAsinh(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Asinh(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vdAsinh(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	 
	Vector& AsinhI(Vector& m) 
	{ 
		vsAsinh(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Vector& AsinhI(Vector& m) 
	{ 
		vdAsinh(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& AsinhI(Matrix& m) 
	{ 
		vsAsinh(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& AsinhI(Matrix& m) 
	{ 
		vdAsinh(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	 
	// Atanh of elements 
	Vector Atanh(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vsAtanh(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Vector Atanh(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vdAtanh(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Atanh(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vsAtanh(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Atanh(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vdAtanh(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	 
	Vector& AtanhI(Vector& m) 
	{ 
		vsAtanh(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Vector& AtanhI(Vector& m) 
	{ 
		vdAtanh(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& AtanhI(Matrix& m) 
	{ 
		vsAtanh(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& AtanhI(Matrix& m) 
	{ 
		vdAtanh(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	 
	 
	// Erf of elements 
	Vector Erf(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vsErf(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Vector Erf(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vdErf(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Erf(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vsErf(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Erf(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vdErf(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	 
	Vector& ErfI(Vector& m) 
	{ 
		vsErf(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Vector& ErfI(Vector& m) 
	{ 
		vdErf(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& ErfI(Matrix& m) 
	{ 
		vsErf(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& ErfI(Matrix& m) 
	{ 
		vdErf(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	 
	// Erfc of elements 
	Vector Erfc(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vsErfc(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Vector Erfc(Vector& m) 
	{ 
		Vector temp(m.Length()); 
		vdErfc(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Erfc(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vsErfc(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	Matrix Erfc(Matrix& m) 
	{ 
		Matrix temp(m.Rows(), m.Columns()); 
		vdErfc(m.Length(), m.Data(), temp.Data()); 
		return temp; 
	} 
	 
	 
	Vector& ErfcI(Vector& m) 
	{ 
		vsErfc(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Vector& ErfcI(Vector& m) 
	{ 
		vdErfc(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& ErfcI(Matrix& m) 
	{ 
		vsErfc(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
	 
	Matrix& ErfcI(Matrix& m) 
	{ 
		vdErfc(m.Length(), m.Data(), m.Data()); 
		return m; 
	} 
 
 
 
};