# FUNCTION

# Public

# * (&REST ARGS)

Multiplication of generalized or regular numbers with an
arbitrary number of arguments.

# + (&REST ARGS)

Addition of generalized or regular numbers with an
arbitrary number of arguments.

# - (&REST ARGS)

Subtraction of generalized or regular numbers.

# / (&REST ARGS)

Division of generalized or regular numbers for an
arbitrary number of arguments.

# ADD-ATTRIBUTE-TO-PARAMETER (CATEGORY NAME ATTRIBUTE &OPTIONAL DESCRIPTION)

Declare that the parameter, already created, has the stated attribute.

# ALL-SAME (LIST &KEY (TEST #'EQL) POST-FUNCTION)

If all elements are the same, that value and T are returned; if
not, nil and nil are returned. The post-function is applied to the
common value before returning the answer if there is one.

# ALL-TIME-UNITS (TIME-INTERVAL &OPTIONAL (STREAM *STANDARD-OUTPUT*))

Show the time interval in all possible time units.

# ANGLE-AS-TIME (ANGLE &OPTIONAL (NORMALIZE T))

Convert the angle to a time (interval), where one revolution is a
complete day.

# ANGLE-LAW-OF-COSINES (LENGTH-OPP LENGTH-ADJ1 LENGTH-ADJ2)

Solve for the angle when lengths of a triangle are known.

# ATTRIBUTEP (SYMBOL-OR-LIST &OPTIONAL ERROR)

This is a defined attribute, or list of attributes.

# CHECK-DIMENSION (OBJ UNITS &OPTIONAL (ERRORP T) (ZEROS-HAVE-ANY-DIMENSION *ZERO-IS-DIMENSIONLESS*))

T if one of these cases hold:
- obj is a pdq and units have the same dimension as obj,
- obj is zero and zeros-have-any-dimension is T,
- obj and units represent a dimensionless quantity,
- obj and units are grids of the same length, and for
each pair of corresponding elements, one of the above is true.

# CLUT-TO-TIMEPOINT (CLUT &OPTIONAL DAY-ONLY)

Compute the timepoint from the CLUT.

# CONVERT-TIME-SCALE (TIMEPOINT NEW-SCALE)

Convert time from one scale to another.

# COORDINATE-UNIT-VECTOR (I &OPTIONAL (LENGTH 3))

A coordinate unit vector.

# COPLANAR (VECT1-OR-MATRIX &OPTIONAL VECT2 VECT3)

The cosine of the angle between vect1 and the cross product of vect2 and vect3.
This should be near zero if the vectors are coplanar.

# COPY-STATE (ORIGINAL-STATE &REST ATTRIBUTES)

Make a new state with the same attributes as an existing state.
The attributes specified are computed if needed.

# DATIME+ (TP TIME)

Add the time to the timepoint. If time is a number,
it is assumed to represent seconds.

# DATIME- (DATIME1 B)

The difference of the datimes, or subtract a time from a datime.

# DATIME-J2000DAY (DATIME)

Julian Day from J2000 epoch, and seconds from the start of the day.

# DATIME-RELATION (RELATION ARGS)

Apply the relation to all the datime arguments and return
what it returns.

# DAYS+ (DATIME &OPTIONAL (INCREMENT 1))

Add the number of days to the given datime.

# DAYS- (DATIME1 DATIME2)

Integer number of days separating the days. Differs from datime-
in that the time of day doesn't matter, just the day on which the two
datimes occur.

# DEFINE-UNIT (UNIT DEFINITION &OPTIONAL SYNONYMS PRINT-NAME DIMENSION)

Define the unit. If the definition is a number then the dimension
information will be extracted from dimension.

# DEFINE-UNITS (DIMENSION UNIT-DEF-SYN-PNM)

Define the units given. The second argument is a list of lists, each
consisting of a unit name, its definition, and a list of synonyms.

# DISTANCE (A B &OPTIONAL (COMBINATION-FUNCTION '-))

The length of the vector and the vector difference a-b.

# DMS-ANGLE (DEGREES-OR-HOURS MINUTES SECONDS &OPTIONAL HOURS)

Read the angle as degrees (or hours), minutes and seconds.
With hours=T computes the hour angle, where a minute is 1/60 of
15 degrees instead of 1/60 of 1 degree. This option is the inverse of
angle-as-time.

# DTSPEC-FROM-JULIAN-DAY-NUMBER (JULIAN-DAY-NUMBER &OPTIONAL MODIFIED)

Find the dtspec for the given (modified) Julian day.
Algorithm given in
http://www.pauahtun.org/CalendarFAQ/cal/node3.html#SECTION003151000000000000000.

# EULER-ANGLE-ROTATION (ROT3A ROT1 ROT3B &OPTIONAL PASSIVE)

Compute the matrix for a 3-1-3 rotation. See Curtis (9.118).

# FIRST-3VECTOR (VEC)

Extract the first 3-vector.

# FORMAT-ATTRIBUTE-NAME (NAME &OPTIONAL (SEPARATE-COMPONENTS T) INCLUDE-UNITS (INCLUDE-NAME T))

Format the attribute name, and possibly the units.

# FORMAT-MATLAB-LIST (LIST &OPTIONAL (STREAM *STANDARD-OUTPUT*) (NUMBER-PER-LINE 3))

Format a matrix row to be read by Matlab.

# FROM-JD (JD &OPTIONAL MODIFIED (SCALE UTC))

Find the timepoint from the Julian date.
Assumes a fixed number of seconds per day (86400).

# FROM-YYDDD (YY-OR-YYDDD &KEY DDD (SCALE UTC) (HOURS 0) (MINUTES 0) (SECONDS 0))

Read datime from yyddd.ddddd or yy, ddd.ddddd format.

# ISO8601-PARSE-TIME-INTERVAL (STRING)

Parse the time interval in
ISO8601:2000(E) Section 5.5.4.2.1 format,
Representation of time-interval by duration only.

# ISO8601-TIME-INTERVAL (TIME &OPTIONAL (FORMAT TUD) (FRACTIONAL-SECONDS-DIGITS *ISO8601-FRACTIONAL-SECONDS-DIGITS*) REQUIRED-COMPONENT)

Represent the time interval in
ISO8601:2000(E) Section 5.5.4.2.1 format,
Representation of time-interval by duration only.

# JD-TABLE (START-YEAR END-YEAR &OPTIONAL (FORMAT ORG))

Write out a JD table in TeX, e.g. for class.
If d is the day of the month, add d+0.5 to the table
to get the J2000 day number for that day.
If csv is T, use csv for import into spread sheet.
IF nil, use TeX.

# JULIAN-DAY-NUMBER (DTSPEC &OPTIONAL MODIFIED FRACTIONAL-DAY)

Julian day number at noon of the day, or modified Julian day at
the start of the day, independent of timescale.
Algorithm given in
http://www.pauahtun.org/CalendarFAQ/cal/node3.html#SECTION003151000000000000000.

# LONG-PRINT-NAME (UNIT)

How the unit or attribute should be printed on the screen.

# MAKE-DTSPEC (&KEY TIMEPARSE (DAY-ONLY NIL) (TYPE 'DTSPEC))

