C library · PHP · Python · Dart · v2.0.0

JPL Moshier Ephemeris

One reference for the native JME C library and the three language bindings. Every binding calls the same jme_* functions and reads the same JME_* constants. Nothing is rounded, reshaped, or given a default the C function does not have.

Start with Quick Start Browse API Reference
225 functions 478 constants ISO C17

What this page covers

  • C — build and link libjme .
  • PHP — FFI wrapper, prebuilt libraries, Laravel.
  • Python — ctypes package jmeph-ffi .
  • Dart — Flutter plugin for desktop and mobile.

Same native contract

Status codes, output arrays, and error buffers stay in the C layout on every language.

Three calculation engines

JPL kernels through CALCEPH, Moshier analytical theory, or VSOP87 + ELP2000 + Meeus.

Matching native binaries

Each language binding must load a library built from the matching C release. Rebuild it when the C sources change.

Start

Installation

Install the language you call. The C library is the implementation. PHP, Python, and Dart load a shared library built from it.

Install commands and entry points
Language Install Entry
C cmake -S . -B build && cmake --build build #include "jme/jme.h"
PHP composer require jayeshmepani/jpl-moshier-ephemeris-php new JmeEph\FFI\JmeEphFFI()
Python pip install jmeph-ffi from jpl_moshier_ephemeris import JmeEph
Dart dart pub add jpl_moshier_ephemeris_dart import 'package:jpl_moshier_ephemeris_dart/jpl_moshier_ephemeris_dart.dart';

Start

Quick Start

Julian day of 2000-01-01 12:00 TT-scale input as UT for jme_calc_ut , then the Sun's geometric longitude. The six-value result array is the native layout on every language.

Shared call jme_calc_ut(jd_ut, body, flags, results, error)

The tabs below are this same call in each language. The argument order does not change.

C

#include "jme/jme.h"
#include <stdio.h>

int main(void) {
    double jd = jme_julian_day(2000, 1, 1, 12.0, JME_CALENDAR_GREGORIAN);
    double xx[6];
    char error[256];
    int result = jme_calc_ut(jd, JME_BODY_SUN, JME_CALC_TRUE_POSITION, xx, error);
    if (result == JME_OK) {
        printf("Sun longitude: %.10f\n", xx[0]);
        return 0;
    }
    printf("JME error: %s\n", error);
    return 1;
}

PHP

<?php
use FFI;
use JmeEph\FFI\JmeEphFFI;

$jme = new JmeEphFFI();
$jd = $jme->jme_julian_day(2000, 1, 1, 12.0, JmeEphFFI::JME_CALENDAR_GREGORIAN);
$xx = $jme->getFFI()->new('double[6]');
$error = $jme->getFFI()->new('char[256]');
$result = $jme->jme_calc_ut($jd, JmeEphFFI::JME_BODY_SUN, JmeEphFFI::JME_CALC_TRUE_POSITION, $xx, $error);

if ($result === JmeEphFFI::JME_OK) {
    echo "Sun longitude: {$xx[0]}\n";
} else {
    echo 'JME error: ' . FFI::string($error) . "\n";
}

Python

from jpl_moshier_ephemeris import (
    JME_BODY_SUN,
    JME_CALC_TRUE_POSITION,
    JME_CALENDAR_GREGORIAN,
    JME_OK,
    JmeEph,
    c_double,
    create_string_buffer,
)

jme = JmeEph()
jd = jme.jme_julian_day(2000, 1, 1, 12.0, JME_CALENDAR_GREGORIAN)
xx = (c_double * 6)()
err = create_string_buffer(256)
result = jme.jme_calc_ut(jd, JME_BODY_SUN, JME_CALC_TRUE_POSITION, xx, err)
print(xx[0] if result == JME_OK else err.value.decode())

Dart

import 'dart:ffi';

import 'package:ffi/ffi.dart';
import 'package:jpl_moshier_ephemeris_dart/jpl_moshier_ephemeris_dart.dart';

void main() {
  final jme = JmeEph();
  final jd = jme.bindings.jme_julian_day(2000, 1, 1, 12.0, JME_CALENDAR_GREGORIAN);
  using((arena) {
    final xx = arena<Double>(6);
    final err = arena<Char>(256);
    final result = jme.bindings.jme_calc_ut(
      jd,
      JME_BODY_SUN,
      JME_CALC_TRUE_POSITION,
      xx,
      err,
    );
    if (result == JME_OK) {
      print('Sun longitude: ${xx[0]}');
    } else {
      print('JME error: ${err.cast<Utf8>().toDartString()}');
    }
  });
}

Start

Engine Selection

The C library chooses the backend. Bindings pass the same token through jme_set_astro_models . They do not reimplement the choice.

Modes

  • JPL: CALCEPH and a readable .bsp kernel. No analytical fallback.
  • MOSHIER: analytical planets and Moon. No kernel file.
  • VSOP_ELP_MEEUS: VSOP87, ELP2000-82B, and Meeus.
  • ANALYTICAL: the analytical stack selected by that token.
  • AUTO: JPL first, then the analytical fallback.

Unset token

If the call is omitted, the library also reads JME_ENGINE with the same names: JPL , MOSHIER , VSOP_ELP_MEEUS , or ANALYTICAL .

Shared call jme_set_astro_models(models, flags)

The tabs below pass the same tokens. models is text such as ENGINE=JPL .

C

jme_set_astro_models("ENGINE=JPL", 0);
jme_set_astro_models("ENGINE=MOSHIER", 0);
jme_set_astro_models("ENGINE=VSOP_ELP_MEEUS", 0);
jme_set_astro_models("ENGINE=AUTO", 0);
jme_set_jpl_file("path/to/de440s.bsp");

PHP

$jme->jme_set_astro_models('ENGINE=JPL', 0);
$jme->jme_set_astro_models('ENGINE=MOSHIER', 0);
$jme->jme_set_astro_models('ENGINE=VSOP_ELP_MEEUS', 0);
$jme->jme_set_astro_models('ENGINE=ANALYTICAL', 0);
$jme->jme_set_astro_models('ENGINE=AUTO', 0);

Python

jme.jme_set_astro_models(b"ENGINE=JPL", 0)
jme.jme_set_astro_models(b"ENGINE=MOSHIER", 0)
jme.jme_set_astro_models(b"ENGINE=VSOP_ELP_MEEUS", 0)
jme.jme_set_astro_models(b"ENGINE=AUTO", 0)

Dart

final jme = JmeEph();
jme.configureEngine('JPL', jplFile: '/path/to/de440s.bsp');
jme.configureEngine('MOSHIER');
jme.configureEngine('VSOP_ELP_MEEUS');
jme.configureEngine('AUTO');

Start

Runtimes and Kernels

This C release is 2.0.0. Each language binding must load a shared library built from the matching C release; rebuild it when the C sources change.

Kernels are separate. Moshier and the other analytical modes do not need a .bsp file. Strict JPL mode does. Kernels are not inside the C repository or the language packages.

Where the library comes from

  • C: cmake --build produces libjme.so , libjme.dylib , or jme.dll .
  • PHP: Composer installs a prebuilt archive from the prebuilt-libs release . Override with JME_LIBRARY_PATH .
  • Python: the jmeph-ffi wheel contains the same desktop libraries, plus CALCEPH. Override with JME_LIBRARY_PATH and JME_CALCEPH_LIBRARY_PATH .
  • Dart: Android, iOS, Linux, macOS, and Windows libraries ship inside the pub package. Desktop CALCEPH is 5.0.1. Android and iOS CALCEPH is 4.0.5.

JPL kernels

Download de440s.bsp , de440.bsp , or de441.bsp from the kernel release. de441.bsp is published in parts because the file exceeds GitHub's asset limit. Join the parts in order. 

jme_set_ephemeris_path("/path/to/ephe");
jme_set_jpl_file("/path/to/de440s.bsp");

Desktop archive names

Platform Archive JME library
Linux x64 jme-linux-x64.tar.gz libjme.so
Linux ARM64 jme-linux-arm64.tar.gz libjme.so
macOS x64 jme-macos-x64.tar.gz libjme.dylib
macOS ARM64 jme-macos-arm64.tar.gz libjme.dylib
Windows x64 jme-windows-x64.zip jme.dll

Language

C

ISO C17 ( __STDC_VERSION__ 201710L , the same language as ISO/IEC 9899:2018). CMake 3.21 or newer. JME_VERSION is 2.0.0 . JME_VERSION_ID stays 400 .

Build

cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_FLAGS="-ffp-contract=off"
cmake --build build
ctest --test-dir build --output-on-failure

Release builds keep -ffp-contract=off so the floating-point contraction matches the tested results. If CALCEPH is missing, the library still builds and JPL calls return an explicit error.

Public surface

  • Headers: include/jme/jme.h and include/jme/jme_extended.h .
  • 225 public jme_* functions.
  • 478 public JME_* constants, plus the include guards JME_JME_H and JME_EXTENDED_H .
  • jme_calc_ut always fills six result slots, including the rates.

Language

PHP

Package jayeshmepani/jpl-moshier-ephemeris-php . PHP 8.3 or newer, with ext-ffi . Class JmeEph\FFI\JmeEphFFI exposes each C function as a method of the same name.

Enable FFI

extension=ffi
ffi.enable=1

Platform packages

Ubuntu / Debian

sudo apt install php8.3-ffi

# Or for PHP 8.4
sudo apt install php8.4-ffi

RHEL / Fedora

sudo dnf install php-ffi
# or
sudo yum install php-ffi

macOS

# Homebrew PHP already includes FFI
brew install php@8.3

Windows

PHP 8.3 and newer for Windows includes FFI. Enable it in php.ini as shown above.

Verify FFI

php -r "echo extension_loaded('ffi') ? 'FFI loaded' : 'FFI not loaded';"
php -r "echo ini_get('ffi.enable') ? 'FFI enabled' : 'FFI not enabled';"

Point the loader at a library built from this release with JME_LIBRARY_PATH when the bundled file is not the one you want. Kernel files, when you use JPL, go through jme_set_ephemeris_path . 

$jme = new JmeEph\FFI\JmeEphFFI();
$jme->jme_set_ephemeris_path(__DIR__ . '/ephe');

Language

PHP Laravel

The PHP package includes a service provider and a facade. Laravel 11 discovers the provider. Older applications register it in config/app.php .

Laravel before 11

'providers' => [
    JmeEph\Service\JmeEphServiceProvider::class,
],
'aliases' => [
    'JmeEph' => JmeEph\Service\JmeEphFacade::class,
],

Configuration

'library_path' => env('JME_LIBRARY_PATH'),
'engine' => env('JME_ENGINE', 'AUTO'),
'ephemeris_path' => env('JME_EPHEMERIS_PATH'),

Facade

$jd = JmeEph::jme_julian_day(
    2000,
    1,
    1,
    12.0,
    JmeEph::JME_CALENDAR_GREGORIAN
);

Language

Python

Package jmeph-ffi on PyPI, import name jpl_moshier_ephemeris . Python 3.10 or newer. Pure ctypes. No extension module. End users do not download a separate binary: the wheel contains libjme and CALCEPH for Linux, macOS, and Windows.

Load order

  1. JME_LIBRARY_PATH and JME_CALCEPH_LIBRARY_PATH
  2. the libraries bundled in the wheel
  3. common system library paths

String arguments that the C API takes as char * are passed as bytes, for example b"ENGINE=MOSHIER" . Output buffers are create_string_buffer . Numeric output arrays are c_double arrays.

Language

Dart

Package jpl_moshier_ephemeris_dart . Dart 3.3 or newer and Flutter 3.19 or newer. JmeEph loads the library. JmeBindings is the direct jme_* surface. Constants such as JME_BODY_SUN are top-level Dart names.

Platforms in the package

  • Android arm64-v8a and x86_64 , with libjme.so and libcalceph.so .
  • iOS Jme.xcframework and Calceph.xcframework , device and simulator.
  • Linux, macOS, and Windows desktop libraries beside the Flutter build.

configureEngine writes ENGINE=... into jme_set_astro_models . For JPL it also opens the kernel and throws if that open fails. Allocate output pointers with arena from package:ffi . Do not free memory the C library still owns.

Contract

API Contract

The counts below are the native header surface. PHP, Python, and Dart generate their declarations from those headers.

Functions

225 public jme_* functions

Constants

478 public JME_* constants
+ JME_JME_H
+ JME_EXTENDED_H
  • Names stay jme_* and JME_* in every language.
  • JME_OK is 0 . JME_ERR is -1 . The error buffer is caller-owned.
  • jme_calc_ut writes six doubles. Indexes 0–2 are position. Indexes 3–5 are the rates. The call fills the rates even when the caller does not request JME_CALC_SPEED .
  • The two include guards are not calculation constants. The bindings still export them because they export every JME_* macro.

Contract

Native Notes

These markdown files stay next to this page. They are the design and validation record for the C library. The language bindings do not keep a second copy.

Reference

225 Functions

Each call is the shared name and argument order. C, PHP, Python, and Dart use that same order. Output arguments are buffers you allocate. A status return is JME_OK or JME_ERR . The line under the name says what the call does, when to choose it, and where it sits in a program.

This box filters the function list. The sidebar search looks through the whole page and highlights each match.

Function group

Angles and Formatting

Use these after you already have a number. They wrap, compare, or print an angle, a clock time, or a duration. They do not compute a planet.

jme_centiseconds_to_lonlat_string

What it does Formats a signed centisecond angle as a degree-style longitude or latitude string.

When to use it Use this to print a geographic or ecliptic angle you stored in centiseconds.

Where it fits Display only.

Call jme_centiseconds_to_lonlat_string(cs, buffer)
Arguments
  • cs Angle or time in centiseconds. A full circle or a day of time is 1,296,000 centiseconds.
  • buffer Caller-owned character buffer. The call writes the text here.
Result

Returns the text. When you pass buffer, the text is written there and the return points at that buffer.

jme_decimal_hour

What it does Turns hours, minutes, and seconds into a decimal hour.

When to use it Use this before jme_julian_day, which takes one hour number.

Where it fits Clock entry.

Call jme_decimal_hour(hour, minute, second)
Arguments
  • hour Whole hours.
  • minute Whole minutes.
  • second Seconds, including a fraction.
Result

Returns the number described above. A non-finite value means the call could not produce that number.

jme_centiseconds_difference

What it does Returns the separation of two centisecond angles.

When to use it Use this to test whether two longitudes stored in centiseconds have met.

Where it fits Angle storage. The signed form keeps the direction.

Call jme_centiseconds_difference(p1, p2)
Arguments
  • p1 First angle in centiseconds.
  • p2 Second angle in centiseconds.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_centiseconds_difference_signed

What it does Returns the signed separation of two centisecond angles.

When to use it Use this when the direction around the circle matters.

Where it fits The unsigned pair is jme_centiseconds_difference.

Call jme_centiseconds_difference_signed(p1, p2)
Arguments
  • p1 First angle in centiseconds.
  • p2 Second angle in centiseconds.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_centiseconds_normalize

What it does Wraps a centisecond angle onto one full circle.

When to use it Use this before you store or compare an angle that may have wound past a full turn.

Where it fits Any centisecond longitude.

Call jme_centiseconds_normalize(p)
Arguments
  • p Angle in centiseconds to wrap onto one full circle.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_centiseconds_round_second

What it does Rounds a centisecond angle to the nearest whole second.

When to use it Use this only for display rounding. Do not feed it back into a calculation you want at full precision.

Where it fits A printed degree-minute-second field.

Call jme_centiseconds_round_second(x)
Arguments
  • x Centiseconds to round to the nearest whole second.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_jd_difference_seconds

What it does Returns the signed number of seconds from one Julian date to another.

When to use it Use this to measure a duration between two instants you already hold as Julian dates.

Where it fits jd_end minus jd_start, in seconds.

Call jme_jd_difference_seconds(jd_end, jd_start)
Arguments
  • jd_end End Julian date.
  • jd_start Julian date to search from. The matching time scale is the one in the function name.
Result

Returns the number described above. A non-finite value means the call could not produce that number.

Function group

Configuration and Utilities

Call these at setup, or when you need an orbital element set. They change or read a library setting that later calculations inherit.

jme_close

What it does Releases resources the library is holding, including an open kernel.

When to use it Call it when the process is finished with ephemeris calls.

Where it fits Shutdown. Later calls need a new setup.

Call jme_close()
Result

Returns nothing. The call writes its output arguments, or it changes a library setting for later calls.

jme_get_orbital_elements

What it does Writes the orbital elements of a body at Terrestrial Time.

When to use it Use this when you need the element set itself, not a longitude.

Where it fits An orbit panel. flags follow the calculation flags.

Call jme_get_orbital_elements(jd_et, body, flags, elem, error)
Arguments
  • jd_et Terrestrial Time (TT) as a Julian date.
  • body Body id such as JME_BODY_SUN. The body constants list every id.
  • flags Flag bits for this call. Pass 0 for the default. The constant group for this family lists the bits.
  • elem Caller-owned array of orbital elements.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_set_astro_models

What it does Sets engine and model tokens for later calculations.

When to use it Call it at startup to choose JPL, Moshier, VSOP plus ELP, or AUTO, and to name precession or nutation models.

Where it fits Before jme_calc. The checked form rejects an unknown token and leaves the old setting in place.

Call jme_set_astro_models(models, flags)
Arguments
  • models Text tokens such as ENGINE=JPL or ENGINE=MOSHIER. The engine section lists the tokens.
  • flags Flag bits for this call. Pass 0 for the default. The constant group for this family lists the bits.
Result

Returns nothing. The call writes its output arguments, or it changes a library setting for later calls.

jme_get_astro_models

What it does Writes the current model tokens into models.

When to use it Call it to show or save the active engine and model choices.

Where it fits After jme_set_astro_models.

Call jme_get_astro_models(models, flags)
Arguments
  • models Text tokens such as ENGINE=JPL or ENGINE=MOSHIER. The engine section lists the tokens.
  • flags Flag bits for this call. Pass 0 for the default. The constant group for this family lists the bits.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_set_lapse_rate

What it does Sets the temperature lapse rate used by extended refraction.

When to use it Call it when the observer is high enough that sea-level weather is the wrong profile.

Where it fits Before jme_refract_extended, if you do not pass the lapse on that call.

Call jme_set_lapse_rate(lapse_rate)
Arguments
  • lapse_rate Temperature lapse rate. jme_refract_extended uses it when the observer is not at sea level.
Result

Returns nothing. The call writes its output arguments, or it changes a library setting for later calls.

jme_set_interpolate_nut

What it does Turns nutation interpolation on or off for later orientation calls.

When to use it Use this only when you deliberately want the interpolated nutation series.

Where it fits A setup call. Leave it off unless you know you want that interpolation.

Call jme_set_interpolate_nut(on)
Arguments
  • on Non-zero turns the option on. Zero turns it off.
Result

Returns nothing. The call writes its output arguments, or it changes a library setting for later calls.

jme_get_tid_acc

What it does Returns the tidal acceleration currently applied to historical Delta-T.

When to use it Call it to record which JME_TIME_TIDAL_* choice is active.

Where it fits After jme_set_tid_acc.

Call jme_get_tid_acc()
Result

Returns the number described above. A non-finite value means the call could not produce that number.

jme_set_tid_acc

What it does Selects the tidal acceleration used with historical Delta-T.

When to use it Call it when a JPL ephemeris requires its matching tidal value. JME_TIME_TIDAL_DE441 has no published historical acceleration, so pre-1955 Delta-T then returns a non-finite value and an error.

Where it fits Setup, before long-range Delta-T. JME_TIME_TIDAL_AUTOMATIC applies no extra correction.

Call jme_set_tid_acc(t_acc)
Arguments
  • t_acc Tidal acceleration selector, usually a JME_TIME_TIDAL_* constant, or a numeric acceleration when you set one directly.
Result

Returns nothing. The call writes its output arguments, or it changes a library setting for later calls.

jme_days_in_month

What it does Returns how many days the month has in that year and calendar.

When to use it Use this to build a month grid or to cap a day field.

Where it fits Date entry.

Call jme_days_in_month(year, month, calendar)
Arguments
  • year Calendar year. Astronomical year numbering, so 1 BCE is year 0.
  • month Month number from 1 to 12.
  • calendar JME_CALENDAR_GREGORIAN or JME_CALENDAR_JULIAN.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_refract

What it does Applies atmospheric refraction to an altitude angle.

When to use it Use this to turn a true altitude into an apparent one, or the reverse, at the observer's pressure and temperature.

Where it fits calc_flag JME_COORD_APPARENT_TO_TRUE subtracts refraction. JME_COORD_TRUE_TO_APPARENT adds it. Below about -1 degree, or with no pressure, the altitude is returned unchanged.

Call jme_refract(altitude, pressure, temperature, calc_flag)
Arguments
  • altitude Altitude angle in degrees.
  • pressure Air pressure in millibars. The sea-level default used by the refraction formula is 1010.
  • temperature Air temperature in degrees Celsius.
  • calc_flag JME_COORD_APPARENT_TO_TRUE removes refraction. JME_COORD_TRUE_TO_APPARENT adds it.
Result

Returns the corrected altitude in degrees. Extended refraction also fills out when you pass it.

jme_refract_extended

What it does Applies refraction with observer height and a lapse rate, and can return the intermediate weather.

When to use it Use this when the observer is not at the pressure you measured at sea level.

Where it fits out, when present, receives corrected altitude, refraction, local pressure, and local temperature.

Call jme_refract_extended(altitude, geoalt, pressure, temperature, lapse_rate, calc_flag, out)
Arguments
  • altitude Altitude angle in degrees.
  • geoalt Observer height in metres, used to adjust pressure and temperature.
  • pressure Air pressure in millibars. The sea-level default used by the refraction formula is 1010.
  • temperature Air temperature in degrees Celsius.
  • lapse_rate Temperature lapse rate. jme_refract_extended uses it when the observer is not at sea level.
  • calc_flag JME_COORD_APPARENT_TO_TRUE removes refraction. JME_COORD_TRUE_TO_APPARENT adds it.
  • out Optional extra outputs. For extended refraction this is four numbers: corrected altitude, refraction, local pressure, local temperature.
Result

Returns the corrected altitude in degrees. Extended refraction also fills out when you pass it.

Function group

Coordinates and Vectors

Use these when you already have a place or a Cartesian state and you need another frame: ecliptic, equator, horizon, or a rotation matrix.

jme_centiseconds_to_degree_string

What it does Formats a centisecond angle as a degree string.

When to use it Use this for the same stored angle when you want degrees rather than a coordinate sign convention.

Where it fits Display only.

Call jme_centiseconds_to_degree_string(cs, buffer)
Arguments
  • cs Angle or time in centiseconds. A full circle or a day of time is 1,296,000 centiseconds.
  • buffer Caller-owned character buffer. The call writes the text here.
Result

Returns the text. When you pass buffer, the text is written there and the return points at that buffer.

jme_get_obliquity

What it does Returns the obliquity of the ecliptic at Terrestrial Time for a chosen model.

When to use it Use this when a house or coordinate call asks you to supply eps, or when you want to display it.

Where it fits Pass the result into the RAMC house calls.

Call jme_get_obliquity(jd_et, model, eps, error)
Arguments
  • jd_et Terrestrial Time (TT) as a Julian date.
  • model Model id from the JME_MODEL_* or JME_SIDEREAL_* constants, depending on the call.
  • eps Obliquity of the ecliptic, in degrees, at the date you are using.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_get_frame_bias_matrix

What it does Writes the frame-bias rotation for a bias model.

When to use it Use this when you rotate vectors between the catalogue frame and the equinox yourself.

Where it fits Before your own matrix multiply. m is nine numbers.

Call jme_get_frame_bias_matrix(model, m)
Arguments
  • model Model id from the JME_MODEL_* or JME_SIDEREAL_* constants, depending on the call.
  • m Caller-owned rotation matrix, nine numbers, row by row.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_get_nutation

What it does Returns nutation in longitude and obliquity at Terrestrial Time.

When to use it Use this when you apply nutation yourself, or when you need those angles for apparent sidereal time.

Where it fits dpsi and deps receive the two angles.

Call jme_get_nutation(jd_et, model, dpsi, deps, error)
Arguments
  • jd_et Terrestrial Time (TT) as a Julian date.
  • model Model id from the JME_MODEL_* or JME_SIDEREAL_* constants, depending on the call.
  • dpsi Receives nutation in longitude.
  • deps Receives nutation in obliquity.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_get_precession_matrix

What it does Writes the precession rotation from one TT date to another.

When to use it Use this to move a vector between two epochs.

Where it fits m is nine numbers. The model selects the precession series.

