lsst::sphgeom::Vector3d Class Reference

Vector3d is a vector in ℝ³ with components stored in double precision. More...

#include <Vector3d.h>

Public Member Functions
	Vector3d ()
	The default constructor creates a zero vector.
	Vector3d (double x, double y, double z)
	This constructor creates a vector with the given components.
bool	operator== (Vector3d const &v) const
bool	operator!= (Vector3d const &v) const
double const *	getData () const
	data returns a pointer to the 3 components of this vector.
double	operator() (int i) const
	The function call operator returns the i-th component of this vector.
double	x () const
double	y () const
double	z () const
double	dot (Vector3d const &v) const
	dot returns the inner product of this vector and v.
double	getSquaredNorm () const
	getSquaredNorm returns the inner product of this vector with itself.
double	getNorm () const
	getNorm returns the L2 norm of this vector.
bool	isZero () const
	isZero returns true if all the components of this vector are zero.
double	normalize ()
	normalize scales this vector to have unit norm and returns its norm prior to scaling.
bool	isNormalized () const
	isNormalized returns true if this vectors norm is very close to 1.
Vector3d	cross (Vector3d const &v) const
	cross returns the cross product of this vector and v.
Vector3d	operator- () const
	The unary minus operator negates every component of this vector.
Vector3d	operator* (double s) const
	The multiplication operator returns the component-wise product of this vector with scalar s.
Vector3d	operator/ (double s) const
	The division operator returns the component-wise quotient of this vector with scalar s.
Vector3d	operator+ (Vector3d const &v) const
	The addition operator returns the sum of this vector and v.
Vector3d	operator- (Vector3d const &v) const
	The subtraction operator returns the difference between this vector and v.
Vector3d &	operator*= (double s)
Vector3d &	operator/= (double s)
Vector3d &	operator+= (Vector3d const &v)
Vector3d &	operator-= (Vector3d const &v)
Vector3d	cwiseProduct (Vector3d const &v) const
	cwiseProduct returns the component-wise product of this vector and v.
Vector3d	rotatedAround (UnitVector3d const &k, Angle a) const
	rotatedAround returns a copy of this vector, rotated around the unit vector k by angle a according to the right hand rule.

Detailed Description

Vector3d is a vector in ℝ³ with components stored in double precision.

Definition at line 51 of file Vector3d.h.

Constructor & Destructor Documentation

Vector3d() [1/2]

lsst::sphgeom::Vector3d::Vector3d ( )

inline

The default constructor creates a zero vector.

Definition at line 54 of file Vector3d.h.

{ _v[0] = 0.0; _v[1] = 0.0; _v[2] = 0.0; }

Vector3d() [2/2]

lsst::sphgeom::Vector3d::Vector3d ( double x, double y, double z )

inline

This constructor creates a vector with the given components.

Definition at line 57 of file Vector3d.h.

{ _v[0] = x; _v[1] = y; _v[2] = z; }

Member Function Documentation

cross()

Vector3d lsst::sphgeom::Vector3d::cross ( Vector3d const & v ) const

inline

cross returns the cross product of this vector and v.

Definition at line 108 of file Vector3d.h.

                                             {
        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]);
    }

cwiseProduct()

Vector3d lsst::sphgeom::Vector3d::cwiseProduct ( Vector3d const & v ) const

inline

cwiseProduct returns the component-wise product of this vector and v.

Definition at line 157 of file Vector3d.h.

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

dot()

double lsst::sphgeom::Vector3d::dot ( Vector3d const & v ) const

inline

dot returns the inner product of this vector and v.

Definition at line 80 of file Vector3d.h.

                                         {
        return _v[0] * v._v[0] + _v[1] * v._v[1] + _v[2] * v._v[2];
    }

getData()

double const * lsst::sphgeom::Vector3d::getData ( ) const

inline

data returns a pointer to the 3 components of this vector.

Definition at line 68 of file Vector3d.h.

{ return _v; }

getNorm()

double lsst::sphgeom::Vector3d::getNorm ( ) const

inline

getNorm returns the L2 norm of this vector.

Definition at line 88 of file Vector3d.h.

                           {
        return std::sqrt(getSquaredNorm());
    }

getSquaredNorm()

double lsst::sphgeom::Vector3d::getSquaredNorm ( ) const

inline

getSquaredNorm returns the inner product of this vector with itself.

Definition at line 85 of file Vector3d.h.

{ return dot(*this); }

isNormalized()

