Astrologos Help

Astrologos

root Astrologos calculator documentation root

Astrologos Calculator
A small programmable calculator for astronomy-oriented values.

Hello World
  print "hello world";

Useful Commands
  help or help() returns the root documentation object.
  help("time") looks up named documentation topics.
  help("examples") or help.examples() shows common astronomy examples.
  help().search("azimuth") or help.search("azimuth") searches all documentation.
  value.help() returns documentation for a computed value.
  about, licence, or disclaimer prints project caveats and licence text.
  resource_sources() lists upstream data sources for registered resources.
  h.doc(), h.compact(), h.syntax, and h.children inspect help values.
  help results are list-like: h[0] selects one result and h.name projects names.

Syntax Shorthand
  let name = <expression>;
  name = <expression>;
  print value, other;
  print; prints a blank line.
  [a, b, c] creates an array; values[0] indexes one element.
  {name: value, other: 2} creates an object; object.name reads a field.
  Object fields can be assigned with object.name = value when the object is mutable.
  value.help() returns contextual documentation.
  help().search("text") performs case-insensitive recursive search.
  for i=0,10 { statements } or for i=0,10,2 { statements }
  while condition { statements }
  if condition statement; or if condition { statements }
  if condition { statements } else if other { statements } else { statements }
  break; exits the nearest loop.

Common Data Pages
  pages(location(60,10)).sky() returns local sky data.
  pages(time()).chart() returns apparent geocentric chart positions.
  pages(location(60,10), moon).summary() returns compact local Moon data.
  pages(location(60,10)).almanac(time()) returns a one-day local almanac.
  pages(location(60,10)).table(days: 30) returns daily rise/set/transit rows.
  pages(time()).state() returns solar-system state vectors.

Functions
  time - creates UTC time, or local civil time when given a timezone, location, or place
  weekday - creates a weekday value
  location - creates a location system value
  observer - creates a body-fixed 3D observer
  body - creates a body system value
  elements - creates osculating orbital elements
  orbit - creates a two-body orbit from elements
  system - creates an immutable system of integrated states, body-backed orbits, and ephemeris bodies
  observation - creates an orbit-determination observation
  orbit_determination - determines an orbit from three or more observations
  heading - creates a compass heading
  direction - creates a frame-tagged unit-sphere direction
  polygon - creates a spherical polygon with great-circle edges
  vector - creates a vector system value
  spherical - creates a vector from spherical coordinates
  matrix - creates a matrix system value
  unit - creates a unit system value
  state - creates an orbital state from ephemeris data or explicit initial conditions
  places (aliases: placedb) - opens the GeoNames places resource
  place - creates a custom Earth place from a location and timezone
  country - resolves a country from a name, ISO code, Place, or Country
  admin1 - resolves a first-level administrative region
  admin2 - resolves a second-level administrative region
  timezones (aliases: timezonedb, tzdb) - opens the IANA timezone boundary resource
  timezone (aliases: tz) - creates an IANA timezone from an id or Earth location
  stars (aliases: stardb) - opens the Yale Bright Star Catalogue resource
  constellations - opens the IAU constellation boundary resource
  graphics (aliases: plot) - creates a deferred SVG graphics object
  target - creates a value/direction target for search(...), or passes through minimum/maximum
  range - creates a numeric or time range for search(...)
  search - searches for function crossings or local minimum/maximum points
  forecast - opens a published GFS forecast cycle from the retained stack
  netcdf - opens a NetCDF dataset and returns its dimensions and variables
  field - creates a global scalar field from a NetCDF variable
  topography - creates an approved global topography field for a body
  magnetic - creates a magnetic field model handle
  pages - creates a data-page builder with optional default body, time, and observer
  help - returns the Astrologos calculator manual or one function's syntax
  about (aliases: disclaimer, licence, license) - returns the project disclaimer, licence, and about text
  resources - lists known runtime resources and whether they are loaded
  resource_sources - lists upstream data sources for known runtime resources
  exit - stops execution after the current statement, optionally returning a message
  run - deprecated alias for exit()
  functions - lists function metadata, optionally filtered by function name
  fields - lists type field metadata, optionally filtered by field name
  types - lists registered astro/system types, constructors, fields, and members
  elapsed - returns elapsed execution time in seconds
  sleep - pauses execution for a number of milliseconds
  array - creates an array from positional values
  hash - creates an ordered hash/object from named values
  args - captures positional and named values as an argument-list value
  keys - returns ordered keys for an array, object, or argument-list value
  values - returns ordered values from an array, object, or argument-list value
  items - returns ordered key/value objects from an array, object, or argument-list value
  pretty - formats a value as indented JSON text
  format - formats values as text with small printf-style placeholders
  typeof - returns the type or function name of a value
  altitude - returns corrected topographic altitude/elevation in degrees
  azimuth - returns corrected topographic azimuth in degrees
  distance - returns corrected geocentric distance in kilometers
  right_ascension (aliases: ra) - returns corrected geocentric true-of-date right ascension in degrees
  declination (aliases: dec) - returns corrected geocentric true-of-date declination in degrees
  ecliptic_longitude - returns corrected apparent geocentric ecliptic longitude in degrees
  heliocentric_ecliptic_longitude - returns corrected heliocentric ecliptic longitude in degrees
  elongation - returns signed geocentric elongation from the Sun in degrees
  moon_phase - returns Moon phase angle percentage in the range 0..100
  moon_illumination - returns illuminated percentage of the Moon as seen from Earth
  magnitude - returns approximate apparent visual magnitude
  apparent_solar_time - returns apparent solar time in local hours
  lunar_time - returns local lunar hour angle as hours
  rotational_axis - returns a body's rotational north-pole RA, declination, and ICRF unit vector
  rotational_axis_ra - returns a body's rotational north-pole right ascension in degrees
  rotational_axis_dec - returns a body's rotational north-pole declination in degrees
  dms - converts decimal degrees to degree-minute-second components
  dd - converts degree-minute-second components to signed decimal degrees
  solar_eclipse_magnitude - returns local solar eclipse magnitude at a time and location
  solar_eclipse_obscuration - returns percent of the solar disc occulted locally
  solar_eclipse_clearance - returns signed local Sun-Moon limb clearance in degrees
  lunar_eclipse_magnitude - returns signed umbral lunar eclipse magnitude
  lunar_penumbra_magnitude - returns signed penumbral lunar eclipse magnitude
  lunar_eclipse_clearance - returns signed Moon-surface clearance from Earth's penumbra in kilometers
  shadow_distance - returns signed surface clearance for the active Sun-Earth-Moon shadow geometry
  moon_shadow_earth_distance - returns signed Earth-surface clearance from the Moon shadow cone in kilometers
  moon_penumbra_distance - returns signed Moon-surface clearance from Earth's penumbra in kilometers
  moon_umbra_distance - returns signed Moon-surface clearance from Earth's umbra in kilometers
  moon_umbra_occultation - returns percent overlap of the Moon and Earth's umbra
  location_shadow_distance - returns signed local observer clearance from the Moon shadow cone in kilometers
  planet_shadow_earth_distance - returns signed Earth-surface clearance from a planet shadow cone in kilometers
  events - finds astronomical events from event type constants and time ranges
  sky - summarizes the local sky and upcoming local events
  almanac - builds a range almanac from astronomical event searches
  integrate - integrates a callable over named ranges or advances named derivatives
  sample - samples a field at a latitude/longitude location
  abs - returns the absolute value
  sign - returns -1, 0, or 1 according to the sign
  floor - rounds down to an integer value
  ceil - rounds up to an integer value
  round - rounds to the nearest integer value
  trunc - truncates toward zero
  fract - returns the fractional part
  sqrt - returns the square root
  cbrt - returns the cube root
  exp - returns e raised to x
  exp2 - returns 2 raised to x
  ln - returns the natural logarithm
  log - returns logarithm of x in the given base
  log2 - returns the base-2 logarithm
  log10 - returns the base-10 logarithm
  pow - returns x raised to y
  sin - returns sine of x radians
  cos - returns cosine of x radians
  tan - returns tangent of x radians
  asin - returns arcsine in radians
  acos - returns arccosine in radians
  atan - returns arctangent in radians
  atan2 - returns atan2(y, x) in radians
  sinh - returns hyperbolic sine
  cosh - returns hyperbolic cosine
  tanh - returns hyperbolic tangent
  asinh - returns inverse hyperbolic sine
  acosh - returns inverse hyperbolic cosine
  atanh - returns inverse hyperbolic tangent
  hypot - returns sqrt(x*x + y*y) without undue overflow
  min - returns the smallest numeric argument
  max - returns the largest numeric argument
  clamp - clips x to the inclusive range lower..upper
  angle_in_degrees (aliases: angle_degrees) - returns the angle between two vectors in degrees
  to_radians - converts degrees to radians
  to_degrees - converts radians to degrees
  is_finite - returns true when x is finite
  is_nan - returns true when x is NaN
  is_infinite - returns true when x is infinite
  navigate - estimates an Earth location from target elevation observations
  minimize - minimizes a numeric callable over named variables with optional bounds and constraints

Resources
  constellations - IAU constellation boundaries from Bill Gray constbnd (source: IAU constellation boundaries / Bill Gray constbnd)
  ephemeris - orbital ephemeris files used for state/orbit calculations (source: NASA/JPL Development Ephemeris DE441)
  gfs_forecast - published GFS forecast cycle stack under gfs/ (source: NOAA/NCEP Global Forecast System)
  iers - IERS Earth orientation and leap-second data used for UTC/TT/UT1/TDB conversions (source: IERS EOP C04)
  magnetic_model - NOAA WMMHR magnetic coefficient model under magnetic/ (source: NOAA/NCEI World Magnetic Model High Resolution)
  atmosphere - not implemented; reserved for atmospheric refraction and climatology inputs (source: not implemented)
  earth_tides - not implemented; reserved for solid Earth tide displacement corrections (source: not implemented)
  earth_topography - global Earth topography/bathymetry scalar field (source: NOAA/NCEI ETOPO1 bedrock global relief)
  ocean_tides - not implemented; reserved for ocean tide and ocean-loading corrections (source: not implemented)
  moon_topography - global Moon altitude topography scalar field (source: installed lunar altitude topography)
  places - GeoNames place lookup database (source: GeoNames geographical database)
  planetary_satellites - planetary-satellite ephemeris store derived from satellite SPK kernels (source: NAIF generic satellite SPK kernels)
  small_bodies - massive small-body ephemeris store for asteroid/KBO perturbation models (source: Astrologos small-body ephemeris store)
  solar_activity - not implemented; reserved for solar and geomagnetic activity indices (source: not implemented)
  stars - Yale Bright Star Catalogue with common-name notes (source: Yale Bright Star Catalogue, 5th Revised Edition)
  timezones - IANA timezone and location-boundary lookup database (source: IANA Time Zone Database and Timezone Boundary Builder)

Types
  Time - UTC date/time value with resolved TT, UT1, and TDB scales
  LocalTime - timezone-adjusted civil time derived from a UTC Time
  Weekday - ISO weekday value
  Location - body-aware latitude/longitude surface location
  LocationSolution - navigation solution with location, residuals, and fit quality
  Observer - body-fixed 3D observer with position, zenith, and derived surface location
  Body - solar-system body with physical parameters from the reference C model
  Bodies - registry of known solar-system bodies and massive small-body perturbers
  Elements - osculating orbital elements using periapsis distance as the primary distance
  Orbit - two-body orbit backed by osculating elements or a relative state vector
  System - immutable orbit propagation system with shared snapshot cache
  Observation - measured sky direction or target elevation observation
  OrbitSolution - orbit determination result with orbit, residuals, and fit quality
  Shadow - instantaneous sunlight shadow geometry for one body on another
  Heading - compass heading measured clockwise from north
  Direction - unit-sphere direction tagged with a coordinate frame
  Polygon - right-handed spherical polygon with great-circle edges
  Vector - 3D vector with cached cartesian and spherical representations
  Matrix - 3x3 matrix compatible with reference vector transforms
  Unit - named unit used when requesting or displaying numeric values
  State - orbital state backed by ephemeris data with lazy derived fields
  Places - GeoNames place lookup database handle
  Place - GeoNames place record with location and feature metadata
  Country - ISO country used to inspect and filter places
  Admin1 - first-level GeoNames administrative region used to filter places
  Admin2 - second-level GeoNames administrative region used to filter places
  Timezones - IANA timezone lookup database handle
  Timezone - IANA timezone with optional boundary and representative-location metadata
  Stars - Yale Bright Star Catalogue database handle
  Star - catalog star with identifiers, astrometry, and sky methods
  ConstellationDb - IAU constellation boundary database handle
  Constellation - IAU constellation boundary record
  Event - astronomical event result
  Graphics - deferred SVG graphics drawing context
  Target - search target value and crossing direction
  Range - numeric or time scan range
  Search - configured scalar search value
  Forecast - published GFS forecast cycle from the retained stack
  ForecastProduct - forecast product selector bound to a forecast
  ScalarField - forecast scalar field selected from a product
  VectorField - forecast vector field selected from a product
  FieldSource - approved external field dataset source
  NetCDF - opened NetCDF dataset metadata
  Field - sampleable global scalar field
  Magnetic - body-scoped magnetic field model
  Pages - curated data-page builder with optional default body, time, and observer

Objects
  Object - ordered mutable field collection
    literal: {name: value, count: 2}
    access: object.name or object["name"]
    helpers: keys(object), values(object), items(object), object.available(), object.help()

Astrologos.syntax

topic general Astrologos language syntax for scripts, expressions, blocks, and definitions

Aliases: language, grammar, programming

Topic: Astrologos.syntax - general Astrologos language syntax for scripts, expressions, blocks, and definitions
Syntax:
  help("syntax")
  help("loops")
  help("blocks")
  help("custom functions")
  help("overloads")
  help("namespaces")
Aliases: language, grammar, programming
Children: syntax basics, loops, blocks, custom functions, function overloads, namespaces

# Minimal local sky script
let loc = location(60.0, 10.0);
let obs = loc.observer(0.002);
let t = time(2026,6,21,12,0,0);
print altitude(sun, t, obs), azimuth(sun, t, obs);

# Define a reusable local altitude helper
let local_altitude = (body, t): {
  let loc = location(latitude: 60, longitude: 10);
  let obs = loc.observer(0.002);
  let value = altitude(body, t, obs);
};
let f = (body, t): local_altitude(body, t).value;
let t = time(2026,1,1,21,0,0);
let a = local_altitude(moon, t);
print f(moon, t), a.value, a.loc, a.obs;

Astrologos.syntax.basics

topic core expression, statement, value, comment, array, object, field, and call syntax

Aliases: basics, statements, expressions, comments, objects, arrays

Topic: Astrologos.syntax.basics - core expression, statement, value, comment, array, object, field, and call syntax
Syntax:
  let name = expression;
  name = expression;
  print value, other;
  # comment
  // comment
  [a, b, c]
  {name: value, other: 2}
  object.name
  object["name"]
  call(argument, named: value)
Aliases: basics, statements, expressions, comments, objects, arrays

# Store one local sky sample as an object row
let t = time(2026,1,1,21,0,0); # UTC
let loc = location(60.0, 10.0);
let row = {body: moon.name, when: t.utc(), altitude: altitude(moon, t, loc.observer())};
print row.body, row.when, row.altitude;

# Use named arguments for an observing site
let loc = location(latitude: 58.9666667, longitude: 5.7333333);
let obs = loc.observer(height: 0.002);
print obs.latitude(), obs.longitude(), altitude(sun, time(2026,6,21,12,0,0), obs);

Astrologos.syntax.loops

topic for loops, while loops, break, and numeric iteration syntax

Aliases: for, while, break, iteration, loop

Topic: Astrologos.syntax.loops - for loops, while loops, break, and numeric iteration syntax
Syntax:
  for i=start,stop { statements }
  for i=start,stop,step { statements }
  while condition { statements }
  break;
Aliases: for, while, break, iteration, loop

# Loop over every third hour of a day
let loc = location(60.0, 10.0);
let obs = loc.observer(0.002);
let t0 = time(2026,6,21,0,0,0);
for h=0,24,3 {
  let t = t0.add_hours(h);
  print t.utc(), altitude(sun, t, obs);
}

# Stop a while loop when the Sun reaches a useful altitude
let loc = location(60.0, 10.0);
let obs = loc.observer(0.002);
let t0 = time(2026,6,21,0,0,0);
let h = 0;
while h < 24 {
  if altitude(sun, t0.add_hours(h), obs) > 20 break;
  h = h + 1;
}
print t0.add_hours(h).utc(), altitude(sun, t0.add_hours(h), obs);

Astrologos.syntax.blocks

topic braced statement blocks, scope expressions, if/else branches, and the implemented For(...) block expression

Aliases: block expressions, scope, For block, if else

Topic: Astrologos.syntax.blocks - braced statement blocks, scope expressions, if/else branches, and the implemented For(...) block expression
Syntax:
  { statements }
  if condition statement;
  if condition { statements } else if other { statements } else { statements }
  For(i, start, stop, step) { statements }
Aliases: block expressions, scope, For block, if else

# if, else if, and else blocks
let altitude_now = altitude(sun, time(), location(60,10).observer());
if altitude_now > 0 {
  print "sun is above the horizon";
} else if altitude_now > -6 {
  print "civil twilight";
} else {
  print "night";
}

# For(...) block expression can keep the last daylight sample
let loc = location(60,10);
let obs = loc.observer();
let t0 = time(2026,6,21,0,0,0);
let result = For(h, 0, 24, 6) {
  let time_utc = t0.add_hours(h).utc();
  let sun_altitude = altitude(sun, t0.add_hours(h), obs);
};
print result.time_utc, result.sun_altitude;

Astrologos.syntax.functions

topic plain definitions, typed definitions, and closure values for reusable calculations

Aliases: definitions, user functions, closures, lambda, callable

Topic: Astrologos.syntax.functions - plain definitions, typed definitions, and closure values for reusable calculations
Syntax:
  name(parameter, other) { statements }
  type Name(parameter) { statements }
  (parameter, other): expression
Aliases: definitions, user functions, closures, lambda, callable

# Custom function returning exported fields
sun_sample(t, loc) {
  let obs = loc.observer(0.002);
  let altitude_deg = altitude(sun, t, obs);
  let azimuth_deg = azimuth(sun, t, obs);
}
let sample = sun_sample(time(2026,6,21,12,0,0), location(60,10));
print sample.altitude_deg, sample.azimuth_deg;

# Closure used as a search function
let root = search((x): cos(x) - 0.5, range(0, 4, 0.25), target(0, decreasing)).next();
print root;

# User-defined type with a closure-valued field
type obs(t) {
  let year_plus = (d): t.year() + d;
}
let x = obs(time(2026,4,27,8,26,0));
print x.year_plus(1);

Astrologos.syntax.overloads

topic multiple callable signatures, overload-specific argument order, and query-dependent return shapes

Aliases: overloads, signatures, return shape, return types, return-shape-dependent behaviour, return-shape-dependent behavior

Topic: Astrologos.syntax.overloads - multiple callable signatures, overload-specific argument order, and query-dependent return shapes
Syntax:
  help("function_name").syntax
  help("events").syntax
  events(event_type, bounded_range) -> List
  events(event_type, open_range) -> Event|Nil
  collection.first()
Aliases: overloads, signatures, return shape, return types, return-shape-dependent behaviour, return-shape-dependent behavior

# Inspect overloads before choosing argument order
print help("events").syntax;

# Bounded event searches return a list, so collection methods apply
let oslo = location(latitude: 59.9139, longitude: 10.7522);
let day = range(time(2026,7,11,0,0,0), time(2026,7,12,0,0,0));
let sunset = events(sunset, day, oslo).first();
print sunset.time.utc();

# Open-ended event searches return one Event or Nil, not a list
let oslo = location(latitude: 59.9139, longitude: 10.7522);
let after = range(time(2026,7,11,0,0,0), infinity, 1);
let sunset = events(sunset, after, oslo);
if sunset != nil { print sunset.time.utc(); }

# Return shape may vary by query: guard Nil and Unavailable values
let empty = places().search("Oslo", country: "ZZ").first();
let missing = places().find("definitely-not-a-real-place-name");
print empty == nil, empty.available();
print missing.available(), missing.reason;
if empty.available() { print empty.name; } else { print "empty search"; }
if missing.available() { print missing.name; } else { print "missing lookup"; }

Astrologos.syntax.namespaces

topic using objects, user-defined types, and returned definition objects as field namespaces

Aliases: objects as namespaces, fields, methods, module objects, type fields

Topic: Astrologos.syntax.namespaces - using objects, user-defined types, and returned definition objects as field namespaces
Syntax:
  {name: value}.name
  object["name"]
  object[key] = value
  type Name(...) { let field = value; }
  definition(...).field
  hash(name: value)
  call(**arguments)
Aliases: objects as namespaces, fields, methods, module objects, type fields

# Object fields as a small namespace
let sky = {place: location(60,10), at: time(2026,1,1,21,0,0)};
print sky.place.latitude, sky.at.utc();

# Nested namespace object
let observatory = {site: {name: "Stavanger", loc: location(58.9666667, 5.7333333)}, instruments: {main: "sky", backup: "chart"}};
print observatory.site.name, observatory.site.loc.latitude, observatory.instruments.main;

# Dynamic field access with brackets
let row = {body: sun.name, value: sun.radius};
let key = "body";
print row[key], row["value"];

# Mutable object fields
let row = {body: sun.name, count: 1};
row.count = row.count + 1;
row["note"] = "updated";
print row.count, row.note;

# Hash as named arguments
let opts = hash(latitude: 60.0, longitude: 10.0);
let loc = location(**opts);
print loc.latitude, loc.longitude;

# Arguments object with updates
let base = args(latitude: 60.0, longitude: 10.0);
let moved = base.with(longitude: 12.0);
print location(**base).longitude, location(**moved).longitude;

# Array spread for positional arguments
let values = array(58.9666667, 5.7333333);
let loc = location(**values);
print loc.latitude, loc.longitude;

# Scope expression exports public let values
let opts = { let latitude = 60.0; let longitude = 10.0; let _internal = 99; };
let loc = location(**opts);
print loc.latitude, loc.longitude;

# Definition result as a namespace of related values
solar_day(loc, t) {
  let span = range(t, t.add_days(1));
  let sunrise_time = events(sunrise, span, loc).first().time.utc();
  let sunset_time = events(sunset, span, loc).first().time.utc();
}
let d = solar_day(location(latitude: 58.9666667, longitude: 5.7333333), time(2024,4,17,0,0,0));
print d.sunrise_time, d.sunset_time;

# Typed namespace with closure-valued members
type SolarSite(loc) {
  let sunrise_time = (t): events(sunrise, range(t, t.add_days(1)), loc).first().time.utc();
  let sunset_time = (t): events(sunset, range(t, t.add_days(1)), loc).first().time.utc();
}
let site = SolarSite(location(latitude: 58.9666667, longitude: 5.7333333));
print site.sunrise_time(time(2024,4,17,0,0,0)), site.sunset_time(time(2024,4,17,0,0,0));

Astrologos.examples

topic common astronomy calculator examples

Aliases: common_examples, cookbook, recipes

Topic: Astrologos.examples - common astronomy calculator examples
Syntax:
  help("examples")
  help.examples()
  help().help("examples")
Aliases: common_examples, cookbook, recipes
Children: getting started, syntax examples, time and calendars, locations and timezones, sunrise examples, sunrise day, sunrise month, moonrise and lunar visibility, moon phase, stars(), constellations(), moon and stars, sky charts fixed stars and close approaches, planet events, eclipses and shadows, almanac pages, pages(), coordinates and directions, vectors matrices orbits, orbit propagation, polygons, places and timezones, weather and fields, topography(), magnetic field, weather and fields, charts and graphics, resources and diagnostics, runtime automation, math recipes, search and optimization

# Local sky sampler for Oslo-style coordinates
let loc = location(60.0, 10.0);
let s = pages(loc).sky(time(2026,1,1,21,0,0));
print s.sun.altitude, s.moon.altitude, s.moon.phase;

# Compact chart sampler with two body longitudes
let t = time(2026,1,1,0,0,0);
let c = pages(t).chart();
print c.bodies.sun.chart.sign, c.bodies.mars.geocentric.longitude;

# Compact local Moon page
let loc = location(60.0, 10.0);
let m = pages(loc, moon).summary(time());
print m.position.topocentric.altitude, m.phase, m.illumination;

# Month-style rise/set table
let loc = location(60.0, 10.0);
let rows = pages(loc, time(2026,6,1,0,0,0)).table(days: 30);
print rows[0].sunrise.time, rows[0].sunset.time;

# Solar-system state sampler for Mars and Earth
let st = pages(time(2026,1,1,0,0,0)).state();
print st.bodies.mars.position_bc_icrf.x, st.bodies.earth.velocity_bc_icrf.y;

# Orbit propagation diagnostics for an explicit comet state
let t0 = time(2026,4,27,8,26,0);
let comet0 = state(body: body("comet"), time: t0, position: vector(100000000,0,0), velocity: vector(0,10,0));
let later = system(t0, comet0, sun).at(t0.add_days(10));
print later.diagnostics.accepted_steps, later.ephemeris_residuals.sun;

# Full local day page
let d = pages(location(60.0, 10.0), time(2026,1,1,0,0,0)).small();
print d.short.sun.rise.time, d.chart.bodies.moon.geocentric.longitude;

# Sunrise in Stavanger on a civil date
let loc = location(58.9666667, 5.7333333);
let day = range(time(2024,4,17,0,0,0), time(2024,4,18,0,0,0));
print events(sunrise, day, loc).first().time.utc();

# Days between two dates
print time(2026,3,1)-time(2025,1,2);

# Sunrise and sunset together
let loc = location(latitude: 58.9666667, longitude: 5.7333333);
let day = range(time(2024,4,17,0,0,0), time(2024,4,18,0,0,0));
print events(sunrise, day, loc).first();
print events(sunset, day, loc).first();

# Moonrise for the next few days
let loc = location(60.0, 10.0);
let start = time(2026,5,20,0,0,0);
print events(moonrise, range(start, start.add_days(5), 0.5), loc);

# Northern solstice in a year
let year = range(time(2024,1,1,0,0,0), time(2025,1,1,0,0,0), 30);
print events(northern_solstice, year).first().time.utc();

# Season sampler from an annual almanac
let a = almanac(time(2024,1,1,0,0,0), time(2025,1,1,0,0,0));
print a.seasons.ascending_equinox.time.utc, a.seasons.northern_solstice.time.utc;

# Earth orbital-distance sampler around perihelion
let peri = events(perihelion, range(time(2024,1,1,0,0,0), time(2024,1,10,0,0,0), 1), earth).first();
print peri.time.utc(), peri.value;

# Body method form for perihelion
print earth.perihelion(time(2024,1,1,0,0,0), time(2024,1,10,0,0,0), 1).first();

# Lunar perigee and apogee in a month
let month = range(time(2024,4,1,0,0,0), time(2024,5,1,0,0,0), 1);
print events(perigee, month, moon);
print events(apogee, month, moon);

# Moon boundary lookup sampler
let t = time(2024,4,17,0,0,0);
let moon_dir = direction(ra(moon, t, all_corrections), dec(moon, t, all_corrections));
print moon_dir.ra, moon_dir.dec, constellations().inside(moon_dir);

# Sirius sampler with altitude at a site
let sirius = stars().find("Sirius");
let obs = location(latitude: 60.0, longitude: 10.0).observer(0.002);
let t = time(2026,1,1,21,0,0);
print sirius.name, sirius.constellation(), sirius.altaz(t, obs).altitude;

# Star transit and set for Sirius
let sirius = stars().find("Sirius");
let obs = location(60.0, 10.0).observer(0.002);
let night = range(time(2026,1,1,0,0,0), time(2026,1,2,0,0,0), 0.25);
print sirius.transit(night, obs).first();
print sirius.set(night, obs).first();

# Constellation sampler for a named star direction
let sirius = stars().find("Sirius");
print sirius.name, constellations().inside(sirius.direction());

# Planet event sampler for Jupiter opposition
let year = range(time(2024,1,1,0,0,0), time(2025,1,1,0,0,0), 2);
print events(opposition, year, jupiter).first().time.utc();

# Local almanac for one month
let loc = location(58.9666667, 5.7333333);
let start = time(2024,4,1,0,0,0);
let a = almanac(start, start.add_months(1), loc);
print a.local.sun.rise;
print a.moon.full;

# Solar eclipse magnitude sampler near Dallas
let dallas = location(latitude: 32.7767, longitude: -96.7970);
let t = time(2024,4,8,18,20,0);
print solar_eclipse_magnitude(t, dallas), solar_eclipse_obscuration(t, dallas);

# Numeric search sampler for a sine crossing
let root = search((x): sin(x), range(2, 4, 0.1), target(0, decreasing)).next();
print root;

# Sun altitude curve samples around a day
let loc = location(60.0, 10.0);
let obs = loc.observer(0.002);
let t0 = time(2026,6,21,0,0,0);
for h=0,24,2 {
  let t = t0.add_hours(h);
  print t.utc(), altitude(sun, t, obs);
}

# Quick SVG sky sampler with planets only
graphics(time(2026,1,1,21,0,0), location(latitude: 60, longitude: 10)).dark().sky_view(center_az: 180, center_alt: 45, fov: 120).sky_grid().sky_planets().write_svg("sky-planets.svg");
print "wrote sky-planets.svg";

Astrologos.themes

topic recommended thematic help areas for the RAG help search cookbook

Aliases: theme list, cookbook index, example themes, recipes index

Topic: Astrologos.themes - recommended thematic help areas for the RAG help search cookbook
Syntax:
  help("sunrise examples")
  help("moon sirius")
  help("weather examples")
  help.search("visible stars")
Aliases: theme list, cookbook index, example themes, recipes index
Children: getting started, syntax examples, time and calendars, locations and timezones, sunrise examples, sunrise day, sunrise month, moonrise and lunar visibility, moon phase, stars(), constellations(), moon and stars, sky charts fixed stars and close approaches, planet events, eclipses and shadows, almanac pages, pages(), coordinates and directions, vectors matrices orbits, polygons, places and timezones, weather and fields, topography(), magnetic field, weather and fields, charts and graphics, resources and diagnostics, runtime automation, math recipes, search and optimization

# Theme list
print help("sunrise examples").compact();
print help("moon and stars").compact();
print help("charts and graphics").compact();

Astrologos.examples.getting_started

topic starter examples for printing, JSON output, help discovery, values, and runtime control

Aliases: hello world, print, json output, introspection, first program

Topic: Astrologos.examples.getting_started - starter examples for printing, JSON output, help discovery, values, and runtime control
Syntax:
  print value, other;
  json value;
  help("topic")
  functions()
  typeof(value)
Aliases: hello world, print, json output, introspection, first program

# Hello world and plain output
print "hello world";
print time(2026,1,1,0,0,0).utc();

# JSON output for a local sky sample
let loc = location(60.0, 10.0);
let t = time(2026,1,1,12,0,0);
json {time: t.utc(), sun_altitude: altitude(sun, t, loc.observer()), moon_phase: moon_phase(t)};

# Pretty-print a compact chart row
let t = time(2026,1,1,0,0,0);
pretty {sun_longitude: ecliptic_longitude(sun, t), moon_longitude: ecliptic_longitude(moon, t), phase: moon_phase(t)};

# First useful almanac query: sunrise and sunset
let loc = location(58.9666667, 5.7333333);
let day = range(time(2024,4,17,0,0,0), time(2024,4,18,0,0,0));
print events(sunrise, day, loc).first().time.utc(), events(sunset, day, loc).first().time.utc();

# Build a body scale table for a report
let rows = [{name: sun.name, radius_ratio: sun.radius / earth.radius}, {name: moon.name, radius_ratio: moon.radius / earth.radius}, {name: mars.name, radius_ratio: mars.radius / earth.radius}];
print rows.name, rows.radius_ratio;

