|| || || || || ||

---

VectorTem.h

Go to the documentation of this file.

#ifndef Impala_Core_Vector_VectorTem_h
#define Impala_Core_Vector_VectorTem_h

#include <iostream>
#include "Basis/String.h"

namespace Impala
{
namespace Core
{
namespace Vector
{


template <class ElemT>
class VectorTem
{
public:

    VectorTem()
    {
        mSize = 0;
        mData = 0;
        mIsWrapper = false;
    }

    VectorTem(int n)
    {
        mSize = n;
        mData = new ElemT[mSize];
        mIsWrapper = false;
    }

    VectorTem(int n, ElemT* data, bool isWrapper)
    {
        mSize = n;
        mIsWrapper = isWrapper;
        mData = (mIsWrapper) ? data : new ElemT[n];
        if (!mIsWrapper)
            CopyData(n, data);
    }

    VectorTem(ElemT a0, ElemT a1)
    {
        mSize = 2;
        mData = new ElemT[mSize];
        mIsWrapper = false;
        mData[0] = a0;
        mData[1] = a1;
    }

    VectorTem(ElemT a0, ElemT a1, ElemT a2)
    {
        mSize = 3;
        mData = new ElemT[mSize];
        mIsWrapper = false;
        mData[0] = a0;
        mData[1] = a1;
        mData[2] = a2;
    }

    VectorTem(const VectorTem& v)
    {
        mSize = v.mSize;
        mIsWrapper = v.mIsWrapper;
        mData = (mIsWrapper) ? v.mData : new ElemT[mSize];
        if (!mIsWrapper)
            CopyData(mSize, v.mData);
    }

    virtual
    ~VectorTem()
    { 
        if (!mIsWrapper)
            delete [] mData; 
    }

    int
    Size() const
    { 
        return mSize; 
    }

    int
    Valid() const
    {
        return (mSize != 0);
    }

    VectorTem&
    operator=(const VectorTem& v)
    {
        if (this != &v)
        {
            if ((mSize != v.mSize) && (!mIsWrapper))
            {
                delete [] mData;
                mSize = v.mSize;
                mData = new ElemT[mSize];
            }
            CopyData(mSize, v.mData);
        }
        return *this;
    }

    void
    CopyData(int n, const ElemT* data, int begin=0)
    {
        for (int i=0 ; i<n && i+begin<Size() ; i++)
            mData[i+begin] = data[i];
    }

    VectorTem&
    operator=(ElemT a)
    {
        for (int i=0 ; i<mSize ; i++)
            mData[i] = a;
        return *this;
    }

    bool
    Equals(const VectorTem& arg) const
    {
        const int size = Size();

        if (size != arg.Size())
            return false;

        for (int i = 0; i < size; i++)
            if (mData[i] != arg[i])
                return false;

        return true;
    }

    ElemT&
    operator[](int i) const
    {
        return mData[i];
    }

    ElemT&
    Elem(int i) const
    {
        return mData[i];
    }

    ElemT*
    GetData()
    {
        return mData;
    }

    const ElemT*
    GetData() const
    {
        return mData;
    }

    // Print vector using ellipsis
    String
    PrintE(int nrElem) const
    {
        if (nrElem == -1)
            nrElem = Size();
        std::ostringstream oss;
        oss << "(";
        for (int i=0 ; i<Size() ; i++)
        {
            if ((i < nrElem) || (i >= Size() - nrElem))
            {
                oss << mData[i];
                if (i != Size() - 1)
                    oss << ",";
            }
            else
            {
                if (i == nrElem)
                    oss << "..., ";
            }
        }
        oss << ")";
        return oss.str();
    }

    template<class ElemTT>
    friend ElemTT
    operator*(const VectorTem<ElemTT>& a, const VectorTem<ElemTT>& b);

    template<class ElemTT>
    friend VectorTem<ElemTT>
    operator*(const ElemTT a, const VectorTem<ElemTT>& b);

    template<class ElemTT>
    friend VectorTem<ElemTT>
    operator*(const VectorTem<ElemTT>& a, const ElemTT b);

private:

    int    mSize;      // number of elements
    ElemT* mData;      // data pointer
    bool   mIsWrapper; // indicates whether we own mData
};

template <class ElemT>
VectorTem<ElemT> Append(const VectorTem<ElemT>& v1, const VectorTem<ElemT>& v2)
{
    VectorTem<ElemT> ret(v1.Size() + v2.Size());
    ret.CopyData(v1.Size(), v1.GetData());
    ret.CopyData(v2.Size(), v2.GetData(), v1.Size());
    return ret;
}

template <class ElemT>
inline std::ostream&
operator<<(std::ostream& os, const VectorTem<ElemT>& v)
{
    os << "(";
    for (int i=0 ; i<v.Size() ; i++)
    {
        os << v[i];
        if (i != v.Size() - 1)
            os << ",";
    }
    os << ")";
    return os;
}

template <class ElemT>
inline VectorTem<ElemT>
operator*(const VectorTem<ElemT>& a, ElemT b)
{
    VectorTem<ElemT> r(a);
    for (int i=0 ; i<r.mSize ; i++)
        r.mData[i] *= b;
    return r;
}

template <class ElemT>
inline VectorTem<ElemT>
operator*(ElemT a, const VectorTem<ElemT> &b)
{
    VectorTem<ElemT> r(b);
    for (int i=0 ; i<r.mSize ; i++)
        r.mData[i] *= a;
    return r;
}

template <class ElemT>
inline ElemT
operator*(const VectorTem<ElemT> &a, const VectorTem<ElemT> &b)
{
    if (a.mSize != b.mSize)
    {
        std::cerr << "nonconformant VectorTem * VectorTem operands." << std::endl;
        return 0;
    }
    ElemT sum = 0;
    int i;
    for (i=0 ; i<a.mSize ; i++)
        sum += a[i] * b[i];
    return sum;
}

} // namespace Vector
} // namespace Core
} // namespace Impala

#endif

---