Vector.inl

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.



namespace CIMPL
{


template< class T >
Vector<T>::Vector()
        : length(0)
{
        data = 0;
        clean = 0;
        memoryManaged = true;
}


template< class T >
Vector<T>::Vector(const int l)
{
        if(l < 1)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Vector length should be larger than 0!");
        }

        length = l;
        data = new (std::nothrow) T[length];
        Utility::CheckPointer(data);

        clean = new (std::nothrow) Cleaner<T>(data);
        Utility::CheckPointer(clean);
        memoryManaged = true;

}


template< class T >
Vector<T>::Vector(string str)
{
        
        if(str.substr(0,1) == "[")
        {
                if(str.substr(str.size()-1,1) == "]")
                {
                        str = str.substr(1,str.size()-2);
                        vector<string> elem_strs = Utility::Split(str);
                        length = (int)elem_strs.size();
                        if(length <= 0)
                        {
                                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                                Utility::RunTimeError("Vector length should be larger than 0!");
                        }
                        data = new (std::nothrow) T[length];
                        Utility::CheckPointer(data);
                        clean = new (std::nothrow) Cleaner<T>(data);
                        Utility::CheckPointer(clean);
                        memoryManaged = true;
                        
                        vector<string>::const_iterator constIterator;
                        int i = 0;
                        for(constIterator = elem_strs.begin(); constIterator != elem_strs.end(); constIterator++)
                        {
                                data[i] = (T)Utility::ToDouble((string)*constIterator);
                                i++;
                        }
                }
                else
                {
                        cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                        Utility::RunTimeError("Incorrect initialization. String cannot be parsed!");
                }
        }
        else
        {
                double start, inc, end;
                vector<string> bounds = Utility::Split(str, ":");
                if(bounds.size() == 3)
                {
                        start = Utility::ToDouble(bounds[0]);
                        inc = Utility::ToDouble(bounds[1]);
                        end = Utility::ToDouble(bounds[2]);
                }
                else if(bounds.size() == 2)
                {
                        start = Utility::ToDouble(bounds[0]);
                        inc = 1.0;
                        end = Utility::ToDouble(bounds[1]);
                }
                else
                {
                        cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                        Utility::RunTimeError("Incorrect initialization. String cannot be parsed!");
                }
                
                length = (int)(abs(end-start)/inc+numeric_limits<float>::epsilon())+1;
                if(length <= 0)
                {
                        cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                        Utility::RunTimeError("Vector length should be larger than 0!");
                }
                data = new (std::nothrow) T[length];
                Utility::CheckPointer(data);
                clean = new (std::nothrow) Cleaner<T>(data);
                Utility::CheckPointer(clean);
                memoryManaged = true;
                for(int i=0;i<length;i++)
                {
                        data[i] = (T)(start+i*inc);
                }

        }




}



template< class T >
Vector<T>::Vector(const int l, T init)
{
        if(l < 1)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Vector length should be larger than 0!");
        }

        length = l;
        data = new (std::nothrow) T[length];
        Utility::CheckPointer(data);

        clean = new (std::nothrow) Cleaner<T>(data);
        Utility::CheckPointer(clean);
        memoryManaged = true;
        for(int i=0;i<length;i++)
        {
                data[i] = init;
        }

}


template< class T >
Vector<T>::Vector(T* _data, const int l)
{
        if(l < 1)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Vector length should be larger than 0!");
        }

        length = l;
        data = _data;
        clean = 0;
        memoryManaged = false;

}



template< class T >
Vector<T>::Vector(Vector<T> &m) 
{
        length = m.length;


        if(m.memoryManaged == true)
        {
                data = m.data;
                clean = new (std::nothrow) Cleaner<T>(data);
                Utility::CheckPointer(clean);
                memoryManaged = true;
        }
        else
        {
                //Utility::RunTimeError("Using copy constructor from an unmanaged vector is not allowed!\nUse Clone() instead.");
                data = m.data;
                clean = 0;
                memoryManaged = false;
                Utility::Warning("Using copy constructor from an unmanaged vector!\nCreated a new unmanaged vector pointing to the same unmanaged memory.");
        }

}



