Draft version January 10, 2025

Typeset using LATEX twocolumn style in AASTeX631

Not-Quite-Transcendental Functions For Logarithmic Interpolation of Tabulated Data

Peter C. Hammond ,1, 2, 3 Jacob M. Fields ,1, 2 Jonah M. Miller ,4, 5 and Brandon L. Barker 4, 5

1 Department of Physics, The Pennsylvania State University, University Park, PA 16802, USA
2 Institute for Gravitation and the Cosmos, The Pennsylvania State University, University Park, PA 16802, USA
3 Department of Physics and Astronomy, University of New Hampshire, Durham, NH 03824, USA
arXiv:2501.05410v1 [physics.comp-ph] 9 Jan 2025

4 Center for Theoretical Astrophysics, Los Alamos National Laboratory, Los Alamos, NM 87545, USA
5 Computational Physics and Methods, Los Alamos National Laboratory, Los Alamos, NM 87545, USA

ABSTRACT
From tabulated nuclear and degenerate equations of state to photon and neutrino opacities, to nuclear
reaction rates: tabulated data is ubiquitous in computational astrophysics. The dynamic range that
must be covered by these tables typically spans many orders of magnitude. Here we present a novel
strategy for accurately and performantly interpolating tabulated data that spans these large dynamic
ranges. We demonstrate the efficacy of this strategy in tabulated lookups for nuclear and terrestrial
equations of state. We show that this strategy is a faster drop-in replacement for linear interpolation
of logarithmic grids.

1. INTRODUCTION is often invoked. Interpolation may then be performed

Complex and computationally difficult microphysical on the transformed variables x′ and y ′ , rather than x
data is often tabulated for efficient lookup. Common and y via usual techniques such as linear or higher-order
examples include finite temperature nuclear equations Lagrange interpolation.
of state, such as those used in neutron star merger Logarithms are transcendental functions (Townsend
and core-collapse supernova modeling (O’Connor & Ott 1915), meaning they cannot be computed with a finite
2010), terrestrial equations of state suitable for moon or set of simple algebraic operations such as addition and
planet formation or planetary defense modeling (Lyon multiplication. Rather they must be approximated up
& Johnson 1992), tabulated photon (Rogers & Iglesias to machine precision via a series expansion (Cody &
1992; Iglesias & Rogers 1996; Zhu et al. 2021; Mills Waite 1980). The logarithmic transformations (1) and
et al. 2024) and neutrino opacities (Burrows et al. 2006; (2) are therefore computationally expensive and can be
O’Connor 2015; Skinner et al. 2019) for use in radiation a bottleneck in simulations.
transport, and tabulated nuclear reaction rates (Cyburt The transformation invoked need not be exactly log-
et al. 2010) for use in reaction networks. arithmic, however. The important traits of the trans-
A common thread in these disparate problems is the formation are that (a) it has approximately logarithmic
need to span many orders of magnitude. For exam- spacing, that is
ple, a finite temperature nuclear equation of state in ∂x′
the Stellar Collapse1 database typically spans densities x ≈k (3)
∂x
between 104 and 1012 g/cm3 and temperatures between
10−2 and 102 MeV. For this reason, logarithmic interpo- for some constant k and that (b) it is exactly invertible.
lation, where the independent and dependent variables Exact invertibility is required to effectively transform
undergo a transformation of the form in and out of the space when performing interpolation.
Relation (3) is required so that the a uniform spacing in
x′ = log10 x (1)
x′ captures the range of scales in x.
′
y = log10 y (2) Miller et al. (2022) recognized that a transformation
need not be logarithmic and introduced a family of
Corresponding author: Jonah M. Miller
exactly invertible functions that they called not-quite-
[email protected] transcendental (NQT). These functions leverage the un-
derlying structure of floating point numbers to construct
1 https://stellarcollapse.org/microphysics.html highly performant almost-logarithmic functions. Miller
2

Figure 1: Linear interpolation of a synthetic function P = 1 + ρ + K1 ρΓ1 + K2 ρΓ2 on a true log grid (left), first-order
NQT grid (center), and second-order NQT grid (right). The x-axis is ρ and the y-axis is the relative error in P . On
average (in the L1 sense), all interpolants converge at second order, but error spikes near the control points of the NQT
gridding converge more slowly. The result is that first-order NQT converges at second order in the L1 norm but slower
in the Lp norm for p > 1. In second-order NQT the spikes also converge at second-order, recovering second-order
convergence in higher p Lp norms. In all three figures, a dashed horizontal line shows the expected magnitude for
second-order convergence.