# Reuse named arguments for nearby observing sites
let stavanger = args(latitude: 58.9666667, longitude: 5.7333333);
let oslo = stavanger.with(latitude: 59.9139, longitude: 10.7522);
print altitude(sun, time(2026,6,21,12,0,0), location(**stavanger).observer()), altitude(sun, time(2026,6,21,12,0,0), location(**oslo).observer());

# Time a useful sunrise search
let start = elapsed();
let loc = location(58.9666667, 5.7333333);
let day = range(time(2024,4,17,0,0,0), time(2024,4,18,0,0,0));
let rise = events(sunrise, day, loc).first().time.utc();
print rise, elapsed() - start;

Astrologos.examples.syntax

topic task-shaped examples for Astrologos language syntax and reusable helper definitions

Aliases: language examples, programming examples, closures examples, definitions examples

Topic: Astrologos.examples.syntax - task-shaped examples for Astrologos language syntax and reusable helper definitions
Syntax:
  let name = expression;
  for i=start,stop,step { statements }
  name(parameter) { statements }
  (x): expression
  {name: value}
Aliases: language examples, programming examples, closures examples, definitions examples
Children: syntax, loops, blocks, custom functions, namespaces

# Loop and conditional syntax together
let total = 0;
for i=0,10,2 {
  if i > 6 break;
  total = total + i;
}
print total;

# Custom helper returning a namespace object
sun_angles(t, loc) {
  let obs = loc.observer(0.002);
  let altitude_deg = altitude(sun, t, obs);
  let azimuth_deg = azimuth(sun, t, obs);
}
let a = sun_angles(time(2026,6,21,12,0,0), location(latitude: 60, longitude: 10));
print a.altitude_deg, a.azimuth_deg;

# Object literal as a reusable observation row
let row = {body: sun.name, time: time(2026,6,21,12,0,0), loc: location(60,10)};
print row.body, row.time.utc(), altitude(sun, row.time, row.loc.observer());

# Hash for named options
let opts = hash(latitude: 58.9666667, longitude: 5.7333333);
print location(**opts);

# Arguments object for reusable call settings
let stavanger = args(latitude: 58.9666667, longitude: 5.7333333);
let oslo = stavanger.with(latitude: 59.9139, longitude: 10.7522);
print location(**stavanger), location(**oslo);

# Project fields from an observation object
let sample = {body: moon.name, phase: moon_phase(time(2026,1,1,0,0,0)), illumination: moon_illumination(time(2026,1,1,0,0,0))};
print sample.body, sample.phase, sample.illumination;

# Bracket access chooses a field at runtime
let field_name = "longitude";
let loc = {latitude: 60, longitude: 10};
print loc[field_name];

# Namespaces can hold local sky report functions
let loc = location(60,10).observer(0.002);
let tools = {sun_alt: (t): altitude(sun, t, loc), moon_alt: (t): altitude(moon, t, loc)};
let t = time(2026,6,21,22,0,0);
print tools.sun_alt(t), tools.moon_alt(t);

# Closure as a reusable altitude formula
let loc = location(60,10).observer(0.002);
let sun_alt = (t): altitude(sun, t, loc);
print sun_alt(time(2026,6,21,12,0,0));

# Scope expression as a computed namespace
let report = {
  let loc = location(60,10);
  let t = time(2026,6,21,12,0,0);
  let sun_altitude = altitude(sun, t, loc.observer());
};
print report.loc.latitude, report.sun_altitude;

# Spread an array into positional arguments
let pair = [60.0, 10.0];
print location(**pair);

# Type definition with a captured value
type Report(t) {
  let year = (): t.year;
}
let r = Report(time(2026,1,1,0,0,0));
print r.year();

# Type definition as a domain-specific namespace
type AlmanacFor(loc) {
  let daylight = (t): events(sunset, range(t, t.add_days(1)), loc).first().time - events(sunrise, range(t, t.add_days(1)), loc).first().time;
}
let a = AlmanacFor(location(58.9666667, 5.7333333));
print a.daylight(time(2024,4,17,0,0,0));

# Derive a one-argument function from a two-argument closure
let f = (x, y): x * y;
let g = (x): f(x, 2);
print g(5);

# Derive several closures from one base formula
let f = (x, y): x * y + y;
let double_plus_two = (x): f(x, 2);
let triple_plus_three = (x): f(x, 3);
print double_plus_two(5), triple_plus_three(5);

# Store related derived functions in a namespace
let f = (x, y): x * y;
let tools = {double: (x): f(x, 2), triple: (x): f(x, 3)};
print tools.double(7), tools.triple(7);

# Function result can expose derived closures
make_scale(k) {
  let apply = (x): x * k;
  let describe = (x): "scaled";
}
let scale = make_scale(4);
print scale.apply(6), scale.describe(6);

# Function result can expose raw values and helper functions
bundle(x) {
  let value = x;
  let square = (n): n * n;
  let cube = (n): n * n * n;
}
let b = bundle(5);
print b.value, b.square(b.value), b.cube(b.value);

# Build a calculation pipeline for daylight quality scoring
let clear_hours = (daylight_hours): daylight_hours * 0.65;
let score = (daylight_hours): clear_hours(daylight_hours) / 12;
print score(18.4);

# Closure captures a constant from the surrounding scope
let offset = 7;
let shifted = (x): x + offset;
print shifted(5);

# Closure captures a location for repeated solar altitude samples
let loc = location(60, 10);
let obs = loc.observer(0.002);
let sun_alt = (t): altitude(sun, t, obs);
print sun_alt(time(2026,6,21,12,0,0));

# Build a reusable time-shift closure
let t0 = time(2026,1,1,0,0,0);
let after_hours = (h): t0.add_hours(h).utc();
print after_hours(6), after_hours(12);

# Use a closure as an object field selected by name
let ops = {add: (x, y): x + y, multiply: (x, y): x * y};
let name = "multiply";
print ops[name](6, 7);

# Dispatch between report formulas with bracket syntax
let loc = location(60,10).observer(0.002);
let formulas = {sun: (t): altitude(sun, t, loc), moon: (t): altitude(moon, t, loc)};
let chosen = "moon";
let t = time(2026,6,21,22,0,0);
print formulas[chosen](t), formulas["sun"](t);

# Update a namespace with a derived function
let tools = {base: (x): x + 1};
tools["twice"] = (x): tools.base(x) * 2;
print tools.twice(9);

# Update an array and then use it as function input
let values = [1, 2, 3];
values[1] = 8;
let sum3 = (items): items[0] + items[1] + items[2];
print sum3(values);

# Build an object row with dynamic keys
let row = {};
let key = "altitude";
row[key] = 42.5;
row["body"] = sun.name;
print row.body, row.altitude;

# Function composition with named intermediate closures
let double = (x): x * 2;
let add_one = (x): x + 1;
let composed = (x): add_one(double(x));
print composed(10);

# Compose a sky calculation from small helpers
let loc = location(60, 10);
let obs = loc.observer();
let at = (h): time(2026,6,21,h,0,0);
let sun_height = (h): altitude(sun, at(h), obs);
print sun_height(6), sun_height(12), sun_height(18);

# Reuse one body-position helper for several bodies
let t = time(2026,1,1,0,0,0);
let longitude_of = (body): ecliptic_longitude(body, t);
print longitude_of(sun), longitude_of(moon), longitude_of(mars);

# Build a report namespace from helper closures
report(body, t) {
  let name = body.name;
  let longitude = ecliptic_longitude(body, t);
  let declination_deg = declination(body, t);
}
let r = report(moon, time(2026,1,1,0,0,0));
print r.name, r.longitude, r.declination_deg;

# Make a chart helper that shares one time
chart_at(t) {
  let lon = (body): ecliptic_longitude(body, t);
  let sun_lon = lon(sun);
  let moon_lon = lon(moon);
  let mars_lon = lon(mars);
}
let c = chart_at(time(2026,1,1,0,0,0));
print c.sun_lon, c.moon_lon, c.mars_lon;

# Make a local sky helper that shares one observer
local_sky(loc) {
  let obs = loc.observer();
  let alt = (body, t): altitude(body, t, obs);
  let sun_at = (t): alt(sun, t);
  let moon_at = (t): alt(moon, t);
}
let sky = local_sky(location(latitude: 60, longitude: 10));
let t = time(2026,6,21,12,0,0);
print sky.sun_at(t), sky.moon_at(t);

# Return a namespace with both data and formulas
measurement(x) {
  let value = x;
  let doubled = (y): y * 2;
  let shifted = (y): y + x;
}
let m = measurement(10);
print m.value, m.doubled(m.value), m.shifted(5);

# Use a closure to choose an object field
let pick = (row, key): row[key];
let row = {body: sun.name, radius: sun.radius};
print pick(row, "body"), pick(row, "radius");

# Loop over names and accumulate a numeric result
let total = 0;
for i=1,5,1 {
  total = total + i * i;
}
print total;

# Use a while loop to search a small integer condition
let n = 1;
while n * n < 50 {
  n = n + 1;
}
print n, n * n;

# Use break to stop at the first useful value
let found = 0;
for i=1,20,1 {
  if i * i > 70 {
    found = i;
    break;
  }
}
print found;

# Project a field from every object in an array
let rows = [{x: 1, name: "sun"}, {x: 3, name: "moon"}];
print rows.x, rows.name;

# Transform object fields with a closure
let row = {a: 2, b: 3};
let scale_fields = (r, k): {a: r.a * k, b: r.b * k};
let scaled = scale_fields(row, 10);
print scaled.a, scaled.b;

# Use a hash to pass options into a helper
make_loc(opts) {
  let value = location(**opts);
}
let opts = hash(latitude: 60.0, longitude: 10.0);
print make_loc(opts).value;

# Extend an arguments object before calling a constructor
let base = args(latitude: 60.0);
let full = base.with(longitude: 10.0);
print location(**full);

# Build positional arguments with an array
let pair = [60.0, 10.0];
let make = (values): location(**values);
print make(pair);

# Use a scope expression as a compact calculation report
let r = {
  let x = 3;
  let y = 4;
  let hyp = hypot(x, y);
};
print r.x, r.y, r.hyp;

# Use For as an expression-like calculation block
let result = For(i, 1, 4, 1) {
  let square = i * i;
};
print result.i, result.square;

# Keep helper constants private with an underscore name
let report = {
  let _scale = 1000;
  let km = 2;
  let meters = km * _scale;
};
print report.km, report.meters;

# Define a reusable multiplier calculator
type Multiplier(k) {
  let apply = (x): x * k;
  let plus = (x, y): apply(x) + y;
}
let m = Multiplier(6);
print m.apply(7), m.plus(7, 3);

# Define chart helpers that share one time
type ChartTools(t) {
  let lon = (body): ecliptic_longitude(body, t);
  let pair = (a, b): lon(a) - lon(b);
}
let tools = ChartTools(time(2026,1,1,0,0,0));
print tools.lon(sun), tools.pair(moon, sun);

# Define local altitude helpers for one observing site
type LocalTools(loc) {
  let obs = loc.observer();
  let alt = (body, t): altitude(body, t, obs);
}
let tools = LocalTools(location(60,10));
print tools.alt(sun, time(2026,6,21,12,0,0));

# Build a small reusable closeness score
let distance_from = (target): (x): abs(x - target);
let score_to_ten = distance_from(10);
print score_to_ten(7), score_to_ten(13);

# Use a derived closure inside numeric search
let f = (x, y): x * y - 10;
let g = (x): f(x, 2);
print search(g, range(0, 10, 0.5), target(0)).next();

# Package a search result with the formula used
solve_linear(a, b) {
  let f = (x): a * x + b;
  let root = search(f, range(-10, 10, 0.5), target(0)).next();
  let formula = "a*x+b";
}
let solved = solve_linear(2, -6);
print solved.formula, solved.root;

Astrologos.examples.time_calendar

topic examples for UTC time construction, date arithmetic, local civil time, and weekday handling

Aliases: time examples, calendar, weekday, local time, date arithmetic

Topic: Astrologos.examples.time_calendar - examples for UTC time construction, date arithmetic, local civil time, and weekday handling
Syntax:
  time(year, month, day, hour, minute, second)
  time.add_days(days)
  time.local(timezone)
  weekday(value)
Aliases: time examples, calendar, weekday, local time, date arithmetic
Resources: timezones, iers

# Construct UTC times and add intervals
let t = time(2026,3,20,12,0,0);
print t.utc(), t.add_hours(6).utc(), t.add_days(7).utc();

# Days between two dates
print time(2026,3,1,0,0,0) - time(2025,1,2,0,0,0);

# Local time at a location
let loc = location(58.9666667, 5.7333333);
let tz = timezones().at(loc);
let local = time(2026,6,1,12,0,0).local(tz);
print local.iso, local.weekday.short();

# Weekday lookup and formatting
let w = weekday("Wednesday");
print w.name(), w.short(), w.index();

# Month-style civil dates from a page table
let rows = pages(location(60,10), time(2026,6,1,0,0,0)).table(days: 3);
print rows[0].date, rows[1].date, rows[2].date;

Astrologos.examples.locations_timezones

topic examples for locations, observers, place lookup, administrative fields, and timezone conversion

Aliases: location examples, place search, timezone examples, city lookup, observer examples

Topic: Astrologos.examples.locations_timezones - examples for locations, observers, place lookup, administrative fields, and timezone conversion
Syntax:
  location(latitude, longitude)
  location(...).observer(height)
  places().search("name")
  timezones().at(location)
Aliases: location examples, place search, timezone examples, city lookup, observer examples
Resources: places, timezones
Children: places and timezones

# Prepare a location and observer for local sky calculations
let loc = location(latitude: 58.9666667, longitude: 5.7333333);
let obs = loc.observer(height: 0.002);
print loc.latitude, loc.longitude, obs.height();

# Format latitude and longitude
let loc = location(latitude: 58.9666667, longitude: 5.7333333);
print dms(loc.latitude, "latitude"), dms(loc.longitude, "longitude");
print dd(58, 58, 0, "N"), dd(5, 44, 0, "E");

# Find a place and administrative names
let p = places().search("Stavanger").first();
print p.name, p.country().name, p.admin1().name, p.admin2().name;

# Timezone from a location and local time conversion
let loc = location(58.9666667, 5.7333333);
let tz = timezone(loc);
print tz.id, time(2026,6,1,12,0,0).local(tz).iso;

# Register an observatory-style place with a timezone
let here = place("Observatory", location(60,10), "Europe/Oslo");
print here.name, here.timezone().id;

Astrologos.examples.sunrise

topic thematic index for sunrise, sunset, rise/set/transit, and local horizon workflows

Aliases: sunrise, sunset, rise set, civil day, how to get sunrise for a location, sunrise in a month, monthly sunrise

Topic: Astrologos.examples.sunrise - thematic index for sunrise, sunset, rise/set/transit, and local horizon workflows
Syntax:
  events(sunrise, range(start, stop), location).first()
  events(sunset, range(start, stop), location).first()
  body.rise(range, observer).first()
  pages(location, start).table(days: count)
Aliases: sunrise, sunset, rise set, civil day, how to get sunrise for a location, sunrise in a month, monthly sunrise
Resources: ephemeris, iers
Children: sunrise day, sunrise month

# Find the focused sunrise topics
print help("sunrise day").compact();
print help("sunrise month").compact();

# Quick sunrise and sunset for one day
let loc = location(latitude: 58.9666667, longitude: 5.7333333);
let day = range(time(2024,4,17,0,0,0), time(2024,4,18,0,0,0));
print events(sunrise, day, loc).first().time.utc();
print events(sunset, day, loc).first().time.utc();

# Month-style rise/set table
let loc = location(58.9666667, 5.7333333);
let rows = pages(loc, time(2024,4,1,0,0,0)).table(days: 30);
print rows[0].sunrise.time, rows[0].sunset.time;

Astrologos.examples.sunrise.day

topic different ways to calculate sunrise, sunset, and daylight for one location and one civil date

Aliases: single day sunrise, daily sunrise, sunrise methods, different ways to calculate sunrise, same sunrise different ways

Topic: Astrologos.examples.sunrise.day - different ways to calculate sunrise, sunset, and daylight for one location and one civil date
Syntax:
  events(sunrise, day, location).first()
  sun.rise(day, observer).first()
  pages(location, time).small().short.sun.rise.time
  pages(location, time).almanac().local.sun.rise
Aliases: single day sunrise, daily sunrise, sunrise methods, different ways to calculate sunrise, same sunrise different ways
Resources: ephemeris, iers

# Method 1: direct sunrise event for a location
let loc = location(latitude: 58.9666667, longitude: 5.7333333);
let day = range(time(2024,4,17,0,0,0), time(2024,4,18,0,0,0));
let sunrise_event = events(sunrise, day, loc).first();
print sunrise_event.time.utc();

# Method 2: body method form with an observer
let loc = location(58.9666667, 5.7333333);
let obs = loc.observer(0.002);
let day = range(time(2024,4,17,0,0,0), time(2024,4,18,0,0,0));
print sun.rise(day, obs).first().time.utc();

# Method 3: one-day pages summary
let loc = location(58.9666667, 5.7333333);
let page = pages(loc, time(2024,4,17,0,0,0)).small();
print page.short.sun.rise.time, page.short.sun.set.time;

# Method 4: one-day almanac page
let loc = location(58.9666667, 5.7333333);
let local_day = pages(loc, time(2024,4,17,0,0,0)).almanac();
print local_day.local.sun.rise, local_day.local.sun.set;

# Day length from sunrise and sunset event times
let loc = location(latitude: 58.9666667, longitude: 5.7333333);
let day = range(time(2024,4,17,0,0,0), time(2024,4,18,0,0,0));
let sunrise_time = events(sunrise, day, loc).first().time;
let sunset_time = events(sunset, day, loc).first().time;
print sunset_time - sunrise_time;

Astrologos.examples.sunrise.month

topic ways to calculate sunrise and sunset tables across many days

Aliases: monthly sunrise, sunrises in a month, sunrise table, rise set table, calculate sunrises in a month

Topic: Astrologos.examples.sunrise.month - ways to calculate sunrise and sunset tables across many days
Syntax:
  pages(location, start).table(days: count)
  almanac(start, stop, location).local.sun.rise
  for d=0,count-1 { events(sunrise, range(day_start, day_stop), location) }
Aliases: monthly sunrise, sunrises in a month, sunrise table, rise set table, calculate sunrises in a month
Resources: ephemeris, iers

# Method 1: pages table for a month of sunrise and sunset rows
let loc = location(latitude: 58.9666667, longitude: 5.7333333);
let start = time(2024,4,1,0,0,0);
let rows = pages(loc, start).table(days: 30);
print rows[0].date, rows[0].sunrise.time, rows[0].sunset.time;
print rows[29].date, rows[29].sunrise.time, rows[29].sunset.time;

# Method 2: month almanac object
let loc = location(58.9666667, 5.7333333);
let start = time(2024,4,1,0,0,0);
let month = almanac(start, start.add_months(1), loc);
print month.local.sun.rise;
print month.local.sun.set;

# Method 3: explicit loop over days
let loc = location(58.9666667, 5.7333333);
let start = time(2024,4,1,0,0,0);
for d=0,29 {
  let day_start = start.add_days(d);
  let day = range(day_start, day_start.add_days(1));
  print day_start.utc(), events(sunrise, day, loc).first().time.utc();
}

# Method 4: compare sunrise drift through a month
let loc = location(58.9666667, 5.7333333);
let rows = pages(loc, time(2024,4,1,0,0,0)).table(days: 30);
print rows[0].sunrise.time, rows[14].sunrise.time, rows[29].sunrise.time;

Astrologos.examples.moonrise

topic examples for moonrise, moonset, Moon altitude, and multi-day lunar visibility

Aliases: moonrise, moonset, moon visibility, lunar visibility, moon altitude

Topic: Astrologos.examples.moonrise - examples for moonrise, moonset, Moon altitude, and multi-day lunar visibility
Syntax:
  events(moonrise, range(start, stop), location)
  moon.rise(range, observer)
  altitude(moon, time, observer)
  pages(location, moon).summary(time)
Aliases: moonrise, moonset, moon visibility, lunar visibility, moon altitude
Resources: ephemeris, iers

# Moonrise and moonset for one night
let loc = location(60.0, 10.0);
let night = range(time(2026,5,20,0,0,0), time(2026,5,21,0,0,0));
print events(moonrise, night, loc).first();
print events(moonset, night, loc).first();

# Moonrise for the next five days
let loc = location(60.0, 10.0);
let start = time(2026,5,20,0,0,0);
print events(moonrise, range(start, start.add_days(5), 0.5), loc);

# Moon altitude through a night
let obs = location(60.0, 10.0).observer(0.002);
let t0 = time(2026,5,20,18,0,0);
for h=0,12,3 {
  let t = t0.add_hours(h);
  print t.utc(), altitude(moon, t, obs), azimuth(moon, t, obs);
}

# Compact local Moon summary
let m = pages(location(60,10), moon).summary(time(2026,5,20,21,0,0));
print m.position.topocentric.altitude, m.phase, m.illumination;

Astrologos.examples.moon_phase

topic examples inspired by lunar phase and orbit catalogs: phase, illumination, perigee, apogee, and shadows

Aliases: lunar phase, full moon, new moon, perigee, apogee, moon illumination

Topic: Astrologos.examples.moon_phase - examples inspired by lunar phase and orbit catalogs: phase, illumination, perigee, apogee, and shadows
Syntax:
  moon_phase(time)
  moon_illumination(time)
  events(full_moon, range)
  events(perigee, range, moon)
Aliases: lunar phase, full moon, new moon, perigee, apogee, moon illumination
Resources: ephemeris
Children: eclipses and shadows

# Moon phase and illumination at a time
let t = time(2026,1,15,0,0,0);
print moon_phase(t), moon_illumination(t), magnitude(moon, t);

# Full moon and new moon in a month
let month = range(time(2026,1,1,0,0,0), time(2026,2,1,0,0,0), 1);
print events(full_moon, month).first().time.utc();
print events(new_moon, month).first().time.utc();

# Lunar perigee and apogee in a month
let month = range(time(2024,4,1,0,0,0), time(2024,5,1,0,0,0), 1);
print events(perigee, month, moon).first();
print events(apogee, month, moon).first();

# Moon distance, speed, and phase-like context
let t = time(2026,1,15,0,0,0);
let st = state(moon, t, geocentric, icrf, all_corrections);
print st.position().length(), st.velocity().length(), moon_illumination(t);

# Lunar eclipse magnitude helpers near a known date
let t = time(2025,3,14,6,0,0);
print lunar_eclipse_magnitude(t), lunar_penumbra_magnitude(t), lunar_eclipse_clearance(t);

Astrologos.examples.stars

topic examples for star catalog lookup, visible stars, star rise/transit/set, and angular distance

Aliases: star catalog, visible stars, Sirius, star rise, bright stars

Topic: Astrologos.examples.stars - examples for star catalog lookup, visible stars, star rise/transit/set, and angular distance
Syntax:
  stars().find("Sirius")
  stars().visible(time, observer)
  star.rise(range, observer)
  star.direction()
Aliases: star catalog, visible stars, Sirius, star rise, bright stars
Resources: stars, ephemeris, iers
Children: moon and stars, constellations()

# Find Sirius and inspect it
let sirius = stars().find("Sirius");
print sirius.name, sirius.magnitude, sirius.constellation();

# Sirius rise, transit, and set
let sirius = stars().find("Sirius");
let obs = location(60.0, 10.0).observer(0.002);
let night = range(time(2026,1,1,0,0,0), time(2026,1,2,0,0,0), 0.25);
print sirius.rise(night, obs).first();
print sirius.transit(night, obs).first();
print sirius.set(night, obs).first();

# Bright visible stars above a local horizon
let obs = location(60,10).observer(0.002);
print stars().visible(time(2026,1,1,21,0,0), obs, magnitude: 2.0);

# Angular distance between Sirius and the Moon
let t = time(2026,1,1,21,0,0);
let sirius = stars().find("Sirius").direction();
let moon_dir = direction(ra(moon, t, all_corrections), dec(moon, t, all_corrections));
print moon_dir.angular_distance(sirius, t);

Astrologos.examples.constellations

topic examples for constellation lookup by direction, Moon, planets, and stars

Aliases: constellation lookup, which constellation, sky region, iau constellation

Topic: Astrologos.examples.constellations - examples for constellation lookup by direction, Moon, planets, and stars
Syntax:
  constellations().inside(direction)
  star.constellation()
  direction(ra: value, dec: value)
Aliases: constellation lookup, which constellation, sky region, iau constellation
Resources: constellations, stars, ephemeris
Children: stars()

# Find which constellation contains a direction
let d = direction(ra: 88.8, dec: 7.4);
print constellations().inside(d);

# Moon and Sirius separation with constellation context
let t = time(2024,4,17,0,0,0);
let sirius = stars().find("Sirius");
let moon_dir = direction(ra(moon, t, all_corrections), dec(moon, t, all_corrections));
print constellations().inside(moon_dir), moon_dir.angular_distance(sirius.direction());

# Planet constellation at a time
let t = time(2026,1,1,0,0,0);
let mars_dir = direction(ra(mars, t, all_corrections), dec(mars, t, all_corrections));
print constellations().inside(mars_dir);

# Star constellation shortcut
print stars().find("Sirius").constellation();

Astrologos.examples.moon_stars

topic examples for stars, Sirius, Moon constellations, visible stars, and angular-distance searches

Aliases: moon sirius, sirius, stars, constellations, moon close to sirius, angular separation

Topic: Astrologos.examples.moon_stars - examples for stars, Sirius, Moon constellations, visible stars, and angular-distance searches
Syntax:
  stars().find("Sirius")
  direction(ra(body, time, correction), dec(body, time, correction))
  direction.angular_distance(other, time)
Aliases: moon sirius, sirius, stars, constellations, moon close to sirius, angular separation
Resources: ephemeris, stars, constellations, iers

# Sirius: lookup, constellation, and next rise
let sirius = stars().find("Sirius");
let obs = location(60.0, 10.0).observer(0.002);
let night = range(time(2026,1,1,0,0,0), time(2026,1,2,0,0,0), 0.25);
print sirius.constellation();
print sirius.rise(night, obs).first().time.utc();

# Moon constellation at a time
let t = time(2024,4,17,0,0,0);
let moon_dir = direction(ra(moon, t, all_corrections), dec(moon, t, all_corrections));
print constellations().inside(moon_dir);

# How to search for times when the Moon is close to Sirius
let sirius = stars().find("Sirius").direction();
let closeness = (t): direction(ra(moon, t, all_corrections), dec(moon, t, all_corrections)).angular_distance(sirius, t) - 5.0;
let span = range(time(2026,1,1,0,0,0), time(2026,2,1,0,0,0), 0.25);
print search(closeness, span, target(0)).next();

# Visible star names for a local evening shortlist
let obs = location(60,10).observer(0.002);
let visible = stars().visible(time(2026,1,1,21,0,0), obs, magnitude: 2.0);
print visible.name, visible.constellation;

Astrologos.examples.sky_charts

topic examples for chart-style sky questions using astronomical constellations, named stars, separations, and time searches

Aliases: sky chart, chart positions, fixed stars, close approaches, planet in constellation, planet enters constellation, planet close to star, moon close to star, constellation change, appulse

Topic: Astrologos.examples.sky_charts - examples for chart-style sky questions using astronomical constellations, named stars, separations, and time searches
Syntax:
  constellations().inside(direction(ra(body, t, all_corrections), dec(body, t, all_corrections)))
  search((t): separation(t), range(start, stop, step), minimum).next()
  search((t): separation(t) - threshold, range(start, stop, step), target(0))
  ecliptic_longitude(time)
Aliases: sky chart, chart positions, fixed stars, close approaches, planet in constellation, planet enters constellation, planet close to star, moon close to star, constellation change, appulse
Resources: ephemeris, stars, constellations, iers
Children: constellations(), moon and stars, planet events, search and optimization

# Which IAU constellation contains a planet now
let t = time(2026,1,1,0,0,0);
let d = direction(ra(mars, t, all_corrections), dec(mars, t, all_corrections));
print mars.name, constellations().inside(d);

# Scan a month for planet constellation changes
let body = mars;
let start = time(2026,1,1,0,0,0);
let previous = "";
for day=0,31 {
  let t = start.add_days(day);
  let d = direction(ra(body, t, all_corrections), dec(body, t, all_corrections));
  let c = constellations().inside(d);
  if c.name != previous {
    print t.utc(), body.name, c.name;
    previous = c.name;
  }
}

# Compare several planets by constellation
let t = time(2026,1,1,0,0,0);
let bodies = [mercury, venus, mars, jupiter, saturn];
for i=0,4 {
  let body = bodies[i];
  let d = direction(ra(body, t, all_corrections), dec(body, t, all_corrections));
  print body.name, constellations().inside(d).name;
}

# Closest approach of Venus to Regulus in a time window
let star = stars().find("Regulus").direction();
let sep = (t): direction(ra(venus, t, all_corrections), dec(venus, t, all_corrections)).angular_distance(star, t);
let span = range(time(2026,7,1,0,0,0), time(2026,9,1,0,0,0), 0.25);
let closest = search(sep, span, minimum).next();
print closest.utc(), sep(closest);

# Times when the Moon is within five degrees of Aldebaran
let star = stars().find("Aldebaran").direction();
let sep = (t): direction(ra(moon, t, all_corrections), dec(moon, t, all_corrections)).angular_distance(star, t) - 5.0;
let span = range(time(2026,1,1,0,0,0), time(2026,2,1,0,0,0), 0.25);
print search(sep, span, target(0)).all();

# Thirty-degree solar longitude sector
let sectors = ["sector 0", "sector 1", "sector 2", "sector 3", "sector 4", "sector 5", "sector 6", "sector 7", "sector 8", "sector 9", "sector 10", "sector 11"];
let t = time(2026,3,20,12,0,0);
let lon = ecliptic_longitude(t);
print sectors[floor(lon / 30.0)], lon;

# Nearest bright star to the Moon
let t = time(2026,1,1,21,0,0);
let moon_dir = direction(ra(moon, t, all_corrections), dec(moon, t, all_corrections));
let nearest = stars().nearest(moon_dir, magnitude: 2.0);
print nearest.name, nearest.separation, nearest.constellation();

Astrologos.examples.planets

topic examples for planetary events such as opposition, conjunction, elongation, perihelion, and aphelion

Aliases: opposition, conjunction, elongation, perihelion, aphelion, planet examples

Topic: Astrologos.examples.planets - examples for planetary events such as opposition, conjunction, elongation, perihelion, and aphelion
Syntax:
  events(opposition, range, body).first()
  events(greatest_elongation, range, body).first()
  body.perihelion(start, stop, step).first()
Aliases: opposition, conjunction, elongation, perihelion, aphelion, planet examples
Resources: ephemeris

# Planet opposition and Mercury elongation
let year = range(time(2024,1,1,0,0,0), time(2025,1,1,0,0,0), 2);
print events(opposition, year, jupiter).first();
print events(greatest_elongation, year, mercury).first();

# Sun orbital events relative to the solar-system barycenter
print sun.periapsis();
print sun.apoapsis();
print sun.greatest_western_elongation();
print sun.greatest_eastern_elongation();
print sun.opposition();
print sun.conjunction();

# Earth's perihelion and aphelion
let peri = events(perihelion, range(time(2024,1,1,0,0,0), time(2024,1,10,0,0,0), 1), earth).first();
let aph = events(aphelion, range(time(2024,7,1,0,0,0), time(2024,7,10,0,0,0), 1), earth).first();
print peri.time.utc(), peri.value;
print aph.time.utc(), aph.value;

# Planet position table at one time
let t = time(2026,1,1,0,0,0);
for i=0,4 {
  let p = [mercury, venus, mars, jupiter, saturn][i];
  print p.name, ra(p, t, all_corrections), dec(p, t, all_corrections), magnitude(p, t);
}