Make the dtspec arguments.

# MAKE-NEW-PHYSICAL-STATE (&REST ATTRIBUTES-VALUES)

Make a new physical state with the given attribute values.

# MAKE-PARAMETER-WITH-ATTRIBUTE (CATEGORY NAME ATTRIBUTE &OPTIONAL TYPE DESCRIPTION DEFAULT)

Make a parameter that has an attribute.

# MAKE-PARAMETERS-FROM-TABLE (TABLE &KEY (HEADERP T) (CATEGORY (FIRST *PARAMETERS*)) (TYPE *DEFAULT-ELEMENT-TYPE*) (PREFIX PAR))

From the list of lists, define the parameters. The optional header should have column names. These column names include 'category 'name 'default 'value 'type 'description ('value and 'default mean the same thing). Any column names not specified will receive a default value. Any values in the cells that are empty will receive a default value. Any columns given with a header not on the list will be ignored. Category must already exist.

# MAKE-PHYSICAL-STATE (STATE ATTRIBUTES &REST ATTRIBUTES-VALUES)

From the given attributes and values, copy the requested attributes
from the existing state if they exist, then define new attribute values.

# MAKE-PQ (MAGNITUDE UNIT-EXPRESSION &OPTIONAL (SYSUNITS *SYSTEM-OF-UNITS*) (SCALAR-DIMENSION T))