et al. (2022) argued that these functions were drop-in demonstrate the efficacy of NQTo2 methods in a suite
replacements for normal logarithms in a wide variety of of test problems. Finally in Section 5 we conclude our
contexts, with no loss in accuracy. discussion. Appendix A discusses how to implement per-
Unfortunately, the original NQT functions are exactly formant versions of the NQT method, which requires un-
invertible, but they do introduce additional error in all derstanding the bit-level representation of floating point
p−norms for p > 1. For reasons that will be discussed numbers.
below, we dub these original functions first-order NQT
functions, or NQTo1. Here we introduce a new family of 2. FIRST-ORDER
NQT functions, which we dub second-order NQT func- NOT-QUITE-TRANSCENDENTAL FUNCTIONS
tions, or NQTo2. We show that second-order NQT func- A positive floating point number n can be represented
tions provide significant improvement in accuracy over as
their first-order counterparts at acceptable increase in n = m × 2p , (4)
cost. We also demonstrate with several numerical exper-
where m ∈ [1/2, 1) is the mantissa and the integer p is
iments that they are excellent drop-in replacements for
the exponent. Most programming languages and hard-
logarithms for second-order logarithmic interpolation of
ware vendors provide the ability to pull apart n into its
tabulated data. That is, if a code is currently performing
components, m and p. This implies that
linear interpolation on logarithmically spaced data, the
NQTo2 method presented here will provide a speedup at lg(n) = lg(m) + p (5)
essentially no cost in accuracy. However, higher-order
interpolation, such as the biquintic interpolation used which reduces the standard problem of computing a
in the Helmholtz equation of state (Timmes & Swesty logarithm to computing lg(m) on the interval [1/2, 1).
2000), will not benefit. Change of basis formulae can then move from lg to what-
This paper is organized as follows. In Section 2, we ever logarithmic basis is appropriate.
review first-order NQT functions and describe why the Miller et al. (2022) define
original claim of Miller et al. (2022) that they imply zero
loss in accuracy was incorrect. In Section 3, we intro- lgo1 (n) = 2(m − 1) + p, (6)
duce second-order NQT functions and discuss why they which is the piecewise linear interpolant of lg(x) with
cure the issues of the first-order version. In Section 4 we control points at powers of 2 (Hall et al. 1970). As
 3

portable aliased
4 1st order lg(x)
time(STL)/time(NQT)

NQT faster 2x
3 NQT slower

2
1
0

4 2nd order
time(STL)/time(NQT)

3 ARM ARM
2
1
0
skylake

skylake
skylake_intel

skylake_intel
rome

rome
spr

grace

spr

grace
spr_intel

M2

spr_intel

M2
V100
A100
H100

V100
A100
H100
Figure 2: Ratio of performance of standard library provided functions to their NQT counterparts. Bigger is bet-
ter. Left column is the portable implementation that uses frexp and ldexp and right column is the integer aliased
implementation described in Appendix A. Top row is first-order NQT and bottom row is second-order NQT. In the
architecture lists, intel implies the intel compiler was used. On CPU systems, the gnu compiler was otherwise used
and on GPU systems the relevant vendor-provided compiler (here CUDA) was used. spr stands for Sapphire Rapids.