Call jme_get_precession_matrix(jd_start, jd_end, model, m)
Arguments
  • jd_start TT Julian date at the start of the precession interval.
  • jd_end TT Julian date at the end of the precession interval.
  • model Model id from the JME_MODEL_* or JME_SIDEREAL_* constants, depending on the call.
  • m Caller-owned rotation matrix, nine numbers, row by row.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_get_nutation_matrix

What it does Builds the nutation matrix from nutation angles and obliquity, in radians.

When to use it Use this after jme_get_nutation when you need the matrix rather than the two angles.

Where it fits A coordinate pipeline you are writing yourself.

Call jme_get_nutation_matrix(dpsi_rad, deps_rad, eps_rad, m)
Arguments
  • dpsi_rad Nutation in longitude, in radians.
  • deps_rad Nutation in obliquity, in radians.
  • eps_rad Obliquity, in radians.
  • m Caller-owned rotation matrix, nine numbers, row by row.
Result

Returns nothing. The call writes its output arguments, or it changes a library setting for later calls.

jme_matrix_identity

What it does Writes a 3 by 3 identity matrix.

When to use it Use this as the starting matrix before you multiply in precession or nutation.

Where it fits m is nine numbers.

Call jme_matrix_identity(m)
Arguments
  • m Caller-owned rotation matrix, nine numbers, row by row.
Result

Returns nothing. The call writes its output arguments, or it changes a library setting for later calls.

jme_matrix_multiply

What it does Multiplies two 3 by 3 matrices into out.

When to use it Use this to combine frame rotations.

Where it fits A coordinate pipeline. out must not be assumed to alias a or b unless you have checked that.

Call jme_matrix_multiply(a, b, out)
Arguments
  • a First rotation matrix, nine numbers.
  • b Second rotation matrix, nine numbers.
  • out Optional extra outputs. For extended refraction this is four numbers: corrected altitude, refraction, local pressure, local temperature.
Result

Returns nothing. The call writes its output arguments, or it changes a library setting for later calls.

jme_matrix_rotate_x

What it does Writes the rotation matrix about the x axis.

When to use it Use this when you build a rotation the library does not already provide.

Where it fits angle_rad is radians. m receives nine numbers.

Call jme_matrix_rotate_x(angle_rad, m)
Arguments
  • angle_rad Rotation angle in radians.
  • m Caller-owned rotation matrix, nine numbers, row by row.
Result

Returns nothing. The call writes its output arguments, or it changes a library setting for later calls.

jme_matrix_rotate_y

What it does Writes the rotation matrix about the y axis.

When to use it Use this for the y component of a rotation you are composing.

Where it fits Same layout as jme_matrix_rotate_x.

Call jme_matrix_rotate_y(angle_rad, m)
Arguments
  • angle_rad Rotation angle in radians.
  • m Caller-owned rotation matrix, nine numbers, row by row.
Result

Returns nothing. The call writes its output arguments, or it changes a library setting for later calls.

jme_matrix_rotate_z

What it does Writes the rotation matrix about the z axis.

When to use it Use this for a rotation in the reference plane, such as a longitude shift you apply yourself.

Where it fits Same layout as jme_matrix_rotate_x.

Call jme_matrix_rotate_z(angle_rad, m)
Arguments
  • angle_rad Rotation angle in radians.
  • m Caller-owned rotation matrix, nine numbers, row by row.
Result

Returns nothing. The call writes its output arguments, or it changes a library setting for later calls.

jme_degree_midpoint

What it does Returns the midpoint of two angles in degrees, on the short arc.

When to use it Use this for the middle of a nakshatra, a house, or an arc.

Where it fits Both inputs are degrees.

Call jme_degree_midpoint(x1, x0)
Arguments
  • x1 First angle in degrees.
  • x0 Second angle in degrees.
Result

Returns the number described above. A non-finite value means the call could not produce that number.

jme_degree_normalize

What it does Wraps a degree angle onto one full circle.

When to use it Use this before you compare a longitude with a boundary.

Where it fits Any ecliptic or equatorial degree measure.

Call jme_degree_normalize(x)
Arguments
  • x Angle in degrees to wrap onto one full circle.
Result

Returns the number described above. A non-finite value means the call could not produce that number.

jme_degrees_to_hours

What it does Converts degrees of angle to hours of right ascension or time.

When to use it Use this when a sidereal-time or right-ascension field must be shown in hours.

Where it fits 15 degrees become 1 hour.

Call jme_degrees_to_hours(degrees)
Arguments
  • degrees Angle in degrees.
Result

Returns the number described above. A non-finite value means the call could not produce that number.

jme_degrees_to_radians

What it does Converts degrees to radians.

When to use it Use this at the boundary of a routine that wants radians, such as the nutation matrix.

Where it fits The reverse is jme_radians_to_degrees.

Call jme_degrees_to_radians(degrees)
Arguments
  • degrees Angle in degrees.
Result

Returns the number described above. A non-finite value means the call could not produce that number.

jme_degrees_difference

What it does Returns the separation of two degree angles.

When to use it Use this to measure a house width or a distance along the ecliptic without the sign.

Where it fits The signed form keeps the direction.

Call jme_degrees_difference(p1, p2)
Arguments
  • p1 First angle in degrees.
  • p2 Second angle in degrees.
Result

Returns the number described above. A non-finite value means the call could not produce that number.

jme_degrees_difference_signed

What it does Returns the signed separation of two degree angles.

When to use it Use this when you need to know which way the motion goes.

Where it fits The unsigned pair is jme_degrees_difference.

Call jme_degrees_difference_signed(p1, p2)
Arguments
  • p1 First angle in degrees.
  • p2 Second angle in degrees.
Result

Returns the number described above. A non-finite value means the call could not produce that number.

jme_ecliptic_to_equatorial

What it does Converts ecliptic longitude and latitude to right ascension and declination.

When to use it Use this when you have an ecliptic place and you need the equator of date.

Where it fits You supply the obliquity eps. The reverse is jme_equatorial_to_ecliptic.

Call jme_ecliptic_to_equatorial(lon, lat, eps, ra, dec)
Arguments
  • lon Longitude in degrees. East is positive when this is a place. For an angle helper it is the ecliptic or equatorial longitude the call names.
  • lat Latitude in degrees. North is positive when this is a place.
  • eps Obliquity of the ecliptic, in degrees, at the date you are using.
  • ra Receives right ascension.
  • dec Declination in degrees, or the variable that receives it.
Result

Returns nothing. The call writes its output arguments, or it changes a library setting for later calls.

jme_equatorial_to_ecliptic

What it does Converts right ascension and declination to ecliptic longitude and latitude.

When to use it Use this when a star or a vector is equatorial and the chart is ecliptic.

Where it fits You supply eps.

Call jme_equatorial_to_ecliptic(ra, dec, eps, lon, lat)
Arguments
  • ra Receives right ascension.
  • dec Declination in degrees, or the variable that receives it.
  • eps Obliquity of the ecliptic, in degrees, at the date you are using.
  • lon Longitude in degrees. East is positive when this is a place. For an angle helper it is the ecliptic or equatorial longitude the call names.
  • lat Latitude in degrees. North is positive when this is a place.
Result

Returns nothing. The call writes its output arguments, or it changes a library setting for later calls.

jme_spherical_angular_separation

What it does Returns the great-circle angle between two spherical positions.

When to use it Use this for the distance on the sky between two longitudes and latitudes.

Where it fits Conjunction tests and angular separation. The unit is degrees.

Call jme_spherical_angular_separation(lon1, lat1, lon2, lat2)
Arguments
  • lon1 Longitude of the first point, in degrees.
  • lat1 Latitude of the first point, in degrees.
  • lon2 Longitude of the second point, in degrees.
  • lat2 Latitude of the second point, in degrees.
Result

Returns the number described above. A non-finite value means the call could not produce that number.

jme_spherical_position_angle

What it does Returns the position angle of the second point from the first.

When to use it Use this when you need the direction of one body from another on the sky.

Where it fits The result is a degree angle.

Call jme_spherical_position_angle(lon1, lat1, lon2, lat2)
Arguments
  • lon1 Longitude of the first point, in degrees.
  • lat1 Latitude of the first point, in degrees.
  • lon2 Longitude of the second point, in degrees.
  • lat2 Latitude of the second point, in degrees.
Result

Returns the number described above. A non-finite value means the call could not produce that number.

jme_radian_midpoint

What it does Returns the midpoint of two radian angles on the short arc.

When to use it Use this when the surrounding math is already in radians.

Where it fits The degree form is jme_degree_midpoint.

Call jme_radian_midpoint(x1, x0)
Arguments
  • x1 First angle in radians.
  • x0 Second angle in radians.
Result

Returns the number described above. A non-finite value means the call could not produce that number.

jme_radian_normalize

What it does Wraps a radian angle onto one full turn.

When to use it Use this before a comparison in radians.

Where it fits The degree form is jme_degree_normalize.

Call jme_radian_normalize(x)
Arguments
  • x Angle in radians to wrap onto one full turn.
Result

Returns the number described above. A non-finite value means the call could not produce that number.

jme_radians_to_degrees

What it does Converts radians to degrees.

When to use it Use this to present a radian result in degrees.

Where it fits The reverse is jme_degrees_to_radians.

Call jme_radians_to_degrees(radians)
Arguments
  • radians Angle in radians.
Result

Returns the number described above. A non-finite value means the call could not produce that number.

jme_radians_difference_signed

What it does Returns the signed separation of two radian angles.

When to use it Use this when both angles are already in radians and the direction matters.

Where it fits The degree form is jme_degrees_difference_signed.

Call jme_radians_difference_signed(p1, p2)
Arguments
  • p1 First angle in radians.
  • p2 Second angle in radians.
Result

Returns the number described above. A non-finite value means the call could not produce that number.

jme_hours_normalize

What it does Wraps a time in hours onto one day.

When to use it Use this after adding hours that may have passed 24.

Where it fits Sidereal time and decimal hours.

Call jme_hours_normalize(hours)
Arguments
  • hours Hours to wrap onto one day.
Result

Returns the number described above. A non-finite value means the call could not produce that number.

jme_hours_to_degrees

What it does Converts hours of right ascension or time to degrees.

When to use it Use this when a sidereal time in hours must enter a house call that wants degrees.

Where it fits 1 hour becomes 15 degrees.

Call jme_hours_to_degrees(hours)
Arguments
  • hours Receives sidereal time in hours.
Result

Returns the number described above. A non-finite value means the call could not produce that number.

jme_split_degree

What it does Splits a decimal degree angle into sign, degrees, minutes, seconds, and the fraction of a second.

When to use it Use this to print a longitude without building the string yourself.

Where it fits roundflag ROUND_DEG, ROUND_MIN, or ROUND_SEC chooses the rounding. The other angle-format ids are not applied here.

Call jme_split_degree(ddeg, roundflag, ideg, imin, isec, dsecfr, isgn)
Arguments
  • ddeg Angle in decimal degrees to split into sign, degrees, minutes, and seconds.
  • roundflag Rounding choice. JME_ANGLE_FORMAT_ROUND_DEG, ROUND_MIN, or ROUND_SEC. The other format ids are not applied by this call.
  • ideg Receives the degree part.
  • imin Receives the minute part.
  • isec Receives the whole-second part.
  • dsecfr Receives the fraction of the second.
  • isgn Receives the sign: 1 or -1.
Result

Returns nothing. The call writes its output arguments, or it changes a library setting for later calls.

Function group

Eclipses and Occultations

Use these to search for an eclipse or an occultation, or to describe one whose time you already know. A position call will not return contact times.

jme_sol_eclipse_where

What it does Finds where on Earth a solar eclipse is central at a Universal Time.

When to use it Use this when you have a time inside an eclipse and you need the geographic path point.

Where it fits Global eclipse maps. For the next eclipse, search first with jme_sol_eclipse_when_glob.

Call jme_sol_eclipse_where(jd_ut, flags, geopos, attr, error)
Arguments
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
  • flags Reserved argument; this function currently ignores it. Pass 0.
  • geopos Observer longitude, latitude, and height, in that order, in degrees and metres.
  • attr Caller-owned array that receives the circumstance values for this call.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns a JME_ECLIPSE_SOLAR_* classification on success, or JME_ERR (-1). Test rc < 0 for failure. The output arguments are written as the description says.

jme_sol_eclipse_how

What it does Computes how a solar eclipse appears at one place and Universal Time.

When to use it Use this when the observer is fixed and you want magnitude and the related attributes.

Where it fits A local eclipse page. geopos is that place.

Call jme_sol_eclipse_how(jd_ut, flags, geopos, attr, error)
Arguments
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
  • flags Reserved argument; this function currently ignores it. Pass 0.
  • geopos Observer longitude, latitude, and height, in that order, in degrees and metres.
  • attr Caller-owned array that receives the circumstance values for this call.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns a JME_ECLIPSE_SOLAR_* classification on success, or JME_ERR (-1). Test rc < 0 for failure. The output arguments are written as the description says.

jme_sol_eclipse_when_loc

What it does Searches for the next or previous solar eclipse at one place.

When to use it Use this when the question is 'when is the eclipse visible here'.

Where it fits A local calendar. backward searches earlier. tret receives the contact times.

Call jme_sol_eclipse_when_loc(jd_start, flags, geopos, tret, attr, backward, error)
Arguments
  • jd_start Julian date to search from. The matching time scale is the one in the function name.
  • flags Reserved argument; this function currently ignores it. Pass 0.
  • geopos Observer longitude, latitude, and height, in that order, in degrees and metres.
  • tret Caller-owned array of Julian dates. The description says which index is which event.
  • attr Caller-owned array that receives the circumstance values for this call.
  • backward Search direction. Non-zero searches before jd_start. Zero searches after it.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns a JME_ECLIPSE_SOLAR_* classification on success, or JME_ERR (-1). Test rc < 0 for failure. The output arguments are written as the description says.

jme_sol_eclipse_when_glob

What it does Searches for the next or previous solar eclipse anywhere on Earth.

When to use it Use this to build a worldwide eclipse list.

Where it fits Start from jd_start and walk forward, or backward. Then call the where and how functions for a chosen instant.

Call jme_sol_eclipse_when_glob(jd_start, flags, epheflag, tret, backward, error)
Arguments
  • jd_start Julian date to search from. The matching time scale is the one in the function name.
  • flags Reserved argument; this function currently ignores it. Pass 0.
  • epheflag Eclipse-type filter: 0 for any, or JME_ECLIPSE_SOLAR_TOTAL, _ANNULAR, _HYBRID, _PARTIAL, _CENTRAL or _NONCENTRAL.
  • tret Caller-owned array of Julian dates. The description says which index is which event.
  • backward Search direction. Non-zero searches before jd_start. Zero searches after it.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns a JME_ECLIPSE_SOLAR_* classification on success, or JME_ERR (-1). Test rc < 0 for failure. The output arguments are written as the description says.

jme_lun_eclipse_how

What it does Computes how a lunar eclipse appears at one place and Universal Time.

When to use it Use this for magnitude and contact data of a lunar eclipse at a known time.

Where it fits A local lunar-eclipse page.

Call jme_lun_eclipse_how(jd_ut, flags, geopos, attr, error)
Arguments
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
  • flags Reserved argument; this function currently ignores it. Pass 0.
  • geopos Observer longitude, latitude, and height, in that order, in degrees and metres.
  • attr Caller-owned array that receives the circumstance values for this call.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns a JME_ECLIPSE_LUNAR_* classification on success, or JME_ERR (-1). Test rc < 0 for failure. The output arguments are written as the description says.

jme_lun_eclipse_when_loc

What it does Searches for the next or previous lunar eclipse at one place.

When to use it Use this when the observer is fixed.

Where it fits A local calendar. The global search is jme_lun_eclipse_when.

Call jme_lun_eclipse_when_loc(jd_start, flags, geopos, tret, attr, backward, error)
Arguments
  • jd_start Julian date to search from. The matching time scale is the one in the function name.
  • flags Reserved argument; this function currently ignores it. Pass 0.
  • geopos Observer longitude, latitude, and height, in that order, in degrees and metres.
  • tret Caller-owned array of Julian dates. The description says which index is which event.
  • attr Caller-owned array that receives the circumstance values for this call.
  • backward Search direction. Non-zero searches before jd_start. Zero searches after it.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns a JME_ECLIPSE_LUNAR_* classification on success, or JME_ERR (-1). Test rc < 0 for failure. The output arguments are written as the description says.

jme_lun_eclipse_when

What it does Searches for the next or previous lunar eclipse worldwide.

When to use it Use this to list lunar eclipses before you care about one city.

Where it fits A worldwide eclipse index.

Call jme_lun_eclipse_when(jd_start, flags, iflag, tret, backward, error)
Arguments
  • jd_start Julian date to search from. The matching time scale is the one in the function name.
  • flags Reserved argument; this function currently ignores it. Pass 0.
  • iflag Eclipse-type filter: 0 for any, or JME_ECLIPSE_LUNAR_TOTAL, _PARTIAL or _PENUMBRAL.
  • tret Caller-owned array of Julian dates. The description says which index is which event.
  • backward Search direction. Non-zero searches before jd_start. Zero searches after it.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns a JME_ECLIPSE_LUNAR_* classification on success, or JME_ERR (-1). Test rc < 0 for failure. The output arguments are written as the description says.

jme_lun_occult_where

What it does Finds where a lunar occultation of a body or star is central at a Universal Time.

When to use it Use this when the time is known and you need the geographic point.

Where it fits Occultation maps. starname is empty for a planet.

Call jme_lun_occult_where(jd_ut, body, starname, flags, geopos, attr, error)
Arguments
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
  • body Body id such as JME_BODY_SUN. The body constants list every id.
  • starname Star name. Use an empty string when the call is for a solar-system body.
  • flags Reserved argument; this function currently ignores it. Pass 0.
  • geopos Observer longitude, latitude, and height, in that order, in degrees and metres.
  • attr Caller-owned array that receives the circumstance values for this call.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_lun_occult_when_loc

What it does Searches for the next or previous occultation by the Moon at one place.

When to use it Use this for 'when does the Moon cover this body here'.

Where it fits A local occultation list. Pass the body, or a star name.

Call jme_lun_occult_when_loc(jd_start, body, starname, flags, geopos, tret, attr, backward, error)
Arguments
  • jd_start Julian date to search from. The matching time scale is the one in the function name.
  • body Body id such as JME_BODY_SUN. The body constants list every id.
  • starname Star name. Use an empty string when the call is for a solar-system body.
  • flags Reserved argument; this function currently ignores it. Pass 0.
  • geopos Observer longitude, latitude, and height, in that order, in degrees and metres.
  • tret Caller-owned array of Julian dates. The description says which index is which event.
  • attr Caller-owned array that receives the circumstance values for this call.
  • backward Search direction. Non-zero searches before jd_start. Zero searches after it.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_lun_occult_when_glob

What it does Searches for the next or previous lunar occultation anywhere on Earth.

When to use it Use this for a worldwide occultation list.

Where it fits tret[0] is greatest occultation. Indexes 2 and 3 are the outer contacts. Stars are treated as points at infinity.

Call jme_lun_occult_when_glob(jd_start, body, starname, flags, iflag, tret, backward, error)
Arguments
  • jd_start Julian date to search from. The matching time scale is the one in the function name.
  • body Body id such as JME_BODY_SUN. The body constants list every id.
  • starname Star name. Use an empty string when the call is for a solar-system body.
  • flags Reserved argument; this function currently ignores it. Pass 0.
  • iflag Reserved search-flag argument; this function currently ignores it.
  • tret Event times. Index 0 is greatest occultation. Indexes 2 and 3 are the first and last contact anywhere on Earth. Indexes 4 and 5 are the total phase when there is one. Indexes 6 and 7 are the central phase when there is one.
  • backward Search direction. Non-zero searches before jd_start. Zero searches after it.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

Function group

Fixed Stars and Metadata

Use these for a named star, or for the version and file paths of the library. Star magnitude does not need a date. Star position does.

jme_version

What it does Copies the library version string into buffer.

When to use it Call it once at startup when you need to show or record which JME build is loaded.

Where it fits Any program, before you trust a result. This release's string is 2.0.0.

Call jme_version(buffer, buffer_size)
Arguments
  • buffer Caller-owned character buffer. The call writes the text here.
  • buffer_size Size of buffer, in bytes, including room for the terminating zero.
Result

Returns the text. When you pass buffer, the text is written there and the return points at that buffer.

jme_ephemeris_path

What it does Returns the directory the library searches for ephemeris files.

When to use it Call it when you need to show or check the path that was set.

Where it fits After jme_set_ephemeris_path, or to read the default.

Call jme_ephemeris_path()
Result

Returns the text. When you pass buffer, the text is written there and the return points at that buffer.

jme_set_ephemeris_path

What it does Sets the directory used to resolve a relative kernel name from jme_set_jpl_file(). Changing it closes any open kernel.

When to use it Call it at startup when the kernel file does not sit on the default path.

Where it fits Before a JPL call that reads a kernel file.

Call jme_set_ephemeris_path(path)
Arguments
  • path Filesystem path. For a kernel this is the .bsp file or the directory that holds it.
Result

Returns nothing. The call writes its output arguments, or it changes a library setting for later calls.

jme_fixstar

What it does Computes a named fixed star at Terrestrial Time.

When to use it Use this when you have TT and a catalogue name.

Where it fits Star longitudes on a chart. The UT form is jme_fixstar_ut.

Call jme_fixstar(star, jd_et, flags, results, error)
Arguments
  • star Star name in the fixed-star catalogue.
  • jd_et Terrestrial Time (TT) as a Julian date.
  • flags Flag bits for this call. Pass 0 for the default. The constant group for this family lists the bits.
  • results Caller-owned output array. Allocate it before the call.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_fixstar_ut

What it does Computes a named fixed star at Universal Time.

When to use it Use this when the clock is UT.

Where it fits The usual star position. Magnitude alone is jme_fixstar_mag.

Call jme_fixstar_ut(star, jd_ut, flags, results, error)
Arguments
  • star Star name in the fixed-star catalogue.
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
  • flags Flag bits for this call. Pass 0 for the default. The constant group for this family lists the bits.
  • results Caller-owned output array. Allocate it before the call.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_fixstar_mag

What it does Looks up the visual magnitude of a named star.

When to use it Use this when you need brightness and not a position.

Where it fits A star list. It does not depend on the date.

Call jme_fixstar_mag(star, mag, error)
Arguments
  • star Star name in the fixed-star catalogue.
  • mag Receives the visual magnitude.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_fixstar2

What it does Computes a named fixed star at Terrestrial Time, using the longer star-name interface.

When to use it Use this when the catalogue key does not fit the shorter star argument.

Where it fits Same result family as jme_fixstar. Prefer it for long traditional names.

Call jme_fixstar2(star, jd_et, flags, results, error)
Arguments
  • star Star name in the fixed-star catalogue.
  • jd_et Terrestrial Time (TT) as a Julian date.
  • flags Flag bits for this call. Pass 0 for the default. The constant group for this family lists the bits.
  • results Caller-owned output array. Allocate it before the call.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_fixstar2_ut

What it does Computes a named fixed star at Universal Time, using the longer star-name interface.

When to use it Use this when the clock is UT and the name is long.

Where it fits The UT pair of jme_fixstar2.

Call jme_fixstar2_ut(star, jd_ut, flags, results, error)
Arguments
  • star Star name in the fixed-star catalogue.
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
  • flags Flag bits for this call. Pass 0 for the default. The constant group for this family lists the bits.
  • results Caller-owned output array. Allocate it before the call.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_fixstar2_mag

What it does Looks up magnitude through the longer star-name interface.

When to use it Use this for a long catalogue key when you only need brightness.

Where it fits A star list, with no date.

Call jme_fixstar2_mag(star, mag, error)
Arguments
  • star Star name in the fixed-star catalogue.
  • mag Receives the visual magnitude.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_library_path

What it does Returns the filesystem path of the loaded library, when the platform provides it.

When to use it Use this in a diagnostic when several builds are installed and you need to see which file ran.

Where it fits A support screen, not a calculation.

Call jme_library_path()
Result

Returns the literal library identifier "jme". It is not a filesystem path.

Function group

General Utilities

Use these for nodes and apsides, a distance range, or a small Julian-date adjustment that is not a body position.

jme_nod_aps

What it does Computes the times of the nodes and apsides of a body at a Terrestrial Time epoch.

When to use it Use this when you need ascending node, descending node, perihelion, and aphelion near a TT date.

Where it fits Orbital geometry. method selects the algorithm.

Call jme_nod_aps(jd_et, body, flags, method, tret, error)
Arguments
  • jd_et Terrestrial Time (TT) as a Julian date.
  • body Body id such as JME_BODY_SUN. The body constants list every id.
  • flags Flag bits for this call. Pass 0 for the default. The constant group for this family lists the bits.
  • method Algorithm selector for nodes and apsides. Use the method values documented for this call.
  • tret Caller-owned array of Julian dates. The description says which index is which event.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_nod_aps_ut