Make a physical dimension quantity (PDQ). Allow for the
possiblity that magnitude is already a PDQ; in this case, check
that the physical dimension is correct, and pass it on. This can
be used as a way of assigning default units to a number. If
sysunits is specified, unitless dimensions (e.g., 'length) are
interpeted as units in that system. If scalar-dimension is T and
magnitude is not a scalar, the unit-expression applies to each
element of the magnitude. Otherwise it must be a grid or list of
the shape as the magnitude.

# MAKE-TIMEPOINT (&REST ARGS &KEY DTSPEC TIMEPARSE SCALE (DAY-ONLY NIL))

Make an object representing a point in time. Either dtspec
or timeparse should be specified, and scale should be specified.

# MAKE-TIMEPOINT-J2000SEC (J2000SEC &OPTIONAL DAY-ONLY)

Make a timepoint from J2000sec.

# MAKE-USER-PACKAGE (NAME)

Make a package in which it is convenient to use Antik and related systems.
If the package already exists, the use-packages and shadowing
symbols are updated.

# MAP-STATE (ORIGINAL-STATE ATTRIBUTES &OPTIONAL FUNCTION)

Make a new state by mapping a function of (value attribute-name)
on existing attributes. If function is NIL, use existing value.
A function, if specified, should return the new value. If attributes
is NIL, use all the defined attributes of the original state.

# MKSTR (&REST ARGS)

Make a string out of the printed representations of the arguments.

# NEW-UNITS (PQ &OPTIONAL (SYSUNITS-ADDITIONAL-UNITS (LIST *SYSTEM-OF-UNITS*)) (STREAM *STANDARD-OUTPUT*))

Format the physical dimension quantity in units different than the default.
Note that sysunits-additional-units must be a list.

# NF-READABLY

The format produced will be readable to Lisp.

# NF-STRING (OBJECT)

Format output for numerical objects to a new string.

# NORM-DENORM-ANGLE (ANGLE FUNCTION &OPTIONAL POSITIVE)

Normalize an angle, process it, and denormalize it back to the
original cycle count. This is useful for e.g. Kepler's equation,
where the normalized angle is needed to for the algorithm to
converge properly, but the full cycles are needed for f & g functions.

# OBJECT-AS-NF (OBJECT)

Define a new object exactly as the current nf options print an existing one. This function can be used for example to define a number exactly as the rounded print format of another one.

# ORG-TABLE (LIST-OF-LISTS &OPTIONAL (STREAM T))

Format the table.

# ORG-TABLE-LINE (LIST &OPTIONAL (STREAM T))

Format the list for a line of an org-mode table.

# PARAMETER-HELP (&OPTIONAL CATEGORY NAME (STREAM T))

Print all information known about the parameter. If category is nil (default), names of all categories are printed. If name is nil, all defined parameters in that category are printed.

# POLAR-TO-RECTANGULAR (AZIMUTH ELEVATION &OPTIONAL (RADIUS 1.0) (SIGN1 1))

Convert polar coordinates to rectangular coordinates.
Argument sign1 should be set to -1 for accomodating topocentric azimuth,
which is measured from North instead of South.

# PQWU (PQ)

If we are dynamically inside without-units, return the magnitude.
If not, return the object as-is.

# PRIME-FACTORS (N)

Find the prime factors of the integer n.

# PRINT-READABLY (OBJECT &OPTIONAL (STREAM T))

If the CL-defined specials are defined appropriately, print readably
and return T, otherwise, return NIL.

# READ-TIME (STRING)

Parse the datime or time interval string and create a timepoint object.

# READ-TIMEPOINT (STRING &OPTIONAL POS-YMDHMS (SCALE UTC))

Read a timepoint from a string with specification for the position in the string of each component; pos-ymdhms is a list of year, month, day, hour, minute, and second as sequence numbers for the integers in the string. Scale is the timescale (zone) as a string or symbol. If pos-ymdhms has only three components, or only a date is provided, the timepoint created will be specifed as day-only. The default reads an ISO8601 string like 1999-03-30T12:33:45.

# READ-TIMEPOINT-ISO8601 (STRING &OPTIONAL (SCALE UTC))

Read the timepoint specified as an ISO8601 string. In contrast
to #'read-timepoint, this accepts the various rearrangements
permitted by ISO8601 (see documentation for #'iso8601-parse,
but does not accept miscellaneous separator symbols.

# READ-US-DATE (STRING &OPTIONAL DAY-ONLY)

Read dates and times in customary US format MM/DD/YYYY; times may
be included as well if day-only is nil.

# RECTANGULAR-TO-POLAR (VECTOR &OPTIONAL (SIGN1 1))

Convert rectangular coordinates to polar coordinates.
Argument sign1 should be set to -1 for accomodating topocentric azimuth,
which is measured from North instead of South.
Returns a list of azimuth, elevation, and radius, and the
plane distance.

# REDIMENSION (MAGNITUDE UNIT-EXPRESSION)

Apply units that were stripped off a quantity.

# RELATIVE-TIME (BASE-TIME TIME &OPTIONAL ABSOLUTE)

Compute a time using base-time as a reference.
Either can be a timepoint or time pdq, and the result
can be chosen either way by specifying absolute T or NIL
respectively. The returned value is the time specified by
the second argument, but referenced to base-time.

# RIGHT-ANGLE (VECTOR)

Find an arbitrary right angle to the vector.

# ROTATE (ANGLE &OPTIONAL PASSIVE)

Create a rotation matrix in two dimensions.
Passive rotation if passive is true, otherwise active.

# ROTATE-3D (AXIS ANGLE &OPTIONAL PASSIVE)

Create a rotation matrix about the (0, 1, 2)
axis in three dimensions. Passive rotation
if passive is true, otherwise active.

# ROTATE-3DAA (ROTATION-AXIS ANGLE &OPTIONAL PASSIVE)

Rotation about an arbitrary axis in 3D.
See Goldstein, Poole, Safko (4.62) or
http://mathworld.wolfram.com/RotationFormula.html.

# SECOND-3VECTOR (VEC)

Extract the second 3-vector.

# SECONDS-PER-DAY (DATIME)

Compute the number of seconds in the given day.

# SET-DEFAULT-SYSUNITS (SYSUNITS &REST ADDITIONAL-UNITS)

Set the default system of units to the specified system,
possibly augmenting it with other units. additional-units
may be NIL to augment the current default system.

# SET-SHOWING (KEYWORD &OPTIONAL (STATUS ON))

Set the showing of intermediate values.

# SET-STATE-VALUE (VALUE ATTRIBUTE STATE-TABLE)

Set the value of a particular attribute for this state.

# SHORT-PRINT-NAME (UNIT)

How the unit or attribute should be printed on the screen.

# SINGLE (LST)

Test list for one element.

# SQRT (NUM)

The square root of the generalized or regular number.

# START-OF-DAY (DATIME &OPTIONAL (RELATIVE-DAY 0) (DAY-ONLY (DAY-ONLY DATIME)))

From the given datime, return the start of the given day,
relative-day = 0: this day, -1: day before, +1 next day, etc.

# STATE-FORMULA (ATTRIBUTE-CANONICAL STATE-TABLE &OPTIONAL APPLY-TO-VALUES (STATE-FUNCTION-GENERATOR *DEFAULT-SFG*))

Find the formula for the attribute given the known quantities in state.

# STREAM-TO-STRING (STREAM &KEY TERMINATOR TERMINATE-IF)

Fill a string with the contents of the stream. Stop when an EOF
is encountered, or when the terminating character :terminator,
which is discarded, is reached, or the function :terminate-if
is satisfied on the character, which is returned to the stream.
Only one of :terminator and :terminate-if should be specified.

# SYMB (&REST ARGS)

Make a symbol out of the printed representations of the arguments.

# TAIT-BRYAN-ANGLES (DCM)

Find the three angles psi, theta, phi of a 3-2-1 (Tait-Bryan)
rotation for the direction cosine matrix.

# TAIT-BRYAN-ROTATION (ROT1 ROT2 ROT3 &OPTIONAL PASSIVE)

Compute the matrix for a 3-2-1 (yaw-pitch-roll) rotation.
See Curtis (9.124). This transforms a vector in the body
frame into a vector in the external frame.

# TEX-PRINT-NAME (UNIT)

How the unit or attribute should be printed in TeX.

# TIME-AS-ANGLE (TIME-STRING)

Compute the angle from the time,
the major field is hours with 24 hours = 1 revolution.

# TIME-LIMITS (TIME1 TIME2 &OPTIONAL (REFERENCE NOW))

Make sense of time1 and time2 in absolute terms. If one is absolute,
and the other relative, it is presumed to be relative to the other.
If they are both relative, they are presumed to be relative to reference.

# TIMEPOINT-J2000SEC (TP)

Seconds from the J2000 epoch, 2000-01-01T12:00:00UTC.

# TO-YYDDD (DATIME)

Generate the twoline element form of datime. Note this
is not year-2000 compliant!

# VECTOR-ANGLE (A B)

The short angle between a and b, and the rotation vector.

# WRITE-DMS (ANGLE &OPTIONAL (STREAM T) (FIRST-SEP (FORMAT NIL ~a *DEGREE-SYMBOL*)) (SECOND-SEP ' ) (FINAL "))

Write the angle as degrees, minutes, seconds.

# WRITE-US-DATE (DATIME)

Write dates and times in customary US format MM/DD/YYYY.

# Undocumented

# < (&REST ARGS)

# <= (&REST ARGS)

# = (&REST ARGS)

# > (&REST ARGS)

# >= (&REST ARGS)

# DATIME< (&REST ARGS)

# DATIME<= (&REST ARGS)

# DATIME= (&REST ARGS)

# DATIME> (&REST ARGS)

# DATIME>= (&REST ARGS)

# GET-CANONICAL-NAME (SYMBOL)

# MAKE-PQ-ZERO (UNIT-EXPRESSION &OPTIONAL (SYSUNITS *SYSTEM-OF-UNITS*))

# MAKE-STATE-TABLE

# MAKE-TIMEPARSE-MAJORD (&OPTIONAL (YEAR 0) (MONTH 0) (DAY 0) (HOUR 0) (MINUTE 0) (SECOND 0))

# MAKE-TIMEPARSE-MINORD (&OPTIONAL (SECOND 0) (MINUTE 0) (HOUR 0) (DAY 0) (MONTH 0) (YEAR 0))

# MAX (&REST ARGS)

# MIN (&REST ARGS)

# PHYSICAL-QUANTITY-P (X)

# READABLY

# SETFSTATE-VALUE (VALUE ATTRIBUTE STATE-TABLE)

# TIMEPARSE-DAY (TIMEPARSE)

# SETFTIMEPARSE-DAY (VALUE TIMEPARSE)

# TIMEPARSE-HOUR (TIMEPARSE)

# TIMEPARSE-MINUTE (TIMEPARSE)

# TIMEPARSE-MONTH (TIMEPARSE)

# SETFTIMEPARSE-MONTH (VALUE TIMEPARSE)

# TIMEPARSE-SECOND (TIMEPARSE)

# TIMEPARSE-YEAR (TIMEPARSE)

# TRANSPOSE-LIST (LISTS)

# Private

# ADD-UNIFORM-TIME (DTSPEC TIME-INTERVAL)

Add the time-interval in seconds to dtspec.
Warning! assumes uniform time, with the same number of seconds per minute
(like TAI, not UTC).

# ALL-PARAMETERS (CATEGORY)

All the parameters for a category.

# APPLY-CONSTRAINTS (ATTRIBUTE VALUE)

Apply the appropriate constraints, if any.
This may constitute computing some mathemtical function of the
number and using the result, or signalling an error.

# AUGMENT-SYSUNITS (&REST SYSUNITS-ADDITIONAL-UNITS)

Augment the system of units with individual unit symbols.
The arguments are optionally one list representing a system of units,
and any number of symbols to override a unit in the system of units.

# CHECK-DIMENSION-OR-TYPE (OBJECT TYPE)

Return T if the object is of the type specified, and, if a physical-quantity, is of the physical-dimension specified in type.

# CHECK-PARAMETER (CATEGORY NAME VALUE &OPTIONAL ERROR)

Check that the value is appropriate for this parameter.
If the parameter is unknown, an error is signalled.

# CLUT-TO-TIMEPARSE (CLUT)

Convert clut, CL's unfortunately-named `universal-time', to timeparse.
No scale is provided; it is a uniform time.

# CONVERT-GPS-TO-UTC (GPS-DTSPEC)

Given any timepoint on the GPS scale, find the UTC time.

# CONVERT-TAI-TO-UTC (TAI-DTSPEC)

Given any TAI time, compute the corresponding UTC time.

# CONVERT-TWO-DIGIT-YEAR (YEAR &OPTIONAL (REFERENCE-YEAR (OR *DEFAULT-TWO-DIGIT-YEAR-REFERENCE-YEAR* (NTH-VALUE 5 (DECODE-UNIVERSAL-TIME (GET-UNIVERSAL-TIME))))))

Convert two-digit year to four digit by taking the year that
is closest to the reference year. Reference year defaults
to the current year.

# CONVERT-UTC-TO-GPS (UTC-DTSPEC)

Given any timepoint on the UTC scale, find the GPS time.

# CONVERT-UTC-TO-TAI (UTC-DTSPEC)

Given any UTC time, compute the corresponding TAI time.

# CONVERT-UTC-UT1 (TIMESPEC &OPTIONAL TO-UT1)

Convert UTC time scale to or from UT1 by adding/subtracting
the appropriate fractional second.

# DEF-DIMENSIONP (SYMBOL)

Define the predicate and type to check a particular dimension.

# DEFAULT-VALUE (CATEGORY NAME)

The default value of a parameter.

# DEFINE-BASIS-DIMENSIONS

Define the dimel for the dimensions in *basis-dimensions*.

# DEFINE-DERIVED-DIMENSIONS (NAME-DEF-PAIRS)

Define the dimel given in the name-def-pairs, where the definition
is in terms of any already-defined physical dimension.

# DIMEL-BASIS-P (DIMEL)

Return the index if this dimel is a basis dimension/unit.

# DIMEL-MAGNITUDE (DIMEL)

A metric on the dimel.

# DIMEL-OR-NOT (OBJECT)

Find the dimel for this object (a physical dimension quantity or a dimel), or
return the dimensionless dimel.

# DIMELP (DIMEL)

Argument is a scalar dimel.

# DIRECTION-COSINE (Q)

Compute the rotation (direction cosine) matrix (DCM) from the unit quaternion.

# DOY-YEAR (DATIME)

Return the doy and year for this datime.

# EQUAL-DIMENSION (X Y &OPTIONAL (ERRORP T) (ZEROS-HAVE-ANY-DIMENSION *ZERO-IS-DIMENSIONLESS*) MATCH-DIMENSIONLESS)

If the pdq are equal physical dimension, return that dimel.
If one quantity is zero and zeros-have-any-dimension, return the
dimel of the other and disregard whether they're the same physical
dimension. If y represents a dimensionless quantity,
and match-dimensionless is true, return the dimel of x.
Return two values: the dimel and whether it is scalar dimension.

# EQUAL-DIMENSIONS (LIST &OPTIONAL (ZERO-IS-DIMENSIONLESS *ZERO-IS-DIMENSIONLESS*))

If all elements of the list have the same physical dimension, return that dimel.

# EULER-QUATERNION (QUATERNION)

The Euler angle and axis for the quaternion.

# FIND-UNIT-EXPR (UNIT-EXPR &OPTIONAL (SYSUNITS *SYSTEM-OF-UNITS*))

Find the unit name or expression in its own system if applicable, or
in the given system. If there are physical dimensions in unit-expr,
all units are made in sysunits.

# FIND-UNITS (DIMEL SYSUNITS)

Find a minimal combination of named units in the designated system of units
that matches the dimel. Returns a list (unit-name exponent remainder-dimel).

# FLFL (INT1 INT2)

Flexible floor; if int2 is zero,
returns nil if int1 is nonzero or t if it is.

# FN-MAJOR-TIMEPARSE (TIMEPARSE FUNCTION)

Apply the function to the most major non-zero component of the timeparse.

# FORMAT-FLOAT (FLOAT &KEY (SIGNIFICANT-FIGURES *FORMAT-FLOAT-SIGNIFICANT-FIGURES*) INTPART-DIGITS FRACPART-DIGITS (INTPART-FILL ) (PRINT-SIGN *PRINT-SIGN*))

Format a floating point number with control over the digits that are printed.
If significant-figures is specified, the formating is as if by ~g, and the given
number of significant figures are formated if using plain float formatting,
one extra significant digit is formated if in scientific notation. If
intpart-digits/fracpart-digits are specified, formatting will always be
in plain format, with the number of digits to the left and right controlled
by these parameters.

# FORMAT-FLOAT-FIXED (FLOAT &OPTIONAL (INTPART-DIGITS 2) (FRACPART-DIGITS 3) (INTPART-FILL ) (PRINT-SIGN *PRINT-SIGN*))

Format a floating-point number with the specified number of digits in the
fractional (and optionally) integer parts, optionally filling the integer part.

# FORMAT-FLOAT-SWITCH (FLOAT &OPTIONAL (SIGNIFICANT-FIGURES *FORMAT-FLOAT-SIGNIFICANT-FIGURES*) (PRINT-SIGN *PRINT-SIGN*) (SPECIFIC-EXPONENT-MARKER T))

Format a floating point number for printing in a readable way. If specific-exponent-marker is T use the 'd', 'f' etc. to mark the exponent, instead of 'e'.

# FORMAT-UNITS (VALUE UNITS &OPTIONAL SCALAR-DIMENSION (STREAM *STANDARD-OUTPUT*))

Format the pieces of the physical dimension quantity. If formatting of
unit alone is desired, value should be nil.

# FORMATTING-TEST-GRID (FOREIGN-ARRAY MATRIX PQ)

Make a test grid for formatting.
foreign-array: nil= CL array, T=foreign array
matrix: nil = vector, T = matrix
pq: nil = numerical grid, :scalar = all the same units, :mixed = different units.

# FUNCALL-DYADIC (OP A B &OPTIONAL RETURN-OTHER RETURN-OTHER-MONADIC)

Call the math function on two arguments a and b, possibly
converting one argument from a number to a generic number like the
other. If return-other is a function designator, funcall
return-other-monadic on the other argument if one passes that
test.

# ISO8601-DATE-PARSE (DATESPEC &OPTIONAL CONVERT-TWO-DIGIT-YEAR)

Parse date specification in complete representation Section 5.2.1.1,
reduced precision Section 5.2.1.2, truncated representation 5.2.1.3,
or time-unit designator Section 5.5.4.2.1. Returns a list of numbers
(day month year). If a field is defaulted, it will return 0, even
though this may make no sense for month or day.

# ISO8601-PARSE (SPEC &OPTIONAL CONVERT-TWO-DIGIT-YEAR)

Parse combinations of date and time of the day, Section 5.4, and
attempt to make sense of either date or time as well. Returns
a list of 6 numbers (second minute hour day month year), and
a list of one of :date, :time, or both, indicating which was
specified.

# ISO8601-STRING (TIMEPARSE &OPTIONAL FORMAT (FRACTIONAL-SECONDS-DIGITS *ISO8601-FRACTIONAL-SECONDS-DIGITS*) REQUIRED-COMPONENT (T-SEPARATOR T))

If format is :TUD use the time-unit designator format; if nil,
use the extended format as described in 5.5.4.2.2. If
fractional-seconds-digits
is in an integer, always display that many digits in the
seconds fraction, even if zero. T-separator specifies the character
used for separating the date part from the time part; if T, it is #T,
if NIL, a space, if a character, that character.

# ISO8601-TIME-PARSE (TIMESPEC)

Parse time specification extended format (Time of day, Sec 5.3.1),
time-unit designator (Time intervals, Sec 5.5.4.2.1),
or alternative format (Time intervals, Sec 5.5.4.2.2). Returns
a list of numbers (second minute hour).

# LAST-LEAP-SECOND (DTSPEC TABLE)

Find the last leap second on whatever time scale table.

# LINEAR-TIMEPOINT (TIMEPOINT &OPTIONAL (REFERENCE-POINT *MIDNIGHT-2000*) (UNIT YEAR))

Compute the timepoint on a linear (number) scale.

# MAKE-DIMEL (&REST NAME-EXPONS)

Make a dimension exponent list (dimel) and SI conversion factor
from name-expons of the form unitname1 expon1 unitname2 expon2...
Symbols may be units or physical dimension names; the
SI conversion value will be nil if a physical dimension is used.

# MAKE-PQ-GRID (MAGNITUDE UNIT-EXPRESSIONS &OPTIONAL (SYSUNITS *SYSTEM-OF-UNITS*))

Make a physical dimension quantity out of a grid where the elements may have different units. This may modify the contents of the magnitude grid.

# MAKE-PQ-GRID-NEW (UNIT-EXPRESSIONS SAME-UNITS &KEY (INITIAL-ELEMENT NIL INITIAL-ELEMENT-P) (INITIAL-CONTENTS NIL INITIAL-CONTENTS-P) SPECIFICATION)

Construct a pdq grid given one of:
1) initial-contents of pdqs and specification
2) initial-contents of magnitudes, unit-expressions,
and optionally specification (else same as magnitudes')
3) initial-element being a pdq, and specification
4) specification and optionally same-units.