Miller et al. (2022) observe, however, it is also an inde- and interpolate it with linear interpolation on a log-log
pendent function in its own right, and straightforwardly grid and on a NQTo1-NQTo1 grid. The former is shown
invertible by simply finding m and p and computing on the left pane, the latter in the center. On average
m × 2p . Miller et al. (2022) define this inverse func- (in the L1 sense), both interpolants converge at second
tion as pow2o1 (x). Multiplication by a constant value is order. However, error spikes near the control points of
all that is required to convert these functions to NQT the NQT gridding converge more slowly. The result is
versions of log10 (x) and 10x . that first-order NQT converges at order in the L1 norm
Definition (6) is everywhere continuous, but only but slower in the Lp norm for p > 1.
piecewise C 1 , as the derivative is discontinuous at the
control points, powers of 2. When this transformation 3. SECOND-ORDER
is applied to smooth data, the resulting function, which NOT-QUITE-TRANSCENDENTAL FUNCTIONS
must then be interpolated, also becomes merely piece- If not-quite transcendental functions can be made ev-
wise C 1 . Unfortunately, second order convergence of erywhere C 1 , then second order convergence may be re-
linear interpolation is only guaranteed for everywhere covered. To do so, will modify definition (6). We begin
C 1 functions. with a second order polynomial form
The consequences of this non-smoothness are shown
in the central panel of Figure 1. We create a fake table lgo2 (x) = ax2 + bx + c + p (7)
of the form
for some as-of-yet undetermined constants a, b, and c.
P = 1 + ρ + K1 ρΓ1 + K2 ρΓ2 To fix these, we enforce continuity of control points, that
4

Figure 3: Interpolation of the SFHo EOS (Steiner et al. 2013) as tabulated in the Stellar Collapse database (O’Connor
& Ott 2010). Left column is the true table, middle is first-order NQT, and right is second-order. Left column shows
pressure vs density and temperature at fixed Ye = 0.1. Middle and right columns show relative error compared to the
true log interpolant.

Figure 4: Interpolation of the tabulated equation of state for Copper in the Sesame database (Lyon & Johnson 1992;
Peterson et al. 2012). Left column is the fifth-order rational function interpolant produced by the EOSPAC library
(Pimentel 2021), which we treat as ground truth. Middle two columns show errors from first- and second-order NQT
interpolation respectively, while rightmost column shows error from true log interpolation.
 5

is
lgo2 (2p ) = p (8)
and that

∂x lgo2 (x)|x=2p = 2∂x lgo2 (x)|2p+1 (9)

which is indeed satisfied by a true logarithm.

This results in the Hermite (1877) interpolant of the
form
4
lgo2 (x) = − ∗ (m − 2) ∗ (m − 1) + p. (10)
3
While intuitively four degrees of freedom (i.e., a cubic
function) would be required to enforce continuity and
continuity of a derivative, recurrence relation (9) allows
the second order NQT function defined in (10) to be
everywhere C 1 . And indeed, when one interpolates a
function on an NQT mesh, second-order convergence is
recovered, as shown in the right panel of 1.
Equation (10) is still exactly invertible, but the in-
verse now requires solving a quadratic equation for the
mantissa:
Figure 5: Density slice of a three-dimensional neutron
p
3 − 1 − 3 ∗ lgo2 (m)
m= . (11) star simulated with AthenaK with logarithmic interpo-
2
lation on the left and second-order NQT on the right.
While they are non-transcendental, numerically, square
roots are also more computationally expensive than
standard algebraic operations, limiting the utility of ex- transcendental counterparts across a variety of architec-
ponentiation. However, as we shall see in Section 4 per- tures including intel, AMD, and ARM CPUs as well
formance is still superior to true logarithms and expo- as NVIDIA GPUs. Broadly, NQT methods are faster
nentials. than transcendental methods, and the integer aliased
Most programming languages provide facilities to split methods are faster than the portable ones. Speedups
a floating point number into mantissa and exponent and for the second-order method are more modest than for
to recombine. In C++ and Python these are called first order. However, especially with the integer-aliased
frexp and ldexp respectively. The NQT methods may versions, 2x or greater speedups are achievable, even for
be implemented in a portable manner via these func- the second-order NQT method.
tions. However, to achieve the best possible perfor- Architecturally, speedups are more modest for GPU
mance, the integer-aliasing approach described in Ap- architectures than for x86-CPUs, likely because GPUs
pendix A must be used. are memory bandwidth, not flop, limited. ARM64-
based architectures sometimes indicate slowdowns
4. NUMERICAL EXPERIMENTS rather than speedups (although the slowdowns are
4.1. Isolated performance mild). This is likely due to the fact that ARM64 pro-
vides a hardware intrinsic for logarithms and exponen-
To measure the performance of NQT functions com- tials, while x86 does not.
pared to their transcendental counterparts, we imple-
ment performance portable versions of first- and second- 4.2. EOS lookups
order NQT logarithm and exponent in the Kokkos
framework (Trott et al. 2022).2 To evaluate NQT methods integrated in table interpo-
Figure 2 compares timings for first- and second-order lation, we implement the integer-aliased versions of first-
NQT methods for logarithm and exponential vs their and second-order NQT methods inside the performance
portable equation of state library Singularity-EOS
(Miller et al. 2024). Interpolation on device is effi-
2 This implementation is available online at https://github.com/ cated by the performance portable interpoaltion library,
lanl/not-quite-transcendental. Spiner (Miller et al. 2022).
 6
