dgGeneralVector.h

/* Copyright (c) <2003-2011> <Julio Jerez, Newton Game Dynamics>
*
* This software is provided 'as-is', without any express or implied
* warranty. In no event will the authors be held liable for any damages
* arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose,
* including commercial applications, and to alter it and redistribute it
* freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not
* claim that you wrote the original software. If you use this software
* in a product, an acknowledgment in the product documentation would be
* appreciated but is not required.
*
* 2. Altered source versions must be plainly marked as such, and must not be
* misrepresented as being the original software.
*
* 3. This notice may not be removed or altered from any source distribution.
*/

#ifndef __dgGeneralVector__
#define __dgGeneralVector__

#include "dgStdafx.h"
#include "dgDebug.h"

#define DG_COUNT_FLOAT_OPS

template<class T> class dgSPDMatrix;
template<class T> class dgGeneralMatrix;

template<class T>
class dgGeneralVector {
    friend class dgSPDMatrix<T>;
    friend class dgGeneralMatrix<T>;

public:
    dgGeneralVector(dgInt32 size);
    dgGeneralVector(dgInt32 size, T *mem);
    dgGeneralVector(const dgGeneralVector<T> &src);
    dgGeneralVector(const dgGeneralVector<T> &src, T *mem);

    ~dgGeneralVector();

    T &operator[](dgInt32 i);
    const T &operator[](dgInt32 i) const;

    dgInt32 GetRowCount() const;

    void Clear(T val);
    void Copy(const dgGeneralVector<T> &src);
    T DotProduct(const dgGeneralVector &b) const;
    T Norm() const;
    T Norm2() const;

    void operator += (const dgGeneralVector &A);
    void operator -= (const dgGeneralVector &A);

    void Scale(T scale);
    void LinearCombine(T scale, const dgGeneralVector &A, const dgGeneralVector &B);


    static dgInt32 GetFloatOps();
    static dgInt32 GetMemWrites();

    static void SetFloatOps(dgInt32 initialCount = 0);
    static void SetMemWrites(dgInt32 initialCount = 0);

    void Trace() const;


protected:
    bool m_ownMemory;
    dgInt32 m_colCount;
    T *m_columns;

    static dgInt32 m_floatsOp;
    static dgInt32 m_memoryWrite;


    dgGeneralVector();
};


// ***********************************************************************************************
//
//  vector
//
// ***********************************************************************************************
template<class T>
dgGeneralVector<T>::dgGeneralVector() {
    m_ownMemory = false;
    m_colCount = 0;
    m_columns = NULL;
}

template<class T>
dgGeneralVector<T>::dgGeneralVector(dgInt32 size) {
    NEWTON_ASSERT(size > 0);
    m_ownMemory = true;
    m_colCount = size;
    m_columns = new T[size];
    NEWTON_ASSERT((((dgUnsigned32) m_columns) & 0x0f) == 0);
}

template<class T>
dgGeneralVector<T>::dgGeneralVector(dgInt32 size, T *mem) {
    m_ownMemory = false;
    m_colCount = size;
    m_columns = mem;
    NEWTON_ASSERT((((dgUnsigned32) m_columns) & 0x0f) == 0);
}

template<class T>
dgGeneralVector<T>::dgGeneralVector(const dgGeneralVector<T> &src) {
    m_ownMemory = true;
    m_colCount = src.m_colCount;
    m_columns = new T[m_colCount];
    NEWTON_ASSERT((((dgUnsigned32) m_columns) & 0x0f) == 0);

    Copy(src);
}

template<class T>
dgGeneralVector<T>::dgGeneralVector(const dgGeneralVector<T> &src,  T *mem) {
    m_ownMemory = false;
    m_colCount = src.m_colCount;
    m_columns = mem;
    NEWTON_ASSERT((((dgUnsigned32) m_columns) & 0x0f) == 0);

    Copy(src);
}


template<class T>
dgInt32 dgGeneralVector<T>::GetFloatOps() {
    return m_floatsOp;
}

template<class T>
void dgGeneralVector<T>::SetFloatOps(dgInt32 initialCount) {
    m_floatsOp = initialCount;
}


template<class T>
dgInt32 dgGeneralVector<T>::GetMemWrites() {
    return m_memoryWrite;
}


template<class T>
void dgGeneralVector<T>::SetMemWrites(dgInt32 initialCount) {
    m_memoryWrite = initialCount;
}



template<class T>
dgGeneralVector<T>::~dgGeneralVector() {
    if (m_ownMemory) {
        delete[] m_columns;
    }
}

