Array.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 Implementation


template< class T >
Array<T>::Array() 
        : ndims(0), length(0)
{
        dims = 0;
        data = 0;
        clean = 0;

}


template< class T >
Array<T>::Array(const int xdim)
{
        if(xdim < 1)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("All array dimensions should be larger than 0!");
        }

        ndims = 1;
        length = xdim;
        dims = new (std::nothrow) int[1];
        Utility::CheckPointer(dims);
        dims[0] = xdim;
        data = new (std::nothrow) T[length];
        Utility::CheckPointer(data);

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


template< class T >
Array<T>::Array(const int xdim, const int ydim)
{
        if(xdim < 1 || ydim < 1)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("All array dimensions should be larger than 0!");
        }

        ndims = 2;
        length = xdim*ydim;
        dims = new (std::nothrow) int[2];
        Utility::CheckPointer(dims);
        dims[0] = xdim;
        dims[1] = ydim;
        data = new (std::nothrow) T[length];
        Utility::CheckPointer(data);

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


template< class T >
Array<T>::Array(const int xdim, const int ydim, const int zdim)
{
        if(xdim < 1 || ydim < 1 || zdim < 1)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("All array dimensions should be larger than 0!");
        }
        ndims = 3;
        length = xdim*ydim*zdim;
        dims = new (std::nothrow) int[3];
        Utility::CheckPointer(dims);
        dims[0] = xdim;
        dims[1] = ydim;
        dims[2] = zdim;
        data = new (std::nothrow) T[length];
        Utility::CheckPointer(data);

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

}


template< class T >
Array<T>::Array(const int xdim, const int ydim, const int zdim, const int extradim, ...)
{
        int *temp = new (std::nothrow) int[10];
        Utility::CheckPointer(temp);
        
        temp[0] = xdim;
        temp[1] = ydim;
        temp[2] = zdim;
        temp[3] = extradim;

        va_list argptr;
        va_start(argptr, extradim);
        int i = 4;
        int a;
        while((a = va_arg(argptr, int)) > 0 && i<10)
        {
                temp[i] = a;
                i++;
        }
        va_end(argptr);

        if(a>=0)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("To create multidimensional arrays of dimension 4 or higher, an extra dimension should be entered as -1 at the end. Dimensionality of arrays cannot exceed 10 !");
        }

        ndims = i;
        length = 1;
        dims = new (std::nothrow) int[ndims];
        Utility::CheckPointer(dims);

        for(int j=0;j<ndims;j++)
        {
                if(temp[j] < 1)
                {
                        cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                        Utility::RunTimeError("All array dimensions should be larger than 1!");
                }

                length *= temp[j];
                dims[j] = temp[j];
        }
        data = new (std::nothrow) T[length];
        Utility::CheckPointer(data);

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


template< class T >
Array<T>::Array(const int _ndims, const int* _dims) 
        : ndims(_ndims)
{
        dims = new (std::nothrow) int[ndims];
        Utility::CheckPointer(dims);
        
        length = 1;
        for(int j=0;j<ndims;j++)
        {
                dims[j] = _dims[j];
                length *= _dims[j];
        }
        data = new (std::nothrow) T[length];
        Utility::CheckPointer(data);

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

}


// copies only the data pointer.
template< class T >
Array<T>::Array(Array<T> &m) 
        : ndims(m.ndims), length(m.length)
{
        dims = new (std::nothrow) int[ndims];
        Utility::CheckPointer(dims);
        
        for(int j=0;j<ndims;j++)
        {
                dims[j] = m.dims[j];
        }

        data = m.data;

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

}


template< class T >
Array<T>::~Array()
{
//      cout << "Array destroyed" << endl;
        delete [] dims;
        
        // Collect garbage
        delete clean;
}


// Useful for passing data to third party libraries.
template< class T >
inline const T* Array<T>::DataPtr()
{
        return data;
}

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