# Close approach style angular separation
let t = time(2026,1,1,0,0,0);
let venus_dir = direction(ra(venus, t, all_corrections), dec(venus, t, all_corrections));
let mars_dir = direction(ra(mars, t, all_corrections), dec(mars, t, all_corrections));
print venus_dir.angular_distance(mars_dir, t), distance(venus, t), distance(mars, t);

# Bright planet context inspired by magnitude catalogs
let t = time(2026,1,1,0,0,0);
print venus.name, magnitude(venus, t), elongation(venus, t), heliocentric_ecliptic_longitude(venus, t);

# Rotational axis helpers
let t = time(2026,1,1,0,0,0);
print rotational_axis_ra(mars, t), rotational_axis_dec(mars, t), rotational_axis(mars, t);

Astrologos.examples.eclipses

topic examples for eclipse events and shadow-distance helper functions

Aliases: solar eclipse, lunar eclipse, shadow, umbra, penumbra, obscuration

Topic: Astrologos.examples.eclipses - examples for eclipse events and shadow-distance helper functions
Syntax:
  events(solar_eclipse, range, location).first()
  solar_eclipse_magnitude(time, location)
  lunar_eclipse_magnitude(time)
  shadow_distance(body, time)
Aliases: solar eclipse, lunar eclipse, shadow, umbra, penumbra, obscuration
Resources: ephemeris, iers
Children: moon phase

# Solar eclipse event near Dallas, 2024-04-08
let dallas = location(latitude: 32.7767, longitude: -96.7970);
let span = range(time(2024,4,8,12,0,0), time(2024,4,9,0,0,0), 0.25);
print events(solar_eclipse, span, dallas).first();

# Solar eclipse helper values at a location
let dallas = location(32.7767, -96.7970);
let t = time(2024,4,8,18,20,0);
print solar_eclipse_magnitude(t, dallas), solar_eclipse_obscuration(t, dallas), solar_eclipse_clearance(t, dallas);

# Lunar eclipse helper values
let t = time(2025,3,14,6,0,0);
print lunar_eclipse_magnitude(t), lunar_penumbra_magnitude(t), lunar_eclipse_clearance(t);

# Moon umbra and penumbra distance helpers
let t = time(2024,4,8,18,20,0);
print moon_umbra_distance(t), moon_penumbra_distance(t), moon_shadow_earth_distance(t);

# Moon umbra occultation helper
let t = time(2024,4,8,18,20,0);
print moon_umbra_occultation(t);

# Location and planet shadow distances
let loc = location(latitude: 32.7767, longitude: -96.7970);
let t = time(2024,4,8,18,20,0);
print location_shadow_distance(t, loc), planet_shadow_earth_distance(mercury, t), shadow_distance(t);

Astrologos.examples.almanac

topic examples for pages(), almanac(), charts, local sky summaries, phases, and seasonal events

Aliases: almanac, pages, local sky, chart, moon phase, seasons

Topic: Astrologos.examples.almanac - examples for pages(), almanac(), charts, local sky summaries, phases, and seasonal events
Syntax:
  pages(location).sky(time)
  pages(time).chart()
  almanac(start, stop, location)
Aliases: almanac, pages, local sky, chart, moon phase, seasons
Resources: ephemeris, iers

# Local sky page now
let loc = location(60.0, 10.0);
let s = pages(loc).sky();
print s.sun.altitude, s.moon.phase;

# Page chart with sign labels for several bodies
let c = pages(time(2026,1,1,0,0,0)).chart();
print c.bodies.sun.chart.sign, c.bodies.moon.chart.sign, c.bodies.mars.chart.sign;

# Equinoxes and solstices in one almanac
let a = almanac(time(2024,1,1,0,0,0), time(2025,1,1,0,0,0));
print a.seasons.ascending_equinox, a.seasons.northern_solstice;
print a.seasons.descending_equinox, a.seasons.southern_solstice;

Astrologos.examples.pages

topic examples for compact page-style data products over sky, chart, almanac, table, and state views

Aliases: data pages, sky page, chart page, state page, report pages

Topic: Astrologos.examples.pages - examples for compact page-style data products over sky, chart, almanac, table, and state views
Syntax:
  pages(location).sky(time)
  pages(time).chart()
  pages(location, body).summary(time)
  pages(time).state()
Aliases: data pages, sky page, chart page, state page, report pages
Resources: ephemeris, iers
Children: almanac pages, sunrise examples

# Local sky page now
let s = pages(location(60.0, 10.0)).sky();
print s.sun.altitude, s.moon.phase;

# Chart positions page
let c = pages(time(2026,1,1,0,0,0)).chart();
print c.bodies.sun.geocentric.longitude, c.bodies.moon.chart.sign;

# Compact Moon summary page
let m = pages(location(60.0, 10.0), moon).summary(time());
print m.position.topocentric.altitude, m.phase, m.illumination;

# One-day full local page
let d = pages(location(60.0, 10.0), time(2026,1,1,0,0,0)).small();
print d.short.sun.rise.time, d.chart.bodies.moon.geocentric.longitude;

# Solar-system state vectors page
let st = pages(time(2026,1,1,0,0,0)).state();
print st.bodies.earth.position_bc_icrf().length();

Astrologos.examples.coordinates

topic examples for right ascension, declination, altitude, azimuth, headings, frames, and units

Aliases: ra dec, altitude azimuth, heading, frames, angle units

Topic: Astrologos.examples.coordinates - examples for right ascension, declination, altitude, azimuth, headings, frames, and units
Syntax:
  direction(ra: value, dec: value)
  direction(topographic, azimuth: value, altitude: value)
  heading(value)
  to_radians(degrees)
  vector.angle(other, deg)
  angle_in_degrees(vector_a, vector_b)
Aliases: ra dec, altitude azimuth, heading, frames, angle units
Resources: ephemeris, iers
Children: vectors matrices orbits

# RA/Dec direction from body coordinates
let t = time(2026,1,1,0,0,0);
let mars_dir = direction(ra: ra(mars, t, all_corrections), dec: dec(mars, t, all_corrections));
print mars_dir.ra, mars_dir.dec;

# Long-form right ascension and ecliptic longitude
let t = time(2026,3,20,12,0,0);
print right_ascension(sun, t, all_corrections), declination(sun, t, all_corrections), ecliptic_longitude(t);

# Local altitude and azimuth for a body
let obs = location(60,10).observer(0.002);
let t = time(2026,1,1,21,0,0);
print altitude(jupiter, t, obs), azimuth(jupiter, t, obs);

# Topographic direction from azimuth and altitude
let d = direction(topographic, azimuth: 180.0, altitude: 25.0);
print d.frame, d.ra, d.dec;

# Apparent geocentric Sun-Moon separation in degrees
let t = time();
let sun_vector = state(body: sun, time: t).pos_gc_icrf;
let moon_vector = state(body: moon, time: t).pos_gc_icrf;
print sun_vector.angle(moon_vector, deg), angle_in_degrees(sun_vector, moon_vector);

# Headings and angle units
print heading("southwest"), heading(270.0), to_radians(180.0), to_degrees(pi);

# Apparent solar and lunar time
let loc = location(60,10);
let t = time(2026,6,21,12,0,0);
print apparent_solar_time(t, loc), lunar_time(t, loc);

Astrologos.examples.vectors_matrices

topic examples for vectors, matrices, state vectors, orbital elements, orbits, units, and spherical coordinates

Aliases: vector, matrix, orbit, elements, state vectors, geometry

Topic: Astrologos.examples.vectors_matrices - examples for vectors, matrices, state vectors, orbital elements, orbits, units, and spherical coordinates
Syntax:
  vector(x, y, z)
  spherical(radius, theta, phi)
  vector.angle(other[, unit])
  matrix(from, to, time)
  elements(q, e, i, node, argument, anomaly, unit)
  orbit(elements, central, time, axis)
Aliases: vector, matrix, orbit, elements, state vectors, geometry
Resources: ephemeris
Children: coordinates and directions

# Vector construction and distance
let a = vector(1, 0, 0);
let b = vector(0, 1, 0);
print a.length(), a.distance(b), a.cross(b);

# Vector angle in degrees
let a = vector(1, 0, 0);
let b = vector(0, 1, 0);
print a.angle(b, deg), angle_in_degrees(a, b);

# Spherical vector and unit conversion
let v = spherical(1.0, 45.0, 30.0, deg);
print v.length(), to_radians(45.0), to_degrees(pi);

# Matrix rotation between frames
let t = time(2026,1,1,0,0,0);
let m = matrix(icrf, ecliptic, t);
print m.determinant(), m.inverse().determinant();

# Body state position and velocity
let st = state(mars, time(2026,1,1,0,0,0), heliocentric, icrf, all_corrections);
print st.position().length(), st.velocity().length();

# Orbital elements and orbit value
let el = elements(q: 0.9, e: 0.1, i: 5.0, node: 80.0, argument: 45.0, anomaly: 0.0, unit: deg);
let o = orbit(el, sun, time(2026,1,1,0,0,0), icrf);
print o.elements().e, o.central.name;

Astrologos.examples.orbit_propagation

topic examples for immutable propagation systems, integrated states, diagnostics, and ephemeris residual checks

Aliases: orbit propagator, system propagation, n body, integrator, ias15, rk4, dp5, ephemeris residuals

Topic: Astrologos.examples.orbit_propagation - examples for immutable propagation systems, integrated states, diagnostics, and ephemeris residual checks
Syntax:
  system(time, state(...), body, ...)
  system(...).at(time)
  system(...).diagnostics
  system(...).ephemeris_residuals
  bodies.find(name)
  bodies.smallBodyStates(time)
  bodies.smallBodyStates(time, min_mass)
Aliases: orbit propagator, system propagation, n body, integrator, ias15, rk4, dp5, ephemeris residuals
Resources: ephemeris, iers
Children: vectors matrices orbits, planet events

# Propagate an explicit comet state with the Sun from the ephemeris
let t0 = time(2026,4,27,8,26,0);
let comet0 = state(body: body("comet"), time: t0, position: vector(100000000,0,0), velocity: vector(0,10,0));
let later = system(t0, comet0, sun).at(t0.add_days(10));
print later.comet.position(), later.sun.position();

# Include massive small-body perturbers through the registry
let t0 = time(2026,1,1);
let ceres = bodies.find("ceres");
let sys = system(t0, bodies.longSolarSystem());
print ceres.name, sys.state("vesta").body.name, sys.states.length();

# Limit small-body perturbers by mass in kg
let t0 = time(2026,1,1);
let threshold = bodies.find("vesta").mass;
let sys = system(t0, bodies.smallBodyStates(t0, threshold));
print sys.states.length();

# Extract small-body states when they should be numerical initial conditions
let t0 = time(2026,1,1);
let small = bodies.smallBodyStates(t0);
let sys = system(t0, small, state(moon, t0));
print sys.sources.ceres, sys.sources.moon, sys.states.length();

# Compare integrated Solar-System states against ephemeris after one year
let t0 = time(2026,1,1);
let t1 = t0.add_days(365.25);
let sys = system(t0, state(sun,t0), state(earth,t0), state(moon,t0), state(mars,t0));
let later = sys.at(t1);
print later.ephemeris_residuals.earth, later.ephemeris_residuals.moon, later.diagnostics.accepted_steps;

# Use the shared cache during a short search-style sequence
let t0 = time(2026,1,1);
let comet0 = state(body: body("comet"), time: t0, position: vector(100000000,0,0), velocity: vector(0,10,0));
let sys = system(t0, comet0, sun);
let a = sys.at(t0.add_days(1));
let b = a.at(t0.add_days(1.25));
print b.cache_size, b.diagnostics.derivative_evaluations;

# Select an expert integrator; dp5 is a slow reference/debug method
let t0 = time(2026,1,1);
let comet0 = state(body: body("comet"), time: t0, position: vector(100000000,0,0), velocity: vector(0,10,0));
print system(t0, comet0, sun).integrator;
print system(t0, comet0, sun, method: "rk4").integrator;
print system(t0, comet0, sun, integrator: "dp5").integrator;

Astrologos.examples.polygons

topic examples for polygon geometry in sky or lon/lat style coordinate work

Aliases: polygon, sky polygon, area, inside, winding

Topic: Astrologos.examples.polygons - examples for polygon geometry in sky or lon/lat style coordinate work
Syntax:
  polygon(frame, time, vertices)
  polygon.inside(direction)
  polygon.area()
Aliases: polygon, sky polygon, area, inside, winding
Children: coordinates and directions

# Polygon around a small sky region
let vertices = [direction(ra: 40, dec: 10), direction(ra: 50, dec: 10), direction(ra: 50, dec: 20), direction(ra: 40, dec: 20)];
let p = polygon(icrf, time(2026,1,1,0,0,0), vertices);
print p.count, p.area(), p.inside(direction(ra: 45, dec: 15));

# Polygon winding and inverted containment
let vertices = [direction(ra: 0, dec: 0), direction(ra: 10, dec: 0), direction(ra: 10, dec: 10)];
let p = polygon(icrf, time(), vertices);
let point = direction(ra: 180, dec: 0);
print p.winding(point), p.invert().inside(point);

# Convert polygon vertices to lon/lat diagnostics
let t = time(2026,1,1,0,0,0);
let p = polygon(icrf, t, [direction(ra: 0, dec: 0), direction(ra: 10, dec: 0), direction(ra: 10, dec: 10)]);
print p.lonlat(t), p.lonlat_diagnostic(t);

Astrologos.examples.places_timezones

topic examples for place search, nearby places, timezone lookup, and local civil time

Aliases: places, timezones, local time, city search, location database

Topic: Astrologos.examples.places_timezones - examples for place search, nearby places, timezone lookup, and local civil time
Syntax:
  places().search("name")
  timezones().at(location)
  time.utc().local(timezone)
Aliases: places, timezones, local time, city search, location database
Resources: places, timezones

# Find a place and its timezone
let p = places().search("Stavanger").first();
let tz = p.timezone();
print p.name, p.location().latitude, tz.id;

# Convert UTC to local civil time at a location
let loc = location(58.9666667, 5.7333333);
let tz = timezones().at(loc);
print time(2026,6,1,12,0,0).local(tz).iso;

Astrologos.examples.weather_fields

topic examples for forecast products, field sources, NetCDF variables, scalar/vector fields, and sampling

Aliases: weather fields, forecast fields, scalar field, vector field, netcdf fields

Topic: Astrologos.examples.weather_fields - examples for forecast products, field sources, NetCDF variables, scalar/vector fields, and sampling
Syntax:
  forecast().sample(location, field)
  field(source, variable)
  netcdf(source)
  sample(field, location)
Aliases: weather fields, forecast fields, scalar field, vector field, netcdf fields
Resources: gfs
Children: topography(), magnetic field

# Sample current forecast fields at a location
let loc = location(60.0, 10.0);
let rows = forecast().sample(loc, temperature, humidity, wind);
print rows[0].temperature, rows[0].wind.u, rows[0].wind.v;

# Forecast metadata and availability
let fc = forecast();
print fc.available(), fc.count(), fc.cycle(), fc.max_time();

# Inspect forecast products
let fc = forecast();
print fc.toc();
print fc.messages().length();

# NetCDF field source and variable inspection
let nc = netcdf(earth_topography);
print nc.path, nc.variables.length(), nc.variable("z");

# Scalar field sample through compatibility helper
let loc = location(latitude: 60.0, longitude: 10.0);
let terrain = topography(earth);
print sample(terrain, loc);

Astrologos.examples.topography

topic examples for topographic field sampling and observer height workflows

Aliases: earth topography, height, elevation, terrain, sample topography

Topic: Astrologos.examples.topography - examples for topographic field sampling and observer height workflows
Syntax:
  topography(body)
  sample(topography(earth), location)
  location.observer(height)
Aliases: earth topography, height, elevation, terrain, sample topography
Resources: earth_topography
Children: weather and fields

# Sample Earth topography
let loc = location(latitude: 60.0, longitude: 10.0);
print sample(topography(earth), loc);

# Sample an explicitly selected topography field
let topo = topography(earth);
print sample(topo, location(latitude: 60.0, longitude: 10.0));

# Use sampled height as an observer height
let loc = location(latitude: 60.0, longitude: 10.0);
let height_km = sample(topography(earth), loc) / 1000.0;
let obs = loc.observer(height_km);
print obs.height();

# Compare topography at two locations
let a = location(latitude: 60.0, longitude: 10.0);
let b = location(latitude: 27.9881, longitude: 86.9250);
print sample(topography(earth), a), sample(topography(earth), b);

Astrologos.examples.magnetic

topic examples for magnetic model handles and field sampling at observers

Aliases: magnetic, magnetic model, field model, geomagnetic

Topic: Astrologos.examples.magnetic - examples for magnetic model handles and field sampling at observers
Syntax:
  magnetic(body, time, observer)
  magnetic(...).field()
Aliases: magnetic, magnetic model, field model, geomagnetic
Resources: magnetic
Children: weather and fields

# Magnetic field at an observer
let obs = location(60.0, 10.0).observer(0.002);
let model = magnetic(earth, time(2026,1,1,0,0,0), obs);
print model.field();

# Magnetic model metadata
let obs = location(60.0, 10.0).observer();
let model = magnetic(earth, time(2026,1,1,0,0,0), obs);
print model.body.name, model.time.utc(), model.observer.latitude();

# Compare magnetic field at two places
let t = time(2026,1,1,0,0,0);
let north = magnetic(earth, t, location(70,20).observer()).field();
let south = magnetic(earth, t, location(-30,20).observer()).field();
print north, south;

Astrologos.examples.weather

topic examples for forecast fields, scalar/vector field sampling, topography, and magnetic models

Aliases: weather, forecast, gfs, topography, magnetic, field sampling

Topic: Astrologos.examples.weather - examples for forecast fields, scalar/vector field sampling, topography, and magnetic models
Syntax:
  forecast().sample(location, field)
  sample(field, location)
  magnetic(body, time, observer).field()
Aliases: weather, forecast, gfs, topography, magnetic, field sampling
Resources: gfs, earth_topography, magnetic

# Build a compact weather-and-terrain row
let loc = location(latitude: 60.0, longitude: 10.0);
let rows = forecast().sample(loc, temperature, wind);
print rows[0].temperature, rows[0].wind.u, sample(topography(earth), loc);

# Compare forecast wind with magnetic field context
let loc = location(60.0, 10.0);
let obs = loc.observer(0.002);
let rows = forecast().sample(loc, wind);
print rows[0].wind.u, rows[0].wind.v, magnetic(earth, time(2026,1,1,0,0,0), obs).field();

# Magnetic field at an observer
let obs = location(60.0, 10.0).observer(0.002);
print magnetic(earth, time(2026,1,1,0,0,0), obs).field();

Astrologos.examples.graphics

topic examples for generating SVG plots and sky views

Aliases: graphics, svg, sky map, plot, chart drawing

Topic: Astrologos.examples.graphics - examples for generating SVG plots and sky views
Syntax:
  graphics().line(...).write_svg("file.svg")
  graphics(time, location).sky_view(center_az: 180, center_alt: 45, fov: 120).sky_grid().sky_planets().write_svg("sky.svg")
Aliases: graphics, svg, sky map, plot, chart drawing
Resources: ephemeris, stars, constellations

# Build a client-ready sky SVG with planets and bright stars
graphics(time(2026,1,1,21,0,0), location(latitude: 60, longitude: 10)).dark().sky_view(center_az: 180, center_alt: 45, fov: 120).sky_grid().sky_planets().sky_stars(magnitude: 4).write_svg("sky.svg");
print "wrote sky.svg";

# Plot Sun altitude samples into an SVG
let loc = location(60,10);
let obs = loc.observer(0.002);
let t0 = time(2026,6,21,0,0,0);
graphics().function((h): altitude(sun, t0.add_hours(h), obs), range(0,24,1)).title("Sun altitude").write_svg("sun-altitude.svg");
print "wrote sun-altitude.svg";

# Draw a labelled line SVG plot with explicit axes
graphics().line([0, 1, 2, 3, 4], [1, 3, 2, 5, 4]).points([0, 1, 2, 3, 4], [1, 3, 2, 5, 4]).text([1, 3], [3, 5], ["local peak", "maximum"]).title("Example line chart").xlabel("sample number").ylabel("measured value").xrange(0, 4).yrange(0, 6).xticks([0, 1, 2, 3, 4]).yticks([0, 2, 4, 6]).write_svg("line-plot.svg");
print "wrote line-plot.svg";

# Draw a labelled point SVG plot with explicit axes
graphics().points([0, 1, 2, 3, 4], [2, 1, 4, 3, 5]).text([0, 2, 4], [2, 4, 5], ["A", "B", "C"]).title("Example point chart").xlabel("sample number").ylabel("score").xrange(-0.5, 4.5).yrange(0, 6).xticks([0, 1, 2, 3, 4]).yticks([0, 2, 4, 6]).write_svg("points-plot.svg");
print "wrote points-plot.svg";

# Return several SVG graphics from one program
let t = time(2026,1,1,21,0,0);
let loc = location(latitude: 60, longitude: 10);
let obs = loc.observer(0.002);
let t0 = time(2026,6,21,0,0,0);
graphics(t, loc).dark().sky_view(center_az: 180, center_alt: 45, fov: 120).sky_grid().sky_stars(magnitude: 4).sky_planets().write_svg("gallery-sky.svg");
graphics().function((h): altitude(sun, t0.add_hours(h), obs), range(0,24,1)).title("Sun altitude").write_svg("gallery-sun-altitude.svg");
graphics().polygon([0, 1, 2, 3, 4], [0, 3, 4, 2, 0]).line([0, 1, 2, 3, 4], [0, 3, 4, 2, 0]).points([0, 1, 2, 3, 4], [0, 3, 4, 2, 0]).text([0, 2, 4], [0, 4, 0], ["start", "peak", "end"]).title("Polygon, points and labels").write_svg("gallery-shape.svg");
print "wrote three SVG graphics";

# Plot daylight duration across three planning dates
let loc = location(latitude: 58.9666667, longitude: 5.7333333);
let d0 = time(2026,4,1,0,0,0);
let d1 = time(2026,5,1,0,0,0);
let d2 = time(2026,6,1,0,0,0);
daylight(d) {
  let span = range(d, d.add_days(1));
  let rise = events(sunrise, span, loc).first().time;
  let set = events(sunset, span, loc).first().time;
  let value = (set - rise) * 24;
}
graphics().line([0, 1, 2], [daylight(d0).value, daylight(d1).value, daylight(d2).value]).points([0, 1, 2], [daylight(d0).value, daylight(d1).value, daylight(d2).value]).xlabel("month").ylabel("daylight hours").write_svg("daylight.svg");
print "wrote daylight.svg";

# Sky map centered on the south horizon
graphics(time(2026,1,1,21,0,0), location(60,10), center_az: 180, center_alt: 25, fov: 100).dark().sky_grid().sky_constellations().sky_planets().write_svg("south-sky.svg");
print "wrote south-sky.svg";

# Add custom text to a graphic
graphics().title("Example plot").text(1, 1, "note").write_svg("text.svg");
print "wrote text.svg";

Astrologos.examples.resources

topic examples for resource discovery, upstream source metadata, and availability checks

Aliases: resources, resource availability, data sources, diagnostics, available

Topic: Astrologos.examples.resources - examples for resource discovery, upstream source metadata, and availability checks
Syntax:
  resources()
  resource_sources()
  value.available()
  help("topic").resources
Aliases: resources, resource availability, data sources, diagnostics, available
Children: weather and fields, topography(), magnetic field

# Verify terrain data before sampling a location
let loc = location(60.0, 10.0);
let terrain = topography(earth);
print terrain.available(), sample(terrain, loc);

# Verify forecast data before sampling weather fields
let fc = forecast();
let loc = location(60.0, 10.0);
let rows = fc.sample(loc, temperature, wind);
print fc.available(), rows[0].temperature, rows[0].wind.u, rows[0].wind.v;

# Inspect the NetCDF file behind Earth topography
let nc = netcdf(earth_topography);
print nc.path, nc.variables.length();

# Export the upstream source table for an operator report
let sources = resource_sources();
print sources;

Astrologos.examples.runtime

topic examples for runtime automation, timing, early exit, and development checks

Aliases: automation, run file, elapsed, sleep, exit, help json

Topic: Astrologos.examples.runtime - examples for runtime automation, timing, early exit, and development checks
Syntax:
  run("file.astrologos")
  elapsed()
  sleep(milliseconds)
  exit()
  astrologos-cli check-help-examples
Aliases: automation, run file, elapsed, sleep, exit, help json
Children: resources and diagnostics

# Time a sunrise search for an operator log
let start = elapsed();
let loc = location(58.9666667, 5.7333333);
let day = range(time(2024,4,17,0,0,0), time(2024,4,18,0,0,0));
let rise = events(sunrise, day, loc).first().time.utc();
print rise, elapsed() - start;

# Pause between two status samples
let before = elapsed();
sleep(10);
print elapsed() - before;

# Stop a script early with the deprecated run() alias
print "before run";
run();
print "after run";

# Stop after a guard condition has printed the reason
let fc = forecast();
if fc.available() == false {
  print "forecast unavailable";
  exit();
}
print fc.count();

# Record the command that validates the shipped help examples
print "astrologos-cli check-help-examples";

Astrologos.examples.math

topic examples for numeric functions, trigonometry, rounding, logs, integration, and optimization

Aliases: math, numeric recipes, trigonometry, logs, rounding

Topic: Astrologos.examples.math - examples for numeric functions, trigonometry, rounding, logs, integration, and optimization
Syntax:
  sin(x)
  pow(x, y)
  clamp(value, min, max)
  angle_in_degrees(vector_a, vector_b)
  integrate((x): expression, {x: range(a, b)})
  minimize((x): expression, {x: start}, options)
Aliases: math, numeric recipes, trigonometry, logs, rounding
Children: search and optimization

# Trigonometry and unit conversion
let angle = to_radians(45);
print sin(angle), cos(angle), tan(angle), to_degrees(angle);

# Vector angle in degrees
let a = vector(1,0,0);
let b = vector(0,1,0);
print a.angle(b, deg), angle_in_degrees(a, b);

# Rounding, clamping, powers, and roots
let x = -2.75;
print abs(x), floor(x), ceil(x), round(x), trunc(x), clamp(x, -1, 1), pow(2, 8), sqrt(81), cbrt(27);

# Fractions, hypot, and signs
let x = -2.75;
print fract(x), hypot(3, 4), sign(x), min(x, 0), max(x, 0);

# Logs, exponentials, and finite checks
let value = exp(ln(10));
print value, exp2(3), log(100, 10), log10(1000), log2(8), is_finite(value), is_nan(0/0), is_infinite(1/0);

# Hyperbolic and inverse functions
print sinh(1), cosh(1), tanh(1), asinh(1), acosh(2), atanh(0.5), asin(0.5), acos(0.5), atan(1), atan2(1, 1);

# Integrate a daylight exposure proxy over a day
let exposure = integrate((h): max(0, sin(pi * h / 24)), {h: range(0, 24, 0.1)});
print exposure;

# Minimize distance from a desired Sun altitude
let loc = location(latitude: 58.9666667, longitude: 5.7333333);
let day = time(2026,6,21,0,0,0);
let objective = (h): pow(altitude(sun, day.add_hours(h), loc) - 20, 2);
print minimize(objective, {h: 6}, {bounds: {h: range(0, 24)}});

Astrologos.examples.search

topic examples for searching ranges, finding target crossings, and using closure-valued scalar functions

Aliases: search, target, root finding, minimize, custom scalar crossing

Topic: Astrologos.examples.search - examples for searching ranges, finding target crossings, and using closure-valued scalar functions
Syntax:
  search((x): expression, range(start, stop, step), target(value)).next()
  target(value, increasing)
  target(value, decreasing)
Aliases: search, target, root finding, minimize, custom scalar crossing
Resources: ephemeris, iers

# Search for a custom scalar crossing
let root = search((x): cos(x) - 0.5, range(0, 4, 0.25), target(0, decreasing)).next();
print root;

# Find when the Sun crosses a chosen altitude
let loc = location(60,10);
let obs = loc.observer(0.002);
let t0 = time(2026,6,21,0,0,0);
let f = (h): altitude(sun, t0.add_hours(h), obs) - 10.0;
print search(f, range(0, 24, 0.25), target(0)).next();

# Search for the Moon near Sirius
let sirius = stars().find("Sirius").direction();
let f = (t): direction(ra(moon, t, all_corrections), dec(moon, t, all_corrections)).angular_distance(sirius, t) - 5.0;
print search(f, range(time(2026,1,1,0,0,0), time(2026,2,1,0,0,0), 0.25), target(0)).next();

# Closest approach style minimization over a numeric domain
let f = (x): pow(x - 2.5, 2) + 1;
print minimize(f, {x: 0}, {bounds: {x: range(0, 5)}});

# Use target direction to pick a crossing side
let root = search((x): sin(x), range(0, 7, 0.1), target(0, increasing)).next();
print root;

time

function creates UTC time, or local civil time when given a timezone, location, or place

Function: time - creates UTC time, or local civil time when given a timezone, location, or place
Syntax:
  time() -> Time
  time(julian_date: Number) -> Time
  time(year: Integer, month: Integer, day: Integer, hour: Integer, minute: Integer, second: Integer) -> Time
  time(timezone: Timezone|Text|Location|Place) -> LocalTime
  time(year: Integer, month: Integer, day: Integer, hour: Integer, minute: Integer, second: Integer, timezone: Timezone|Text|Location|Place) -> LocalTime
Arguments:
  julian_date: Number [optional] - UTC Julian date
  year: Integer [optional] - full UTC year
  month: Integer [optional] - month from 1 to 12
  day: Integer [optional] - day from 1 to 31
  hour: Integer [optional] - hour from 0 to 23
  minute: Integer [optional] - minute from 0 to 59
  second: Integer [optional] - second from 0 to 59
  timezone: Timezone|Text|Location|Place [optional] - timezone id, Timezone, Location, or Place for local civil time
Resources: iers
Children: Time, year, month, day, hour, minute, second, weekday, year(), utc(), tt(), ut1(), tdb(), dt(), local(), add_months(), add_days(), add_hours(), add_minutes(), add_seconds(), children(), fields(), functions(), help(), available()

# Build a UTC timestamp for later calculations
print time();

weekday

function creates a weekday value

Function: weekday - creates a weekday value
Syntax:
  weekday(value: Integer|Text) -> Weekday
Arguments:
  value: Integer|Text - ISO index from 1 to 7, full name, or short name
Children: Weekday, name(), short(), letter(), index(), children(), fields(), functions(), help(), available()

# Convert a date or name to a weekday value
print wednesday;

location

function creates a location system value

Function: location - creates a location system value
Syntax:
  location(body: Body, latitude: Number, longitude: Number) -> Location
Arguments:
  body: Body [optional] - central body; defaults to earth
  latitude: Number - latitude in degrees
  longitude: Number - longitude in degrees
Children: Location, body, latitude, longitude, observer(), direction(), children(), fields(), functions(), help(), available()

# Prepare a latitude and longitude for local sky calculations
print location(latitude: 60.0, longitude: 270.0);

observer

function creates a body-fixed 3D observer

Function: observer - creates a body-fixed 3D observer
Syntax:
  observer(location_or_body: Location|Body, height_or_position: Number|Field|Vector, height_or_zenith: Number|Vector) -> Observer
Arguments:
  location_or_body: Location|Body - surface location or body for body-fixed vectors
  height_or_position: Number|Field|Vector [optional] - height in kilometers, topography field for a location, or observer position vector
  height_or_zenith: Number|Vector [optional] - height above topography for a location, or body-fixed zenith/up vector
Children: Observer, body, position, zenith, location, height_km, position(), location(), latitude(), longitude(), height(), zenith(), north(), west(), limb(), direction(), orbit(), children(), fields(), functions(), help(), available()

# Prepare an observing site with height
print location(latitude: 60.0, longitude: 270.0).observer(height: 1.5);

body

function creates a body system value

