vector.inl

Go to the documentation of this file.

/*
    Sheep - A Rigid Body Dynamics Engine
    Copyright (C) 2001-2004 Francois Beaune
    Contact: http://toxicengine.sourceforge.net/

    This file is part of Sheep.

    Sheep 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.

    Sheep is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Sheep; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#define LOOP(OP) for(int i = 0; i < m_d; ++i) OP;

inline
Vector::Vector(int d) {
    assert(d > 0);

    m_d = d;
    m_v = new Real[m_d];
}

inline
Vector::Vector(int d, Real r) {
    assert(d > 0);

    m_d = d;
    m_v = new Real[m_d];

    LOOP(m_v[i] = r);
}

inline
Vector::Vector(const Vector &v) {
    m_d = v.m_d;
    m_v = new Real[m_d];

    LOOP(m_v[i] = v.m_v[i]);
}

inline
Vector::~Vector() {
    delete [] m_v;
}

inline
Vector &Vector::operator=(Real r) {
    LOOP(m_v[i] = r);

    return *this;
}

inline
Vector &Vector::operator=(const Vector &v) {
    assert(m_d == v.m_d);

    LOOP(m_v[i] = v.m_v[i]);

    return *this;
}

inline
int Vector::GetDimension() const {
    return m_d;
}

inline
Vector Vector::operator+(const Vector &v) const {
    assert(m_d == v.m_d);

    Vector res(m_d);

    LOOP(res.m_v[i] = m_v[i] + v.m_v[i]);

    return res;
}

inline
Vector Vector::operator-(const Vector &v) const {
    assert(m_d == v.m_d);

    Vector res(m_d);

    LOOP(res.m_v[i] = m_v[i] - v.m_v[i]);

    return res;
}

inline
Vector Vector::operator-() const {
    Vector res(m_d);

    LOOP(res.m_v[i] = -m_v[i]);

    return res;
}

inline
Vector Vector::operator*(Real r) const {
    Vector res(m_d);

    LOOP(res.m_v[i] = m_v[i] * r);

    return res;
}

inline
Vector Vector::operator/(Real r) const {
    Real inv_r = 1.0 / r;

    Vector res(m_d);

    LOOP(res.m_v[i] = m_v[i] * inv_r);

    return res;
}

inline
Vector &Vector::operator+=(const Vector &v) {
    assert(m_d == v.m_d);

    LOOP(m_v[i] += v.m_v[i]);

    return *this;
}

inline
Vector &Vector::operator-=(const Vector &v) {
    assert(m_d == v.m_d);

    LOOP(m_v[i] -= v.m_v[i]);

    return *this;
}

inline
Vector &Vector::operator*=(Real r) {
    LOOP(m_v[i] *= r);

    return *this;
}

inline
Vector &Vector::operator/=(Real r) {
    Real inv_r = 1.0 / r;

    LOOP(m_v[i] *= inv_r);

    return *this;
}

inline
Real &Vector::operator[](int i) {
    assert(i >= 0);
    assert(i < m_d);

    return m_v[i];
}

inline
const Real &Vector::operator[](int i) const {
    assert(i >= 0);
    assert(i < m_d);

    return m_v[i];
}

inline
Real *Vector::GetData() {
    return m_v;
}

inline
Real Vector::SquareNorm() const {
    Real res = 0.0;

    LOOP(res += m_v[i] * m_v[i]);

    return res;
}

inline
Real Vector::Norm() const {
    return sqrt(SquareNorm());
}

inline
Vector Vector::Normalized() const {
    const Real n = Norm();

    if(n == 0.0) {
        Vector res(m_d);
        res.m_v[0] = 1.0;
        for(int i = 1; i < m_d; ++i)
            res.m_v[i] = 0.0;
        return res;
    } else return *this / n;
}

inline
void Vector::Normalize() {
    const Real n = Norm();

    if(n == 0.0) {
        m_v[0] = 1.0;
        for(int i = 1; i < m_d; ++i)
            m_v[i] = 0.0;
    } else {
        const Real inv_n = 1.0 / n;
        LOOP(m_v[i] *= inv_n);
    }
}

inline
bool Vector::IsUnitLength(Real e /*= EPS*/) const {
    return feq(SquareNorm(), 1.0, e);
}

inline
Vector operator*(Real r, const Vector &v) {
    return v * r;
}

#undef LOOP

---