template< class T >
Array<T> Array<T>::Clone() const
{
        Array<T> temp(this->ndims, this->dims);

        // memcopy here...
        for(int j=0;j<temp.length;j++)
        {
                temp.data[j] = this->data[j];
        }


        return temp;
}






template< class T >
inline const int Array<T>::XDim() const
{
        return dims[0];
}

template< class T >
inline const int Array<T>::YDim() const
{
        if(ndims < 2)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("YDim(): Number of dimensions is less than 2!");
        }
        return dims[1];
}

template< class T >
inline const int Array<T>::ZDim() const
{
        if(ndims < 3)
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("ZDim(): Number of dimensions is less than 3!");
        }
        return dims[2];
}

template< class T >
inline const int* Array<T>::Dims() const
{
        return dims;
}

template< class T >
inline const int* Array<T>::Size() const
{
        return dims;
}

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

template< class T >
inline int Array<T>::NDims() const
{
        return ndims;
}

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













template< class T >
bool Array<T>::IsCompatible(Array<T>& m1, Array<T>& m2)
{
        bool temp = true;
        if(m1.ndims != m2.ndims)
        {
                temp = false;
        }
        else
        {
                for(int i=0; i<m1.ndims; i++)
                {
                        if(m1.dims[i] != m2.dims[i])
                        {
                                temp = false;
                                break;
                        }
                }
        }

        return temp;
}





// Boolean Operations...
template< class T >
Array<int> Array<T>::And(Array<T>& m1, Array<T>& m2)
{
        if(!Array<T>::IsCompatible(m1, m2))
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Array sizes are not compatible!");
        }

        Array<int> temp(m1.ndims, m1.dims);
        for(int i=0;i<temp.Length();i++)
        {
                temp[i] = (m1.data[i] != 0 && m2.data[i] != 0) ? 1 : 0;
        }
        
        return temp;
}


template< class T >
Array<int> Array<T>::Or(Array<T>& m1, Array<T>& m2)
{
        if(!Array<T>::IsCompatible(m1, m2))
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Array sizes are not compatible!");
        }

        Array<int> temp(m1.ndims, m1.dims);
        for(int i=0;i<temp.Length();i++)
        {
                temp[i] = (m1.data[i] == 0 && m2.data[i] == 0) ? 0 : 1;
        }
        
        return temp;
}


template< class T >
Array<int> Array<T>::Lt(Array<T>& m1, Array<T>& m2)
{
        if(!Array<T>::IsCompatible(m1, m2))
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Array sizes are not compatible!");
        }

        Array<int> temp(m1.ndims, m1.dims);
        for(int i=0;i<temp.Length();i++)
        {
                temp[i] = (m1.data[i] < m2.data[i]) ? 1 : 0;
        }
        
        return temp;
}


template< class T >
Array<int> Array<T>::Gt(Array<T>& m1, Array<T>& m2)
{
        if(!Array<T>::IsCompatible(m1, m2))
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Array sizes are not compatible!");
        }

        Array<int> temp(m1.ndims, m1.dims);
        for(int i=0;i<temp.Length();i++)
        {
                temp[i] = (m1.data[i] > m2.data[i]) ? 1 : 0;
        }
        
        return temp;
}


template< class T >
Array<int> Array<T>::Le(Array<T>& m1, Array<T>& m2)
{
        if(!Array<T>::IsCompatible(m1, m2))
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Array sizes are not compatible!");
        }

        Array<int> temp(m1.ndims, m1.dims);
        for(int i=0;i<temp.Length();i++)
        {
                temp[i] = (m1.data[i] <= m2.data[i]) ? 1 : 0;
        }
        
        return temp;
}


template< class T >
Array<int> Array<T>::Ge(Array<T>& m1, Array<T>& m2)
{
        if(!Array<T>::IsCompatible(m1, m2))
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Array sizes are not compatible!");
        }

        Array<int> temp(m1.ndims, m1.dims);
        for(int i=0;i<temp.Length();i++)
        {
                temp[i] = (m1.data[i] >= m2.data[i]) ? 1 : 0;
        }
        
        return temp;
}


