lsst::geom::Angle Class Reference

A class representing an angle. More...

#include <Angle.h>

Public Member Functions
constexpr	Angle (double val, AngleUnit units=radians) noexcept
	Construct an Angle with the specified value (interpreted in the given units). More...
constexpr	Angle () noexcept
	Construct the zero angle. More...
constexpr	Angle (Angle const &other) noexcept=default
	Copy constructor. More...
constexpr	Angle (Angle &&other) noexcept=default
	Move constructor. More...
Angle &	operator= (Angle const &other) noexcept=default
	Copy assignment. More...
Angle &	operator= (Angle &&other) noexcept=default
	Move assignment. More...
	~Angle ()=default
constexpr	operator double () const noexcept
	Convert an Angle to a double in radians. More...
constexpr double	asAngularUnits (AngleUnit const &units) const noexcept
	Return an Angle's value in the specified units. More...
constexpr double	asRadians () const noexcept
	Return an Angle's value in radians. More...
constexpr double	asDegrees () const noexcept
	Return an Angle's value in degrees. More...
constexpr double	asHours () const noexcept
	Return an Angle's value in hours. More...
constexpr double	asArcminutes () const noexcept
	Return an Angle's value in arcminutes. More...
constexpr double	asArcseconds () const noexcept
	Return an Angle's value in arcseconds. More...
constexpr double	asMilliarcseconds () const noexcept
	Return an Angle's value in milliarcseconds. More...
Angle	wrap () const noexcept
	Wrap this angle to the range [0, 2π). More...
Angle	wrapCtr () const noexcept
	Wrap this angle to the range [-π, π). More...
Angle	wrapNear (Angle const &refAng) const noexcept
	Wrap this angle to a value x such that -π ≤ x - refAng ≤ π, approximately. More...
Angle	separation (Angle const &other) const noexcept
	The signed difference between two Angles. More...
Angle &	operator*= (double const &d) noexcept
	Multiply this angle by the given factor. More...
Angle &	operator*= (int const &d) noexcept
Angle &	operator+= (double const &d) noexcept
	Increase this angle by the given number of radians. More...
Angle &	operator+= (int const &d) noexcept
Angle &	operator-= (double const &d) noexcept
	Decrease this angle by the given number of radians. More...
Angle &	operator-= (int const &d) noexcept
constexpr bool	operator== (const Angle &rhs) const noexcept
	Test if two Angles represent the same angle (without wrapping). More...
constexpr bool	operator!= (const Angle &rhs) const noexcept
constexpr bool	operator<= (const Angle &rhs) const noexcept
	Compare the sizes of two Angles (without wrapping). More...
constexpr bool	operator>= (const Angle &rhs) const noexcept
constexpr bool	operator< (const Angle &rhs) const noexcept
constexpr bool	operator> (const Angle &rhs) const noexcept
std::size_t	hash_value () const noexcept
	Return a hash of this object. More...

Friends
class	AngleUnit

Related Functions
(Note that these are not member functions.)
constexpr Angle	operator+ (Angle a, Angle d) noexcept
	Sum of two angles. More...
constexpr Angle	operator- (Angle a, Angle d) noexcept
	Difference of two angles. More...
constexpr Angle	operator* (Angle a, Angle d) noexcept
	Product of two angles. More...
constexpr Angle	operator* (Angle a, double d) noexcept
	Product of an angle and a scalar. More...
constexpr Angle	operator- (Angle angle)
	An angle in the opposite sense. More...
constexpr Angle	operator/ (Angle a, int d) noexcept
	Ratio of an angle and a scalar. More...
constexpr Angle	operator/ (Angle a, double d) noexcept
	Ratio of an angle and a scalar. More...
std::ostream &	operator<< (std::ostream &s, Angle a)
	Print an Angle to a stream. More...
template<typename T >
constexpr Angle	operator* (T lhs, AngleUnit rhs) noexcept
	Use AngleUnit to convert a POD (e.g. int, double) to an Angle; e.g. 180*degrees. More...

Detailed Description

A class representing an angle.

Angles may be manipulated like doubles, and automatically converted to doubles, but they may not be constructed from doubles without calling a constructor or multiplying by an AngleUnit. Angles can be modified only by assignment; all other operations that transform an Angle return a new Angle instead.