template< class T >
Vector<T>::~Vector(void)
{

        if(clean != 0 && memoryManaged == true) // probably redundant
        {
                delete clean;
        }
}



template< class T >
void Vector<T>::Set(T* _data, const int l)
{
        if(l < 1)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Vector length should be larger than 0!");
        }

        length = l;
        data = _data;
        delete clean;
        clean = 0;
        memoryManaged = false;

}


template< class T >
void Vector<T>::Clean()
{
        if(clean != 0 && memoryManaged == true)
        {
                delete clean;
                data = 0;
                clean = 0;
        }
}



template< class T >
inline const T* Vector<T>::DataPtr() const
{
        return data;
}

template< class T >
inline T* Vector<T>::Data()
{
        return data;
}



template< class T >
Vector<T> Vector<T>::Clone() const
{
        Vector<T> temp(length);
        
        for(int j=0;j<temp.length;j++)
        {
                temp.data[j] = data[j];
        }

        return temp;
}


// returns an unmanaged vector
//template< class T >
//Vector<T> Vector<T>::Slice(int start, int end)
//{
//      if(start<0 || start>=length || end<0 || end>=length)
//      {
//              cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
//              Utility::RunTimeError("Index outside bounds!");
//      }
//      if(start > end)
//      {
//              cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
//              Utility::RunTimeError("Second slice parameter cannot be less than the first parameter!");
//      }
//
//
//      Vector<T> temp(&(data[start]), end-start+1);
//      return temp;
//}

template< class T >
Vector<T> Vector<T>::Slice(int start, int end)
{

        if(start<0 || start>=length || end<0 || end>=length)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Index outside bounds!");
        }
        
        if(start > end)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Second slice parameter cannot be less than the first parameter!");
        }
        
        Vector<T> temp(end-start+1);
        //memcopy here...
        for(int i=start; i<=end; i++)
        {
                temp[i-start] = data[i];
        }

        return temp;
}

template< class T >
Vector<T> Vector<T>::Slice(string str)
{
        int start, end;
        vector<string> bounds = Utility::Split(str, ":");
        
        if(str == ":")
        {
                start = 0;
                end = length-1;
        }
        else if(bounds.size() == 2)
        {
                start = Utility::ToInt(bounds[0]);
                end = Utility::ToInt(bounds[1]);
        }
        else
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Incorrect slice argument. String cannot be parsed!");
        }

        return this->Slice(start, end);
}


template< class T >
inline const bool Vector<T>::IsMemoryManaged() const
{
        return memoryManaged;
}



template< class T >
inline const int Vector<T>::Length() const
{
        return length;
}


template< class T >
inline const int Vector<T>::Numel() const
{
        return length;
}


template< class T >
inline void Vector<T>::Init(const T init)
{
        for(int i=0;i<length;i++)
        {
                data[i] = init;
        }
}



template< class T >
inline Vector<T>& Vector<T>::Rand(const double max)
{
        if(!RandomGen::Initialized())
        {
                RandomGen::Initialize();
        }
        for(int i=0;i<length;i++)
        {
                data[i] = (T)(rand()/(double)RAND_MAX*max);
        }
        return *this;
}


template< class T >
Vector<T> Vector<T>::Rand(const int l, const double max)
{
        Vector<T> m(l);
        if(!RandomGen::Initialized())
        {
                RandomGen::Initialize();
        }
        for(int i=0;i<l;i++)
        {
                m.data[i] = (T)(rand()/(double)RAND_MAX*max);
        }
        return m;
}



template< class T >
void Vector<T>::ReadFromVector(const Vector<T>& m, const int index)
{
        if(length < m.length+index)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("You can't read from a larger Vector (from the copy start point) to a smaller Vector!");
        }

        for(int i=0;i<m.length;i++)
        {
                        data[i+index] = m.data[i];
        }

}




