
(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 -1e+163)
t_2
(if (<= z -3.8e-74)
t_1
(if (<= z 1.22e-82)
(fma y (/ (- t x) a) x)
(if (<= z 3.9e+144) 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 <= -1e+163) {
tmp = t_2;
} else if (z <= -3.8e-74) {
tmp = t_1;
} else if (z <= 1.22e-82) {
tmp = fma(y, ((t - x) / a), x);
} else if (z <= 3.9e+144) {
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 <= -1e+163) tmp = t_2; elseif (z <= -3.8e-74) tmp = t_1; elseif (z <= 1.22e-82) tmp = fma(y, Float64(Float64(t - x) / a), x); elseif (z <= 3.9e+144) 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, -1e+163], t$95$2, If[LessEqual[z, -3.8e-74], t$95$1, If[LessEqual[z, 1.22e-82], N[(y * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[z, 3.9e+144], 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 \cdot 10^{+163}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;z \leq -3.8 \cdot 10^{-74}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 1.22 \cdot 10^{-82}:\\
\;\;\;\;\mathsf{fma}\left(y, \frac{t - x}{a}, x\right)\\
\mathbf{elif}\;z \leq 3.9 \cdot 10^{+144}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if z < -9.9999999999999994e162 or 3.90000000000000018e144 < 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 -9.9999999999999994e162 < z < -3.7999999999999996e-74 or 1.22000000000000001e-82 < z < 3.90000000000000018e144Initial 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 -3.7999999999999996e-74 < z < 1.22000000000000001e-82Initial 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 -9e+160)
t
(if (<= z -1.06e-151)
(* x (/ (- y a) z))
(if (<= z 1.35e-48)
(* y (/ (- t x) a))
(if (<= z 4.9e+143) (* 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.06e-151) {
tmp = x * ((y - a) / z);
} else if (z <= 1.35e-48) {
tmp = y * ((t - x) / a);
} else if (z <= 4.9e+143) {
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 <= (-9d+160)) then
tmp = t
else if (z <= (-1.06d-151)) then
tmp = x * ((y - a) / z)
else if (z <= 1.35d-48) then
tmp = y * ((t - x) / a)
else if (z <= 4.9d+143) 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 <= -9e+160) {
tmp = t;
} else if (z <= -1.06e-151) {
tmp = x * ((y - a) / z);
} else if (z <= 1.35e-48) {
tmp = y * ((t - x) / a);
} else if (z <= 4.9e+143) {
tmp = t * (y / (a - z));
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -9e+160: tmp = t elif z <= -1.06e-151: tmp = x * ((y - a) / z) elif z <= 1.35e-48: tmp = y * ((t - x) / a) elif z <= 4.9e+143: 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.06e-151) tmp = Float64(x * Float64(Float64(y - a) / z)); elseif (z <= 1.35e-48) tmp = Float64(y * Float64(Float64(t - x) / a)); elseif (z <= 4.9e+143) 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 <= -9e+160) tmp = t; elseif (z <= -1.06e-151) tmp = x * ((y - a) / z); elseif (z <= 1.35e-48) tmp = y * ((t - x) / a); elseif (z <= 4.9e+143) tmp = t * (y / (a - z)); else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -9e+160], t, If[LessEqual[z, -1.06e-151], N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.35e-48], N[(y * N[(N[(t - x), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4.9e+143], 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.06 \cdot 10^{-151}:\\
\;\;\;\;x \cdot \frac{y - a}{z}\\
\mathbf{elif}\;z \leq 1.35 \cdot 10^{-48}:\\
\;\;\;\;y \cdot \frac{t - x}{a}\\
\mathbf{elif}\;z \leq 4.9 \cdot 10^{+143}:\\
\;\;\;\;t \cdot \frac{y}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -8.99999999999999959e160 or 4.89999999999999986e143 < 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.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 < 1.35000000000000006e-48Initial 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 1.35000000000000006e-48 < z < 4.89999999999999986e143Initial 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 -9e+160)
t
(if (<= z -1.3e-183)
t_1
(if (<= z 5e-100) (/ (* 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 <= -9e+160) {
tmp = t;
} else if (z <= -1.3e-183) {
tmp = t_1;
} else if (z <= 5e-100) {
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 <= -9e+160) tmp = t; elseif (z <= -1.3e-183) tmp = t_1; elseif (z <= 5e-100) 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, -9e+160], t, If[LessEqual[z, -1.3e-183], t$95$1, If[LessEqual[z, 5e-100], 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 -9 \cdot 10^{+160}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq -1.3 \cdot 10^{-183}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;z \leq 5 \cdot 10^{-100}:\\
\;\;\;\;\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 < -8.99999999999999959e160 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 -8.99999999999999959e160 < z < -1.2999999999999999e-183 or 5.0000000000000001e-100 < 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.2999999999999999e-183 < z < 5.0000000000000001e-100Initial 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 -9e+160)
t
(if (<= z -1.06e-154)
(* x (/ (- y a) z))
(if (<= z 4.9e+143) (* y (/ t (- 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.06e-154) {
tmp = x * ((y - a) / z);
} else if (z <= 4.9e+143) {
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 <= (-9d+160)) then
tmp = t
else if (z <= (-1.06d-154)) then
tmp = x * ((y - a) / z)
else if (z <= 4.9d+143) 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 <= -9e+160) {
tmp = t;
} else if (z <= -1.06e-154) {
tmp = x * ((y - a) / z);
} else if (z <= 4.9e+143) {
tmp = y * (t / (a - z));
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -9e+160: tmp = t elif z <= -1.06e-154: tmp = x * ((y - a) / z) elif z <= 4.9e+143: tmp = y * (t / (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.06e-154) tmp = Float64(x * Float64(Float64(y - a) / z)); elseif (z <= 4.9e+143) 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 <= -9e+160) tmp = t; elseif (z <= -1.06e-154) tmp = x * ((y - a) / z); elseif (z <= 4.9e+143) tmp = y * (t / (a - z)); else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -9e+160], t, If[LessEqual[z, -1.06e-154], N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4.9e+143], N[(y * N[(t / 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.06 \cdot 10^{-154}:\\
\;\;\;\;x \cdot \frac{y - a}{z}\\
\mathbf{elif}\;z \leq 4.9 \cdot 10^{+143}:\\
\;\;\;\;y \cdot \frac{t}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -8.99999999999999959e160 or 4.89999999999999986e143 < 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.06e-154Initial 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-154 < z < 4.89999999999999986e143Initial 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 -9e+160)
t
(if (<= z -1.6e-152)
(* x (/ (- y a) z))
(if (<= z 4.9e+143) (* 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.6e-152) {
tmp = x * ((y - a) / z);
} else if (z <= 4.9e+143) {
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 <= (-9d+160)) then
tmp = t
else if (z <= (-1.6d-152)) then
tmp = x * ((y - a) / z)
else if (z <= 4.9d+143) 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 <= -9e+160) {
tmp = t;
} else if (z <= -1.6e-152) {
tmp = x * ((y - a) / z);
} else if (z <= 4.9e+143) {
tmp = t * (y / (a - z));
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -9e+160: tmp = t elif z <= -1.6e-152: tmp = x * ((y - a) / z) elif z <= 4.9e+143: 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.6e-152) tmp = Float64(x * Float64(Float64(y - a) / z)); elseif (z <= 4.9e+143) 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 <= -9e+160) tmp = t; elseif (z <= -1.6e-152) tmp = x * ((y - a) / z); elseif (z <= 4.9e+143) tmp = t * (y / (a - z)); else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -9e+160], t, If[LessEqual[z, -1.6e-152], N[(x * N[(N[(y - a), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 4.9e+143], 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.6 \cdot 10^{-152}:\\
\;\;\;\;x \cdot \frac{y - a}{z}\\
\mathbf{elif}\;z \leq 4.9 \cdot 10^{+143}:\\
\;\;\;\;t \cdot \frac{y}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -8.99999999999999959e160 or 4.89999999999999986e143 < 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.60000000000000006e-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 -1.60000000000000006e-152 < z < 4.89999999999999986e143Initial 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 -4.5e-153)
(fma x (/ y z) 0.0)
(if (<= z 4.9e+143) (* 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 <= -4.5e-153) {
tmp = fma(x, (y / z), 0.0);
} else if (z <= 4.9e+143) {
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 <= -4.5e-153) tmp = fma(x, Float64(y / z), 0.0); elseif (z <= 4.9e+143) 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, -4.5e-153], N[(x * N[(y / z), $MachinePrecision] + 0.0), $MachinePrecision], If[LessEqual[z, 4.9e+143], 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 -4.5 \cdot 10^{-153}:\\
\;\;\;\;\mathsf{fma}\left(x, \frac{y}{z}, 0\right)\\
\mathbf{elif}\;z \leq 4.9 \cdot 10^{+143}:\\
\;\;\;\;t \cdot \frac{y}{a - z}\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -8.99999999999999959e160 or 4.89999999999999986e143 < 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 < -4.5e-153Initial 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 -4.5e-153 < z < 4.89999999999999986e143Initial 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 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 + ((y / z) * (x - t));
double tmp;
if (z <= -1.25e+153) {
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(y / z) * Float64(x - t))) tmp = 0.0 if (z <= -1.25e+153) 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[(y / z), $MachinePrecision] * N[(x - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -1.25e+153], 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 + \frac{y}{z} \cdot \left(x - t\right)\\
\mathbf{if}\;z \leq -1.25 \cdot 10^{+153}:\\
\;\;\;\;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.25000000000000005e153 or 5.3000000000000002e116 < 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.3000000000000002e116Initial 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 -6.5e-116)
(fma (- y z) (/ t (- a z)) x)
(if (<= a 4.9e-110)
(+ 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 <= -6.5e-116) {
tmp = fma((y - z), (t / (a - z)), x);
} else if (a <= 4.9e-110) {
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 <= -6.5e-116) tmp = fma(Float64(y - z), Float64(t / Float64(a - z)), x); elseif (a <= 4.9e-110) 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, -6.5e-116], N[(N[(y - z), $MachinePrecision] * N[(t / N[(a - z), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[a, 4.9e-110], 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 -6.5 \cdot 10^{-116}:\\
\;\;\;\;\mathsf{fma}\left(y - z, \frac{t}{a - z}, x\right)\\
\mathbf{elif}\;a \leq 4.9 \cdot 10^{-110}:\\
\;\;\;\;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 < -6.5000000000000001e-116Initial 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 -6.5000000000000001e-116 < a < 4.8999999999999997e-110Initial 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 4.8999999999999997e-110 < 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 -6.5e-116)
t_1
(if (<= a 2.9e-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 <= -6.5e-116) {
tmp = t_1;
} else if (a <= 2.9e-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 <= -6.5e-116) tmp = t_1; elseif (a <= 2.9e-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, -6.5e-116], t$95$1, If[LessEqual[a, 2.9e-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 -6.5 \cdot 10^{-116}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 2.9 \cdot 10^{-32}:\\
\;\;\;\;t + \frac{y}{z} \cdot \left(x - t\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if a < -6.5000000000000001e-116 or 2.89999999999999996e-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 -6.5000000000000001e-116 < a < 2.89999999999999996e-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 -1.9e-69)
t_1
(if (<= a 4.9e-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 <= -1.9e-69) {
tmp = t_1;
} else if (a <= 4.9e-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 <= -1.9e-69) tmp = t_1; elseif (a <= 4.9e-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, -1.9e-69], t$95$1, If[LessEqual[a, 4.9e-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 -1.9 \cdot 10^{-69}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;a \leq 4.9 \cdot 10^{-110}:\\
\;\;\;\;t + \frac{y}{z} \cdot \left(x - t\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if a < -1.8999999999999999e-69 or 4.8999999999999997e-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 -1.8999999999999999e-69 < a < 4.8999999999999997e-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 8e+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 <= 8e+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 <= 8e+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, 8e+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 8 \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 8.00000000000000012e116 < 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 < 8.00000000000000012e116Initial 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 8e+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 <= 8e+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 <= 8e+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, 8e+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 8 \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 8.00000000000000012e116 < 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 < 8.00000000000000012e116Initial 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 5.3e+116) (fma (- x) (/ y 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 <= 5.3e+116) {
tmp = fma(-x, (y / 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 <= 5.3e+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, -9e+171], t, If[LessEqual[z, 5.3e+116], N[((-x) * N[(y / 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.3 \cdot 10^{+116}:\\
\;\;\;\;\mathsf{fma}\left(-x, \frac{y}{a}, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -8.99999999999999937e171 or 5.3000000000000002e116 < 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.3000000000000002e116Initial 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 -3.7e-31) t (if (<= z 1.35e-10) (/ (* y t) a) t)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -3.7e-31) {
tmp = t;
} else if (z <= 1.35e-10) {
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 <= (-3.7d-31)) then
tmp = t
else if (z <= 1.35d-10) 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 <= -3.7e-31) {
tmp = t;
} else if (z <= 1.35e-10) {
tmp = (y * t) / a;
} else {
tmp = t;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -3.7e-31: tmp = t elif z <= 1.35e-10: tmp = (y * t) / a else: tmp = t return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -3.7e-31) tmp = t; elseif (z <= 1.35e-10) 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 <= -3.7e-31) tmp = t; elseif (z <= 1.35e-10) tmp = (y * t) / a; else tmp = t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -3.7e-31], t, If[LessEqual[z, 1.35e-10], N[(N[(y * t), $MachinePrecision] / a), $MachinePrecision], t]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -3.7 \cdot 10^{-31}:\\
\;\;\;\;t\\
\mathbf{elif}\;z \leq 1.35 \cdot 10^{-10}:\\
\;\;\;\;\frac{y \cdot t}{a}\\
\mathbf{else}:\\
\;\;\;\;t\\
\end{array}
\end{array}
if z < -3.6999999999999998e-31 or 1.35e-10 < 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 -3.6999999999999998e-31 < z < 1.35e-10Initial 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)))))