Struct Angle

Source

pub struct Angle { /* private fields */ }

Expand description

An angular measurement stored as radians.

Angle is the primary type for representing angles throughout this library. It stores the angle as a 64-bit float in radians and provides conversions to/from other angular units commonly used in astronomy.

§Internal Representation

Angles are stored as radians (f64). This choice optimizes for:

Direct use with trigonometric functions
Precision in intermediate calculations
Consistency with mathematical conventions

§Derives

Copy, Clone: Angles are small (8 bytes) and cheap to copy
Debug: Shows internal radian value
PartialEq, PartialOrd: Compare angles directly (compares radian values)

Note: Eq and Ord are not implemented because f64 can be NaN.

Implementations§

Source §

impl Angle

Source

pub const ZERO: Self

Zero angle (0 radians).

Source

pub const PI: Self

Pi radians (180 degrees). Useful for half-circle operations.

Source

pub const HALF_PI: Self

Pi/2 radians (90 degrees). Useful for right angles and pole declinations.

Source

pub const fn from_radians(rad: f64) -> Self

Creates an angle from radians.

This is the only const constructor because radians are the internal representation.

§Example

use celestial_core::Angle;
use std::f64::consts::FRAC_PI_4;

let angle = Angle::from_radians(FRAC_PI_4);
assert!((angle.degrees() - 45.0).abs() < 1e-10);

Source

pub fn from_degrees(deg: f64) -> Self

Creates an angle from degrees.

§Example

use celestial_core::Angle;

let angle = Angle::from_degrees(180.0);
assert!((angle.radians() - celestial_core::constants::PI).abs() < 1e-10);

Source

pub fn from_hours(h: f64) -> Self

Creates an angle from hours.

In astronomy, right ascension is measured in hours where 24h = 360 degrees. Each hour equals 15 degrees.

§Example

use celestial_core::Angle;

let ra = Angle::from_hours(6.0);  // 6h = 90 degrees
assert!((ra.degrees() - 90.0).abs() < 1e-10);

let ra_24h = Angle::from_hours(24.0);  // Full circle
assert!((ra_24h.degrees() - 360.0).abs() < 1e-10);

Source

pub fn from_arcseconds(arcsec: f64) -> Self

Creates an angle from arcseconds.

One arcsecond = 1/3600 of a degree. Commonly used for:

Parallax measurements
Proper motion
Small angular separations

§Example

use celestial_core::Angle;

let angle = Angle::from_arcseconds(3600.0);  // 1 degree
assert!((angle.degrees() - 1.0).abs() < 1e-10);

// Proxima Centauri's parallax is about 0.77 arcseconds
let parallax = Angle::from_arcseconds(0.77);

Source

pub fn from_arcminutes(arcmin: f64) -> Self

Creates an angle from arcminutes.

One arcminute = 1/60 of a degree. Commonly used for:

Field of view specifications
Object sizes (e.g., the Moon is about 31 arcminutes)

§Example

use celestial_core::Angle;

let angle = Angle::from_arcminutes(60.0);  // 1 degree
assert!((angle.degrees() - 1.0).abs() < 1e-10);

// Full Moon's apparent diameter
let moon_diameter = Angle::from_arcminutes(31.0);

Source

pub fn radians(self) -> f64

Returns the angle in radians.

This is the internal representation, so no conversion occurs.

Source

pub fn degrees(self) -> f64

Returns the angle in degrees.

Source

pub fn hours(self) -> f64

Returns the angle in hours.

Useful for right ascension where 24h = 360 degrees.

Source

pub fn arcseconds(self) -> f64

Returns the angle in arcseconds.

Source

pub fn arcminutes(self) -> f64

Returns the angle in arcminutes.

Source

pub fn sin(self) -> f64

Returns the sine of the angle.

Source

pub fn cos(self) -> f64

Returns the cosine of the angle.

Source

pub fn sin_cos(self) -> (f64, f64)

Returns both sine and cosine of the angle.

Convenience method when you need both values.

§Returns

A tuple (sin, cos).

§Example

use celestial_core::Angle;

let angle = Angle::from_degrees(30.0);
let (sin, cos) = angle.sin_cos();
assert!((sin - 0.5).abs() < 1e-10);
assert!((cos - 0.866025).abs() < 1e-5);

Source

pub fn tan(self) -> f64

Returns the tangent of the angle.

Source

pub fn abs(self) -> Self

Returns the absolute value of the angle.

§Example

use celestial_core::Angle;

let negative = Angle::from_degrees(-45.0);
let absolute = negative.abs();
assert!((absolute.degrees() - 45.0).abs() < 1e-10);

Source

pub fn wrapped(self) -> Self

Wraps the angle to the range [-pi, +pi) (i.e., [-180, +180) degrees).

Use this for longitude-like quantities or angular differences where you want the shortest arc representation.

§Example

use celestial_core::Angle;

let angle = Angle::from_degrees(270.0);
let wrapped = angle.wrapped();
assert!((wrapped.degrees() - (-90.0)).abs() < 1e-10);

let angle2 = Angle::from_degrees(-270.0);
let wrapped2 = angle2.wrapped();
assert!((wrapped2.degrees() - 90.0).abs() < 1e-10);

Source

pub fn normalized(self) -> Self

Normalizes the angle to the range [0, 2*pi) (i.e., [0, 360) degrees).

Use this for right ascension or any angle that should be non-negative.

§Example

use celestial_core::Angle;

let angle = Angle::from_degrees(-90.0);
let normalized = angle.normalized();
assert!((normalized.degrees() - 270.0).abs() < 1e-10);

let angle2 = Angle::from_degrees(450.0);
let normalized2 = angle2.normalized();
assert!((normalized2.degrees() - 90.0).abs() < 1e-10);