template< class T >
Vector<T> Vector<T>::Cat(Vector<T>& m1, Vector<T>& m2)
{
        Vector<T> temp(m1.Length()+m2.Length());
        for(int i=0;i<m1.Length();i++)
        {
                temp.data[i] = m1.data[i];
        }
        for(int i=m1.Length();i<temp.Length();i++)
        {
                temp.data[i] = m2.data[i-m1.Length()];
        }
        return temp;
}



template< class T >
Vector<T> Vector<T>::Ones(int side)
{
        Vector<T> temp(side,1);
        return temp;
}

template< class T >
Vector<T> Vector<T>::Zeros(int side)
{
        Vector<T> temp(side,0);
        return temp;
}





template< class T >
T Vector<T>::Inner(Vector<T>& m1, Vector<T>& m2)
{
        if(m1.length != m2.length)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Vector lengths are not the same!");
        }

        T inner = 0;
        for(int i=0; i<m1.length; i++)
        {
                inner += m1.data[i]*m2.data[i];
        }
        
        return inner;
}




// Boolean Operations...
template< class T >
Vector<int> Vector<T>::And(Vector<T>& m1, Vector<T>& m2)
{
        if(m1.length != m2.length)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Vector lengths are not the same!");
        }

        Vector<int> temp(m1.length);
        for(int i=0;i<m1.length;i++)
        {
                temp[i] = (m1.data[i] != 0 && m2.data[i] != 0) ? 1 : 0;
        }
        
        return temp;
}



template< class T >
Vector<int> Vector<T>::Or(Vector<T>& m1, Vector<T>& m2)
{
        if(m1.length != m2.length)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Vector lengths are not the same!");
        }

        Vector<int> temp(m1.length);
        for(int i=0;i<m1.length;i++)
        {
                temp[i] = (m1.data[i] == 0 && m2.data[i] == 0) ? 0 : 1;
        }
        
        return temp;
}

template< class T >
Vector<int> Vector<T>::Lt(Vector<T>& m1, Vector<T>& m2)
{
        if(m1.length != m2.length)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Vector lengths are not the same!");
        }

        Vector<int> temp(m1.length);
        for(int i=0;i<m1.length;i++)
        {
                temp[i] = (m1.data[i] < m2.data[i]) ? 1 : 0;
        }
        
        return temp;
}

template< class T >
Vector<int> Vector<T>::Gt(Vector<T>& m1, Vector<T>& m2)
{
        if(m1.length != m2.length)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Vector lengths are not the same!");
        }

        Vector<int> temp(m1.length);
        for(int i=0;i<m1.length;i++)
        {
                temp[i] = (m1.data[i] > m2.data[i]) ? 1 : 0;
        }
        
        return temp;
}

template< class T >
Vector<int> Vector<T>::Le(Vector<T>& m1, Vector<T>& m2)
{
        if(m1.length != m2.length)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Vector lengths are not the same!");
        }

        Vector<int> temp(m1.length);
        for(int i=0;i<m1.length;i++)
        {
                temp[i] = (m1.data[i] <= m2.data[i]) ? 1 : 0;
        }
        
        return temp;
}

template< class T >
Vector<int> Vector<T>::Ge(Vector<T>& m1, Vector<T>& m2)
{
        if(m1.length != m2.length)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Vector lengths are not the same!");
        }

        Vector<int> temp(m1.length);
        for(int i=0;i<m1.length;i++)
        {
                temp[i] = (m1.data[i] >= m2.data[i]) ? 1 : 0;
        }
        
        return temp;
}

template< class T >
Vector<int> Vector<T>::Eq(Vector<T>& m1, Vector<T>& m2)
{
        if(m1.length != m2.length)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Vector lengths are not the same!");
        }

        Vector<int> temp(m1.length);
        for(int i=0;i<m1.length;i++)
        {
                temp[i] = (m1.data[i] == m2.data[i]) ? 1 : 0;
        }
        
        return temp;
}

