lsst::sphgeom::NormalizedAngle Class Reference

NormalizedAngle is an angle that lies in the range [0, 2π), with one exception - a NormalizedAngle can be NaN. More...

#include <NormalizedAngle.h>

Public Member Functions
	NormalizedAngle ()
	This constructor creates a NormalizedAngle with a value of zero. More...
	NormalizedAngle (NormalizedAngle const &a)
	This constructor creates a copy of a. More...
	NormalizedAngle (Angle const &a)
	This constructor creates a normalized copy of a. More...
	NormalizedAngle (double a)
	This constructor creates a NormalizedAngle with the given value in radians, normalized to be in the range [0, 2π). More...
	NormalizedAngle (LonLat const &, LonLat const &)
	This constructor creates a NormalizedAngle equal to the angle between the given points on the unit sphere. More...
	NormalizedAngle (Vector3d const &, Vector3d const &)
	This constructor creates a NormalizedAngle equal to the angle between the given 3-vectors, which need not have unit norm. More...
	operator Angle const & () const
	This conversion operator returns a const reference to the underlying Angle. More...
bool	operator== (Angle const &a) const
bool	operator!= (Angle const &a) const
bool	operator< (Angle const &a) const
bool	operator> (Angle const &a) const
bool	operator<= (Angle const &a) const
bool	operator>= (Angle const &a) const
Angle	operator- () const
Angle	operator+ (Angle const &a) const
Angle	operator- (Angle const &a) const
Angle	operator* (double a) const
Angle	operator/ (double a) const
double	operator/ (Angle const &a) const
double	asDegrees () const
	asDegrees returns the value of this angle in units of degrees. More...
double	asRadians () const
	asRadians returns the value of this angle in units of radians. More...
bool	isNan () const
	isNan returns true if the angle value is NaN. More...
NormalizedAngle	getAngleTo (NormalizedAngle const &a) const
	getAngleTo computes the angle α ∈ [0, 2π) such that adding α to this angle and then normalizing the result yields a. More...

Static Public Member Functions
static NormalizedAngle	nan ()
static NormalizedAngle	fromDegrees (double a)
static NormalizedAngle	fromRadians (double a)
static NormalizedAngle	between (NormalizedAngle const &a, NormalizedAngle const &b)
	For two angles a and b, between(a, b) returns the smaller of a.getAngleTo(b) and b.getAngleTo(a). More...
static NormalizedAngle	center (NormalizedAngle const &a, NormalizedAngle const &b)
	For two normalized angles a and b, center(a, b) returns the angle m such that a.getAngleTo(m) is equal to m.getAngleTo(b). More...

Detailed Description

NormalizedAngle is an angle that lies in the range [0, 2π), with one exception - a NormalizedAngle can be NaN.

Definition at line 41 of file NormalizedAngle.h.

Constructor & Destructor Documentation

NormalizedAngle() [1/6]

lsst::sphgeom::NormalizedAngle::NormalizedAngle ( )

inline

This constructor creates a NormalizedAngle with a value of zero.

Definition at line 71 of file NormalizedAngle.h.

{}

NormalizedAngle() [2/6]

lsst::sphgeom::NormalizedAngle::NormalizedAngle ( NormalizedAngle const &  a )

inline

This constructor creates a copy of a.

Definition at line 74 of file NormalizedAngle.h.

: _a(a._a) {}

NormalizedAngle() [3/6]

lsst::sphgeom::NormalizedAngle::NormalizedAngle ( Angle const &  a )

inlineexplicit

This constructor creates a normalized copy of a.

Definition at line 77 of file NormalizedAngle.h.

                                              {
        *this = NormalizedAngle(a.asRadians());
    }

NormalizedAngle() [4/6]

lsst::sphgeom::NormalizedAngle::NormalizedAngle ( double  a )

inlineexplicit

This constructor creates a NormalizedAngle with the given value in radians, normalized to be in the range [0, 2π).

Definition at line 83 of file NormalizedAngle.h.

                                       {
        // For really large |a|, the error in this reduction can exceed 2*PI
        // (because PI is only an approximation to π).
        if (a < 0.0) {
            _a = Angle(std::fmod(a, 2.0 * PI) + 2.0 * PI);
        } else if (a > 2 * PI) {
            _a = Angle(std::fmod(a, 2.0 * PI));
        } else {
            _a = Angle(a);
        }
    }