sign bit mantissa
1.4 NQTo1
1.2 NQTo2
speedup vs. log10

1.0 exponent

0.8 Figure 7: Structure of a big-endian double precision

0.6 floating point number under the IEEE754 standard.

0.4 mic and second-order NQT interpolation are otherwise

0.2 essentially indistinguishable, with very small errors. We
note that these grids are not uniformly spaced in log
0.0 space, rather they are more finely resolved around the
EPYC 7763
Grace ARM

A100
H200
MI250X
Xeon Plat 8280
Ryzen 9 5900X

RTX 3070

phase transition.
In these experiments we find the integrated second-
order NQT method to be about 2x faster than true logs
on x86 architectures, and indistinguishable on GPU ar-
chitectures, broadly consistent with the timing results
reported in Section 4.1. In a pleasant surprise, we find
Figure 6: Integrated performance data comparing log- the second-order NQT method to be about 25% faster
arithmic with first- and second-order NQT interpolation than true logs on ARM64. We are unsure why this is the
in an AthenaK simulation of an isolated neutron star on case. However, given the artificial nature of the exper-
various architectures. Speedups are with respect to log- iments in the previous section compared to these, per-
arithmic interpolation. Broadly NQTo2 always provides haps a compiler optimization was available previously
a speedup in integrated runtime, though smaller than where now it is not.
NQTo1. The largest speedup for NQTo2 is about 30%
on an RTX 3070. Performance is measured by record- 4.3. Integrated numerical relativity simulation
ing the total number of zone-cycles/wallsecond in each
Finally as an integrated demonstration, we run simu-
calculation.
lations of an isolated neutron star, constructed using
Tolman-Oppenheimer-Volkoff initial conditions (Tol-
Figure 3 shows interpolation of the SFHo (Steiner man 1934, 1939; Oppenheimer & Volkoff 1939) with a
et al. 2013) equation of state as tabulated in the Stel- tabulated SFHo equation of state (Steiner et al. 2013).
lar Collapse format O’Connor & Ott (2010). Particu- These simulations are performed in the performance
larly at low densities, the relative error for the second- portable numerical relativity code AthenaK (Stone et al.
order NQT is significantly reduced compared to first- 2024; Zhu et al. 2024; Fields et al. 2024). A density
order NQT, to the point that they are essentially indis- slice is shown in Figure 5. Broadly results are similar.
tinguishable. The eigenfrequencies of oscillations of an isolated neu-
Figure 4 compares interpolation treatments for the tron star depend sensitively on the equation of state,
equation of state for Copper tabulated in the Sesame however, and we have not yet explored the density of
database (Lyon & Johnson 1992; Peterson et al. 2012). table required for the NQTo2 and logarithmic tables to
The leftmost column pressure as a function of density produce eiqenspectra that agree.
and temperature computed via a fifth-order rational Performance data comparing logarithmic to first- and
function interpolant computed by the EOSPAC library second-order NQT interpolation is shown in Figure 6.
(Pimentel 2021), which we treat as ground truth. The Improvements for second-order NQT are more modest
middle two columns are the errors of first- and second- than for first-order, but still are as large as approxi-
order NQT interpolation respectively, and the rightmost mately 30%, a significant improvement. AthenaK makes
column is error from a true log grid. Copper undergoes many equation of state calls per cycle due to the con-
a phase transition around standard density and temper- served to primitive solver and first-order flux correc-
ature, where it goes into tension, interpreted as a neg- tion algorithm utilized, which may explain the large
ative pressure. This phase transition is sharp and none speedups.
of the methods are correct, hence the cone-shaped error.
This error cannot be removed. However, the logarith- 5. OUTLOOK
 7

