Functions.cpp

Go to the documentation of this file.

//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<float> Inv(Vector<float>& m)
        {
                Vector<float> temp(m.Length());
                vsInv(m.Length(), m.Data(), temp.Data());
                return temp;
        }


        Vector<double> Inv(Vector<double>& m)
        {
                Vector<double> temp(m.Length());
                vdInv(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        Matrix<float> Inv(Matrix<float>& m)
        {
                Matrix<float> temp(m.Rows(), m.Columns());
                vsInv(m.Length(), m.Data(), temp.Data());
                return temp;
        }

        Matrix<double> Inv(Matrix<double>& m)
        {
                Matrix<double> temp(m.Rows(), m.Columns());
                vdInv(m.Length(), m.Data(), temp.Data());
                return temp;
        }


        Vector<float>& InvI(Vector<float>& m)
        {
                vsInv(m.Length(), m.Data(), m.Data());
                return m;
        }

        Vector<double>& InvI(Vector<double>& m)
        {
                vdInv(m.Length(), m.Data(), m.Data());
                return m;
        }

        Matrix<float>& InvI(Matrix<float>& m)
        {
                vsInv(m.Length(), m.Data(), m.Data());
                return m;
        }

        Matrix<double>& InvI(Matrix<double>& m)
        {
                vdInv(m.Length(), m.Data(), m.Data());
                return m;
        }


        // Division of elements
        Vector<float> Div(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!");
                }
                
                Vector<float> temp(m1.Length());
                vsDiv(m1.Length(), m1.Data(), m2.Data(), temp.Data());
                return temp;
        }

        Vector<double> Div(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());
                vdDiv(m1.Length(), m1.Data(), m2.Data(), temp.Data());
                return temp;
        }

        Matrix<float> Div(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());
                vsDiv(m1.Length(), m1.Data(), m2.Data(), temp.Data());
                return temp;
        }

        Matrix<double> Div(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());
                vdDiv(m1.Length(), m1.Data(), m2.Data(), temp.Data());
                return temp;
        }


        Vector<float>& DivI(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!");
                }
                
                vsDiv(m1.Length(), m1.Data(), m2.Data(), m1.Data());
                return m1;
        }

        Vector<double>& DivI(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!");
                }
                
                vdDiv(m1.Length(), m1.Data(), m2.Data(), m1.Data());
                return m1;
        }

        Matrix<float>& DivI(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!");
                }
                
                vsDiv(m1.Length(), m1.Data(), m2.Data(), m1.Data());
                return m1;
        }

        Matrix<double>& DivI(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!");
                }
                
                vdDiv(m1.Length(), m1.Data(), m2.Data(), m1.Data());
                return m1;
        }


        // Square root of elements
        Vector<float> Sqrt(Vector<float>& m)
        {
                Vector<float> temp(m.Length());
                vsSqrt(m.Length(), m.Data(), temp.Data());
                return temp;
        }

        Vector<double> Sqrt(Vector<double>& m)
        {
                Vector<double> temp(m.Length());
                vdSqrt(m.Length(), m.Data(), temp.Data());
                return temp;
        }

        Matrix<float> Sqrt(Matrix<float>& m)
        {
                Matrix<float> temp(m.Rows(), m.Columns());
                vsSqrt(m.Length(), m.Data(), temp.Data());
                return temp;
        }

        Matrix<double> Sqrt(Matrix<double>& m)
        {
                Matrix<double> temp(m.Rows(), m.Columns());
                vdSqrt(m.Length(), m.Data(), temp.Data());
                return temp;
        }


        Vector<float>& SqrtI(Vector<float>& m)
        {
                vsSqrt(m.Length(), m.Data(), m.Data());
                return m;
        }

        Vector<double>& SqrtI(Vector<double>& m)
        {
                vdSqrt(m.Length(), m.Data(), m.Data());
                return m;
        }

        Matrix<float>& SqrtI(Matrix<float>& m)
        {
                vsSqrt(m.Length(), m.Data(), m.Data());
                return m;
        }

        Matrix<double>& SqrtI(Matrix<double>& m)
        {
                vdSqrt(m.Length(), m.Data(), m.Data());
                return m;
        }


        // Inverse Square root of elements
        Vector<float> InvSqrt(Vector<float>& m)
        {
                Vector<float> temp(m.Length());
                vsInvSqrt(m.Length(), m.Data(), temp.Data());
                return temp;
        }

        Vector<double> InvSqrt(Vector<double>& m)
        {
                Vector<double> temp(m.Length());
                vdInvSqrt(m.Length(), m.Data(), temp.Data());
                return temp;
        }

        Matrix<float> InvSqrt(Matrix<float>& m)
        {
                Matrix<float> temp(m.Rows(), m.Columns());
                vsInvSqrt(m.Length(), m.Data(), temp.Data());
                return temp;
        }

        Matrix<double> InvSqrt(Matrix<double>& m)
        {
                Matrix<double> temp(m.Rows(), m.Columns());
                vdInvSqrt(m.Length(), m.Data(), temp.Data());
                return temp;
        }


        Vector<float>& InvSqrtI(Vector<float>& m)
        {
                vsInvSqrt(m.Length(), m.Data(), m.Data());
                return m;
        }

        Vector<double>& InvSqrtI(Vector<double>& m)
        {
                vdInvSqrt(m.Length(), m.Data(), m.Data());
                return m;
        }

        Matrix<float>& InvSqrtI(Matrix<float>& m)
        {
                vsInvSqrt(m.Length(), m.Data(), m.Data());
                return m;
        }

        Matrix<double>& InvSqrtI(Matrix<double>& m)
        {
                vdInvSqrt(m.Length(), m.Data(), m.Data());
                return m;
        }


        // Cube root of elements
        Vector<float> Cbrt(Vector<float>& m)
        {
                Vector<float> temp(m.Length());
                vsCbrt(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        Vector<double> Cbrt(Vector<double>& m)
        {
                Vector<double> temp(m.Length());
                vdCbrt(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        Matrix<float> Cbrt(Matrix<float>& m)
        {
                Matrix<float> temp(m.Rows(), m.Columns());
                vsCbrt(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        Matrix<double> Cbrt(Matrix<double>& m)
        {
                Matrix<double> temp(m.Rows(), m.Columns());
                vdCbrt(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        
        Vector<float>& CbrtI(Vector<float>& m)
        {
                vsCbrt(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        Vector<double>& CbrtI(Vector<double>& m)
        {
                vdCbrt(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        Matrix<float>& CbrtI(Matrix<float>& m)
        {
                vsCbrt(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        Matrix<double>& CbrtI(Matrix<double>& m)
        {
                vdCbrt(m.Length(), m.Data(), m.Data());
                return m;
        }
        

        // Cube root of elements
        Vector<float> InvCbrt(Vector<float>& m)
        {
                Vector<float> temp(m.Length());
                vsInvCbrt(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        Vector<double> InvCbrt(Vector<double>& m)
        {
                Vector<double> temp(m.Length());
                vdInvCbrt(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        Matrix<float> InvCbrt(Matrix<float>& m)
        {
                Matrix<float> temp(m.Rows(), m.Columns());
                vsInvCbrt(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        Matrix<double> InvCbrt(Matrix<double>& m)
        {
                Matrix<double> temp(m.Rows(), m.Columns());
                vdInvCbrt(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        
        Vector<float>& InvCbrtI(Vector<float>& m)
        {
                vsInvCbrt(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        Vector<double>& InvCbrtI(Vector<double>& m)
        {
                vdInvCbrt(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        Matrix<float>& InvCbrtI(Matrix<float>& m)
        {
                vsInvCbrt(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        Matrix<double>& InvCbrtI(Matrix<double>& m)
        {
                vdInvCbrt(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        
        // Pow of elements
        Vector<float> Pow(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!");
                }
                
                Vector<float> temp(m1.Length());
                vsPow(m1.Length(), m1.Data(), m2.Data(), temp.Data());
                return temp;
        }
        
        Vector<double> Pow(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());
                vdPow(m1.Length(), m1.Data(), m2.Data(), temp.Data());
                return temp;
        }
        
        Matrix<float> Pow(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());
                vsPow(m1.Length(), m1.Data(), m2.Data(), temp.Data());
                return temp;
        }
        
        Matrix<double> Pow(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());
                vdPow(m1.Length(), m1.Data(), m2.Data(), temp.Data());
                return temp;
        }
        
        
        Vector<float>& PowI(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!");
                }
                
                vsPow(m1.Length(), m1.Data(), m2.Data(), m1.Data());
                return m1;
        }
        
        Vector<double>& PowI(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!");
                }
                
                vdPow(m1.Length(), m1.Data(), m2.Data(), m1.Data());
                return m1;
        }
        
        Matrix<float>& PowI(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!");
                }
                
                vsPow(m1.Length(), m1.Data(), m2.Data(), m1.Data());
                return m1;
        }
        
        Matrix<double>& PowI(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!");
                }
                
                vdPow(m1.Length(), m1.Data(), m2.Data(), m1.Data());
                return m1;
        }
        
        
        // Pow of vector elements to a constant
        Vector<float> Powx(Vector<float>& m1, const float m2)
        {
                Vector<float> temp(m1.Length());
                vsPowx(m1.Length(), m1.Data(), m2, temp.Data());
                return temp;
        }
        
        Vector<double> Powx(Vector<double>& m1, const double m2)
        {
                Vector<double> temp(m1.Length());
                vdPowx(m1.Length(), m1.Data(), m2, temp.Data());
                return temp;
        }
        
        Matrix<float> Powx(Matrix<float>& m1, const float m2)
        {
                Matrix<float> temp(m1.Rows(), m1.Columns());
                vsPowx(m1.Length(), m1.Data(), m2, temp.Data());
                return temp;
        }
        
        Matrix<double> Powx(Matrix<double>& m1, const double m2)
        {
                Matrix<double> temp(m1.Rows(), m1.Columns());
                vdPowx(m1.Length(), m1.Data(), m2, temp.Data());
                return temp;
        }
        
        
        Vector<float>& PowxI(Vector<float>& m1, const float m2)
        {
                vsPowx(m1.Length(), m1.Data(), m2, m1.Data());
                return m1;
        }
        
        Vector<double>& PowxI(Vector<double>& m1, const double m2)
        {
                vdPowx(m1.Length(), m1.Data(), m2, m1.Data());
                return m1;
        }
        
        Matrix<float>& PowxI(Matrix<float>& m1, const float m2)
        {
                vsPowx(m1.Length(), m1.Data(), m2, m1.Data());
                return m1;
        }
        
        Matrix<double>& PowxI(Matrix<double>& m1, const double m2)
        {
                vdPowx(m1.Length(), m1.Data(), m2, m1.Data());
                return m1;
        }
        
        
        
        
        // Exponent of elements
        Vector<float> Exp(Vector<float>& m)
        {
                Vector<float> temp(m.Length());
                vsExp(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        Vector<double> Exp(Vector<double>& m)
        {
                Vector<double> temp(m.Length());
                vdExp(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        Matrix<float> Exp(Matrix<float>& m)
        {
                Matrix<float> temp(m.Rows(), m.Columns());
                vsExp(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        Matrix<double> Exp(Matrix<double>& m)
        {
                Matrix<double> temp(m.Rows(), m.Columns());
                vdExp(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        
        Vector<float>& ExpI(Vector<float>& m)
        {
                vsExp(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        Vector<double>& ExpI(Vector<double>& m)
        {
                vdExp(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        Matrix<float>& ExpI(Matrix<float>& m)
        {
                vsExp(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        Matrix<double>& ExpI(Matrix<double>& m)
        {
                vdExp(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        
        
        // Ln of elements
        Vector<float> Ln(Vector<float>& m)
        {
                Vector<float> temp(m.Length());
                vsLn(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        Vector<double> Ln(Vector<double>& m)
        {
                Vector<double> temp(m.Length());
                vdLn(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        Matrix<float> Ln(Matrix<float>& m)
        {
                Matrix<float> temp(m.Rows(), m.Columns());
                vsLn(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        Matrix<double> Ln(Matrix<double>& m)
        {
                Matrix<double> temp(m.Rows(), m.Columns());
                vdLn(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        
        Vector<float>& LnI(Vector<float>& m)
        {
                vsLn(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        Vector<double>& LnI(Vector<double>& m)
        {
                vdLn(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        Matrix<float>& LnI(Matrix<float>& m)
        {
                vsLn(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        Matrix<double>& LnI(Matrix<double>& m)
        {
                vdLn(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        
        // Log10 of elements
        Vector<float> Log10(Vector<float>& m)
        {
                Vector<float> temp(m.Length());
                vsLog10(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        Vector<double> Log10(Vector<double>& m)
        {
                Vector<double> temp(m.Length());
                vdLog10(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        Matrix<float> Log10(Matrix<float>& m)
        {
                Matrix<float> temp(m.Rows(), m.Columns());
                vsLog10(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        Matrix<double> Log10(Matrix<double>& m)
        {
                Matrix<double> temp(m.Rows(), m.Columns());
                vdLog10(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        
        Vector<float>& Log10I(Vector<float>& m)
        {
                vsLog10(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        Vector<double>& Log10I(Vector<double>& m)
        {
                vdLog10(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        Matrix<float>& Log10I(Matrix<float>& m)
        {
                vsLog10(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        Matrix<double>& Log10I(Matrix<double>& m)
        {
                vdLog10(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        
        
        // Cos of elements
        Vector<float> Cos(Vector<float>& m)
        {
                Vector<float> temp(m.Length());
                vsCos(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        Vector<double> Cos(Vector<double>& m)
        {
                Vector<double> temp(m.Length());
                vdCos(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        Matrix<float> Cos(Matrix<float>& m)
        {
                Matrix<float> temp(m.Rows(), m.Columns());
                vsCos(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        Matrix<double> Cos(Matrix<double>& m)
        {
                Matrix<double> temp(m.Rows(), m.Columns());
                vdCos(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        
        Vector<float>& CosI(Vector<float>& m)
        {
                vsCos(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        Vector<double>& CosI(Vector<double>& m)
        {
                vdCos(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        Matrix<float>& CosI(Matrix<float>& m)
        {
                vsCos(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        Matrix<double>& CosI(Matrix<double>& m)
        {
                vdCos(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        
        // Sin of elements
        Vector<float> Sin(Vector<float>& m)
        {
                Vector<float> temp(m.Length());
                vsSin(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        Vector<double> Sin(Vector<double>& m)
        {
                Vector<double> temp(m.Length());
                vdSin(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        Matrix<float> Sin(Matrix<float>& m)
        {
                Matrix<float> temp(m.Rows(), m.Columns());
                vsSin(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        Matrix<double> Sin(Matrix<double>& m)
        {
                Matrix<double> temp(m.Rows(), m.Columns());
                vdSin(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        
        Vector<float>& SinI(Vector<float>& m)
        {
                vsSin(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        Vector<double>& SinI(Vector<double>& m)
        {
                vdSin(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        Matrix<float>& SinI(Matrix<float>& m)
        {
                vsSin(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        Matrix<double>& SinI(Matrix<double>& m)
        {
                vdSin(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        
        // Tan of elements
        Vector<float> Tan(Vector<float>& m)
        {
                Vector<float> temp(m.Length());
                vsTan(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        Vector<double> Tan(Vector<double>& m)
        {
                Vector<double> temp(m.Length());
                vdTan(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        Matrix<float> Tan(Matrix<float>& m)
        {
                Matrix<float> temp(m.Rows(), m.Columns());
                vsTan(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        Matrix<double> Tan(Matrix<double>& m)
        {
                Matrix<double> temp(m.Rows(), m.Columns());
                vdTan(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        
        Vector<float>& TanI(Vector<float>& m)
        {
                vsTan(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        Vector<double>& TanI(Vector<double>& m)
        {
                vdTan(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        Matrix<float>& TanI(Matrix<float>& m)
        {
                vsTan(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        Matrix<double>& TanI(Matrix<double>& m)
        {
                vdTan(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        
        // Acos of elements
        Vector<float> Acos(Vector<float>& m)
        {
                Vector<float> temp(m.Length());
                vsAcos(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        Vector<double> Acos(Vector<double>& m)
        {
                Vector<double> temp(m.Length());
                vdAcos(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        Matrix<float> Acos(Matrix<float>& m)
        {
                Matrix<float> temp(m.Rows(), m.Columns());
                vsAcos(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        Matrix<double> Acos(Matrix<double>& m)
        {
                Matrix<double> temp(m.Rows(), m.Columns());
                vdAcos(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        
        Vector<float>& AcosI(Vector<float>& m)
        {
                vsAcos(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        Vector<double>& AcosI(Vector<double>& m)
        {
                vdAcos(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        Matrix<float>& AcosI(Matrix<float>& m)
        {
                vsAcos(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        Matrix<double>& AcosI(Matrix<double>& m)
        {
                vdAcos(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        
        // Asin of elements
        Vector<float> Asin(Vector<float>& m)
        {
                Vector<float> temp(m.Length());
                vsAsin(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        Vector<double> Asin(Vector<double>& m)
        {
                Vector<double> temp(m.Length());
                vdAsin(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        Matrix<float> Asin(Matrix<float>& m)
        {
                Matrix<float> temp(m.Rows(), m.Columns());
                vsAsin(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        Matrix<double> Asin(Matrix<double>& m)
        {
                Matrix<double> temp(m.Rows(), m.Columns());
                vdAsin(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        
        Vector<float>& AsinI(Vector<float>& m)
        {
                vsAsin(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        Vector<double>& AsinI(Vector<double>& m)
        {
                vdAsin(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        Matrix<float>& AsinI(Matrix<float>& m)
        {
                vsAsin(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        Matrix<double>& AsinI(Matrix<double>& m)
        {
                vdAsin(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        
        // Atan of elements
        Vector<float> Atan(Vector<float>& m)
        {
                Vector<float> temp(m.Length());
                vsAtan(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        Vector<double> Atan(Vector<double>& m)
        {
                Vector<double> temp(m.Length());
                vdAtan(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        Matrix<float> Atan(Matrix<float>& m)
        {
                Matrix<float> temp(m.Rows(), m.Columns());
                vsAtan(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        Matrix<double> Atan(Matrix<double>& m)
        {
                Matrix<double> temp(m.Rows(), m.Columns());
                vdAtan(m.Length(), m.Data(), temp.Data());
                return temp;
        }
        
        
        Vector<float>& AtanI(Vector<float>& m)
        {
                vsAtan(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        Vector<double>& AtanI(Vector<double>& m)
        {
                vdAtan(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        Matrix<float>& AtanI(Matrix<float>& m)
        {
                vsAtan(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        Matrix<double>& AtanI(Matrix<double>& m)
        {
                vdAtan(m.Length(), m.Data(), m.Data());
                return m;
        }
        
        
        // Atan2 of elements
        Vector<float> Atan2(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!");
                }
                
                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;
        }



};

---