# MAKE-PQ-STRING (UNIT-SEXP &OPTIONAL STYLE)

Make a string in a customary form for unit expressions from the sexp.

# MAKE-PQ-UE (MAGNITUDE UNIT-EXPRESSION SYSUNITS)

Make the physical dimension quantity with a unit expression from a number or grid; if a grid, the same units apply to all elements.

# MAKE-RADIAN (X)

From the number x, return the representation of an angle in radians.

# MAKE-TIMEPOINT-NOCONVERT (&KEY DTSPEC TIMEPARSE SCALE (DAY-ONLY NIL DAY-ONLY-SPECIFIED))

Make an object representing a point in time. Either dtspec,
or timeparse should be specified, and scale should be specified.

# MAKE-UE (DIMEL SYSUNITS)

From the dimel (list of dimension exponents),
make an unit-exponent list.

# MAKE-UNIT-SEXP (DIMEL SYSUNITS SCALAR-DIMENSIONS)

From the dimel (list of dimension exponents),
make an unit sexp.

# MAP-LEAF (FUNCTION TREE)

Map onto the leaves (non-list) of the tree.

# MAP-PQ (FUNCTION OBJECT &OPTIONAL FLATTEN)

Map the function of a pdq onto the nested lists of pdqs, optionally flattening.