Function: body - creates a body system value
Syntax:
  body(name: Text) -> Body
Arguments:
  name: Text - solar-system body name
Children: Body, name, kind, xmu, radius, mass, H, n, k, known, rotational_axis(), rotational_axis_ra(), rotational_axis_dec(), state(), rise(), set(), conjunction(), inferior_conjunction(), superior_conjunction(), opposition(), eastern_quadrature(), western_quadrature(), quadrature(), greatest_eastern_elongation(), greatest_western_elongation(), greatest_elongation(), periapsis(), apoapsis(), transit(), children(), fields(), functions(), help(), available()

# Look up a solar-system body by name
print sun;

elements

function creates osculating orbital elements

Function: elements - creates osculating orbital elements
Syntax:
  elements(q: Number, e: Number, i: Number, node: Number, argument: Number, anomaly: Number, unit: Unit) -> Elements
Arguments:
  q: Number - periapsis distance in kilometers
  e: Number - eccentricity
  i: Number - inclination in degrees by default
  node: Number - longitude of ascending node in degrees by default
  argument: Number - argument of periapsis in degrees by default
  anomaly: Number - true anomaly in degrees by default
  unit: Unit [optional] - optional angle unit, such as rad
Children: Elements, q, e, i, node, argument, anomaly, semimajor_axis, semi_latus_rectum, children(), fields(), functions(), help(), available()

# Define elliptic orbital elements and inspect eccentricity and inclination
let el = elements(q: 7000, e: 0.1, i: 30, node: 40, argument: 50, anomaly: 0, unit: deg);
print el.q, el.e, el.i;

orbit

function creates a two-body orbit from elements

Function: orbit - creates a two-body orbit from elements
Syntax:
  orbit(elements: Elements, central: Body, time: Time, axis: Axis) -> Orbit
Arguments:
  elements: Elements - osculating elements at the epoch
  central: Body - central gravitating body
  time: Time - epoch time
  axis: Axis [optional] - non-rotating element axis, icrf by default; tod is also accepted
Children: Orbit, body, central, time, epoch, axis, elements, position, velocity, conic, position(), velocity(), at(), elements(), predict(), children(), fields(), functions(), help(), available()

# Propagate an elliptic orbit six hours forward
let epoch = time(2026,1,1,0,0,0);
let el = elements(q: 7000, e: 0.1, i: 30, node: 40, argument: 50, anomaly: 0, unit: deg);
let orb = orbit(el, earth, epoch);
print orb.position().length(), orb.position(epoch.add_hours(6)).length();

system

function creates an immutable system of integrated states, body-backed orbits, and ephemeris bodies

Function: system - creates an immutable system of integrated states, body-backed orbits, and ephemeris bodies
Syntax:
  system(epoch: Time, bodies: Body|State|Orbit|Text|List, integrator: Text) -> System
Arguments:
  epoch: Time - system epoch
  bodies: Body|State|Orbit|Text|List - system entries: explicit states, body-backed orbits, or ephemeris bodies
  integrator: Text [optional] - optional integrator: "ias15", "dp5", or "rk4"; "dp5" is slow and mainly for debugging/reference comparisons
Resources: ephemeris, iers, small_bodies
Children: System, time, bodies, states, sources, source_counts, integrator, method, ephemeris_coverage, diagnostics, ephemeris_residuals, positions, velocities, integrated, ephemeris, cache_size, at(), cache(), clear_cache(), state(), position(), velocity(), distance(), children(), fields(), functions(), help(), available()

# Run the example and print a useful result
let t0 = time(2026, 7, 4); system(t0, earth, moon, sun)

# Run the example and print a useful result
let t0 = time(2026, 7, 4); let comet = state(body: body("comet"), time: t0, position: vector(100000000,0,0), velocity: vector(0,10,0)); system(t0, comet, sun)

# Run the example and print a useful result
let t0 = time(2026, 7, 4); let orbit0 = state(earth, t0).orbit_around(state(sun, t0)); system(t0, orbit0, moon)

# Run the example and print a useful result
let t0 = time(2026, 7, 4); system(t0, earth, moon, sun, integrator: "dp5")

observation

function creates an orbit-determination observation

Function: observation - creates an orbit-determination observation
Syntax:
  observation(observer: Observer, time: Time, direction: Direction|State, frame: Frame) -> Observation
  observation(target: Body|Star, time: Time, elevation: Number) -> Observation
Arguments:
  observer: Observer [optional] - observing site
  time: Time - observation time
  direction: Direction|State [optional] - measured line of sight, or a state whose position gives the line of sight
  frame: Frame [optional] - coordinate frame for RA/Dec shorthand or state conversion; defaults to icrf
  target: Body|Star [optional] - observed planet, Moon, Sun, or star
  elevation: Number [optional] - measured elevation above the horizon in degrees
Children: Observation, observer, time, direction, target, elevation, uncertainty, weight, label, icrf(), topographic(), with_uncertainty(), with_weight(), children(), fields(), functions(), help(), available()

# Run the example and print a useful result
print observation(observer(location(59.91,10.75)), time(2026,7,3), direction(ra:120.1, dec:22.4));

# Synthesize a planet elevation observation for navigation
let loc = location(latitude: 59.91, longitude: 10.75);
let t = time(2026, 1, 12, 22, 10, 0);
let o = observation(jupiter, t, elevation: altitude(jupiter, t, loc));
print o.target.name, o.elevation;

# Synthesize a star elevation observation for navigation
let loc = location(latitude: 59.91, longitude: 10.75);
let site = loc.observer(height: 0);
let t = time(2026, 1, 12, 22, 0, 0);
let sirius = stars().find("sirius");
let o = observation(sirius, t, elevation: sirius.altaz(t, site).altitude);
print o.target.name, o.elevation;

# Build an observation from RA/Dec in an explicit frame
let obs = location(latitude: 59.91, longitude: 10.75).observer(height: 0);
let t = time(2026, 7, 3, 0, 0, 0);
print observation(obs, t, ra: 120.1, dec: 22.4, frame: icrf);

# Build an observation from a topocentric planet state
let loc = location(latitude: 59.91, longitude: 10.75);
let obs = loc.observer(height: 0);
let t = time(2026, 7, 3, 0, 0, 0);
let seen = state(mars, t, loc, topocentric, icrf, no_correction);
print observation(obs, t, seen);

orbit_determination

function determines an orbit from three or more observations

Function: orbit_determination - determines an orbit from three or more observations
Syntax:
  orbit_determination(observations: List<Observation>) -> OrbitSolution
Arguments:
  observations: List<Observation> - three or more observations
Resources: ephemeris, iers
Children: OrbitSolution, orbit, elements, observations, residuals, rms, max_residual, method, status, iterations, predict(), residuals(), children(), fields(), functions(), help(), available()

# Determine an elliptic orbit from five observations
let site = location(latitude: 59.91, longitude: 10.75).observer(height: 0);
let o1 = observation(site, time(2028, 7, 3, 0, 0, 0), ra: 131.0857742519269, dec: 18.803678151005595);
let o2 = observation(site, time(2028, 7, 23, 0, 0, 0), ra: 135.0300892722528, dec: 18.040162341691612);
let o3 = observation(site, time(2028, 8, 12, 0, 0, 0), ra: 139.04202357010908, dec: 17.175191580463146);
let o4 = observation(site, time(2028, 9, 1, 0, 0, 0), ra: 142.9726130958044, dec: 16.26645304942825);
let o5 = observation(site, time(2028, 9, 21, 0, 0, 0), ra: 146.67383907727944, dec: 15.384398529605518);
let od = orbit_determination([o1, o2, o3, o4, o5], central: sun);
print od.status, od.rms, od.orbit.conic;
print od.elements;

# Determine a parabolic orbit from five observations
let site = location(latitude: 59.91, longitude: 10.75).observer(height: 0);
let o1 = observation(site, time(2028, 7, 3, 0, 0, 0), ra: 131.17579335594158, dec: 18.78269573364523);
let o2 = observation(site, time(2028, 7, 23, 0, 0, 0), ra: 135.28728784032972, dec: 18.019922410032073);
let o3 = observation(site, time(2028, 8, 12, 0, 0, 0), ra: 139.4336093408432, dec: 17.155215233522643);
let o4 = observation(site, time(2028, 9, 1, 0, 0, 0), ra: 143.47212659888854, dec: 16.247957989051894);
let o5 = observation(site, time(2028, 9, 21, 0, 0, 0), ra: 147.26211907839155, dec: 15.369205484638817);
let od = orbit_determination([o1, o2, o3, o4, o5], central: sun);
print od.status, od.rms, od.orbit.conic;
print od.elements;

# Determine a hyperbolic orbit from five observations
let site = location(latitude: 59.91, longitude: 10.75).observer(height: 0);
let o1 = observation(site, time(2028, 7, 3, 0, 0, 0), ra: 131.18472418056754, dec: 18.780611424357605);
let o2 = observation(site, time(2028, 7, 23, 0, 0, 0), ra: 135.32226127731965, dec: 18.017374322931712);
let o3 = observation(site, time(2028, 8, 12, 0, 0, 0), ra: 139.49019892428979, dec: 17.151931814342543);
let o4 = observation(site, time(2028, 9, 1, 0, 0, 0), ra: 143.54674567209997, dec: 16.24393067242571);
let o5 = observation(site, time(2028, 9, 21, 0, 0, 0), ra: 147.35214877838115, dec: 15.364550692814579);
let od = orbit_determination([o1, o2, o3, o4, o5], central: sun);
print od.status, od.rms, od.orbit.conic;
print od.elements;

# Generate an observation from a planet state
let loc = location(latitude: 59.91, longitude: 10.75);
let obs = loc.observer(height: 0);
let t = time(2026, 7, 3, 0, 0, 0);
let seen = state(mars, t, loc, topocentric, icrf, no_correction);
print observation(obs, t, seen);

# Generate an observation from orbital elements
let obs = location(latitude: 59.91, longitude: 10.75).observer(height: 0);
let epoch = time(2028, 7, 3, 0, 0, 0);
let target = orbit(
    elements(q: 900000000, e: 1.1, i: 18.0, node: 35.0, argument: 75.0, anomaly: 25.0),
    sun,
    epoch,
    icrf
);
print observation(obs, epoch, target.predict(epoch, obs));

heading

function creates a compass heading

Function: heading - creates a compass heading
Syntax:
  heading(azimuth: Number|Text, unit: Unit) -> Heading
Arguments:
  azimuth: Number|Text - degrees clockwise from north, or a compass name such as "nw"
  unit: Unit [optional] - optional angle unit for numeric headings; degrees are default
Children: Heading, azimuth_degrees, long_name, short_name, azimuth(), long(), short(), vector(), children(), fields(), functions(), help(), available()

# Prepare a compass heading for horizon calculations
print heading(135.0);

direction

function creates a frame-tagged unit-sphere direction

Function: direction - creates a frame-tagged unit-sphere direction
Syntax:
  direction(frame: Frame, ra: Number, dec: Number, azimuth: Number, altitude: Number, zenith: Number, unit: Unit) -> Direction
Arguments:
  frame: Frame [optional] - coordinate frame, defaulting to icrf
  ra: Number [optional] - right ascension / longitude in degrees by default
  dec: Number [optional] - declination / latitude in degrees by default
  azimuth: Number [optional] - topographic azimuth clockwise from north; degrees are default
  altitude: Number [optional] - topographic altitude/elevation above the horizon; degrees are default
  zenith: Number [optional] - topographic angle down from local zenith; degrees are default
  unit: Unit [optional] - optional angle unit such as rad
Children: Direction, frame, vector, ra, dec, to_frame(), altaz(), angular_distance(), rise(), set(), transit(), children(), fields(), functions(), help(), available()

# Compare two sky directions by angular distance
let a = direction(ra: 42.0, dec: 18.0);
let b = direction(ra: 45.0, dec: 20.0);
print a.angular_distance(b);

polygon

function creates a spherical polygon with great-circle edges

Function: polygon - creates a spherical polygon with great-circle edges
Syntax:
  polygon(frame: Frame, vertices: List, time: Time) -> Polygon
Arguments:
  frame: Frame [optional] - coordinate frame for the polygon vertices
  vertices: List - right-handed vertex list with great-circle edges
  time: Time [optional] - time used when converting vertices between frames
Children: Polygon, frame, count, vertices, invert(), to_frame(), inside(), area(), signed_area(), winding(), lonlat(), lonlat_unwrapped(), lonlat_diagnostic(), children(), fields(), functions(), help(), available()

# Test a sky direction against a polygon
print polygon(vertices: [direction(ra: 42.0, dec: 18.0), direction(ra: 90.0, dec: 20.0), direction(ra: 150.0, dec: 55.0)]);

vector

function creates a vector system value

Function: vector - creates a vector system value
Syntax:
  vector(x: Number, y: Number, z: Number) -> Vector
  vector(from: Origin, to: Origin, time: Time) -> Vector
Arguments:
  x: Number [optional] - cartesian x component in km
  y: Number [optional] - cartesian y component in km, defaulting to zero
  z: Number [optional] - cartesian z component in km, defaulting to zero
  from: Origin [optional] - source origin such as barycentric or geocentric
  to: Origin [optional] - target origin such as barycentric or geocentric
  time: Time [optional] - time for the origin transform
Children: Vector, kind, orientation, transposed, x(), y(), z(), range(), theta(), phi(), length(), lenxy(), lenxz(), lenyz(), dot(), cross(), angle(), distance(), online(), turn(), normalise(), transpose(), translate_origin(), children(), fields(), functions(), help(), available()

# Compute distance between two position vectors
let a = vector(7000, 0, 0);
let b = vector(0, 7000, 0);
print a.length(), b.length(), a.distance(b);

spherical

function creates a vector from spherical coordinates

Function: spherical - creates a vector from spherical coordinates
Syntax:
  spherical(radius: Number, theta: Number, phi: Number, unit: Unit) -> Vector
Arguments:
  radius: Number - spherical range/radius in km
  theta: Number - azimuth angle in radians by default
  phi: Number - elevation angle in radians by default
  unit: Unit [optional] - optional angle unit for theta and phi, such as deg
Children: help(), available()

# Convert spherical coordinates into a vector-like value
print vector(1.0, 2.0, 3.0);

matrix

function creates a matrix system value

Function: matrix - creates a matrix system value
Syntax:
  matrix(x0: Number, y0: Number, z0: Number) -> Matrix
  matrix(from: Axis, to: Axis, time: Time) -> Matrix
  matrix(m00: Number, m10: Number, m20: Number, m01: Number, m11: Number, m21: Number, m02: Number, m12: Number, m22: Number) -> Matrix
Arguments:
  x0: Number [optional] - first diagonal value, or first column x for a 9-value matrix
  y0: Number [optional] - second diagonal value, or first column y for a 9-value matrix
  z0: Number [optional] - third diagonal value, or first column z for a 9-value matrix
  from: Axis [optional] - source axis such as icrf, tod, ef, or topographic
  to: Axis [optional] - target axis such as icrf, tod, ef, or topographic
  time: Time [optional] - time for the axis transform
  m00: Number [optional] - row 0 column 0
  m10: Number [optional] - row 1 column 0
  m20: Number [optional] - row 2 column 0
  m01: Number [optional] - row 0 column 1
  m11: Number [optional] - row 1 column 1
  m21: Number [optional] - row 2 column 1
  m02: Number [optional] - row 0 column 2
  m12: Number [optional] - row 1 column 2
  m22: Number [optional] - row 2 column 2
Resources: iers
Children: Matrix, m00, m10, m20, m01, m11, m21, m02, m12, m22, kind, transpose(), inverse(), determinant(), normalise(), multiply_transpose(), rotate_axis(), children(), fields(), functions(), help(), available()

# Rotate a vector from ICRF into Earth-fixed coordinates
let t = time(2026,1,1,0,0,0);
let v = matrix(icrf, earthfixed, t) * vector(1, 0, 0);
print v.x(), v.y(), v.z();

unit

function creates a unit system value

Function: unit - creates a unit system value
Syntax:
  unit(name: Text) -> Unit
Arguments:
  name: Text - unit name such as km, au, deg, or rad
Children: Unit, name, dimension, factor_to_base, children(), fields(), functions(), help(), available()

# Prepare a unit for quantity conversion
print deg;

state

function creates an orbital state from ephemeris data or explicit initial conditions

Function: state - creates an orbital state from ephemeris data or explicit initial conditions
Syntax:
  state(body: Body, time: Time, location: Location, origin: Origin, axis: Axis, correction: Correction, orbit: Orbit, position: Vector, velocity: Vector, mass: Number, xmu: Number) -> State
  state(template: State, body: Body) -> State
Arguments:
  body: Body [optional] - solar-system body
  time: Time [optional] - time for the state; defaults to current UTC time
  location: Location [optional] - optional observer location
  origin: Origin [optional] - default origin such as barycentric or geocentric
  axis: Axis [optional] - default axis such as icrf, tod, ef, or topographic
  correction: Correction [optional] - default correction model
  orbit: Orbit [optional] - explicit two-body orbit to resolve into a barycentric ICRF state
  position: Vector [optional] - explicit barycentric ICRF position in kilometers
  velocity: Vector [optional] - explicit barycentric ICRF velocity in kilometers per day
  mass: Number [optional] - override body mass in kg for integrated systems
  xmu: Number [optional] - override gravitational parameter in km^3/s^2 for integrated systems
  template: State [optional] - existing state whose time/location/defaults are reused
Resources: ephemeris, iers
Children: State, body, time, location, origin, axis, correction, ephemeris, pos_bc_icrf, vel_bc_icrf, pos_gc_icrf, vel_gc_icrf, pos_gc_tod, vel_gc_tod, pos_gc_ef, vel_gc_ef, position(), velocity(), ra(), dec(), geocentric(), topographic(), observer(), orbit_around(), shadow(), limb(), profile(), horizon(), children(), fields(), functions(), help(), available()

# Convert ephemeris position and velocity into orbital elements
let t = time(2026,1,1,0,0,0);
let earth_state = state(earth, t, barycentric, icrf, no_correction);
let sun_state = state(sun, t, barycentric, icrf, no_correction);
let orbit = earth_state.orbit_around(sun_state);
let el = orbit.elements();
print earth_state.position().length(), earth_state.velocity().length(), el.e;

places

function opens the GeoNames places resource

Aliases: placedb

Function: places - opens the GeoNames places resource
Syntax:
  places(name: Text|Number, id: Number, country: Text|Country|Place, admin1: Text|Admin1|Admin2|Place, admin2: Text|Admin2|Place, limit: Number) -> Places
Aliases: placedb
Arguments:
  name: Text|Number [optional] - place name or search text used to narrow this places view
  id: Number [optional] - GeoNames id used to narrow this places view
  country: Text|Country|Place [optional] - country filter for this places view
  admin1: Text|Admin1|Admin2|Place [optional] - admin1 filter for this places view
  admin2: Text|Admin2|Place [optional] - admin2 filter for this places view
  limit: Number [optional] - maximum number of name matches retained by this places view
Resources: places
Children: Places, count, type_count, first(), all(), find(), search(), nearest(), nearby(), index(), types(), children(), fields(), functions(), help(), available()

# Open the place database for lookup
print places().find("Oslo");

# Open the place database for lookup
print places(name:"Oslo", country:"Norway").first();

# Open the place database for lookup
print places(id:3143244).first();

# Open the place database for lookup
print places().nearest(location(60, 10));

place

function creates a custom Earth place from a location and timezone

Function: place - creates a custom Earth place from a location and timezone
Syntax:
  place(id: Number) -> Place|Unavailable
  place(name: Text, location: Location, timezone: Timezone|Text) -> Place
Arguments:
  id: Number [optional] - GeoNames place id
  name: Text [optional] - custom place name
  location: Location [optional] - Earth location
  timezone: Timezone|Text [optional] - timezone; inferred from location when omitted
Children: Place, id, name, ascii_name, names, latitude, longitude, feature_class, feature_code, place_type, country_code, admin1_code, admin2_code, population, elevation_m, dem_m, timezone_id, modified, importance, distance_km, location(), timezone(), country(), admin1(), admin2(), children(), fields(), functions(), help(), available()

# Look up or define a named place
print places().find("Oslo");

# Look up or define a named place
print place("Cabin", location(60, 10));

country

function resolves a country from a name, ISO code, Place, or Country

Function: country - resolves a country from a name, ISO code, Place, or Country
Syntax:
  country(country: Text|Place|Country) -> Country
Arguments:
  country: Text|Place|Country - country name, ISO alpha-2 code, Place, or Country
Resources: places
Children: Country, code, name, place_id, children(), fields(), functions(), help(), available()

# Look up country metadata for a place
print country("Norway");

# Look up country metadata for a place
print places().find("Jar", country("NO"));

admin1

function resolves a first-level administrative region

Function: admin1 - resolves a first-level administrative region
Syntax:
  admin1(admin1: Text|Number|Admin1, country: Text|Country|Place) -> Admin1
Arguments:
  admin1: Text|Number|Admin1 - admin1 name or GeoNames admin1 code
  country: Text|Country|Place - country containing the admin1 region
Resources: places
Children: Admin1, country_code, code, name, place_id, children(), fields(), functions(), help(), available()

# Look up first-level administrative metadata
print admin1("Akershus", country("NO"));

# Look up first-level administrative metadata
print places().find("Jar", admin1("01", norway));

admin2

function resolves a second-level administrative region

Function: admin2 - resolves a second-level administrative region
Syntax:
  admin2(admin2: Text|Number|Admin2, admin1: Admin1|Place) -> Admin2
Arguments:
  admin2: Text|Number|Admin2 - admin2 name or GeoNames admin2 code
  admin1: Admin1|Place - admin1 region containing the admin2 region
Resources: places
Children: Admin2, country_code, admin1_code, code, name, place_id, children(), fields(), functions(), help(), available()

# Look up second-level administrative metadata
print admin2("3201", admin1("01", norway));

# Look up second-level administrative metadata
print places().find("Jar", admin2("3201", admin1("01", norway)));

timezones

function opens the IANA timezone boundary resource

Aliases: timezonedb, tzdb

Function: timezones - opens the IANA timezone boundary resource
Syntax:
  timezones() -> Timezones
Aliases: timezonedb, tzdb
Resources: timezones
Children: Timezones, count, release, find(), at(), ids(), validate_places(), children(), fields(), functions(), help(), available()

# Open the timezone database for lookup
print timezones().find("Europe/Oslo");

# Open the timezone database for lookup
print timezones().at(location(60, 10));

timezone

function creates an IANA timezone from an id or Earth location

Aliases: tz

Function: timezone - creates an IANA timezone from an id or Earth location
Syntax:
  timezone(timezone: Text|Location|Timezone) -> Timezone
Aliases: tz
Arguments:
  timezone: Text|Location|Timezone - IANA timezone id, Location, or existing Timezone
Resources: timezones
Children: Timezone, id, aliases, countries, comment, latitude, longitude, release, local(), offset(), location(), children(), fields(), functions(), help(), available()

# Resolve an IANA timezone id
let zone = timezone("Europe/Oslo");
print zone.id, zone.location();

# Find the timezone for a latitude-longitude location
let loc = location(60, 10);
print timezone(loc).id;

# Format a UTC time in a resolved timezone
let zone = timezone("Europe/Oslo");
print time(2026,6,7,12,0,0).local(zone).iso;

stars

function opens the Yale Bright Star Catalogue resource

Aliases: stardb

Function: stars - opens the Yale Bright Star Catalogue resource
Syntax:
  stars() -> Stars
Aliases: stardb
Resources: iers, ephemeris, stars, constellations
Children: Stars, count, find(), glob(), nearest(), all(), visible(), children(), fields(), functions(), help(), available()

# Look up Sirius in the star catalog and print its constellation
let sirius = stars().find("Sirius");
print sirius.name, sirius.constellation();

# Round-trip through the primary star id
let sirius = stars().find("sirius");
print sirius.id, stars().find(sirius.id).name;

# Explore uncertain spellings with a glob pattern
let matches = stars().glob("sir*");
print matches.length(), matches[0].name;

constellations

function opens the IAU constellation boundary resource

Function: constellations - opens the IAU constellation boundary resource
Syntax:
  constellations() -> ConstellationDb
Resources: constellations
Children: ConstellationDb, count, find(), inside(), children(), fields(), functions(), help(), available()

# Find the constellation containing a sky direction
let d = direction(ra: 88.8, dec: 7.4);
print constellations().inside(d);

graphics

function creates a deferred SVG graphics object

Aliases: plot

Function: graphics - creates a deferred SVG graphics object
Syntax:
  graphics(time: Time, location: Location|Observer, center: Direction, theme: Text, center_az: Number, center_alt: Number, fov: Number) -> Graphics
Aliases: plot
Arguments:
  time: Time [optional] - default sky-view time
  location: Location|Observer [optional] - default sky-view observer
  center: Direction [optional] - default sky-view center direction
  theme: Text [optional] - graphics theme, either dark or light
  center_az: Number [optional] - default sky-view center azimuth in degrees
  center_alt: Number [optional] - default sky-view center altitude in degrees
  fov: Number [optional] - default sky-view field of view in degrees
Children: Graphics, line(), points(), polygon(), text(), function(), title(), xlabel(), ylabel(), xrange(), yrange(), xticks(), yticks(), dark(), light(), sky_view(), sky_grid(), sky_stars(), sky_constellations(), sky_planets(), sky_horizon(), svg(), write_svg(), children(), fields(), functions(), help(), available()

# Plot a local Sun-altitude curve and report the output file
let loc = location(60,10);
let obs = loc.observer(0.002);
let t0 = time(2026,6,21,0,0,0);
let g = graphics().function((h): altitude(sun, t0.add_hours(h), obs), range(0,24,1)).title("Sun altitude");
g.write_svg("sun-altitude.svg");
print "wrote sun-altitude.svg";

target

function creates a value/direction target for search(...), or passes through minimum/maximum

Function: target - creates a value/direction target for search(...), or passes through minimum/maximum
Syntax:
  target(value: Number|SearchGoal, direction: SearchDirection) -> Target|SearchGoal
Arguments:
  value: Number|SearchGoal - numeric crossing value, minimum, or maximum
  direction: SearchDirection [optional] - any, increasing, or decreasing
Children: Target, value, direction, children(), fields(), functions(), help(), available()

# Build a target crossing goal for morning Sun altitude
let loc = location(58.9666667, 5.7333333);
let day = time(2026,6,21,0,0,0);
let f = (h): altitude(sun, day.add_hours(h), loc);
print search(f, range(0, 24, 0.25), target(10, increasing)).next();

range

function creates a numeric or time range for search(...)

Function: range - creates a numeric or time range for search(...)
Syntax:
  range(start: Number|Time, stop: Number, step: Number) -> Range
  range(start: Number|Time, stop: Number|Time, step: Number) -> Range
Arguments:
  start: Number|Time - start of the range
  stop: Number - infinity or -infinity
  step: Number [optional] - signed sampling step; time ranges use UTC days
Children: Range, kind, bounded, start, stop, step, children(), fields(), functions(), help(), available()

# Build a one-day hour range for a local altitude scan
let hours = range(0, 24, 2);
let t0 = time(2026,6,21,0,0,0);
for h=hours.start,hours.stop,hours.step {
  print t0.add_hours(h).utc();
}

search

function searches for function crossings or local minimum/maximum points

Function: search - searches for function crossings or local minimum/maximum points
Syntax:
  search(function: Callable, range: Range, goal: Target|SearchGoal) -> Search
Arguments:
  function: Callable - function of one Number or Time argument returning a Number
  range: Range - range(start, stop), range(start, stop, step), or range(start, infinity, step)
  goal: Target|SearchGoal [optional] - target value and direction, minimum, or maximum; defaults to target(0, any)
Resources: iers
Children: Search, range, target, direction, next(), all(), children(), fields(), functions(), help(), available()

# Search for the morning hour when the Sun reaches ten degrees
let loc = location(58.9666667, 5.7333333);
let day = time(2026,6,21,0,0,0);
let f = (h): altitude(sun, day.add_hours(h), loc);
print search(f, range(0, 24, 0.25), target(10, increasing)).next();

forecast

function opens a published GFS forecast cycle from the retained stack

Function: forecast - opens a published GFS forecast cycle from the retained stack
Syntax:
  forecast(index: Number, format: Text) -> Forecast
Arguments:
  index: Number [optional] - forecast cycle stack index; 0 is the latest cycle
  format: Text [optional] - optional storage format: "netcdf" (default when available), "grib", or "auto"
Resources: gfs_forecast
Children: Forecast, source, format, path, reason, index, hour, run, run_name, reference_time, valid_time, message_count, available(), count(), cycle(), cycle_step(), max_time(), spans(), times(), sample(), toc(), messages(), children(), fields(), functions(), help(), available()

# Open the latest forecast product and print availability metadata
let fc = forecast();
print fc.available(), fc.count();

netcdf

function opens a NetCDF dataset and returns its dimensions and variables

Function: netcdf - opens a NetCDF dataset and returns its dimensions and variables
Syntax:
  netcdf(source: FieldSource) -> NetCDF
Arguments:
  source: FieldSource - approved field source constant such as earth_topography or moon_topography
Children: NetCDF, source, path, dimensions, variables, variable(), children(), fields(), functions(), help(), available()

# Open a NetCDF-backed topography source and inspect its path
let nc = netcdf(earth_topography);
print nc.path, nc.variables.length();

field

function creates a global scalar field from a NetCDF variable

Function: field - creates a global scalar field from a NetCDF variable
Syntax:
  field(source: FieldSource|NetCDF, variable: Text, body: Text|Body, lat: Text, lon: Text, indices: Object) -> Field
Arguments:
  source: FieldSource|NetCDF - approved field source constant or opened NetCDF dataset
  variable: Text [optional] - variable containing the scalar field; defaults from the source constant
  body: Text|Body [optional] - body this field is attached to
  lat: Text [optional] - latitude coordinate variable name
  lon: Text [optional] - longitude coordinate variable name
  indices: Object [optional] - fixed indices for non-lat/lon dimensions
Children: Field, source, path, variable, body, lat, lon, dimensions, indices, sample(), children(), fields(), functions(), help(), available()

# Sample a topography field at a location
let loc = location(60.0, 10.0);
let terrain = topography(earth);
print sample(terrain, loc);

topography

function creates an approved global topography field for a body

Function: topography - creates an approved global topography field for a body
Syntax:
  topography(body: Body|Text|FieldSource) -> Field
Arguments:
  body: Body|Text|FieldSource - body with an approved topography dataset, currently earth or moon
Children: help(), available()

# Sample Earth terrain height at a location
let loc = location(60.0, 10.0);
let topo = topography(earth);
print sample(topo, loc);

magnetic

function creates a magnetic field model handle

Function: magnetic - creates a magnetic field model handle
Syntax:
  magnetic(body: Body, time: Time, observer: Observer) -> Magnetic
Arguments:
  body: Body [optional] - body to model; Earth uses WMMHR, other bodies use crude dipoles
  time: Time [optional] - default sample time
  observer: Observer [optional] - default observer location
Children: Magnetic, body, time, observer, field(), children(), fields(), functions(), help(), available()

# Compute the magnetic field at an observer
print magnetic(earth).field(time(2025,1,1,0,0,0), location(latitude: 80, longitude: 0).observer());

# Compute the magnetic field at an observer
print magnetic(jupiter, time(2026,1,1,0,0,0), location(jupiter, latitude: 0, longitude: 0).observer()).field();

pages

function creates a data-page builder with optional default body, time, and observer

Function: pages - creates a data-page builder with optional default body, time, and observer
Syntax:
  pages(body: Body, time: Time, observer: Location|Observer) -> Pages
Arguments:
  body: Body [optional] - default body for body-oriented pages
  time: Time [optional] - default time for page methods
  observer: Location|Observer [optional] - default observer or surface location for local pages
Children: Pages, body, time, observer, sky(), chart(), summary(), sun(), moon(), almanac(), short(), small(), state(), states(), table(), children(), fields(), functions(), help(), available()