template< class T >
Array<int> Array<T>::Eq(Array<T>& m1, Array<T>& m2)
{
        if(!Array<T>::IsCompatible(m1, m2))
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Array sizes are not compatible!");
        }

        Array<int> temp(m1.ndims, m1.dims);
        for(int i=0;i<temp.Length();i++)
        {
                temp[i] = (m1.data[i] == m2.data[i]) ? 1 : 0;
        }
        
        return temp;
}


template< class T >
Array<int> Array<T>::Ne(Array<T>& m1, Array<T>& m2)
{
        if(!Array<T>::IsCompatible(m1, m2))
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Array sizes are not compatible!");
        }

        Array<int> temp(m1.ndims, m1.dims);
        for(int i=0;i<temp.Length();i++)
        {
                temp[i] = (m1.data[i] != m2.data[i]) ? 1 : 0;
        }
        
        return temp;
}








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


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


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


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


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


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


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


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










// Add matrix to another matrix
template< class T >
Array<T> Array<T>::Add(Array<T>& m1, Array<T>& m2)
{
        if(!Array<T>::IsCompatible(m1, m2))
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Array sizes are not compatible!");
        }

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


template< class T >
Array<T> Array<T>::Subtract(Array<T>& m1, Array<T>& m2)
{
        if(!Array<T>::IsCompatible(m1, m2))
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Array sizes are not compatible!");
        }

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


template< class T >
Array<T> Array<T>::Multiply(Array<T>& m1, Array<T>& m2)
{
        if(!Array<T>::IsCompatible(m1, m2))
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Array sizes are not compatible!");
        }

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


template< class T >
Array<T> Array<T>::Divide(Array<T>& m1, Array<T>& m2)
{
        if(!Array<T>::IsCompatible(m1, m2))
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Array sizes are not compatible!");
        }

        Array<T> temp(m1.ndims, m1.dims);
        for(int i=0;i<temp.length;i++)
        {
                //catch division exception instead... Future work
                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 matrix division!");
                }
        }
        
        return temp;
}


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


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


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


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


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

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


template< class T >
Array<T> Array<T>::Divide(T v2, Array<T>& m1)
{
        Array<T> temp(m1.ndims, m1.dims);
        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 matrix division!");
                }
        }
        return temp;
}



// Add matrix to "this" matrix
template< class T >
Array<T>& Array<T>::Add(Array<T>& m)
{
        if(!Array<T>::IsCompatible(*this, m))
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Array sizes are not compatible!");
        }

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


template< class T >
Array<T>& Array<T>::Subtract(Array<T>& m)
{
        if(!Array<T>::IsCompatible(*this, m))
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Array sizes are not compatible!");
        }

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


template< class T >
Array<T>& Array<T>::Multiply(Array<T>& m)
{
        if(!Array<T>::IsCompatible(*this, m))
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Array sizes are not compatible!");
        }

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


template< class T >
Array<T>& Array<T>::Divide(Array<T>& m)
{
        if(!Array<T>::IsCompatible(*this, m))
        {
                cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                Utility::RunTimeError("Array sizes are not compatible!");
        }

        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 matrix division!");
                }
        }
        
        return *this;
}


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


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


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


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












// OPERATORS


template< class T >
Array<T>& Array<T>::operator= (Array<T>& m)
{
        ndims = m.ndims;
        length = m.length;
        dims = new (std::nothrow) int[ndims];
        Utility::CheckPointer(dims);

        for(int j=0;j<ndims;j++)
        {
                dims[j] = m.dims[j];
        }
        data = m.data;

        delete clean;
        clean = new (std::nothrow) Cleaner<T>(data);
        Utility::CheckPointer(clean);   
        
        return *this;
}

template< class T >
Array<T>& Array<T>::operator= (Matrix<T>& m)
{
        ndims = m.ndims;
        length = m.length;
        dims = new (std::nothrow) int[ndims];
        Utility::CheckPointer(dims);

        dims[0] = m.xDim;
        dims[1] = m.yDim;
        data = m.data;
        
        delete clean;
        clean = new (std::nothrow) Cleaner<T>(data);
        Utility::CheckPointer(clean);
        
        return *this;
}