To summarize, we have developed a novel set of func- total integrated calculation. This speaks to the large
tions that satisfy many of the properties that make fraction of time that a numerical relativity simulation
logarithms appealing transformations for interpolation may spend in equation of state physics. There are still
of tabulated data, but which are faster to evaluate, gains to be had in low-level optimizations such as this
often significantly. We call these functions not-quite- one.
transcendental.
We have demonstrated in a series of experiments the 1 The authors thank Luke Roberts, Josh Dolence, Patrick
efficacy of these NQT functions for the interpolation of 2 Mullen, Jeff Peterson, and Daniel Holladay for many
tabulated equation of state data, such as finite tempera- 3 useful discussions. PH and JMF acknowledge fund-
ture nuclear equations of state, suitable for core-collapse 4 ing from the National Science Foundation under Grant
supernova and neutron star merger simulations, and ter- 5 No. PHY-2116686. This research was supported by
restrial equations of state, suitable for planet and moon 6 funding from the U.S. Department of Energy, Office of
formation and planetary defense. 7 Science, Division of Nuclear Physics under Award Num-
This functionality has been implemented in the open 8 ber DE-SC0021177. JMM was supported by the ASC
source singularity-EOS (Miller et al. 2024) library and 9 M3 AP and XCAP projects in Advanced Simulation and
AthenaK (Stone et al. 2024; Zhu et al. 2021; Fields 10 Computing (ASC) program the at Los Alamos National
et al. 2024) and Phoebus (Barker et al. 2024) numer- 11 Laboratory (LANL). BLB acknowledges support from
ical relativity codes, where it is now in use. While 12 the ASC Program of LANL as a Metropolis Postdoc-
a portable implementation is possible, to squeeze the 13 toral Fellow. LANL is operated by Triad National Se-
most performance out of the method, a lower-level, in- 14 curity, LLC, for the National Nuclear Security Admin-
teger aliased approach is required. Reference imple- 15 istration of U.S. Department of Energy (Contract No.
mentations are available at https://github.com/lanl/ 16 89233218CNA000001). This work is cleared for unlim-
not-quite-transcendental. 17 ited release under LA-UR-25-20182.
Swapping out the logarithm can have a significant im- Software: singularity-eos (Miller et al. 2024), Spiner
pact on performance. In AthenaK, we found that re- (Miller et al. 2022), Parthenon (Grete et al. 2023),
placing the logarithm with NQTo2 in equation of state Kokkos (Trott et al. 2022), AthenaK (Stone et al. 2024;
interpolation resulted in as high as a 30% speedup in the Zhu et al. 2024; Fields et al. 2024), Phoebus (Barker et al.
2024), yt (Turk et al. 2011)

APPENDIX

A. INTEGER ALIASING
In this section, we discuss the integer aliasing strategy required to implement the most performant versions of NQT
functions.

A.1. On the structure of floating point numbers

The following discussion assumes a big-endian3 implementation of the IEEE754 standard (IEEE Computer Society
2019) for double precision numbers. However, it may be generalized to other precisions and other endianness straight-
forwardly. Figure 7 shows the structure of an IEEE754 number, which encodes equation (4). Each box is a bit. The
leading bit (at the lowest memory address) is the sign bit. The next 11 bits, e, are the exponent, represented as a
biased integer in base 2, such as p in equation (4), where p is given by p = 1 − 1023. The remaining 52 bits represent
the mantissa, again in base 2. The bits stored represent the number 0.b, howver the IEEE754 calls for a leading 1,
so the value is represented as 1.b, which exists on the interval [1, 2). To recover m ∈ [1/2, 1), we use m = (1 + b)/2).
The mantissa and exponent may thus be extracted from the original number by appropriate masking of the bits. For
example, to extract the mantissa b of 64 bit floating point number n, one may use

m = (252 − 1) & n (A1)

3 That is to say the most significant bit is at the smallest memory

address and the least significant bit at the largest.
 8