# Build a local Moon summary page
let page = pages(location(60.0, 10.0), moon).summary(time(2026,1,1,0,0,0));
print page.phase, page.illumination;

# Build a chart page for a fixed time
let chart = pages(time(2026,1,1,0,0,0)).chart();
print chart.bodies.sun.geocentric.longitude, chart.bodies.moon.chart.sign;

help

function returns the Astrologos calculator manual or one function's syntax

Function: help - returns the Astrologos calculator manual or one function's syntax
Syntax:
  help() -> Help
  help(name: Text|Any) -> Help|HelpResult|Nil
  help(value: Any, name: Text) -> Help|HelpResult|Nil
Arguments:
  name: Text|Any [optional] - registered help topic name or value to inspect
  value: Any [optional] - value whose documentation should be searched
Children: help(), available(), doc(), compact(), search(), examples()

# Look up documentation from inside Astrologos
print help();

# Look up documentation from inside Astrologos
print help.search("azimuth");

about

function returns the project disclaimer, licence, and about text

Aliases: disclaimer, licence, license

Function: about - returns the project disclaimer, licence, and about text
Syntax:
  about() -> Text
Aliases: disclaimer, licence, license
Children: help(), available()

# Review runtime version and caveat information
print about;

# Review runtime version and caveat information
print about();

resources

function lists known runtime resources and whether they are loaded

Function: resources - lists known runtime resources and whether they are loaded
Syntax:
  resources() -> List
Children: help(), available()

# Lists known runtime resources and whether they are loaded
print resources();

resource_sources

function lists upstream data sources for known runtime resources

Function: resource_sources - lists upstream data sources for known runtime resources
Syntax:
  resource_sources() -> List
Children: help(), available()

# List upstream data sources used by the runtime
print resource_sources();

exit

function stops execution after the current statement, optionally returning a message

Function: exit - stops execution after the current statement, optionally returning a message
Syntax:
  exit() -> Nil
  exit(messages: Any...) -> Text
Arguments:
  messages: Any... [optional] - optional values printed on the warning channel before exit
Children: help(), available()

# Stops execution after the current statement, optionally returning a message
print exit();

run

function deprecated alias for exit()

Function: run - deprecated alias for exit()
Syntax:
  run() -> Nil
Children: help(), available()

# Deprecated alias for exit()
print run();

functions

function lists function metadata, optionally filtered by function name

Function: functions - lists function metadata, optionally filtered by function name
Syntax:
  functions() -> List
  functions(name: Text) -> List
Arguments:
  name: Text [optional] - exact function or method name to list
Children: help(), available()

# Find callable helpers related to lunar phase
let hits = functions("moon_phase");
print hits.length(), hits[0].name, hits[0].path;

fields

function lists type field metadata, optionally filtered by field name

Function: fields - lists type field metadata, optionally filtered by field name
Syntax:
  fields() -> List
  fields(name: Text) -> List
Arguments:
  name: Text [optional] - exact field name to list
Children: help(), available()

# Lists type field metadata, optionally filtered by field name
print fields();

types

function lists registered astro/system types, constructors, fields, and members

Function: types - lists registered astro/system types, constructors, fields, and members
Syntax:
  types() -> List
Children: help(), available()

# Inspect a small slice of registered runtime types
let all = types();
print all.length(), all[0].name;

elapsed

function returns elapsed execution time in seconds

Function: elapsed - returns elapsed execution time in seconds
Syntax:
  elapsed() -> Number
Children: help(), available()

# Returns elapsed execution time in seconds
print elapsed();

sleep

function pauses execution for a number of milliseconds

Function: sleep - pauses execution for a number of milliseconds
Syntax:
  sleep(milliseconds: Number) -> Nil
Arguments:
  milliseconds: Number - Duration to pause execution, in milliseconds.
Children: help(), available()

# Pauses execution for a number of milliseconds
print sleep(42.0);

array

function creates an array from positional values

Function: array - creates an array from positional values
Syntax:
  array() -> Array
Children: help(), available()

# Creates an array from positional values
print array();

hash

function creates an ordered hash/object from named values

Function: hash - creates an ordered hash/object from named values
Syntax:
  hash() -> Object
Children: help(), available()

# Creates an ordered hash/object from named values
print hash();

args

function captures positional and named values as an argument-list value

Function: args - captures positional and named values as an argument-list value
Syntax:
  args() -> Arguments
Children: help(), available()

# Captures positional and named values as an argument-list value
print args();

keys

function returns ordered keys for an array, object, or argument-list value

Function: keys - returns ordered keys for an array, object, or argument-list value
Syntax:
  keys(value: Any) -> List
Arguments:
  value: Any - array, object, or argument-list value to inspect
Children: help(), available()

# Audit the columns in a Moon visibility report row
let row = {body: moon.name, phase: moon_phase(time(2026,1,1,0,0,0)), illumination: moon_illumination(time(2026,1,1,0,0,0))};
print keys(row);

values

function returns ordered values from an array, object, or argument-list value

Function: values - returns ordered values from an array, object, or argument-list value
Syntax:
  values(value: Any) -> List
Arguments:
  value: Any - array, object, or argument-list value to inspect
Children: help(), available()

# Export the values from a Moon visibility report row
let row = {body: moon.name, phase: moon_phase(time(2026,1,1,0,0,0)), illumination: moon_illumination(time(2026,1,1,0,0,0))};
print values(row);

items

function returns ordered key/value objects from an array, object, or argument-list value

Function: items - returns ordered key/value objects from an array, object, or argument-list value
Syntax:
  items(value: Any) -> List
Arguments:
  value: Any - array, object, or argument-list value to inspect
Children: help(), available()

# Convert a Moon visibility row to key-value audit items
let row = {body: moon.name, phase: moon_phase(time(2026,1,1,0,0,0)), illumination: moon_illumination(time(2026,1,1,0,0,0))};
print items(row);

pretty

function formats a value as indented JSON text

Function: pretty - formats a value as indented JSON text
Syntax:
  pretty(value: Any) -> Text
Arguments:
  value: Any - array, object, or argument-list value to inspect
Children: help(), available()

# Pretty-print a structured value
print pretty({name:"sun", positions:[1, 2, 3]});

format

function formats values as text with small printf-style placeholders

Function: format - formats values as text with small printf-style placeholders
Syntax:
  format(pattern: Text, value: Any) -> Text
Arguments:
  pattern: Text - format pattern containing %f, %.Nf, %s, {}, or %% placeholders
  value: Any - value consumed by the next placeholder
Children: help(), available()

# Format chart numbers to fixed decimal places
let t = time(2026,1,1,0,0,0);
let moon_chart = pages(t).chart().bodies.moon;
print moon_chart.chart.sign, format("%.6f", moon_chart.chart.degree_in_sign), format("%.6f", moon_chart.geocentric.longitude);

# Combine text, numeric precision, literal percent, and value rendering
print format("%s %.2f %% {}", "moon", 12.345, {sign:"virgo"});

typeof

function returns the type or function name of a value

Function: typeof - returns the type or function name of a value
Syntax:
  typeof(value: Any) -> Text
Arguments:
  value: Any - array, object, or argument-list value to inspect
Children: help(), available()

# Validate the shape of a generated result
print typeof(location(latitude: 60.0, longitude: 270.0));

altitude

function returns corrected topographic altitude/elevation in degrees

Function: altitude - returns corrected topographic altitude/elevation in degrees
Syntax:
  altitude(body: Body, time: Time, observer: Location|Observer, correction: Correction) -> Number
Arguments:
  body: Body - solar-system body
  time: Time - observation time
  observer: Location|Observer - observer location or elevated/body-fixed observer
  correction: Correction [optional] - optional correction model; defaults to all_corrections
Resources: ephemeris
Children: help(), available()

# Returns corrected topographic altitude/elevation in degrees
print altitude(sun, time(), location(latitude: 60.0, longitude: 270.0));

azimuth

function returns corrected topographic azimuth in degrees

Function: azimuth - returns corrected topographic azimuth in degrees
Syntax:
  azimuth(body: Body, time: Time, observer: Location|Observer, correction: Correction) -> Number
Arguments:
  body: Body - solar-system body
  time: Time - observation time
  observer: Location|Observer - observer location or elevated/body-fixed observer
  correction: Correction [optional] - optional correction model; defaults to all_corrections
Resources: ephemeris
Children: help(), available()

# Returns corrected topographic azimuth in degrees
print azimuth(sun, time(), location(latitude: 60.0, longitude: 270.0));

distance

function returns corrected geocentric distance in kilometers

Function: distance - returns corrected geocentric distance in kilometers
Syntax:
  distance(body: Body, time: Time, correction: Correction) -> Number
Arguments:
  body: Body - solar-system body
  time: Time - observation time
  correction: Correction [optional] - optional correction model; defaults to all_corrections
Resources: ephemeris
Children: help(), available()

# Returns corrected geocentric distance in kilometers
print distance(sun, time());

right_ascension

function returns corrected geocentric true-of-date right ascension in degrees

Aliases: ra

Function: right_ascension - returns corrected geocentric true-of-date right ascension in degrees
Syntax:
  right_ascension(body: Body, time: Time, correction: Correction) -> Number
Aliases: ra
Arguments:
  body: Body - solar-system body
  time: Time - observation time
  correction: Correction [optional] - optional correction model; defaults to all_corrections
Resources: ephemeris
Children: help(), available()

# Returns corrected geocentric true-of-date right ascension in degrees
print right_ascension(sun, time());

declination

function returns corrected geocentric true-of-date declination in degrees

Aliases: dec

Function: declination - returns corrected geocentric true-of-date declination in degrees
Syntax:
  declination(body: Body, time: Time, correction: Correction) -> Number
Aliases: dec
Arguments:
  body: Body - solar-system body
  time: Time - observation time
  correction: Correction [optional] - optional correction model; defaults to all_corrections
Resources: ephemeris
Children: help(), available()

# Returns corrected geocentric true-of-date declination in degrees
print declination(sun, time());

ecliptic_longitude

function returns corrected apparent geocentric ecliptic longitude in degrees

Function: ecliptic_longitude - returns corrected apparent geocentric ecliptic longitude in degrees
Syntax:
  ecliptic_longitude(time: Time, correction: Correction) -> Number
  ecliptic_longitude(body: Body, time: Time, correction: Correction) -> Number
Arguments:
  time: Time - observation time; returns the Sun's apparent geocentric ecliptic longitude
  correction: Correction [optional] - optional correction model; defaults to all_corrections
  body: Body [optional] - solar-system body
Resources: ephemeris
Children: help(), available()

# Returns corrected apparent geocentric ecliptic longitude in degrees
print ecliptic_longitude(time());

heliocentric_ecliptic_longitude

function returns corrected heliocentric ecliptic longitude in degrees

Function: heliocentric_ecliptic_longitude - returns corrected heliocentric ecliptic longitude in degrees
Syntax:
  heliocentric_ecliptic_longitude(body: Body, time: Time, correction: Correction) -> Number
Arguments:
  body: Body - solar-system body
  time: Time - observation time
  correction: Correction [optional] - optional correction model; defaults to all_corrections
Resources: ephemeris
Children: help(), available()

# Returns corrected heliocentric ecliptic longitude in degrees
print heliocentric_ecliptic_longitude(sun, time());

elongation

function returns signed geocentric elongation from the Sun in degrees

Function: elongation - returns signed geocentric elongation from the Sun in degrees
Syntax:
  elongation(body: Body, time: Time) -> Number
Arguments:
  body: Body - solar-system body
  time: Time - observation time
Resources: ephemeris
Children: help(), available()

# Returns signed geocentric elongation from the Sun in degrees
print elongation(sun, time());

moon_phase

function returns Moon phase angle percentage in the range 0..100

Function: moon_phase - returns Moon phase angle percentage in the range 0..100
Syntax:
  moon_phase(time: Time) -> Number
Arguments:
  time: Time - observation time
Resources: ephemeris
Children: help(), available()

# Returns Moon phase angle percentage in the range 0..100
print moon_phase(time());

moon_illumination

function returns illuminated percentage of the Moon as seen from Earth

Function: moon_illumination - returns illuminated percentage of the Moon as seen from Earth
Syntax:
  moon_illumination(time: Time) -> Number
Arguments:
  time: Time - observation time
Resources: ephemeris
Children: help(), available()

# Returns illuminated percentage of the Moon as seen from Earth
print moon_illumination(time());

magnitude

function returns approximate apparent visual magnitude

Function: magnitude - returns approximate apparent visual magnitude
Syntax:
  magnitude(body: Body, time: Time) -> Number
Arguments:
  body: Body - solar-system body
  time: Time - observation time
Resources: ephemeris
Children: help(), available()

# Returns approximate apparent visual magnitude
print magnitude(sun, time());

apparent_solar_time

function returns apparent solar time in local hours

Function: apparent_solar_time - returns apparent solar time in local hours
Syntax:
  apparent_solar_time(time: Time, location: Location) -> Number
Arguments:
  time: Time - observation time
  location: Location - observer location
Resources: ephemeris
Children: help(), available()

# Returns apparent solar time in local hours
print apparent_solar_time(time(), location(latitude: 60.0, longitude: 270.0));

lunar_time

function returns local lunar hour angle as hours

Function: lunar_time - returns local lunar hour angle as hours
Syntax:
  lunar_time(time: Time, location: Location) -> Number
Arguments:
  time: Time - observation time
  location: Location - observer location
Resources: ephemeris
Children: help(), available()

# Returns local lunar hour angle as hours
print lunar_time(time(), location(latitude: 60.0, longitude: 270.0));

rotational_axis

function returns a body's rotational north-pole RA, declination, and ICRF unit vector

Function: rotational_axis - returns a body's rotational north-pole RA, declination, and ICRF unit vector
Syntax:
  rotational_axis(body: Body, time: Time) -> Object
Arguments:
  body: Body - solar-system body
  time: Time - observation time
Children: help(), available()

# Returns a body's rotational north-pole RA, declination, and ICRF unit vector
print rotational_axis(sun, time());

rotational_axis_ra

function returns a body's rotational north-pole right ascension in degrees

Function: rotational_axis_ra - returns a body's rotational north-pole right ascension in degrees
Syntax:
  rotational_axis_ra(body: Body, time: Time) -> Number
Arguments:
  body: Body - solar-system body
  time: Time - observation time
Children: help(), available()

# Returns a body's rotational north-pole right ascension in degrees
print rotational_axis_ra(sun, time());

rotational_axis_dec

function returns a body's rotational north-pole declination in degrees

Function: rotational_axis_dec - returns a body's rotational north-pole declination in degrees
Syntax:
  rotational_axis_dec(body: Body, time: Time) -> Number
Arguments:
  body: Body - solar-system body
  time: Time - observation time
Children: help(), available()

# Returns a body's rotational north-pole declination in degrees
print rotational_axis_dec(sun, time());

dms

function converts decimal degrees to degree-minute-second components

Function: dms - converts decimal degrees to degree-minute-second components
Syntax:
  dms(value: Number) -> Object
  dms(value: Number, axis: Text) -> Object
Arguments:
  value: Number - signed decimal degrees
  axis: Text [optional] - latitude or longitude for hemisphere labels
Children: help(), available()

# Converts decimal degrees to degree-minute-second components
print dms(42.0);

dd

function converts degree-minute-second components to signed decimal degrees

Function: dd - converts degree-minute-second components to signed decimal degrees
Syntax:
  dd(degrees: Number, minutes: Number, seconds: Number, hemisphere: Text) -> Number
Arguments:
  degrees: Number - degrees component
  minutes: Number [optional] - minutes component
  seconds: Number [optional] - seconds component
  hemisphere: Text [optional] - N, S, E, or W
Children: help(), available()

# Converts degree-minute-second components to signed decimal degrees
print dd(42.0);

solar_eclipse_magnitude

function returns local solar eclipse magnitude at a time and location

Function: solar_eclipse_magnitude - returns local solar eclipse magnitude at a time and location
Syntax:
  solar_eclipse_magnitude(time: Time, location: Location) -> Number
Arguments:
  time: Time - observation time
  location: Location - observer location
Resources: ephemeris
Children: help(), available()

# Returns local solar eclipse magnitude at a time and location
print solar_eclipse_magnitude(time(), location(latitude: 60.0, longitude: 270.0));

solar_eclipse_obscuration

function returns percent of the solar disc occulted locally

Function: solar_eclipse_obscuration - returns percent of the solar disc occulted locally
Syntax:
  solar_eclipse_obscuration(time: Time, location: Location) -> Number
Arguments:
  time: Time - observation time
  location: Location - observer location
Resources: ephemeris
Children: help(), available()

# Returns percent of the solar disc occulted locally
print solar_eclipse_obscuration(time(), location(latitude: 60.0, longitude: 270.0));

solar_eclipse_clearance

function returns signed local Sun-Moon limb clearance in degrees

Function: solar_eclipse_clearance - returns signed local Sun-Moon limb clearance in degrees
Syntax:
  solar_eclipse_clearance(time: Time, location: Location) -> Number
Arguments:
  time: Time - observation time
  location: Location - observer location
Resources: ephemeris
Children: help(), available()

# Returns signed local Sun-Moon limb clearance in degrees
print solar_eclipse_clearance(time(), location(latitude: 60.0, longitude: 270.0));

lunar_eclipse_magnitude

function returns signed umbral lunar eclipse magnitude

Function: lunar_eclipse_magnitude - returns signed umbral lunar eclipse magnitude
Syntax:
  lunar_eclipse_magnitude(time: Time) -> Number
Arguments:
  time: Time - observation time
Resources: ephemeris
Children: help(), available()

# Returns signed umbral lunar eclipse magnitude
print lunar_eclipse_magnitude(time());

lunar_penumbra_magnitude

function returns signed penumbral lunar eclipse magnitude

Function: lunar_penumbra_magnitude - returns signed penumbral lunar eclipse magnitude
Syntax:
  lunar_penumbra_magnitude(time: Time) -> Number
Arguments:
  time: Time - observation time
Resources: ephemeris
Children: help(), available()

# Returns signed penumbral lunar eclipse magnitude
print lunar_penumbra_magnitude(time());

lunar_eclipse_clearance

function returns signed Moon-surface clearance from Earth's penumbra in kilometers

Function: lunar_eclipse_clearance - returns signed Moon-surface clearance from Earth's penumbra in kilometers
Syntax:
  lunar_eclipse_clearance(time: Time) -> Number
Arguments:
  time: Time - observation time
Resources: ephemeris
Children: help(), available()

# Returns signed Moon-surface clearance from Earth's penumbra in kilometers
print lunar_eclipse_clearance(time());

shadow_distance

function returns signed surface clearance for the active Sun-Earth-Moon shadow geometry

Function: shadow_distance - returns signed surface clearance for the active Sun-Earth-Moon shadow geometry
Syntax:
  shadow_distance(time: Time) -> Number
Arguments:
  time: Time - observation time
Resources: ephemeris
Children: help(), available()

# Returns signed surface clearance for the active Sun-Earth-Moon shadow geometry
print shadow_distance(time());

moon_shadow_earth_distance

function returns signed Earth-surface clearance from the Moon shadow cone in kilometers

Function: moon_shadow_earth_distance - returns signed Earth-surface clearance from the Moon shadow cone in kilometers
Syntax:
  moon_shadow_earth_distance(time: Time) -> Number
Arguments:
  time: Time - observation time
Resources: ephemeris
Children: help(), available()

# Returns signed Earth-surface clearance from the Moon shadow cone in kilometers
print moon_shadow_earth_distance(time());

moon_penumbra_distance

function returns signed Moon-surface clearance from Earth's penumbra in kilometers

Function: moon_penumbra_distance - returns signed Moon-surface clearance from Earth's penumbra in kilometers
Syntax:
  moon_penumbra_distance(time: Time) -> Number
Arguments:
  time: Time - observation time
Resources: ephemeris
Children: help(), available()

# Returns signed Moon-surface clearance from Earth's penumbra in kilometers
print moon_penumbra_distance(time());

moon_umbra_distance

function returns signed Moon-surface clearance from Earth's umbra in kilometers

Function: moon_umbra_distance - returns signed Moon-surface clearance from Earth's umbra in kilometers
Syntax:
  moon_umbra_distance(time: Time) -> Number
Arguments:
  time: Time - observation time
Resources: ephemeris
Children: help(), available()

# Returns signed Moon-surface clearance from Earth's umbra in kilometers
print moon_umbra_distance(time());

moon_umbra_occultation

function returns percent overlap of the Moon and Earth's umbra

Function: moon_umbra_occultation - returns percent overlap of the Moon and Earth's umbra
Syntax:
  moon_umbra_occultation(time: Time) -> Number
Arguments:
  time: Time - observation time
Resources: ephemeris
Children: help(), available()

# Returns percent overlap of the Moon and Earth's umbra
print moon_umbra_occultation(time());

location_shadow_distance

function returns signed local observer clearance from the Moon shadow cone in kilometers

Function: location_shadow_distance - returns signed local observer clearance from the Moon shadow cone in kilometers
Syntax:
  location_shadow_distance(time: Time, location: Location) -> Number
Arguments:
  time: Time - observation time
  location: Location - observer location
Resources: ephemeris
Children: help(), available()

# Compute local eclipse shadow clearance for a location and time
let loc = location(latitude: 32.7767, longitude: -96.7970);
let t = time(2024,4,8,18,40,0);
print location_shadow_distance(t, loc);

planet_shadow_earth_distance

function returns signed Earth-surface clearance from a planet shadow cone in kilometers

Function: planet_shadow_earth_distance - returns signed Earth-surface clearance from a planet shadow cone in kilometers
Syntax:
  planet_shadow_earth_distance(body: Body, time: Time) -> Number
Arguments:
  body: Body - solar-system body
  time: Time - observation time
Resources: ephemeris
Children: help(), available()

# Measure Mercury shadow-cone clearance during a transit
let t = time(2019,11,11,15,0,0);
print planet_shadow_earth_distance(mercury, t);

events

function finds astronomical events from event type constants and time ranges

Function: events - finds astronomical events from event type constants and time ranges
Syntax:
  events(event_type: EventType, bounded_range: Range) -> List
  events(event_type: EventType, open_range: Range) -> Event|Nil
  events(event_type: EventType, bounded_range: Range, observer_or_body: Location|Observer|Body) -> List
  events(event_type: EventType, open_range: Range, observer_or_body: Location|Observer|Body) -> Event|Nil
  events(event_type: EventType, bounded_range: Range, body: Body, observer: Location|Observer) -> List
  events(event_type: EventType, open_range: Range, body: Body, observer: Location|Observer) -> Event|Nil
  events(event_type: EventType, range: Range, observer: Location|Observer|Body, secondary: Location|Observer) -> List|Event|Nil
Arguments:
  event_type: EventType - event constant such as sunrise, full_moon, conjunction, or northern_solstice
  bounded_range: Range [optional] - time range with a finite stop, such as range(start, stop)
  open_range: Range [optional] - open-ended time range, such as range(start, infinity, step)
  observer_or_body: Location|Observer|Body [optional] - observer for local events, body for planetary events, or eclipsed body for eclipse
  body: Body [optional] - eclipsed body, such as sun or moon
  observer: Location|Observer [optional] - optional observer for local generic solar eclipse events
  range: Range [optional] - bounded or open-ended time range
  secondary: Location|Observer [optional] - optional observer for generic solar eclipse events
Resources: iers, ephemeris
Children: help(), available()

# Find sunrise events for a bounded day and explicit location
let loc = location(latitude: 58.9666667, longitude: 5.7333333);
let day = range(time(2024,4,17,0,0,0), time(2024,4,18,0,0,0));
print events(sunrise, day, loc).first().time.utc();

sky

function summarizes the local sky and upcoming local events

Function: sky - summarizes the local sky and upcoming local events
Syntax:
  sky(time: Time, observer: Location|Observer) -> Object
Arguments:
  time: Time - time at which to describe the local sky
  observer: Location|Observer - Earth location or observer
Resources: iers, ephemeris
Children: help(), available()

# Summarizes the local sky and upcoming local events
print sky(time(), location(latitude: 60.0, longitude: 270.0));

almanac

function builds a range almanac from astronomical event searches

Function: almanac - builds a range almanac from astronomical event searches
Syntax:
  almanac(range: Range|Time, stop: Time, observer: Location|Observer) -> Object
Arguments:
  range: Range|Time - bounded time range, or start time when using start/stop arguments
  stop: Time - stop time
  observer: Location|Observer [optional] - optional Earth location or observer for local horizon events
Resources: iers, ephemeris
Children: help(), available()

# Build an almanac over a non-empty time range
let start = time(2024,1,1,0,0,0);
let stop = time(2025,1,1,0,0,0);
print almanac(start, stop).seasons.northern_solstice.time.utc;

integrate

function integrates a callable over named ranges or advances named derivatives

Function: integrate - integrates a callable over named ranges or advances named derivatives
Syntax:
  integrate(function: Function, domain: Object) -> Number
  integrate(initial: Object, derivatives: Object, domain: Object) -> Array
Arguments:
  function: Function [optional] - numeric function to integrate
  domain: Object - object of named ranges; omit step for adaptive integration
  initial: Object [optional] - numeric initial state fields
  derivatives: Object [optional] - callable derivatives keyed by state field
Children: help(), available()

# Integrate a simple scalar function over a bounded range
print integrate((x): x*x, {x: range(0, 1, 0.001)});

sample

function samples a field at a latitude/longitude location

Function: sample - samples a field at a latitude/longitude location
Syntax:
  sample(field: Field, location: Location) -> Number|Nil
Arguments:
  field: Field - global scalar field
  location: Location - location to sample
Children: help(), available()

# Samples a field at a latitude/longitude location
print sample(topography(earth), location(latitude: 60.0, longitude: 270.0));

abs

function returns the absolute value

Function: abs - returns the absolute value
Syntax:
  abs(x: Number) -> Number
Arguments:
  x: Number - numeric input
Children: help(), available()

# Returns the absolute value
print abs(42.0);

sign

function returns -1, 0, or 1 according to the sign

Function: sign - returns -1, 0, or 1 according to the sign
Syntax:
  sign(x: Number) -> Number
Arguments:
  x: Number - numeric input
Children: help(), available()

# Returns -1, 0, or 1 according to the sign
print sign(42.0);

floor

function rounds down to an integer value

Function: floor - rounds down to an integer value
Syntax:
  floor(x: Number) -> Number
Arguments:
  x: Number - numeric input
Children: help(), available()

# Rounds down to an integer value
print floor(42.0);

ceil

function rounds up to an integer value

Function: ceil - rounds up to an integer value
Syntax:
  ceil(x: Number) -> Number
Arguments:
  x: Number - numeric input
Children: help(), available()

# Rounds up to an integer value
print ceil(42.0);

round

function rounds to the nearest integer value

Function: round - rounds to the nearest integer value
Syntax:
  round(x: Number) -> Number
Arguments:
  x: Number - numeric input
Children: help(), available()

# Rounds to the nearest integer value
print round(42.0);

trunc

function truncates toward zero

Function: trunc - truncates toward zero
Syntax:
  trunc(x: Number) -> Number
Arguments:
  x: Number - numeric input
Children: help(), available()

# Truncates toward zero
print trunc(42.0);

fract

function returns the fractional part

Function: fract - returns the fractional part
Syntax:
  fract(x: Number) -> Number
Arguments:
  x: Number - numeric input
Children: help(), available()

# Returns the fractional part
print fract(42.0);

sqrt

function returns the square root

Function: sqrt - returns the square root
Syntax:
  sqrt(x: Number) -> Number
Arguments:
  x: Number - numeric input
Children: help(), available()

# Returns the square root
print sqrt(42.0);

cbrt

function returns the cube root

Function: cbrt - returns the cube root
Syntax:
  cbrt(x: Number) -> Number
Arguments:
  x: Number - numeric input
Children: help(), available()

# Returns the cube root
print cbrt(42.0);

exp

function returns e raised to x

Function: exp - returns e raised to x
Syntax:
  exp(x: Number) -> Number
Arguments:
  x: Number - numeric input
Children: help(), available()

# Returns e raised to x
print exp(42.0);

exp2

function returns 2 raised to x

Function: exp2 - returns 2 raised to x
Syntax:
  exp2(x: Number) -> Number
Arguments:
  x: Number - numeric input
Children: help(), available()

# Returns 2 raised to x
print exp2(42.0);

ln

function returns the natural logarithm

Function: ln - returns the natural logarithm
Syntax:
  ln(x: Number) -> Number
Arguments:
  x: Number - numeric input
Children: help(), available()

# Returns the natural logarithm
print ln(42.0);

log

function returns logarithm of x in the given base

Function: log - returns logarithm of x in the given base
Syntax:
  log(x: Number, y: Number) -> Number
Arguments:
  x: Number - first numeric input
  y: Number - second numeric input
Children: help(), available()

# Returns logarithm of x in the given base
print log(42.0, 42.0);

log2

function returns the base-2 logarithm

Function: log2 - returns the base-2 logarithm
Syntax:
  log2(x: Number) -> Number
Arguments:
  x: Number - numeric input
Children: help(), available()

# Returns the base-2 logarithm
print log2(42.0);

log10

function returns the base-10 logarithm

Function: log10 - returns the base-10 logarithm
Syntax:
  log10(x: Number) -> Number
Arguments:
  x: Number - numeric input
Children: help(), available()

# Returns the base-10 logarithm
print log10(42.0);

pow

function returns x raised to y

Function: pow - returns x raised to y
Syntax:
  pow(x: Number, y: Number) -> Number
Arguments:
  x: Number - first numeric input
  y: Number - second numeric input
Children: help(), available()

# Returns x raised to y
print pow(42.0, 42.0);

sin

function returns sine of x radians

Function: sin - returns sine of x radians
Syntax:
  sin(x: Number) -> Number
Arguments:
  x: Number - numeric input
Children: help(), available()

# Returns sine of x radians
print sin(42.0);

cos

function returns cosine of x radians

Function: cos - returns cosine of x radians
Syntax:
  cos(x: Number) -> Number
Arguments:
  x: Number - numeric input
Children: help(), available()

# Returns cosine of x radians
print cos(42.0);

tan

function returns tangent of x radians

Function: tan - returns tangent of x radians
Syntax:
  tan(x: Number) -> Number
Arguments:
  x: Number - numeric input
Children: help(), available()

# Returns tangent of x radians
print tan(42.0);

asin

function returns arcsine in radians

Function: asin - returns arcsine in radians
Syntax:
  asin(x: Number) -> Number
Arguments:
  x: Number - numeric input
Children: help(), available()

# Returns arcsine in radians
print asin(42.0);

acos

function returns arccosine in radians

Function: acos - returns arccosine in radians
Syntax:
  acos(x: Number) -> Number
Arguments:
  x: Number - numeric input
Children: help(), available()

# Returns arccosine in radians
print acos(42.0);

atan

function returns arctangent in radians

Function: atan - returns arctangent in radians
Syntax:
  atan(x: Number) -> Number
Arguments:
  x: Number - numeric input
Children: help(), available()

# Returns arctangent in radians
print atan(42.0);

atan2

function returns atan2(y, x) in radians

Function: atan2 - returns atan2(y, x) in radians
Syntax:
  atan2(x: Number, y: Number) -> Number
Arguments:
  x: Number - first numeric input
  y: Number - second numeric input
Children: help(), available()

# Returns atan2(y, x) in radians
print atan2(42.0, 42.0);

sinh

function returns hyperbolic sine

Function: sinh - returns hyperbolic sine
Syntax:
  sinh(x: Number) -> Number
Arguments:
  x: Number - numeric input
Children: help(), available()

# Returns hyperbolic sine
print sinh(42.0);

cosh

function returns hyperbolic cosine

Function: cosh - returns hyperbolic cosine
Syntax:
  cosh(x: Number) -> Number
Arguments:
  x: Number - numeric input
Children: help(), available()

# Returns hyperbolic cosine
print cosh(42.0);

tanh

function returns hyperbolic tangent