// Unary +-!
template< class T >
inline Array<T> Array<T>::operator+ ()
{
        return *this;
}

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

template< class T >
inline Array<int> Array<T>::operator! ()
{
        Array<int> temp(this->ndims, this->dims);
        for(int i=0;i<length;i++)
        {
                if(data[i] == 0)
                {
                        temp[i] = 1;
                }
                else
                {
                        temp[i] = 0;
                }
        }
        return temp;
}






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




        // no bounds checking...
template< class T >
inline T& Array<T>::operator[] (const int i)
{
        return data[i];
}


        

template< class T >
inline T& Array<T>::operator() (const int i, const int j, ...)
{
        int *temp = new (std::nothrow) int[ndims];
        Utility::CheckPointer(temp);
        temp[0] = i;
        temp[1] = j;

        va_list argptr;
        va_start(argptr, j);
        int lim = 2;
        int a;
        while(lim<ndims)
        {
                a = va_arg(argptr, int);
                if(a<0 || a>=dims[lim])
                {
                        cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                        Utility::RunTimeError("Index outside bounds!");
                }

                temp[lim] = a;
                lim++;
        }
        va_end(argptr);

        int ind = 0;
        for(int it=0;it<lim;it++)
        {
                int tempDim = 1;
                for(int it2=0;it2<it;it2++)
                {
                        tempDim *= dims[it2];
                }

                ind += temp[it]*tempDim;
        }

        return data[ind];
}



template< class T >
inline T& Array<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& Array<T>::ElemNC(const int i)
{
        return data[i];
}


template< class T >
inline T& Array<T>::Elem(const int i, const int j, ...)
{
        int *temp = new (std::nothrow) int[ndims];
        Utility::CheckPointer(temp);
        temp[0] = i;
        temp[1] = j;

        va_list argptr;
        va_start(argptr, j);
        int lim = 2;
        int a;
        while(lim<ndims)
        {
                a = va_arg(argptr, int);
                if(a<0 || a>=dims[lim])
                {
                        cerr << "Line: " << __LINE__ << " File: " << __FILE__ << endl;
                        Utility::RunTimeError("Index outside bounds!");
                }

                temp[lim] = a;
                lim++;
        }
        va_end(argptr);

        int ind = 0;
        for(int it=0;it<lim;it++)
        {
                int tempDim = 1;
                for(int it2=0;it2<it;it2++)
                {
                        tempDim *= dims[it2];
                }

                ind += temp[it]*tempDim;
        }

        return data[ind];
}


template< class T >
inline T& Array<T>::ElemNC(const int i, const int j, ...)
{
        int *temp = new (std::nothrow) int[ndims];
        Utility::CheckPointer(temp);
        temp[0] = i;
        temp[1] = j;

        va_list argptr;
        va_start(argptr, j);
        int lim = 2;
        int a;
        while(lim<ndims)
        {
                a = va_arg(argptr, int);
                temp[lim] = a;
                lim++;
        }
        va_end(argptr);

        int ind = 0;
        for(int it=0;it<lim;it++)
        {
                int tempDim = 1;
                for(int it2=0;it2<it;it2++)
                {
                        tempDim *= dims[it2];
                }

                ind += temp[it]*tempDim;
        }

        return data[ind];
}





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

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

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

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


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

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

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

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



template< class T >
Array<T>::Array(Matrix<T> &m) 
{
        ndims = m.ndims;
        length = m.length;
        dims = new (std::nothrow) int[ndims];
        Utility::CheckPointer(dims);
        
        dims[0] = m.xDim;
        dims[1] = m.yDim;
        data = m.data;
        
        clean = new (std::nothrow) Cleaner<T>(data);
        Utility::CheckPointer(clean);
        
}








}; //namespace

---