where & is the bitwise and operator. Similarly, the exponent e may be extracted via
p = (262 − 252 ) & n (A2)
where equation (A1) selects for the trailing 52 bits and equation (A2) selects for the exponent bits, but not the sign
bit. For more details on constructing masks (A1) and (A2), see Warren (2012).
A.2. Classic integer aliasing
Because the leading order bits in the number represent the exponent, the total collection of bits reinterpreted as an
integer scales roughly as the logarithm of the original floating point number. To be useful as a floating point number,
the resultant integer must then be typecast back to its original type and then shifted and scaled, as shown below:
Listing 1: The basic integer-aliased NQTo1 log
1 inline auto as_int ( double f ) {
2 return * reinterpret_cast < std :: int64_t * >(& f ) ;
3 }
4

5 inline auto as_double ( std :: int64_t i ) {

6 return * reinterpret_cast < double * >(& i ) ;
7 }
8

9 inline double lg_o1_aliased ( const double x ) {

10 std :: int64_t one_as_int = as_int (1.0) ;
11 double scale_down = 1./ static_cast < double >( as_int (2.0) - as_int (1.0) ) ;
12 return static_cast < double >( as_int ( x ) - one_as_int ) * scale_down ;
13 }

This observation, made by Blinn (1997), is the core idea of integer aliasing. Indeed it turns out the resultant function
is exactly the first-order NQT lg defined in equation (6). Incidentally it is also the 64 bit generalization of the first
part of the infamous Quake 3 fast inverse square root (Abrash & Carmack 1999; Kushner 2002). The magic numbers
from that algorithm can be mapped to the one as int and scale down numbers in Listing 1.
A.3. Integer aliasing for second-order NQT methods
Integer aliasing for the second-order NQT method proceeds by picking out the mantissa and exponent as in equations
(A1) and (A2) and then using equation (10). To accelerate calculation, one may perform the arithmetic operations
required, such as squaring the mantissa, while treating it as an integer, as shown below:
Listing 2: The integer-aliased NQTo2 log
1 inline double lg_o2_aliased ( const double x ) {
2 // picks out the mantissa
3 constexpr std :: int64_t mantissa_mask = ( one << 52) - one ;
4 // picks out the least significant 26 bits
5 constexpr std :: int64_t low_mask = ( one << 26) - 1;
6

7 const std :: int64_t x_as_int = as_int ( x ) - as_int (1) ;

8 const std :: int64_t m_as_int = x_as_int & mantissa_mask ;
9 const std :: int64_t m_high = m_as_int >> 26;
10 const std :: int64_t m_low = m_as_int & low_mask ;
11

12 // square of the mantissa , but drops the least significant bits

13 const std :: int64_t m_squared =
14 m_high * m_high + (( m_high * m_low ) >> 25) ;
15

16 return static_cast < double >( x_as_int + (( m_as_int - m_squared ) / 3) ) * scale_down ;

17 }

Doing so will drop the least significant bits of the logarithm, however.
 9

