src/colarray/vector.h

Go to the documentation of this file.

/***************************************************************************
                          vector.h  -  description
                             -------------------
    begin                : Mon Dec 15 2003
    copyright            : (C) 2003 by Roman Geus
    email                : roman.geus@psi.ch
***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef VECTOR_H
#define VECTOR_H

#include <iostream>
#include "blas_types.h"

namespace colarray {

    using blas::int_t;

    template <typename T> class Matrix;

    // declare friend operator before class: seems to be necessary for Borland C++
    template <typename T> class Vector;
    template <typename T>
    std::ostream& operator << (std::ostream&, const Vector<T> &);

    template <typename T>
    class Vector {
    public:
        int_t _n;
        int_t _inc;
        T* _v;                       
    protected:
        T* _data;
        int* _refCount;              

        // constructors
    public:
        Vector() : _n(0), _inc(0), _v(0), _data(0), _refCount(0) { }

        Vector(int_t n);

        Vector(const Vector& x, int_t start, int_t end) :
            _n(end - start), _inc(x._inc), _v(x._v + start*x._inc),
            _data(x._data),  _refCount(x._refCount)
        { if (_refCount) *_refCount += 1; }

        Vector(const Vector& a) : _n(a._n), _inc(a._inc), _v(a._v),
                                  _data(a._data), _refCount(a._refCount)
        { if (_refCount) *_refCount += 1; }

    protected:
        Vector(T* v, int_t n, int_t inc, T* data, int* refCount) :
            _n(n), _inc(inc), _v(v), _data(data), _refCount(refCount)
        { if (_refCount) *_refCount += 1; }

    public:
        // destructors
        ~Vector();

        // index operators
        const T& operator () (int_t i) const
        { return _v[i*_inc]; }
        T& operator () (int_t i)
        { return _v[i*_inc]; }
        const T& operator[] (int i) const
        { return _v[i*_inc]; }
        T& operator[] (int i)
        { return _v[i*_inc]; }


        // assignment operators
        inline Vector& operator= (const Vector&);
        T operator= (const T v);

        // methods
        void inject(const Vector<T> &x);

        friend std::ostream& operator << <T> (std::ostream&, const Vector<T> &);
    };

    template <typename T>
    class ColumnVector : public Vector<T> {
    public:
        ColumnVector() : Vector<T>() {}

        ColumnVector(int_t n) : Vector<T>(n) {}

        ColumnVector(const ColumnVector& x, int_t start, int_t end) :
            Vector<T>(x._v + start, end - start, 1, x._data, x._refcount) {}

        ColumnVector(const Matrix<T>& A, int_t i) :
            Vector<T>(A._v + A._ld*i, A._m, 1, A._data, A._refCount) {}

        ColumnVector(T* v, int n) :
            Vector<T>(v, n, 1, 0, 0) { }

        // index operators (faster because stride is 1)
        const T& operator () (int_t i) const
        { return (this->_v)[i]; }
        T& operator () (int_t i)
        { return (this->_v)[i]; }
        const T& operator[] (int i) const
        { return (this->_v)[i]; }
        T& operator[] (int i)
        { return (this->_v)[i]; }

        // no inheritance for the assignment operator
        inline T operator = (const T v) { return this->Vector<T>::operator=(v); }
    };


    template <typename T>
    class RowVector : public Vector<T> {
    public:

        RowVector(const Matrix<T>& a, int_t i) :
            Vector<T>(a._v + i, a._n, a._ld, a._data, a._refCount) {}

        // no inheritance for the assignment operator
        inline T operator = (const T v) { return this->Vector<T>::operator=(v); }
    };

} // namespace

//#include "vector.cpp"

/***************************************************************************
                          vector.cpp  -  description
                             -------------------
    begin                : Mon Dec 15 2003
    copyright            : (C) 2003 by Roman Geus
    email                : roman.geus@psi.ch
***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#include <cassert>
#include "vector.h"

namespace colarray {

    template <typename T>
    Vector<T>::Vector(int_t n) {
        _n = n;
        _inc = 1;
        _refCount = new int(1);
        _v = _data = new T[n];
#if 0
        std::cout << std::showbase << std::hex << this->v << std::endl << std::dec;
#endif
    }

    template <typename T>
    inline Vector<T>::~Vector() {
        if (_refCount) {
            *_refCount -= 1;
            if (*_refCount < 1) {
                delete [] _data;
                delete _refCount;
            }
        }
    }

    template <typename T>
    T Vector<T>::operator = (const T v) {
        for (int_t i = 0; i < _n; i ++)
            this->operator()(i) = v;
        return v;
    }

    template <typename T>
    inline Vector<T>& Vector<T>::operator= (const Vector<T>& x) {
        if (&x != this) {
            // delete old object
            if (_refCount) {
                *_refCount -= 1;
                if (*_refCount < 1) {
                    delete [] _data;
                    delete _refCount;
                }
            }
            // create new object
            _n = x._n;
            _inc = x._inc;
            _v = x._v;
            _data = x._data;
            _refCount = x._refCount;
            if (_refCount) *_refCount += 1;
        }
        return *this;
    }

    template <typename T>
    void Vector<T>::inject(const Vector<T> &x) {
        assert(_n == x._n);
        for (int_t i = 0; i < _n; i ++)
            this->operator()(i) = x(i);
    }

    template <typename T>
    std::ostream& operator << (std::ostream& ostr, const Vector<T>& x)
    {
        bool first = true;

        ostr << "Vector(" << x._n << ")" ;
        ostr << "{";
        for (int_t i = 0; i < x._n; i ++) {
            if (!first) {
                ostr << ", ";
            } else
                first = false;
            ostr << x(i);
        }
        ostr << "}";
        return ostr;
    }

} // namespace


#endif

---