bool lsst::sphgeom::Vector3d::isNormalized ( ) const

inline

isNormalized returns true if this vectors norm is very close to 1.

Definition at line 103 of file Vector3d.h.

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

isZero()

bool lsst::sphgeom::Vector3d::isZero ( ) const

inline

isZero returns true if all the components of this vector are zero.

Definition at line 93 of file Vector3d.h.

{ return *this == Vector3d(); }

normalize()

double lsst::sphgeom::Vector3d::normalize

(

)

normalize scales this vector to have unit norm and returns its norm prior to scaling.

It will accurately normalize any vector with finite components except for (0, 0, 0), including those with norms that overflow. Trying to normalize (0, 0, 0) will cause a std::runtime_error to be thrown.

Definition at line 48 of file Vector3d.cc.

                           {
    static constexpr uint8_t UNUSED = 255;
    // Given a 3 component vector (x, y, z), this LUT provides the indexes
    // of the components in order of smallest absolute value to largest.
    // The index into the LUT must be computed as:
    //
    //      ((|x| > |z|) << 2) +
    //      ((|x| > |y|) << 1) +
    //       (|y| > |z|)
    static uint8_t const COMPONENT[8][4] = {
        {0, 1, 2, UNUSED},
        {0, 2, 1, UNUSED},
        {1, 0, 2, UNUSED},
        {UNUSED, UNUSED, UNUSED, UNUSED},
        {UNUSED, UNUSED, UNUSED, UNUSED},
        {2, 0, 1, UNUSED},
        {1, 2, 0, UNUSED},
        {2, 1, 0, UNUSED}
    };
#if defined(NO_SIMD) || !defined(__x86_64__)
    double ax = std::fabs(_v[0]);
    double ay = std::fabs(_v[1]);
    double az = std::fabs(_v[2]);
    int index = ((ax > az) << 2) +
                ((ax > ay) << 1) +
                 (ay > az);
    double w = _v[COMPONENT[index][2]];
    if (w == 0.0) {
        throw std::runtime_error("Cannot normalize zero vector");
    }
    // Divide components by the absolute value of the largest
    // component to avoid overflow/underflow.
    double maxabs = std::fabs(w);
    double u = _v[COMPONENT[index][0]] / maxabs;
    double v = _v[COMPONENT[index][1]] / maxabs;
    w = std::copysign(1.0, w);
    double d = u * u + v * v;
    double norm = std::sqrt(1.0 + d);
    _v[COMPONENT[index][0]] = u / norm;
    _v[COMPONENT[index][1]] = v / norm;
    _v[COMPONENT[index][2]] = w / norm;
    return norm * maxabs;
#else
    static __m128d const m0m0 = _mm_set_pd(-0.0, -0.0);
    __m128d ayaz = _mm_andnot_pd(m0m0, _mm_loadu_pd(_v + 1));
    __m128d axax = _mm_andnot_pd(m0m0, _mm_set1_pd(_v[0]));
    __m128d az = _mm_unpackhi_pd(ayaz, _mm_setzero_pd());
    int index = (_mm_movemask_pd(_mm_cmpgt_pd(axax, ayaz)) << 1) |
                 _mm_movemask_pd(_mm_cmplt_sd(az, ayaz));
    // The lower double in uv contains the vector component
    // with the lowest absolute value. The higher double contains
    // the component with absolute value betweem the lowest and
    // highest absolute values.
    __m128d uv = _mm_set_pd(_v[COMPONENT[index][1]],
                            _v[COMPONENT[index][0]]);
    // ww contains two copies of the vector component with the
    // highest absolute value.
    __m128d ww = _mm_set1_pd(_v[COMPONENT[index][2]]);
    __m128d maxabs = _mm_andnot_pd(m0m0, ww);
    if (_mm_ucomieq_sd(ww, _mm_setzero_pd())) {
        throw std::runtime_error("Cannot normalize zero vector");
    }
    // Divide components by the absolute value of the largest
    // component to avoid overflow/underflow.
    uv = _mm_div_pd(uv, maxabs);
    ww = _mm_or_pd(_mm_and_pd(m0m0, ww), _mm_set1_pd(1.0));
    __m128d norm = _mm_mul_pd(uv, uv);
    norm = _mm_sqrt_sd(
        _mm_setzero_pd(),
        _mm_add_sd(
            _mm_set_sd(1.0),
            _mm_add_sd(norm, _mm_unpackhi_pd(norm, _mm_setzero_pd()))
        )
    );
    // Normalize components and store the results.
    ww = _mm_div_sd(ww, norm);
    uv = _mm_div_pd(uv, _mm_shuffle_pd(norm, norm, 0));
    _mm_store_sd(&_v[COMPONENT[index][0]], uv);
    _mm_storeh_pd(&_v[COMPONENT[index][1]], uv);
    _mm_store_sd(&_v[COMPONENT[index][2]], ww);
    return _mm_cvtsd_f64(_mm_mul_sd(norm, maxabs));
#endif
}