Unless otherwise specified, all methods and associated operators shall not throw exceptions.

Definition at line 127 of file Angle.h.

Constructor & Destructor Documentation

Angle() [1/4]

constexpr lsst::geom::Angle::Angle ( double  val, AngleUnit  units = radians  )

inlineexplicitconstexprnoexcept

Construct an Angle with the specified value (interpreted in the given units).

Parameters

val	the size of the angle
units	the units in which val is measured

Definition at line 136 of file Angle.h.

: _val(val * units._val) {}

Angle() [2/4]

constexpr lsst::geom::Angle::Angle ( )

inlineconstexprnoexcept

Construct the zero angle.

Definition at line 139 of file Angle.h.

: _val(0) {}

Angle() [3/4]

constexpr lsst::geom::Angle::Angle ( Angle const &  other )

constexprdefaultnoexcept

Copy constructor.

Angle() [4/4]

constexpr lsst::geom::Angle::Angle ( Angle &&  other )

constexprdefaultnoexcept

Move constructor.

~Angle()

lsst::geom::Angle::~Angle ( )

default

Member Function Documentation

asAngularUnits()

constexpr double lsst::geom::Angle::asAngularUnits ( AngleUnit const &  units ) const

inlineconstexprnoexcept

Return an Angle's value in the specified units.

Parameters

units

the units in which the angle's value is desired (e.g. degrees).

Definition at line 163 of file Angle.h.

{ return _val / units._val; }

asArcminutes()

constexpr double lsst::geom::Angle::asArcminutes ( ) const

inlineconstexprnoexcept

Return an Angle's value in arcminutes.

Definition at line 175 of file Angle.h.

{ return asAngularUnits(arcminutes); }

asArcseconds()

constexpr double lsst::geom::Angle::asArcseconds ( ) const

inlineconstexprnoexcept

Return an Angle's value in arcseconds.

Definition at line 178 of file Angle.h.

{ return asAngularUnits(arcseconds); }

asDegrees()

constexpr double lsst::geom::Angle::asDegrees ( ) const

inlineconstexprnoexcept

Return an Angle's value in degrees.

Definition at line 169 of file Angle.h.

{ return asAngularUnits(degrees); }

asHours()

constexpr double lsst::geom::Angle::asHours ( ) const

inlineconstexprnoexcept

Return an Angle's value in hours.

Definition at line 172 of file Angle.h.

{ return asAngularUnits(hours); }

asMilliarcseconds()

constexpr double lsst::geom::Angle::asMilliarcseconds ( ) const

inlineconstexprnoexcept

Return an Angle's value in milliarcseconds.

Definition at line 181 of file Angle.h.

{ return asAngularUnits(milliarcseconds); }

asRadians()

constexpr double lsst::geom::Angle::asRadians ( ) const

inlineconstexprnoexcept

Return an Angle's value in radians.

Definition at line 166 of file Angle.h.

{ return asAngularUnits(radians); }

hash_value()

std::size_t lsst::geom::Angle::hash_value ( ) const

inlinenoexcept

Return a hash of this object.

Definition at line 278 of file Angle.h.

{ return std::hash<double>()(_val); }

operator double()

constexpr lsst::geom::Angle::operator double ( ) const

inlineconstexprnoexcept

Convert an Angle to a double in radians.

Definition at line 156 of file Angle.h.

{ return _val; }

operator!=()

constexpr bool lsst::geom::Angle::operator!= ( const Angle &  rhs ) const

inlineconstexprnoexcept

Definition at line 265 of file Angle.h.

operator*=() [1/2]

Angle& lsst::geom::Angle::operator*= ( double const &  d )

inlinenoexcept

Multiply this angle by the given factor.

Definition at line 243 of file Angle.h.

{ return _val OP rhs._val; }

operator*=() [2/2]

Angle& lsst::geom::Angle::operator*= ( int const &  d )

inlinenoexcept

Definition at line 244 of file Angle.h.

{ return _val OP rhs._val; }

operator+=() [1/2]

Angle& lsst::geom::Angle::operator+= ( double const &  d )

inlinenoexcept