Function: tanh - returns hyperbolic tangent
Syntax:
  tanh(x: Number) -> Number
Arguments:
  x: Number - numeric input
Children: help(), available()

# Returns hyperbolic tangent
print tanh(42.0);

asinh

function returns inverse hyperbolic sine

Function: asinh - returns inverse hyperbolic sine
Syntax:
  asinh(x: Number) -> Number
Arguments:
  x: Number - numeric input
Children: help(), available()

# Returns inverse hyperbolic sine
print asinh(42.0);

acosh

function returns inverse hyperbolic cosine

Function: acosh - returns inverse hyperbolic cosine
Syntax:
  acosh(x: Number) -> Number
Arguments:
  x: Number - numeric input
Children: help(), available()

# Returns inverse hyperbolic cosine
print acosh(42.0);

atanh

function returns inverse hyperbolic tangent

Function: atanh - returns inverse hyperbolic tangent
Syntax:
  atanh(x: Number) -> Number
Arguments:
  x: Number - numeric input
Children: help(), available()

# Returns inverse hyperbolic tangent
print atanh(42.0);

hypot

function returns sqrt(x*x + y*y) without undue overflow

Function: hypot - returns sqrt(x*x + y*y) without undue overflow
Syntax:
  hypot(x: Number, y: Number) -> Number
Arguments:
  x: Number - first numeric input
  y: Number - second numeric input
Children: help(), available()

# Returns sqrt(x*x + y*y) without undue overflow
print hypot(42.0, 42.0);

min

function returns the smallest numeric argument

Function: min - returns the smallest numeric argument
Syntax:
  min() -> Number
Children: help(), available()

# Find the lower endpoint altitude in a daylight window
let loc = location(60,10);
let obs = loc.observer();
let morning = altitude(sun, time(2026,6,21,6,0,0), obs);
let evening = altitude(sun, time(2026,6,21,18,0,0), obs);
print min(morning, evening);

max

function returns the largest numeric argument

Function: max - returns the largest numeric argument
Syntax:
  max() -> Number
Children: help(), available()

# Find the higher endpoint altitude in a daylight window
let loc = location(60,10);
let obs = loc.observer();
let morning = altitude(sun, time(2026,6,21,6,0,0), obs);
let evening = altitude(sun, time(2026,6,21,18,0,0), obs);
print max(morning, evening);

clamp

function clips x to the inclusive range lower..upper

Function: clamp - clips x to the inclusive range lower..upper
Syntax:
  clamp(x: Number, lower: Number, upper: Number) -> Number
Arguments:
  x: Number - value to clip
  lower: Number - inclusive lower bound
  upper: Number - inclusive upper bound
Children: help(), available()

# Clips x to the inclusive range lower..upper
print clamp(42.0, 42.0, 42.0);

angle_in_degrees

function returns the angle between two vectors in degrees

Aliases: angle_degrees

Function: angle_in_degrees - returns the angle between two vectors in degrees
Syntax:
  angle_in_degrees(a: Vector, b: Vector) -> Number
Aliases: angle_degrees
Arguments:
  a: Vector - first vector
  b: Vector - second vector
Children: help(), available()

# Returns the angle between two vectors in degrees
print angle_in_degrees(vector(1.0, 2.0, 3.0), vector(1.0, 2.0, 3.0));

to_radians

function converts degrees to radians

Function: to_radians - converts degrees to radians
Syntax:
  to_radians(x: Number) -> Number
Arguments:
  x: Number - numeric input
Children: help(), available()

# Converts degrees to radians
print to_radians(42.0);

to_degrees

function converts radians to degrees

Function: to_degrees - converts radians to degrees
Syntax:
  to_degrees(x: Number) -> Number
Arguments:
  x: Number - numeric input
Children: help(), available()

# Converts radians to degrees
print to_degrees(42.0);

is_finite

function returns true when x is finite

Function: is_finite - returns true when x is finite
Syntax:
  is_finite(x: Number) -> Bool
Arguments:
  x: Number - numeric input
Children: help(), available()

# Returns true when x is finite
print is_finite(42.0);

is_nan

function returns true when x is NaN

Function: is_nan - returns true when x is NaN
Syntax:
  is_nan(x: Number) -> Bool
Arguments:
  x: Number - numeric input
Children: help(), available()

# Returns true when x is NaN
print is_nan(42.0);

is_infinite

function returns true when x is infinite

Function: is_infinite - returns true when x is infinite
Syntax:
  is_infinite(x: Number) -> Bool
Arguments:
  x: Number - numeric input
Children: help(), available()

# Returns true when x is infinite
print is_infinite(42.0);

navigate

function estimates an Earth location from target elevation observations

Function: navigate - estimates an Earth location from target elevation observations
Syntax:
  navigate(observations: Observation|[Observation]) -> LocationSolution
Arguments:
  observations: Observation|[Observation] - three or more target elevation observations
Resources: ephemeris, iers
Children: help(), available()

# Estimate a location from seven pasted elevation observations
let sirius = stars().find("sirius");
let betelgeuse = stars().find("betelgeuse");
let procyon = stars().find("procyon");
let aldebaran = stars().find("aldebaran");
let rigel = stars().find("rigel");
let o1 = observation(sirius, time(2026, 1, 12, 22, 0, 0), elevation: 13.032698485299838);
let o2 = observation(jupiter, time(2026, 1, 12, 22, 10, 0), elevation: 50.72978965272842);
let o3 = observation(uranus, time(2026, 1, 12, 22, 20, 0), elevation: 39.45114824559175);
let o4 = observation(betelgeuse, time(2026, 1, 12, 22, 30, 0), elevation: 36.78064241831301);
let o5 = observation(procyon, time(2026, 1, 12, 22, 40, 0), elevation: 34.48682253366456);
let o6 = observation(aldebaran, time(2026, 1, 12, 22, 50, 0), elevation: 39.32907688782253);
let o7 = observation(rigel, time(2026, 1, 12, 23, 0, 0), elevation: 18.06018919597869);
let sol = navigate(o1, o2, o3, o4, o5, o6, o7);
print sol.location.latitude, sol.location.longitude, sol.rms;

minimize

function minimizes a numeric callable over named variables with optional bounds and constraints

Function: minimize - minimizes a numeric callable over named variables with optional bounds and constraints
Syntax:
  minimize(objective: Function, initial: Object, options: Object) -> Object
Arguments:
  objective: Function - numeric objective function
  initial: Object - named numeric initial variables
  options: Object [optional] - bounds, constraints, tolerance, and iteration options
Children: help(), available()

# Minimize a numeric objective over a bounded variable
let result = minimize((x): (x - 2) * (x - 2), {x: 0}, {bounds: {x: range(-5, 5)}});
print result.solution.x, result.value;

Time

type UTC date/time value with resolved TT, UT1, and TDB scales

Type: Time - UTC date/time value with resolved TT, UT1, and TDB scales
Syntax:
  time() -> Time
  time(julian_date: Number) -> Time
  time(year: Integer, month: Integer, day: Integer, hour: Integer, minute: Integer, second: Integer) -> Time
  time(timezone: Timezone|Text|Location|Place) -> LocalTime
  time(year: Integer, month: Integer, day: Integer, hour: Integer, minute: Integer, second: Integer, timezone: Timezone|Text|Location|Place) -> LocalTime
Arguments:
  julian_date: Number [optional] - UTC Julian date
  year: Integer [optional] - full UTC year
  month: Integer [optional] - month from 1 to 12
  day: Integer [optional] - day from 1 to 31
  hour: Integer [optional] - hour from 0 to 23
  minute: Integer [optional] - minute from 0 to 59
  second: Integer [optional] - second from 0 to 59
  timezone: Timezone|Text|Location|Place [optional] - timezone id, Timezone, Location, or Place for local civil time
Children: year, month, day, hour, minute, second, weekday, year(), utc(), tt(), ut1(), tdb(), dt(), local(), add_months(), add_days(), add_hours(), add_minutes(), add_seconds(), children(), fields(), functions()

# Convert a UTC time to local civil time
let t = time(2026,6,1,12,0,0);
print t.utc(), t.local("Europe/Oslo").iso;

Time.year

field full UTC year

Field: Time.year - full UTC year
Syntax:
  <Time>.year -> Integer

# Read the year field from a Time value
print time().year;

Time.month

field month from 1 to 12

Field: Time.month - month from 1 to 12
Syntax:
  <Time>.month -> Integer

# Read the month field from a Time value
print time().month;

Time.day

field day from 1 to 31

Field: Time.day - day from 1 to 31
Syntax:
  <Time>.day -> Integer

# Read the day field from a Time value
print time().day;

Time.hour

field hour from 0 to 23

Field: Time.hour - hour from 0 to 23
Syntax:
  <Time>.hour -> Integer

# Read the hour field from a Time value
print time().hour;

Time.minute

field minute from 0 to 59

Field: Time.minute - minute from 0 to 59
Syntax:
  <Time>.minute -> Integer

# Read the minute field from a Time value
print time().minute;

Time.second

field second from 0 to 59

Field: Time.second - second from 0 to 59
Syntax:
  <Time>.second -> Integer

# Read the second field from a Time value
print time().second;

Time.weekday

field UTC weekday

Field: Time.weekday - UTC weekday
Syntax:
  <Time>.weekday -> Weekday

# Read the weekday field from a Time value
print time().weekday;

Time.year

method returns the year component of a Time

Method: Time.year - returns the year component of a Time
Syntax:
  <Time>.year() -> Number

# Use Time.year on a Time value
let value = time();
print value.year();

Time.utc

method returns the UTC Julian date

Method: Time.utc - returns the UTC Julian date
Syntax:
  <Time>.utc() -> Number

# Use Time.utc on a Time value
let value = time();
print value.utc();

Time.tt

method returns the TT Julian date

Method: Time.tt - returns the TT Julian date
Syntax:
  <Time>.tt() -> Number

# Use Time.tt on a Time value
let value = time();
print value.tt();

Time.ut1

method returns the UT1 Julian date

Method: Time.ut1 - returns the UT1 Julian date
Syntax:
  <Time>.ut1() -> Number

# Use Time.ut1 on a Time value
let value = time();
print value.ut1();

Time.tdb

method returns the TDB Julian date

Method: Time.tdb - returns the TDB Julian date
Syntax:
  <Time>.tdb() -> Number

# Use Time.tdb on a Time value
let value = time();
print value.tdb();

Time.dt

method returns Delta-T (TT-UT1) in seconds

Method: Time.dt - returns Delta-T (TT-UT1) in seconds
Syntax:
  <Time>.dt() -> Number

# Use Time.dt on a Time value
let value = time();
print value.dt();

Time.local

method converts a UTC Time into local civil time for a timezone

Method: Time.local - converts a UTC Time into local civil time for a timezone
Syntax:
  <Time>.local(timezone: Timezone|Text|Location|Place) -> LocalTime
Arguments:
  timezone: Timezone|Text|Location|Place - timezone id, Timezone, Location, or Place

# Use Time.local on a Time value
let value = time();
print value.local(location(latitude: 60.0, longitude: 270.0));

Time.add_months

method adds calendar months to a Time

Method: Time.add_months - adds calendar months to a Time
Syntax:
  <Time>.add_months(months: Integer) -> Time
Arguments:
  months: Integer - number of calendar months to add

# Use Time.add_months on a Time value
let value = time();
print value.add_months(42);

Time.add_days

method adds UTC days to a Time

Method: Time.add_days - adds UTC days to a Time
Syntax:
  <Time>.add_days(days: Number) -> Time
Arguments:
  days: Number - number of UTC days to add

# Use Time.add_days on a Time value
let value = time();
print value.add_days(42.0);

Time.add_hours

method adds UTC hours to a Time

Method: Time.add_hours - adds UTC hours to a Time
Syntax:
  <Time>.add_hours(hours: Number) -> Time
Arguments:
  hours: Number - number of UTC hours to add

# Use Time.add_hours on a Time value
let value = time();
print value.add_hours(42.0);

Time.add_minutes

method adds UTC minutes to a Time

Method: Time.add_minutes - adds UTC minutes to a Time
Syntax:
  <Time>.add_minutes(minutes: Number) -> Time
Arguments:
  minutes: Number - number of UTC minutes to add

# Use Time.add_minutes on a Time value
let value = time();
print value.add_minutes(42.0);

Time.add_seconds

method adds UTC seconds to a Time

Method: Time.add_seconds - adds UTC seconds to a Time
Syntax:
  <Time>.add_seconds(seconds: Number) -> Time
Arguments:
  seconds: Number - number of UTC seconds to add

# Use Time.add_seconds on a Time value
let value = time();
print value.add_seconds(42.0);

Time.children

method lists child fields and callable members available on this value

Method: Time.children - lists child fields and callable members available on this value
Syntax:
  <Time>.children() -> List

# Use Time.children on a Time value
let value = time();
print value.children();

Time.fields

method returns an object containing the value's plain fields

Method: Time.fields - returns an object containing the value's plain fields
Syntax:
  <Time>.fields() -> Object

# Use Time.fields on a Time value
let value = time();
print value.fields();

Time.functions

method lists callable members available on this value

Method: Time.functions - lists callable members available on this value
Syntax:
  <Time>.functions() -> List

# Use Time.functions on a Time value
let value = time();
print value.functions();

LocalTime

type timezone-adjusted civil time derived from a UTC Time

Type: LocalTime - timezone-adjusted civil time derived from a UTC Time
Children: timezone, year, month, day, hour, minute, second, weekday, offset_seconds, offset_hours, offset, abbreviation, is_dst, iso, utc(), local(), children(), fields(), functions()

# Show a UTC timestamp as local civil time
let local = time(2026,6,21,12,0,0).local("Europe/Oslo");
print local.iso, local.timezone;

LocalTime.timezone

field IANA timezone id

Field: LocalTime.timezone - IANA timezone id
Syntax:
  <LocalTime>.timezone -> Text

# Read the timezone field from a LocalTime value
print time(2026,6,7,12,0,0).local("Europe/Oslo").timezone;

LocalTime.year

field local civil year

Field: LocalTime.year - local civil year
Syntax:
  <LocalTime>.year -> Number

# Read the year field from a LocalTime value
print time(2026,6,7,12,0,0).local("Europe/Oslo").year;

LocalTime.month

field local civil month

Field: LocalTime.month - local civil month
Syntax:
  <LocalTime>.month -> Number

# Read the month field from a LocalTime value
print time(2026,6,7,12,0,0).local("Europe/Oslo").month;

LocalTime.day

field local civil day

Field: LocalTime.day - local civil day
Syntax:
  <LocalTime>.day -> Number

# Read the day field from a LocalTime value
print time(2026,6,7,12,0,0).local("Europe/Oslo").day;

LocalTime.hour

field local civil hour

Field: LocalTime.hour - local civil hour
Syntax:
  <LocalTime>.hour -> Number

# Read the hour field from a LocalTime value
print time(2026,6,7,12,0,0).local("Europe/Oslo").hour;

LocalTime.minute

field local civil minute

Field: LocalTime.minute - local civil minute
Syntax:
  <LocalTime>.minute -> Number

# Read the minute field from a LocalTime value
print time(2026,6,7,12,0,0).local("Europe/Oslo").minute;

LocalTime.second

field local civil second

Field: LocalTime.second - local civil second
Syntax:
  <LocalTime>.second -> Number

# Read the second field from a LocalTime value
print time(2026,6,7,12,0,0).local("Europe/Oslo").second;

LocalTime.weekday

field local ISO weekday

Field: LocalTime.weekday - local ISO weekday
Syntax:
  <LocalTime>.weekday -> Weekday

# Read the weekday field from a LocalTime value
print time(2026,6,7,12,0,0).local("Europe/Oslo").weekday;

LocalTime.offset_seconds

field UTC offset in seconds

Field: LocalTime.offset_seconds - UTC offset in seconds
Syntax:
  <LocalTime>.offset_seconds -> Number

# Read the offset_seconds field from a LocalTime value
print time(2026,6,7,12,0,0).local("Europe/Oslo").offset_seconds;

LocalTime.offset_hours

field UTC offset in hours

Field: LocalTime.offset_hours - UTC offset in hours
Syntax:
  <LocalTime>.offset_hours -> Number

# Read the offset_hours field from a LocalTime value
print time(2026,6,7,12,0,0).local("Europe/Oslo").offset_hours;

LocalTime.offset

field formatted UTC offset

Field: LocalTime.offset - formatted UTC offset
Syntax:
  <LocalTime>.offset -> Text

# Read the offset field from a LocalTime value
print time(2026,6,7,12,0,0).local("Europe/Oslo").offset;

LocalTime.abbreviation

field timezone abbreviation at this instant

Field: LocalTime.abbreviation - timezone abbreviation at this instant
Syntax:
  <LocalTime>.abbreviation -> Text

# Read the abbreviation field from a LocalTime value
print time(2026,6,7,12,0,0).local("Europe/Oslo").abbreviation;

LocalTime.is_dst

field true when the selected offset is daylight-saving time

Field: LocalTime.is_dst - true when the selected offset is daylight-saving time
Syntax:
  <LocalTime>.is_dst -> Bool

# Read the is_dst field from a LocalTime value
print time(2026,6,7,12,0,0).local("Europe/Oslo").is_dst;

LocalTime.iso

field ISO-like local timestamp with UTC offset

Field: LocalTime.iso - ISO-like local timestamp with UTC offset
Syntax:
  <LocalTime>.iso -> Text

# Read the iso field from a LocalTime value
print time(2026,6,7,12,0,0).local("Europe/Oslo").iso;

LocalTime.utc

method returns the original UTC Time

Method: LocalTime.utc - returns the original UTC Time
Syntax:
  <LocalTime>.utc() -> Time

# Use LocalTime.utc on a LocalTime value
let value = time(2026,6,7,12,0,0).local("Europe/Oslo");
print value.utc();

LocalTime.local

method converts this local time's UTC instant into another local civil time

Method: LocalTime.local - converts this local time's UTC instant into another local civil time
Syntax:
  <LocalTime>.local(timezone: Timezone|Text|Location|Place) -> LocalTime
Arguments:
  timezone: Timezone|Text|Location|Place - timezone id, Timezone, Location, or Place

# Use LocalTime.local on a LocalTime value
let value = time(2026,6,7,12,0,0).local("Europe/Oslo");
print value.local(location(latitude: 60.0, longitude: 270.0));

LocalTime.children

method lists child fields and callable members available on this value

Method: LocalTime.children - lists child fields and callable members available on this value
Syntax:
  <LocalTime>.children() -> List

# Use LocalTime.children on a LocalTime value
let value = time(2026,6,7,12,0,0).local("Europe/Oslo");
print value.children();

LocalTime.fields

method returns an object containing the value's plain fields

Method: LocalTime.fields - returns an object containing the value's plain fields
Syntax:
  <LocalTime>.fields() -> Object

# Use LocalTime.fields on a LocalTime value
let value = time(2026,6,7,12,0,0).local("Europe/Oslo");
print value.fields();

LocalTime.functions

method lists callable members available on this value

Method: LocalTime.functions - lists callable members available on this value
Syntax:
  <LocalTime>.functions() -> List

# Use LocalTime.functions on a LocalTime value
let value = time(2026,6,7,12,0,0).local("Europe/Oslo");
print value.functions();

Weekday

type ISO weekday value

Type: Weekday - ISO weekday value
Syntax:
  weekday(value: Integer|Text) -> Weekday
Arguments:
  value: Integer|Text - ISO index from 1 to 7, full name, or short name
Children: name(), short(), letter(), index(), children(), fields(), functions()

# Check the weekday for a planned observation date
let t = time(2026,6,21,12,0,0);
print t.utc(), t.weekday;

Weekday.name

method returns the full weekday name

Method: Weekday.name - returns the full weekday name
Syntax:
  <Weekday>.name() -> Text

# Use Weekday.name on a Weekday value
let value = wednesday;
print value.name();

Weekday.short

method returns the short weekday name

Method: Weekday.short - returns the short weekday name
Syntax:
  <Weekday>.short() -> Text

# Use Weekday.short on a Weekday value
let value = wednesday;
print value.short();

Weekday.letter

method returns the one-letter weekday label

Method: Weekday.letter - returns the one-letter weekday label
Syntax:
  <Weekday>.letter() -> Text

# Use Weekday.letter on a Weekday value
let value = wednesday;
print value.letter();

Weekday.index

method returns the ISO weekday index

Method: Weekday.index - returns the ISO weekday index
Syntax:
  <Weekday>.index() -> Integer

# Use Weekday.index on a Weekday value
let value = wednesday;
print value.index();

Weekday.children

method lists child fields and callable members available on this value

Method: Weekday.children - lists child fields and callable members available on this value
Syntax:
  <Weekday>.children() -> List

# Use Weekday.children on a Weekday value
let value = wednesday;
print value.children();

Weekday.fields

method returns an object containing the value's plain fields

Method: Weekday.fields - returns an object containing the value's plain fields
Syntax:
  <Weekday>.fields() -> Object

# Use Weekday.fields on a Weekday value
let value = wednesday;
print value.fields();

Weekday.functions

method lists callable members available on this value

Method: Weekday.functions - lists callable members available on this value
Syntax:
  <Weekday>.functions() -> List

# Use Weekday.functions on a Weekday value
let value = wednesday;
print value.functions();

Location

type body-aware latitude/longitude surface location

Type: Location - body-aware latitude/longitude surface location
Syntax:
  location(body: Body, latitude: Number, longitude: Number) -> Location
Arguments:
  body: Body [optional] - central body; defaults to earth
  latitude: Number - latitude in degrees
  longitude: Number - longitude in degrees
Children: body, latitude, longitude, observer(), direction(), children(), fields(), functions()

# Format a location as latitude and longitude text
let loc = location(latitude: 58.9666667, longitude: 5.7333333);
print dms(loc.latitude, "latitude"), dms(loc.longitude, "longitude");

Location.body

field central body; defaults to earth

Field: Location.body - central body; defaults to earth
Syntax:
  <Location>.body -> Body

# Read the body field from a Location value
print location(latitude: 60.0, longitude: 270.0).body;

Location.latitude

field latitude in degrees

Field: Location.latitude - latitude in degrees
Syntax:
  <Location>.latitude -> Number

# Read the latitude field from a Location value
print location(latitude: 60.0, longitude: 270.0).latitude;

Location.longitude

field longitude in degrees

Field: Location.longitude - longitude in degrees
Syntax:
  <Location>.longitude -> Number

# Read the longitude field from a Location value
print location(latitude: 60.0, longitude: 270.0).longitude;

Location.observer

method promotes this location to a 3D observer

Method: Location.observer - promotes this location to a 3D observer
Syntax:
  <Location>.observer(topography: Field, height: Number) -> Observer
Arguments:
  topography: Field [optional] - optional body-matching topography field; use `topography(earth)` or `topography(moon)`
  height: Number [optional] - height in kilometers above the datum or supplied topography; defaults to zero

# Use Location.observer on a Location value
let value = location(latitude: 60.0, longitude: 270.0);
print value.observer();

Location.direction

method returns a local topographic direction

Method: Location.direction - returns a local topographic direction
Syntax:
  <Location>.direction(azimuth: Number, elevation: Number, zenith: Number, unit: Unit) -> Direction
Arguments:
  azimuth: Number - local azimuth clockwise from north; degrees are default
  elevation: Number [optional] - angle above the local horizon; degrees are default
  zenith: Number [optional] - angle down from local zenith; degrees are default
  unit: Unit [optional] - optional angle unit for azimuth and elevation/zenith

# Build a local topographic direction from a location
let loc = location(latitude: 60.0, longitude: 10.0);
print loc.direction(azimuth: 180, elevation: 25);

Location.children

method lists child fields and callable members available on this value

Method: Location.children - lists child fields and callable members available on this value
Syntax:
  <Location>.children() -> List

# Use Location.children on a Location value
let value = location(latitude: 60.0, longitude: 270.0);
print value.children();

Location.fields

method returns an object containing the value's plain fields

Method: Location.fields - returns an object containing the value's plain fields
Syntax:
  <Location>.fields() -> Object

# Use Location.fields on a Location value
let value = location(latitude: 60.0, longitude: 270.0);
print value.fields();

Location.functions

method lists callable members available on this value

Method: Location.functions - lists callable members available on this value
Syntax:
  <Location>.functions() -> List

# Use Location.functions on a Location value
let value = location(latitude: 60.0, longitude: 270.0);
print value.functions();

LocationSolution

type navigation solution with location, residuals, and fit quality

Type: LocationSolution - navigation solution with location, residuals, and fit quality
Children: location, observations, residuals, rms, lat_rms, lon_rms, status, method, iterations, children(), fields(), functions()

LocationSolution.location

field best-fit Earth location

Field: LocationSolution.location - best-fit Earth location
Syntax:
  <LocationSolution>.location -> Location

LocationSolution.observations

field elevation observations used for the navigation solution

Field: LocationSolution.observations - elevation observations used for the navigation solution
Syntax:
  <LocationSolution>.observations -> List<Observation>

LocationSolution.residuals

field per-observation elevation residuals in degrees

Field: LocationSolution.residuals - per-observation elevation residuals in degrees
Syntax:
  <LocationSolution>.residuals -> List<Object>

LocationSolution.rms

field RMS elevation residual in degrees

Field: LocationSolution.rms - RMS elevation residual in degrees
Syntax:
  <LocationSolution>.rms -> Number?

LocationSolution.lat_rms

field latitude uncertainty estimate in degrees, or nil when unavailable

Field: LocationSolution.lat_rms - latitude uncertainty estimate in degrees, or nil when unavailable
Syntax:
  <LocationSolution>.lat_rms -> Number?

LocationSolution.lon_rms

field longitude uncertainty estimate in degrees, or nil when unavailable

Field: LocationSolution.lon_rms - longitude uncertainty estimate in degrees, or nil when unavailable
Syntax:
  <LocationSolution>.lon_rms -> Number?

LocationSolution.status

field solution status

Field: LocationSolution.status - solution status
Syntax:
  <LocationSolution>.status -> Text?

LocationSolution.method

field navigation solution method

Field: LocationSolution.method - navigation solution method
Syntax:
  <LocationSolution>.method -> Text?

LocationSolution.iterations

field number of refinement iterations, or nil when unavailable

Field: LocationSolution.iterations - number of refinement iterations, or nil when unavailable
Syntax:
  <LocationSolution>.iterations -> Number?

LocationSolution.children

method lists child fields and callable members available on this value

Method: LocationSolution.children - lists child fields and callable members available on this value
Syntax:
  <LocationSolution>.children() -> List

LocationSolution.fields

method returns an object containing the value's plain fields

Method: LocationSolution.fields - returns an object containing the value's plain fields
Syntax:
  <LocationSolution>.fields() -> Object

LocationSolution.functions

method lists callable members available on this value

Method: LocationSolution.functions - lists callable members available on this value
Syntax:
  <LocationSolution>.functions() -> List

Observer

type body-fixed 3D observer with position, zenith, and derived surface location

Type: Observer - body-fixed 3D observer with position, zenith, and derived surface location
Syntax:
  observer(location_or_body: Location|Body, height_or_position: Number|Field|Vector, height_or_zenith: Number|Vector) -> Observer
Arguments:
  location_or_body: Location|Body - surface location or body for body-fixed vectors
  height_or_position: Number|Field|Vector [optional] - height in kilometers, topography field for a location, or observer position vector
  height_or_zenith: Number|Vector [optional] - height above topography for a location, or body-fixed zenith/up vector
Children: body, position, zenith, location, height_km, position(), location(), latitude(), longitude(), height(), zenith(), north(), west(), limb(), direction(), orbit(), children(), fields(), functions()

# Sample the Sun altitude from an elevated observer
let obs = location(58.9666667, 5.7333333).observer(height: 0.002);
print obs.height(), altitude(sun, time(2026,6,21,12,0,0), obs);

Observer.body

field body whose fixed frame contains the observer

Field: Observer.body - body whose fixed frame contains the observer
Syntax:
  <Observer>.body -> Body

# Read the body field from a Observer value
print location(latitude: 60.0, longitude: 270.0).observer(height: 1.5).body;

Observer.position

field body-fixed observer position in kilometers

Field: Observer.position - body-fixed observer position in kilometers
Syntax:
  <Observer>.position -> Vector

# Read the position field from a Observer value
print location(latitude: 60.0, longitude: 270.0).observer(height: 1.5).position;

Observer.zenith

field body-fixed local zenith direction

Field: Observer.zenith - body-fixed local zenith direction
Syntax:
  <Observer>.zenith -> Vector

# Read the zenith field from a Observer value
print location(latitude: 60.0, longitude: 270.0).observer(height: 1.5).zenith;

Observer.location

field derived body-aware surface location

Field: Observer.location - derived body-aware surface location
Syntax:
  <Observer>.location -> Location

# Read the location field from a Observer value
print location(latitude: 60.0, longitude: 270.0).observer(height: 1.5).location;

Observer.height_km

field derived height above the body shape in kilometers

Field: Observer.height_km - derived height above the body shape in kilometers
Syntax:
  <Observer>.height_km -> Number

# Read the height_km field from a Observer value
print location(latitude: 60.0, longitude: 270.0).observer(height: 1.5).height_km;

Observer.position

method returns the observer position vector in a requested origin and frame

Method: Observer.position - returns the observer position vector in a requested origin and frame
Syntax:
  <Observer>.position() -> Vector
  <Observer>.position(time: Time, origin: Body, axis: Axis) -> Vector
Arguments:
  time: Time [optional] - time at which to resolve the observer position
  origin: Body [optional] - origin body center such as earth, mars, or jupiter
  axis: Axis [optional] - target frame such as icrf, earthfixed, marsfixed, or jupiterfixed

# Use Observer.position on a Observer value
let value = location(latitude: 60.0, longitude: 270.0).observer(height: 1.5);
print value.position();

Observer.location

method returns the datum-derived location

Method: Observer.location - returns the datum-derived location
Syntax:
  <Observer>.location() -> Location

# Use Observer.location on a Observer value
let value = location(latitude: 60.0, longitude: 270.0).observer(height: 1.5);
print value.location();

Observer.latitude

method returns the datum-derived latitude in degrees

Method: Observer.latitude - returns the datum-derived latitude in degrees
Syntax:
  <Observer>.latitude() -> Number

# Use Observer.latitude on a Observer value
let value = location(latitude: 60.0, longitude: 270.0).observer(height: 1.5);
print value.latitude();

Observer.longitude

method returns the datum-derived longitude in degrees

Method: Observer.longitude - returns the datum-derived longitude in degrees
Syntax:
  <Observer>.longitude() -> Number

# Use Observer.longitude on a Observer value
let value = location(latitude: 60.0, longitude: 270.0).observer(height: 1.5);
print value.longitude();

Observer.height

method returns height above the body datum in kilometers

Method: Observer.height - returns height above the body datum in kilometers
Syntax:
  <Observer>.height() -> Number

# Use Observer.height on a Observer value
let value = location(latitude: 60.0, longitude: 270.0).observer(height: 1.5);
print value.height();

Observer.zenith

method returns the body-fixed local zenith unit vector

Method: Observer.zenith - returns the body-fixed local zenith unit vector
Syntax:
  <Observer>.zenith() -> Vector

# Use Observer.zenith on a Observer value
let value = location(latitude: 60.0, longitude: 270.0).observer(height: 1.5);
print value.zenith();

Observer.north

method returns the body-fixed local north unit vector

Method: Observer.north - returns the body-fixed local north unit vector
Syntax:
  <Observer>.north() -> Vector

# Use Observer.north on a Observer value
let value = location(latitude: 60.0, longitude: 270.0).observer(height: 1.5);
print value.north();

Observer.west

method returns the body-fixed local west unit vector

Method: Observer.west - returns the body-fixed local west unit vector
Syntax:
  <Observer>.west() -> Vector

# Use Observer.west on a Observer value
let value = location(latitude: 60.0, longitude: 270.0).observer(height: 1.5);
print value.west();

Observer.limb

method computes the apparent limb profile of a target state from this observer

