Vector3d.h

Go to the documentation of this file.

/*
 * LSST Data Management System
 * Copyright 2014-2015 AURA/LSST.
 *
 * This product includes software developed by the
 * LSST Project (http://www.lsst.org/).
 *
 * 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 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 LSST License Statement and
 * the GNU General Public License along with this program.  If not,
 * see <https://www.lsstcorp.org/LegalNotices/>.
 */

#ifndef LSST_SPHGEOM_VECTOR3D_H_
#define LSST_SPHGEOM_VECTOR3D_H_


#include <cmath>
#include <iosfwd>
#include <limits>
#include <stdexcept>


namespace lsst {
namespace sphgeom {

// Forward declarations
class Angle;
class UnitVector3d;


class Vector3d {
public:
    Vector3d() { _v[0] = 0.0; _v[1] = 0.0; _v[2] = 0.0; }

    Vector3d(double x, double y, double z) { _v[0] = x; _v[1] = y; _v[2] = z; }

    bool operator==(Vector3d const & v) const {
        return _v[0] == v._v[0] && _v[1] == v._v[1] && _v[2] == v._v[2];
    }

    bool operator!=(Vector3d const & v) const {
        return _v[0] != v._v[0] || _v[1] != v._v[1] || _v[2] != v._v[2];
    }

    double const * getData() const { return _v; }

    double operator()(int i) const { return _v[i]; }

    double x() const { return _v[0]; }

    double y() const { return _v[1]; }

    double z() const { return _v[2]; }

    double dot(Vector3d const & v) const {
        return _v[0] * v._v[0] + _v[1] * v._v[1] + _v[2] * v._v[2];
    }

    double getSquaredNorm() const { return dot(*this); }

    double getNorm() const {
        return std::sqrt(getSquaredNorm());
    }

    bool isZero() const { return *this == Vector3d(); }

    double normalize();

    bool isNormalized() const {
        return std::fabs(1.0 - getSquaredNorm()) <= 1e-15;
    }

    Vector3d cross(Vector3d const & v) const {
        return Vector3d(_v[1] * v._v[2] - _v[2] * v._v[1],
                        _v[2] * v._v[0] - _v[0] * v._v[2],
                        _v[0] * v._v[1] - _v[1] * v._v[0]);
    }

    Vector3d operator-() const {
        return Vector3d(-_v[0],
                        -_v[1],
                        -_v[2]);
    }

    Vector3d operator*(double s) const {
        return Vector3d(_v[0] * s,
                        _v[1] * s,
                        _v[2] * s);
    }

    Vector3d operator/(double s) const {
        return Vector3d(_v[0] / s,
                        _v[1] / s,
                        _v[2] / s);
    }

    Vector3d operator+(Vector3d const & v) const {
        return Vector3d(_v[0] + v._v[0],
                        _v[1] + v._v[1],
                        _v[2] + v._v[2]);
    }

    Vector3d operator-(Vector3d const & v) const {
        return Vector3d(_v[0] - v._v[0],
                        _v[1] - v._v[1],
                        _v[2] - v._v[2]);
    }

    Vector3d & operator*=(double s) { *this = *this * s; return *this; }
    Vector3d & operator/=(double s) { *this = *this / s; return *this; }
    Vector3d & operator+=(Vector3d const & v) { *this = *this + v; return *this; }
    Vector3d & operator-=(Vector3d const & v) { *this = *this - v; return *this; }

    Vector3d cwiseProduct(Vector3d const & v) const {
        return Vector3d(_v[0] * v._v[0],
                        _v[1] * v._v[1],
                        _v[2] * v._v[2]);
    }

    Vector3d rotatedAround(UnitVector3d const & k, Angle a) const;

private:
    double _v[3];
};


inline Vector3d operator*(double s, Vector3d const & v) { return v * s; }

std::ostream & operator<<(std::ostream &, Vector3d const &);

}} // namespace lsst::sphgeom

#endif // LSST_SPHGEOM_VECTOR3D_H_