Increase this angle by the given number of radians.

Definition at line 248 of file Angle.h.

{ return _val OP rhs._val; }

operator+=() [2/2]

Angle& lsst::geom::Angle::operator+= ( int const &  d )

inlinenoexcept

Definition at line 249 of file Angle.h.

{ return _val OP rhs._val; }

operator-=() [1/2]

Angle& lsst::geom::Angle::operator-= ( double const &  d )

inlinenoexcept

Decrease this angle by the given number of radians.

Definition at line 253 of file Angle.h.

{ return _val OP rhs._val; }

operator-=() [2/2]

Angle& lsst::geom::Angle::operator-= ( int const &  d )

inlinenoexcept

Definition at line 254 of file Angle.h.

{ return _val OP rhs._val; }

operator<()

constexpr bool lsst::geom::Angle::operator< ( const Angle &  rhs ) const

inlineconstexprnoexcept

Definition at line 271 of file Angle.h.

operator<=()

constexpr bool lsst::geom::Angle::operator<= ( const Angle &  rhs ) const

inlineconstexprnoexcept

Compare the sizes of two Angles (without wrapping).

Definition at line 269 of file Angle.h.

operator=() [1/2]

Angle& lsst::geom::Angle::operator= ( Angle &&  other )

defaultnoexcept

Move assignment.

operator=() [2/2]

Angle& lsst::geom::Angle::operator= ( Angle const &  other )

defaultnoexcept

Copy assignment.

operator==()

constexpr bool lsst::geom::Angle::operator== ( const Angle &  rhs ) const

inlineconstexprnoexcept

Test if two Angles represent the same angle (without wrapping).

Definition at line 264 of file Angle.h.

operator>()

constexpr bool lsst::geom::Angle::operator> ( const Angle &  rhs ) const

inlineconstexprnoexcept

Definition at line 272 of file Angle.h.

operator>=()

constexpr bool lsst::geom::Angle::operator>= ( const Angle &  rhs ) const

inlineconstexprnoexcept

Definition at line 270 of file Angle.h.

separation()

Angle lsst::geom::Angle::separation ( Angle const &  other ) const

inlinenoexcept

The signed difference between two Angles.

Parameters

other

the angle to which this angle will be compared

Returns

*this - other, wrapped to the range [-π, π)

Exception Safety

Shall not throw exceptions.

Definition at line 449 of file Angle.h.

{ return (*this - other).wrapCtr(); }

wrap()

Angle lsst::geom::Angle::wrap ( ) const

inlinenoexcept

Wrap this angle to the range [0, 2π).

Returns

an angle in the normalized interval.

Exception Safety

Shall not throw exceptions.

Warning

The upper limit is only guaranteed for radians; the upper limit may be slightly squishy for other units, due to roundoff errors. Whether there are any violations is unknown; please update this comment if you can prove that the limits are or are not valid for all supported units.

Definition at line 403 of file Angle.h.

                                        {
    double wrapped = std::fmod(_val, TWOPI);
    // wrapped is in the range (-TWOPI, TWOPI)
    if (wrapped < 0.0) wrapped += TWOPI;
    // if wrapped is small enough, adding 2 pi gives 2 pi
    if (wrapped >= TWOPI) wrapped = 0.0;
    return wrapped * radians;
}

wrapCtr()

Angle lsst::geom::Angle::wrapCtr ( ) const

inlinenoexcept

Wrap this angle to the range [-π, π).

Returns

an angle in the normalized interval.

Exception Safety

Shall not throw exceptions.

Warning

Exact limits are only guaranteed for radians; limits for other units may be slightly squishy, due to roundoff errors. Whether there are any violations is unknown; please update this comment if you can prove that the limits are or are not valid for all supported units.

Definition at line 412 of file Angle.h.

                                           {
    double wrapped = std::fmod(_val, TWOPI);
    // wrapped is in the range [-TWOPI, TWOPI]
    if (wrapped < -PI) {
        wrapped += TWOPI;
        if (wrapped >= PI) {
            // handle roundoff error, however unlikely
            wrapped = -PI;
        }
    } else if (wrapped >= PI) {
        wrapped -= TWOPI;
        if (wrapped < -PI) {
            // handle roundoff error, however unlikely
            wrapped = -PI;
        }
    }
    return wrapped * radians;
}