template< class T >
Vector<int> Vector<T>::Ne(Vector<T>& m1, Vector<T>& m2)
{
        if(m1.length != m2.length)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Vector lengths are not the same!");
        }

        Vector<int> temp(m1.length);
        for(int i=0;i<m1.length;i++)
        {
                temp[i] = (m1.data[i] != m2.data[i]) ? 1 : 0;
        }
        
        return temp;
}





// Boolean Operations with value types...
template< class T >
Vector<int> Vector<T>::And(Vector<T>& m1, T v)
{
        Vector<int> temp(m1.length);
        for(int i=0;i<m1.length;i++)
        {
                temp[i] = (m1.data[i] != 0 && v != 0) ? 1 : 0;
        }
        
        return temp;
}


template< class T >
Vector<int> Vector<T>::Or(Vector<T>& m1, T v)
{
        Vector<int> temp(m1.length);
        for(int i=0;i<m1.length;i++)
        {
                temp[i] = (m1.data[i] == 0 && v == 0) ? 0 : 1;
        }
        
        return temp;
}


template< class T >
Vector<int> Vector<T>::Lt(Vector<T>& m1, T v)
{
        Vector<int> temp(m1.length);
        for(int i=0;i<m1.length;i++)
        {
                temp[i] = (m1.data[i] < v) ? 1 : 0;
        }
        
        return temp;
}


template< class T >
Vector<int> Vector<T>::Gt(Vector<T>& m1, T v)
{
        Vector<int> temp(m1.length);
        for(int i=0;i<m1.length;i++)
        {
                temp[i] = (m1.data[i] > v) ? 1 : 0;
        }
        
        return temp;
}


template< class T >
Vector<int> Vector<T>::Le(Vector<T>& m1, T v)
{
        Vector<int> temp(m1.length);
        for(int i=0;i<m1.length;i++)
        {
                temp[i] = (m1.data[i] <= v) ? 1 : 0;
        }
        
        return temp;
}


template< class T >
Vector<int> Vector<T>::Ge(Vector<T>& m1, T v)
{
        Vector<int> temp(m1.length);
        for(int i=0;i<m1.length;i++)
        {
                temp[i] = (m1.data[i] >= v) ? 1 : 0;
        }
        
        return temp;
}


template< class T >
Vector<int> Vector<T>::Eq(Vector<T>& m1, T v)
{
        Vector<int> temp(m1.length);
        for(int i=0;i<m1.length;i++)
        {
                temp[i] = (m1.data[i] == v) ? 1 : 0;
        }
        
        return temp;
}


template< class T >
Vector<int> Vector<T>::Ne(Vector<T>& m1, T v)
{
        Vector<int> temp(m1.length);
        for(int i=0;i<m1.length;i++)
        {
                temp[i] = (m1.data[i] != v) ? 1 : 0;
        }
        
        return temp;
}

















// Add vector to another vector
template< class T >
Vector<T> Vector<T>::Add(Vector<T>& m1, Vector<T>& m2)
{
        if(m1.length != m2.length)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Vector lengths are not the same!");
        }

        Vector<T> temp(m1.length);
        for(int i=0;i<temp.length;i++)
        {
                temp.data[i] = m1.data[i] + m2.data[i];
        }
        
        return temp;
}


template< class T >
Vector<T> Vector<T>::Subtract(Vector<T>& m1, Vector<T>& m2)
{
        if(m1.length != m2.length)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Vector lengths are not the same!");
        }

        Vector<T> temp(m1.length);
        for(int i=0;i<temp.length;i++)
        {
                temp.data[i] = m1.data[i] - m2.data[i];
        }
        
        return temp;
}

template< class T >
Vector<T> Vector<T>::Multiply(Vector<T>& m1, Vector<T>& m2)
{
        if(m1.length != m2.length)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Vector lengths are not the same!");
        }

        Vector<T> temp(m1.length);
        for(int i=0;i<temp.length;i++)
        {
                temp.data[i] = m1.data[i] * m2.data[i];
        }
        
        return temp;
}