What it does Computes nodes and apsides starting from Universal Time.

When to use it Use this when the epoch clock is UT.

Where it fits The UT pair of jme_nod_aps.

Call jme_nod_aps_ut(jd_ut, body, flags, method, tret, error)
Arguments
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
  • body Body id such as JME_BODY_SUN. The body constants list every id.
  • flags Flag bits for this call. Pass 0 for the default. The constant group for this family lists the bits.
  • method Algorithm selector for nodes and apsides. Use the method values documented for this call.
  • tret Caller-owned array of Julian dates. The description says which index is which event.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_orbit_max_min_true_distance

What it does Finds the nearby times and values of maximum and minimum true distance.

When to use it Use this when the question is how near and how far the body gets around this date.

Where it fits Distance ranges. Outputs are tmax, tmin, dmax, and dmin.

Call jme_orbit_max_min_true_distance(jd_et, body, flags, tmax, tmin, dmax, dmin, error)
Arguments
  • jd_et Terrestrial Time (TT) as a Julian date.
  • body Body id such as JME_BODY_SUN. The body constants list every id.
  • flags Flag bits for this call. Pass 0 for the default. The constant group for this family lists the bits.
  • tmax Receives the time of maximum true distance.
  • tmin Receives the time of minimum true distance.
  • dmax Receives the maximum true distance.
  • dmin Receives the minimum true distance.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_double_to_long

What it does Rounds a floating-point number to the nearest integer.

When to use it Use this for a display count, not for a longitude you will compute with again.

Where it fits Halfway cases move away from zero.

Call jme_double_to_long(x)
Arguments
  • x Number to round to the nearest integer, away from zero on a tie.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_jd_add_seconds

What it does Adds a number of seconds to a Julian date.

When to use it Use this to step a search or to apply a small clock correction without rebuilding the calendar date.

Where it fits The result is another Julian date.

Call jme_jd_add_seconds(jd, seconds)
Arguments
  • jd Julian date. The description of the call says which time scale that number is.
  • seconds A number of seconds to add, or the seconds field of a clock time.
Result

Returns the number described above. A non-finite value means the call could not produce that number.

Function group

Houses and Topocentric Geometry

Use these for a chart on Earth: the observer, the house cusps, and which house a longitude falls in. Set the place before a topocentric planet.

jme_set_topo

What it does Stores the observer longitude, latitude, and height for later topocentric calls.

When to use it Call it before any position, house, or rise that should be for a place rather than the geocentre.

Where it fits Once per observer. The checked form rejects a latitude outside -90 to 90.

Call jme_set_topo(lon, lat, altitude)
Arguments
  • lon Geographic longitude in degrees. East is positive. The checked setter wraps it into the half-open range around zero.
  • lat Geographic latitude in degrees. The checked setter rejects a value outside -90 to 90.
  • altitude Observer height in metres.
Result

Returns nothing. The call writes its output arguments, or it changes a library setting for later calls.

jme_houses

What it does Computes the twelve house cusps and the angles for a place at Universal Time.

When to use it Use this for a natal or horary chart when you do not need cusp speeds or extra flags.

Where it fits After you know UT, latitude, and longitude. Pick the system with a JME_HOUSE_* id.

Call jme_houses(jd_ut, geo_lat, geo_lon, house_system, cusps, ascmc)
Arguments
  • jd_ut Universal Time of the chart, as a Julian date.
  • geo_lat Geographic latitude in degrees. North is positive.
  • geo_lon Geographic longitude in degrees. East is positive.
  • house_system House-system id such as JME_HOUSE_PLACIDUS. Do not pass JME_HOUSE_GAUQUELIN to the 12-cusp calls.
  • cusps Caller-owned cusp array. Twelve-cusp calls use 13 numbers (index 1 to 12). Gauquelin calls use 37 numbers.
  • ascmc Caller-owned array for the Ascendant, Midheaven, and the other angles this call returns.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_houses_ex

What it does Computes house cusps with calculation flags such as sidereal or no nutation.

When to use it Use this when the houses must follow the same sidereal mode or nutation choice as the planets.

Where it fits A sidereal chart. Flags match the house flags documented for this call.

Call jme_houses_ex(jd_ut, flags, geo_lat, geo_lon, house_system, cusps, ascmc)
Arguments
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
  • flags Flag bits for this call. Pass 0 for the default. The constant group for this family lists the bits.
  • geo_lat Geographic latitude in degrees. North is positive.
  • geo_lon Geographic longitude in degrees. East is positive.
  • house_system House-system id such as JME_HOUSE_PLACIDUS. Do not pass JME_HOUSE_GAUQUELIN to the 12-cusp calls.
  • cusps Caller-owned cusp array. Twelve-cusp calls use 13 numbers (index 1 to 12). Gauquelin calls use 37 numbers.
  • ascmc Caller-owned array for the Ascendant, Midheaven, and the other angles this call returns.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_houses_ex2

What it does Computes house cusps and the speed of each cusp and angle.

When to use it Use this when a chart needs how fast the cusps are moving.

Where it fits The same place and time as jme_houses_ex, with two more output arrays.

Call jme_houses_ex2(jd_ut, flags, geo_lat, geo_lon, house_system, cusps, ascmc, cusps_speed, ascmc_speed)
Arguments
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
  • flags Flag bits for this call. Pass 0 for the default. The constant group for this family lists the bits.
  • geo_lat Geographic latitude in degrees. North is positive.
  • geo_lon Geographic longitude in degrees. East is positive.
  • house_system House-system id such as JME_HOUSE_PLACIDUS. Do not pass JME_HOUSE_GAUQUELIN to the 12-cusp calls.
  • cusps Caller-owned cusp array. Twelve-cusp calls use 13 numbers (index 1 to 12). Gauquelin calls use 37 numbers.
  • ascmc Caller-owned array for the Ascendant, Midheaven, and the other angles this call returns.
  • cusps_speed Caller-owned array for the rate of each cusp. Use the same length as cusps.
  • ascmc_speed Caller-owned array for the rate of each angle in ascmc.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_houses_armc

What it does Computes house cusps from the right ascension of the Midheaven and the obliquity.

When to use it Use this when you already have RAMC and obliquity and you do not want the call to derive them from UT.

Where it fits A house routine downstream of your own sidereal time.

Call jme_houses_armc(armc, geo_lat, eps, house_system, cusps, ascmc)
Arguments
  • armc Right ascension of the Midheaven, in degrees.
  • geo_lat Geographic latitude in degrees. North is positive.
  • eps Obliquity of the ecliptic, in degrees, at the date you are using.
  • house_system House-system id such as JME_HOUSE_PLACIDUS. Do not pass JME_HOUSE_GAUQUELIN to the 12-cusp calls.
  • cusps Caller-owned cusp array. Twelve-cusp calls use 13 numbers (index 1 to 12). Gauquelin calls use 37 numbers.
  • ascmc Caller-owned array for the Ascendant, Midheaven, and the other angles this call returns.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_houses_armc_ex2

What it does Computes house cusps and their speeds from RAMC and obliquity.

When to use it Use this when you have RAMC and you also need cusp rates.

Where it fits The speed-aware pair of jme_houses_armc.

Call jme_houses_armc_ex2(armc, geo_lat, eps, house_system, cusps, ascmc, cusps_speed, ascmc_speed)
Arguments
  • armc Right ascension of the Midheaven, in degrees.
  • geo_lat Geographic latitude in degrees. North is positive.
  • eps Obliquity of the ecliptic, in degrees, at the date you are using.
  • house_system House-system id such as JME_HOUSE_PLACIDUS. Do not pass JME_HOUSE_GAUQUELIN to the 12-cusp calls.
  • cusps Caller-owned cusp array. Twelve-cusp calls use 13 numbers (index 1 to 12). Gauquelin calls use 37 numbers.
  • ascmc Caller-owned array for the Ascendant, Midheaven, and the other angles this call returns.
  • cusps_speed Caller-owned array for the rate of each cusp. Use the same length as cusps.
  • ascmc_speed Caller-owned array for the rate of each angle in ascmc.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_house_pos

What it does Returns the house number, with a fraction, of one ecliptic longitude.

When to use it Use this after the cusps exist and you want 'which house is this planet in'.

Where it fits Per body, once the angles are known. xpin[0] is the longitude. A missing system returns a non-finite value.

Call jme_house_pos(armc, geo_lat, eps, house_system, xpin, error)
Arguments
  • armc Right ascension of the Midheaven, in degrees.
  • geo_lat Geographic latitude in degrees. North is positive.
  • eps Obliquity of the ecliptic, in degrees, at the date you are using.
  • house_system House-system id such as JME_HOUSE_PLACIDUS. Do not pass JME_HOUSE_GAUQUELIN to the 12-cusp calls.
  • xpin Ecliptic longitude of the point, in degrees, in the first element.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns the house position as a number such as 1.25 for a point a quarter of the way through house 1. Returns a non-finite value, and writes error, when the house system is unavailable.

jme_gauquelin_sector

What it does Computes the Gauquelin sector of one body or star for an observer.

When to use it Use this when you need the sector number of a single body, not the whole cusp list.

Where it fits After the observer place is known. imeth selects the sector method.

Call jme_gauquelin_sector(jd_ut, body, starname, flags, imeth, geopos, atpress, attemp, dgsect, error)
Arguments
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
  • body Body id such as JME_BODY_SUN. The body constants list every id.
  • starname Star name. Use an empty string when the call is for a solar-system body.
  • flags Flag bits for this call. Pass 0 for the default. The constant group for this family lists the bits.
  • imeth Gauquelin method selector for the sector division.
  • geopos Observer longitude, latitude, and height, in that order, in degrees and metres.
  • atpress Atmospheric pressure at the observer, in millibars.
  • attemp Atmospheric temperature at the observer, in degrees Celsius.
  • dgsect Receives the Gauquelin sector number.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_get_topo_pos

What it does Returns the observer position in astronomical units at Terrestrial Time.

When to use it Use this when a topocentric vector must start from the stored observer.

Where it fits After jme_set_topo. Polar motion is applied only when that option is on.

Call jme_get_topo_pos(jd_et, pos_au, error)
Arguments
  • jd_et Terrestrial Time (TT) as a Julian date.
  • pos_au Receives the observer position in astronomical units.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_equatorial_to_horizontal

What it does Converts hour angle and declination to azimuth and altitude.

When to use it Use this for a sky position at a known latitude: is the body up, and where.

Where it fits After you have the hour angle. Refraction is separate, in jme_refract.

Call jme_equatorial_to_horizontal(hour_angle, dec, geo_lat, azimuth, altitude)
Arguments
  • hour_angle Hour angle in degrees, or the variable that receives it.
  • dec Declination in degrees, or the variable that receives it.
  • geo_lat Geographic latitude in degrees. North is positive.
  • azimuth Receives azimuth.
  • altitude Height. For an observer this is metres. For refraction this is the altitude angle in degrees.
Result

Returns nothing. The call writes its output arguments, or it changes a library setting for later calls.

jme_horizontal_to_equatorial

What it does Converts azimuth and altitude to hour angle and declination.

When to use it Use this when the observation is a horizon reading and you need the equator.

Where it fits You supply the observer latitude.

Call jme_horizontal_to_equatorial(azimuth, altitude, geo_lat, hour_angle, dec)
Arguments
  • azimuth Receives azimuth.
  • altitude Height. For an observer this is metres. For refraction this is the altitude angle in degrees.
  • geo_lat Geographic latitude in degrees. North is positive.
  • hour_angle Hour angle in degrees, or the variable that receives it.
  • dec Declination in degrees, or the variable that receives it.
Result

Returns nothing. The call writes its output arguments, or it changes a library setting for later calls.

jme_house_system_name

What it does Returns the display name of a house-system id.

When to use it Use this to label a JME_HOUSE_* value in a menu.

Where it fits Gauquelin sectors are computed by jme_houses_gauquelin, not by passing that id to jme_houses.

Call jme_house_system_name(house_system)
Arguments
  • house_system House-system id such as JME_HOUSE_PLACIDUS. Do not pass JME_HOUSE_GAUQUELIN to the 12-cusp calls.
Result

Returns a pointer to a static display name, or NULL for an unknown id.

Function group

JPL and CALCEPH Kernels

Use these only when you read a .bsp kernel yourself. Open the file first. The date is the kernel's own time scale, not Universal Time, except for the calls whose names say utc.

jme_jpl_file

What it does Returns the kernel path currently selected for the high-level engine.

When to use it Call it to confirm which file ENGINE=JPL will open.

Where it fits After jme_set_jpl_file.

Call jme_jpl_file()
Result

Returns the text. When you pass buffer, the text is written there and the return points at that buffer.

jme_set_jpl_file

What it does Selects the .bsp file used by the high-level JPL engine. The kernel is opened lazily on the next high-level calculation.

When to use it Call it when ENGINE=JPL or ENGINE=AUTO should read a kernel.

Where it fits Startup, before jme_calc. Low-level reads use jme_jpl_open instead.

Call jme_set_jpl_file(path)
Arguments
  • path Filesystem path to a .bsp file, or a relative kernel name resolved against jme_set_ephemeris_path().
Result

Returns nothing. The call writes its output arguments, or it changes a library setting for later calls.

jme_jpl_body_state

What it does Reads the position and velocity from the open kernel at one Julian date on the kernel's native time scale (TDB or TCB), identified by JME body ids. unit selects AU or kilometres, and per day or per second.

When to use it Use this low-level read when you have one Julian date already expressed on the kernel time scale and you want the kernel vector rather than the ecliptic place from jme_calc.

Where it fits After jme_jpl_open. Do not pass UT here. For a civil clock and an ecliptic longitude, use jme_calc_ut.

Call jme_jpl_body_state(jd_time, target_body, center_body, unit, state, error)
Arguments
  • jd_time Input or output for this call. The name is the shared argument name.
  • target_body Body id of the object you want.
  • center_body Body id of the origin of the vector. The solar-system barycentre and the Earth are both valid centers when the kernel has them.
  • unit Output unit. Position calls use a JME_VECTOR_* id. Orientation calls use a JME_ORIENTATION_* id.
  • state Caller-owned state array. Position calls use six numbers: position, then velocity.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_body_state_split

What it does Reads the position and velocity from the open kernel at a split Julian date (jd0 + time_offset) on the kernel's native time scale, identified by JME body ids. unit selects AU or kilometres, and per day or per second.

When to use it Use this low-level read when you already hold a split Julian date and need to keep that split and you want the kernel vector rather than the ecliptic place from jme_calc.

Where it fits After jme_jpl_open. Do not pass UT here. For a civil clock and an ecliptic longitude, use jme_calc_ut.

Call jme_jpl_body_state_split(jd0, time_offset, target_body, center_body, unit, state, error)
Arguments
  • jd0 Coarse part of a split Julian date on the kernel time scale.
  • time_offset Small part added to jd0, so the split date keeps its digits.
  • target_body Body id of the object you want.
  • center_body Body id of the origin of the vector. The solar-system barycentre and the Earth are both valid centers when the kernel has them.
  • unit Output unit. Position calls use a JME_VECTOR_* id. Orientation calls use a JME_ORIENTATION_* id.
  • state Caller-owned state array. Position calls use six numbers: position, then velocity.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_ecliptic_state

What it does Reads the ecliptic position and velocity from the open kernel at one Julian date on the kernel's native time scale (TDB or TCB), identified by JME body ids. unit selects AU or kilometres, and per day or per second.

When to use it Use this low-level read when you have one Julian date already expressed on the kernel time scale and you want the kernel vector rather than the ecliptic place from jme_calc.

Where it fits After jme_jpl_open. Do not pass UT here. For a civil clock and an ecliptic longitude, use jme_calc_ut.

Call jme_jpl_ecliptic_state(jd_time, target_body, center_body, unit, state, error)
Arguments
  • jd_time Input or output for this call. The name is the shared argument name.
  • target_body Body id of the object you want.
  • center_body Body id of the origin of the vector. The solar-system barycentre and the Earth are both valid centers when the kernel has them.
  • unit Output unit. Position calls use a JME_VECTOR_* id. Orientation calls use a JME_ORIENTATION_* id.
  • state Caller-owned state array. Position calls use six numbers: position, then velocity.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_body_state_naif

What it does Reads the position and velocity from the open kernel at one Julian date on the kernel's native time scale (TDB or TCB), identified by NAIF ids. unit selects AU or kilometres, and per day or per second.

When to use it Use this low-level read when you have one Julian date already expressed on the kernel time scale and you want the kernel vector rather than the ecliptic place from jme_calc.

Where it fits After jme_jpl_open. Do not pass UT here. For a civil clock and an ecliptic longitude, use jme_calc_ut.

Call jme_jpl_body_state_naif(jd_time, target_naif, center_naif, unit, state, error)
Arguments
  • jd_time Input or output for this call. The name is the shared argument name.
  • target_naif NAIF id of the object, as stored in the kernel.
  • center_naif NAIF id of the origin of the vector.
  • unit Output unit. Position calls use a JME_VECTOR_* id. Orientation calls use a JME_ORIENTATION_* id.
  • state Caller-owned state array. Position calls use six numbers: position, then velocity.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_body_state_split_naif

What it does Reads the position and velocity from the open kernel at a split Julian date (jd0 + time_offset) on the kernel's native time scale, identified by NAIF ids. unit selects AU or kilometres, and per day or per second.

When to use it Use this low-level read when you already hold a split Julian date and need to keep that split and you want the kernel vector rather than the ecliptic place from jme_calc.

Where it fits After jme_jpl_open. Do not pass UT here. For a civil clock and an ecliptic longitude, use jme_calc_ut.

Call jme_jpl_body_state_split_naif(jd0, time_offset, target_naif, center_naif, unit, state, error)
Arguments
  • jd0 Coarse part of a split Julian date on the kernel time scale.
  • time_offset Small part added to jd0, so the split date keeps its digits.
  • target_naif NAIF id of the object, as stored in the kernel.
  • center_naif NAIF id of the origin of the vector.
  • unit Output unit. Position calls use a JME_VECTOR_* id. Orientation calls use a JME_ORIENTATION_* id.
  • state Caller-owned state array. Position calls use six numbers: position, then velocity.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_body_state_native_naif

What it does Reads the position and velocity from the open kernel at one Julian date on the kernel's native time scale (TDB or TCB), identified by NAIF ids. The numbers stay in the kernel's native units.

When to use it Use this low-level read when you have one Julian date already expressed on the kernel time scale and you want the kernel vector rather than the ecliptic place from jme_calc.

Where it fits After jme_jpl_open. Do not pass UT here. For a civil clock and an ecliptic longitude, use jme_calc_ut.

Call jme_jpl_body_state_native_naif(jd_time, target_naif, center_naif, state, error)
Arguments
  • jd_time Input or output for this call. The name is the shared argument name.
  • target_naif NAIF id of the object, as stored in the kernel.
  • center_naif NAIF id of the origin of the vector.
  • state Caller-owned state array. Position calls use six numbers: position, then velocity.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_body_state_native

What it does Reads the position and velocity from the open kernel at one Julian date on the kernel's native time scale (TDB or TCB), identified by JME body ids. The numbers stay in the kernel's native units.

When to use it Use this low-level read when you have one Julian date already expressed on the kernel time scale and you want the kernel vector rather than the ecliptic place from jme_calc.

Where it fits After jme_jpl_open. Do not pass UT here. For a civil clock and an ecliptic longitude, use jme_calc_ut.

Call jme_jpl_body_state_native(jd_time, target_body, center_body, state, error)
Arguments
  • jd_time Input or output for this call. The name is the shared argument name.
  • target_body Body id of the object you want.
  • center_body Body id of the origin of the vector. The solar-system barycentre and the Earth are both valid centers when the kernel has them.
  • state Caller-owned state array. Position calls use six numbers: position, then velocity.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_body_state_native_split_naif

What it does Reads the position and velocity from the open kernel at a split Julian date (jd0 + time_offset) on the kernel's native time scale, identified by NAIF ids. The numbers stay in the kernel's native units.

When to use it Use this low-level read when you already hold a split Julian date and need to keep that split and you want the kernel vector rather than the ecliptic place from jme_calc.

Where it fits After jme_jpl_open. Do not pass UT here. For a civil clock and an ecliptic longitude, use jme_calc_ut.

Call jme_jpl_body_state_native_split_naif(jd0, time_offset, target_naif, center_naif, state, error)
Arguments
  • jd0 Coarse part of a split Julian date on the kernel time scale.
  • time_offset Small part added to jd0, so the split date keeps its digits.
  • target_naif NAIF id of the object, as stored in the kernel.
  • center_naif NAIF id of the origin of the vector.
  • state Caller-owned state array. Position calls use six numbers: position, then velocity.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_body_state_native_split

What it does Reads the position and velocity from the open kernel at a split Julian date (jd0 + time_offset) on the kernel's native time scale, identified by JME body ids. The numbers stay in the kernel's native units.

When to use it Use this low-level read when you already hold a split Julian date and need to keep that split and you want the kernel vector rather than the ecliptic place from jme_calc.

Where it fits After jme_jpl_open. Do not pass UT here. For a civil clock and an ecliptic longitude, use jme_calc_ut.

Call jme_jpl_body_state_native_split(jd0, time_offset, target_body, center_body, state, error)
Arguments
  • jd0 Coarse part of a split Julian date on the kernel time scale.
  • time_offset Small part added to jd0, so the split date keeps its digits.
  • target_body Body id of the object you want.
  • center_body Body id of the origin of the vector. The solar-system barycentre and the Earth are both valid centers when the kernel has them.
  • state Caller-owned state array. Position calls use six numbers: position, then velocity.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_body_state_order_naif

What it does Reads the position and velocity from the open kernel at a split Julian date (jd0 + time_offset) on the kernel's native time scale, identified by NAIF ids. order asks for derivatives beyond velocity. unit selects AU or kilometres, and per day or per second.

When to use it Use this low-level read when you already hold a split Julian date and need to keep that split and you want the kernel vector rather than the ecliptic place from jme_calc.

Where it fits After jme_jpl_open. Do not pass UT here. For a civil clock and an ecliptic longitude, use jme_calc_ut.

Call jme_jpl_body_state_order_naif(jd0, time_offset, target_naif, center_naif, unit, order, state, error)
Arguments
  • jd0 Coarse part of a split Julian date on the kernel time scale.
  • time_offset Small part added to jd0, so the split date keeps its digits.
  • target_naif NAIF id of the object, as stored in the kernel.
  • center_naif NAIF id of the origin of the vector.
  • unit Output unit. Position calls use a JME_VECTOR_* id. Orientation calls use a JME_ORIENTATION_* id.
  • order Highest derivative to return. Zero is position only.
  • state Caller-owned state array. Position calls use six numbers: position, then velocity.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_body_state_order

What it does Reads the position and velocity from the open kernel at a split Julian date (jd0 + time_offset) on the kernel's native time scale, identified by JME body ids. order asks for derivatives beyond velocity. unit selects AU or kilometres, and per day or per second.

When to use it Use this low-level read when you already hold a split Julian date and need to keep that split and you want the kernel vector rather than the ecliptic place from jme_calc.

Where it fits After jme_jpl_open. Do not pass UT here. For a civil clock and an ecliptic longitude, use jme_calc_ut.

Call jme_jpl_body_state_order(jd0, time_offset, target_body, center_body, unit, order, state, error)
Arguments
  • jd0 Coarse part of a split Julian date on the kernel time scale.
  • time_offset Small part added to jd0, so the split date keeps its digits.
  • target_body Body id of the object you want.
  • center_body Body id of the origin of the vector. The solar-system barycentre and the Earth are both valid centers when the kernel has them.
  • unit Output unit. Position calls use a JME_VECTOR_* id. Orientation calls use a JME_ORIENTATION_* id.
  • order Highest derivative to return. Zero is position only.
  • state Caller-owned state array. Position calls use six numbers: position, then velocity.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_body_state_utc_naif

What it does Reads the position and velocity from the open kernel at a UTC calendar date, converted inside the call onto the kernel time scale, identified by NAIF ids. unit selects AU or kilometres, and per day or per second.

When to use it Use this low-level read when the time you have is a UTC calendar date and you want the kernel vector rather than the ecliptic place from jme_calc.

Where it fits After jme_jpl_open. Do not pass UT here. For a civil clock and an ecliptic longitude, use jme_calc_ut.