Method: Observer.limb - computes the apparent limb profile of a target state from this observer
Syntax:
  <Observer>.limb(state: State, north: Vector, samples: Number) -> Array
Arguments:
  state: State - target body state whose limb should be sampled
  north: Vector [optional] - direction projected as clock-angle zero; defaults to body north
  samples: Number [optional] - number of limb samples; defaults to 360

# Compute a target limb profile from an observer
let obs = location(latitude: 0, longitude: 0).observer(0.052);
let target = state(moon, time(2026,4,27,8,26,0));
print obs.limb(target, 4).length();

Observer.direction

method returns a local topographic direction

Method: Observer.direction - returns a local topographic direction
Syntax:
  <Observer>.direction(azimuth: Number, elevation: Number, zenith: Number, unit: Unit) -> Direction
Arguments:
  azimuth: Number - local azimuth clockwise from north; degrees are default
  elevation: Number [optional] - angle above the local horizon; degrees are default
  zenith: Number [optional] - angle down from local zenith; degrees are default
  unit: Unit [optional] - optional angle unit for azimuth and elevation/zenith

# Build a local topographic direction from an observer
let obs = location(latitude: 60.0, longitude: 10.0).observer(0.002);
print obs.direction(azimuth: 180, elevation: 25);

Observer.orbit

method determines an orbit from observations made by this observer

Method: Observer.orbit - determines an orbit from observations made by this observer
Syntax:
  <Observer>.orbit(observations: Observation...) -> OrbitSolution
Arguments:
  observations: Observation... - three or more observations, or one list of observations

# Prepare observations that can be passed to observer.orbit(...)
let obs = location(latitude: 59.91, longitude: 10.75).observer(height: 0);
let first = observation(obs, time(2028,7,3), ra: 131.0857742519269, dec: 18.803678151005595);
let second = observation(obs, time(2028,7,23), ra: 135.0300892722528, dec: 18.040162341691612);
let third = observation(obs, time(2028,8,12), ra: 139.04202357010908, dec: 17.175191580463146);
print first.time.utc(), second.time.utc(), third.time.utc();

Observer.children

method lists child fields and callable members available on this value

Method: Observer.children - lists child fields and callable members available on this value
Syntax:
  <Observer>.children() -> List

# Use Observer.children on a Observer value
let value = location(latitude: 60.0, longitude: 270.0).observer(height: 1.5);
print value.children();

Observer.fields

method returns an object containing the value's plain fields

Method: Observer.fields - returns an object containing the value's plain fields
Syntax:
  <Observer>.fields() -> Object

# Use Observer.fields on a Observer value
let value = location(latitude: 60.0, longitude: 270.0).observer(height: 1.5);
print value.fields();

Observer.functions

method lists callable members available on this value

Method: Observer.functions - lists callable members available on this value
Syntax:
  <Observer>.functions() -> List

# Use Observer.functions on a Observer value
let value = location(latitude: 60.0, longitude: 270.0).observer(height: 1.5);
print value.functions();

Body

type solar-system body with physical parameters from the reference C model

Type: Body - solar-system body with physical parameters from the reference C model
Syntax:
  body(name: Text) -> Body
Arguments:
  name: Text - solar-system body name
Children: name, kind, xmu, radius, mass, H, n, k, known, rotational_axis(), rotational_axis_ra(), rotational_axis_dec(), state(), rise(), set(), conjunction(), inferior_conjunction(), superior_conjunction(), opposition(), eastern_quadrature(), western_quadrature(), quadrature(), greatest_eastern_elongation(), greatest_western_elongation(), greatest_elongation(), periapsis(), apoapsis(), transit(), children(), fields(), functions()

# Compare physical reference values for two bodies
print earth.radius, moon.radius, moon.mass / earth.mass;

Body.name

field canonical body name

Field: Body.name - canonical body name
Syntax:
  <Body>.name -> Text

# Read the name field from a Body value
print sun.name;

Body.kind

field reference body kind

Field: Body.kind - reference body kind
Syntax:
  <Body>.kind -> Text

# Read the kind field from a Body value
print sun.kind;

Body.xmu

field gravitational parameter in km^3/s^2

Field: Body.xmu - gravitational parameter in km^3/s^2
Syntax:
  <Body>.xmu -> Number

# Read the xmu field from a Body value
print sun.xmu;

Body.radius

field body radius in km

Field: Body.radius - body radius in km
Syntax:
  <Body>.radius -> Number

# Read the radius field from a Body value
print sun.radius;

Body.mass

field body mass in kg

Field: Body.mass - body mass in kg
Syntax:
  <Body>.mass -> Number

# Read the mass field from a Body value
print sun.mass;

Body.H

field reference absolute magnitude parameter

Field: Body.H - reference absolute magnitude parameter
Syntax:
  <Body>.H -> Number

# Read the H field from a Body value
print sun.H;

Body.n

field reference illumination exponent

Field: Body.n - reference illumination exponent
Syntax:
  <Body>.n -> Number

# Read the n field from a Body value
print sun.n;

Body.k

field reference G Muller constant

Field: Body.k - reference G Muller constant
Syntax:
  <Body>.k -> Number

# Read the k field from a Body value
print sun.k;

Body.known

field whether the body name matched the built-in table

Field: Body.known - whether the body name matched the built-in table
Syntax:
  <Body>.known -> Bool

# Read the known field from a Body value
print sun.known;

Body.rotational_axis

method returns this body's rotational north pole at a time

Method: Body.rotational_axis - returns this body's rotational north pole at a time
Syntax:
  <Body>.rotational_axis(time: Time) -> Object
Arguments:
  time: Time - time at which to evaluate the rotational pole

# Use Body.rotational_axis on a Body value
let value = sun;
print value.rotational_axis(time());

Body.rotational_axis_ra

method returns the rotational north-pole right ascension in degrees

Method: Body.rotational_axis_ra - returns the rotational north-pole right ascension in degrees
Syntax:
  <Body>.rotational_axis_ra(time: Time) -> Number
Arguments:
  time: Time - time at which to evaluate the rotational pole

# Use Body.rotational_axis_ra on a Body value
let value = sun;
print value.rotational_axis_ra(time());

Body.rotational_axis_dec

method returns the rotational north-pole declination in degrees

Method: Body.rotational_axis_dec - returns the rotational north-pole declination in degrees
Syntax:
  <Body>.rotational_axis_dec(time: Time) -> Number
Arguments:
  time: Time - time at which to evaluate the rotational pole

# Use Body.rotational_axis_dec on a Body value
let value = sun;
print value.rotational_axis_dec(time());

Body.state

method returns the orbital state for this body at a time

Method: Body.state - returns the orbital state for this body at a time
Syntax:
  <Body>.state(time: Time) -> State
Arguments:
  time: Time - time at which to evaluate the rotational pole

# Use Body.state on a Body value
let value = sun;
print value.state(time());

Body.rise

method returns sunrise or moonrise events for an observer

Method: Body.rise - returns sunrise or moonrise events for an observer
Syntax:
  <Body>.rise(observer: Location|Observer, range: Range) -> List|Event|Nil
Arguments:
  observer: Location|Observer - Earth location or observer for the local horizon event
  range: Range - time range to search; open ranges return the next event

# Find rise events for a body from an explicit observer
let obs = location(latitude: 60.0, longitude: 10.0).observer(0.002);
let span = range(time(2026,1,1,0,0,0), time(2026,1,2,0,0,0));
print sun.rise(obs, span).first();

Body.set

method returns sunset or moonset events for an observer

Method: Body.set - returns sunset or moonset events for an observer
Syntax:
  <Body>.set(observer: Location|Observer, range: Range) -> List|Event|Nil
Arguments:
  observer: Location|Observer - Earth location or observer for the local horizon event
  range: Range - time range to search; open ranges return the next event

# Find set events for a body from an explicit observer
let obs = location(latitude: 60.0, longitude: 10.0).observer(0.002);
let span = range(time(2026,1,1,0,0,0), time(2026,1,2,0,0,0));
print sun.set(obs, span).first();

Body.conjunction

method returns conjunction events for this body

Method: Body.conjunction - returns conjunction events for this body
Syntax:
  <Body>.conjunction(time: Time|Range, stop: Time, count: Number) -> List|Event|Nil
Arguments:
  time: Time|Range [optional] - start time for the next event, start/stop times, or time range to search
  stop: Time [optional] - optional stop time when passing start and stop times separately
  count: Number [optional] - maximum number of events to return

# Find conjunction events for an explicit body and time range
let span = range(time(2026,1,1,0,0,0), time(2026,3,1,0,0,0), 1);
print moon.conjunction(span).first();

Body.inferior_conjunction

method returns inferior conjunction events for this body

Method: Body.inferior_conjunction - returns inferior conjunction events for this body
Syntax:
  <Body>.inferior_conjunction(time: Time|Range, stop: Time, count: Number) -> List|Event|Nil
Arguments:
  time: Time|Range [optional] - start time for the next event, start/stop times, or time range to search
  stop: Time [optional] - optional stop time when passing start and stop times separately
  count: Number [optional] - maximum number of events to return

# Find inferior conjunction events for an inner planet
let span = range(time(2024,1,1,0,0,0), time(2026,1,1,0,0,0), 5);
print mercury.inferior_conjunction(span).first();

Body.superior_conjunction

method returns superior conjunction events for this body

Method: Body.superior_conjunction - returns superior conjunction events for this body
Syntax:
  <Body>.superior_conjunction(time: Time|Range, stop: Time, count: Number) -> List|Event|Nil
Arguments:
  time: Time|Range [optional] - start time for the next event, start/stop times, or time range to search
  stop: Time [optional] - optional stop time when passing start and stop times separately
  count: Number [optional] - maximum number of events to return

# Find superior conjunction events for an inner planet
let span = range(time(2024,1,1,0,0,0), time(2026,1,1,0,0,0), 5);
print mercury.superior_conjunction(span).first();

Body.opposition

method returns opposition events for this body

Method: Body.opposition - returns opposition events for this body
Syntax:
  <Body>.opposition(time: Time|Range, stop: Time, count: Number) -> List|Event|Nil
Arguments:
  time: Time|Range [optional] - start time for the next event, start/stop times, or time range to search
  stop: Time [optional] - optional stop time when passing start and stop times separately
  count: Number [optional] - maximum number of events to return

# Find opposition events for an explicit body and time range
let span = range(time(2025,1,1,0,0,0), time(2026,1,1,0,0,0), 1);
print mars.opposition(span).first();

Body.eastern_quadrature

method returns eastern quadrature events for this body

Method: Body.eastern_quadrature - returns eastern quadrature events for this body
Syntax:
  <Body>.eastern_quadrature(time: Time|Range, stop: Time, count: Number) -> List|Event|Nil
Arguments:
  time: Time|Range [optional] - start time for the next event, start/stop times, or time range to search
  stop: Time [optional] - optional stop time when passing start and stop times separately
  count: Number [optional] - maximum number of events to return

# Find eastern quadrature events for an outer planet
let span = range(time(2025,1,1,0,0,0), time(2026,1,1,0,0,0), 1);
print mars.eastern_quadrature(span).first();

Body.western_quadrature

method returns western quadrature events for this body

Method: Body.western_quadrature - returns western quadrature events for this body
Syntax:
  <Body>.western_quadrature(time: Time|Range, stop: Time, count: Number) -> List|Event|Nil
Arguments:
  time: Time|Range [optional] - start time for the next event, start/stop times, or time range to search
  stop: Time [optional] - optional stop time when passing start and stop times separately
  count: Number [optional] - maximum number of events to return

# Find western quadrature events for an outer planet
let span = range(time(2025,1,1,0,0,0), time(2026,1,1,0,0,0), 1);
print mars.western_quadrature(span).first();

Body.quadrature

method returns eastern and western quadrature events for this body

Method: Body.quadrature - returns eastern and western quadrature events for this body
Syntax:
  <Body>.quadrature(time: Time|Range, stop: Time, count: Number) -> List|Event|Nil
Arguments:
  time: Time|Range [optional] - start time for the next event, start/stop times, or time range to search
  stop: Time [optional] - optional stop time when passing start and stop times separately
  count: Number [optional] - maximum number of events to return

# Find quadrature events for an explicit body and time range
let span = range(time(2025,1,1,0,0,0), time(2026,1,1,0,0,0), 1);
print mars.quadrature(span).first();

Body.greatest_eastern_elongation

method returns greatest eastern elongation events for this body

Method: Body.greatest_eastern_elongation - returns greatest eastern elongation events for this body
Syntax:
  <Body>.greatest_eastern_elongation(time: Time|Range, stop: Time, count: Number) -> List|Event|Nil
Arguments:
  time: Time|Range [optional] - start time for the next event, start/stop times, or time range to search
  stop: Time [optional] - optional stop time when passing start and stop times separately
  count: Number [optional] - maximum number of events to return

# Find greatest eastern elongation events for an inner planet
let span = range(time(2024,1,1,0,0,0), time(2026,1,1,0,0,0), 5);
print venus.greatest_eastern_elongation(span).first();

Body.greatest_western_elongation

method returns greatest western elongation events for this body

Method: Body.greatest_western_elongation - returns greatest western elongation events for this body
Syntax:
  <Body>.greatest_western_elongation(time: Time|Range, stop: Time, count: Number) -> List|Event|Nil
Arguments:
  time: Time|Range [optional] - start time for the next event, start/stop times, or time range to search
  stop: Time [optional] - optional stop time when passing start and stop times separately
  count: Number [optional] - maximum number of events to return

# Find greatest western elongation events for an inner planet
let span = range(time(2024,1,1,0,0,0), time(2026,1,1,0,0,0), 5);
print venus.greatest_western_elongation(span).first();

Body.greatest_elongation

method returns greatest eastern and western elongation events for this body

Method: Body.greatest_elongation - returns greatest eastern and western elongation events for this body
Syntax:
  <Body>.greatest_elongation(time: Time|Range, stop: Time, count: Number) -> List|Event|Nil
Arguments:
  time: Time|Range [optional] - start time for the next event, start/stop times, or time range to search
  stop: Time [optional] - optional stop time when passing start and stop times separately
  count: Number [optional] - maximum number of events to return

# Find greatest elongation events for an inner planet
let span = range(time(2024,1,1,0,0,0), time(2026,1,1,0,0,0), 5);
print venus.greatest_elongation(span).first();

Body.periapsis

method returns periapsis events for this body

Method: Body.periapsis - returns periapsis events for this body
Syntax:
  <Body>.periapsis(time: Time|Range, stop: Time, count: Number) -> List|Event|Nil
Arguments:
  time: Time|Range [optional] - start time for the next event, start/stop times, or time range to search
  stop: Time [optional] - optional stop time when passing start and stop times separately
  count: Number [optional] - maximum number of events to return

# Find periapsis events for an explicit body and time range
let span = range(time(2024,1,1,0,0,0), time(2024,1,10,0,0,0), 1);
print earth.periapsis(span).first();

Body.apoapsis

method returns apoapsis events for this body

Method: Body.apoapsis - returns apoapsis events for this body
Syntax:
  <Body>.apoapsis(time: Time|Range, stop: Time, count: Number) -> List|Event|Nil
Arguments:
  time: Time|Range [optional] - start time for the next event, start/stop times, or time range to search
  stop: Time [optional] - optional stop time when passing start and stop times separately
  count: Number [optional] - maximum number of events to return

# Find apoapsis events for an explicit body and time range
let span = range(time(2024,7,1,0,0,0), time(2024,7,10,0,0,0), 1);
print earth.apoapsis(span).first();

Body.transit

method returns solar transit events for Mercury or Venus

Method: Body.transit - returns solar transit events for Mercury or Venus
Syntax:
  <Body>.transit(time: Time|Range, stop: Time, count: Number) -> List|Event|Nil
Arguments:
  time: Time|Range [optional] - start time for the next event, start/stop times, or time range to search
  stop: Time [optional] - optional stop time when passing start and stop times separately
  count: Number [optional] - maximum number of events to return

# Find solar transit events for Mercury or Venus
let span = range(time(2032,11,1,0,0,0), time(2032,11,20,0,0,0), 1);
print mercury.transit(span).first();

Body.children

method lists child fields and callable members available on this value

Method: Body.children - lists child fields and callable members available on this value
Syntax:
  <Body>.children() -> List

# Use Body.children on a Body value
let value = sun;
print value.children();

Body.fields

method returns an object containing the value's plain fields

Method: Body.fields - returns an object containing the value's plain fields
Syntax:
  <Body>.fields() -> Object

# Use Body.fields on a Body value
let value = sun;
print value.fields();

Body.functions

method lists callable members available on this value

Method: Body.functions - lists callable members available on this value
Syntax:
  <Body>.functions() -> List

# Use Body.functions on a Body value
let value = sun;
print value.functions();

Bodies

type registry of known solar-system bodies and massive small-body perturbers

Type: Bodies - registry of known solar-system bodies and massive small-body perturbers
Children: count, small_count, find(), planets(), solarSystem(), smallBodies(), longSolarSystem(), all(), categories(), get(), names(), has(), search(), states(), smallBodyStates(), solarSystemStates(), children(), fields(), functions()

# Build a Bodies value and print the result
let value = bodies;
print value;

Bodies.count

field number of currently built-in registry body names

Field: Bodies.count - number of currently built-in registry body names
Syntax:
  <Bodies>.count -> Number

# Read the count field from a Bodies value
print bodies.count;

Bodies.small_count

field number of currently built-in massive small-body perturbers

Field: Bodies.small_count - number of currently built-in massive small-body perturbers
Syntax:
  <Bodies>.small_count -> Number

# Read the small_count field from a Bodies value
print bodies.small_count;

Bodies.find

method finds a body by name, designation, alias, or SPK-style id

Method: Bodies.find - finds a body by name, designation, alias, or SPK-style id
Syntax:
  <Bodies>.find(name: Text) -> Body|Unavailable
Arguments:
  name: Text - body name, designation, alias, or SPK-style id

# Use Bodies.find on a Bodies value
let value = bodies;
print value.find("value");

Bodies.planets

method returns Mercury through Neptune

Method: Bodies.planets - returns Mercury through Neptune
Syntax:
  <Bodies>.planets() -> [Body]

# Use Bodies.planets on a Bodies value
let value = bodies;
print value.planets();

Bodies.solarSystem

method returns Sun, planets, Moon, and Pluto

Method: Bodies.solarSystem - returns Sun, planets, Moon, and Pluto
Syntax:
  <Bodies>.solarSystem() -> [Body]

# Use Bodies.solarSystem on a Bodies value
let value = bodies;
print value.solarSystem();

Bodies.smallBodies

method returns configured massive small-body perturbers, optionally filtered by minimum mass

Method: Bodies.smallBodies - returns configured massive small-body perturbers, optionally filtered by minimum mass
Syntax:
  <Bodies>.smallBodies() -> [Body]
  <Bodies>.smallBodies(min_mass: Number) -> [Body]
Arguments:
  min_mass: Number [optional] - minimum small-body mass in kg

# Use Bodies.smallBodies on a Bodies value
let value = bodies;
print value.smallBodies();

Bodies.longSolarSystem

method returns Sun, planets, Moon, Pluto, and massive small-body perturbers, optionally filtered by minimum mass

Method: Bodies.longSolarSystem - returns Sun, planets, Moon, Pluto, and massive small-body perturbers, optionally filtered by minimum mass
Syntax:
  <Bodies>.longSolarSystem() -> [Body]
  <Bodies>.longSolarSystem(min_mass: Number) -> [Body]
Arguments:
  min_mass: Number [optional] - minimum small-body mass in kg

# Use Bodies.longSolarSystem on a Bodies value
let value = bodies;
print value.longSolarSystem();

Bodies.all

method returns all registry bodies currently available through built-ins and loaded body stores

Method: Bodies.all - returns all registry bodies currently available through built-ins and loaded body stores
Syntax:
  <Bodies>.all() -> [Body]

# Use Bodies.all on a Bodies value
let value = bodies;
print value.all();

Bodies.categories

method lists available body categories

Method: Bodies.categories - lists available body categories
Syntax:
  <Bodies>.categories() -> [Text]

# Use Bodies.categories on a Bodies value
let value = bodies;
print value.categories();

Bodies.get

method returns bodies in a named category

Method: Bodies.get - returns bodies in a named category
Syntax:
  <Bodies>.get(category: Text) -> [Body]
Arguments:
  category: Text - category name such as planets, asteroids, moons, kbos, or comets

# Use Bodies.get on a Bodies value
let value = bodies;
print value.get("value");

Bodies.names

method lists known registry names

Method: Bodies.names - lists known registry names
Syntax:
  <Bodies>.names() -> [Text]

# Use Bodies.names on a Bodies value
let value = bodies;
print value.names();

Bodies.has

method reports whether the body registry can resolve a name

Method: Bodies.has - reports whether the body registry can resolve a name
Syntax:
  <Bodies>.has(name: Text) -> Bool
Arguments:
  name: Text - body name, designation, alias, or SPK-style id

# Use Bodies.has on a Bodies value
let value = bodies;
print value.has("value");

Bodies.search

method searches known registry body names

Method: Bodies.search - searches known registry body names
Syntax:
  <Bodies>.search(query: Text) -> [Body]
Arguments:
  query: Text - case-insensitive body-name fragment

# Use Bodies.search on a Bodies value
let value = bodies;
print value.search("value");

Bodies.states

method returns states for the long Solar System body collection at a time, optionally filtering small bodies by minimum mass

Method: Bodies.states - returns states for the long Solar System body collection at a time, optionally filtering small bodies by minimum mass
Syntax:
  <Bodies>.states(time: Time) -> [State]
  <Bodies>.states(time: Time, min_mass: Number) -> [State]
Arguments:
  time: Time - epoch at which to extract each body state
  min_mass: Number [optional] - minimum small-body mass in kg

# Use Bodies.states on a Bodies value
let value = bodies;
print value.states(time());

Bodies.smallBodyStates

method returns states for configured massive small-body perturbers at a time, optionally filtered by minimum mass

Method: Bodies.smallBodyStates - returns states for configured massive small-body perturbers at a time, optionally filtered by minimum mass
Syntax:
  <Bodies>.smallBodyStates(time: Time) -> [State]
  <Bodies>.smallBodyStates(time: Time, min_mass: Number) -> [State]
Arguments:
  time: Time - epoch at which to extract each body state
  min_mass: Number [optional] - minimum small-body mass in kg

# Use Bodies.smallBodyStates on a Bodies value
let value = bodies;
print value.smallBodyStates(time());

Bodies.solarSystemStates

method returns states for Sun, planets, Moon, and Pluto at a time

Method: Bodies.solarSystemStates - returns states for Sun, planets, Moon, and Pluto at a time
Syntax:
  <Bodies>.solarSystemStates(time: Time) -> [State]
Arguments:
  time: Time - epoch at which to extract each body state

# Use Bodies.solarSystemStates on a Bodies value
let value = bodies;
print value.solarSystemStates(time());

Bodies.children

method lists child fields and callable members available on this value

Method: Bodies.children - lists child fields and callable members available on this value
Syntax:
  <Bodies>.children() -> List

# Use Bodies.children on a Bodies value
let value = bodies;
print value.children();

Bodies.fields

method returns an object containing the value's plain fields

Method: Bodies.fields - returns an object containing the value's plain fields
Syntax:
  <Bodies>.fields() -> Object

# Use Bodies.fields on a Bodies value
let value = bodies;
print value.fields();

Bodies.functions

method lists callable members available on this value

Method: Bodies.functions - lists callable members available on this value
Syntax:
  <Bodies>.functions() -> List

# Use Bodies.functions on a Bodies value
let value = bodies;
print value.functions();

Elements

type osculating orbital elements using periapsis distance as the primary distance

Type: Elements - osculating orbital elements using periapsis distance as the primary distance
Syntax:
  elements(q: Number, e: Number, i: Number, node: Number, argument: Number, anomaly: Number, unit: Unit) -> Elements
Arguments:
  q: Number - periapsis distance in kilometers
  e: Number - eccentricity
  i: Number - inclination in degrees by default
  node: Number - longitude of ascending node in degrees by default
  argument: Number - argument of periapsis in degrees by default
  anomaly: Number - true anomaly in degrees by default
  unit: Unit [optional] - optional angle unit, such as rad
Children: q, e, i, node, argument, anomaly, semimajor_axis, semi_latus_rectum, children(), fields(), functions()

# Derive osculating elements from an Earth state around the Sun
let t = time(2026,1,1,0,0,0);
let earth_state = state(earth, t, barycentric, icrf, no_correction);
let sun_state = state(sun, t, barycentric, icrf, no_correction);
let orbit = earth_state.orbit_around(sun_state);
let el = orbit.elements();
print el.q, el.e, el.i;

Elements.q

field periapsis distance in kilometers

Field: Elements.q - periapsis distance in kilometers
Syntax:
  <Elements>.q -> Number

# Read the q field from a Elements value
print elements(7000.0, 0.01, 5.0, 40.0, 80.0, 120.0).q;

Elements.e

field eccentricity

Field: Elements.e - eccentricity
Syntax:
  <Elements>.e -> Number

# Read the e field from a Elements value
print elements(7000.0, 0.01, 5.0, 40.0, 80.0, 120.0).e;

Elements.i

field inclination in degrees

Field: Elements.i - inclination in degrees
Syntax:
  <Elements>.i -> Number

# Read the i field from a Elements value
print elements(7000.0, 0.01, 5.0, 40.0, 80.0, 120.0).i;

Elements.node

field longitude of ascending node in degrees

Field: Elements.node - longitude of ascending node in degrees
Syntax:
  <Elements>.node -> Number

# Read the node field from a Elements value
print elements(7000.0, 0.01, 5.0, 40.0, 80.0, 120.0).node;

Elements.argument

field argument of periapsis in degrees

Field: Elements.argument - argument of periapsis in degrees
Syntax:
  <Elements>.argument -> Number

# Read the argument field from a Elements value
print elements(7000.0, 0.01, 5.0, 40.0, 80.0, 120.0).argument;

Elements.anomaly

field true anomaly in degrees

Field: Elements.anomaly - true anomaly in degrees
Syntax:
  <Elements>.anomaly -> Number

# Read the anomaly field from a Elements value
print elements(7000.0, 0.01, 5.0, 40.0, 80.0, 120.0).anomaly;

Elements.semimajor_axis

field derived semimajor axis in kilometers when available

Field: Elements.semimajor_axis - derived semimajor axis in kilometers when available
Syntax:
  <Elements>.semimajor_axis -> Number

# Read the semimajor_axis field from a Elements value
print elements(7000.0, 0.01, 5.0, 40.0, 80.0, 120.0).semimajor_axis;

Elements.semi_latus_rectum

field derived semi-latus rectum in kilometers when available

Field: Elements.semi_latus_rectum - derived semi-latus rectum in kilometers when available
Syntax:
  <Elements>.semi_latus_rectum -> Number

# Read the semi_latus_rectum field from a Elements value
print elements(7000.0, 0.01, 5.0, 40.0, 80.0, 120.0).semi_latus_rectum;

Elements.children

method lists child fields and callable members available on this value

Method: Elements.children - lists child fields and callable members available on this value
Syntax:
  <Elements>.children() -> List

# Use Elements.children on a Elements value
let value = elements(7000.0, 0.01, 5.0, 40.0, 80.0, 120.0);
print value.children();

Elements.fields

method returns an object containing the value's plain fields

Method: Elements.fields - returns an object containing the value's plain fields
Syntax:
  <Elements>.fields() -> Object

# Use Elements.fields on a Elements value
let value = elements(7000.0, 0.01, 5.0, 40.0, 80.0, 120.0);
print value.fields();

Elements.functions

method lists callable members available on this value

Method: Elements.functions - lists callable members available on this value
Syntax:
  <Elements>.functions() -> List

# Use Elements.functions on a Elements value
let value = elements(7000.0, 0.01, 5.0, 40.0, 80.0, 120.0);
print value.functions();

Orbit

type two-body orbit backed by osculating elements or a relative state vector

Type: Orbit - two-body orbit backed by osculating elements or a relative state vector
Syntax:
  orbit(elements: Elements, central: Body, time: Time, axis: Axis) -> Orbit
Arguments:
  elements: Elements - osculating elements at the epoch
  central: Body - central gravitating body
  time: Time - epoch time
  axis: Axis [optional] - non-rotating element axis, icrf by default; tod is also accepted
Children: body, central, time, epoch, axis, elements, position, velocity, conic, position(), velocity(), at(), elements(), predict(), children(), fields(), functions()

# Propagate an elliptic orbit forward and print the new radius
let epoch = time(2026,1,1,0,0,0);
let el = elements(q: 7000, e: 0.1, i: 30, node: 40, argument: 50, anomaly: 0, unit: deg);
let orbit0 = orbit(el, earth, epoch);
let orbit1 = orbit0.at(epoch.add_hours(6));
print orbit0.position().length(), orbit1.position().length();

Orbit.body

field orbiting body when the orbit came from ephemeris states

Field: Orbit.body - orbiting body when the orbit came from ephemeris states
Syntax:
  <Orbit>.body -> Body

# Read the body field from a Orbit value
print orbit(elements(7000.0, 0.01, 5.0, 40.0, 80.0, 120.0), earth, time()).body;

Orbit.central

field central gravitating body

Field: Orbit.central - central gravitating body
Syntax:
  <Orbit>.central -> Body

# Read the central field from a Orbit value
print orbit(elements(7000.0, 0.01, 5.0, 40.0, 80.0, 120.0), earth, time()).central;

Orbit.time

field epoch time

Field: Orbit.time - epoch time
Syntax:
  <Orbit>.time -> Time

# Read the time field from a Orbit value
print orbit(elements(7000.0, 0.01, 5.0, 40.0, 80.0, 120.0), earth, time()).time;

Orbit.epoch

field epoch time

Field: Orbit.epoch - epoch time
Syntax:
  <Orbit>.epoch -> Time

# Read the epoch field from a Orbit value
print orbit(elements(7000.0, 0.01, 5.0, 40.0, 80.0, 120.0), earth, time()).epoch;

Orbit.axis

field axis used for the osculating elements and relative state vectors

Field: Orbit.axis - axis used for the osculating elements and relative state vectors
Syntax:
  <Orbit>.axis -> Axis

# Read the axis field from a Orbit value
print orbit(elements(7000.0, 0.01, 5.0, 40.0, 80.0, 120.0), earth, time()).axis;

Orbit.elements

field osculating elements at the orbit epoch

Field: Orbit.elements - osculating elements at the orbit epoch
Syntax:
  <Orbit>.elements -> Elements

# Read the elements field from a Orbit value
print orbit(elements(7000.0, 0.01, 5.0, 40.0, 80.0, 120.0), earth, time()).elements;

Orbit.position

field relative position vector at the orbit epoch

Field: Orbit.position - relative position vector at the orbit epoch
Syntax:
  <Orbit>.position -> Vector

# Read the position field from a Orbit value
print orbit(elements(7000.0, 0.01, 5.0, 40.0, 80.0, 120.0), earth, time()).position;

Orbit.velocity

field relative velocity vector at the orbit epoch

Field: Orbit.velocity - relative velocity vector at the orbit epoch
Syntax:
  <Orbit>.velocity -> Vector

# Read the velocity field from a Orbit value
print orbit(elements(7000.0, 0.01, 5.0, 40.0, 80.0, 120.0), earth, time()).velocity;

Orbit.conic

field elliptic, parabolic, or hyperbolic conic class

Field: Orbit.conic - elliptic, parabolic, or hyperbolic conic class
Syntax:
  <Orbit>.conic -> Text

# Read the conic field from a Orbit value
print orbit(elements(7000.0, 0.01, 5.0, 40.0, 80.0, 120.0), earth, time()).conic;

Orbit.position

method returns orbit-relative position

Method: Orbit.position - returns orbit-relative position
Syntax:
  <Orbit>.position(time: Time) -> Vector
Arguments:
  time: Time [optional] - time to propagate to; defaults to the orbit epoch