NormalizedAngle() [5/6]

lsst::sphgeom::NormalizedAngle::NormalizedAngle	(	LonLat const &	p1,
		LonLat const &	p2
	)

This constructor creates a NormalizedAngle equal to the angle between the given points on the unit sphere.

Definition at line 59 of file NormalizedAngle.cc.

                                                                     {
    double x = sin((p1.getLon() - p2.getLon()) * 0.5);
    x *= x;
    double y = sin((p1.getLat() - p2.getLat()) * 0.5);
    y *= y;
    double z = cos((p1.getLat() + p2.getLat()) * 0.5);
    z *= z;
    // Compute the square of the sine of half of the desired angle. This is
    // easily shown to be be one fourth of the squared Euclidian distance
    // (chord length) between p1 and p2.
    double sha2 = (x * (z - y) + y);
    // Avoid domain errors in asin and sqrt due to rounding errors.
    if (sha2 < 0.0) {
        _a = Angle(0.0);
    } else if (sha2 >= 1.0) {
        _a = Angle(PI);
    } else {
        _a = Angle(2.0 * std::asin(std::sqrt(sha2)));
    }
}

NormalizedAngle() [6/6]

lsst::sphgeom::NormalizedAngle::NormalizedAngle	(	Vector3d const &	v1,
		Vector3d const &	v2
	)

This constructor creates a NormalizedAngle equal to the angle between the given 3-vectors, which need not have unit norm.

Definition at line 80 of file NormalizedAngle.cc.

                                                                         {
    double s = v1.cross(v2).getNorm();
    double c = v1.dot(v2);
    if (s == 0.0 && c == 0.0) {
        // Avoid the atan2(±0, -0) = ±PI special case.
        _a = Angle(0.0);
    } else {
        _a = Angle(std::atan2(s, c));
    }
}

Member Function Documentation

asDegrees()

double lsst::sphgeom::NormalizedAngle::asDegrees ( ) const

inline

asDegrees returns the value of this angle in units of degrees.

Definition at line 125 of file NormalizedAngle.h.

{ return _a.asDegrees(); }

asRadians()

double lsst::sphgeom::NormalizedAngle::asRadians ( ) const

inline

asRadians returns the value of this angle in units of radians.

Definition at line 128 of file NormalizedAngle.h.

{ return _a.asRadians(); }

between()

NormalizedAngle lsst::sphgeom::NormalizedAngle::between ( NormalizedAngle const &  a, NormalizedAngle const &  b  )

static

For two angles a and b, between(a, b) returns the smaller of a.getAngleTo(b) and b.getAngleTo(a).

The result will be in the range [0, π].

If one interprets an angle in [0, 2π) as a point on the unit circle, then between can be thought of as computing the arc length of the shortest unit circle segment between the points for a and b.

Definition at line 35 of file NormalizedAngle.cc.

{
    NormalizedAngle x;
    double a1 = std::fabs(a.asRadians() - b.asRadians());
    double a2 = 2.0 * PI - a1;
    x._a = Angle(std::min(a1, a2));
    return x;
}

center()

NormalizedAngle lsst::sphgeom::NormalizedAngle::center ( NormalizedAngle const &  a, NormalizedAngle const &  b  )

static

For two normalized angles a and b, center(a, b) returns the angle m such that a.getAngleTo(m) is equal to m.getAngleTo(b).

Definition at line 45 of file NormalizedAngle.cc.

{
    NormalizedAngle x;
    double c = 0.5 * (a.asRadians() + b.asRadians());
    if (a <= b) {
        x._a = Angle(c);
    } else {
        // The result is (a + b + 2π) / 2, normalized to [0, 2π)
        x._a = Angle((c < PI) ? (c + PI) : (c - PI));
    }
    return x;
}

fromDegrees()

static NormalizedAngle lsst::sphgeom::NormalizedAngle::fromDegrees ( double  a )

inlinestatic

Definition at line 47 of file NormalizedAngle.h.

                                                 {
        return NormalizedAngle(a * RAD_PER_DEG);
    }

fromRadians()

static NormalizedAngle lsst::sphgeom::NormalizedAngle::fromRadians ( double  a )