Call jme_jpl_body_state_utc_naif(year, month, day, hour, minute, second, calendar, target_naif, center_naif, unit, state, error)
Arguments
  • year Calendar year. Astronomical year numbering, so 1 BCE is year 0.
  • month Month number from 1 to 12.
  • day Day of the month.
  • hour Hour. Where the call takes a decimal hour, fractions of an hour are allowed.
  • minute Minute.
  • second Second, including the fraction. A leap second 60 is accepted only on a UTC path that validates it.
  • calendar JME_CALENDAR_GREGORIAN or JME_CALENDAR_JULIAN.
  • target_naif NAIF id of the object, as stored in the kernel.
  • center_naif NAIF id of the origin of the vector.
  • unit Output unit. Position calls use a JME_VECTOR_* id. Orientation calls use a JME_ORIENTATION_* id.
  • state Caller-owned state array. Position calls use six numbers: position, then velocity.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_body_state_utc

What it does Reads the position and velocity from the open kernel at a UTC calendar date, converted inside the call onto the kernel time scale, identified by JME body ids. unit selects AU or kilometres, and per day or per second.

When to use it Use this low-level read when the time you have is a UTC calendar date and you want the kernel vector rather than the ecliptic place from jme_calc.

Where it fits After jme_jpl_open. Do not pass UT here. For a civil clock and an ecliptic longitude, use jme_calc_ut.

Call jme_jpl_body_state_utc(year, month, day, hour, minute, second, calendar, target_body, center_body, unit, state, error)
Arguments
  • year Calendar year. Astronomical year numbering, so 1 BCE is year 0.
  • month Month number from 1 to 12.
  • day Day of the month.
  • hour Hour. Where the call takes a decimal hour, fractions of an hour are allowed.
  • minute Minute.
  • second Second, including the fraction. A leap second 60 is accepted only on a UTC path that validates it.
  • calendar JME_CALENDAR_GREGORIAN or JME_CALENDAR_JULIAN.
  • target_body Body id of the object you want.
  • center_body Body id of the origin of the vector. The solar-system barycentre and the Earth are both valid centers when the kernel has them.
  • unit Output unit. Position calls use a JME_VECTOR_* id. Orientation calls use a JME_ORIENTATION_* id.
  • state Caller-owned state array. Position calls use six numbers: position, then velocity.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_ecliptic_state_naif

What it does Reads the ecliptic position and velocity from the open kernel at one Julian date on the kernel's native time scale (TDB or TCB), identified by NAIF ids. unit selects AU or kilometres, and per day or per second.

When to use it Use this low-level read when you have one Julian date already expressed on the kernel time scale and you want the kernel vector rather than the ecliptic place from jme_calc.

Where it fits After jme_jpl_open. Do not pass UT here. For a civil clock and an ecliptic longitude, use jme_calc_ut.

Call jme_jpl_ecliptic_state_naif(jd_time, target_naif, center_naif, unit, state, error)
Arguments
  • jd_time Input or output for this call. The name is the shared argument name.
  • target_naif NAIF id of the object, as stored in the kernel.
  • center_naif NAIF id of the origin of the vector.
  • unit Output unit. Position calls use a JME_VECTOR_* id. Orientation calls use a JME_ORIENTATION_* id.
  • state Caller-owned state array. Position calls use six numbers: position, then velocity.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_ecliptic_state_split

What it does Reads the ecliptic position and velocity from the open kernel at a split Julian date (jd0 + time_offset) on the kernel's native time scale, identified by JME body ids. unit selects AU or kilometres, and per day or per second.

When to use it Use this low-level read when you already hold a split Julian date and need to keep that split and you want the kernel vector rather than the ecliptic place from jme_calc.

Where it fits After jme_jpl_open. Do not pass UT here. For a civil clock and an ecliptic longitude, use jme_calc_ut.

Call jme_jpl_ecliptic_state_split(jd0, time_offset, target_body, center_body, unit, state, error)
Arguments
  • jd0 Coarse part of a split Julian date on the kernel time scale.
  • time_offset Small part added to jd0, so the split date keeps its digits.
  • target_body Body id of the object you want.
  • center_body Body id of the origin of the vector. The solar-system barycentre and the Earth are both valid centers when the kernel has them.
  • unit Output unit. Position calls use a JME_VECTOR_* id. Orientation calls use a JME_ORIENTATION_* id.
  • state Caller-owned state array. Position calls use six numbers: position, then velocity.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_ecliptic_state_split_naif

What it does Reads the ecliptic position and velocity from the open kernel at a split Julian date (jd0 + time_offset) on the kernel's native time scale, identified by NAIF ids. unit selects AU or kilometres, and per day or per second.

When to use it Use this low-level read when you already hold a split Julian date and need to keep that split and you want the kernel vector rather than the ecliptic place from jme_calc.

Where it fits After jme_jpl_open. Do not pass UT here. For a civil clock and an ecliptic longitude, use jme_calc_ut.

Call jme_jpl_ecliptic_state_split_naif(jd0, time_offset, target_naif, center_naif, unit, state, error)
Arguments
  • jd0 Coarse part of a split Julian date on the kernel time scale.
  • time_offset Small part added to jd0, so the split date keeps its digits.
  • target_naif NAIF id of the object, as stored in the kernel.
  • center_naif NAIF id of the origin of the vector.
  • unit Output unit. Position calls use a JME_VECTOR_* id. Orientation calls use a JME_ORIENTATION_* id.
  • state Caller-owned state array. Position calls use six numbers: position, then velocity.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_ecliptic_state_utc_naif

What it does Reads the ecliptic position and velocity from the open kernel at a UTC calendar date, converted inside the call onto the kernel time scale, identified by NAIF ids. unit selects AU or kilometres, and per day or per second.

When to use it Use this low-level read when the time you have is a UTC calendar date and you want the kernel vector rather than the ecliptic place from jme_calc.

Where it fits After jme_jpl_open. Do not pass UT here. For a civil clock and an ecliptic longitude, use jme_calc_ut.

Call jme_jpl_ecliptic_state_utc_naif(year, month, day, hour, minute, second, calendar, target_naif, center_naif, unit, state, error)
Arguments
  • year Calendar year. Astronomical year numbering, so 1 BCE is year 0.
  • month Month number from 1 to 12.
  • day Day of the month.
  • hour Hour. Where the call takes a decimal hour, fractions of an hour are allowed.
  • minute Minute.
  • second Second, including the fraction. A leap second 60 is accepted only on a UTC path that validates it.
  • calendar JME_CALENDAR_GREGORIAN or JME_CALENDAR_JULIAN.
  • target_naif NAIF id of the object, as stored in the kernel.
  • center_naif NAIF id of the origin of the vector.
  • unit Output unit. Position calls use a JME_VECTOR_* id. Orientation calls use a JME_ORIENTATION_* id.
  • state Caller-owned state array. Position calls use six numbers: position, then velocity.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_ecliptic_state_utc

What it does Reads the ecliptic position and velocity from the open kernel at a UTC calendar date, converted inside the call onto the kernel time scale, identified by JME body ids. unit selects AU or kilometres, and per day or per second.

When to use it Use this low-level read when the time you have is a UTC calendar date and you want the kernel vector rather than the ecliptic place from jme_calc.

Where it fits After jme_jpl_open. Do not pass UT here. For a civil clock and an ecliptic longitude, use jme_calc_ut.

Call jme_jpl_ecliptic_state_utc(year, month, day, hour, minute, second, calendar, target_body, center_body, unit, state, error)
Arguments
  • year Calendar year. Astronomical year numbering, so 1 BCE is year 0.
  • month Month number from 1 to 12.
  • day Day of the month.
  • hour Hour. Where the call takes a decimal hour, fractions of an hour are allowed.
  • minute Minute.
  • second Second, including the fraction. A leap second 60 is accepted only on a UTC path that validates it.
  • calendar JME_CALENDAR_GREGORIAN or JME_CALENDAR_JULIAN.
  • target_body Body id of the object you want.
  • center_body Body id of the origin of the vector. The solar-system barycentre and the Earth are both valid centers when the kernel has them.
  • unit Output unit. Position calls use a JME_VECTOR_* id. Orientation calls use a JME_ORIENTATION_* id.
  • state Caller-owned state array. Position calls use six numbers: position, then velocity.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_close

What it does Closes the kernel opened for the low-level JPL calls.

When to use it Call it when you are finished with jme_jpl_body_state and the other kernel reads.

Where it fits The high-level engine has its own file selection through jme_set_jpl_file.

Call jme_jpl_close()
Result

Returns nothing. The call writes its output arguments, or it changes a library setting for later calls.

jme_jpl_coverage

What it does Reports the first time, last time, and whether the open kernel coverage is continuous.

When to use it Call it before a date that might fall outside the file.

Where it fits After jme_jpl_open.

Call jme_jpl_coverage(first_time, last_time, continuous, error)
Arguments
  • first_time Receives the first time the kernel covers.
  • last_time Receives the last time the kernel covers.
  • continuous Receives non-zero when the coverage has no gap.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_constant

What it does Reads one numeric constant from the open kernel by name.

When to use it Use this for a kernel header value such as a defined constant the file publishes.

Where it fits After the kernel is open. The name is the kernel's own constant name.

Call jme_jpl_constant(name, value, error)
Arguments
  • name Name to look up, or the buffer that receives a name.
  • value Receives one numeric kernel constant.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_constant_count

What it does Returns how many constants the open kernel publishes.

When to use it Use this before you loop with jme_jpl_constant_index.

Where it fits A kernel inspection screen.

Call jme_jpl_constant_count(error)
Arguments
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_constant_index

What it does Reads one kernel constant by its index, returning the name and the value.

When to use it Use this to list every constant when you do not know the names.

Where it fits Index runs from zero to one less than jme_jpl_constant_count.

Call jme_jpl_constant_index(index, name, name_size, value, error)
Arguments
  • index Zero-based index into the kernel list you are reading.
  • name Name to look up, or the buffer that receives a name.
  • name_size Size of the name buffer, in bytes.
  • value Receives one numeric kernel constant.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_constant_vector

What it does Reads a numeric kernel constant that has several values.

When to use it Use this when jme_jpl_constant is the wrong shape because the constant is a vector.

Where it fits value_count is how many numbers you allocated.

Call jme_jpl_constant_vector(name, values, value_count, error)
Arguments
  • name Name to look up, or the buffer that receives a name.
  • values Receives several numeric kernel constants, or the text buffer for a string vector.
  • value_count How many values to write.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_constant_string

What it does Reads a text kernel constant by name.

When to use it Use this for a kernel constant that is a string rather than a number.

Where it fits value is your buffer.

Call jme_jpl_constant_string(name, value, value_size, error)
Arguments
  • name Name to look up, or the buffer that receives a name.
  • value Receives one numeric kernel constant.
  • value_size Size of one text value, in bytes.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_constant_string_vector

What it does Reads a kernel constant that is a list of strings.

When to use it Use this when the constant is several text values.

Where it fits Each slot is single_value_size bytes.

Call jme_jpl_constant_string_vector(name, values, single_value_size, value_count, error)
Arguments
  • name Name to look up, or the buffer that receives a name.
  • values Receives several numeric kernel constants, or the text buffer for a string vector.
  • single_value_size Size of each text slot in the string vector.
  • value_count How many values to write.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_engine_version

What it does Copies the CALCEPH build version into buffer.

When to use it Call it in a diagnostic next to jme_version, so you can see the kernel library as well as JME.

Where it fits It does not need a kernel to be open.

Call jme_jpl_engine_version(buffer, buffer_size)
Arguments
  • buffer Caller-owned character buffer. The call writes the text here.
  • buffer_size Size of buffer, in bytes, including room for the terminating zero.
Result

Returns the text. When you pass buffer, the text is written there and the return points at that buffer.

jme_jpl_file_version

What it does Copies the open kernel's file version into buffer.

When to use it Use this to record which kernel edition produced a result.

Where it fits After jme_jpl_open.

Call jme_jpl_file_version(buffer, buffer_size, error)
Arguments
  • buffer Caller-owned character buffer. The call writes the text here.
  • buffer_size Size of buffer, in bytes, including room for the terminating zero.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_current_file_data

What it does Reports the open kernel path and its coverage in one call.

When to use it Use this on a status screen instead of calling path and coverage separately.

Where it fits After jme_jpl_open.

Call jme_jpl_current_file_data(path, path_size, first_time, last_time, continuous, error)
Arguments
  • path Filesystem path. For a kernel this is the .bsp file or the directory that holds it.
  • path_size Size of the path buffer, in bytes.
  • first_time Receives the first time the kernel covers.
  • last_time Receives the last time the kernel covers.
  • continuous Receives non-zero when the coverage has no gap.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_is_available

What it does Reports whether this build of JME was linked with CALCEPH.

When to use it Call it before you offer a JPL mode. A build without CALCEPH cannot open a kernel.

Where it fits Startup. The analytical engines still work when this returns false.

Call jme_jpl_is_available()
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_jpl_is_open

What it does Reports whether a kernel is currently open.

When to use it Call it before a low-level state read.

Where it fits After jme_jpl_open or jme_jpl_close.

Call jme_jpl_is_open()
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_jpl_open

What it does Opens one kernel file for the low-level JPL calls.

When to use it Call it when you will use jme_jpl_body_state rather than jme_calc.

Where it fits A planet-centre that lives in a second file needs jme_jpl_open_array.

Call jme_jpl_open(path, error)
Arguments
  • path Filesystem path. For a kernel this is the .bsp file or the directory that holds it.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_open_array

What it does Opens several kernel files together.

When to use it Use this for a planetary kernel plus the satellite kernels that hold planet centres.

Where it fits paths lists the files. This is how you avoid substituting a system barycentre.

Call jme_jpl_open_array(path_count, paths, error)
Arguments
  • path_count How many kernel paths are in the list.
  • paths List of kernel paths to open together, for a planet kernel plus its satellite kernels.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_prefetch

What it does Asks the kernel library to read ahead.

When to use it Use this before a tight loop of state calls when you want the file cached.

Where it fits After the kernel is open, before the loop.

Call jme_jpl_prefetch(error)
Arguments
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_is_thread_safe

What it does Reports whether this CALCEPH build may be called from more than one thread.

When to use it Call it before you share one open kernel across threads.

Where it fits A negative answer means you keep the JPL calls on one thread.

Call jme_jpl_is_thread_safe(error)
Arguments
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_id_by_name

What it does Looks up a kernel object id from its name.

When to use it Use this when the user has a kernel name and the state call wants an id.

Where it fits After the kernel is open.

Call jme_jpl_id_by_name(name, id, error)
Arguments
  • name Name to look up, or the buffer that receives a name.
  • id Receives a body or kernel id.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_name_by_id

What it does Looks up a kernel object name from its id.

When to use it Use this to label a NAIF id.

Where it fits After the kernel is open.

Call jme_jpl_name_by_id(id, name, name_size, error)
Arguments
  • id Receives a body or kernel id.
  • name Name to look up, or the buffer that receives a name.
  • name_size Size of the name buffer, in bytes.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_max_supported_order

What it does Returns the highest derivative order a kernel segment type can provide.

When to use it Call it before jme_jpl_body_state_order when you might ask for a derivative the segment does not have.

Where it fits segment_type comes from a record-index call.

Call jme_jpl_max_supported_order(segment_type)
Arguments
  • segment_type Kernel segment type, used to ask which derivative order that segment can return.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_jpl_position_record_count

What it does Returns how many position records the open kernel contains.

When to use it Use this before you loop with jme_jpl_position_record_index.

Where it fits A kernel inventory.

Call jme_jpl_position_record_count(error)
Arguments
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_position_record_index

What it does Reads one position record: target, centre, time span, frame, and segment type.

When to use it Use this to see which bodies the file can actually compute.

Where it fits Index runs from zero to one less than the record count.

Call jme_jpl_position_record_index(index, target, center, first_time, last_time, frame, segment_type, error)
Arguments
  • index Zero-based index into the kernel list you are reading.
  • target Receives the target id of one kernel record.
  • center Body id used as the origin instead of the default centre.
  • first_time Receives the first time the kernel covers.
  • last_time Receives the last time the kernel covers.
  • frame Receives the frame id of one kernel record.
  • segment_type Kernel segment type, used to ask which derivative order that segment can return.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_orientation_state_naif

What it does Reads the orientation state from the open kernel at one Julian date on the kernel's native time scale (TDB or TCB), identified by NAIF ids. unit selects radians per day or radians per second.

When to use it Use this low-level read when you have one Julian date already expressed on the kernel time scale and you want the kernel vector rather than the ecliptic place from jme_calc.

Where it fits After jme_jpl_open. Do not pass UT here. For a civil clock and an ecliptic longitude, use jme_calc_ut.

Call jme_jpl_orientation_state_naif(jd_time, target_naif, unit, state, error)
Arguments
  • jd_time Input or output for this call. The name is the shared argument name.
  • target_naif NAIF id of the object, as stored in the kernel.
  • unit Output unit. Position calls use a JME_VECTOR_* id. Orientation calls use a JME_ORIENTATION_* id.
  • state Caller-owned state array. Position calls use six numbers: position, then velocity.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_orientation_state_split_naif

What it does Reads the orientation state from the open kernel at a split Julian date (jd0 + time_offset) on the kernel's native time scale, identified by NAIF ids. unit selects radians per day or radians per second.

When to use it Use this low-level read when you already hold a split Julian date and need to keep that split and you want the kernel vector rather than the ecliptic place from jme_calc.

Where it fits After jme_jpl_open. Do not pass UT here. For a civil clock and an ecliptic longitude, use jme_calc_ut.

Call jme_jpl_orientation_state_split_naif(jd0, time_offset, target_naif, unit, state, error)
Arguments
  • jd0 Coarse part of a split Julian date on the kernel time scale.
  • time_offset Small part added to jd0, so the split date keeps its digits.
  • target_naif NAIF id of the object, as stored in the kernel.
  • unit Output unit. Position calls use a JME_VECTOR_* id. Orientation calls use a JME_ORIENTATION_* id.
  • state Caller-owned state array. Position calls use six numbers: position, then velocity.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_orientation_state_order_naif

What it does Reads the orientation state from the open kernel at a split Julian date (jd0 + time_offset) on the kernel's native time scale, identified by NAIF ids. order asks for derivatives beyond velocity. unit selects radians per day or radians per second.

When to use it Use this low-level read when you already hold a split Julian date and need to keep that split and you want the kernel vector rather than the ecliptic place from jme_calc.

Where it fits After jme_jpl_open. Do not pass UT here. For a civil clock and an ecliptic longitude, use jme_calc_ut.

Call jme_jpl_orientation_state_order_naif(jd0, time_offset, target_naif, unit, order, state, error)
Arguments
  • jd0 Coarse part of a split Julian date on the kernel time scale.
  • time_offset Small part added to jd0, so the split date keeps its digits.
  • target_naif NAIF id of the object, as stored in the kernel.
  • unit Output unit. Position calls use a JME_VECTOR_* id. Orientation calls use a JME_ORIENTATION_* id.
  • order Highest derivative to return. Zero is position only.
  • state Caller-owned state array. Position calls use six numbers: position, then velocity.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_orientation_state_utc_naif

What it does Reads the orientation state from the open kernel at a UTC calendar date, converted inside the call onto the kernel time scale, identified by NAIF ids. unit selects radians per day or radians per second.

When to use it Use this low-level read when the time you have is a UTC calendar date and you want the kernel vector rather than the ecliptic place from jme_calc.

Where it fits After jme_jpl_open. Do not pass UT here. For a civil clock and an ecliptic longitude, use jme_calc_ut.

Call jme_jpl_orientation_state_utc_naif(year, month, day, hour, minute, second, calendar, target_naif, unit, state, error)
Arguments
  • year Calendar year. Astronomical year numbering, so 1 BCE is year 0.
  • month Month number from 1 to 12.
  • day Day of the month.
  • hour Hour. Where the call takes a decimal hour, fractions of an hour are allowed.
  • minute Minute.
  • second Second, including the fraction. A leap second 60 is accepted only on a UTC path that validates it.
  • calendar JME_CALENDAR_GREGORIAN or JME_CALENDAR_JULIAN.
  • target_naif NAIF id of the object, as stored in the kernel.
  • unit Output unit. Position calls use a JME_VECTOR_* id. Orientation calls use a JME_ORIENTATION_* id.
  • state Caller-owned state array. Position calls use six numbers: position, then velocity.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_rotational_angular_momentum_state_naif

What it does Reads the rotational angular-momentum state from the open kernel at one Julian date on the kernel's native time scale (TDB or TCB), identified by NAIF ids. unit selects radians per day or radians per second.

When to use it Use this low-level read when you have one Julian date already expressed on the kernel time scale and you want the kernel vector rather than the ecliptic place from jme_calc.

Where it fits After jme_jpl_open. Do not pass UT here. For a civil clock and an ecliptic longitude, use jme_calc_ut.

Call jme_jpl_rotational_angular_momentum_state_naif(jd_time, target_naif, unit, state, error)
Arguments
  • jd_time Input or output for this call. The name is the shared argument name.
  • target_naif NAIF id of the object, as stored in the kernel.
  • unit Output unit. Position calls use a JME_VECTOR_* id. Orientation calls use a JME_ORIENTATION_* id.
  • state Caller-owned state array. Position calls use six numbers: position, then velocity.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_rotational_angular_momentum_state_utc_naif

What it does Reads the rotational angular-momentum state from the open kernel at a UTC calendar date, converted inside the call onto the kernel time scale, identified by NAIF ids. unit selects radians per day or radians per second.

When to use it Use this low-level read when the time you have is a UTC calendar date and you want the kernel vector rather than the ecliptic place from jme_calc.

Where it fits After jme_jpl_open. Do not pass UT here. For a civil clock and an ecliptic longitude, use jme_calc_ut.

Call jme_jpl_rotational_angular_momentum_state_utc_naif(year, month, day, hour, minute, second, calendar, target_naif, unit, state, error)
Arguments
  • year Calendar year. Astronomical year numbering, so 1 BCE is year 0.
  • month Month number from 1 to 12.
  • day Day of the month.
  • hour Hour. Where the call takes a decimal hour, fractions of an hour are allowed.
  • minute Minute.
  • second Second, including the fraction. A leap second 60 is accepted only on a UTC path that validates it.
  • calendar JME_CALENDAR_GREGORIAN or JME_CALENDAR_JULIAN.
  • target_naif NAIF id of the object, as stored in the kernel.
  • unit Output unit. Position calls use a JME_VECTOR_* id. Orientation calls use a JME_ORIENTATION_* id.
  • state Caller-owned state array. Position calls use six numbers: position, then velocity.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_rotational_angular_momentum_state_split_naif

What it does Reads the rotational angular-momentum state from the open kernel at a split Julian date (jd0 + time_offset) on the kernel's native time scale, identified by NAIF ids. unit selects radians per day or radians per second.

When to use it Use this low-level read when you already hold a split Julian date and need to keep that split and you want the kernel vector rather than the ecliptic place from jme_calc.

Where it fits After jme_jpl_open. Do not pass UT here. For a civil clock and an ecliptic longitude, use jme_calc_ut.

Call jme_jpl_rotational_angular_momentum_state_split_naif(jd0, time_offset, target_naif, unit, state, error)
Arguments
  • jd0 Coarse part of a split Julian date on the kernel time scale.
  • time_offset Small part added to jd0, so the split date keeps its digits.
  • target_naif NAIF id of the object, as stored in the kernel.
  • unit Output unit. Position calls use a JME_VECTOR_* id. Orientation calls use a JME_ORIENTATION_* id.
  • state Caller-owned state array. Position calls use six numbers: position, then velocity.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_rotational_angular_momentum_state_order_naif

What it does Reads the rotational angular-momentum state from the open kernel at a split Julian date (jd0 + time_offset) on the kernel's native time scale, identified by NAIF ids. order asks for derivatives beyond velocity. unit selects radians per day or radians per second.

When to use it Use this low-level read when you already hold a split Julian date and need to keep that split and you want the kernel vector rather than the ecliptic place from jme_calc.

Where it fits After jme_jpl_open. Do not pass UT here. For a civil clock and an ecliptic longitude, use jme_calc_ut.

Call jme_jpl_rotational_angular_momentum_state_order_naif(jd0, time_offset, target_naif, unit, order, state, error)
Arguments
  • jd0 Coarse part of a split Julian date on the kernel time scale.
  • time_offset Small part added to jd0, so the split date keeps its digits.
  • target_naif NAIF id of the object, as stored in the kernel.
  • unit Output unit. Position calls use a JME_VECTOR_* id. Orientation calls use a JME_ORIENTATION_* id.
  • order Highest derivative to return. Zero is position only.
  • state Caller-owned state array. Position calls use six numbers: position, then velocity.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_orientation_record_count

What it does Returns how many orientation records the open kernel contains.

When to use it Use this before an orientation loop. Many planetary kernels have none.

Where it fits A kernel inventory.

Call jme_jpl_orientation_record_count(error)
Arguments
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_orientation_record_index