template< class T >
Vector<T> Vector<T>::Divide(Vector<T>& m1, Vector<T>& m2)
{
        if(m1.length != m2.length)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Vector lengths are not the same!");
        }

        Vector<T> temp(m1.length);
        for(int i=0;i<temp.length;i++)
        {
                //catch division exception instead...
                if(m2.data[i] != 0)
                {
                        temp.data[i] = m1.data[i] / m2.data[i];
                }
                else
                {
                        cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                        Utility::RunTimeError("Divide by zero in vector division!");
                }
        }
        
        return temp;
}


// Add value to another vector
template< class T >
Vector<T> Vector<T>::Add(Vector<T>& m1, T v2)
{
        Vector<T> temp(m1.length);
        for(int i=0;i<temp.length;i++)
        {
                temp.data[i] = m1.data[i] + v2;
        }
        return temp;
}

template< class T >
Vector<T> Vector<T>::Subtract(Vector<T>& m1, T v2)
{
        Vector<T> temp(m1.length);
        for(int i=0;i<temp.length;i++)
        {
                temp.data[i] = m1.data[i] - v2;
        }
        return temp;
}

template< class T >
Vector<T> Vector<T>::Subtract(T v2, Vector<T>& m1)
{
        Vector<T> temp(m1.length);
        for(int i=0;i<temp.length;i++)
        {
                temp.data[i] = v2 - m1.data[i];
        }
        return temp;
}


template< class T >
Vector<T> Vector<T>::Multiply(Vector<T>& m1, T v2)
{
        Vector<T> temp(m1.length);
        for(int i=0;i<temp.length;i++)
        {
                temp.data[i] = m1.data[i] * v2;
        }
        return temp;
}

template< class T >
Vector<T> Vector<T>::Divide(Vector<T>& m1, T v2)
{
        if(v2 == 0)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Divide by zero in vector by value division!");
        }

        Vector<T> temp(m1.length);
        for(int i=0;i<temp.length;i++)
        {
                temp.data[i] = m1.data[i] / v2;
        }
        return temp;
}

template< class T >
Vector<T> Vector<T>::Divide(T v2, Vector<T>& m1)
{
        Vector<T> temp(m1.length);
        for(int i=0;i<temp.length;i++)
        {
                if(m1.data[i] != 0)
                {
                        temp.data[i] = v2 / m1.data[i];
                }
                else
                {
                        cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                        Utility::RunTimeError("Divide by zero in value by vector division!");
                }
        }
        return temp;
}



// Add vector to "this" vector
template< class T >
Vector<T>& Vector<T>::Add(Vector<T>& m)
{
        if(length != m.length)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Vector lengths are not the same!");
        }

        for(int i=0;i<this->length;i++)
        {
                this->data[i] += m.data[i];
        }
        
        return *this;
}

template< class T >
Vector<T>& Vector<T>::Subtract(Vector<T>& m)
{
        if(length != m.length)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Vector lengths are not the same!");
        }

        for(int i=0;i<this->length;i++)
        {
                this->data[i] -= m.data[i];
        }
        
        return *this;
}

template< class T >
Vector<T>& Vector<T>::Multiply(Vector<T>& m)
{
        if(length != m.length)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Vector lengths are not the same!");
        }

        for(int i=0;i<this->length;i++)
        {
                this->data[i] *= m.data[i];
        }
        
        return *this;
}

template< class T >
Vector<T>& Vector<T>::Divide(Vector<T>& m)
{
        if(length != m.length)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Vector lengths are not the same!");
        }

        for(int i=0;i<this->length;i++)
        {
                if(m.data[i] != 0)
                {
                        this->data[i] /= m.data[i];
                }
                else
                {
                        cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                        Utility::RunTimeError("Divide by zero in vector division!");
                }
        }
        
        return *this;
}

// Add value to "this" vector
template< class T >
Vector<T>& Vector<T>::Add(T v)
{
        for(int i=0;i<this->length;i++)
        {
                this->data[i] += v;
        }
        return *this;
}

template< class T >
Vector<T>& Vector<T>::Subtract(T v)
{
        for(int i=0;i<this->length;i++)
        {
                this->data[i] -= v;
        }
        return *this;
}

