
(FPCore (x y z t a) :precision binary64 (+ x (* (- y z) (/ (- t x) (- a z)))))
double code(double x, double y, double z, double t, double a) {
return x + ((y - z) * ((t - x) / (a - z)));
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
code = x + ((y - z) * ((t - x) / (a - z)))
end function
public static double code(double x, double y, double z, double t, double a) {
return x + ((y - z) * ((t - x) / (a - z)));
}
def code(x, y, z, t, a): return x + ((y - z) * ((t - x) / (a - z)))
function code(x, y, z, t, a) return Float64(x + Float64(Float64(y - z) * Float64(Float64(t - x) / Float64(a - z)))) end
function tmp = code(x, y, z, t, a) tmp = x + ((y - z) * ((t - x) / (a - z))); end
code[x_, y_, z_, t_, a_] := N[(x + N[(N[(y - z), $MachinePrecision] * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \left(y - z\right) \cdot \frac{t - x}{a - z}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 19 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a) :precision binary64 (+ x (* (- y z) (/ (- t x) (- a z)))))
double code(double x, double y, double z, double t, double a) {
return x + ((y - z) * ((t - x) / (a - z)));
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
code = x + ((y - z) * ((t - x) / (a - z)))
end function
public static double code(double x, double y, double z, double t, double a) {
return x + ((y - z) * ((t - x) / (a - z)));
}
def code(x, y, z, t, a): return x + ((y - z) * ((t - x) / (a - z)))
function code(x, y, z, t, a) return Float64(x + Float64(Float64(y - z) * Float64(Float64(t - x) / Float64(a - z)))) end
function tmp = code(x, y, z, t, a) tmp = x + ((y - z) * ((t - x) / (a - z))); end
code[x_, y_, z_, t_, a_] := N[(x + N[(N[(y - z), $MachinePrecision] * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \left(y - z\right) \cdot \frac{t - x}{a - z}
\end{array}
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (fma (/ (- y z) (- a z)) (- t x) x))
(t_2 (+ x (* (- y z) (/ (- t x) (- a z))))))
(if (<= t_2 -1e-274)
t_1
(if (<= t_2 0.0) (+ t (* (- t x) (/ (- a y) z))) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = fma(((y - z) / (a - z)), (t - x), x);
double t_2 = x + ((y - z) * ((t - x) / (a - z)));
double tmp;
if (t_2 <= -1e-274) {
tmp = t_1;
} else if (t_2 <= 0.0) {
tmp = t + ((t - x) * ((a - y) / z));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = fma(Float64(Float64(y - z) / Float64(a - z)), Float64(t - x), x) t_2 = Float64(x + Float64(Float64(y - z) * Float64(Float64(t - x) / Float64(a - z)))) tmp = 0.0 if (t_2 <= -1e-274) tmp = t_1; elseif (t_2 <= 0.0) tmp = Float64(t + Float64(Float64(t - x) * Float64(Float64(a - y) / z))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(N[(y - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision] * N[(t - x), $MachinePrecision] + x), $MachinePrecision]}, Block[{t$95$2 = N[(x + N[(N[(y - z), $MachinePrecision] * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, -1e-274], t$95$1, If[LessEqual[t$95$2, 0.0], N[(t + N[(N[(t - x), $MachinePrecision] * N[(N[(a - y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(\frac{y - z}{a - z}, t - x, x\right)\\
t_2 := x + \left(y - z\right) \cdot \frac{t - x}{a - z}\\
\mathbf{if}\;t\_2 \leq -1 \cdot 10^{-274}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq 0:\\
\;\;\;\;t + \left(t - x\right) \cdot \frac{a - y}{z}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) < -9.99999999999999966e-275 or 0.0 < (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) Initial program 93.3%
lift--.f64N/A
lift--.f64N/A
lift--.f64N/A
div-invN/A
div-invN/A
lift-/.f64N/A
lift-*.f64N/A
+-commutativeN/A
Applied egg-rr95.5%
if -9.99999999999999966e-275 < (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) < 0.0Initial program 3.2%
lift--.f64N/A
lift--.f64N/A
lift--.f64N/A
div-invN/A
div-invN/A
lift-/.f64N/A
lift-*.f64N/A
+-commutativeN/A
Applied egg-rr11.2%
lift--.f64N/A
lift--.f64N/A
div-invN/A
lift-/.f64N/A
*-commutativeN/A
lift--.f64N/A
associate-*r*N/A
lift-*.f64N/A
lift-/.f64N/A
associate-*l/N/A
*-lft-identityN/A
lift-*.f64N/A
associate-*l/N/A
div-invN/A
lift-/.f64N/A
associate-*l*N/A
Applied egg-rr3.6%
Taylor expanded in z around inf
associate--l+N/A
distribute-lft-out--N/A
div-subN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
distribute-rgt-out--N/A
associate-/l*N/A
lower-*.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower--.f6499.9
Simplified99.9%
Final simplification95.9%
(FPCore (x y z t a) :precision binary64 (if (<= (+ x (* (- y z) (/ (- t x) (- a z)))) 4e+300) t (/ (* t t) t)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if ((x + ((y - z) * ((t - x) / (a - z)))) <= 4e+300) {
tmp = t;
} else {
tmp = (t * t) / t;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if ((x + ((y - z) * ((t - x) / (a - z)))) <= 4d+300) then
tmp = t
else
tmp = (t * t) / t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if ((x + ((y - z) * ((t - x) / (a - z)))) <= 4e+300) {
tmp = t;
} else {
tmp = (t * t) / t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if (x + ((y - z) * ((t - x) / (a - z)))) <= 4e+300: tmp = t else: tmp = (t * t) / t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (Float64(x + Float64(Float64(y - z) * Float64(Float64(t - x) / Float64(a - z)))) <= 4e+300) tmp = t; else tmp = Float64(Float64(t * t) / t); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if ((x + ((y - z) * ((t - x) / (a - z)))) <= 4e+300) tmp = t; else tmp = (t * t) / t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[N[(x + N[(N[(y - z), $MachinePrecision] * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 4e+300], t, N[(N[(t * t), $MachinePrecision] / t), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x + \left(y - z\right) \cdot \frac{t - x}{a - z} \leq 4 \cdot 10^{+300}:\\
\;\;\;\;t\\
\mathbf{else}:\\
\;\;\;\;\frac{t \cdot t}{t}\\
\end{array}
\end{array}
if (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) < 4.0000000000000002e300Initial program 83.7%
Taylor expanded in z around inf
lower--.f6418.0
Simplified18.0%
lift--.f64N/A
+-commutativeN/A
lift--.f64N/A
associate-+l-N/A
lower--.f64N/A
lower--.f6422.8
Applied egg-rr22.8%
+-inversesN/A
--rgt-identity22.8
Applied egg-rr22.8%
if 4.0000000000000002e300 < (+.f64 x (*.f64 (-.f64 y z) (/.f64 (-.f64 t x) (-.f64 a z)))) Initial program 95.7%
Taylor expanded in z around inf
lower--.f642.7
Simplified2.7%
lift--.f64N/A
+-commutativeN/A
lift--.f64N/A
associate-+l-N/A
lower--.f64N/A
lower--.f642.9
Applied egg-rr2.9%
lift--.f64N/A
flip--N/A
lift--.f64N/A
+-inversesN/A
lift--.f64N/A
+-inversesN/A
metadata-evalN/A
--rgt-identityN/A
lift--.f64N/A
+-inversesN/A
+-rgt-identityN/A
lower-/.f64N/A
lower-*.f6427.0
Applied egg-rr27.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* y (/ (- t x) (- a z)))) (t_2 (fma (- t x) (/ a z) t)))
(if (<= z -1.9e+163)
t_2
(if (<= z -6.4e-74)
t_1
(if (<= z 9.2e-83)
(fma y (/ (- t x) a) x)
(if (<= z 1.4e+148) t_1 t_2))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y * ((t - x) / (a - z));
double t_2 = fma((t - x), (a / z), t);
double tmp;
if (z <= -1.9e+163) {
tmp = t_2;
} else if (z <= -6.4e-74) {
tmp = t_1;
} else if (z <= 9.2e-83) {
tmp = fma(y, ((t - x) / a), x);
} else if (z <= 1.4e+148) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = Float64(y * Float64(Float64(t - x) / Float64(a - z))) t_2 = fma(Float64(t - x), Float64(a / z), t) tmp = 0.0 if (z <= -1.9e+163) tmp = t_2; elseif (z <= -6.4e-74) tmp = t_1; elseif (z <= 9.2e-83) tmp = fma(y, Float64(Float64(t - x) / a), x); elseif (z <= 1.4e+148) tmp = t_1; else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y * N[(N[(t - x), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(t - x), $MachinePrecision] * N[(a / z), $MachinePrecision] + t), $MachinePrecision]}, If[LessEqual[z, -1.9e+163], t$95$2, If[LessEqual[z, -6.4e-74], t$95$1, If[LessEqual[z, 9.2e-83], N[(y * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[z, 1.4e+148], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \frac{t - x}{a - z}\\
t_2 := \mathsf{fma}\left(t - x, \frac{a}{z}, t\right)\\
\mathbf{if}\;z \leq -1.9 \cdot 10^{+163}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;z \leq -6.4 \cdot 10^{-74}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 9.2 \cdot 10^{-83}:\\
\;\;\;\;\mathsf{fma}\left(y, \frac{t - x}{a}, x\right)\\
\mathbf{elif}\;z \leq 1.4 \cdot 10^{+148}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if z < -1.90000000000000004e163 or 1.3999999999999999e148 < z Initial program 62.7%
lift--.f64N/A
lift--.f64N/A
lift--.f64N/A
div-invN/A
div-invN/A
lift-/.f64N/A
lift-*.f64N/A
+-commutativeN/A
Applied egg-rr73.9%
lift--.f64N/A
lift--.f64N/A
div-invN/A
lift-/.f64N/A
*-commutativeN/A
lift--.f64N/A
associate-*r*N/A
lift-*.f64N/A
lift-/.f64N/A
associate-*l/N/A
*-lft-identityN/A
lift-*.f64N/A
associate-*l/N/A
div-invN/A
lift-/.f64N/A
associate-*l*N/A
Applied egg-rr62.8%
Taylor expanded in z around inf
associate--l+N/A
distribute-lft-out--N/A
div-subN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
distribute-rgt-out--N/A
associate-/l*N/A
lower-*.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower--.f6485.5
Simplified85.5%
Taylor expanded in y around 0
sub-negN/A
mul-1-negN/A
remove-double-negN/A
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower--.f64N/A
lower-/.f6473.0
Simplified73.0%
if -1.90000000000000004e163 < z < -6.3999999999999997e-74 or 9.19999999999999959e-83 < z < 1.3999999999999999e148Initial program 83.1%
Taylor expanded in y around inf
div-subN/A
associate-/l*N/A
lower-/.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f6448.5
Simplified48.5%
lift--.f64N/A
lift--.f64N/A
associate-/l*N/A
*-commutativeN/A
lower-*.f64N/A
lower-/.f6457.8
Applied egg-rr57.8%
if -6.3999999999999997e-74 < z < 9.19999999999999959e-83Initial program 97.6%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower--.f6489.6
Simplified89.6%
Final simplification73.7%
(FPCore (x y z t a)
:precision binary64
(if (<= z -2e+162)
t
(if (<= z -1.06e-151)
(* x (/ (- y a) z))
(if (<= z 5.8e-50)
(* y (/ (- t x) a))
(if (<= z 8.2e+141) (* t (/ y (- a z))) t)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2e+162) {
tmp = t;
} else if (z <= -1.06e-151) {
tmp = x * ((y - a) / z);
} else if (z <= 5.8e-50) {
tmp = y * ((t - x) / a);
} else if (z <= 8.2e+141) {
tmp = t * (y / (a - z));
} else {
tmp = t;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-2d+162)) then
tmp = t
else if (z <= (-1.06d-151)) then
tmp = x * ((y - a) / z)
else if (z <= 5.8d-50) then
tmp = y * ((t - x) / a)
else if (z <= 8.2d+141) then
tmp = t * (y / (a - z))
else
tmp = t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2e+162) {
tmp = t;
} else if (z <= -1.06e-151) {
tmp = x * ((y - a) / z);
} else if (z <= 5.8e-50) {
tmp = y * ((t - x) / a);
} else if (z <= 8.2e+141) {
tmp = t * (y / (a - z));
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -2e+162: tmp = t elif z <= -1.06e-151: tmp = x * ((y - a) / z) elif z <= 5.8e-50: tmp = y * ((t - x) / a) elif z <= 8.2e+141: tmp = t * (y / (a - z)) else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -2e+162) tmp = t; elseif (z <= -1.06e-151) tmp = Float64(x * Float64(Float64(y - a) / z)); elseif (z <= 5.8e-50) tmp = Float64(y * Float64(Float64(t - x) / a)); elseif (z <= 8.2e+141) tmp = Float64(t * Float64(y / Float64(a - z))); else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -2e+162) tmp = t; elseif (z <= -1.06e-151) tmp = x * ((y - a) / z); elseif (z <= 5.8e-50) tmp = y * ((t - x) / a); elseif (z <= 8.2e+141) tmp = t * (y / (a - z)); else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -2e+162], t, If[LessEqual[z, -1.06e-151], N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 5.8e-50], N[(y * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 8.2e+141], N[(t * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2 \cdot 10^{+162}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq -1.06 \cdot 10^{-151}:\\
\;\;\;\;x \cdot \frac{y - a}{z}\\
\mathbf{elif}\;z \leq 5.8 \cdot 10^{-50}:\\
\;\;\;\;y \cdot \frac{t - x}{a}\\
\mathbf{elif}\;z \leq 8.2 \cdot 10^{+141}:\\
\;\;\;\;t \cdot \frac{y}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -1.9999999999999999e162 or 8.20000000000000044e141 < z Initial program 62.3%
Taylor expanded in z around inf
lower--.f6452.1
Simplified52.1%
lift--.f64N/A
+-commutativeN/A
lift--.f64N/A
associate-+l-N/A
lower--.f64N/A
lower--.f6464.0
Applied egg-rr64.0%
+-inversesN/A
--rgt-identity64.0
Applied egg-rr64.0%
if -1.9999999999999999e162 < z < -1.06e-151Initial program 84.3%
lift--.f64N/A
lift--.f64N/A
lift--.f64N/A
div-invN/A
div-invN/A
lift-/.f64N/A
lift-*.f64N/A
+-commutativeN/A
Applied egg-rr86.0%
lift--.f64N/A
lift--.f64N/A
div-invN/A
lift-/.f64N/A
*-commutativeN/A
lift--.f64N/A
associate-*r*N/A
lift-*.f64N/A
lift-/.f64N/A
associate-*l/N/A
*-lft-identityN/A
lift-*.f64N/A
associate-*l/N/A
div-invN/A
lift-/.f64N/A
associate-*l*N/A
Applied egg-rr84.2%
Taylor expanded in z around inf
associate--l+N/A
distribute-lft-out--N/A
div-subN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
distribute-rgt-out--N/A
associate-/l*N/A
lower-*.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower--.f6453.9
Simplified53.9%
Taylor expanded in t around 0
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
lower--.f6437.9
Simplified37.9%
if -1.06e-151 < z < 5.80000000000000016e-50Initial program 96.5%
Taylor expanded in y around inf
div-subN/A
associate-/l*N/A
lower-/.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f6458.1
Simplified58.1%
lift--.f64N/A
lift--.f64N/A
associate-/l*N/A
*-commutativeN/A
lower-*.f64N/A
lower-/.f6461.2
Applied egg-rr61.2%
Taylor expanded in a around inf
lower-/.f64N/A
lower--.f6454.4
Simplified54.4%
if 5.80000000000000016e-50 < z < 8.20000000000000044e141Initial program 89.9%
Taylor expanded in y around inf
div-subN/A
associate-/l*N/A
lower-/.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f6445.7
Simplified45.7%
Taylor expanded in t around inf
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
lower--.f6431.0
Simplified31.0%
Final simplification47.5%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (fma x (/ y z) 0.0)))
(if (<= z -6e+161)
t
(if (<= z -1.25e-183)
t_1
(if (<= z 3.1e-88) (/ (* y t) a) (if (<= z 2.25e+142) t_1 t))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = fma(x, (y / z), 0.0);
double tmp;
if (z <= -6e+161) {
tmp = t;
} else if (z <= -1.25e-183) {
tmp = t_1;
} else if (z <= 3.1e-88) {
tmp = (y * t) / a;
} else if (z <= 2.25e+142) {
tmp = t_1;
} else {
tmp = t;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = fma(x, Float64(y / z), 0.0) tmp = 0.0 if (z <= -6e+161) tmp = t; elseif (z <= -1.25e-183) tmp = t_1; elseif (z <= 3.1e-88) tmp = Float64(Float64(y * t) / a); elseif (z <= 2.25e+142) tmp = t_1; else tmp = t; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(x * N[(y / z), $MachinePrecision] + 0.0), $MachinePrecision]}, If[LessEqual[z, -6e+161], t, If[LessEqual[z, -1.25e-183], t$95$1, If[LessEqual[z, 3.1e-88], N[(N[(y * t), $MachinePrecision] / a), $MachinePrecision], If[LessEqual[z, 2.25e+142], t$95$1, t]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(x, \frac{y}{z}, 0\right)\\
\mathbf{if}\;z \leq -6 \cdot 10^{+161}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq -1.25 \cdot 10^{-183}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 3.1 \cdot 10^{-88}:\\
\;\;\;\;\frac{y \cdot t}{a}\\
\mathbf{elif}\;z \leq 2.25 \cdot 10^{+142}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -6.00000000000000023e161 or 2.2499999999999999e142 < z Initial program 62.3%
Taylor expanded in z around inf
lower--.f6452.1
Simplified52.1%
lift--.f64N/A
+-commutativeN/A
lift--.f64N/A
associate-+l-N/A
lower--.f64N/A
lower--.f6464.0
Applied egg-rr64.0%
+-inversesN/A
--rgt-identity64.0
Applied egg-rr64.0%
if -6.00000000000000023e161 < z < -1.2500000000000001e-183 or 3.0999999999999998e-88 < z < 2.2499999999999999e142Initial program 86.6%
Taylor expanded in x around inf
+-commutativeN/A
distribute-rgt-inN/A
mul-1-negN/A
distribute-lft-neg-outN/A
*-commutativeN/A
associate-/l*N/A
*-commutativeN/A
associate-/l*N/A
distribute-rgt-neg-inN/A
*-lft-identityN/A
lower-fma.f64N/A
lower--.f64N/A
lower-neg.f64N/A
lower-/.f64N/A
lower--.f6453.8
Simplified53.8%
Taylor expanded in a around 0
+-commutativeN/A
associate-/l*N/A
div-subN/A
sub-negN/A
*-inversesN/A
metadata-evalN/A
distribute-lft-outN/A
associate-/l*N/A
*-commutativeN/A
associate-+l+N/A
distribute-lft1-inN/A
metadata-evalN/A
mul0-lftN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6431.2
Simplified31.2%
if -1.2500000000000001e-183 < z < 3.0999999999999998e-88Initial program 98.6%
lift--.f64N/A
lift--.f64N/A
lift--.f64N/A
div-invN/A
div-invN/A
lift-/.f64N/A
lift-*.f64N/A
+-commutativeN/A
Applied egg-rr98.7%
Taylor expanded in a around inf
lower-/.f64N/A
lower--.f6494.7
Simplified94.7%
Taylor expanded in t around inf
div-subN/A
associate-/l*N/A
lower-/.f64N/A
lower-*.f64N/A
lower--.f6435.7
Simplified35.7%
Taylor expanded in y around inf
lower-/.f64N/A
*-commutativeN/A
lower-*.f6435.7
Simplified35.7%
(FPCore (x y z t a)
:precision binary64
(if (<= z -6.2e+161)
t
(if (<= z -6.6e-152)
(* x (/ (- y a) z))
(if (<= z 1.1e+142) (* y (/ t (- a z))) t))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -6.2e+161) {
tmp = t;
} else if (z <= -6.6e-152) {
tmp = x * ((y - a) / z);
} else if (z <= 1.1e+142) {
tmp = y * (t / (a - z));
} else {
tmp = t;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-6.2d+161)) then
tmp = t
else if (z <= (-6.6d-152)) then
tmp = x * ((y - a) / z)
else if (z <= 1.1d+142) then
tmp = y * (t / (a - z))
else
tmp = t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -6.2e+161) {
tmp = t;
} else if (z <= -6.6e-152) {
tmp = x * ((y - a) / z);
} else if (z <= 1.1e+142) {
tmp = y * (t / (a - z));
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -6.2e+161: tmp = t elif z <= -6.6e-152: tmp = x * ((y - a) / z) elif z <= 1.1e+142: tmp = y * (t / (a - z)) else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -6.2e+161) tmp = t; elseif (z <= -6.6e-152) tmp = Float64(x * Float64(Float64(y - a) / z)); elseif (z <= 1.1e+142) tmp = Float64(y * Float64(t / Float64(a - z))); else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -6.2e+161) tmp = t; elseif (z <= -6.6e-152) tmp = x * ((y - a) / z); elseif (z <= 1.1e+142) tmp = y * (t / (a - z)); else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -6.2e+161], t, If[LessEqual[z, -6.6e-152], N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.1e+142], N[(y * N[(t / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -6.2 \cdot 10^{+161}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq -6.6 \cdot 10^{-152}:\\
\;\;\;\;x \cdot \frac{y - a}{z}\\
\mathbf{elif}\;z \leq 1.1 \cdot 10^{+142}:\\
\;\;\;\;y \cdot \frac{t}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -6.20000000000000013e161 or 1.09999999999999993e142 < z Initial program 62.3%
Taylor expanded in z around inf
lower--.f6452.1
Simplified52.1%
lift--.f64N/A
+-commutativeN/A
lift--.f64N/A
associate-+l-N/A
lower--.f64N/A
lower--.f6464.0
Applied egg-rr64.0%
+-inversesN/A
--rgt-identity64.0
Applied egg-rr64.0%
if -6.20000000000000013e161 < z < -6.59999999999999997e-152Initial program 84.3%
lift--.f64N/A
lift--.f64N/A
lift--.f64N/A
div-invN/A
div-invN/A
lift-/.f64N/A
lift-*.f64N/A
+-commutativeN/A
Applied egg-rr86.0%
lift--.f64N/A
lift--.f64N/A
div-invN/A
lift-/.f64N/A
*-commutativeN/A
lift--.f64N/A
associate-*r*N/A
lift-*.f64N/A
lift-/.f64N/A
associate-*l/N/A
*-lft-identityN/A
lift-*.f64N/A
associate-*l/N/A
div-invN/A
lift-/.f64N/A
associate-*l*N/A
Applied egg-rr84.2%
Taylor expanded in z around inf
associate--l+N/A
distribute-lft-out--N/A
div-subN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
distribute-rgt-out--N/A
associate-/l*N/A
lower-*.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower--.f6453.9
Simplified53.9%
Taylor expanded in t around 0
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
lower--.f6437.9
Simplified37.9%
if -6.59999999999999997e-152 < z < 1.09999999999999993e142Initial program 94.0%
Taylor expanded in y around inf
div-subN/A
associate-/l*N/A
lower-/.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f6453.4
Simplified53.4%
lift--.f64N/A
lift--.f64N/A
associate-/l*N/A
*-commutativeN/A
lower-*.f64N/A
lower-/.f6460.2
Applied egg-rr60.2%
Taylor expanded in t around inf
lower-/.f64N/A
lower--.f6434.8
Simplified34.8%
Final simplification41.7%
(FPCore (x y z t a)
:precision binary64
(if (<= z -4.9e+160)
t
(if (<= z -4.8e-152)
(* x (/ (- y a) z))
(if (<= z 8.2e+141) (* t (/ y (- a z))) t))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -4.9e+160) {
tmp = t;
} else if (z <= -4.8e-152) {
tmp = x * ((y - a) / z);
} else if (z <= 8.2e+141) {
tmp = t * (y / (a - z));
} else {
tmp = t;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-4.9d+160)) then
tmp = t
else if (z <= (-4.8d-152)) then
tmp = x * ((y - a) / z)
else if (z <= 8.2d+141) then
tmp = t * (y / (a - z))
else
tmp = t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -4.9e+160) {
tmp = t;
} else if (z <= -4.8e-152) {
tmp = x * ((y - a) / z);
} else if (z <= 8.2e+141) {
tmp = t * (y / (a - z));
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -4.9e+160: tmp = t elif z <= -4.8e-152: tmp = x * ((y - a) / z) elif z <= 8.2e+141: tmp = t * (y / (a - z)) else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -4.9e+160) tmp = t; elseif (z <= -4.8e-152) tmp = Float64(x * Float64(Float64(y - a) / z)); elseif (z <= 8.2e+141) tmp = Float64(t * Float64(y / Float64(a - z))); else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -4.9e+160) tmp = t; elseif (z <= -4.8e-152) tmp = x * ((y - a) / z); elseif (z <= 8.2e+141) tmp = t * (y / (a - z)); else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -4.9e+160], t, If[LessEqual[z, -4.8e-152], N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 8.2e+141], N[(t * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -4.9 \cdot 10^{+160}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq -4.8 \cdot 10^{-152}:\\
\;\;\;\;x \cdot \frac{y - a}{z}\\
\mathbf{elif}\;z \leq 8.2 \cdot 10^{+141}:\\
\;\;\;\;t \cdot \frac{y}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -4.9000000000000002e160 or 8.20000000000000044e141 < z Initial program 62.3%
Taylor expanded in z around inf
lower--.f6452.1
Simplified52.1%
lift--.f64N/A
+-commutativeN/A
lift--.f64N/A
associate-+l-N/A
lower--.f64N/A
lower--.f6464.0
Applied egg-rr64.0%
+-inversesN/A
--rgt-identity64.0
Applied egg-rr64.0%
if -4.9000000000000002e160 < z < -4.8e-152Initial program 84.3%
lift--.f64N/A
lift--.f64N/A
lift--.f64N/A
div-invN/A
div-invN/A
lift-/.f64N/A
lift-*.f64N/A
+-commutativeN/A
Applied egg-rr86.0%
lift--.f64N/A
lift--.f64N/A
div-invN/A
lift-/.f64N/A
*-commutativeN/A
lift--.f64N/A
associate-*r*N/A
lift-*.f64N/A
lift-/.f64N/A
associate-*l/N/A
*-lft-identityN/A
lift-*.f64N/A
associate-*l/N/A
div-invN/A
lift-/.f64N/A
associate-*l*N/A
Applied egg-rr84.2%
Taylor expanded in z around inf
associate--l+N/A
distribute-lft-out--N/A
div-subN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
distribute-rgt-out--N/A
associate-/l*N/A
lower-*.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower--.f6453.9
Simplified53.9%
Taylor expanded in t around 0
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
lower--.f6437.9
Simplified37.9%
if -4.8e-152 < z < 8.20000000000000044e141Initial program 94.0%
Taylor expanded in y around inf
div-subN/A
associate-/l*N/A
lower-/.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f6453.4
Simplified53.4%
Taylor expanded in t around inf
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
lower--.f6434.2
Simplified34.2%
(FPCore (x y z t a)
:precision binary64
(if (<= z -9e+160)
t
(if (<= z -1.05e-151)
(fma x (/ y z) 0.0)
(if (<= z 2.9e+145) (* t (/ y (- a z))) t))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -9e+160) {
tmp = t;
} else if (z <= -1.05e-151) {
tmp = fma(x, (y / z), 0.0);
} else if (z <= 2.9e+145) {
tmp = t * (y / (a - z));
} else {
tmp = t;
}
return tmp;
}
function code(x, y, z, t, a) tmp = 0.0 if (z <= -9e+160) tmp = t; elseif (z <= -1.05e-151) tmp = fma(x, Float64(y / z), 0.0); elseif (z <= 2.9e+145) tmp = Float64(t * Float64(y / Float64(a - z))); else tmp = t; end return tmp end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -9e+160], t, If[LessEqual[z, -1.05e-151], N[(x * N[(y / z), $MachinePrecision] + 0.0), $MachinePrecision], If[LessEqual[z, 2.9e+145], N[(t * N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -9 \cdot 10^{+160}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq -1.05 \cdot 10^{-151}:\\
\;\;\;\;\mathsf{fma}\left(x, \frac{y}{z}, 0\right)\\
\mathbf{elif}\;z \leq 2.9 \cdot 10^{+145}:\\
\;\;\;\;t \cdot \frac{y}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -8.99999999999999959e160 or 2.9000000000000001e145 < z Initial program 62.3%
Taylor expanded in z around inf
lower--.f6452.1
Simplified52.1%
lift--.f64N/A
+-commutativeN/A
lift--.f64N/A
associate-+l-N/A
lower--.f64N/A
lower--.f6464.0
Applied egg-rr64.0%
+-inversesN/A
--rgt-identity64.0
Applied egg-rr64.0%
if -8.99999999999999959e160 < z < -1.04999999999999995e-151Initial program 84.3%
Taylor expanded in x around inf
+-commutativeN/A
distribute-rgt-inN/A
mul-1-negN/A
distribute-lft-neg-outN/A
*-commutativeN/A
associate-/l*N/A
*-commutativeN/A
associate-/l*N/A
distribute-rgt-neg-inN/A
*-lft-identityN/A
lower-fma.f64N/A
lower--.f64N/A
lower-neg.f64N/A
lower-/.f64N/A
lower--.f6456.7
Simplified56.7%
Taylor expanded in a around 0
+-commutativeN/A
associate-/l*N/A
div-subN/A
sub-negN/A
*-inversesN/A
metadata-evalN/A
distribute-lft-outN/A
associate-/l*N/A
*-commutativeN/A
associate-+l+N/A
distribute-lft1-inN/A
metadata-evalN/A
mul0-lftN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6434.5
Simplified34.5%
if -1.04999999999999995e-151 < z < 2.9000000000000001e145Initial program 94.0%
Taylor expanded in y around inf
div-subN/A
associate-/l*N/A
lower-/.f64N/A
lower-*.f64N/A
lower--.f64N/A
lower--.f6453.4
Simplified53.4%
Taylor expanded in t around inf
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
lower--.f6434.2
Simplified34.2%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ t (* (- t x) (/ (- a y) z)))))
(if (<= z -1.25e-9)
t_1
(if (<= z 5.3e+116) (fma (/ y (- a z)) (- t x) x) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t + ((t - x) * ((a - y) / z));
double tmp;
if (z <= -1.25e-9) {
tmp = t_1;
} else if (z <= 5.3e+116) {
tmp = fma((y / (a - z)), (t - x), x);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = Float64(t + Float64(Float64(t - x) * Float64(Float64(a - y) / z))) tmp = 0.0 if (z <= -1.25e-9) tmp = t_1; elseif (z <= 5.3e+116) tmp = fma(Float64(y / Float64(a - z)), Float64(t - x), x); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t + N[(N[(t - x), $MachinePrecision] * N[(N[(a - y), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.25e-9], t$95$1, If[LessEqual[z, 5.3e+116], N[(N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision] * N[(t - x), $MachinePrecision] + x), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t + \left(t - x\right) \cdot \frac{a - y}{z}\\
\mathbf{if}\;z \leq -1.25 \cdot 10^{-9}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 5.3 \cdot 10^{+116}:\\
\;\;\;\;\mathsf{fma}\left(\frac{y}{a - z}, t - x, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -1.25e-9 or 5.3000000000000002e116 < z Initial program 67.5%
lift--.f64N/A
lift--.f64N/A
lift--.f64N/A
div-invN/A
div-invN/A
lift-/.f64N/A
lift-*.f64N/A
+-commutativeN/A
Applied egg-rr74.6%
lift--.f64N/A
lift--.f64N/A
div-invN/A
lift-/.f64N/A
*-commutativeN/A
lift--.f64N/A
associate-*r*N/A
lift-*.f64N/A
lift-/.f64N/A
associate-*l/N/A
*-lft-identityN/A
lift-*.f64N/A
associate-*l/N/A
div-invN/A
lift-/.f64N/A
associate-*l*N/A
Applied egg-rr67.3%
Taylor expanded in z around inf
associate--l+N/A
distribute-lft-out--N/A
div-subN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
distribute-rgt-out--N/A
associate-/l*N/A
lower-*.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower--.f6478.1
Simplified78.1%
if -1.25e-9 < z < 5.3000000000000002e116Initial program 95.2%
lift--.f64N/A
lift--.f64N/A
lift--.f64N/A
div-invN/A
div-invN/A
lift-/.f64N/A
lift-*.f64N/A
+-commutativeN/A
Applied egg-rr95.3%
Taylor expanded in y around inf
lower-/.f64N/A
lower--.f6489.1
Simplified89.1%
Final simplification85.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (+ t (* (/ y z) (- x t)))))
(if (<= z -1.25e+153)
t_1
(if (<= z 5e+116) (fma (/ y (- a z)) (- t x) x) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = t + ((y / z) * (x - t));
double tmp;
if (z <= -1.25e+153) {
tmp = t_1;
} else if (z <= 5e+116) {
tmp = fma((y / (a - z)), (t - x), x);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = Float64(t + Float64(Float64(y / z) * Float64(x - t))) tmp = 0.0 if (z <= -1.25e+153) tmp = t_1; elseif (z <= 5e+116) tmp = fma(Float64(y / Float64(a - z)), Float64(t - x), x); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(t + N[(N[(y / z), $MachinePrecision] * N[(x - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.25e+153], t$95$1, If[LessEqual[z, 5e+116], N[(N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision] * N[(t - x), $MachinePrecision] + x), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t + \frac{y}{z} \cdot \left(x - t\right)\\
\mathbf{if}\;z \leq -1.25 \cdot 10^{+153}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 5 \cdot 10^{+116}:\\
\;\;\;\;\mathsf{fma}\left(\frac{y}{a - z}, t - x, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -1.25000000000000005e153 or 5.00000000000000025e116 < z Initial program 63.7%
lift--.f64N/A
lift--.f64N/A
lift--.f64N/A
div-invN/A
div-invN/A
lift-/.f64N/A
lift-*.f64N/A
+-commutativeN/A
Applied egg-rr72.7%
lift--.f64N/A
lift--.f64N/A
div-invN/A
lift-/.f64N/A
*-commutativeN/A
lift--.f64N/A
associate-*r*N/A
lift-*.f64N/A
lift-/.f64N/A
associate-*l/N/A
*-lft-identityN/A
lift-*.f64N/A
associate-*l/N/A
div-invN/A
lift-/.f64N/A
associate-*l*N/A
Applied egg-rr63.5%
Taylor expanded in z around inf
associate--l+N/A
distribute-lft-out--N/A
div-subN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
distribute-rgt-out--N/A
associate-/l*N/A
lower-*.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower--.f6486.6
Simplified86.6%
Taylor expanded in y around inf
lower-/.f6480.5
Simplified80.5%
if -1.25000000000000005e153 < z < 5.00000000000000025e116Initial program 91.9%
lift--.f64N/A
lift--.f64N/A
lift--.f64N/A
div-invN/A
div-invN/A
lift-/.f64N/A
lift-*.f64N/A
+-commutativeN/A
Applied egg-rr92.5%
Taylor expanded in y around inf
lower-/.f64N/A
lower--.f6484.4
Simplified84.4%
Final simplification83.4%
(FPCore (x y z t a)
:precision binary64
(if (<= a -1e-118)
(fma (- y z) (/ t (- a z)) x)
(if (<= a 5.2e-111)
(+ t (* (/ y z) (- x t)))
(fma (- y z) (/ (- t x) a) x))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (a <= -1e-118) {
tmp = fma((y - z), (t / (a - z)), x);
} else if (a <= 5.2e-111) {
tmp = t + ((y / z) * (x - t));
} else {
tmp = fma((y - z), ((t - x) / a), x);
}
return tmp;
}
function code(x, y, z, t, a) tmp = 0.0 if (a <= -1e-118) tmp = fma(Float64(y - z), Float64(t / Float64(a - z)), x); elseif (a <= 5.2e-111) tmp = Float64(t + Float64(Float64(y / z) * Float64(x - t))); else tmp = fma(Float64(y - z), Float64(Float64(t - x) / a), x); end return tmp end
code[x_, y_, z_, t_, a_] := If[LessEqual[a, -1e-118], N[(N[(y - z), $MachinePrecision] * N[(t / N[(a - z), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[a, 5.2e-111], N[(t + N[(N[(y / z), $MachinePrecision] * N[(x - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(y - z), $MachinePrecision] * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision] + x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;a \leq -1 \cdot 10^{-118}:\\
\;\;\;\;\mathsf{fma}\left(y - z, \frac{t}{a - z}, x\right)\\
\mathbf{elif}\;a \leq 5.2 \cdot 10^{-111}:\\
\;\;\;\;t + \frac{y}{z} \cdot \left(x - t\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(y - z, \frac{t - x}{a}, x\right)\\
\end{array}
\end{array}
if a < -9.99999999999999985e-119Initial program 94.1%
lift--.f64N/A
lift--.f64N/A
lift--.f64N/A
div-invN/A
div-invN/A
lift-/.f64N/A
lift-*.f64N/A
+-commutativeN/A
Applied egg-rr98.8%
lift--.f64N/A
lift--.f64N/A
div-invN/A
lift-/.f64N/A
*-commutativeN/A
lift--.f64N/A
associate-*r*N/A
lift-*.f64N/A
lift-/.f64N/A
associate-*l/N/A
*-lft-identityN/A
lift-*.f64N/A
associate-*l/N/A
div-invN/A
lift-/.f64N/A
associate-*l*N/A
Applied egg-rr94.1%
Taylor expanded in t around inf
lower-/.f64N/A
lower--.f6483.3
Simplified83.3%
if -9.99999999999999985e-119 < a < 5.19999999999999965e-111Initial program 69.6%
lift--.f64N/A
lift--.f64N/A
lift--.f64N/A
div-invN/A
div-invN/A
lift-/.f64N/A
lift-*.f64N/A
+-commutativeN/A
Applied egg-rr73.4%
lift--.f64N/A
lift--.f64N/A
div-invN/A
lift-/.f64N/A
*-commutativeN/A
lift--.f64N/A
associate-*r*N/A
lift-*.f64N/A
lift-/.f64N/A
associate-*l/N/A
*-lft-identityN/A
lift-*.f64N/A
associate-*l/N/A
div-invN/A
lift-/.f64N/A
associate-*l*N/A
Applied egg-rr69.2%
Taylor expanded in z around inf
associate--l+N/A
distribute-lft-out--N/A
div-subN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
distribute-rgt-out--N/A
associate-/l*N/A
lower-*.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower--.f6493.7
Simplified93.7%
Taylor expanded in y around inf
lower-/.f6493.7
Simplified93.7%
if 5.19999999999999965e-111 < a Initial program 87.9%
Taylor expanded in a around inf
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower--.f6470.8
Simplified70.8%
Final simplification81.8%
(FPCore (x y z t a) :precision binary64 (let* ((t_1 (fma (- y z) (/ t (- a z)) x))) (if (<= a -8e-116) t_1 (if (<= a 3.2e-32) (+ t (* (/ y z) (- x t))) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = fma((y - z), (t / (a - z)), x);
double tmp;
if (a <= -8e-116) {
tmp = t_1;
} else if (a <= 3.2e-32) {
tmp = t + ((y / z) * (x - t));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = fma(Float64(y - z), Float64(t / Float64(a - z)), x) tmp = 0.0 if (a <= -8e-116) tmp = t_1; elseif (a <= 3.2e-32) tmp = Float64(t + Float64(Float64(y / z) * Float64(x - t))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(y - z), $MachinePrecision] * N[(t / N[(a - z), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision]}, If[LessEqual[a, -8e-116], t$95$1, If[LessEqual[a, 3.2e-32], N[(t + N[(N[(y / z), $MachinePrecision] * N[(x - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(y - z, \frac{t}{a - z}, x\right)\\
\mathbf{if}\;a \leq -8 \cdot 10^{-116}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 3.2 \cdot 10^{-32}:\\
\;\;\;\;t + \frac{y}{z} \cdot \left(x - t\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if a < -8e-116 or 3.2000000000000002e-32 < a Initial program 92.5%
lift--.f64N/A
lift--.f64N/A
lift--.f64N/A
div-invN/A
div-invN/A
lift-/.f64N/A
lift-*.f64N/A
+-commutativeN/A
Applied egg-rr95.6%
lift--.f64N/A
lift--.f64N/A
div-invN/A
lift-/.f64N/A
*-commutativeN/A
lift--.f64N/A
associate-*r*N/A
lift-*.f64N/A
lift-/.f64N/A
associate-*l/N/A
*-lft-identityN/A
lift-*.f64N/A
associate-*l/N/A
div-invN/A
lift-/.f64N/A
associate-*l*N/A
Applied egg-rr92.4%
Taylor expanded in t around inf
lower-/.f64N/A
lower--.f6479.9
Simplified79.9%
if -8e-116 < a < 3.2000000000000002e-32Initial program 72.0%
lift--.f64N/A
lift--.f64N/A
lift--.f64N/A
div-invN/A
div-invN/A
lift-/.f64N/A
lift-*.f64N/A
+-commutativeN/A
Applied egg-rr74.2%
lift--.f64N/A
lift--.f64N/A
div-invN/A
lift-/.f64N/A
*-commutativeN/A
lift--.f64N/A
associate-*r*N/A
lift-*.f64N/A
lift-/.f64N/A
associate-*l/N/A
*-lft-identityN/A
lift-*.f64N/A
associate-*l/N/A
div-invN/A
lift-/.f64N/A
associate-*l*N/A
Applied egg-rr71.9%
Taylor expanded in z around inf
associate--l+N/A
distribute-lft-out--N/A
div-subN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
distribute-rgt-out--N/A
associate-/l*N/A
lower-*.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower--.f6484.4
Simplified84.4%
Taylor expanded in y around inf
lower-/.f6483.2
Simplified83.2%
Final simplification81.1%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (fma y (/ (- t x) a) x)))
(if (<= a -4.4e-70)
t_1
(if (<= a 6.2e-110) (+ t (* (/ y z) (- x t))) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = fma(y, ((t - x) / a), x);
double tmp;
if (a <= -4.4e-70) {
tmp = t_1;
} else if (a <= 6.2e-110) {
tmp = t + ((y / z) * (x - t));
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = fma(y, Float64(Float64(t - x) / a), x) tmp = 0.0 if (a <= -4.4e-70) tmp = t_1; elseif (a <= 6.2e-110) tmp = Float64(t + Float64(Float64(y / z) * Float64(x - t))); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision] + x), $MachinePrecision]}, If[LessEqual[a, -4.4e-70], t$95$1, If[LessEqual[a, 6.2e-110], N[(t + N[(N[(y / z), $MachinePrecision] * N[(x - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(y, \frac{t - x}{a}, x\right)\\
\mathbf{if}\;a \leq -4.4 \cdot 10^{-70}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 6.2 \cdot 10^{-110}:\\
\;\;\;\;t + \frac{y}{z} \cdot \left(x - t\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if a < -4.3999999999999998e-70 or 6.20000000000000014e-110 < a Initial program 90.6%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower--.f6469.7
Simplified69.7%
if -4.3999999999999998e-70 < a < 6.20000000000000014e-110Initial program 72.5%
lift--.f64N/A
lift--.f64N/A
lift--.f64N/A
div-invN/A
div-invN/A
lift-/.f64N/A
lift-*.f64N/A
+-commutativeN/A
Applied egg-rr76.0%
lift--.f64N/A
lift--.f64N/A
div-invN/A
lift-/.f64N/A
*-commutativeN/A
lift--.f64N/A
associate-*r*N/A
lift-*.f64N/A
lift-/.f64N/A
associate-*l/N/A
*-lft-identityN/A
lift-*.f64N/A
associate-*l/N/A
div-invN/A
lift-/.f64N/A
associate-*l*N/A
Applied egg-rr72.2%
Taylor expanded in z around inf
associate--l+N/A
distribute-lft-out--N/A
div-subN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
distribute-rgt-out--N/A
associate-/l*N/A
lower-*.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower--.f6491.9
Simplified91.9%
Taylor expanded in y around inf
lower-/.f6491.9
Simplified91.9%
Final simplification76.8%
(FPCore (x y z t a) :precision binary64 (let* ((t_1 (fma (- t x) (/ a z) t))) (if (<= z -9e+171) t_1 (if (<= z 6.5e+116) (fma y (/ (- t x) a) x) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = fma((t - x), (a / z), t);
double tmp;
if (z <= -9e+171) {
tmp = t_1;
} else if (z <= 6.5e+116) {
tmp = fma(y, ((t - x) / a), x);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = fma(Float64(t - x), Float64(a / z), t) tmp = 0.0 if (z <= -9e+171) tmp = t_1; elseif (z <= 6.5e+116) tmp = fma(y, Float64(Float64(t - x) / a), x); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(t - x), $MachinePrecision] * N[(a / z), $MachinePrecision] + t), $MachinePrecision]}, If[LessEqual[z, -9e+171], t$95$1, If[LessEqual[z, 6.5e+116], N[(y * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision] + x), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(t - x, \frac{a}{z}, t\right)\\
\mathbf{if}\;z \leq -9 \cdot 10^{+171}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 6.5 \cdot 10^{+116}:\\
\;\;\;\;\mathsf{fma}\left(y, \frac{t - x}{a}, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if z < -8.99999999999999937e171 or 6.4999999999999998e116 < z Initial program 63.6%
lift--.f64N/A
lift--.f64N/A
lift--.f64N/A
div-invN/A
div-invN/A
lift-/.f64N/A
lift-*.f64N/A
+-commutativeN/A
Applied egg-rr74.0%
lift--.f64N/A
lift--.f64N/A
div-invN/A
lift-/.f64N/A
*-commutativeN/A
lift--.f64N/A
associate-*r*N/A
lift-*.f64N/A
lift-/.f64N/A
associate-*l/N/A
*-lft-identityN/A
lift-*.f64N/A
associate-*l/N/A
div-invN/A
lift-/.f64N/A
associate-*l*N/A
Applied egg-rr63.7%
Taylor expanded in z around inf
associate--l+N/A
distribute-lft-out--N/A
div-subN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
distribute-rgt-out--N/A
associate-/l*N/A
lower-*.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower--.f6489.9
Simplified89.9%
Taylor expanded in y around 0
sub-negN/A
mul-1-negN/A
remove-double-negN/A
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower--.f64N/A
lower-/.f6469.6
Simplified69.6%
if -8.99999999999999937e171 < z < 6.4999999999999998e116Initial program 90.7%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower--.f6466.7
Simplified66.7%
(FPCore (x y z t a) :precision binary64 (if (<= z -9e+171) t (if (<= z 5e+116) (fma y (/ (- t x) a) x) t)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -9e+171) {
tmp = t;
} else if (z <= 5e+116) {
tmp = fma(y, ((t - x) / a), x);
} else {
tmp = t;
}
return tmp;
}
function code(x, y, z, t, a) tmp = 0.0 if (z <= -9e+171) tmp = t; elseif (z <= 5e+116) tmp = fma(y, Float64(Float64(t - x) / a), x); else tmp = t; end return tmp end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -9e+171], t, If[LessEqual[z, 5e+116], N[(y * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision] + x), $MachinePrecision], t]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -9 \cdot 10^{+171}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq 5 \cdot 10^{+116}:\\
\;\;\;\;\mathsf{fma}\left(y, \frac{t - x}{a}, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -8.99999999999999937e171 or 5.00000000000000025e116 < z Initial program 63.6%
Taylor expanded in z around inf
lower--.f6452.0
Simplified52.0%
lift--.f64N/A
+-commutativeN/A
lift--.f64N/A
associate-+l-N/A
lower--.f64N/A
lower--.f6462.4
Applied egg-rr62.4%
+-inversesN/A
--rgt-identity62.4
Applied egg-rr62.4%
if -8.99999999999999937e171 < z < 5.00000000000000025e116Initial program 90.7%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower--.f6466.7
Simplified66.7%
(FPCore (x y z t a) :precision binary64 (if (<= z -1.3e+172) t (if (<= z 6.2e+116) (fma (- x) (/ y a) x) t)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.3e+172) {
tmp = t;
} else if (z <= 6.2e+116) {
tmp = fma(-x, (y / a), x);
} else {
tmp = t;
}
return tmp;
}
function code(x, y, z, t, a) tmp = 0.0 if (z <= -1.3e+172) tmp = t; elseif (z <= 6.2e+116) tmp = fma(Float64(-x), Float64(y / a), x); else tmp = t; end return tmp end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1.3e+172], t, If[LessEqual[z, 6.2e+116], N[((-x) * N[(y / a), $MachinePrecision] + x), $MachinePrecision], t]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.3 \cdot 10^{+172}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq 6.2 \cdot 10^{+116}:\\
\;\;\;\;\mathsf{fma}\left(-x, \frac{y}{a}, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -1.3e172 or 6.19999999999999992e116 < z Initial program 63.6%
Taylor expanded in z around inf
lower--.f6452.0
Simplified52.0%
lift--.f64N/A
+-commutativeN/A
lift--.f64N/A
associate-+l-N/A
lower--.f64N/A
lower--.f6462.4
Applied egg-rr62.4%
+-inversesN/A
--rgt-identity62.4
Applied egg-rr62.4%
if -1.3e172 < z < 6.19999999999999992e116Initial program 90.7%
Taylor expanded in x around inf
+-commutativeN/A
distribute-rgt-inN/A
mul-1-negN/A
distribute-lft-neg-outN/A
*-commutativeN/A
associate-/l*N/A
*-commutativeN/A
associate-/l*N/A
distribute-rgt-neg-inN/A
*-lft-identityN/A
lower-fma.f64N/A
lower--.f64N/A
lower-neg.f64N/A
lower-/.f64N/A
lower--.f6459.1
Simplified59.1%
Taylor expanded in z around 0
+-commutativeN/A
mul-1-negN/A
associate-/l*N/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-/.f6451.4
Simplified51.4%
(FPCore (x y z t a) :precision binary64 (if (<= z -1.4e-40) t (if (<= z 7e-11) (/ (* y t) a) t)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.4e-40) {
tmp = t;
} else if (z <= 7e-11) {
tmp = (y * t) / a;
} else {
tmp = t;
}
return tmp;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8) :: tmp
if (z <= (-1.4d-40)) then
tmp = t
else if (z <= 7d-11) then
tmp = (y * t) / a
else
tmp = t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.4e-40) {
tmp = t;
} else if (z <= 7e-11) {
tmp = (y * t) / a;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -1.4e-40: tmp = t elif z <= 7e-11: tmp = (y * t) / a else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -1.4e-40) tmp = t; elseif (z <= 7e-11) tmp = Float64(Float64(y * t) / a); else tmp = t; end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -1.4e-40) tmp = t; elseif (z <= 7e-11) tmp = (y * t) / a; else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1.4e-40], t, If[LessEqual[z, 7e-11], N[(N[(y * t), $MachinePrecision] / a), $MachinePrecision], t]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.4 \cdot 10^{-40}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq 7 \cdot 10^{-11}:\\
\;\;\;\;\frac{y \cdot t}{a}\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -1.4e-40 or 7.00000000000000038e-11 < z Initial program 73.6%
Taylor expanded in z around inf
lower--.f6429.2
Simplified29.2%
lift--.f64N/A
+-commutativeN/A
lift--.f64N/A
associate-+l-N/A
lower--.f64N/A
lower--.f6437.3
Applied egg-rr37.3%
+-inversesN/A
--rgt-identity37.3
Applied egg-rr37.3%
if -1.4e-40 < z < 7.00000000000000038e-11Initial program 97.1%
lift--.f64N/A
lift--.f64N/A
lift--.f64N/A
div-invN/A
div-invN/A
lift-/.f64N/A
lift-*.f64N/A
+-commutativeN/A
Applied egg-rr97.3%
Taylor expanded in a around inf
lower-/.f64N/A
lower--.f6485.7
Simplified85.7%
Taylor expanded in t around inf
div-subN/A
associate-/l*N/A
lower-/.f64N/A
lower-*.f64N/A
lower--.f6429.1
Simplified29.1%
Taylor expanded in y around inf
lower-/.f64N/A
*-commutativeN/A
lower-*.f6427.1
Simplified27.1%
(FPCore (x y z t a) :precision binary64 t)
double code(double x, double y, double z, double t, double a) {
return t;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
code = t
end function
public static double code(double x, double y, double z, double t, double a) {
return t;
}
def code(x, y, z, t, a): return t
function code(x, y, z, t, a) return t end
function tmp = code(x, y, z, t, a) tmp = t; end
code[x_, y_, z_, t_, a_] := t
\begin{array}{l}
\\
t
\end{array}
Initial program 84.8%
Taylor expanded in z around inf
lower--.f6416.7
Simplified16.7%
lift--.f64N/A
+-commutativeN/A
lift--.f64N/A
associate-+l-N/A
lower--.f64N/A
lower--.f6421.0
Applied egg-rr21.0%
+-inversesN/A
--rgt-identity21.0
Applied egg-rr21.0%
(FPCore (x y z t a) :precision binary64 0.0)
double code(double x, double y, double z, double t, double a) {
return 0.0;
}
real(8) function code(x, y, z, t, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
code = 0.0d0
end function
public static double code(double x, double y, double z, double t, double a) {
return 0.0;
}
def code(x, y, z, t, a): return 0.0
function code(x, y, z, t, a) return 0.0 end
function tmp = code(x, y, z, t, a) tmp = 0.0; end
code[x_, y_, z_, t_, a_] := 0.0
\begin{array}{l}
\\
0
\end{array}
Initial program 84.8%
Taylor expanded in x around inf
+-commutativeN/A
distribute-rgt-inN/A
mul-1-negN/A
distribute-lft-neg-outN/A
*-commutativeN/A
associate-/l*N/A
*-commutativeN/A
associate-/l*N/A
distribute-rgt-neg-inN/A
*-lft-identityN/A
lower-fma.f64N/A
lower--.f64N/A
lower-neg.f64N/A
lower-/.f64N/A
lower--.f6448.9
Simplified48.9%
Taylor expanded in z around inf
distribute-rgt1-inN/A
metadata-evalN/A
mul0-lft2.6
Simplified2.6%
herbie shell --seed 2024207
(FPCore (x y z t a)
:name "Numeric.Signal:interpolate from hsignal-0.2.7.1"
:precision binary64
(+ x (* (- y z) (/ (- t x) (- a z)))))