What it does Reads one orientation record: target, time span, frame, and segment type.

When to use it Use this to see whether a body has an orientation series.

Where it fits Index runs from zero to one less than the orientation record count.

Call jme_jpl_orientation_record_index(index, target, first_time, last_time, frame, segment_type, error)
Arguments
  • index Zero-based index into the kernel list you are reading.
  • target Receives the target id of one kernel record.
  • first_time Receives the first time the kernel covers.
  • last_time Receives the last time the kernel covers.
  • frame Receives the frame id of one kernel record.
  • segment_type Kernel segment type, used to ask which derivative order that segment can return.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jpl_timescale

What it does Returns the native time scale of the open kernel, TDB or TCB.

When to use it Call it before a low-level state call so you pass a date on that scale.

Where it fits High-level jme_calc converts TT for you. These low-level calls do not.

Call jme_jpl_timescale()
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

Function group

Main Body Calculations

Start here for a Sun, Moon, planet, or node. jme_calc_ut is the usual call from a civil clock. The other calls in this group are appearance, names, or one chosen analytical series.

jme_calc

What it does Computes a body position at Terrestrial Time.

When to use it Use this when the instant you have is already TT. For a civil clock, use jme_calc_ut.

Where it fits The usual planet, Sun, Moon, or node position. flags choose equatorial, rectangular, topocentric, sidereal, and the other frames.

Call jme_calc(jd_et, body, flags, results, error)
Arguments
  • jd_et Terrestrial Time (TT) as a Julian date.
  • body Body id such as JME_BODY_SUN. The body constants list every id.
  • flags Flag bits for this call. Pass 0 for the default. The constant group for this family lists the bits.
  • results Six numbers you allocate. Indexes 0–2 are position. Indexes 3–5 are the rates. The call fills the rates even when JME_CALC_SPEED is absent.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK or JME_ERR. On JME_OK, results holds six numbers: position in 0–2 and rates in 3–5.

jme_calc_ut

What it does Computes a body position at Universal Time.

When to use it Use this when the instant you have is UT, including a Julian date built from a civil clock.

Where it fits The usual entry for a chart or a panchang. The six results are position then rates.

Call jme_calc_ut(jd_ut, body, flags, results, error)
Arguments
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
  • body Body id such as JME_BODY_SUN. The body constants list every id.
  • flags Flag bits for this call. Pass 0 for the default. The constant group for this family lists the bits.
  • results Six numbers you allocate. Indexes 0–2 are position. Indexes 3–5 are the rates. The call fills the rates even when JME_CALC_SPEED is absent.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK or JME_ERR. On JME_OK, results holds six numbers: position in 0–2 and rates in 3–5.

jme_calc_pctr

What it does Computes a body position relative to an explicit centre, at Terrestrial Time.

When to use it Use this when the origin must be a chosen body, not the default geocentric or heliocentric centre.

Where it fits Relative positions, such as a moon of a planet seen from that planet, at TT.

Call jme_calc_pctr(jd_et, body, center, flags, results, error)
Arguments
  • jd_et Terrestrial Time (TT) as a Julian date.
  • body Body id such as JME_BODY_SUN. The body constants list every id.
  • center Body id used as the origin instead of the default centre.
  • flags Flag bits for this call. Pass 0 for the default. The constant group for this family lists the bits.
  • results Six numbers you allocate, same layout as jme_calc: position, then rates, relative to center.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK or JME_ERR. On JME_OK, results holds six numbers: position in 0–2 and rates in 3–5.

jme_pheno

What it does Computes appearance data for a body at Terrestrial Time, such as phase and elongation.

When to use it Use this when you need how the body looks, not its ecliptic longitude.

Where it fits After you already know the body and the TT date. The UT form is jme_pheno_ut.

Call jme_pheno(jd_et, body, flags, attr, error)
Arguments
  • jd_et Terrestrial Time (TT) as a Julian date.
  • body Body id such as JME_BODY_SUN. The body constants list every id.
  • flags Flag bits for this call. Pass 0 for the default. The constant group for this family lists the bits.
  • attr Caller-owned array that receives the circumstance values for this call.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_pheno_ut

What it does Computes appearance data for a body at Universal Time.

When to use it Use this when the clock is UT and you need phase, elongation, and the related attributes.

Where it fits A planet panel or a lunar-phase display. For the longitude itself, use jme_calc_ut.

Call jme_pheno_ut(jd_ut, body, flags, attr, error)
Arguments
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
  • body Body id such as JME_BODY_SUN. The body constants list every id.
  • flags Flag bits for this call. Pass 0 for the default. The constant group for this family lists the bits.
  • attr Caller-owned array that receives the circumstance values for this call.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_heliacal_pheno_ut

What it does Computes the heliacal appearance attributes at a known Universal Time.

When to use it Use this when the time is already chosen and you need the visibility circumstances.

Where it fits The attribute pair of the heliacal search.

Call jme_heliacal_pheno_ut(jd_ut, geopos, dat_hel, error)
Arguments
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
  • geopos Observer longitude, latitude, and height, in that order, in degrees and metres.
  • dat_hel Caller-owned array of the shared heliacal inputs: place, atmosphere, and object data.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_matrix_transform_state

What it does Applies a 3 by 3 matrix to a Cartesian state.

When to use it Use this after you have built a precession or nutation matrix and you still hold x, y, z and their rates.

Where it fits input and output are states. output is caller-owned.

Call jme_matrix_transform_state(m, input, output)
Arguments
  • m Caller-owned rotation matrix, nine numbers, row by row.
  • input State or matrix going in.
  • output Caller-owned state or matrix coming out.
Result

Returns nothing. The call writes its output arguments, or it changes a library setting for later calls.

jme_body_id_from_name

What it does Returns the body id for a name such as Sun or Moon.

When to use it Use this when a user typed a name and the calculation calls want an id.

Where it fits A name that is not a body returns an id you should test before jme_calc.

Call jme_body_id_from_name(name)
Arguments
  • name Name to look up, or the buffer that receives a name.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_body_name

What it does Returns the library's name for a body id.

When to use it Use this to label a JME_BODY_* value.

Where it fits The pointer is library-owned text. Copy it if you need to keep it.

Call jme_body_name(body)
Arguments
  • body Body id such as JME_BODY_SUN. The body constants list every id.
Result

Returns library-owned text. Generated names for Asteroid 013..110, Comet 001..060, and Minor Planet 001..060 use a thread-local buffer, overwritten by the next generated body name returned on the same thread. Copy the text if you need to keep it.

jme_copy_body_name

What it does Copies a body name into your buffer.

When to use it Use this when the binding must own the string.

Where it fits Safer than holding the pointer from jme_body_name across later calls.

Call jme_copy_body_name(body, buffer)
Arguments
  • body Body id such as JME_BODY_SUN. The body constants list every id.
  • buffer Caller-owned character buffer. The call writes the text here.
Result

Returns the text. When you pass buffer, the text is written there and the return points at that buffer.

jme_body_naif_id

What it does Returns the NAIF id that corresponds to a JME body id.

When to use it Use this before a jme_jpl_*_naif call when you started from JME_BODY_*.

Where it fits Kernel code. The reverse lookup is jme_jpl_name_by_id.

Call jme_body_naif_id(body)
Arguments
  • body Body id such as JME_BODY_SUN. The body constants list every id.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_ecliptic_to_equatorial_rectangular_state

What it does Rotates an ecliptic Cartesian state onto the equator.

When to use it Use this when you hold x, y, z and their rates, not spherical angles.

Where it fits eps is the obliquity. The reverse is the equatorial-to-ecliptic state call.

Call jme_ecliptic_to_equatorial_rectangular_state(ecliptic, eps, equatorial)
Arguments
  • ecliptic Ecliptic rectangular state.
  • eps Obliquity of the ecliptic, in degrees, at the date you are using.
  • equatorial Equatorial rectangular state.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_equatorial_to_ecliptic_rectangular_state

What it does Rotates an equatorial Cartesian state onto the ecliptic.

When to use it Use this for a rectangular state that must be expressed in ecliptic axes.

Where it fits The reverse of the ecliptic-to-equatorial state call.

Call jme_equatorial_to_ecliptic_rectangular_state(equatorial, eps, ecliptic)
Arguments
  • equatorial Equatorial rectangular state.
  • eps Obliquity of the ecliptic, in degrees, at the date you are using.
  • ecliptic Ecliptic rectangular state.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_spherical_to_rectangular_state

What it does Converts a spherical state to a rectangular state.

When to use it Use this when a later kernel-style step wants x, y, z and rates.

Where it fits The reverse is jme_rectangular_to_spherical_state.

Call jme_spherical_to_rectangular_state(spherical, rectangular)
Arguments
  • spherical Spherical state: longitude, latitude, distance, and their rates.
  • rectangular Rectangular state: x, y, z, and their rates.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_rectangular_to_spherical_state

What it does Converts a rectangular state to longitude, latitude, distance, and their rates.

When to use it Use this after a rectangular kernel read when you want spherical coordinates.

Where it fits The reverse is jme_spherical_to_rectangular_state.

Call jme_rectangular_to_spherical_state(rectangular, spherical)
Arguments
  • rectangular Rectangular state: x, y, z, and their rates.
  • spherical Spherical state: longitude, latitude, distance, and their rates.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_state_distance

What it does Returns the distance from the position part of a Cartesian state.

When to use it Use this when you have x, y, z and need the range.

Where it fits A state from jme_jpl_body_state or a rectangular conversion.

Call jme_state_distance(state)
Arguments
  • state Caller-owned state array. Position calls use six numbers: position, then velocity.
Result

Returns the number described above. A non-finite value means the call could not produce that number.

jme_state_convert_units

What it does Converts a Cartesian state between AU and kilometres, and between per day and per second.

When to use it Use this when a kernel vector must be shown in kilometres per second, or the reverse.

Where it fits input_unit and output_unit are JME_VECTOR_* ids.

Call jme_state_convert_units(input, input_unit, output_unit, output)
Arguments
  • input State or matrix going in.
  • input_unit Unit of the input state, a JME_VECTOR_* id.
  • output_unit Unit wanted in the output state, a JME_VECTOR_* id.
  • output Caller-owned state or matrix coming out.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_state_light_time_days

What it does Returns the light time of a state, in days.

When to use it Use this when you need the light-time delay of a distance you already hold.

Where it fits unit says whether the state is in AU or kilometres.

Call jme_state_light_time_days(state, unit)
Arguments
  • state Caller-owned state array. Position calls use six numbers: position, then velocity.
  • unit Output unit. Position calls use a JME_VECTOR_* id. Orientation calls use a JME_ORIENTATION_* id.
Result

Returns the number described above. A non-finite value means the call could not produce that number.

jme_state_position_velocity_dot

What it does Returns the dot product of the position and velocity parts of a state.

When to use it Use this in your own range-rate geometry.

Where it fits A 6-number state.

Call jme_state_position_velocity_dot(state)
Arguments
  • state Caller-owned state array. Position calls use six numbers: position, then velocity.
Result

Returns the number described above. A non-finite value means the call could not produce that number.

jme_state_speed

What it does Returns the speed from the velocity part of a state.

When to use it Use this to show how fast the body is moving in the state's unit.

Where it fits It does not recompute a position.

Call jme_state_speed(state)
Arguments
  • state Caller-owned state array. Position calls use six numbers: position, then velocity.
Result

Returns the number described above. A non-finite value means the call could not produce that number.

jme_state_add

What it does Adds two Cartesian states.

When to use it Use this to combine a barycentric vector with an offset you already have.

Where it fits output is caller-owned.

Call jme_state_add(left, right, output)
Arguments
  • left First state in the sum or difference.
  • right Second state in the sum or difference.
  • output Caller-owned state or matrix coming out.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_state_scale

What it does Multiplies every component of a state by a factor.

When to use it Use this for a unit scale the conversion helper does not cover.

Where it fits output is caller-owned.

Call jme_state_scale(input, factor, output)
Arguments
  • input State or matrix going in.
  • factor Number to multiply every component by.
  • output Caller-owned state or matrix coming out.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_state_subtract

What it does Subtracts one Cartesian state from another.

When to use it Use this to change the origin of a vector, when both states share a frame and a unit.

Where it fits output is caller-owned.

Call jme_state_subtract(left, right, output)
Arguments
  • left First state in the sum or difference.
  • right Second state in the sum or difference.
  • output Caller-owned state or matrix coming out.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_vsop87_planet_state

What it does Computes a planet with the VSOP87 series at Terrestrial Time.

When to use it Use this only when you want VSOP87 specifically, not the engine selected by jme_set_astro_models.

Where it fits A direct theory call. For the normal position, use jme_calc.

Call jme_vsop87_planet_state(jd_et, body, results)
Arguments
  • jd_et Terrestrial Time (TT) as a Julian date.
  • body Body id such as JME_BODY_SUN. The body constants list every id.
  • results Caller-owned output array. Allocate it before the call.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_meeus_sun_state

What it does Computes the Sun with the Meeus series at Terrestrial Time.

When to use it Use this when you want that solar series specifically.

Where it fits A direct theory call. The engine switch does not apply.

Call jme_meeus_sun_state(jd_et, results)
Arguments
  • jd_et Terrestrial Time (TT) as a Julian date.
  • results Caller-owned output array. Allocate it before the call.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_meeus_moon_state

What it does Computes the Moon with the Meeus series at Terrestrial Time.

When to use it Use this when you want that lunar series specifically.

Where it fits A direct theory call.

Call jme_meeus_moon_state(jd_et, results)
Arguments
  • jd_et Terrestrial Time (TT) as a Julian date.
  • results Caller-owned output array. Allocate it before the call.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_elp2000_moon_state

What it does Computes the Moon with ELP2000-82B at Terrestrial Time.

When to use it Use this when you want ELP specifically.

Where it fits A direct theory call. The high-level engine can select this series for you.

Call jme_elp2000_moon_state(jd_et, results)
Arguments
  • jd_et Terrestrial Time (TT) as a Julian date.
  • results Caller-owned output array. Allocate it before the call.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_meeus_planet_state

What it does Computes a planet with the Meeus planetary series at Terrestrial Time.

When to use it Use this when you want that series specifically.

Where it fits A direct theory call.

Call jme_meeus_planet_state(jd_et, body, results)
Arguments
  • jd_et Terrestrial Time (TT) as a Julian date.
  • body Body id such as JME_BODY_SUN. The body constants list every id.
  • results Caller-owned output array. Allocate it before the call.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_moshier_planet_state

What it does Computes a body with the Moshier analytical theory at Terrestrial Time.

When to use it Use this when you want Moshier specifically, including in a comparison against JPL.

Where it fits A direct theory call. ENGINE=MOSHIER on jme_calc is the usual way to select it.

Call jme_moshier_planet_state(jd_et, body, results)
Arguments
  • jd_et Terrestrial Time (TT) as a Julian date.
  • body Body id such as JME_BODY_SUN. The body constants list every id.
  • results Caller-owned output array. Allocate it before the call.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

Function group

Rise, Set, and Crossings

Use these when the result you want is a time: a rise, a set, a transit, or the moment a longitude is reached. The start date is where the search begins.

jme_rise_trans

What it does Finds the next rise, set, or transit of a body or star at a place.

When to use it Use this for the time the object crosses the horizon or the meridian.

Where it fits A panchang sunrise, moonrise, or a planet rise. rsmi is a JME_RISE_* value. The UT date is the search start.

Call jme_rise_trans(jd_ut, body, starname, flags, rsmi, geopos, atpress, attemp, tret, error)
Arguments
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
  • body Body id such as JME_BODY_SUN. The body constants list every id.
  • starname Star name. Use an empty string when the call is for a solar-system body.
  • flags Flag bits for this call. Pass 0 for the default. The constant group for this family lists the bits.
  • rsmi What to find: a JME_RISE_* value such as rise, set, transit, or a twilight.
  • geopos Observer longitude, latitude, and height, in that order, in degrees and metres.
  • atpress Atmospheric pressure at the observer, in millibars.
  • attemp Atmospheric temperature at the observer, in degrees Celsius.
  • tret Caller-owned array of Julian dates. The description says which index is which event.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_rise_trans_true_hor

What it does Finds rise, set, or transit against a horizon you raise or lower.

When to use it Use this when the local horizon is not the geometric one, for example a hill of known altitude.

Where it fits Same inputs as jme_rise_trans, plus horhgt in degrees.

Call jme_rise_trans_true_hor(jd_ut, body, starname, flags, rsmi, geopos, atpress, attemp, horhgt, tret, error)
Arguments
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
  • body Body id such as JME_BODY_SUN. The body constants list every id.
  • starname Star name. Use an empty string when the call is for a solar-system body.
  • flags Flag bits for this call. Pass 0 for the default. The constant group for this family lists the bits.
  • rsmi What to find: a JME_RISE_* value such as rise, set, transit, or a twilight.
  • geopos Observer longitude, latitude, and height, in that order, in degrees and metres.
  • atpress Atmospheric pressure at the observer, in millibars.
  • attemp Atmospheric temperature at the observer, in degrees Celsius.
  • horhgt Height of the local horizon above the geometric horizon, in degrees.
  • tret Caller-owned array of Julian dates. The description says which index is which event.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_solcross

What it does Finds when the Sun next reaches an ecliptic longitude, on the Terrestrial Time entry.

When to use it Use this when your start instant is TT.

Where it fits Ingress and sankranti calculations. The UT entry is jme_solcross_ut.

Call jme_solcross(x2cross, jd_ut, flags, tret, error)
Arguments
  • x2cross Ecliptic longitude to reach, in degrees.
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
  • flags Flag bits for this call. Pass 0 for the default. The constant group for this family lists the bits.
  • tret Caller-owned array of Julian dates. The description says which index is which event.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_solcross_ut

What it does Finds when the Sun next reaches an ecliptic longitude, starting from Universal Time.

When to use it Use this for a civil date and a target longitude such as 0° for the March equinox longitude.

Where it fits A calendar of solar ingresses.

Call jme_solcross_ut(x2cross, jd_ut, flags, tret, error)
Arguments
  • x2cross Ecliptic longitude to reach, in degrees.
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
  • flags Flag bits for this call. Pass 0 for the default. The constant group for this family lists the bits.
  • tret Caller-owned array of Julian dates. The description says which index is which event.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_mooncross

What it does Finds when the Moon next reaches an ecliptic longitude, on the Terrestrial Time entry.

When to use it Use this when the start instant is TT.

Where it fits Tithi or nakshatra boundaries when you already hold TT.

Call jme_mooncross(x2cross, jd_ut, flags, tret, error)
Arguments
  • x2cross Ecliptic longitude to reach, in degrees.
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
  • flags Flag bits for this call. Pass 0 for the default. The constant group for this family lists the bits.
  • tret Caller-owned array of Julian dates. The description says which index is which event.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_mooncross_ut

What it does Finds when the Moon next reaches an ecliptic longitude, starting from Universal Time.

When to use it Use this for rashi, nakshatra, or tithi edges from a civil clock.

Where it fits The usual lunar-ingress search.

Call jme_mooncross_ut(x2cross, jd_ut, flags, tret, error)
Arguments
  • x2cross Ecliptic longitude to reach, in degrees.
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
  • flags Flag bits for this call. Pass 0 for the default. The constant group for this family lists the bits.
  • tret Caller-owned array of Julian dates. The description says which index is which event.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_mooncross_node

What it does Finds when the Moon next reaches its node, on the Terrestrial Time entry.

When to use it Use this when the start instant is TT and you want the nodal passage.

Where it fits Eclipse seasons. The UT entry is jme_mooncross_node_ut.

Call jme_mooncross_node(jd_ut, flags, tret, error)
Arguments
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
  • flags Flag bits for this call. Pass 0 for the default. The constant group for this family lists the bits.
  • tret Caller-owned array of Julian dates. The description says which index is which event.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_mooncross_node_ut

What it does Finds when the Moon next reaches its node, starting from Universal Time.

When to use it Use this from a civil date.

Where it fits The UT pair of jme_mooncross_node.

Call jme_mooncross_node_ut(jd_ut, flags, tret, error)
Arguments
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
  • flags Flag bits for this call. Pass 0 for the default. The constant group for this family lists the bits.
  • tret Caller-owned array of Julian dates. The description says which index is which event.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_helio_cross

What it does Finds when a body's heliocentric longitude next reaches a target, on the Terrestrial Time entry.

When to use it Use this for a heliocentric ingress when you have TT.

Where it fits Outer-planet heliocentric work. The UT entry is jme_helio_cross_ut.

Call jme_helio_cross(body, x2cross, jd_ut, flags, tret, error)
Arguments
  • body Body id such as JME_BODY_SUN. The body constants list every id.
  • x2cross Ecliptic longitude to reach, in degrees.
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
  • flags Flag bits for this call. Pass 0 for the default. The constant group for this family lists the bits.
  • tret Caller-owned array of Julian dates. The description says which index is which event.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_helio_cross_ut

What it does Finds when a body's heliocentric longitude next reaches a target, starting from Universal Time.

When to use it Use this when the clock is UT.

Where it fits The UT pair of jme_helio_cross.

Call jme_helio_cross_ut(body, x2cross, jd_ut, flags, tret, error)
Arguments
  • body Body id such as JME_BODY_SUN. The body constants list every id.
  • x2cross Ecliptic longitude to reach, in degrees.
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
  • flags Flag bits for this call. Pass 0 for the default. The constant group for this family lists the bits.
  • tret Caller-owned array of Julian dates. The description says which index is which event.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_heliacal_ut

What it does Searches heliacal rising or setting phenomena at a place.

When to use it Use this for first or last visibility, not for the geometric sunrise.

Where it fits A visibility calendar. dat_hel carries the shared atmosphere and object inputs.

Call jme_heliacal_ut(jd_ut, geopos, dat_hel, error)
Arguments
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
  • geopos Observer longitude, latitude, and height, in that order, in degrees and metres.
  • dat_hel Caller-owned array of the shared heliacal inputs: place, atmosphere, and object data.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_vis_limit_mag

What it does Estimates the limiting visual magnitude at a place and time.

When to use it Use this to decide whether an object is bright enough to see in those conditions.

Where it fits Before or beside a heliacal call, with the same dat_hel inputs.

Call jme_vis_limit_mag(jd_ut, geopos, dat_hel, error)
Arguments
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
  • geopos Observer longitude, latitude, and height, in that order, in degrees and metres.
  • dat_hel Caller-owned array of the shared heliacal inputs: place, atmosphere, and object data.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_heliacal_angle

What it does Returns the heliacal angle used by the visibility routines.

When to use it Use this when you need that angle itself rather than a search time.

Where it fits A visibility diagram.

Call jme_heliacal_angle(jd_ut, geopos, dat_hel, error)
Arguments
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
  • geopos Observer longitude, latitude, and height, in that order, in degrees and metres.
  • dat_hel Caller-owned array of the shared heliacal inputs: place, atmosphere, and object data.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns the number described above. A non-finite value means the call could not produce that number.

jme_topo_arcus_visionis

What it does Returns the topocentric arcus visionis for the heliacal inputs.

When to use it Use this when a traditional visibility rule asks for the arcus visionis.

Where it fits The same dat_hel setup as the other heliacal calls.

Call jme_topo_arcus_visionis(jd_ut, geopos, dat_hel, error)
Arguments
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
  • geopos Observer longitude, latitude, and height, in that order, in degrees and metres.
  • dat_hel Caller-owned array of the shared heliacal inputs: place, atmosphere, and object data.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns the number described above. A non-finite value means the call could not produce that number.

Function group

Sidereal, Ayanamsa, and Time

Use these for the clock and the zodiac: Julian dates, Delta-T, sidereal time, and the ayanamsa. Most position calls take a Julian date you build here.

jme_set_sidereal_mode

What it does Selects the ayanamsa used by later sidereal longitudes.

When to use it Call it before a calculation that passes JME_CALC_SIDEREAL, or before an ayanamsa read that should follow the library setting.

Where it fits Once per chart style. For a user ayanamsa, pass JME_SIDEREAL_USER with t0 and ayan_t0.

Call jme_set_sidereal_mode(sidereal_mode, t0, ayan_t0)
Arguments
  • sidereal_mode Ayanamsa id from the JME_SIDEREAL_* constants.
  • t0 Reference epoch for a user ayanamsa, as a Julian date.
  • ayan_t0 Ayanamsa at t0, in degrees, for the user mode.
Result

Returns nothing. The call writes its output arguments, or it changes a library setting for later calls.

jme_get_sidereal_mode

What it does Reads the ayanamsa id and the user-mode epoch back out.

When to use it Call it when another part of the program must follow the mode already set.

Where it fits After jme_set_sidereal_mode.