# MULTIARG-COMPARISON (OP ARGS)

Extend a comparison operator from two to any number of arguments.

# NF-GRID (OBJECT &OPTIONAL (STREAM *STANDARD-OUTPUT*))

Format the grid.

# NF-MATRIX (OBJECT &OPTIONAL (STREAM *STANDARD-OUTPUT*))

Format the two dimensional grid, or the one dimensional grid horizontally or vertically.

# NF-SYSUNITS

The system of units used in nf.

# NF-VECTOR (OBJECT &OPTIONAL (STREAM *STANDARD-OUTPUT*))

Format the one dimensional grid.

# OP-DIMENSION (DIMENSION0 DIMENSION1 &OPTIONAL (OPERATION '+))

Operate on the dimensions, either dimels or vectors of dimels.

# PARAMETER-ATTRIBUTE (INSTANCE)

@arg[extid]{A @class{extid}}
@return[sytemid]{puri:uri or nil}
Returns the System ID part of this External ID.

# PARAMETER-CATEGORY (INSTANCE)

@arg[extid]{A @class{extid}}
@return[sytemid]{puri:uri or nil}
Returns the System ID part of this External ID.

# PARAMETER-DEFAULT (INSTANCE)

@arg[extid]{A @class{extid}}
@return[sytemid]{puri:uri or nil}
Returns the System ID part of this External ID.

# PARAMETER-DESCRIPTION (INSTANCE)

# PARAMETER-NAME (INSTANCE)

# PARAMETER-TYPE (INSTANCE)

# PARENSTYLE (OUTER)

Parentheses should be used in this case.

# PARSE-PQ-STRING (STRING)

Parse a string or symbol specifying units into lists.

# PARSE-TIME-INTERVAL-TEST

Test cases for parser.

# PARSE-UNIT-SEXP (EXPRESSION)