# Use Orbit.position on a Orbit value
let value = orbit(elements(7000.0, 0.01, 5.0, 40.0, 80.0, 120.0), earth, time());
print value.position();

Orbit.velocity

method returns orbit-relative velocity

Method: Orbit.velocity - returns orbit-relative velocity
Syntax:
  <Orbit>.velocity(time: Time) -> Vector
Arguments:
  time: Time [optional] - time to propagate to; defaults to the orbit epoch

# Use Orbit.velocity on a Orbit value
let value = orbit(elements(7000.0, 0.01, 5.0, 40.0, 80.0, 120.0), earth, time());
print value.velocity();

Orbit.at

method propagates the orbit to a new time

Method: Orbit.at - propagates the orbit to a new time
Syntax:
  <Orbit>.at(time: Time) -> Orbit
Arguments:
  time: Time - time to propagate to

# Use Orbit.at on a Orbit value
let value = orbit(elements(7000.0, 0.01, 5.0, 40.0, 80.0, 120.0), earth, time());
print value.at(time());

Orbit.elements

method returns osculating elements

Method: Orbit.elements - returns osculating elements
Syntax:
  <Orbit>.elements() -> Elements

# Use Orbit.elements on a Orbit value
let value = orbit(elements(7000.0, 0.01, 5.0, 40.0, 80.0, 120.0), earth, time());
print value.elements();

Orbit.predict

method predicts a sky direction from this orbit

Method: Orbit.predict - predicts a sky direction from this orbit
Syntax:
  <Orbit>.predict(time: Time, observer: Observer) -> Direction
Arguments:
  time: Time - prediction time
  observer: Observer - observing site

# Use Orbit.predict on a Orbit value
let value = orbit(elements(7000.0, 0.01, 5.0, 40.0, 80.0, 120.0), earth, time());
print value.predict(time(), location(latitude: 60.0, longitude: 270.0).observer(height: 1.5));

Orbit.children

method lists child fields and callable members available on this value

Method: Orbit.children - lists child fields and callable members available on this value
Syntax:
  <Orbit>.children() -> List

# Use Orbit.children on a Orbit value
let value = orbit(elements(7000.0, 0.01, 5.0, 40.0, 80.0, 120.0), earth, time());
print value.children();

Orbit.fields

method returns an object containing the value's plain fields

Method: Orbit.fields - returns an object containing the value's plain fields
Syntax:
  <Orbit>.fields() -> Object

# Use Orbit.fields on a Orbit value
let value = orbit(elements(7000.0, 0.01, 5.0, 40.0, 80.0, 120.0), earth, time());
print value.fields();

Orbit.functions

method lists callable members available on this value

Method: Orbit.functions - lists callable members available on this value
Syntax:
  <Orbit>.functions() -> List

# Use Orbit.functions on a Orbit value
let value = orbit(elements(7000.0, 0.01, 5.0, 40.0, 80.0, 120.0), earth, time());
print value.functions();

System

type immutable orbit propagation system with shared snapshot cache

Type: System - immutable orbit propagation system with shared snapshot cache
Syntax:
  system(epoch: Time, bodies: Body|State|Orbit|Text|List, integrator: Text) -> System
Arguments:
  epoch: Time - system epoch
  bodies: Body|State|Orbit|Text|List - system entries: explicit states, body-backed orbits, or ephemeris bodies
  integrator: Text [optional] - optional integrator: "ias15", "dp5", or "rk4"; "dp5" is slow and mainly for debugging/reference comparisons
Children: time, bodies, states, sources, source_counts, integrator, method, ephemeris_coverage, diagnostics, ephemeris_residuals, positions, velocities, integrated, ephemeris, cache_size, at(), cache(), clear_cache(), state(), position(), velocity(), distance(), children(), fields(), functions()

# Build a System value and print the result
let value = system(time(2026, 7, 4), earth, moon, sun);
print value;

System.time

field snapshot time

Field: System.time - snapshot time
Syntax:
  <System>.time -> Time

# Read the time field from a System value
print system(time(2026, 7, 4), earth, moon, sun).time;

System.bodies

field bodies in the system

Field: System.bodies - bodies in the system
Syntax:
  <System>.bodies -> List

# Read the bodies field from a System value
print system(time(2026, 7, 4), earth, moon, sun).bodies;

System.states

field states at the snapshot time

Field: System.states - states at the snapshot time
Syntax:
  <System>.states -> List

# Read the states field from a System value
print system(time(2026, 7, 4), earth, moon, sun).states;

System.sources

field per-body source names

Field: System.sources - per-body source names
Syntax:
  <System>.sources -> Object

# Read the sources field from a System value
print system(time(2026, 7, 4), earth, moon, sun).sources;

System.source_counts

field counts of integrated and ephemeris-derived bodies

Field: System.source_counts - counts of integrated and ephemeris-derived bodies
Syntax:
  <System>.source_counts -> Object

# Read the source_counts field from a System value
print system(time(2026, 7, 4), earth, moon, sun).source_counts;

System.integrator

field numerical integrator name; dp5 is a slow reference/debug method

Field: System.integrator - numerical integrator name; dp5 is a slow reference/debug method
Syntax:
  <System>.integrator -> Text

# Read the integrator field from a System value
print system(time(2026, 7, 4), earth, moon, sun).integrator;

System.method

field alias for integrator

Field: System.method - alias for integrator
Syntax:
  <System>.method -> Text

# Read the method field from a System value
print system(time(2026, 7, 4), earth, moon, sun).method;

System.ephemeris_coverage

field whether this snapshot time is covered by the loaded ephemeris

Field: System.ephemeris_coverage - whether this snapshot time is covered by the loaded ephemeris
Syntax:
  <System>.ephemeris_coverage -> Text

# Read the ephemeris_coverage field from a System value
print system(time(2026, 7, 4), earth, moon, sun).ephemeris_coverage;

System.diagnostics

field last propagation diagnostics: steps, rejections, and derivative evaluations

Field: System.diagnostics - last propagation diagnostics: steps, rejections, and derivative evaluations
Syntax:
  <System>.diagnostics -> Object

# Read the diagnostics field from a System value
print system(time(2026, 7, 4), earth, moon, sun).diagnostics;

System.ephemeris_residuals

field per-body position residuals in kilometers against ephemeris at covered times

Field: System.ephemeris_residuals - per-body position residuals in kilometers against ephemeris at covered times
Syntax:
  <System>.ephemeris_residuals -> Object

# Read the ephemeris_residuals field from a System value
print system(time(2026, 7, 4), earth, moon, sun).ephemeris_residuals;

System.positions

field per-body barycentric ICRF positions

Field: System.positions - per-body barycentric ICRF positions
Syntax:
  <System>.positions -> Object

# Read the positions field from a System value
print system(time(2026, 7, 4), earth, moon, sun).positions;

System.velocities

field per-body barycentric ICRF velocities

Field: System.velocities - per-body barycentric ICRF velocities
Syntax:
  <System>.velocities -> Object

# Read the velocities field from a System value
print system(time(2026, 7, 4), earth, moon, sun).velocities;

System.integrated

field names of currently integrated system bodies

Field: System.integrated - names of currently integrated system bodies
Syntax:
  <System>.integrated -> List

# Read the integrated field from a System value
print system(time(2026, 7, 4), earth, moon, sun).integrated;

System.ephemeris

field names of ephemeris-derived system bodies

Field: System.ephemeris - names of ephemeris-derived system bodies
Syntax:
  <System>.ephemeris -> List

# Read the ephemeris field from a System value
print system(time(2026, 7, 4), earth, moon, sun).ephemeris;

System.cache_size

field number of cached snapshot checkpoints

Field: System.cache_size - number of cached snapshot checkpoints
Syntax:
  <System>.cache_size -> Number

# Read the cache_size field from a System value
print system(time(2026, 7, 4), earth, moon, sun).cache_size;

System.at

method returns a system snapshot at a time

Method: System.at - returns a system snapshot at a time
Syntax:
  <System>.at(time: Time) -> System
Arguments:
  time: Time - snapshot time

# Use System.at on a System value
let value = system(time(2026, 7, 4), earth, moon, sun);
print value.at(time());

System.cache

method returns a system snapshot and marks it as a cache checkpoint

Method: System.cache - returns a system snapshot and marks it as a cache checkpoint
Syntax:
  <System>.cache(time: Time) -> System
Arguments:
  time: Time - checkpoint time

# Use System.cache on a System value
let value = system(time(2026, 7, 4), earth, moon, sun);
print value.cache(time());

System.clear_cache

method clears cached system checkpoints without changing the system definition

Method: System.clear_cache - clears cached system checkpoints without changing the system definition
Syntax:
  <System>.clear_cache() -> System

# Use System.clear_cache on a System value
let value = system(time(2026, 7, 4), earth, moon, sun);
print value.clear_cache();

System.state

method returns states from this system snapshot

Method: System.state - returns states from this system snapshot
Syntax:
  <System>.state() -> List
  <System>.state(body: Body|Text) -> State
Arguments:
  body: Body|Text [optional] - body or system object name

# Use System.state on a System value
let value = system(time(2026, 7, 4), earth, moon, sun);
print value.state();

System.position

method returns a named body's snapshot position

Method: System.position - returns a named body's snapshot position
Syntax:
  <System>.position(body: Body|Text) -> Vector
Arguments:
  body: Body|Text - body or system object name

# Use System.position on a System value
let value = system(time(2026, 7, 4), earth, moon, sun);
print value.position(sun);

System.velocity

method returns a named body's snapshot velocity

Method: System.velocity - returns a named body's snapshot velocity
Syntax:
  <System>.velocity(body: Body|Text) -> Vector
Arguments:
  body: Body|Text - body or system object name

# Use System.velocity on a System value
let value = system(time(2026, 7, 4), earth, moon, sun);
print value.velocity(sun);

System.distance

method returns the distance between two system bodies

Method: System.distance - returns the distance between two system bodies
Syntax:
  <System>.distance(a: Body|Text, b: Body|Text) -> Number
Arguments:
  a: Body|Text - first body or system object name
  b: Body|Text - second body or system object name

# Use System.distance on a System value
let value = system(time(2026, 7, 4), earth, moon, sun);
print value.distance(sun, sun);

System.children

method lists child fields and callable members available on this value

Method: System.children - lists child fields and callable members available on this value
Syntax:
  <System>.children() -> List

# Use System.children on a System value
let value = system(time(2026, 7, 4), earth, moon, sun);
print value.children();

System.fields

method returns an object containing the value's plain fields

Method: System.fields - returns an object containing the value's plain fields
Syntax:
  <System>.fields() -> Object

# Use System.fields on a System value
let value = system(time(2026, 7, 4), earth, moon, sun);
print value.fields();

System.functions

method lists callable members available on this value

Method: System.functions - lists callable members available on this value
Syntax:
  <System>.functions() -> List

# Use System.functions on a System value
let value = system(time(2026, 7, 4), earth, moon, sun);
print value.functions();

Observation

type measured sky direction or target elevation observation

Type: Observation - measured sky direction or target elevation observation
Syntax:
  observation(observer: Observer, time: Time, direction: Direction|State, frame: Frame) -> Observation
  observation(target: Body|Star, time: Time, elevation: Number) -> Observation
Arguments:
  observer: Observer [optional] - observing site
  time: Time - observation time
  direction: Direction|State [optional] - measured line of sight, or a state whose position gives the line of sight
  frame: Frame [optional] - coordinate frame for RA/Dec shorthand or state conversion; defaults to icrf
  target: Body|Star [optional] - observed planet, Moon, Sun, or star
  elevation: Number [optional] - measured elevation above the horizon in degrees
Children: observer, time, direction, target, elevation, uncertainty, weight, label, icrf(), topographic(), with_uncertainty(), with_weight(), children(), fields(), functions()

# Build a Observation value and print the result
let value = observation(observer(location(59.91,10.75)), time(2026,7,3), direction(ra:120.1, dec:22.4));
print value;

Observation.observer

field observing site, when this is a direction observation

Field: Observation.observer - observing site, when this is a direction observation
Syntax:
  <Observation>.observer -> Observer?

# Read the observer field from a Observation value
print observation(observer(location(59.91,10.75)), time(2026,7,3), direction(ra:120.1, dec:22.4)).observer;

Observation.time

field observation time

Field: Observation.time - observation time
Syntax:
  <Observation>.time -> Time

# Read the time field from a Observation value
print observation(observer(location(59.91,10.75)), time(2026,7,3), direction(ra:120.1, dec:22.4)).time;

Observation.direction

field measured direction, when this is a direction observation

Field: Observation.direction - measured direction, when this is a direction observation
Syntax:
  <Observation>.direction -> Direction?

# Read the direction field from a Observation value
print observation(observer(location(59.91,10.75)), time(2026,7,3), direction(ra:120.1, dec:22.4)).direction;

Observation.target

field observed body or star, when this is an elevation observation

Field: Observation.target - observed body or star, when this is an elevation observation
Syntax:
  <Observation>.target -> Body|Star?

# Read the target field from a Observation value
print observation(observer(location(59.91,10.75)), time(2026,7,3), direction(ra:120.1, dec:22.4)).target;

Observation.elevation

field measured target elevation in degrees, when this is an elevation observation

Field: Observation.elevation - measured target elevation in degrees, when this is an elevation observation
Syntax:
  <Observation>.elevation -> Number?

# Read the elevation field from a Observation value
print observation(observer(location(59.91,10.75)), time(2026,7,3), direction(ra:120.1, dec:22.4)).elevation;

Observation.uncertainty

field direction uncertainty in arcseconds

Field: Observation.uncertainty - direction uncertainty in arcseconds
Syntax:
  <Observation>.uncertainty -> Number?

# Read the uncertainty field from a Observation value
print observation(observer(location(59.91,10.75)), time(2026,7,3), direction(ra:120.1, dec:22.4)).uncertainty;

Observation.weight

field least-squares weight

Field: Observation.weight - least-squares weight
Syntax:
  <Observation>.weight -> Number?

# Read the weight field from a Observation value
print observation(observer(location(59.91,10.75)), time(2026,7,3), direction(ra:120.1, dec:22.4)).weight;

Observation.label

field optional observation label

Field: Observation.label - optional observation label
Syntax:
  <Observation>.label -> Text?

# Read the label field from a Observation value
print observation(observer(location(59.91,10.75)), time(2026,7,3), direction(ra:120.1, dec:22.4)).label;

Observation.icrf

method converts the observation direction to ICRF

Method: Observation.icrf - converts the observation direction to ICRF
Syntax:
  <Observation>.icrf() -> Direction

# Use Observation.icrf on a Observation value
let value = observation(observer(location(59.91,10.75)), time(2026,7,3), direction(ra:120.1, dec:22.4));
print value.icrf();

Observation.topographic

method converts the observation direction to topographic axes

Method: Observation.topographic - converts the observation direction to topographic axes
Syntax:
  <Observation>.topographic() -> Direction

# Read an observation line of sight in local topographic axes
let obs = location(latitude: 59.91, longitude: 10.75).observer(height: 0);
let dir = direction(topographic, azimuth: 120.0, altitude: 25.0);
let value = observation(obs, time(2026,7,3), dir);
print value.topographic();

Observation.with_uncertainty

method sets observation uncertainty

Method: Observation.with_uncertainty - sets observation uncertainty
Syntax:
  <Observation>.with_uncertainty(arcsec: Number) -> Observation
Arguments:
  arcsec: Number - one-sigma uncertainty in arcseconds

# Use Observation.with_uncertainty on a Observation value
let value = observation(observer(location(59.91,10.75)), time(2026,7,3), direction(ra:120.1, dec:22.4));
print value.with_uncertainty(42.0);

Observation.with_weight

method sets observation weight

Method: Observation.with_weight - sets observation weight
Syntax:
  <Observation>.with_weight(weight: Number) -> Observation
Arguments:
  weight: Number - relative observation weight

# Use Observation.with_weight on a Observation value
let value = observation(observer(location(59.91,10.75)), time(2026,7,3), direction(ra:120.1, dec:22.4));
print value.with_weight(42.0);

Observation.children

method lists child fields and callable members available on this value

Method: Observation.children - lists child fields and callable members available on this value
Syntax:
  <Observation>.children() -> List

# Use Observation.children on a Observation value
let value = observation(observer(location(59.91,10.75)), time(2026,7,3), direction(ra:120.1, dec:22.4));
print value.children();

Observation.fields

method returns an object containing the value's plain fields

Method: Observation.fields - returns an object containing the value's plain fields
Syntax:
  <Observation>.fields() -> Object

# Use Observation.fields on a Observation value
let value = observation(observer(location(59.91,10.75)), time(2026,7,3), direction(ra:120.1, dec:22.4));
print value.fields();

Observation.functions

method lists callable members available on this value

Method: Observation.functions - lists callable members available on this value
Syntax:
  <Observation>.functions() -> List

# Use Observation.functions on a Observation value
let value = observation(observer(location(59.91,10.75)), time(2026,7,3), direction(ra:120.1, dec:22.4));
print value.functions();

OrbitSolution

type orbit determination result with orbit, residuals, and fit quality

Type: OrbitSolution - orbit determination result with orbit, residuals, and fit quality
Syntax:
  orbit_determination(observations: List<Observation>) -> OrbitSolution
Arguments:
  observations: List<Observation> - three or more observations
Children: orbit, elements, observations, residuals, rms, max_residual, method, status, iterations, predict(), residuals(), children(), fields(), functions()

# Build a OrbitSolution value and print the result
let value = orbit_determination([observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,7,3),ra:131.0857742519269,dec:18.803678151005595),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,7,23),ra:135.0300892722528,dec:18.040162341691612),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,8,12),ra:139.04202357010908,dec:17.175191580463146),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,9,1),ra:142.9726130958044,dec:16.26645304942825),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,9,21),ra:146.67383907727944,dec:15.384398529605518)],central:sun);
print value;

OrbitSolution.orbit

field determined two-body orbit

Field: OrbitSolution.orbit - determined two-body orbit
Syntax:
  <OrbitSolution>.orbit -> Orbit

# Read the orbit field from a OrbitSolution value
print orbit_determination([observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,7,3),ra:131.0857742519269,dec:18.803678151005595),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,7,23),ra:135.0300892722528,dec:18.040162341691612),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,8,12),ra:139.04202357010908,dec:17.175191580463146),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,9,1),ra:142.9726130958044,dec:16.26645304942825),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,9,21),ra:146.67383907727944,dec:15.384398529605518)],central:sun).orbit;

OrbitSolution.elements

field osculating elements for the determined orbit

Field: OrbitSolution.elements - osculating elements for the determined orbit
Syntax:
  <OrbitSolution>.elements -> Elements

# Read the elements field from a OrbitSolution value
print orbit_determination([observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,7,3),ra:131.0857742519269,dec:18.803678151005595),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,7,23),ra:135.0300892722528,dec:18.040162341691612),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,8,12),ra:139.04202357010908,dec:17.175191580463146),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,9,1),ra:142.9726130958044,dec:16.26645304942825),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,9,21),ra:146.67383907727944,dec:15.384398529605518)],central:sun).elements;

OrbitSolution.observations

field observations used for the determination

Field: OrbitSolution.observations - observations used for the determination
Syntax:
  <OrbitSolution>.observations -> List<Observation>

# Read the observations field from a OrbitSolution value
print orbit_determination([observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,7,3),ra:131.0857742519269,dec:18.803678151005595),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,7,23),ra:135.0300892722528,dec:18.040162341691612),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,8,12),ra:139.04202357010908,dec:17.175191580463146),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,9,1),ra:142.9726130958044,dec:16.26645304942825),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,9,21),ra:146.67383907727944,dec:15.384398529605518)],central:sun).observations;

OrbitSolution.residuals

field per-observation residual objects

Field: OrbitSolution.residuals - per-observation residual objects
Syntax:
  <OrbitSolution>.residuals -> List<Object>

# Read the residuals field from a OrbitSolution value
print orbit_determination([observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,7,3),ra:131.0857742519269,dec:18.803678151005595),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,7,23),ra:135.0300892722528,dec:18.040162341691612),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,8,12),ra:139.04202357010908,dec:17.175191580463146),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,9,1),ra:142.9726130958044,dec:16.26645304942825),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,9,21),ra:146.67383907727944,dec:15.384398529605518)],central:sun).residuals;

OrbitSolution.rms

field RMS angular residual in arcseconds

Field: OrbitSolution.rms - RMS angular residual in arcseconds
Syntax:
  <OrbitSolution>.rms -> Number

# Read the rms field from a OrbitSolution value
print orbit_determination([observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,7,3),ra:131.0857742519269,dec:18.803678151005595),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,7,23),ra:135.0300892722528,dec:18.040162341691612),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,8,12),ra:139.04202357010908,dec:17.175191580463146),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,9,1),ra:142.9726130958044,dec:16.26645304942825),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,9,21),ra:146.67383907727944,dec:15.384398529605518)],central:sun).rms;

OrbitSolution.max_residual

field largest angular residual in arcseconds

Field: OrbitSolution.max_residual - largest angular residual in arcseconds
Syntax:
  <OrbitSolution>.max_residual -> Number

# Read the max_residual field from a OrbitSolution value
print orbit_determination([observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,7,3),ra:131.0857742519269,dec:18.803678151005595),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,7,23),ra:135.0300892722528,dec:18.040162341691612),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,8,12),ra:139.04202357010908,dec:17.175191580463146),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,9,1),ra:142.9726130958044,dec:16.26645304942825),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,9,21),ra:146.67383907727944,dec:15.384398529605518)],central:sun).max_residual;

OrbitSolution.method

field solver method used

Field: OrbitSolution.method - solver method used
Syntax:
  <OrbitSolution>.method -> Text

# Read the method field from a OrbitSolution value
print orbit_determination([observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,7,3),ra:131.0857742519269,dec:18.803678151005595),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,7,23),ra:135.0300892722528,dec:18.040162341691612),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,8,12),ra:139.04202357010908,dec:17.175191580463146),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,9,1),ra:142.9726130958044,dec:16.26645304942825),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,9,21),ra:146.67383907727944,dec:15.384398529605518)],central:sun).method;

OrbitSolution.status

field solver status

Field: OrbitSolution.status - solver status
Syntax:
  <OrbitSolution>.status -> Text

# Read the status field from a OrbitSolution value
print orbit_determination([observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,7,3),ra:131.0857742519269,dec:18.803678151005595),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,7,23),ra:135.0300892722528,dec:18.040162341691612),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,8,12),ra:139.04202357010908,dec:17.175191580463146),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,9,1),ra:142.9726130958044,dec:16.26645304942825),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,9,21),ra:146.67383907727944,dec:15.384398529605518)],central:sun).status;

OrbitSolution.iterations

field differential-correction iterations performed

Field: OrbitSolution.iterations - differential-correction iterations performed
Syntax:
  <OrbitSolution>.iterations -> Number

# Read the iterations field from a OrbitSolution value
print orbit_determination([observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,7,3),ra:131.0857742519269,dec:18.803678151005595),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,7,23),ra:135.0300892722528,dec:18.040162341691612),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,8,12),ra:139.04202357010908,dec:17.175191580463146),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,9,1),ra:142.9726130958044,dec:16.26645304942825),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,9,21),ra:146.67383907727944,dec:15.384398529605518)],central:sun).iterations;

OrbitSolution.predict

method predicts a direction from the determined orbit

Method: OrbitSolution.predict - predicts a direction from the determined orbit
Syntax:
  <OrbitSolution>.predict(time: Time, observer: Observer) -> Direction
Arguments:
  time: Time - prediction time
  observer: Observer - observing site

# Use OrbitSolution.predict on a OrbitSolution value
let value = orbit_determination([observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,7,3),ra:131.0857742519269,dec:18.803678151005595),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,7,23),ra:135.0300892722528,dec:18.040162341691612),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,8,12),ra:139.04202357010908,dec:17.175191580463146),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,9,1),ra:142.9726130958044,dec:16.26645304942825),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,9,21),ra:146.67383907727944,dec:15.384398529605518)],central:sun);
print value.predict(time(), location(latitude: 60.0, longitude: 270.0).observer(height: 1.5));

OrbitSolution.residuals

method returns per-observation residuals

Method: OrbitSolution.residuals - returns per-observation residuals
Syntax:
  <OrbitSolution>.residuals() -> List<Object>

# Use OrbitSolution.residuals on a OrbitSolution value
let value = orbit_determination([observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,7,3),ra:131.0857742519269,dec:18.803678151005595),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,7,23),ra:135.0300892722528,dec:18.040162341691612),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,8,12),ra:139.04202357010908,dec:17.175191580463146),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,9,1),ra:142.9726130958044,dec:16.26645304942825),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,9,21),ra:146.67383907727944,dec:15.384398529605518)],central:sun);
print value.residuals();

OrbitSolution.children

method lists child fields and callable members available on this value

Method: OrbitSolution.children - lists child fields and callable members available on this value
Syntax:
  <OrbitSolution>.children() -> List

# Use OrbitSolution.children on a OrbitSolution value
let value = orbit_determination([observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,7,3),ra:131.0857742519269,dec:18.803678151005595),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,7,23),ra:135.0300892722528,dec:18.040162341691612),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,8,12),ra:139.04202357010908,dec:17.175191580463146),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,9,1),ra:142.9726130958044,dec:16.26645304942825),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,9,21),ra:146.67383907727944,dec:15.384398529605518)],central:sun);
print value.children();

OrbitSolution.fields

method returns an object containing the value's plain fields

Method: OrbitSolution.fields - returns an object containing the value's plain fields
Syntax:
  <OrbitSolution>.fields() -> Object

# Use OrbitSolution.fields on a OrbitSolution value
let value = orbit_determination([observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,7,3),ra:131.0857742519269,dec:18.803678151005595),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,7,23),ra:135.0300892722528,dec:18.040162341691612),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,8,12),ra:139.04202357010908,dec:17.175191580463146),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,9,1),ra:142.9726130958044,dec:16.26645304942825),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,9,21),ra:146.67383907727944,dec:15.384398529605518)],central:sun);
print value.fields();

OrbitSolution.functions

method lists callable members available on this value

Method: OrbitSolution.functions - lists callable members available on this value
Syntax:
  <OrbitSolution>.functions() -> List

# Use OrbitSolution.functions on a OrbitSolution value
let value = orbit_determination([observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,7,3),ra:131.0857742519269,dec:18.803678151005595),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,7,23),ra:135.0300892722528,dec:18.040162341691612),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,8,12),ra:139.04202357010908,dec:17.175191580463146),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,9,1),ra:142.9726130958044,dec:16.26645304942825),observation(location(latitude:59.91,longitude:10.75).observer(height:0),time(2028,9,21),ra:146.67383907727944,dec:15.384398529605518)],central:sun);
print value.functions();

Shadow

type instantaneous sunlight shadow geometry for one body on another

Type: Shadow - instantaneous sunlight shadow geometry for one body on another
Syntax:
  shadow() -> Shadow
Children: surface, blocker, source, time, sample(), occultation(), distance(), polygon(), limb(), children(), fields(), functions()

# Compute a Moon shadow state on Earth
let t = time(2024,4,8,18,40,0);
let sh = state(earth, t).shadow(moon);
print sh.surface.name, sh.blocker.name, sh.distance();

Shadow.surface

field body receiving the shadow

Field: Shadow.surface - body receiving the shadow
Syntax:
  <Shadow>.surface -> Body

# Read the surface field from a Shadow value
print state(earth, time(2024,4,8,18,40,0)).shadow(moon).surface;

Shadow.blocker

field body casting the shadow

Field: Shadow.blocker - body casting the shadow
Syntax:
  <Shadow>.blocker -> Body

# Read the blocker field from a Shadow value
print state(earth, time(2024,4,8,18,40,0)).shadow(moon).blocker;

Shadow.source

field light source; currently the Sun

Field: Shadow.source - light source; currently the Sun
Syntax:
  <Shadow>.source -> Body

# Read the source field from a Shadow value
print state(earth, time(2024,4,8,18,40,0)).shadow(moon).source;

Shadow.time

field time of the shadow geometry

Field: Shadow.time - time of the shadow geometry
Syntax:
  <Shadow>.time -> Time

# Read the time field from a Shadow value
print state(earth, time(2024,4,8,18,40,0)).shadow(moon).time;

Shadow.sample

method samples this shadow at a location or observer

Method: Shadow.sample - samples this shadow at a location or observer
Syntax:
  <Shadow>.sample(location: Location|Observer) -> Object
Arguments:
  location: Location|Observer - surface location or observer to sample

# Sample this shadow at an explicit observer
let t = time(2024,4,8,18,40,0);
let obs = location(latitude: 32.7767, longitude: -96.7970).observer();
let sh = state(earth, t).shadow(moon);
print sh.sample(obs);

Shadow.occultation

method returns a low-level local solar-disc occultation scalar

Method: Shadow.occultation - returns a low-level local solar-disc occultation scalar
Syntax:
  <Shadow>.occultation(location: Location|Observer, lunar_limb: List) -> Number
Arguments:
  location: Location|Observer - surface location or observer to evaluate
  lunar_limb: List [optional] - optional precomputed lunar limb profile from `state(moon,time).limb(...)`

# Use Shadow.occultation on a Shadow value
let value = state(earth, time(2024,4,8,18,40,0)).shadow(moon);
print value.occultation(location(latitude: 60.0, longitude: 270.0));

Shadow.distance

method returns signed global shadow clearance

Method: Shadow.distance - returns signed global shadow clearance
Syntax:
  <Shadow>.distance() -> Number

# Use Shadow.distance on a Shadow value
let value = state(earth, time(2024,4,8,18,40,0)).shadow(moon);
print value.distance();

Shadow.polygon

method binary-searches a daylight-clipped shadow border polygon around the eclipse center

Method: Shadow.polygon - binary-searches a daylight-clipped shadow border polygon around the eclipse center
Syntax:
  <Shadow>.polygon(samples: Number, spacing_km: Number, spacing_degrees: Number, deviation: Number, magnitude: Number, kind: Text, lunar_limb: List, topography: Field, height: Number) -> Polygon|Unavailable
Arguments:
  samples: Number [optional] - optional fixed number of border rays; omitted uses adaptive sampling
  spacing_km: Number [optional] - adaptive target great-circle spacing between polygon vertices, in km
  spacing_degrees: Number [optional] - adaptive target great-circle spacing between polygon vertices, in degrees
  deviation: Number [optional] - adaptive maximum midpoint deviation from the segment, in degrees; `error` is an alias
  magnitude: Number [optional] - optional eclipse magnitude threshold between 0 and 1; can also be positional
  kind: Text [optional] - optional contour kind: `total` or `annular`; can also be positional
  lunar_limb: List [optional] - precomputed lunar limb profile from `state(moon,time).limb(...)`; only valid for totality contours
  topography: Field [optional] - optional body-matching topography field, for example `topography(earth)`
  height: Number [optional] - observer height in km above the datum or supplied topography; `observer_height` is an alias

# Use Shadow.polygon on a Shadow value
let value = state(earth, time(2024,4,8,18,40,0)).shadow(moon);
print value.polygon();

Shadow.limb

method projects a precomputed lunar limb profile onto the Earth shadow map

Method: Shadow.limb - projects a precomputed lunar limb profile onto the Earth shadow map
Syntax:
  <Shadow>.limb(lunar_limb: List, scale: Number) -> Polygon|Unavailable
Arguments:
  lunar_limb: List - precomputed lunar limb profile from `state(moon,time).limb(...)`
  scale: Number [optional] - non-negative exaggeration factor for lunar-radius deviations from the mean limb

# Project a precomputed lunar limb profile onto an eclipse shadow
let t = time(2024,4,8,18,40,0);
let loc = location(latitude: 32.7767, longitude: -96.7970);
let limb = state(moon, t).limb(loc, 8);
let sh = state(earth, t).shadow(moon);
print sh.limb(limb, scale: 1).available();

Shadow.children

method lists child fields and callable members available on this value