Call jme_get_sidereal_mode(sidereal_mode, t0, ayan_t0)
Arguments
  • sidereal_mode Ayanamsa id from the JME_SIDEREAL_* constants.
  • t0 Reference epoch for a user ayanamsa, as a Julian date.
  • ayan_t0 Ayanamsa at t0, in degrees, for the user mode.
Result

Returns nothing. The call writes its output arguments, or it changes a library setting for later calls.

jme_set_delta_t_userdef

What it does Fixes Delta-T at a constant number of seconds.

When to use it Use this when you must force TT minus UT, for a test or a historical convention.

Where it fits A non-finite dt clears the override and returns to the model.

Call jme_set_delta_t_userdef(dt)
Arguments
  • dt Delta-T in seconds. A non-finite value clears a user-defined Delta-T.
Result

Returns nothing. The call writes its output arguments, or it changes a library setting for later calls.

jme_get_ayanamsa_name

What it does Returns the display name of an ayanamsa id.

When to use it Use this to label a JME_SIDEREAL_* value in a menu.

Where it fits A settings screen. The id does not have to be the active mode.

Call jme_get_ayanamsa_name(model)
Arguments
  • model Model id from the JME_MODEL_* or JME_SIDEREAL_* constants, depending on the call.
Result

Returns a pointer to a static string.

jme_lmt_to_lat

What it does Converts local mean time to local apparent time at a longitude.

When to use it Use this when a clock is mean time and you need apparent solar time.

Where it fits It applies the equation of time. The reverse is jme_lat_to_lmt.

Call jme_lmt_to_lat(jd_lmt, geo_lon, jd_lat, error)
Arguments
  • jd_lmt Local mean time as a Julian date.
  • geo_lon Geographic longitude in degrees. East is positive.
  • jd_lat Local apparent time as a Julian date.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_lat_to_lmt

What it does Converts local apparent time to local mean time at a longitude.

When to use it Use this when you have sundial time and need mean time.

Where it fits The reverse of jme_lmt_to_lat.

Call jme_lat_to_lmt(jd_lat, geo_lon, jd_lmt, error)
Arguments
  • jd_lat Local apparent time as a Julian date.
  • geo_lon Geographic longitude in degrees. East is positive.
  • jd_lmt Local mean time as a Julian date.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_centiseconds_to_time_string

What it does Formats a count of centiseconds as a clock string.

When to use it Use this to print a duration or a time of day you already hold in centiseconds.

Where it fits Display only. It does not compute an ephemeris time.

Call jme_centiseconds_to_time_string(cs, buffer)
Arguments
  • cs Angle or time in centiseconds. A full circle or a day of time is 1,296,000 centiseconds.
  • buffer Caller-owned character buffer. The call writes the text here.
Result

Returns the text. When you pass buffer, the text is written there and the return points at that buffer.

jme_julian_day

What it does Builds a Julian date from a calendar date and a decimal hour.

When to use it Use this to turn a year, month, day, and hour into the jd_ut or jd_et argument of every other call.

Where it fits The first step of almost every calculation. calendar selects Gregorian or Julian.

Call jme_julian_day(year, month, day, hour, calendar)
Arguments
  • year Calendar year. Astronomical year numbering, so 1 BCE is year 0.
  • month Month number from 1 to 12.
  • day Day of the month.
  • hour Hour. Where the call takes a decimal hour, fractions of an hour are allowed.
  • calendar JME_CALENDAR_GREGORIAN or JME_CALENDAR_JULIAN.
Result

Returns the number described above. A non-finite value means the call could not produce that number.

jme_calendar_is_leap_year

What it does Reports whether a year is a leap year in the selected calendar.

When to use it Use this before you accept 29 February.

Where it fits Date entry. It does not convert a Julian date.

Call jme_calendar_is_leap_year(year, calendar)
Arguments
  • year Calendar year. Astronomical year numbering, so 1 BCE is year 0.
  • calendar JME_CALENDAR_GREGORIAN or JME_CALENDAR_JULIAN.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_date_is_valid

What it does Reports whether year, month, and day exist in the selected calendar.

When to use it Use this to reject a date before you call jme_julian_day.

Where it fits Form validation.

Call jme_date_is_valid(year, month, day, calendar)
Arguments
  • year Calendar year. Astronomical year numbering, so 1 BCE is year 0.
  • month Month number from 1 to 12.
  • day Day of the month.
  • calendar JME_CALENDAR_GREGORIAN or JME_CALENDAR_JULIAN.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_day_of_year

What it does Returns the day number within the year, starting at 1.

When to use it Use this for a day-of-year display or a seasonal index.

Where it fits After the date is known to be valid.

Call jme_day_of_year(year, month, day, calendar)
Arguments
  • year Calendar year. Astronomical year numbering, so 1 BCE is year 0.
  • month Month number from 1 to 12.
  • day Day of the month.
  • calendar JME_CALENDAR_GREGORIAN or JME_CALENDAR_JULIAN.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_day_of_week

What it does Returns the weekday of a Julian date.

When to use it Use this for a calendar label. The numbering is the library's weekday index.

Where it fits Any date you already converted.

Call jme_day_of_week(jd)
Arguments
  • jd Julian date. The description of the call says which time scale that number is.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

jme_reverse_julian_day

What it does Splits a Julian date back into calendar year, month, day, and decimal hour.

When to use it Use this to display a Julian date you computed, such as a rise time.

Where it fits The inverse of jme_julian_day. For UTC fields including minutes and seconds, use jme_jd_to_utc.

Call jme_reverse_julian_day(jd, calendar, year, month, day, hour)
Arguments
  • jd Julian date. The description of the call says which time scale that number is.
  • calendar JME_CALENDAR_GREGORIAN or JME_CALENDAR_JULIAN.
  • year Calendar year. Astronomical year numbering, so 1 BCE is year 0.
  • month Month number from 1 to 12.
  • day Day of the month.
  • hour Hour. Where the call takes a decimal hour, fractions of an hour are allowed.
Result

Returns nothing. The call writes its output arguments, or it changes a library setting for later calls.

jme_delta_t

What it does Returns Delta-T, TT minus UT, in seconds for a Universal Time date, using the active model.

When to use it Use this when you have UT and need TT, or you need to show Delta-T.

Where it fits The model-selecting form is jme_delta_t_ex.

Call jme_delta_t(jd_ut)
Arguments
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
Result

Returns the number described above. A non-finite value means the call could not produce that number.

jme_delta_t_ex

What it does Returns Delta-T for an explicit model.

When to use it Use this when the caller chooses the series, including JME_TIME_DELTAT_AUTOMATIC.

Where it fits Models whose source tables are not in the library return a non-finite value and an error.

Call jme_delta_t_ex(jd_ut, model, error)
Arguments
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
  • model Model id from the JME_MODEL_* or JME_SIDEREAL_* constants, depending on the call.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns the number described above. A non-finite value means the call could not produce that number.

jme_get_ayanamsa

What it does Returns the active ayanamsa at Terrestrial Time.

When to use it Use this to subtract from a tropical longitude when you want the sidereal longitude of the current mode.

Where it fits The mode comes from jme_set_sidereal_mode. The UT form is jme_get_ayanamsa_ut.

Call jme_get_ayanamsa(jd_et)
Arguments
  • jd_et Terrestrial Time (TT) as a Julian date.
Result

Returns the number described above. A non-finite value means the call could not produce that number.

jme_get_ayanamsa_ut

What it does Returns the active ayanamsa at Universal Time.

When to use it Use this when the clock is UT.

Where it fits The UT pair of jme_get_ayanamsa.

Call jme_get_ayanamsa_ut(jd_ut)
Arguments
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
Result

Returns the number described above. A non-finite value means the call could not produce that number.

jme_get_ayanamsa_ex

What it does Returns one named ayanamsa at Terrestrial Time, without changing the active mode.

When to use it Use this to compare two ayanamsas, or to label a model you have not selected.

Where it fits model is a JME_SIDEREAL_* id.

Call jme_get_ayanamsa_ex(jd_et, model, ayan, error)
Arguments
  • jd_et Terrestrial Time (TT) as a Julian date.
  • model Model id from the JME_MODEL_* or JME_SIDEREAL_* constants, depending on the call.
  • ayan Receives the ayanamsa in degrees.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_get_ayanamsa_ex_ut

What it does Returns one named ayanamsa at Universal Time.

When to use it Use this when the clock is UT and the mode is an argument, not the library setting.

Where it fits The UT pair of jme_get_ayanamsa_ex.

Call jme_get_ayanamsa_ex_ut(jd_ut, model, ayan, error)
Arguments
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
  • model Model id from the JME_MODEL_* or JME_SIDEREAL_* constants, depending on the call.
  • ayan Receives the ayanamsa in degrees.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_time_equ

What it does Returns the equation of time at Universal Time.

When to use it Use this to move between mean solar time and apparent solar time.

Where it fits jme_lmt_to_lat uses the same quantity. e receives the value.

Call jme_time_equ(jd_ut, e, error)
Arguments
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
  • e Receives the equation of time.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_jd_to_utc

What it does Splits a Julian date into UTC calendar fields, including minutes and seconds.

When to use it Use this to display a computed instant on a civil clock.

Where it fits calendar selects Gregorian or Julian. For a decimal hour only, jme_reverse_julian_day is enough.

Call jme_jd_to_utc(jd, calendar, year, month, day, hour, minute, second)
Arguments
  • jd Julian date. The description of the call says which time scale that number is.
  • calendar JME_CALENDAR_GREGORIAN or JME_CALENDAR_JULIAN.
  • year Calendar year. Astronomical year numbering, so 1 BCE is year 0.
  • month Month number from 1 to 12.
  • day Day of the month.
  • hour Hour. Where the call takes a decimal hour, fractions of an hour are allowed.
  • minute Minute.
  • second Second, including the fraction. A leap second 60 is accepted only on a UTC path that validates it.
Result

Returns nothing. The call writes its output arguments, or it changes a library setting for later calls.

jme_sidereal_time

What it does Returns Greenwich sidereal time in hours for a Universal Time date.

When to use it Use this when you need RAMC's starting point and you do not need a status code.

Where it fits The explicit mean-or-apparent form is jme_sidereal_time_ex.

Call jme_sidereal_time(jd_ut)
Arguments
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
Result

Returns the number described above. A non-finite value means the call could not produce that number.

jme_sidereal_time0

What it does Returns Greenwich sidereal time from UT, an obliquity, and a nutation you already have.

When to use it Use this when you computed eps and nut yourself and you do not want the call to look them up.

Where it fits A custom precession pipeline.

Call jme_sidereal_time0(jd_ut, eps, nut)
Arguments
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
  • eps Obliquity of the ecliptic, in degrees, at the date you are using.
  • nut Nutation contribution already computed, in the unit this sidereal-time call expects.
Result

Returns the number described above. A non-finite value means the call could not produce that number.

jme_utc_time_zone

What it does Shifts a UTC calendar time by a timezone offset in hours.

When to use it Use this to present an instant in local civil time, or to convert a local civil time toward UTC.

Where it fits timezone is hours east of UTC. This is a clock shift, not the equation of time.

Call jme_utc_time_zone(year, month, day, hour, minute, second, timezone, out_year, out_month, out_day, out_hour, out_minute, out_second)
Arguments
  • year Calendar year. Astronomical year numbering, so 1 BCE is year 0.
  • month Month number from 1 to 12.
  • day Day of the month.
  • hour Hour. Where the call takes a decimal hour, fractions of an hour are allowed.
  • minute Minute.
  • second Second, including the fraction. A leap second 60 is accepted only on a UTC path that validates it.
  • timezone Hours east of UTC. West longitudes use a negative offset.
  • out_year Receives the converted year.
  • out_month Receives the converted month.
  • out_day Receives the converted day.
  • out_hour Receives the converted hour.
  • out_minute Receives the converted minute.
  • out_second Receives the converted second.
Result

Returns nothing. The call writes its output arguments, or it changes a library setting for later calls.

jme_utc_to_jd

What it does Converts a UTC calendar time to a UTC Julian date.

When to use it Use this when the input is UTC wall time, including a possible leap second, and you need a Julian date.

Where it fits Dates after the leap-second table fail. jme_julian_day does not apply the leap-second table.

Call jme_utc_to_jd(year, month, day, hour, minute, second, calendar, jd_utc)
Arguments
  • year Calendar year. Astronomical year numbering, so 1 BCE is year 0.
  • month Month number from 1 to 12.
  • day Day of the month.
  • hour Hour. Where the call takes a decimal hour, fractions of an hour are allowed.
  • minute Minute.
  • second Second, including the fraction. A leap second 60 is accepted only on a UTC path that validates it.
  • calendar JME_CALENDAR_GREGORIAN or JME_CALENDAR_JULIAN.
  • jd_utc Receives the UTC Julian date.
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

Function group

Added in 1.1.0

These entered in 1.1.0 and stay in 2.0.0. Use them when you need an explicit time scale, a mean or true ayanamsa, Gauquelin sectors, polar motion, or a checked setter.

Time scales

jme_time_scale_convert

What it does Converts a split Julian date from one time scale to another.

When to use it Use this when you must move among UT, TAI, TT, TDB, TCG, and TCB yourself.

Where it fits High-level jme_calc_ut already converts UT. UTC on this call follows the leap-second table, which currently stops at 2027-06-30.

Call jme_time_scale_convert(jd1, jd2, from_scale, to_scale, out1, out2, error)
Arguments
  • jd1 First part of a split Julian date.
  • jd2 Second part of a split Julian date. The instant is jd1 + jd2.
  • from_scale Source time scale, one of the JME_TIME_SCALE_* constants.
  • to_scale Time scale to convert into, one of the JME_TIME_SCALE_* constants.
  • out1 Receives the first part of the converted split Julian date.
  • out2 Receives the second part of the converted split Julian date.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_time_scale_name

What it does Returns the display name of a time-scale id.

When to use it Use this to label a JME_TIME_SCALE_* value.

Where it fits A time-scale menu.

Call jme_time_scale_name(scale)
Arguments
  • scale Time-scale id from the JME_TIME_SCALE_* constants.
Result

Returns the text. When you pass buffer, the text is written there and the return points at that buffer.

jme_leap_second_table_info

What it does Reports how far the embedded UTC leap-second table extends.

When to use it Call it before you convert a future UTC date, so you can fail clearly past the table.

Where it fits The covered range currently ends at 2027-06-30 UTC.

Call jme_leap_second_table_info(jd_utc_valid_until, last_tai_minus_utc, error)
Arguments
  • jd_utc_valid_until Receives the first UTC Julian date the leap-second table does not cover.
  • last_tai_minus_utc Receives the latest TAI minus UTC, in seconds.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_delta_t_iers_table_info

What it does Reports the first, last observed, and last predicted dates of the embedded IERS Delta-T table.

When to use it Call it when you need to know whether a date is observed, predicted, or outside the IERS file.

Where it fits Automatic Delta-T uses this table where it covers the date.

Call jme_delta_t_iers_table_info(jd_first, jd_last_observed, jd_last, error)
Arguments
  • jd_first Receives the first Julian date in the table.
  • jd_last_observed Receives the last Julian date marked as observed.
  • jd_last Receives the last Julian date in the table, including predictions.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_sidereal_time_ex

What it does Returns Greenwich sidereal time in hours, mean or apparent, with a status.

When to use it Use this when a failure, such as a bad Delta-T, must be an error rather than a bare number.

Where it fits apparent is zero for mean time and non-zero for apparent time. hours receives the result.

Call jme_sidereal_time_ex(jd_ut, apparent, hours, error)
Arguments
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
  • apparent Zero asks for mean sidereal time. Non-zero asks for apparent sidereal time.
  • hours Receives sidereal time in hours.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

Sidereal

jme_get_ayanamsa_ex2

What it does Returns a named ayanamsa at Terrestrial Time, and optionally its rate, with mean or true equinox chosen by flags.

When to use it Use this when the chart must say whether the ayanamsa is mean or true.

Where it fits flags is JME_AYANAMSA_MEAN or JME_AYANAMSA_TRUE. rate may be omitted.

Call jme_get_ayanamsa_ex2(jd_et, model, flags, ayan, rate, error)
Arguments
  • jd_et Terrestrial Time (TT) as a Julian date.
  • model Model id from the JME_MODEL_* or JME_SIDEREAL_* constants, depending on the call.
  • flags Flag bits for this call. Pass 0 for the default. The constant group for this family lists the bits.
  • ayan Receives the ayanamsa in degrees.
  • rate Receives the rate of change. You may pass an empty pointer when you do not need it.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_get_ayanamsa_ex2_ut

What it does Returns a named mean or true ayanamsa at Universal Time, and optionally its rate.

When to use it Use this when the clock is UT.

Where it fits The UT pair of jme_get_ayanamsa_ex2.

Call jme_get_ayanamsa_ex2_ut(jd_ut, model, flags, ayan, rate, error)
Arguments
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
  • model Model id from the JME_MODEL_* or JME_SIDEREAL_* constants, depending on the call.
  • flags Flag bits for this call. Pass 0 for the default. The constant group for this family lists the bits.
  • ayan Receives the ayanamsa in degrees.
  • rate Receives the rate of change. You may pass an empty pointer when you do not need it.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

Houses

jme_houses_gauquelin

What it does Computes the 36 Gauquelin sector cusps at Universal Time.

When to use it Use this for Gauquelin sectors. Do not pass JME_HOUSE_GAUQUELIN to jme_houses.

Where it fits A sector wheel. cusps needs 37 numbers. Polar latitudes, where a semi-arc is undefined, return JME_ERR.

Call jme_houses_gauquelin(jd_ut, flags, geo_lat, geo_lon, cusps, ascmc, error)
Arguments
  • jd_ut Universal Time as a Julian date. Use this when the clock you have is UT.
  • flags Flag bits for this call. Pass 0 for the default. The constant group for this family lists the bits.
  • geo_lat Geographic latitude in degrees. North is positive.
  • geo_lon Geographic longitude in degrees. East is positive.
  • cusps Caller-owned cusp array. Twelve-cusp calls use 13 numbers (index 1 to 12). Gauquelin calls use 37 numbers.
  • ascmc Caller-owned array for the Ascendant, Midheaven, and the other angles this call returns.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_houses_gauquelin_armc

What it does Computes the 36 Gauquelin sector cusps from RAMC and obliquity.

When to use it Use this when you already have RAMC.

Where it fits The RAMC pair of jme_houses_gauquelin. Same 37-cusp array.

Call jme_houses_gauquelin_armc(armc, geo_lat, eps, cusps, ascmc, error)
Arguments
  • armc Right ascension of the Midheaven, in degrees.
  • geo_lat Geographic latitude in degrees. North is positive.
  • eps Obliquity of the ecliptic, in degrees, at the date you are using.
  • cusps Caller-owned cusp array. Twelve-cusp calls use 13 numbers (index 1 to 12). Gauquelin calls use 37 numbers.
  • ascmc Caller-owned array for the Ascendant, Midheaven, and the other angles this call returns.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

Engine policy

jme_calc_resolve_engine

What it does Reports which engine jme_calc will use for a body at a Terrestrial Time.

When to use it Use this when ENGINE=AUTO must not switch models silently, and you want the choice in advance.

Where it fits engine_id receives JPL, Moshier, or VSOP87 plus ELP. The substituted flag is 1 when a barycentre replaced a planet centre.

Call jme_calc_resolve_engine(jd_et, body, engine_id, jpl_center_substituted, error)
Arguments
  • jd_et Terrestrial Time (TT) as a Julian date.
  • body Body id such as JME_BODY_SUN. The body constants list every id.
  • engine_id Receives the engine id: JPL, Moshier, or VSOP87 plus ELP.
  • jpl_center_substituted Receives 1 when a missing planet centre was replaced by its system barycentre.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_set_jpl_center_policy

What it does Chooses what happens when a JPL planet centre is not in the open kernels.

When to use it Use JME_JPL_CENTER_STRICT, the default, when a missing centre must be an error. Use BARYCENTER only when the system barycentre is an acceptable stand-in.

Where it fits Before jme_calc in JPL or AUTO mode. A bad value leaves the previous policy in place.

Call jme_set_jpl_center_policy(policy, error)
Arguments
  • policy JME_JPL_CENTER_STRICT or JME_JPL_CENTER_BARYCENTER.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_get_jpl_center_policy

What it does Returns the active planet-centre policy.

When to use it Call it before you interpret a JPL position of Mars through Pluto.

Where it fits After jme_set_jpl_center_policy.

Call jme_get_jpl_center_policy()
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

Validating setters

jme_set_astro_models_checked

What it does Sets model tokens and rejects an unknown or over-long token.

When to use it Use this instead of jme_set_astro_models when a bad string must not change anything.

Where it fits Startup from user input. On JME_ERR the previous models stay.

Call jme_set_astro_models_checked(models, error)
Arguments
  • models Text tokens such as ENGINE=JPL or ENGINE=MOSHIER. The engine section lists the tokens.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_set_topo_checked

What it does Stores the observer and rejects a non-finite value or a latitude outside -90 to 90.

When to use it Use this when the place comes from a form.

Where it fits On JME_ERR the previous observer stays. Longitude is wrapped.

Call jme_set_topo_checked(lon, lat, altitude, error)
Arguments
  • lon Longitude in degrees. East is positive when this is a place. For an angle helper it is the ecliptic or equatorial longitude the call names.
  • lat Latitude in degrees. North is positive when this is a place.
  • altitude Height. For an observer this is metres. For refraction this is the altitude angle in degrees.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_set_sidereal_mode_checked

What it does Selects an ayanamsa and rejects an unknown mode or a non-finite epoch.

When to use it Use this when the mode comes from a form.

Where it fits On JME_ERR the previous mode stays.

Call jme_set_sidereal_mode_checked(sidereal_mode, t0, ayan_t0, error)
Arguments
  • sidereal_mode Ayanamsa id from the JME_SIDEREAL_* constants.
  • t0 Reference epoch for a user ayanamsa, as a Julian date.
  • ayan_t0 Ayanamsa at t0, in degrees, for the user mode.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

Earth orientation (polar motion)

jme_eop_load_file

What it does Loads an Earth-orientation file of polar motion.

When to use it Call it before you ask for topocentric places that should include polar motion.

Where it fits The file supplies x and y. jme_set_polar_motion turns the correction on.

Call jme_eop_load_file(path, error)
Arguments
  • path Filesystem path. For a kernel this is the .bsp file or the directory that holds it.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_eop_clear

What it does Drops the loaded Earth-orientation table.

When to use it Call it when a later calculation must not use the file you loaded.

Where it fits After a chart that needed polar motion, if the next chart must not inherit it.

Call jme_eop_clear()
Result

Returns nothing. The call writes its output arguments, or it changes a library setting for later calls.

jme_eop_coverage

What it does Reports the first and last modified Julian dates in the loaded Earth-orientation table.

When to use it Call it before you evaluate a date, so you know the date is inside the file.

Where it fits After jme_eop_load_file.

Call jme_eop_coverage(mjd_first, mjd_last, error)
Arguments
  • mjd_first Receives the first modified Julian date in the Earth-orientation file.
  • mjd_last Receives the last modified Julian date in the Earth-orientation file.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_eop_polar_motion

What it does Interpolates polar motion x and y at a modified Julian date.

When to use it Use this to read the angles yourself, or to check a date before enabling the correction.

Where it fits predicted is non-zero when a prediction row was used.

Call jme_eop_polar_motion(mjd, xp_arcsec, yp_arcsec, predicted, error)
Arguments
  • mjd Modified Julian date of the Earth-orientation row you want.
  • xp_arcsec Receives polar motion x, in arcseconds.
  • yp_arcsec Receives polar motion y, in arcseconds.
  • predicted Receives non-zero when a predicted row was used.
  • error Caller-owned text buffer. On failure the library writes the reason here.
Result

Returns JME_OK (0) or JME_ERR (-1). On JME_ERR, read error. The output arguments are written as the description says.

jme_set_polar_motion

What it does Turns polar motion on or off for later topocentric work.

When to use it Turn it on only after a file is loaded and the date is inside that file.

Where it fits It affects observer position, horizontal coordinates, and eclipse geography.

Call jme_set_polar_motion(enabled)
Arguments
  • enabled Non-zero applies polar motion. Zero leaves the observer on the ellipsoid without it.
Result

Returns nothing. The call writes its output arguments, or it changes a library setting for later calls.

jme_get_polar_motion

What it does Returns whether polar motion is currently applied.

When to use it Call it before you interpret a topocentric altitude.

Where it fits After jme_set_polar_motion.

Call jme_get_polar_motion()
Result

Returns the integer result named above. A status-style return uses JME_OK and JME_ERR.

Function group

Behaviour changes in 1.1.0