wrapNear()

Angle lsst::geom::Angle::wrapNear ( Angle const &  refAng ) const

inlinenoexcept

Wrap this angle to a value x such that -π ≤ x - refAng ≤ π, approximately.

Parameters

refAng

reference angle to match

Returns

an angle in the custom normalized interval.

Exception Safety

Shall not throw exceptions.

Warning

The only firm limit is -π ≤ x - refAng in radians. The upper limit in radians and both limits in other units are somewhat squishy, due to roundoff error.

Definition at line 431 of file Angle.h.

                                                               {
    // compute (this - refAng).wrapCtr() + refAng
    // which is correct except for roundoff error at the edges
    double const refAngRad = refAng.asRadians();
    double wrapped = (*this - refAng).wrapCtr().asRadians() + refAngRad;
 
    // roundoff can cause slightly out-of-range values; fix those as bast we can;
    // note that both conditionals are wanted, since either or both may execute
    // (though if/else could be used if the lower limit was squishy for radians)
    if (wrapped - refAngRad >= PI) {
        wrapped -= TWOPI;
    }
    if (wrapped - refAngRad < -PI) {
        wrapped += TWOPI;
    }
    return wrapped * radians;
}

Friends And Related Function Documentation

AngleUnit

friend class AngleUnit

friend

Definition at line 128 of file Angle.h.

operator*() [1/3]

constexpr Angle operator* ( Angle  a, Angle  d  )

related

Product of two angles.

Warning

The result will be treated like an planar angle, not a solid angle.

Definition at line 322 of file Angle.h.

{ return Angle(-static_cast<double>(angle)); }

operator*() [2/3]

constexpr Angle operator* ( Angle  a, double  d  )

related

Product of an angle and a scalar.

Definition at line 329 of file Angle.h.

{ return Angle(-static_cast<double>(angle)); }

operator*() [3/3]

template<typename T >

constexpr Angle operator* ( T  lhs, AngleUnit  rhs  )

related

Use AngleUnit to convert a POD (e.g. int, double) to an Angle; e.g. 180*degrees.

Parameters

lhs	the value to convert
rhs	the conversion coefficient

Exception Safety

Shall not throw exceptions.

Definition at line 395 of file Angle.h.

                                                                {
    static_assert(std::is_arithmetic<T>::value,
                  "Only numeric types may be multiplied by an AngleUnit to create an Angle!");
    return Angle(lhs * rhs._val);
}

operator+()

constexpr Angle operator+ ( Angle  a, Angle  d  )

related

Sum of two angles.

Definition at line 308 of file Angle.h.

{ return Angle(-static_cast<double>(angle)); }

operator-() [1/2]

constexpr Angle operator- ( Angle  a, Angle  d  )

related

Difference of two angles.

Definition at line 314 of file Angle.h.

{ return Angle(-static_cast<double>(angle)); }

operator-() [2/2]

constexpr Angle operator- ( Angle  angle )

related

An angle in the opposite sense.

Definition at line 341 of file Angle.h.

{ return Angle(-static_cast<double>(angle)); }

operator/() [1/2]

constexpr Angle operator/ ( Angle  a, double  d  )

related

Ratio of an angle and a scalar.

Definition at line 356 of file Angle.h.

{ return Angle(static_cast<double>(a) / d); }

operator/() [2/2]

constexpr Angle operator/ ( Angle  a, int  d  )

related

Ratio of an angle and a scalar.

Definition at line 349 of file Angle.h.

{ return Angle(static_cast<double>(a) / d); }

operator<<()

std::ostream & operator<< ( std::ostream &  s, Angle  a  )

related

Print an Angle to a stream.

The exact details of the string representation are unspecified and subject to change, but the following may be regarded as typical: "0.567 rad".

Parameters

s	The output stream.
a	The angle.

Exception Safety

Provides basic exception guarantee.

Definition at line 29 of file Angle.cc.

{ return s << static_cast<double>(a) << " rad"; }

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/geom/22.0.1-5-g096abc9+d18c45d440/include/lsst/geom/Angle.h