template< class T >
Vector<T>& Vector<T>::Multiply(T v)
{
        for(int i=0;i<this->length;i++)
        {
                this->data[i] *= v;
        }
        return *this;
}

template< class T >
Vector<T>& Vector<T>::Divide(T v)
{
        if(v == 0)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Divide by zero in vector by value division!");
        }
        
        for(int i=0;i<this->length;i++)
        {
                this->data[i] /= v;
        }
        return *this;
}




//OPERATORS

template< class T >
Vector<T>& Vector<T>::operator= (Vector<T>& m)
{
        
        if(m.memoryManaged == true && memoryManaged == true)
        {
                length = m.length;
                data = m.data;
                delete clean;
                clean = new (std::nothrow) Cleaner<T>(data);
                Utility::CheckPointer(clean);
        }
        else if(m.memoryManaged == false && memoryManaged == true)
        {
                length = m.length;
                data = new (std::nothrow) T[length];
                Utility::CheckPointer(data);
                clean = new (std::nothrow) Cleaner<T>(data);
                Utility::CheckPointer(clean);
                for(int j=0;j<length;j++)
                {
                        data[j] = m.data[j];
                }
                Utility::Warning("Using assignment from an unmanaged vector!\nValues are copied to the new vector.");
                //Utility::RunTimeError("Assignment of an unmanaged vector to another vector is not allowed!\nUse Clone() instead.");
        }
        else if(memoryManaged == false)
        {
                if(length == m.length)
                {
                        for(int j=0;j<length;j++)
                        {
                                data[j] = m.data[j];
                        }
                        Utility::Warning("Using assignment to an unmanaged vector!\nValues are copied.");
                }
                else
                {
                        cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                        Utility::RunTimeError("Assignment to an unmanaged vector. Lengths of the vectors must match!");
                }
        }
        else
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Something is wrong. We shouldn't arrive to this branch!");
        }
        
        return *this;
}


template< class T >
Vector<T>& Vector<T>::operator= (Array<T>& m)
{
        if(memoryManaged == true)
        {
                length = m.length;
                
                data = m.data;
                clean = new (std::nothrow) Cleaner(data);
                Utility::CheckPointer(clean);
        }
        else
        {
                if(length == m.length)
                {
                        for(int j=0;j<length;j++)
                        {
                                data[j] = m.data[j];
                        }
                        Utility::Warning("Using assignment to an unmanaged vector!\nValues are copied.");
                }
                else
                {
                        cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                        Utility::RunTimeError("Assignment to an unmanaged vector. Number of elements in vector and array must match!");
                }
        }

        return *this;
}

template< class T >
Vector<T>& Vector<T>::operator= (Matrix<T>& m)
{
        if(memoryManaged == true)
        {
                length = m.length;
                
                data = m.data;
                clean = new (std::nothrow) Cleaner(data);
                Utility::CheckPointer(clean);
        }
        else
        {
                if(length == m.length)
                {
                        for(int j=0;j<length;j++)
                        {
                                data[j] = m.data[j];
                        }
                        Utility::Warning("Using assignment to an unmanaged vector!\nValues are copied.");
                }
                else
                {
                        cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                        Utility::RunTimeError("Assignment to an unmanaged vector. Number of elements in vector and array must match!");
                }
        }

        return *this;
}



template< class T >
Vector<T>& Vector<T>::operator= (string str)
{
        Vector<T> temp(str);
        *this = temp;
        return *this;
}



//Unary operators
template< class T >
inline Vector<T> Vector<T>::operator+ ()
{
        return *this;
}


template< class T >
inline Vector<T> Vector<T>::operator- ()
{
        Vector<T> temp(length);
        for(int i=0;i<length;i++)
        {
                temp.data[i] = - data[i];
        }
        return temp;
}


template< class T >
inline Vector<int> Vector<T>::operator! ()
{
        Vector<int> temp(yDim, xDim);
        for(int i=0;i<length;i++)
        {
                if(data[i] == 0)
                {
                        temp.Data()[i] = 1;
                }
                else
                {
                        temp.Data()[i] = 0;
                }
        }
        return temp;
}