Find dimel from a unit expression; the symbols in this expression may
be either unit names or dimension names. Return the dimel and
the conversion; if the expression contains a physical dimension (like 'time)
as opposed to a unit of measure (like 'second), then the conversion
is nil.

# PARSE-UNITS (UNIT-EXPRESSION &OPTIONAL (SYSUNITS *SYSTEM-OF-UNITS*))

Find the dimel representation of the dimensions from a
string, symbol, or unit sexp.

# QUATERNION* (Q1 Q2)

Quaternion multiplication.

# QUATERNION-EULER (ANGLE AXIS)

The quaternion corresponding to a given pair of Euler parameters.

# RATIONALIZE-UNITS (DIMEL)

Find a common denominator of the unit exponents and
return the integer dimel with the common denominator.

# READ-DTSPEC (STRING)

Read the ISO8601 specification and make a dtspec.

# READ-EOP-FILE

Read the earth orientation parameters from USNO.

# READ-PQ-FROM-STRING (STRING UNITS &OPTIONAL SYSUNITS)

Read the next number and interpret as a pdq, if units is non-nil.
The special 'pointer gives the starting location to read
and is updated after the read.

# RELATIVE-DATIME (DTSPEC1 DTSPEC2 &OPTIONAL DAY-ONLY)

Find the largest time unit where the two dtspecs differ, and
return the difference of that unit and the unit name.
If the dtspecs are the same, return 0 :second.

# SHOW-DATIME-FIELD (FORMAT &REST ARGS)

The first of args is to be shown if it is not zero (:tud format) or
args are not all zeros (nil format).

# SYSUNITSP (THING)

This is possibly a system of units.

# TEST-GRID-FORMATTING (GRID)

Format the 1D grid with all different combinations.

# TIMEPARSE-TO-CLUT (TIMEPARSE)

Convert timeparse to clut, CL's unfortunately-named `universal-time'.
No scale is provided; it is a uniform time.

# TIMEPOINT-RELATION (RELATION X Y)

Do the two timepoints obey the relation?

# UNIT-REMOVE-ILLEGAL-CHARS (UNIT)

Remove the characters that are illegal in unit and dimension
names because they are used in unit math.

# UTC-TO-TAI-LEAP-SECOND-TABLE-CONVERSION (UTC-TABLE)

Generate a tai leap second table from the utc leap second table.

# VECFLOOR (VEC1 VEC2)

Find the lowest flexible floor of the two vectors of integers, and the
remainder vec1-gcd*vec2.

# VECTOR-COMPONENT-NAMES (I)

The name of the ith vector component.

# Undocumented

# ACCELERATIONP (X)

# ANGLEP (X)

# ANGULAR-MOMENTUMP (X)

# ANTIK-SYMBOL (SYMBOL)

# AREAP (X)

# CAPACITANCEP (X)

# CHARGEP (X)

# CHECK-PARAMETER-TYPE (VALUE TYPE ERROR CATEGORY NAME)

# CHECK-UNAME (NEW NAME)

# CHECK-UNAMES (NEW NAMES)

# CONDUCTANCEP (X)

# COPY-PARAMETER (INSTANCE)

# CURRENTP (X)

# DEFINE-PARAMETER-INT (CATEGORY NAME DEFAULT TYPE DESCRIPTION)

# DENSITYP (X)

# DOSEP (X)

# ELECTRIC-POTENTIALP (X)

# ENERGYP (X)

# FIND-PARAMETER (CATEGORY NAME)

# FORCEP (X)

# FORMAT-LIST (LIST STREAM)

# FREQUENCYP (X)

# INDUCTANCEP (X)

# LENGTHP (X)

# LUMINOSITYP (X)

# MAGNETIC-FIELDP (X)

# MAGNETIC-FLUXP (X)

# MAKE-NEW-DIMEL (&OPTIONAL (INITIAL-ELEMENT 0))

# MAKE-PAR-INT (CATEGORY NAME DEFAULT TYPE DESCRIPTION)

# MAKE-PQ-OBJECT (MAG DIMEL SCALAR-DIMENSION)

# MASSP (X)

# MOMENTUMP (X)

# MONEYP (X)

# NAN-WARNING

# SETFPARAMETER-ATTRIBUTE (NEW-VALUE INSTANCE)

# SETFPARAMETER-CATEGORY (NEW-VALUE INSTANCE)

# SETFPARAMETER-DEFAULT (NEW-VALUE INSTANCE)

# SETFPARAMETER-DESCRIPTION (NEW-VALUE INSTANCE)

# SETFPARAMETER-NAME (NEW-VALUE INSTANCE)

# PARAMETER-P (OBJECT)

# SETFPARAMETER-TYPE (NEW-VALUE INSTANCE)

# POWERP (X)

# PQ-GRIDP (OBJECT)

# PQVAL-NF (PQ)

# PQVAL-SEQ (PQ &REST SYSUNITS-ADDITIONAL-UNITS)

# PRESSUREP (X)

# READ-TIMESCALE (STRING)

# RESISTANCEP (X)

# SCALAR-UNITS-P (UNITS)

# SET-ATTRIBUTE (STRUCT ATTRIBUTE &OPTIONAL DESCRIPTION)

# SPECIAL-SYMBOL-LOOKUP (CATEGORY)

# SUBSTANCEP (X)

# SYSUNITS-DIMEL (X)

# SYSUNITS-METRIC (DIMEL-INDEX-ITEM)

# SYSUNITS-UNITNAME (X)

# TEMPERATUREP (X)

# TIMEP (X)

# TIMEPARSE-PART (TIMEPARSE PART)

# VELOCITYP (X)

# VOLUMEP (X)

# MACRO

# Public

# ARITHMETIC-ERRORS-RETURN-NAN (&BODY BODY)

Return a NaN for a variety of arithmetic errors.

# COMPONENTS (NAME)

Components of vector.

# CONSTRAINTS (NAME)

Constraint on acceptable values.

# CREATION-FORM-READABLY (OBJECT NON-READABLY)

If we are printing readably, then rely on printed form
to create the new object.

# DEF-DYADIC-SCALAR (METHOD &OPTIONAL (OPERATION METHOD) (LEFT T) (RIGHT T))

Define a method of the operation that operates elementwise on a grid.

# DEF-MAKE-LOAD-FORM (OBJECT-TYPE)

Defmethod the make-load-form assuming creation-form exists.

# DEF-MONADIC (OPERATION)

Define a method of the operation that operates elementwise on a grid.

# DEFATTRIBUTE (NAME DIMENSION &OPTIONAL SYNONYMS PRINT-NAMES DESCRIPTION COMPONENTS CONSTRAINTS (MAKE-FUNCTION T))

Define an attribute of a physical system. The name should
not be the same as a physical dimension or unit name.

# DEFINE-PARAMETER (CATEGORY NAME DEFAULT TYPE DESCRIPTION)

Define the parameter name in category.

# DEFINE-PARAMETER-CATEGORY (NAME)

Define a new category for parameters.

# DEFINE-PHYSICAL-CONSTANT (NAME VALUE &OPTIONAL SYNONYMS PRINT-NAME DOCSTRING)

Define the variable to be the physical dimension quantity given, and also make it a unit of measure.

# DEFINE-SYSUNITS (SYSTEM-NAME UNITS &OPTIONAL BASE-SYSUNITS DOCSTRING)

Make a system of units with the given name and units, optionally
agumenting the existing system of units base-sysunits.

# DIMENSION (UNIT-OR-DIMENSION)

The dimension as a dimel (list of exponents)
from a unit name or dimension name.

# DIMENSIONLESS-CALL (FUNCTION ANSWER-DIMENSION &REST ARGUMENTS)

Call a function that is incapable of handling physical dimension quantities. This macro will consistently remove the units from all arguments, then create the answer with the specified units.

# EXPORT-VALUE (FORM &OPTIONAL (NF-OPTIONS *CODE-BLOCK-EVAL-NF-OPTIONS*))

The form value formatted for tex. Useful in embedded org-mode code block evaluation as e.g.
src_lisp[:results raw]{(export-value xyz)}.

# HANDLING-COMPLEX-NUMBER (RESTART &BODY BODY)

A handler to make the complex number.

# NF-OPTION (NAME)

Get/set the nf option named.

# PARAMETER-VALUE (CATEGORY NAME &OPTIONAL (DEFAULT (DEFAULT-VALUE CATEGORY NAME)))

Get or set the parameter value.

# PARAMETER-VALUE* (CATEGORY NAME &OPTIONAL DEFAULT)

Get the parameter value dynamically.

# PARAMETERS-SET (CATEGORY)

A list of parameters that are set.

# PRINT-NAME (UNIT)

How a unit is printed.

# PYTHAGOREAN-COMPLEMENT (X)

sqrt(1-x^2)

# PYTHAGOREAN-SUM (&REST ARGS)

Sum the squares of the arguments.

# RESET-PARAMETERS (CATEGORY &REST NAMES)

Reset the parameter(s) to the default value; if none are specified,
all in the category are reset.

# SEE-INTERMEDIATE-VALUE (KEYWORD LABEL FORM)

If keyword is in *pedagogical*, then print returned value of form,
and return it; otherwise, just evaluate the form and return.

# SEE-VALUES (KEYWORD SKIPPING-COMPUTE FORMAT-STRING &REST ARGS)

If keyword is in *pedagogical*, then print returned value of form,
and return it; otherwise, just evaluate the form and return.
If skipping-compute is true, forms are evaluated left to right,
whether or not the keyword is in *pedagogical*.
If it is false, they are only evaluated if keyword is in *pedagogical*,
and the last one is returned from this form.

# SERIALIZE-BINDING (SYMBOL)

Generate a form that when loaded will redefine the object
and bind the variable to it.

# SET-NF-OPTIONS (&REST NAME-VALUES)

Set the numerical formatting options.

# SET-PARAMETER-VALUE (CATEGORY NAME VALUE)

Set the parameter value, checking that the name is legitimate and
the value is of the correct type.

# SET-PARAMETERS (CATEGORY &REST NAMES-VALUES)

Set the values of the parameters.

# SETSYS (SYMBOL SYSUNITS &REST ADDITIONAL-UNITS)

Set the symbol macro symbol to make the system of units sysunits default.
additional-units may be useform{NIL} to augment the current default system.

# VAL (CATEGORY VARIABLE &OPTIONAL (NF-OPTIONS *CODE-BLOCK-EVAL-NF-OPTIONS*))

The parameter value formatted for tex. Useful in embedded org-mode code block evaluation as e.g.
src_lisp[:results raw]{(val P1020 B)}.

# WITH-NF-OPTIONS ((&REST NAME-VALUES) &BODY BODY)

Set the options for all nf calls within body to inherit.

# WITH-PARAMETERS ((CATEGORY &REST NAME-VALUES) &BODY BODY)

Provide local scope for parameter values, and possibly
bind new values.

# WITH-PQ (PHYSICAL-QUANTITIES &BODY BODY)

Ensure that the named physical dimension quantities are of the right dimensions, or convert them from plain numbers using the current system of units as specified by *system-of-units*.

# WITH-UNITS (&BODY BODY)

Compute everything within the dynamic scope with physical units,
when there is an outer dynamic scope with without-units.
Remove units from returned value of body.

# WITHOUT-UNITS ((&OPTIONAL (SYSTEM-OF-UNITS '*SYSTEM-OF-UNITS*)) &BODY BODY)

Compute everything within the dynamic scope without physical units.
Physical dimension quantities should be wrapped with #'pqwu.

# Undocumented

# DECF (REF &OPTIONAL (DELTA 1))

# INCF (REF &OPTIONAL (DELTA 1))

# LENGTH (&REST ARGS)

# PEDAGOGICAL (KEYWORD &BODY BODY)

# TIME (&REST ARGS)

# Private

# ANGLE-FIND (&KEY SINE-ANGLE COSINE-ANGLE SIGN-SINE-ANGLE SIGN-COSINE-ANGLE ANGLE-CLONE)

Find the angle, with accurate quadrant, from just about anything.
Returns a value between -pi and pi.
sine-angle: The sine of the angle
cosine-angle: The cosine of the angle
sign-sine-angle: If sine-angle is not supplied, the sign of sine
will be assumed to be the sign of this number.
sign-cosine-angle: If cosine-angle is not supplied, the sign of cosine
will be assumed to be the sign of this number.
angle-clone: If the sine-angle or the cosine-angle is not supplied,
its sign will be the same as the sign of that function applied
to this angle.

# CANONICAL-NAME (UNIT-OR-SYN)

The full unit name from a synonym.

# CL-READABLE-NF (&BODY BODY)

For use in #'print-object methods that rely on nf methods for
printing: they should print readably if cl:*print-escape* or
cl:*print-readably* say to.

# DESCRIPTION (NAME)

Description of the attribute.

# PARAMETER-ACCESS ((CATEGORY PARAMETER-SYMBOL) &BODY BODY)

Give access to the parameter special, for use in other parameter macros.

# SET-PARAMETER-VALUE* (CATEGORY NAME VALUE)

Set the parameter value without checking.

# SICONVERSION (UNIT)

Ratio of the given unit to the SI unit of the same dimension.

# SYNONYMS (UNIT)

The synonyms of the unit.

# TEX-FORM (NAME)

How to print in TeX.

# UNDIMENSIONED-SHOULD-NOT-BE-HERE (&REST ARGS)

A debugging macro to help trap quantities that did not
properly have a #'pqwu wrapping them.

# UNIT-PROPERTY (UNIT PROPERTY)

Find or set the particular property of the unit or dimension.
Package of unit does not matter.

# UNIT-SYMBOL-MACRO (UNIT &OPTIONAL (MULTIPLIER 1) PREFIX)

Define a symbol macro to expand to the given unit.

# Undocumented

# CHECK-DIMEL (DIMEL)

# GRID-CALL-NEXT-METHOD (&REST ARGS)

# PRINCN (OBJECT STREAM)

# WITH-CONVERTED-NUMBERS ((LIKE &REST SYMBOLS) &BODY BODY)

# GENERIC-FUNCTION

# Public

# ABS (NUM)

The absolute value.

# ACOS (ARG)

The arccosine of the generalized or regular number.

# ASIN (ARG)

The arcsine of the generalized or regular number.

# ATAN (NUM &OPTIONAL DEN DEFAULT ZERO-ENOUGH)

The arctangent of the generalized or regular number. If absolute value of the arguments are below zero-enough, default is returned.

# COERCE (NUMBER LIKE)

Make number into an object similar to like, or
if like is a number type, into that type.

# COS (NUM)

The cosine of the generalized or regular number.

# COSH (NUM)

The hyperbolic cosine of the generalized or regular number.

# CREATION-FORM (OBJECT)

A form that creates the object.

# DEFINED-ATTRIBUTES (STATE)

List the attributes defined for this state.

# EXP (NUM)

The natural exponent e^num of the generalized or regular number.

# EXPT (NUM EXPONENT)

Raise the number to the exponent.

# FLATTEN-ANGLE (OBJECT)

Remove the angular dimension; the number is not changed
and therefore the angles are radians. This function is
necessary as proper dimensional arithmetic ignores angles as a
dimension.

# FLOOR (NUMBER &OPTIONAL DIVISOR)

Greatest multiple of divisor less than number.

# LOG (NUM &OPTIONAL BASE)

The natural logarithm of the generalized or regular number.

# MINUSP (A)

Negative

# NF (OBJECT &OPTIONAL STREAM)

Format output for numerical objects. If stream is nil, use *standard-output*.

# NORMALIZE-ANGLE (ANGLE &OPTIONAL POSITIVE)

Normalizes the angle to (in radians) -pi to pi
or 0 to 2pi (positive = t).
Two values are returned: the normalized angle, and the number
of full revolutions that should be added to the normalized angle
to recreate the original angle.

# PLUSP (A)

Positive.

# PQVAL (PQ &REST SYSUNITS-ADDITIONAL-UNITS)

Get the numerical value and the units of the physical dimension quantity. Returns the magnitude, the units, and whether units are the same for each element of a sequence or grid.

# ROUND (NUMBER &OPTIONAL DIVISOR)

Nearest multiple of divisor to number.

# SHOW-STATE (STATE)

Show the physical state attributes.

# SIGNUM (A)

Signum(a).

# SIN (NUM)

The sine of the generalized or regular number.

# SINH (NUM)

The hyperbolic sine of the generalized or regular number.

# STATE-VALUE (ATTRIBUTE STATE &OPTIONAL STATE-FUNCTION-GENERATOR)

Get the value of the attribute from the state table.
If it is not present, compute it if possible with state-function-generator.
If state-function-generator is nil, do not compute.

# TAN (NUM)

The tangent of the generalized or regular number.

# TANH (NUM)

The hyperbolic tangent of the generalized or regular number.

# ZEROP (A)

Zero.

# Private

# *I (A B)

Multiplication of generalized or regular numbers.

# +I (A B)

Addition of generalized or regular numbers.

# -I (A B)

Subtraction/negation of generalized or regular numbers, internal.
Users call -.

# /I (A B)

Division of generalized or regular numbers, internal.
Users call /.

# <=I (A B)

Less than or equal.

# <I (A B)

Less than.

# =I (A B)

Numeric equal

# >=I (A B)

Greater than or equal.

# >I (A B)

Greater than

# NUMBCOMP (X)

Function for number comparison. If this function is
defined for a generalized number and returns an object for which all
comparison functions such as <, >, etc. are defined,
then all comparison functions will automatically be defined
for that object.

# Undocumented

# COERCE-OBJECT (CONDITION)

# COERCE-TO (CONDITION)

# GCONSTANT (NAME LIKE)

# MCN-NUMBER (CONDITION)

# MCN-OPERATION (CONDITION)

# SLOT-ACCESSOR

# Public

# Undocumented

# DAY-ONLY (OBJECT)

# ISO8601 (OBJECT)

# TIMEPARSE (OBJECT)

# Private

# PQ-DIMENSION (OBJECT)

The Dimel for the physical dimension quantity.

# PQ-MAGNITUDE (OBJECT)

The Numerical magnitude of a physical dimension quantity.

# SCALAR-DIMENSION (OBJECT)

The Physical dimensions for object are a scalar.

# Undocumented

# SCALE (OBJECT)

# VARIABLE

# Public

# *CGSU*

The CGS system of units.

# *CODE-BLOCK-EVAL-NF-OPTIONS*

NF options for LaTeX output generated from parameters.

# *DATIME-READABLE*

Whether to print datimes readably.

# *DEFAULT-SFG*

The default state function generator.

# *ENGLISHU*

The English system of units.

# *FORMAT-FLOAT-SIGNIFICANT-FIGURES*

The default number of significant figures in
floating point number output.

# *REAL-UT1-UTC*

If NIL, UT1 will be taken the same as UTC.

# *RETURN-FORMULA*

Show the formula used in computing the attribute.

# *SIU*

Systeme internationale system of units.

# *SYSTEM-OF-UNITS*

Default system of units used by pqval.

# *TIMEPOINT-PRINT-SCALE*

Convert timepoints to this timescale for printing.
If nil, use the internal time scale (UTC).

# *TIMEPOINT-PRINT-SCALE-NAME*

When T, print the scale (UTC, TAI, etc.) with a timepoint.

# *TIMESCALES*

All known time scales.

# *USE-READABLE-PRINT-FORM*

Use the readable print form in creation-form if available.

# *ZERO-IS-DIMENSIONLESS*

Numbers with zero magnitude are made dimensionless.

# Undocumented

# *PREHISTORIC*

# Private

# *ALL-ATTRIBUTES*

All defined attributes.

# *ALL-FORMATTING-TEST-GRIDS*

A set of grids for testing formatting, covering all combinations of
arrays and foreign-arrays, vectors and matrices, and no units, same
units, and mixed (different) units.

# *ANTIK-USER-SHADOW-SYMBOLS*

Symbols to be shadowed by default in antik-user packages.

# *ANTIK-USER-USE-PACKAGES*

Packages to be used by default in antik-user packages.

# *BASIS-DIMENSIONS*

The basis dimensions, in order.

# *CHECK-ANGLE-LIMITS*

Whether to check that the angle pieces are within the normal
range of numbers, e.g., number of seconds is < 60.

# *CLUT-J2000-TAI*

J2000 epoch in CL's `universal-time' time linearization, in the TAI scale.

# *DEFAULT-TWO-DIGIT-YEAR-REFERENCE-YEAR*

If NIL, use the current year as the reference year for deciding in which century
a two-digit year belongs. Otherwise, use the specified year.

# *DEGREE-SYMBOL*

The degree symbol.

# *GPS-REFERENCE-TIME*

Timepoint at which GPS time agreed with UTC;
see Kaplan, Understanding GPS, Section 2.7.2.

# *GPS-TAI*

Time interval in seconds between GPS time and TAI time.
Add this amount to the GPS time to get TAI.

# *ISO8601-FRACTIONAL-SECONDS-DIGITS*

Default number of digits to print for fractional part of seconds.

# *PEDAGOGICAL*

A list of categories of intermediate values
that should be printed during calculation.

# *PEDAGOGICAL-STREAM*

Stream to output information.

# *PQVAL-ALLSAME-SEQUENCE-COLLAPSE*

If a sequence passed to pqval has all the same units,
collapse to one unit specification.

# *PRINT-SIGN*

Always print the sign, even if +.

# *REMOVE-UNITS-SYSUNITS*

System of units with which physical dimension quantities will be converted to plain numbers.

# *TAI-LEAP-SECOND-TABLE*

Table of TAI leap second insertion times, with the UTC-TAI offset.

# *TIMEZONE-OFFSETS*

Timezones that may be used to input timepoints.

# *UNIT-INFORMATION*

Properties of each unit of measure and physical dimension.

# *UNIT-SYMBOL-MACROS*

Unit symbols that were defined with unit-symbol-macro.

# *UT1-UTC-FIRST-ESTIMATED*

First estimated UT1-UTC value in *ut1-utc-table*.
This serves as a marker for the age of the eop.dat file.

# *UT1-UTC-TABLE*

Hash table of differences UT1-UTC by J2000 day number.
Use (read-op-file) to load.

# *UTC-LEAP-SECOND-TABLE*

Table of UTC leap second insertion times, with the UTC-TAI offset.
See http://www.boulder.nist.gov/timefreq/pubs/bulletin/leapsecond.htm.

# Undocumented

# *ALL-TIME-UNITS*

# *J2000-EPOCH*

# *MIDNIGHT-2000*

# *MONTH-NAMES*

# *MONTH-NAMES-FULL*

# *PARAMETER-CHECK-FUNCTION*

# *PARAMETERS*

# *RADIAN*

# *TYPE-EQUALITY*

# /NF-PARAMETERS/

# CLASS

# Public

# DTSPEC

Specification of date and time, without an assigned scale.

# PHYSICAL-QUANTITY

A quantity with a dimension and possibly a unit,
e.g. length or meter.

# TIMEPOINT

Specification of a point in time, including a scale.

# Private

# Undocumented

# PARAMETER

# CONDITION

# Public

# COERCE-NIL

Signalled when gcoercing something to nil.

# COERCE-UNDEFINED

Signalled when making a generalized number in which a higher type
(like taylor-number) is a component of a lower type (like physical-quantity).

# MAKING-COMPLEX-NUMBER

Signalled when a mathematical calculation would result in a complex number.