template<class T>
void dgGeneralVector<T>::Trace() const {
    dgInt32 i;
    for (i = 0; i < m_colCount; i ++) {
        dgTrace(("%f ", m_columns[i]));

    }
    dgTrace(("\n"));
}



template<class T>
T &dgGeneralVector<T>::operator[](dgInt32 i) {
    NEWTON_ASSERT(i < m_colCount);
    NEWTON_ASSERT(i >= 0);
    return m_columns[i];
}

template<class T>
const T &dgGeneralVector<T>::operator[](dgInt32 i) const {
    NEWTON_ASSERT(i < m_colCount);
    NEWTON_ASSERT(i >= 0);
    return m_columns[i];
}

template<class T>
dgInt32 dgGeneralVector<T>::GetRowCount() const {
    return m_colCount;
}


// return dot product
template<class T>
T dgGeneralVector<T>::DotProduct(const dgGeneralVector<T> &A) const {
    dgInt32 i;

    NEWTON_ASSERT(m_colCount == A.m_colCount);
    T val(0.0);
    for (i = 0; i < m_colCount; i ++) {
        val = val + m_columns[i] * A.m_columns[i];
    }

#ifdef DG_COUNT_FLOAT_OPS
    m_floatsOp += 2 * m_colCount;
    m_memoryWrite += m_colCount;
#endif

    return val;
}




template<class T>
void dgGeneralVector<T>::Clear(T val) {
    dgInt32 i;
    for (i = 0; i < m_colCount; i ++) {
        m_columns[i] = val;
    }

#ifdef DG_COUNT_FLOAT_OPS
    m_memoryWrite += m_colCount;
#endif
}

template<class T>
void dgGeneralVector<T>::Copy(const dgGeneralVector<T> &src) {
    dgInt32 i;

    NEWTON_ASSERT(m_colCount == src.m_colCount);
    for (i = 0; i < m_colCount; i ++) {
        m_columns[i] = src.m_columns[i];
    }

#ifdef DG_COUNT_FLOAT_OPS
    m_memoryWrite += m_colCount;
#endif
}



template<class T>
void dgGeneralVector<T>::Scale(T scale) {
    dgInt32 i;
    for (i = 0; i < m_colCount; i ++) {
        m_columns[i] = m_columns[i] * scale;
    }

#ifdef DG_COUNT_FLOAT_OPS
    m_floatsOp += m_colCount;
    m_memoryWrite += m_colCount;
#endif
}


template<class T>
T dgGeneralVector<T>::Norm2() const {
    dgInt32 i;
    T max;

    max = 0;
    for (i = 0; i < m_colCount; i ++) {
        max = GetMax(m_columns[i] * m_columns[i], max);
    }

#ifdef DG_COUNT_FLOAT_OPS
    m_floatsOp += m_colCount;
    m_memoryWrite += m_colCount;
#endif

    return max;
}

template<class T>
T dgGeneralVector<T>::Norm() const {
    return T(sqrt(Norm2()));
}


template<class T>
void dgGeneralVector<T>::LinearCombine(T scale, const dgGeneralVector<T> &A, const dgGeneralVector<T> &B) {
    dgInt32 i;

    NEWTON_ASSERT(A.m_colCount == m_colCount);
    NEWTON_ASSERT(B.m_colCount == m_colCount);
    for (i = 0; i < m_colCount; i ++) {
        m_columns[i] = A.m_columns[i] * scale + B.m_columns[i];
    }

#ifdef DG_COUNT_FLOAT_OPS
    m_floatsOp += 3 * m_colCount;
    m_memoryWrite += m_colCount;
#endif
}


template<class T>
void dgGeneralVector<T>::operator+= (const dgGeneralVector<T> &A) {
    dgInt32 i;

    NEWTON_ASSERT(A.m_colCount == m_colCount);
    for (i = 0; i < m_colCount; i ++) {
        m_columns[i] += A.m_columns[i];
    }

#ifdef DG_COUNT_FLOAT_OPS
    m_floatsOp += m_colCount;
    m_memoryWrite += m_colCount;
#endif
}

template<class T>
void dgGeneralVector<T>::operator-= (const dgGeneralVector<T> &A) {
    dgInt32 i;

    NEWTON_ASSERT(A.m_colCount == m_colCount);
    for (i = 0; i < m_colCount; i ++) {
        m_columns[i] -= A.m_columns[i];
    }

#ifdef DG_COUNT_FLOAT_OPS
    m_floatsOp += m_colCount;
    m_memoryWrite += m_colCount;
#endif
}


template<class T> dgInt32 dgGeneralVector <T>::m_floatsOp = 0;
template<class T> dgInt32 dgGeneralVector <T>::m_memoryWrite = 0;


#endif