operator!=()

bool lsst::sphgeom::Vector3d::operator!= ( Vector3d const & v ) const

inline

Definition at line 63 of file Vector3d.h.

                                              {
        return _v[0] != v._v[0] || _v[1] != v._v[1] || _v[2] != v._v[2];
    }

operator()()

double lsst::sphgeom::Vector3d::operator() ( int i ) const

inline

The function call operator returns the i-th component of this vector.

Definition at line 71 of file Vector3d.h.

{ return _v[i]; }

operator*()

Vector3d lsst::sphgeom::Vector3d::operator* ( double s ) const

inline

The multiplication operator returns the component-wise product of this vector with scalar s.

Definition at line 123 of file Vector3d.h.

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

operator*=()

Vector3d & lsst::sphgeom::Vector3d::operator*= ( double s )

inline

Definition at line 151 of file Vector3d.h.

{ *this = *this * s; return *this; }

operator+()

Vector3d lsst::sphgeom::Vector3d::operator+ ( Vector3d const & v ) const

inline

The addition operator returns the sum of this vector and v.

Definition at line 138 of file Vector3d.h.

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

operator+=()

Vector3d & lsst::sphgeom::Vector3d::operator+= ( Vector3d const & v )

inline

Definition at line 153 of file Vector3d.h.

{ *this = *this + v; return *this; }

operator-() [1/2]

Vector3d lsst::sphgeom::Vector3d::operator- ( ) const

inline

The unary minus operator negates every component of this vector.

Definition at line 115 of file Vector3d.h.

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

operator-() [2/2]

Vector3d lsst::sphgeom::Vector3d::operator- ( Vector3d const & v ) const

inline

The subtraction operator returns the difference between this vector and v.

Definition at line 145 of file Vector3d.h.

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

operator-=()

Vector3d & lsst::sphgeom::Vector3d::operator-= ( Vector3d const & v )

inline

Definition at line 154 of file Vector3d.h.

{ *this = *this - v; return *this; }

operator/()

Vector3d lsst::sphgeom::Vector3d::operator/ ( double s ) const

inline

The division operator returns the component-wise quotient of this vector with scalar s.

Definition at line 131 of file Vector3d.h.

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

operator/=()

Vector3d & lsst::sphgeom::Vector3d::operator/= ( double s )

inline

Definition at line 152 of file Vector3d.h.

{ *this = *this / s; return *this; }

operator==()

bool lsst::sphgeom::Vector3d::operator== ( Vector3d const & v ) const

inline

Definition at line 59 of file Vector3d.h.

                                              {
        return _v[0] == v._v[0] && _v[1] == v._v[1] && _v[2] == v._v[2];
    }

rotatedAround()

Vector3d lsst::sphgeom::Vector3d::rotatedAround	(	UnitVector3d const &	k,
		Angle	a ) const

rotatedAround returns a copy of this vector, rotated around the unit vector k by angle a according to the right hand rule.

Definition at line 132 of file Vector3d.cc.

                                                                      {
    // Use Rodrigues' rotation formula.
    Vector3d const & v = *this;
    double s = sin(a);
    double c = cos(a);
    return v * c + k.cross(v) * s + k * (k.dot(v) * (1.0 - c));
}

x()

double lsst::sphgeom::Vector3d::x ( ) const

inline

Definition at line 73 of file Vector3d.h.

{ return _v[0]; }

y()

double lsst::sphgeom::Vector3d::y ( ) const

inline

Definition at line 75 of file Vector3d.h.

{ return _v[1]; }

z()

double lsst::sphgeom::Vector3d::z ( ) const

inline

Definition at line 77 of file Vector3d.h.

{ return _v[2]; }

---

The documentation for this class was generated from the following files:

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/sphgeom/g8a8a8dda67+585e252eca/include/lsst/sphgeom/Vector3d.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/sphgeom/g8a8a8dda67+585e252eca/src/Vector3d.cc