Read this before you compare a result with a build from before 1.1.0. The items are changes in existing models, not new function names.

  • Precession model PREC=LASKAR1986 (JME_MODEL_PREC_LASKAR_1986) now returns a matrix (Laskar 1986 Tables 5 and 8) instead of an error.
  • JME_MODEL_DELTAT_STEPHENSON_ETC_2016 is now the published 2016 Table S15; JME_TIME_DELTAT_AUTOMATIC uses the 2021 revision before the IERS table.
  • With the DE441 tidal selector (jme_set_tid_acc(JME_TIME_TIDAL_DE441)), historical (pre-1955) Delta-T returns NaN and an error naming Park et al. 2021, because no DE441 lunar tidal acceleration has been published. JME_TIME_TIDAL_AUTOMATIC applies no correction.
  • The tidal correction is never applied to IERS observed/predicted values or to a user-fixed Delta-T.
  • Delta-T models SM1984 and S1997 stay refused with explicit errors (sources unavailable).

Reference

478 Public Constants

Public JME_* constants from the C headers. The same names are exported by PHP, Python, and Dart. JME_JME_H and JME_EXTENDED_H are header include guards, not calculation constants. The bindings still export those two guards. The Use column says what the constant means and which call receives it.

This box filters the constant list. The sidebar search looks through the whole page and highlights each match.

Constant group

Additional Constants

Coordinate ids and other values that did not fall in a narrower group. Pass a coordinate id only to the call that documents it, such as refraction.

Constant Value Use
JME_COORD_APPARENT_TO_TRUE 289 Refraction direction. Pass this as calc_flag to jme_refract or jme_refract_extended to remove refraction and turn an apparent altitude into a true altitude.
JME_COORD_ECLIPTIC_TO_HORIZONTAL 290 Name of the ecliptic-to-horizon conversion. The functions that perform the pieces are jme_ecliptic_to_equatorial and jme_equatorial_to_horizontal.
JME_COORD_EQUATORIAL_TO_HORIZONTAL 291 Name of the equator-to-horizon conversion. The call is jme_equatorial_to_horizontal.
JME_COORD_HORIZONTAL_TO_ECLIPTIC 292 Name of the horizon-to-ecliptic conversion. Go through jme_horizontal_to_equatorial and then jme_equatorial_to_ecliptic.
JME_COORD_HORIZONTAL_TO_EQUATORIAL 293 Name of the horizon-to-equator conversion. The call is jme_horizontal_to_equatorial.
JME_COORD_TRUE_TO_APPARENT 294 Refraction direction. Pass this as calc_flag to add refraction and turn a true altitude into an apparent altitude.

Constant group

Angle and Formatting Constants

Pass a rounding id to jme_split_degree when you print a degree angle. ROUND_DEG, ROUND_MIN, and ROUND_SEC are the values that call applies.

Constant Value Use
JME_ANGLE_FORMAT_KEEP_DEG 0 Angle-format id for keeping the degree field. jme_split_degree itself applies only the ROUND_DEG, ROUND_MIN, and ROUND_SEC ids.
JME_ANGLE_FORMAT_KEEP_SIGN 1 Angle-format id for keeping the sign. jme_split_degree returns the sign separately in isgn.
JME_ANGLE_FORMAT_NAKSHATRA 2 Angle-format id naming a nakshatra-style display. It is not a nakshatra calculation. Longitude boundaries still come from jme_mooncross_ut.
JME_ANGLE_FORMAT_ROUND_DEG 3 Round a split angle to the nearest degree. Pass this as roundflag to jme_split_degree.
JME_ANGLE_FORMAT_ROUND_MIN 4 Round a split angle to the nearest arcminute. Pass this as roundflag to jme_split_degree.
JME_ANGLE_FORMAT_ROUND_SEC 5 Round a split angle to the nearest arcsecond. Pass this as roundflag to jme_split_degree.
JME_ANGLE_FORMAT_ZODIACAL 6 Angle-format id for a sign-and-degree display. It does not compute a sign. Normalise the longitude first, then split it.

Constant group

Body Identifiers

Pass one of these as the body argument. The Sun through Pluto, the Earth, the nodes, and the system barycentres are the usual analytical targets. A numbered asteroid or a small body needs a JPL kernel that contains it.

Constant Value Use
JME_BODY_SUN 0 Body id for the Sun. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MOON 1 Body id for the Moon. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MERCURY 2 Body id for Mercury. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_VENUS 3 Body id for Venus. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MARS 4 Body id for Mars. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_JUPITER 5 Body id for Jupiter. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_SATURN 6 Body id for Saturn. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_URANUS 7 Body id for Uranus. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_NEPTUNE 8 Body id for Neptune. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_PLUTO 9 Body id for Pluto. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_EARTH 10 Body id for the Earth. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_SOLAR_SYSTEM_BARYCENTER 11 Body id for the solar-system barycentre. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MERCURY_BARYCENTER 12 Barycentre of the Mercury system. Use this centre when the kernel has the system barycentre and you did not load the satellite kernel that holds the planet centre.
JME_BODY_VENUS_BARYCENTER 13 Barycentre of the Venus system. Use this centre when the kernel has the system barycentre and you did not load the satellite kernel that holds the planet centre.
JME_BODY_EARTH_MOON_BARYCENTER 14 Body id for the Earth-Moon barycentre. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MARS_BARYCENTER 15 Barycentre of the Mars system. Use this centre when the kernel has the system barycentre and you did not load the satellite kernel that holds the planet centre.
JME_BODY_JUPITER_BARYCENTER 16 Barycentre of the Jupiter system. Use this centre when the kernel has the system barycentre and you did not load the satellite kernel that holds the planet centre.
JME_BODY_SATURN_BARYCENTER 17 Barycentre of the Saturn system. Use this centre when the kernel has the system barycentre and you did not load the satellite kernel that holds the planet centre.
JME_BODY_URANUS_BARYCENTER 18 Barycentre of the Uranus system. Use this centre when the kernel has the system barycentre and you did not load the satellite kernel that holds the planet centre.
JME_BODY_NEPTUNE_BARYCENTER 19 Barycentre of the Neptune system. Use this centre when the kernel has the system barycentre and you did not load the satellite kernel that holds the planet centre.
JME_BODY_PLUTO_BARYCENTER 20 Barycentre of the Pluto system. Use this centre when the kernel has the system barycentre and you did not load the satellite kernel that holds the planet centre.
JME_BODY_MEAN_NODE 21 Body id for the mean lunar node. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_TRUE_NODE 22 Body id for the true lunar node. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_ALTJIRA -1000 Body id for Altjira. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_AMYCUS -1001 Body id for Amycus. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_ARROKOTH -1002 Body id for Arrokoth. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_ASBOLUS -1003 Body id for Asbolus. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_ASTEROID_001 -1004 Asteroid slot 1. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_002 -1005 Asteroid slot 2. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_003 -1006 Asteroid slot 3. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_004 -1007 Asteroid slot 4. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_005 -1008 Asteroid slot 5. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_006 -1009 Asteroid slot 6. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_007 -1010 Asteroid slot 7. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_008 -1011 Asteroid slot 8. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_009 -1012 Asteroid slot 9. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_010 -1013 Asteroid slot 10. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_011 -1014 Asteroid slot 11. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_012 -1015 Asteroid slot 12. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_013 -1016 Asteroid slot 13. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_014 -1017 Asteroid slot 14. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_015 -1018 Asteroid slot 15. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_016 -1019 Asteroid slot 16. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_017 -1020 Asteroid slot 17. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_018 -1021 Asteroid slot 18. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_019 -1022 Asteroid slot 19. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_020 -1023 Asteroid slot 20. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_021 -1024 Asteroid slot 21. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_022 -1025 Asteroid slot 22. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_023 -1026 Asteroid slot 23. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_024 -1027 Asteroid slot 24. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_025 -1028 Asteroid slot 25. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_026 -1029 Asteroid slot 26. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_027 -1030 Asteroid slot 27. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_028 -1031 Asteroid slot 28. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_029 -1032 Asteroid slot 29. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_030 -1033 Asteroid slot 30. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_031 -1034 Asteroid slot 31. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_032 -1035 Asteroid slot 32. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_033 -1036 Asteroid slot 33. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_034 -1037 Asteroid slot 34. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_035 -1038 Asteroid slot 35. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_036 -1039 Asteroid slot 36. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_037 -1040 Asteroid slot 37. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_038 -1041 Asteroid slot 38. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_039 -1042 Asteroid slot 39. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_040 -1043 Asteroid slot 40. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_041 -1044 Asteroid slot 41. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_042 -1045 Asteroid slot 42. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_043 -1046 Asteroid slot 43. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_044 -1047 Asteroid slot 44. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_045 -1048 Asteroid slot 45. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_046 -1049 Asteroid slot 46. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_047 -1050 Asteroid slot 47. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_048 -1051 Asteroid slot 48. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_049 -1052 Asteroid slot 49. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_050 -1053 Asteroid slot 50. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_051 -1054 Asteroid slot 51. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_052 -1055 Asteroid slot 52. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_053 -1056 Asteroid slot 53. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_054 -1057 Asteroid slot 54. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_055 -1058 Asteroid slot 55. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_056 -1059 Asteroid slot 56. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_057 -1060 Asteroid slot 57. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_058 -1061 Asteroid slot 58. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_059 -1062 Asteroid slot 59. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_060 -1063 Asteroid slot 60. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_061 -1064 Asteroid slot 61. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_062 -1065 Asteroid slot 62. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_063 -1066 Asteroid slot 63. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_064 -1067 Asteroid slot 64. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_065 -1068 Asteroid slot 65. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_066 -1069 Asteroid slot 66. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_067 -1070 Asteroid slot 67. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_068 -1071 Asteroid slot 68. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_069 -1072 Asteroid slot 69. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_070 -1073 Asteroid slot 70. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_071 -1074 Asteroid slot 71. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_072 -1075 Asteroid slot 72. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_073 -1076 Asteroid slot 73. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_074 -1077 Asteroid slot 74. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_075 -1078 Asteroid slot 75. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_076 -1079 Asteroid slot 76. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_077 -1080 Asteroid slot 77. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_078 -1081 Asteroid slot 78. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_079 -1082 Asteroid slot 79. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_080 -1083 Asteroid slot 80. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_081 -1084 Asteroid slot 81. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_082 -1085 Asteroid slot 82. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_083 -1086 Asteroid slot 83. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_084 -1087 Asteroid slot 84. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_085 -1088 Asteroid slot 85. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_086 -1089 Asteroid slot 86. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_087 -1090 Asteroid slot 87. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_088 -1091 Asteroid slot 88. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_089 -1092 Asteroid slot 89. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_090 -1093 Asteroid slot 90. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_091 -1094 Asteroid slot 91. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_092 -1095 Asteroid slot 92. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_093 -1096 Asteroid slot 93. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_094 -1097 Asteroid slot 94. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_095 -1098 Asteroid slot 95. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_096 -1099 Asteroid slot 96. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_097 -1100 Asteroid slot 97. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_098 -1101 Asteroid slot 98. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_099 -1102 Asteroid slot 99. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_100 -1103 Asteroid slot 100. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_101 -1104 Asteroid slot 101. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_102 -1105 Asteroid slot 102. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_103 -1106 Asteroid slot 103. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_104 -1107 Asteroid slot 104. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_105 -1108 Asteroid slot 105. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_106 -1109 Asteroid slot 106. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_107 -1110 Asteroid slot 107. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_108 -1111 Asteroid slot 108. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_109 -1112 Asteroid slot 109. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_ASTEROID_110 -1113 Asteroid slot 110. No engine currently maps this slot; jme_calc returns JME_ERR.
JME_BODY_BIENOR -1114 Body id for Bienor. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_BORASISI -1115 Body id for Borasisi. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_CERES -1116 Body id for Ceres. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_CHARIKLO -1117 Body id for Chariklo. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_CHIRON -1118 Body id for Chiron. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_001 -1119 Body id for Comet 001. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_002 -1120 Body id for Comet 002. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_003 -1121 Body id for Comet 003. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_004 -1122 Body id for Comet 004. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_005 -1123 Body id for Comet 005. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_006 -1124 Body id for Comet 006. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_007 -1125 Body id for Comet 007. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_008 -1126 Body id for Comet 008. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_009 -1127 Body id for Comet 009. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_010 -1128 Body id for Comet 010. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_011 -1129 Body id for Comet 011. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_012 -1130 Body id for Comet 012. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_013 -1131 Body id for Comet 013. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_014 -1132 Body id for Comet 014. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_015 -1133 Body id for Comet 015. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_016 -1134 Body id for Comet 016. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_017 -1135 Body id for Comet 017. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_018 -1136 Body id for Comet 018. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_019 -1137 Body id for Comet 019. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_020 -1138 Body id for Comet 020. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_021 -1139 Body id for Comet 021. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_022 -1140 Body id for Comet 022. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_023 -1141 Body id for Comet 023. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_024 -1142 Body id for Comet 024. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_025 -1143 Body id for Comet 025. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_026 -1144 Body id for Comet 026. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_027 -1145 Body id for Comet 027. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_028 -1146 Body id for Comet 028. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_029 -1147 Body id for Comet 029. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_030 -1148 Body id for Comet 030. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_031 -1149 Body id for Comet 031. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_032 -1150 Body id for Comet 032. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_033 -1151 Body id for Comet 033. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_034 -1152 Body id for Comet 034. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_035 -1153 Body id for Comet 035. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_036 -1154 Body id for Comet 036. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_037 -1155 Body id for Comet 037. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_038 -1156 Body id for Comet 038. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_039 -1157 Body id for Comet 039. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_040 -1158 Body id for Comet 040. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_041 -1159 Body id for Comet 041. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_042 -1160 Body id for Comet 042. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_043 -1161 Body id for Comet 043. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_044 -1162 Body id for Comet 044. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_045 -1163 Body id for Comet 045. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_046 -1164 Body id for Comet 046. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_047 -1165 Body id for Comet 047. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_048 -1166 Body id for Comet 048. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_049 -1167 Body id for Comet 049. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_050 -1168 Body id for Comet 050. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_051 -1169 Body id for Comet 051. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_052 -1170 Body id for Comet 052. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_053 -1171 Body id for Comet 053. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_054 -1172 Body id for Comet 054. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_055 -1173 Body id for Comet 055. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_056 -1174 Body id for Comet 056. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_057 -1175 Body id for Comet 057. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_058 -1176 Body id for Comet 058. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_059 -1177 Body id for Comet 059. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_COMET_060 -1178 Body id for Comet 060. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_CRANTOR -1179 Body id for Crantor. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_CYLLARUS -1180 Body id for Cyllarus. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_DEUCALION -1181 Body id for Deucalion. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_ECHECLUS -1182 Body id for Echeclus. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_ELATUS -1183 Body id for Elatus. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_ERIS -1184 Body id for Eris. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_GONGGONG -1185 Body id for Gonggong. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_HAUMEA -1186 Body id for Haumea. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_HUYA -1187 Body id for Huya. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_HYLONOME -1188 Body id for Hylonome. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_IXION -1189 Body id for Ixion. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_JUNO -1190 Body id for Juno. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MAKEMAKE -1191 Body id for Makemake. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_001 -1192 Body id for Minor Planet 001. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_002 -1193 Body id for Minor Planet 002. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_003 -1194 Body id for Minor Planet 003. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_004 -1195 Body id for Minor Planet 004. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_005 -1196 Body id for Minor Planet 005. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_006 -1197 Body id for Minor Planet 006. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_007 -1198 Body id for Minor Planet 007. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_008 -1199 Body id for Minor Planet 008. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_009 -1200 Body id for Minor Planet 009. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_010 -1201 Body id for Minor Planet 010. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_011 -1202 Body id for Minor Planet 011. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_012 -1203 Body id for Minor Planet 012. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_013 -1204 Body id for Minor Planet 013. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_014 -1205 Body id for Minor Planet 014. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_015 -1206 Body id for Minor Planet 015. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_016 -1207 Body id for Minor Planet 016. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_017 -1208 Body id for Minor Planet 017. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_018 -1209 Body id for Minor Planet 018. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_019 -1210 Body id for Minor Planet 019. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_020 -1211 Body id for Minor Planet 020. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_021 -1212 Body id for Minor Planet 021. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_022 -1213 Body id for Minor Planet 022. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_023 -1214 Body id for Minor Planet 023. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_024 -1215 Body id for Minor Planet 024. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_025 -1216 Body id for Minor Planet 025. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_026 -1217 Body id for Minor Planet 026. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_027 -1218 Body id for Minor Planet 027. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_028 -1219 Body id for Minor Planet 028. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_029 -1220 Body id for Minor Planet 029. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_030 -1221 Body id for Minor Planet 030. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_031 -1222 Body id for Minor Planet 031. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_032 -1223 Body id for Minor Planet 032. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_033 -1224 Body id for Minor Planet 033. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_034 -1225 Body id for Minor Planet 034. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_035 -1226 Body id for Minor Planet 035. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_036 -1227 Body id for Minor Planet 036. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_037 -1228 Body id for Minor Planet 037. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_038 -1229 Body id for Minor Planet 038. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_039 -1230 Body id for Minor Planet 039. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_040 -1231 Body id for Minor Planet 040. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_041 -1232 Body id for Minor Planet 041. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_042 -1233 Body id for Minor Planet 042. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_043 -1234 Body id for Minor Planet 043. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_044 -1235 Body id for Minor Planet 044. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_045 -1236 Body id for Minor Planet 045. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_046 -1237 Body id for Minor Planet 046. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_047 -1238 Body id for Minor Planet 047. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_048 -1239 Body id for Minor Planet 048. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_049 -1240 Body id for Minor Planet 049. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_050 -1241 Body id for Minor Planet 050. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_051 -1242 Body id for Minor Planet 051. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_052 -1243 Body id for Minor Planet 052. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_053 -1244 Body id for Minor Planet 053. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_054 -1245 Body id for Minor Planet 054. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_055 -1246 Body id for Minor Planet 055. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_056 -1247 Body id for Minor Planet 056. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_057 -1248 Body id for Minor Planet 057. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_058 -1249 Body id for Minor Planet 058. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_059 -1250 Body id for Minor Planet 059. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_MINOR_PLANET_060 -1251 Body id for Minor Planet 060. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_NESSUS -1252 Body id for Nessus. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_OKYRHOE -1253 Body id for Okyrhoe. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_ORCUS -1254 Body id for Orcus. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_PALLAS -1255 Body id for Pallas. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_PELOPS -1256 Body id for Pelops. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_PHOLUS -1257 Body id for Pholus. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_QUAOAR -1258 Body id for Quaoar. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_RHADAMANTHUS -1259 Body id for Rhadamanthus. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_SALACIA -1260 Body id for Salacia. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_SEDNA -1261 Body id for Sedna. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_THEREUS -1262 Body id for Thereus. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_TYTHONUS -1263 Body id for Tythonus. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_VARUNA -1264 Body id for Varuna. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.
JME_BODY_VESTA -1265 Body id for Vesta. Calculation support depends on the selected engine and, for JPL, the loaded kernel. Unsupported targets return JME_ERR.

Constant group

Calculation Flags

Combine these bits in the flags argument of jme_calc, jme_calc_ut, and the calls that share that flags word. Pass 0 for the default place. jme_calc still fills the six result slots when JME_CALC_SPEED is absent.

Constant Value Use
JME_CALC_NONE 0 No extra bits. Pass this, or the number 0, when you want the default place. Combine it with other JME_CALC_* bits in flags.
JME_CALC_SPEED 1 Speed bit. jme_calc and jme_calc_ut still fill indexes 3–5, the rates, whether or not you set it. Combine it with other JME_CALC_* bits in flags.
JME_CALC_EQUATORIAL 2 Ask for equatorial coordinates instead of ecliptic coordinates. Combine it with other JME_CALC_* bits in flags.
JME_CALC_XYZ 4 Ask for a rectangular vector. Same bit value as JME_CALC_RECTANGULAR and JME_CALC_RAW_VECTOR. Combine it with other JME_CALC_* bits in flags.
JME_CALC_RADIANS 8 Return angles in radians instead of degrees. Combine it with other JME_CALC_* bits in flags.
JME_CALC_BARYCENTRIC 16 Use the solar-system barycentre as the origin. Combine it with other JME_CALC_* bits in flags.
JME_CALC_HELIOCENTRIC 32 Use the Sun as the origin. Combine it with other JME_CALC_* bits in flags.
JME_CALC_TRUE_POSITION 64 Ask for the true geometric place rather than the apparent place. Combine it with other JME_CALC_* bits in flags.
JME_CALC_J2000 128 Express the place in the J2000 frame. Combine it with other JME_CALC_* bits in flags.
JME_CALC_NO_NUTATION 256 Leave nutation out of this call. Combine it with other JME_CALC_* bits in flags.
JME_CALC_SIDEREAL 512 Subtract the active ayanamsa. Set the mode first with jme_set_sidereal_mode. Combine it with other JME_CALC_* bits in flags.
JME_CALC_APPARENT_POSITION 0 The apparent-place choice. Its value is 0, so it is the default when no true-position bit is set. Combine it with other JME_CALC_* bits in flags.
JME_CALC_ASTROMETRIC 3072 Astrometric place: light time and light deflection without aberration. It combines the no-aberration and no-deflection bits as this enum defines them. Combine it with other JME_CALC_* bits in flags.
JME_CALC_CENTER_BODY 4096 Take the centre from the call that has a centre argument, rather than from the default. Combine it with other JME_CALC_* bits in flags.
JME_CALC_DISTANCE_AU 0 Distance in astronomical units. Its value is 0, so it is the default distance unit. Combine it with other JME_CALC_* bits in flags.
JME_CALC_DISTANCE_KM 8192 Distance in kilometres. Combine it with other JME_CALC_* bits in flags.
JME_CALC_HIGH_PRECISION 16384 High-precision request bit. The published reduction does not drop series terms when this bit is absent. Combine it with other JME_CALC_* bits in flags.
JME_CALC_ICRS 32768 Express the place in the ICRS frame. Combine it with other JME_CALC_* bits in flags.
JME_CALC_NO_ABERRATION 1024 Leave aberration out of an apparent place. Combine it with other JME_CALC_* bits in flags.
JME_CALC_NO_LIGHT_DEFLECTION 2048 Leave gravitational light deflection out. Combine it with other JME_CALC_* bits in flags.
JME_CALC_RAW_VECTOR 4 Rectangular vector. Same value as JME_CALC_XYZ. Combine it with other JME_CALC_* bits in flags.
JME_CALC_RECTANGULAR 4 Rectangular coordinates. Same value as JME_CALC_XYZ. Combine it with other JME_CALC_* bits in flags.
JME_CALC_SPHERICAL 0 Spherical coordinates. Its value is 0, so it is the default shape. Combine it with other JME_CALC_* bits in flags.
JME_CALC_STRICT 65536 Fail instead of substituting another model or another centre. Combine it with other JME_CALC_* bits in flags.
JME_CALC_TOPOCENTRIC 131072 Compute for the observer stored by jme_set_topo. Combine it with other JME_CALC_* bits in flags.
JME_CALC_VELOCITY_PER_DAY 0 Rates per day. Its value is 0, so it is the default rate unit. Combine it with other JME_CALC_* bits in flags.
JME_CALC_VELOCITY_PER_SECOND 262144 Rates per second. Combine it with other JME_CALC_* bits in flags.

Constant group

Calendar and Time Constants

Pass these to calendar and time calls: which calendar, which time scale, and which Delta-T or tidal choice.

Constant Value Use
JME_SECONDS_PER_DAY 86400.0 Length of a day in seconds, 86400. Use it to turn a Julian-date fraction into seconds.
JME_CALENDAR_JULIAN 0 Calendar-system selector.
JME_CALENDAR_GREGORIAN 1 Calendar-system selector.
JME_TIME_DELTAT_AUTOMATIC 389 Default Delta-T choice for jme_delta_t_ex: IERS values where the embedded table covers the date, the 2021 Stephenson revision before that table, and Espenak–Meeus 2006 after it.
JME_TIME_TIDAL_AUTOMATIC 390 Tidal choice that applies no extra historical correction. Pass this to jme_set_tid_acc when you do not want a DE-specific acceleration.
JME_TIME_TIDAL_DE200 391 Tidal acceleration associated with the DE200 planetary ephemeris. Pass this to jme_set_tid_acc when long-range Delta-T should follow that ephemeris.
JME_TIME_TIDAL_DE403 392 Tidal acceleration associated with the DE403 planetary ephemeris. Pass this to jme_set_tid_acc when long-range Delta-T should follow that ephemeris.
JME_TIME_TIDAL_DE404 393 Tidal acceleration associated with the DE404 planetary ephemeris. Pass this to jme_set_tid_acc when long-range Delta-T should follow that ephemeris.
JME_TIME_TIDAL_DE405 394 Tidal acceleration associated with the DE405 planetary ephemeris. Pass this to jme_set_tid_acc when long-range Delta-T should follow that ephemeris.
JME_TIME_TIDAL_DE406 395 Tidal acceleration associated with the DE406 planetary ephemeris. Pass this to jme_set_tid_acc when long-range Delta-T should follow that ephemeris.
JME_TIME_TIDAL_DE421 396 Tidal acceleration associated with the DE421 planetary ephemeris. Pass this to jme_set_tid_acc when long-range Delta-T should follow that ephemeris.
JME_TIME_TIDAL_DE430 397 Tidal acceleration associated with the DE430 planetary ephemeris. Pass this to jme_set_tid_acc when long-range Delta-T should follow that ephemeris.
JME_TIME_TIDAL_DE431 398 Tidal acceleration associated with the DE431 planetary ephemeris. Pass this to jme_set_tid_acc when long-range Delta-T should follow that ephemeris.
JME_TIME_TIDAL_DE441 399 Tidal acceleration associated with the DE441 planetary ephemeris. Pass this to jme_set_tid_acc when long-range Delta-T should follow that ephemeris. No historical tidal acceleration has been published for DE441, so pre-1955 Delta-T then returns a non-finite value and an error.

