functions.cpp

图像分割算法

		Vector<float> temp(m1.Length());
		vsAtan2(m1.Length(), m1.Data(), m2.Data(), temp.Data());
		return temp;
	}
	
	Vector<double> Atan2(Vector<double>& m1, Vector<double>& m2)
	{
		if(m1.Length() != m2.Length())
		{
			cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
			Utility::RunTimeError("Vector lengths are not the same!");
		}
		
		Vector<double> temp(m1.Length());
		vdAtan2(m1.Length(), m1.Data(), m2.Data(), temp.Data());
		return temp;
	}
	
	Matrix<float> Atan2(Matrix<float>& m1, Matrix<float>& m2)
	{
		if(m1.Rows() != m2.Rows() || m1.Columns() != m2.Columns())
		{
			cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
			Utility::RunTimeError("Matrix dimensions does not match!");
		}
		
		Matrix<float> temp(m1.Rows(), m1.Columns());
		vsAtan2(m1.Length(), m1.Data(), m2.Data(), temp.Data());
		return temp;
	}
	
	Matrix<double> Atan2(Matrix<double>& m1, Matrix<double>& m2)
	{
		if(m1.Rows() != m2.Rows() || m1.Columns() != m2.Columns())
		{
			cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
			Utility::RunTimeError("Matrix dimensions does not match!");
		}
		
		Matrix<double> temp(m1.Rows(), m1.Columns());
		vdAtan2(m1.Length(), m1.Data(), m2.Data(), temp.Data());
		return temp;
	}
	
	
	Vector<float>& Atan2I(Vector<float>& m1, Vector<float>& 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<double>& Atan2I(Vector<double>& m1, Vector<double>& 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<float>& Atan2I(Matrix<float>& m1, Matrix<float>& 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<double>& Atan2I(Matrix<double>& m1, Matrix<double>& 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<float> Cosh(Vector<float>& m)
	{
		Vector<float> temp(m.Length());
		vsCosh(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Vector<double> Cosh(Vector<double>& m)
	{
		Vector<double> temp(m.Length());
		vdCosh(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Matrix<float> Cosh(Matrix<float>& m)
	{
		Matrix<float> temp(m.Rows(), m.Columns());
		vsCosh(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Matrix<double> Cosh(Matrix<double>& m)
	{
		Matrix<double> temp(m.Rows(), m.Columns());
		vdCosh(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	
	Vector<float>& CoshI(Vector<float>& m)
	{
		vsCosh(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Vector<double>& CoshI(Vector<double>& m)
	{
		vdCosh(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Matrix<float>& CoshI(Matrix<float>& m)
	{
		vsCosh(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Matrix<double>& CoshI(Matrix<double>& m)
	{
		vdCosh(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	
	// Sinh of elements
	Vector<float> Sinh(Vector<float>& m)
	{
		Vector<float> temp(m.Length());
		vsSinh(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Vector<double> Sinh(Vector<double>& m)
	{
		Vector<double> temp(m.Length());
		vdSinh(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Matrix<float> Sinh(Matrix<float>& m)
	{
		Matrix<float> temp(m.Rows(), m.Columns());
		vsSinh(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Matrix<double> Sinh(Matrix<double>& m)
	{
		Matrix<double> temp(m.Rows(), m.Columns());
		vdSinh(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	
	Vector<float>& SinhI(Vector<float>& m)
	{
		vsSinh(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Vector<double>& SinhI(Vector<double>& m)
	{
		vdSinh(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Matrix<float>& SinhI(Matrix<float>& m)
	{
		vsSinh(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Matrix<double>& SinhI(Matrix<double>& m)
	{
		vdSinh(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	
	// Tanh of elements
	Vector<float> Tanh(Vector<float>& m)
	{
		Vector<float> temp(m.Length());
		vsTanh(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Vector<double> Tanh(Vector<double>& m)
	{
		Vector<double> temp(m.Length());
		vdTanh(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Matrix<float> Tanh(Matrix<float>& m)
	{
		Matrix<float> temp(m.Rows(), m.Columns());
		vsTanh(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Matrix<double> Tanh(Matrix<double>& m)
	{
		Matrix<double> temp(m.Rows(), m.Columns());
		vdTanh(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	
	Vector<float>& TanhI(Vector<float>& m)
	{
		vsTanh(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Vector<double>& TanhI(Vector<double>& m)
	{
		vdTanh(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Matrix<float>& TanhI(Matrix<float>& m)
	{
		vsTanh(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Matrix<double>& TanhI(Matrix<double>& m)
	{
		vdTanh(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	
	// Acosh of elements
	Vector<float> Acosh(Vector<float>& m)
	{
		Vector<float> temp(m.Length());
		vsAcosh(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Vector<double> Acosh(Vector<double>& m)
	{
		Vector<double> temp(m.Length());
		vdAcosh(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Matrix<float> Acosh(Matrix<float>& m)
	{
		Matrix<float> temp(m.Rows(), m.Columns());
		vsAcosh(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Matrix<double> Acosh(Matrix<double>& m)
	{
		Matrix<double> temp(m.Rows(), m.Columns());
		vdAcosh(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	
	Vector<float>& AcoshI(Vector<float>& m)
	{
		vsAcosh(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Vector<double>& AcoshI(Vector<double>& m)
	{
		vdAcosh(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Matrix<float>& AcoshI(Matrix<float>& m)
	{
		vsAcosh(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Matrix<double>& AcoshI(Matrix<double>& m)
	{
		vdAcosh(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	
	// Asinh of elements
	Vector<float> Asinh(Vector<float>& m)
	{
		Vector<float> temp(m.Length());
		vsAsinh(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Vector<double> Asinh(Vector<double>& m)
	{
		Vector<double> temp(m.Length());
		vdAsinh(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Matrix<float> Asinh(Matrix<float>& m)
	{
		Matrix<float> temp(m.Rows(), m.Columns());
		vsAsinh(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Matrix<double> Asinh(Matrix<double>& m)
	{
		Matrix<double> temp(m.Rows(), m.Columns());
		vdAsinh(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	
	Vector<float>& AsinhI(Vector<float>& m)
	{
		vsAsinh(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Vector<double>& AsinhI(Vector<double>& m)
	{
		vdAsinh(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Matrix<float>& AsinhI(Matrix<float>& m)
	{
		vsAsinh(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Matrix<double>& AsinhI(Matrix<double>& m)
	{
		vdAsinh(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	
	// Atanh of elements
	Vector<float> Atanh(Vector<float>& m)
	{
		Vector<float> temp(m.Length());
		vsAtanh(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Vector<double> Atanh(Vector<double>& m)
	{
		Vector<double> temp(m.Length());
		vdAtanh(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Matrix<float> Atanh(Matrix<float>& m)
	{
		Matrix<float> temp(m.Rows(), m.Columns());
		vsAtanh(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Matrix<double> Atanh(Matrix<double>& m)
	{
		Matrix<double> temp(m.Rows(), m.Columns());
		vdAtanh(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	
	Vector<float>& AtanhI(Vector<float>& m)
	{
		vsAtanh(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Vector<double>& AtanhI(Vector<double>& m)
	{
		vdAtanh(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Matrix<float>& AtanhI(Matrix<float>& m)
	{
		vsAtanh(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Matrix<double>& AtanhI(Matrix<double>& m)
	{
		vdAtanh(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	
	
	// Erf of elements
	Vector<float> Erf(Vector<float>& m)
	{
		Vector<float> temp(m.Length());
		vsErf(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Vector<double> Erf(Vector<double>& m)
	{
		Vector<double> temp(m.Length());
		vdErf(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Matrix<float> Erf(Matrix<float>& m)
	{
		Matrix<float> temp(m.Rows(), m.Columns());
		vsErf(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Matrix<double> Erf(Matrix<double>& m)
	{
		Matrix<double> temp(m.Rows(), m.Columns());
		vdErf(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	
	Vector<float>& ErfI(Vector<float>& m)
	{
		vsErf(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Vector<double>& ErfI(Vector<double>& m)
	{
		vdErf(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Matrix<float>& ErfI(Matrix<float>& m)
	{
		vsErf(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Matrix<double>& ErfI(Matrix<double>& m)
	{
		vdErf(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	
	// Erfc of elements
	Vector<float> Erfc(Vector<float>& m)
	{
		Vector<float> temp(m.Length());
		vsErfc(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Vector<double> Erfc(Vector<double>& m)
	{
		Vector<double> temp(m.Length());
		vdErfc(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Matrix<float> Erfc(Matrix<float>& m)
	{
		Matrix<float> temp(m.Rows(), m.Columns());
		vsErfc(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	Matrix<double> Erfc(Matrix<double>& m)
	{
		Matrix<double> temp(m.Rows(), m.Columns());
		vdErfc(m.Length(), m.Data(), temp.Data());
		return temp;
	}
	
	
	Vector<float>& ErfcI(Vector<float>& m)
	{
		vsErfc(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Vector<double>& ErfcI(Vector<double>& m)
	{
		vdErfc(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Matrix<float>& ErfcI(Matrix<float>& m)
	{
		vsErfc(m.Length(), m.Data(), m.Data());
		return m;
	}
	
	Matrix<double>& ErfcI(Matrix<double>& m)
	{
		vdErfc(m.Length(), m.Data(), m.Data());
		return m;
	}



};