template< class T >
inline T& Vector<T>::operator() (const int i)
{
        if(i<0 || i>=length)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Index outside bounds!");
        }
        return data[i];
}


template< class T >
inline T& Vector<T>::operator[] (const int i)
{
        return data[i];
}




// slice: returns a new vector.
//template< class T >
//inline Vector<T> Vector<T>::operator() (int start, int end)
//{
//
//      if(start<0 || start>=length || end<0 || end>=length)
//      {
//              cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
//              Utility::RunTimeError("Index outside bounds!");
//      }
//      
//      if(start > end)
//      {
//              cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
//              Utility::RunTimeError("Second slice parameter cannot be less than the first parameter!");
//      }
//      
//      Vector<T> temp(end-start+1);
//      //memcopy here...
//      for(int i=start; i<=end; i++)
//      {
//              temp[i-start] = data[i];
//      }
//
//      return temp;
//}

template< class T >
inline Vector<T> Vector<T>::operator() (int start, int end)
{
        if(start<0 || start>=length || end<0 || end>=length)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Index outside bounds!");
        }
        if(start > end)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Second slice parameter cannot be less than the first parameter!");
        }


        Vector<T> temp(&(data[start]), end-start+1);
        return temp;
}


template< class T >
inline Vector<T> Vector<T>::operator() (string str)
{
        int start, end;
        vector<string> bounds = Utility::Split(str, ":");
        
        if(str == ":")
        {
                start = 0;
                end = length-1;
        }
        else if(bounds.size() == 2)
        {
                start = Utility::ToInt(bounds[0]);
                end = Utility::ToInt(bounds[1]);
        }
        else
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Incorrect slice argument. String cannot be parsed!");
        }

        return this->operator()(start, end);


}




template< class T >
inline Vector<T> Vector<T>::operator() (Vector<int>& ind)
{
        Vector<T> temp(ind.Length());
        for(int i=0; i<ind.Length(); i++)
        {
                if(ind.ElemNC(i) >= length)
                {
                        cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                        Utility::RunTimeError("Index outside bounds!");
                }
                temp.data[i] = data[ind.ElemNC(i)];
        }
        return temp;
}





template< class T >
inline T& Vector<T>::Elem(const int i)
{
        if(i<0 || i>=length)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Index outside bounds!");
        }
        return data[i];
}

template< class T >
inline T& Vector<T>::ElemNC(const int i)
{
        return data[i];
}







// Add inline
template< class T >
Vector<T>& Vector<T>::operator+= (Vector<T>& m)
{
        return this->Add(m);
}

template< class T >
Vector<T>& Vector<T>::operator-= (Vector<T>& m)
{
        return this->Subtract(m);
}

template< class T >
Vector<T>& Vector<T>::operator*= (Vector<T>& m)
{
        return this->Multiply(m);
}

template< class T >
Vector<T>& Vector<T>::operator/= (Vector<T>& m)
{
        return this->Divide(m);
}


template< class T >
Vector<T>& Vector<T>::operator+= (T v)
{
        return this->Add(v);
}

template< class T >
Vector<T>& Vector<T>::operator-= (T v)
{
        return this->Subtract(v);
}

template< class T >
Vector<T>& Vector<T>::operator*= (T v)
{
        return this->Multiply(v);
}

template< class T >
Vector<T>& Vector<T>::operator/= (T v)
{
        return this->Divide(v);
}





// Converting constructors
template< class T >
Vector<T>::Vector(Matrix<T> &m) 
{
        length = m.length;
        
        data = m.data;
        
        clean = new (std::nothrow) Cleaner<T>(data);
        Utility::CheckPointer(clean);
        
        memoryManaged = true;
        
}




template< class T >
Vector<T>::Vector(Array<T> &m) 
{
        length = m.length;
        
        data = m.data;
        
        clean = new (std::nothrow) Cleaner<T>(data);
        Utility::CheckPointer(clean);
        
        memoryManaged = true;

}








}; //namespace

---