inlinestatic

Definition at line 51 of file NormalizedAngle.h.

                                                 {
        return NormalizedAngle(a);
    }

getAngleTo()

NormalizedAngle lsst::sphgeom::NormalizedAngle::getAngleTo ( NormalizedAngle const &  a ) const

inline

getAngleTo computes the angle α ∈ [0, 2π) such that adding α to this angle and then normalizing the result yields a.

If one interprets an angle in [0, 2π) as a point on the unit circle, then this method can be thought of as computing the positive rotation angle required to map this point to a.

Definition at line 139 of file NormalizedAngle.h.

                                                                {
        NormalizedAngle x;
        double d = a.asRadians() - asRadians();
        x._a = Angle((d < 0.0) ? 2.0 * PI + d : d);
        return x;
    }

isNan()

bool lsst::sphgeom::NormalizedAngle::isNan ( ) const

inline

isNan returns true if the angle value is NaN.

Definition at line 131 of file NormalizedAngle.h.

{ return _a.isNan(); }

nan()

static NormalizedAngle lsst::sphgeom::NormalizedAngle::nan ( )

inlinestatic

Definition at line 43 of file NormalizedAngle.h.

                                 {
        return NormalizedAngle(std::numeric_limits<double>::quiet_NaN());
    }

operator Angle const &()

lsst::sphgeom::NormalizedAngle::operator Angle const & ( ) const

inline

This conversion operator returns a const reference to the underlying Angle.

It allows a NormalizedAngle to transparently replace an Angle as an argument in most function calls.

Definition at line 106 of file NormalizedAngle.h.

{ return _a; }

operator!=()

bool lsst::sphgeom::NormalizedAngle::operator!= ( Angle const &  a ) const

inline

Definition at line 110 of file NormalizedAngle.h.

{ return _a != a; }

operator*()

Angle lsst::sphgeom::NormalizedAngle::operator* ( double  a ) const

inline

Definition at line 120 of file NormalizedAngle.h.

{ return _a * a; }

operator+()

Angle lsst::sphgeom::NormalizedAngle::operator+ ( Angle const &  a ) const

inline

Definition at line 118 of file NormalizedAngle.h.

{ return _a + a; }

operator-() [1/2]

Angle lsst::sphgeom::NormalizedAngle::operator- ( ) const

inline

Definition at line 117 of file NormalizedAngle.h.

{ return Angle(-_a); }

operator-() [2/2]

Angle lsst::sphgeom::NormalizedAngle::operator- ( Angle const &  a ) const

inline

Definition at line 119 of file NormalizedAngle.h.

{ return _a - a; }

operator/() [1/2]

double lsst::sphgeom::NormalizedAngle::operator/ ( Angle const &  a ) const

inline

Definition at line 122 of file NormalizedAngle.h.

{ return _a / a; }

operator/() [2/2]

Angle lsst::sphgeom::NormalizedAngle::operator/ ( double  a ) const

inline

Definition at line 121 of file NormalizedAngle.h.

{ return _a / a; }

operator<()

bool lsst::sphgeom::NormalizedAngle::operator< ( Angle const &  a ) const

inline

Definition at line 111 of file NormalizedAngle.h.

{ return _a < a; }

operator<=()

bool lsst::sphgeom::NormalizedAngle::operator<= ( Angle const &  a ) const

inline

Definition at line 113 of file NormalizedAngle.h.

{ return _a <= a; }

operator==()

bool lsst::sphgeom::NormalizedAngle::operator== ( Angle const &  a ) const

inline

Definition at line 109 of file NormalizedAngle.h.

{ return _a == a; }

operator>()

bool lsst::sphgeom::NormalizedAngle::operator> ( Angle const &  a ) const

inline

Definition at line 112 of file NormalizedAngle.h.

{ return _a > a; }

operator>=()

bool lsst::sphgeom::NormalizedAngle::operator>= ( Angle const &  a ) const

inline

Definition at line 114 of file NormalizedAngle.h.

{ return _a >= a; }

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/sphgeom/22.0.1-2-gac51dbf+052faf71bd/include/lsst/sphgeom/NormalizedAngle.h
• /j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/sphgeom/22.0.1-2-gac51dbf+052faf71bd/src/NormalizedAngle.cc