REFERENCES
Abrash, M., & Carmack, J. 1999, Fast Inverse Square Root Miller, J. M., et al. 2024, Journal of Open Source Software,
Algorithm. 9, 6805, doi: 10.21105/joss.06805
https://github.com/id-Software/Quake-III-Arena Mills, B. S., Davis, S. W., Jiang, Y.-F., & Middleton, M. J.
Barker, B., Gogilashvili, M., Rodriguez-Bueno, J., et al. 2024, ApJ, 974, 166, doi: 10.3847/1538-4357/ad6b21
2024, arXiv e-prints, arXiv:2410.09146, O’Connor, E. 2015, ApJS, 219, 24,
doi: 10.48550/arXiv.2410.09146 doi: 10.1088/0067-0049/219/2/24
Blinn, J. 1997, IEEE Computer Graphics and Applications, O’Connor, E., & Ott, C. D. 2010, Classical and Quantum
17, 80, doi: 10.1109/38.595279 Gravity, 27, 114103.
http://stacks.iop.org/0264-9381/27/i=11/a=114103
Burrows, A., Reddy, S., & Thompson, T. A. 2006, Nuclear
Oppenheimer, J. R., & Volkoff, G. M. 1939, Physical
Physics A, 777, 356, doi: 10.1016/j.nuclphysa.2004.06.012
Review, 55, 374, doi: 10.1103/PhysRev.55.374
Cody, W., & Waite, W. 1980, Software Manual for the
Peterson, J. H., Honnell, K. G., Greeff, C., et al. 2012, AIP
Elementary Functions, Prentice-Hall Foundations of
Conference Proceedings, 1426, 763,
Earth Science Series (Prentice-Hall).
doi: 10.1063/1.3686390
https://books.google.com/books?id=d4UZAQAAIAAJ
Pimentel, D. A. 2021, EOSPAC User’s Manual: V.6.5
Cyburt, R. H., Amthor, A. M., Ferguson, R., et al. 2010, (United States), doi: 10.2172/1765849
The Astrophysical Journal Supplement Series, 189, 240, Rogers, F. J., & Iglesias, C. A. 1992, ApJS, 79, 507,
doi: 10.1088/0067-0049/189/1/240 doi: 10.1086/191659
Fields, J., Zhu, H., Radice, D., et al. 2024, arXiv e-prints, Skinner, M. A., Dolence, J. C., Burrows, A., Radice, D., &
arXiv:2409.10384, doi: 10.48550/arXiv.2409.10384 Vartanyan, D. 2019, ApJS, 241, 7,
Grete, P., Dolence, J. C., Miller, J. M., et al. 2023, The doi: 10.3847/1538-4365/ab007f
International Journal of High Performance Computing Steiner, A. W., Hempel, M., & Fischer, T. 2013, ApJ, 774,
Applications, 37, 465, doi: 10.1177/10943420221143775 17, doi: 10.1088/0004-637X/774/1/17
Hall, E., Lynch, D., & Dwyer, S. 1970, IEEE Transactions Stone, J. M., Mullen, P. D., Fielding, D., et al. 2024, arXiv
on Computers, C-19, 97, doi: 10.1109/T-C.1970.222874 e-prints, arXiv:2409.16053,
Hermite, C. 1877, Journal für die reine und angewandte doi: 10.48550/arXiv.2409.16053
Timmes, F. X., & Swesty, F. D. 2000, ApJS, 126, 501,
Mathematik, 84, 70. http://eudml.org/doc/148345
doi: 10.1086/313304
IEEE Computer Society. 2019, IEEE Standard for
Tolman, R. C. 1934, Proceedings of the National Academy
Floating-Point Arithmetic, Standard IEEE Std 754-2019,
of Sciences, 20, 169, doi: 10.1073/pnas.20.3.169
Institute of Electrical and Electronics Engineers (IEEE).
Tolman, R. C. 1939, Physical Review, 55, 364,
https://standards.ieee.org/standard/754-2019.html
doi: 10.1103/PhysRev.55.364
Iglesias, C. A., & Rogers, F. J. 1996, ApJ, 464, 943, Townsend, E. 1915, Functions of a Complex Variable,
doi: 10.1086/177381 American mathematical series (H. Holt).
Kushner, D. 2002, IEEE Spectrum, 39, 42, https://books.google.com/books?id=JDUNAAAAYAAJ
doi: 10.1109/MSPEC.2002.1021943 Trott, C. R., Lebrun-Grandié, D., Arndt, D., et al. 2022,
Lyon, S. P., & Johnson, J. D. 1992, Sesame: The Los IEEE Transactions on Parallel and Distributed Systems,
Alamos National Laboratory Equation of State 33, 805, doi: 10.1109/TPDS.2021.3097283
Database, Tech. Rep. LA-UR-92-3407, Los Alamos Turk, M. J., Smith, B. D., Oishi, J. S., et al. 2011, ApJS,
National Laboratory 192, 9, doi: 10.1088/0067-0049/192/1/9
Miller, J. M., Dolence, J. C., & Holladay, D. 2022, arXiv Warren, H. 2012, Hacker’s Delight (Pearson Education).
e-prints, arXiv:2206.08957, https://books.google.com/books?id=VicPJYM0I5QC
doi: 10.48550/arXiv.2206.08957 Zhu, H., Fields, J., Zappa, F., et al. 2024, arXiv e-prints,
Miller, J. M., Holladay, D., Meyer, C. D., et al. 2022, arXiv:2409.10383, doi: 10.48550/arXiv.2409.10383
Zhu, Z., Jiang, Y.-F., Baehr, H., et al. 2021, MNRAS, 508,
Journal of Open Source Software, 7, 4367,
453, doi: 10.1093/mnras/stab2517
doi: 10.21105/joss.04367