Constant group

Eclipse and Event Flags

These name eclipse contacts and eclipse types. Use them to read a circumstance value or to recognise a returned type. They are not a replacement for the eclipse search calls.

Constant Value Use
JME_ECLIPSE_FIRST_CONTACT 295 First contact, the start of the partial phase. Read it against the attributes returned by the eclipse calls.
JME_ECLIPSE_FOURTH_CONTACT 296 Fourth contact, the end of the partial phase. Read it against the attributes returned by the eclipse calls.
JME_ECLIPSE_LUNAR_PARTIAL 297 Lunar eclipse type: partial. Read it against the attributes returned by the eclipse calls.
JME_ECLIPSE_LUNAR_PENUMBRAL 298 Lunar eclipse type: penumbral. Read it against the attributes returned by the eclipse calls.
JME_ECLIPSE_LUNAR_TOTAL 299 Lunar eclipse type: total. Read it against the attributes returned by the eclipse calls.
JME_ECLIPSE_MAX_VISIBLE 300 Maximum eclipse at the place you asked about. Read it against the attributes returned by the eclipse calls.
JME_ECLIPSE_PENUMBRAL_BEGIN 301 Start of the penumbral phase of a lunar eclipse. Read it against the attributes returned by the eclipse calls.
JME_ECLIPSE_PENUMBRAL_END 302 End of the penumbral phase of a lunar eclipse. Read it against the attributes returned by the eclipse calls.
JME_ECLIPSE_SECOND_CONTACT 303 Second contact, the start of totality or annularity. Read it against the attributes returned by the eclipse calls.
JME_ECLIPSE_SOLAR_ANNULAR 304 Solar eclipse type: annular. Read it against the attributes returned by the eclipse calls.
JME_ECLIPSE_SOLAR_CENTRAL 305 The axis of the shadow meets the Earth. Read it against the attributes returned by the eclipse calls.
JME_ECLIPSE_SOLAR_HYBRID 306 Solar eclipse type: hybrid, annular on part of the path and total on part. Read it against the attributes returned by the eclipse calls.
JME_ECLIPSE_SOLAR_NONCENTRAL 307 The eclipse is not central. Read it against the attributes returned by the eclipse calls.
JME_ECLIPSE_SOLAR_PARTIAL 308 Solar eclipse type: partial. Read it against the attributes returned by the eclipse calls.
JME_ECLIPSE_SOLAR_TOTAL 309 Solar eclipse type: total. Read it against the attributes returned by the eclipse calls.
JME_ECLIPSE_THIRD_CONTACT 310 Third contact, the end of totality or annularity. Read it against the attributes returned by the eclipse calls.
JME_ECLIPSE_VISIBLE 311 The eclipse is visible for the circumstance you tested. Read it against the attributes returned by the eclipse calls.

Constant group

House Systems

Pass one of these as house_system to jme_houses, jme_houses_ex, or jme_houses_ex2. JME_HOUSE_GAUQUELIN is not accepted there. Gauquelin sectors use jme_houses_gauquelin.

Constant Value Use
JME_HOUSE_ALCABITIUS 312 Alcabitius houses. Pass it as house_system to jme_houses, jme_houses_ex, or jme_houses_ex2.
JME_HOUSE_APC 313 APC houses. Pass it as house_system to jme_houses, jme_houses_ex, or jme_houses_ex2.
JME_HOUSE_AZIMUTHAL 314 Azimuthal or horizontal-azimuth houses. Pass it as house_system to jme_houses, jme_houses_ex, or jme_houses_ex2.
JME_HOUSE_CAMPANUS 315 Campanus houses. Pass it as house_system to jme_houses, jme_houses_ex, or jme_houses_ex2.
JME_HOUSE_EQUAL 316 Equal houses from the Ascendant. Pass it as house_system to jme_houses, jme_houses_ex, or jme_houses_ex2.
JME_HOUSE_GAUQUELIN 317 Gauquelin sector id. Do not pass it to jme_houses. Call jme_houses_gauquelin, which returns 36 sectors.
JME_HOUSE_HORIZONTAL 318 Horizontal houses. Pass it as house_system to jme_houses, jme_houses_ex, or jme_houses_ex2.
JME_HOUSE_KOCH 319 Koch houses. Pass it as house_system to jme_houses, jme_houses_ex, or jme_houses_ex2.
JME_HOUSE_KRUSINSKI 320 Krusinski houses. Pass it as house_system to jme_houses, jme_houses_ex, or jme_houses_ex2.
JME_HOUSE_MERIDIAN 321 Meridian houses. Pass it as house_system to jme_houses, jme_houses_ex, or jme_houses_ex2.
JME_HOUSE_MORINUS 322 Morinus houses. Pass it as house_system to jme_houses, jme_houses_ex, or jme_houses_ex2.
JME_HOUSE_PLACIDUS 323 Placidus houses. This is the usual time-based system. Pass it as house_system to jme_houses, jme_houses_ex, or jme_houses_ex2.
JME_HOUSE_POLICH_PAGE 324 Polich-Page, or topocentric, houses. Pass it as house_system to jme_houses, jme_houses_ex, or jme_houses_ex2.
JME_HOUSE_PORPHYRIUS 325 Porphyry houses. Pass it as house_system to jme_houses, jme_houses_ex, or jme_houses_ex2.
JME_HOUSE_REGIOMONTANUS 326 Regiomontanus houses. Pass it as house_system to jme_houses, jme_houses_ex, or jme_houses_ex2.
JME_HOUSE_SUNSHINE 327 Sunshine houses, which use the Sun's declination. Pass it as house_system to jme_houses, jme_houses_ex, or jme_houses_ex2.
JME_HOUSE_VEHLOW_EQUAL 328 Vehlow equal houses. Pass it as house_system to jme_houses, jme_houses_ex, or jme_houses_ex2.
JME_HOUSE_WHOLE_SIGN 329 Whole-sign houses. Pass it as house_system to jme_houses, jme_houses_ex, or jme_houses_ex2.

Constant group

JPL and Kernel Constants

Use these with the low-level kernel calls: vector units, orientation units, and the planet-centre policy.

Constant Value Use
JME_JPL_TIMESCALE_UNKNOWN 0 JPL/CALCEPH kernel, target, or metadata selector.
JME_JPL_TIMESCALE_TDB 1 JPL/CALCEPH kernel, target, or metadata selector.
JME_JPL_TIMESCALE_TCB 2 JPL/CALCEPH kernel, target, or metadata selector.

Constant group

Models and Frames

Pass these to the model getters and to jme_set_astro_models when you need a named precession, nutation, obliquity, bias, or Delta-T series.

Constant Value Use
JME_VECTOR_AU_PER_DAY 0 State unit: astronomical units and days. Pass this as unit to a kernel position call or to jme_state_convert_units. It is the usual default.
JME_VECTOR_KM_PER_DAY 1 State unit: kilometres and days.
JME_VECTOR_AU_PER_SECOND 2 State unit: astronomical units and seconds.
JME_VECTOR_KM_PER_SECOND 3 State unit: kilometres and seconds.
JME_ORIENTATION_RAD_PER_DAY 0 Orientation unit: radians and days. Pass this as unit to a kernel orientation or angular-momentum call.
JME_ORIENTATION_RAD_PER_SECOND 1 Orientation unit: radians and seconds.
JME_MODEL_BIAS_IAU2000 330 IAU 2000 frame bias.
JME_MODEL_BIAS_IAU2006 331 IAU 2006 frame bias.
JME_MODEL_BIAS_NONE 332 No frame bias. Pass this when a matrix call should skip the bias rotation.
JME_MODEL_NUT_IAU_1980 333 Nutation series IAU 1980. Pass this to jme_get_nutation or as the nutation token.
JME_MODEL_NUT_IAU_2000A 334 Nutation series IAU 2000A.
JME_MODEL_NUT_IAU_2000B 335 Nutation series IAU 2000B, the shorter 2000 series.
JME_MODEL_OBL_IAU_1980 336 Obliquity polynomial IAU 1980. Pass this to jme_get_obliquity.
JME_MODEL_OBL_IAU_2000 337 Obliquity polynomial IAU 2000.
JME_MODEL_OBL_IAU_2006 338 Obliquity polynomial IAU 2006.
JME_MODEL_PREC_IAU_1976 339 Precession IAU 1976. Pass this to jme_get_precession_matrix or as a precession token.
JME_MODEL_PREC_IAU_2000 340 Precession IAU 2000.
JME_MODEL_PREC_IAU_2006 341 Precession IAU 2006.
JME_MODEL_PREC_LASKAR_1986 342 Precession Laskar 1986. From 1.1.0 this returns a matrix from Laskar's tables instead of an error.
JME_MODEL_PREC_VONDRAK_2011 343 Precession Vondrák 2011, for long time spans.
JME_MODEL_SIDT_IAU_1976 344 Sidereal-time model IAU 1976.
JME_MODEL_SIDT_IAU_2006 345 Sidereal-time model IAU 2006.
JME_MODEL_DELTAT_STEPHENSON_MORRISON_1984 346 Delta-T id for Stephenson and Morrison 1984. The source table is not in this library, so a request returns a non-finite value and an error.
JME_MODEL_DELTAT_STEPHENSON_1997 347 Delta-T id for Stephenson 1997. The source table is not in this library, so a request returns a non-finite value and an error.
JME_MODEL_DELTAT_STEPHENSON_MORRISON_2004 348 Delta-T id for Stephenson and Morrison 2004. The primary table is not transcribed here, so a request returns a non-finite value and an error. The separate linear-table id is the one that evaluates.
JME_MODEL_DELTAT_ESPENAK_MEEUS_2006 349 Delta-T series of Espenak and Meeus 2006. Pass this to jme_delta_t_ex. Automatic mode uses it after the IERS table ends.
JME_MODEL_DELTAT_STEPHENSON_ETC_2016 350 Delta-T from the published 2016 Table S15. Pass this to jme_delta_t_ex when you want that series rather than the 2021 revision used by automatic mode.
JME_MODEL_REVISED_IAU_2000 401 Enum id for the revised IAU 2000 convention. Pass it only to a setter or getter that lists this id. It is not a position by itself.
JME_MODEL_REVISED_IAU_2006 402 Enum id for the revised IAU 2006 convention. Pass it only where that id is documented.
JME_MODEL_REVISED_PREC_LASKAR 403 Enum id naming a revised Laskar precession. Pass it only where that id is documented.
JME_MODEL_REVISED_PREC_VONDRAK 404 Enum id naming a revised Vondrák precession. Pass it only where that id is documented.
JME_MODEL_REVISED_PREC_LIESKE 405 Enum id naming a revised Lieske precession. Pass it only where that id is documented.

Constant group

Rise and Transit Flags

Pass one of these as rsmi to jme_rise_trans or jme_rise_trans_true_hor. Rise, set, transit, and the twilights are different searches.

Constant Value Use
JME_RISE_ANTI_MERIDIAN_TRANSIT 8 Search for the transit across the anti-meridian, the lower culmination.
JME_RISE_ASTRONOMICAL_TWILIGHT 512 Sun at the astronomical twilight depression.
JME_RISE_CIVIL_TWILIGHT 128 Sun at the civil twilight depression.
JME_RISE_DISC_BOTTOM 2048 Lower-limb horizon. Unsupported: jme_rise_trans returns JME_ERR when this bit is set.
JME_RISE_DISC_CENTER 256 Use the centre of the disc rather than the upper limb.
JME_RISE_FIXED_DISC_SIZE 1024 Keep the fixed horizon used by this engine (accepted).
JME_RISE_HINDU_RISING 4096 Hindu rising convention. Unsupported: jme_rise_trans returns JME_ERR when this bit is set.
JME_RISE_MERIDIAN_TRANSIT 4 Search for the transit across the meridian, the culmination.
JME_RISE_NAUTICAL_TWILIGHT 64 Sun at the nautical twilight depression.
JME_RISE_NO_REFRACTION 8192 Do not apply atmospheric refraction to the horizon.
JME_RISE_RISE 1 Search for rising. Pass this as rsmi when you want the moment the body comes up.
JME_RISE_SET 2 Search for setting.

Constant group

Sidereal Modes

Pass one of these to jme_set_sidereal_mode, or to an ayanamsa getter that takes a model. The epoch of each mode is described in AYANAMSA_MODELS.md.

Constant Value Use
JME_SIDEREAL_FAGAN_BRADLEY 0 Ayanamsa FAGAN BRADLEY. Pass this to jme_set_sidereal_mode, or to an ayanamsa getter that takes a model, when sidereal longitudes should use this mode. The epoch is in AYANAMSA_MODELS.md.
JME_SIDEREAL_LAHIRI 1 Ayanamsa LAHIRI. Pass this to jme_set_sidereal_mode, or to an ayanamsa getter that takes a model, when sidereal longitudes should use this mode. The epoch is in AYANAMSA_MODELS.md.
JME_SIDEREAL_USER 255 User ayanamsa. Pass this to jme_set_sidereal_mode with your own epoch t0 and the ayanamsa ayan_t0 at that epoch.
JME_SIDEREAL_ALDEBARAN_15TAU 363 Ayanamsa ALDEBARAN 15TAU. Pass this to jme_set_sidereal_mode, or to an ayanamsa getter that takes a model, when sidereal longitudes should use this mode. The epoch is in AYANAMSA_MODELS.md.
JME_SIDEREAL_ARYABHATA 364 Ayanamsa ARYABHATA. Pass this to jme_set_sidereal_mode, or to an ayanamsa getter that takes a model, when sidereal longitudes should use this mode. The epoch is in AYANAMSA_MODELS.md.
JME_SIDEREAL_B1950 365 Ayanamsa B1950. Pass this to jme_set_sidereal_mode, or to an ayanamsa getter that takes a model, when sidereal longitudes should use this mode. The epoch is in AYANAMSA_MODELS.md.
JME_SIDEREAL_BABYL_ETPSC 366 Ayanamsa BABYL ETPSC. Pass this to jme_set_sidereal_mode, or to an ayanamsa getter that takes a model, when sidereal longitudes should use this mode. The epoch is in AYANAMSA_MODELS.md.
JME_SIDEREAL_BABYL_HUBER 367 Ayanamsa BABYL HUBER. Pass this to jme_set_sidereal_mode, or to an ayanamsa getter that takes a model, when sidereal longitudes should use this mode. The epoch is in AYANAMSA_MODELS.md.
JME_SIDEREAL_BABYL_KUGLER1 368 Ayanamsa BABYL KUGLER1. Pass this to jme_set_sidereal_mode, or to an ayanamsa getter that takes a model, when sidereal longitudes should use this mode. The epoch is in AYANAMSA_MODELS.md.
JME_SIDEREAL_BABYL_KUGLER2 369 Ayanamsa BABYL KUGLER2. Pass this to jme_set_sidereal_mode, or to an ayanamsa getter that takes a model, when sidereal longitudes should use this mode. The epoch is in AYANAMSA_MODELS.md.
JME_SIDEREAL_BABYL_KUGLER3 370 Ayanamsa BABYL KUGLER3. Pass this to jme_set_sidereal_mode, or to an ayanamsa getter that takes a model, when sidereal longitudes should use this mode. The epoch is in AYANAMSA_MODELS.md.
JME_SIDEREAL_DELUCE 371 Ayanamsa DELUCE. Pass this to jme_set_sidereal_mode, or to an ayanamsa getter that takes a model, when sidereal longitudes should use this mode. The epoch is in AYANAMSA_MODELS.md.
JME_SIDEREAL_GALCENT_0SAG 372 Ayanamsa GALCENT 0SAG. Pass this to jme_set_sidereal_mode, or to an ayanamsa getter that takes a model, when sidereal longitudes should use this mode. The epoch is in AYANAMSA_MODELS.md.
JME_SIDEREAL_HIPPARCHOS 373 Ayanamsa HIPPARCHOS. Pass this to jme_set_sidereal_mode, or to an ayanamsa getter that takes a model, when sidereal longitudes should use this mode. The epoch is in AYANAMSA_MODELS.md.
JME_SIDEREAL_J1900 374 Ayanamsa J1900. Pass this to jme_set_sidereal_mode, or to an ayanamsa getter that takes a model, when sidereal longitudes should use this mode. The epoch is in AYANAMSA_MODELS.md.
JME_SIDEREAL_J2000 375 Ayanamsa J2000. Pass this to jme_set_sidereal_mode, or to an ayanamsa getter that takes a model, when sidereal longitudes should use this mode. The epoch is in AYANAMSA_MODELS.md.
JME_SIDEREAL_JN_BHASIN 376 Ayanamsa JN BHASIN. Pass this to jme_set_sidereal_mode, or to an ayanamsa getter that takes a model, when sidereal longitudes should use this mode. The epoch is in AYANAMSA_MODELS.md.
JME_SIDEREAL_KRISHNAMURTI 377 Ayanamsa KRISHNAMURTI. Pass this to jme_set_sidereal_mode, or to an ayanamsa getter that takes a model, when sidereal longitudes should use this mode. The epoch is in AYANAMSA_MODELS.md.
JME_SIDEREAL_RAMAN 378 Ayanamsa RAMAN. Pass this to jme_set_sidereal_mode, or to an ayanamsa getter that takes a model, when sidereal longitudes should use this mode. The epoch is in AYANAMSA_MODELS.md.
JME_SIDEREAL_SASSANIAN 379 Ayanamsa SASSANIAN. Pass this to jme_set_sidereal_mode, or to an ayanamsa getter that takes a model, when sidereal longitudes should use this mode. The epoch is in AYANAMSA_MODELS.md.
JME_SIDEREAL_SS_CITRA 380 Ayanamsa SS CITRA. Pass this to jme_set_sidereal_mode, or to an ayanamsa getter that takes a model, when sidereal longitudes should use this mode. The epoch is in AYANAMSA_MODELS.md.
JME_SIDEREAL_SS_REVATI 381 Ayanamsa SS REVATI. Pass this to jme_set_sidereal_mode, or to an ayanamsa getter that takes a model, when sidereal longitudes should use this mode. The epoch is in AYANAMSA_MODELS.md.
JME_SIDEREAL_SURYASIDDHANTA 382 Ayanamsa SURYASIDDHANTA. Pass this to jme_set_sidereal_mode, or to an ayanamsa getter that takes a model, when sidereal longitudes should use this mode. The epoch is in AYANAMSA_MODELS.md.
JME_SIDEREAL_TRUE_CITRA 383 Ayanamsa TRUE CITRA. Pass this to jme_set_sidereal_mode, or to an ayanamsa getter that takes a model, when sidereal longitudes should use this mode. The epoch is in AYANAMSA_MODELS.md.
JME_SIDEREAL_TRUE_MULA 384 Ayanamsa TRUE MULA. Pass this to jme_set_sidereal_mode, or to an ayanamsa getter that takes a model, when sidereal longitudes should use this mode. The epoch is in AYANAMSA_MODELS.md.
JME_SIDEREAL_TRUE_PUSHYA 385 Ayanamsa TRUE PUSHYA. Pass this to jme_set_sidereal_mode, or to an ayanamsa getter that takes a model, when sidereal longitudes should use this mode. The epoch is in AYANAMSA_MODELS.md.
JME_SIDEREAL_TRUE_REVATI 386 Ayanamsa TRUE REVATI. Pass this to jme_set_sidereal_mode, or to an ayanamsa getter that takes a model, when sidereal longitudes should use this mode. The epoch is in AYANAMSA_MODELS.md.
JME_SIDEREAL_USHASHASHI 387 Ayanamsa USHASHASHI. Pass this to jme_set_sidereal_mode, or to an ayanamsa getter that takes a model, when sidereal longitudes should use this mode. The epoch is in AYANAMSA_MODELS.md.
JME_SIDEREAL_YUKTESHWAR 388 Ayanamsa YUKTESHWAR. Pass this to jme_set_sidereal_mode, or to an ayanamsa getter that takes a model, when sidereal longitudes should use this mode. The epoch is in AYANAMSA_MODELS.md.

Constant group

Status and Metadata

JME_OK and JME_ERR are the status codes. The version and physical constants are for display and for your own unit conversions.

Constant Value Use
JME_JME_H 1 Header include guard exported by the bindings. Not a calculation constant.
JME_VERSION 2.0.0 Version string of this library. jme_version copies it. This release is 2.0.0.
JME_AU_KM 149597870.7 Astronomical unit in kilometres, 149597870.700. Use it when you convert a distance yourself. Light-time inside the library already uses this value.
JME_SPEED_OF_LIGHT_KM_PER_SEC 299792.458 Speed of light in kilometres per second. Use it for your own light-time check. The library's reduction already uses the defined SI value.
JME_OK 0 Native success/error status code.
JME_ERR -1 Native success/error status code.
JME_EXTENDED_H 1 Header include guard exported by the bindings. Not a calculation constant.
JME_VERSION_ID 400 Numeric id 400. It stays 400 across this release. It is not the package version. Read JME_VERSION or call jme_version for the version string.

Constant group

Added in 1.1.0

Constants that entered in 1.1.0. They belong to time scales, ayanamsa flags, the planet-centre policy, and the engine report.

Constant Value Use
JME_TIME_SCALE_UTC 0 Time scale for jme_time_scale_convert (ABI value).
JME_TIME_SCALE_UT1 1 Time scale for jme_time_scale_convert (realised with the context Delta-T model).
JME_TIME_SCALE_TAI 2 Time scale for jme_time_scale_convert.
JME_TIME_SCALE_TT 3 Time scale for jme_time_scale_convert.
JME_TIME_SCALE_TDB 4 Time scale for jme_time_scale_convert.
JME_TIME_SCALE_TCG 5 Time scale for jme_time_scale_convert.
JME_TIME_SCALE_TCB 6 Time scale for jme_time_scale_convert.
JME_AYANAMSA_MEAN 0 jme_get_ayanamsa_ex2 flag: mean equinox of date.
JME_AYANAMSA_TRUE 1 jme_get_ayanamsa_ex2 flag: true equinox of date (mean + nutation in longitude).
JME_JPL_CENTER_STRICT 0 JPL planet-centre policy: missing planet centre is an error (default).
JME_JPL_CENTER_BARYCENTER 1 JPL planet-centre policy: use the system barycentre when the planet centre is missing (opt-in).
JME_ENGINE_ID_JPL 1 Engine reported by jme_calc_resolve_engine: JPL/CALCEPH.
JME_ENGINE_ID_MOSHIER 2 Engine reported by jme_calc_resolve_engine: Moshier.
JME_ENGINE_ID_VSOP87_ELP82B 3 Engine reported by jme_calc_resolve_engine: VSOP87A + ELP 2000-82B.
JME_MODEL_NUT_IAU_2006A 351 Nutation model: IAU 2000A with IAU 2006 (P03) adjustments (ERFA eraNut06a).
JME_SIDEREAL_LAHIRI_ICRC 406 Sidereal mode: Lahiri (ICRC definition).
JME_MODEL_DELTAT_STEPHENSON_ETC_2021 407 Delta-T model: Morrison, Stephenson, Hohenkerk & Zawilski 2021 (Table S15, 2020 revision); used by AUTOMATIC before the IERS table.
JME_MODEL_DELTAT_MS2004_TABLE1_LINEAR 408 Delta-T model: Morrison & Stephenson 2004 Table 1 with the authors' simple (linear) interpolation; their parabola -20 + 32t^2 outside the table.

Check

Quality

Run the check in the repository you changed. The wrapper checks compare the generated surface with the C headers.

C

make test
make quality

PHP

composer verify:surface
composer quality

Python

python -m ruff check .
python -m ruff format . --check
python -m pyright
python -m pytest

Dart

./scripts/quality.sh