
(FPCore (x y z t a) :precision binary64 (+ x (* y (/ (- z t) (- z a)))))
double code(double x, double y, double z, double t, double a) {
return x + (y * ((z - t) / (z - a)));
}
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) / (z - a)))
end function
public static double code(double x, double y, double z, double t, double a) {
return x + (y * ((z - t) / (z - a)));
}
def code(x, y, z, t, a): return x + (y * ((z - t) / (z - a)))
function code(x, y, z, t, a) return Float64(x + Float64(y * Float64(Float64(z - t) / Float64(z - a)))) end
function tmp = code(x, y, z, t, a) tmp = x + (y * ((z - t) / (z - a))); end
code[x_, y_, z_, t_, a_] := N[(x + N[(y * N[(N[(z - t), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + y \cdot \frac{z - t}{z - a}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 11 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a) :precision binary64 (+ x (* y (/ (- z t) (- z a)))))
double code(double x, double y, double z, double t, double a) {
return x + (y * ((z - t) / (z - a)));
}
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) / (z - a)))
end function
public static double code(double x, double y, double z, double t, double a) {
return x + (y * ((z - t) / (z - a)));
}
def code(x, y, z, t, a): return x + (y * ((z - t) / (z - a)))
function code(x, y, z, t, a) return Float64(x + Float64(y * Float64(Float64(z - t) / Float64(z - a)))) end
function tmp = code(x, y, z, t, a) tmp = x + (y * ((z - t) / (z - a))); end
code[x_, y_, z_, t_, a_] := N[(x + N[(y * N[(N[(z - t), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + y \cdot \frac{z - t}{z - a}
\end{array}
(FPCore (x y z t a) :precision binary64 (- x (* (/ (- t z) (- z a)) y)))
double code(double x, double y, double z, double t, double a) {
return x - (((t - z) / (z - a)) * y);
}
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 - (((t - z) / (z - a)) * y)
end function
public static double code(double x, double y, double z, double t, double a) {
return x - (((t - z) / (z - a)) * y);
}
def code(x, y, z, t, a): return x - (((t - z) / (z - a)) * y)
function code(x, y, z, t, a) return Float64(x - Float64(Float64(Float64(t - z) / Float64(z - a)) * y)) end
function tmp = code(x, y, z, t, a) tmp = x - (((t - z) / (z - a)) * y); end
code[x_, y_, z_, t_, a_] := N[(x - N[(N[(N[(t - z), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x - \frac{t - z}{z - a} \cdot y
\end{array}
Initial program 98.0%
Final simplification98.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ (- t z) (- a z))))
(if (<= t_1 -2e+50)
(* (/ y (- a z)) t)
(if (<= t_1 2e-10)
(fma (/ t a) y x)
(if (<= t_1 45000.0)
(+ y x)
(if (<= t_1 2e+110) (fma (/ (- t) z) y x) (/ (* t y) (- a z))))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (t - z) / (a - z);
double tmp;
if (t_1 <= -2e+50) {
tmp = (y / (a - z)) * t;
} else if (t_1 <= 2e-10) {
tmp = fma((t / a), y, x);
} else if (t_1 <= 45000.0) {
tmp = y + x;
} else if (t_1 <= 2e+110) {
tmp = fma((-t / z), y, x);
} else {
tmp = (t * y) / (a - z);
}
return tmp;
}
function code(x, y, z, t, a) t_1 = Float64(Float64(t - z) / Float64(a - z)) tmp = 0.0 if (t_1 <= -2e+50) tmp = Float64(Float64(y / Float64(a - z)) * t); elseif (t_1 <= 2e-10) tmp = fma(Float64(t / a), y, x); elseif (t_1 <= 45000.0) tmp = Float64(y + x); elseif (t_1 <= 2e+110) tmp = fma(Float64(Float64(-t) / z), y, x); else tmp = Float64(Float64(t * y) / Float64(a - z)); end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(t - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -2e+50], N[(N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[t$95$1, 2e-10], N[(N[(t / a), $MachinePrecision] * y + x), $MachinePrecision], If[LessEqual[t$95$1, 45000.0], N[(y + x), $MachinePrecision], If[LessEqual[t$95$1, 2e+110], N[(N[((-t) / z), $MachinePrecision] * y + x), $MachinePrecision], N[(N[(t * y), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{t - z}{a - z}\\
\mathbf{if}\;t\_1 \leq -2 \cdot 10^{+50}:\\
\;\;\;\;\frac{y}{a - z} \cdot t\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{-10}:\\
\;\;\;\;\mathsf{fma}\left(\frac{t}{a}, y, x\right)\\
\mathbf{elif}\;t\_1 \leq 45000:\\
\;\;\;\;y + x\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+110}:\\
\;\;\;\;\mathsf{fma}\left(\frac{-t}{z}, y, x\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{t \cdot y}{a - z}\\
\end{array}
\end{array}
if (/.f64 (-.f64 z t) (-.f64 z a)) < -2.0000000000000002e50Initial program 97.4%
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
frac-2negN/A
lower-/.f64N/A
neg-sub0N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
associate--r+N/A
neg-sub0N/A
remove-double-negN/A
lower--.f64N/A
neg-sub0N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
associate--r+N/A
neg-sub0N/A
remove-double-negN/A
lower--.f6497.5
Applied rewrites97.5%
Taylor expanded in t around inf
*-commutativeN/A
associate-*l/N/A
lower-*.f64N/A
lower-/.f64N/A
lower--.f6480.4
Applied rewrites80.4%
if -2.0000000000000002e50 < (/.f64 (-.f64 z t) (-.f64 z a)) < 2.00000000000000007e-10Initial program 99.9%
Taylor expanded in z around 0
lower-/.f6484.1
Applied rewrites84.1%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6484.1
Applied rewrites84.1%
if 2.00000000000000007e-10 < (/.f64 (-.f64 z t) (-.f64 z a)) < 45000Initial program 99.9%
Taylor expanded in z around inf
+-commutativeN/A
lower-+.f6496.7
Applied rewrites96.7%
if 45000 < (/.f64 (-.f64 z t) (-.f64 z a)) < 2e110Initial program 99.9%
Taylor expanded in a around 0
+-commutativeN/A
associate-/l*N/A
*-commutativeN/A
div-subN/A
sub-negN/A
*-inversesN/A
mul-1-negN/A
lower-fma.f64N/A
*-inversesN/A
mul-1-negN/A
sub-negN/A
div-subN/A
lower-/.f64N/A
lower--.f6486.9
Applied rewrites86.9%
Taylor expanded in t around inf
Applied rewrites86.4%
if 2e110 < (/.f64 (-.f64 z t) (-.f64 z a)) Initial program 83.1%
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
frac-2negN/A
lower-/.f64N/A
neg-sub0N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
associate--r+N/A
neg-sub0N/A
remove-double-negN/A
lower--.f64N/A
neg-sub0N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
associate--r+N/A
neg-sub0N/A
remove-double-negN/A
lower--.f6483.2
Applied rewrites83.2%
Taylor expanded in t around inf
*-commutativeN/A
associate-*l/N/A
lower-*.f64N/A
lower-/.f64N/A
lower--.f6478.3
Applied rewrites78.3%
Applied rewrites78.4%
Final simplification86.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ (- t z) (- a z))) (t_2 (* (/ y (- a z)) t)))
(if (<= t_1 -2e+50)
t_2
(if (<= t_1 2e-10)
(fma (/ t a) y x)
(if (<= t_1 45000.0)
(+ y x)
(if (<= t_1 2e+110) (fma (/ (- t) z) y x) t_2))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (t - z) / (a - z);
double t_2 = (y / (a - z)) * t;
double tmp;
if (t_1 <= -2e+50) {
tmp = t_2;
} else if (t_1 <= 2e-10) {
tmp = fma((t / a), y, x);
} else if (t_1 <= 45000.0) {
tmp = y + x;
} else if (t_1 <= 2e+110) {
tmp = fma((-t / z), y, x);
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = Float64(Float64(t - z) / Float64(a - z)) t_2 = Float64(Float64(y / Float64(a - z)) * t) tmp = 0.0 if (t_1 <= -2e+50) tmp = t_2; elseif (t_1 <= 2e-10) tmp = fma(Float64(t / a), y, x); elseif (t_1 <= 45000.0) tmp = Float64(y + x); elseif (t_1 <= 2e+110) tmp = fma(Float64(Float64(-t) / z), y, x); else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(t - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]}, If[LessEqual[t$95$1, -2e+50], t$95$2, If[LessEqual[t$95$1, 2e-10], N[(N[(t / a), $MachinePrecision] * y + x), $MachinePrecision], If[LessEqual[t$95$1, 45000.0], N[(y + x), $MachinePrecision], If[LessEqual[t$95$1, 2e+110], N[(N[((-t) / z), $MachinePrecision] * y + x), $MachinePrecision], t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{t - z}{a - z}\\
t_2 := \frac{y}{a - z} \cdot t\\
\mathbf{if}\;t\_1 \leq -2 \cdot 10^{+50}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{-10}:\\
\;\;\;\;\mathsf{fma}\left(\frac{t}{a}, y, x\right)\\
\mathbf{elif}\;t\_1 \leq 45000:\\
\;\;\;\;y + x\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+110}:\\
\;\;\;\;\mathsf{fma}\left(\frac{-t}{z}, y, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if (/.f64 (-.f64 z t) (-.f64 z a)) < -2.0000000000000002e50 or 2e110 < (/.f64 (-.f64 z t) (-.f64 z a)) Initial program 92.2%
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
frac-2negN/A
lower-/.f64N/A
neg-sub0N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
associate--r+N/A
neg-sub0N/A
remove-double-negN/A
lower--.f64N/A
neg-sub0N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
associate--r+N/A
neg-sub0N/A
remove-double-negN/A
lower--.f6492.3
Applied rewrites92.3%
Taylor expanded in t around inf
*-commutativeN/A
associate-*l/N/A
lower-*.f64N/A
lower-/.f64N/A
lower--.f6479.6
Applied rewrites79.6%
if -2.0000000000000002e50 < (/.f64 (-.f64 z t) (-.f64 z a)) < 2.00000000000000007e-10Initial program 99.9%
Taylor expanded in z around 0
lower-/.f6484.1
Applied rewrites84.1%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6484.1
Applied rewrites84.1%
if 2.00000000000000007e-10 < (/.f64 (-.f64 z t) (-.f64 z a)) < 45000Initial program 99.9%
Taylor expanded in z around inf
+-commutativeN/A
lower-+.f6496.7
Applied rewrites96.7%
if 45000 < (/.f64 (-.f64 z t) (-.f64 z a)) < 2e110Initial program 99.9%
Taylor expanded in a around 0
+-commutativeN/A
associate-/l*N/A
*-commutativeN/A
div-subN/A
sub-negN/A
*-inversesN/A
mul-1-negN/A
lower-fma.f64N/A
*-inversesN/A
mul-1-negN/A
sub-negN/A
div-subN/A
lower-/.f64N/A
lower--.f6486.9
Applied rewrites86.9%
Taylor expanded in t around inf
Applied rewrites86.4%
Final simplification86.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ (- t z) (- a z))))
(if (<= t_1 -2e+50)
(* (/ t (- a z)) y)
(if (<= t_1 2e-10)
(fma (- t z) (/ y a) x)
(if (<= t_1 2e+110) (fma (- 1.0 (/ t z)) y x) (/ (* t y) (- a z)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (t - z) / (a - z);
double tmp;
if (t_1 <= -2e+50) {
tmp = (t / (a - z)) * y;
} else if (t_1 <= 2e-10) {
tmp = fma((t - z), (y / a), x);
} else if (t_1 <= 2e+110) {
tmp = fma((1.0 - (t / z)), y, x);
} else {
tmp = (t * y) / (a - z);
}
return tmp;
}
function code(x, y, z, t, a) t_1 = Float64(Float64(t - z) / Float64(a - z)) tmp = 0.0 if (t_1 <= -2e+50) tmp = Float64(Float64(t / Float64(a - z)) * y); elseif (t_1 <= 2e-10) tmp = fma(Float64(t - z), Float64(y / a), x); elseif (t_1 <= 2e+110) tmp = fma(Float64(1.0 - Float64(t / z)), y, x); else tmp = Float64(Float64(t * y) / Float64(a - z)); end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(t - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -2e+50], N[(N[(t / N[(a - z), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision], If[LessEqual[t$95$1, 2e-10], N[(N[(t - z), $MachinePrecision] * N[(y / a), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[t$95$1, 2e+110], N[(N[(1.0 - N[(t / z), $MachinePrecision]), $MachinePrecision] * y + x), $MachinePrecision], N[(N[(t * y), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{t - z}{a - z}\\
\mathbf{if}\;t\_1 \leq -2 \cdot 10^{+50}:\\
\;\;\;\;\frac{t}{a - z} \cdot y\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{-10}:\\
\;\;\;\;\mathsf{fma}\left(t - z, \frac{y}{a}, x\right)\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+110}:\\
\;\;\;\;\mathsf{fma}\left(1 - \frac{t}{z}, y, x\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{t \cdot y}{a - z}\\
\end{array}
\end{array}
if (/.f64 (-.f64 z t) (-.f64 z a)) < -2.0000000000000002e50Initial program 97.4%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
associate-/l*N/A
distribute-lft-neg-inN/A
neg-mul-1N/A
lower-*.f64N/A
neg-mul-1N/A
lower-neg.f64N/A
lower-/.f64N/A
lower--.f6480.4
Applied rewrites80.4%
if -2.0000000000000002e50 < (/.f64 (-.f64 z t) (-.f64 z a)) < 2.00000000000000007e-10Initial program 99.9%
Taylor expanded in a around inf
+-commutativeN/A
mul-1-negN/A
*-commutativeN/A
associate-/l*N/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
lower--.f64N/A
lower-/.f6493.8
Applied rewrites93.8%
if 2.00000000000000007e-10 < (/.f64 (-.f64 z t) (-.f64 z a)) < 2e110Initial program 99.9%
Taylor expanded in a around 0
+-commutativeN/A
associate-/l*N/A
*-commutativeN/A
div-subN/A
sub-negN/A
*-inversesN/A
mul-1-negN/A
lower-fma.f64N/A
*-inversesN/A
mul-1-negN/A
sub-negN/A
div-subN/A
lower-/.f64N/A
lower--.f6495.6
Applied rewrites95.6%
Applied rewrites95.6%
if 2e110 < (/.f64 (-.f64 z t) (-.f64 z a)) Initial program 83.1%
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
frac-2negN/A
lower-/.f64N/A
neg-sub0N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
associate--r+N/A
neg-sub0N/A
remove-double-negN/A
lower--.f64N/A
neg-sub0N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
associate--r+N/A
neg-sub0N/A
remove-double-negN/A
lower--.f6483.2
Applied rewrites83.2%
Taylor expanded in t around inf
*-commutativeN/A
associate-*l/N/A
lower-*.f64N/A
lower-/.f64N/A
lower--.f6478.3
Applied rewrites78.3%
Applied rewrites78.4%
Final simplification91.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ (- t z) (- a z))))
(if (<= t_1 -2e+50)
(* (/ y (- a z)) t)
(if (<= t_1 2e-10)
(fma (- t z) (/ y a) x)
(if (<= t_1 2e+110) (fma (- 1.0 (/ t z)) y x) (/ (* t y) (- a z)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (t - z) / (a - z);
double tmp;
if (t_1 <= -2e+50) {
tmp = (y / (a - z)) * t;
} else if (t_1 <= 2e-10) {
tmp = fma((t - z), (y / a), x);
} else if (t_1 <= 2e+110) {
tmp = fma((1.0 - (t / z)), y, x);
} else {
tmp = (t * y) / (a - z);
}
return tmp;
}
function code(x, y, z, t, a) t_1 = Float64(Float64(t - z) / Float64(a - z)) tmp = 0.0 if (t_1 <= -2e+50) tmp = Float64(Float64(y / Float64(a - z)) * t); elseif (t_1 <= 2e-10) tmp = fma(Float64(t - z), Float64(y / a), x); elseif (t_1 <= 2e+110) tmp = fma(Float64(1.0 - Float64(t / z)), y, x); else tmp = Float64(Float64(t * y) / Float64(a - z)); end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(t - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -2e+50], N[(N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[t$95$1, 2e-10], N[(N[(t - z), $MachinePrecision] * N[(y / a), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[t$95$1, 2e+110], N[(N[(1.0 - N[(t / z), $MachinePrecision]), $MachinePrecision] * y + x), $MachinePrecision], N[(N[(t * y), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{t - z}{a - z}\\
\mathbf{if}\;t\_1 \leq -2 \cdot 10^{+50}:\\
\;\;\;\;\frac{y}{a - z} \cdot t\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{-10}:\\
\;\;\;\;\mathsf{fma}\left(t - z, \frac{y}{a}, x\right)\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+110}:\\
\;\;\;\;\mathsf{fma}\left(1 - \frac{t}{z}, y, x\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{t \cdot y}{a - z}\\
\end{array}
\end{array}
if (/.f64 (-.f64 z t) (-.f64 z a)) < -2.0000000000000002e50Initial program 97.4%
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
frac-2negN/A
lower-/.f64N/A
neg-sub0N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
associate--r+N/A
neg-sub0N/A
remove-double-negN/A
lower--.f64N/A
neg-sub0N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
associate--r+N/A
neg-sub0N/A
remove-double-negN/A
lower--.f6497.5
Applied rewrites97.5%
Taylor expanded in t around inf
*-commutativeN/A
associate-*l/N/A
lower-*.f64N/A
lower-/.f64N/A
lower--.f6480.4
Applied rewrites80.4%
if -2.0000000000000002e50 < (/.f64 (-.f64 z t) (-.f64 z a)) < 2.00000000000000007e-10Initial program 99.9%
Taylor expanded in a around inf
+-commutativeN/A
mul-1-negN/A
*-commutativeN/A
associate-/l*N/A
distribute-lft-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
sub-negN/A
+-commutativeN/A
distribute-neg-inN/A
unsub-negN/A
remove-double-negN/A
lower--.f64N/A
lower-/.f6493.8
Applied rewrites93.8%
if 2.00000000000000007e-10 < (/.f64 (-.f64 z t) (-.f64 z a)) < 2e110Initial program 99.9%
Taylor expanded in a around 0
+-commutativeN/A
associate-/l*N/A
*-commutativeN/A
div-subN/A
sub-negN/A
*-inversesN/A
mul-1-negN/A
lower-fma.f64N/A
*-inversesN/A
mul-1-negN/A
sub-negN/A
div-subN/A
lower-/.f64N/A
lower--.f6495.6
Applied rewrites95.6%
Applied rewrites95.6%
if 2e110 < (/.f64 (-.f64 z t) (-.f64 z a)) Initial program 83.1%
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
frac-2negN/A
lower-/.f64N/A
neg-sub0N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
associate--r+N/A
neg-sub0N/A
remove-double-negN/A
lower--.f64N/A
neg-sub0N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
associate--r+N/A
neg-sub0N/A
remove-double-negN/A
lower--.f6483.2
Applied rewrites83.2%
Taylor expanded in t around inf
*-commutativeN/A
associate-*l/N/A
lower-*.f64N/A
lower-/.f64N/A
lower--.f6478.3
Applied rewrites78.3%
Applied rewrites78.4%
Final simplification91.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ (- t z) (- a z))))
(if (<= t_1 -2e+50)
(* (/ y (- a z)) t)
(if (<= t_1 2e-10)
(fma (/ t a) y x)
(if (<= t_1 2e+110) (fma (- 1.0 (/ t z)) y x) (/ (* t y) (- a z)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (t - z) / (a - z);
double tmp;
if (t_1 <= -2e+50) {
tmp = (y / (a - z)) * t;
} else if (t_1 <= 2e-10) {
tmp = fma((t / a), y, x);
} else if (t_1 <= 2e+110) {
tmp = fma((1.0 - (t / z)), y, x);
} else {
tmp = (t * y) / (a - z);
}
return tmp;
}
function code(x, y, z, t, a) t_1 = Float64(Float64(t - z) / Float64(a - z)) tmp = 0.0 if (t_1 <= -2e+50) tmp = Float64(Float64(y / Float64(a - z)) * t); elseif (t_1 <= 2e-10) tmp = fma(Float64(t / a), y, x); elseif (t_1 <= 2e+110) tmp = fma(Float64(1.0 - Float64(t / z)), y, x); else tmp = Float64(Float64(t * y) / Float64(a - z)); end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(t - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -2e+50], N[(N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[t$95$1, 2e-10], N[(N[(t / a), $MachinePrecision] * y + x), $MachinePrecision], If[LessEqual[t$95$1, 2e+110], N[(N[(1.0 - N[(t / z), $MachinePrecision]), $MachinePrecision] * y + x), $MachinePrecision], N[(N[(t * y), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{t - z}{a - z}\\
\mathbf{if}\;t\_1 \leq -2 \cdot 10^{+50}:\\
\;\;\;\;\frac{y}{a - z} \cdot t\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{-10}:\\
\;\;\;\;\mathsf{fma}\left(\frac{t}{a}, y, x\right)\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+110}:\\
\;\;\;\;\mathsf{fma}\left(1 - \frac{t}{z}, y, x\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{t \cdot y}{a - z}\\
\end{array}
\end{array}
if (/.f64 (-.f64 z t) (-.f64 z a)) < -2.0000000000000002e50Initial program 97.4%
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
frac-2negN/A
lower-/.f64N/A
neg-sub0N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
associate--r+N/A
neg-sub0N/A
remove-double-negN/A
lower--.f64N/A
neg-sub0N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
associate--r+N/A
neg-sub0N/A
remove-double-negN/A
lower--.f6497.5
Applied rewrites97.5%
Taylor expanded in t around inf
*-commutativeN/A
associate-*l/N/A
lower-*.f64N/A
lower-/.f64N/A
lower--.f6480.4
Applied rewrites80.4%
if -2.0000000000000002e50 < (/.f64 (-.f64 z t) (-.f64 z a)) < 2.00000000000000007e-10Initial program 99.9%
Taylor expanded in z around 0
lower-/.f6484.1
Applied rewrites84.1%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6484.1
Applied rewrites84.1%
if 2.00000000000000007e-10 < (/.f64 (-.f64 z t) (-.f64 z a)) < 2e110Initial program 99.9%
Taylor expanded in a around 0
+-commutativeN/A
associate-/l*N/A
*-commutativeN/A
div-subN/A
sub-negN/A
*-inversesN/A
mul-1-negN/A
lower-fma.f64N/A
*-inversesN/A
mul-1-negN/A
sub-negN/A
div-subN/A
lower-/.f64N/A
lower--.f6495.6
Applied rewrites95.6%
Applied rewrites95.6%
if 2e110 < (/.f64 (-.f64 z t) (-.f64 z a)) Initial program 83.1%
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
frac-2negN/A
lower-/.f64N/A
neg-sub0N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
associate--r+N/A
neg-sub0N/A
remove-double-negN/A
lower--.f64N/A
neg-sub0N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
associate--r+N/A
neg-sub0N/A
remove-double-negN/A
lower--.f6483.2
Applied rewrites83.2%
Taylor expanded in t around inf
*-commutativeN/A
associate-*l/N/A
lower-*.f64N/A
lower-/.f64N/A
lower--.f6478.3
Applied rewrites78.3%
Applied rewrites78.4%
Final simplification87.2%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ (- t z) (- a z))) (t_2 (fma (/ y a) t x)))
(if (<= t_1 2e-10)
t_2
(if (<= t_1 45000.0)
(+ y x)
(if (<= t_1 2e+110) (fma (/ (- t) z) y x) t_2)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (t - z) / (a - z);
double t_2 = fma((y / a), t, x);
double tmp;
if (t_1 <= 2e-10) {
tmp = t_2;
} else if (t_1 <= 45000.0) {
tmp = y + x;
} else if (t_1 <= 2e+110) {
tmp = fma((-t / z), y, x);
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = Float64(Float64(t - z) / Float64(a - z)) t_2 = fma(Float64(y / a), t, x) tmp = 0.0 if (t_1 <= 2e-10) tmp = t_2; elseif (t_1 <= 45000.0) tmp = Float64(y + x); elseif (t_1 <= 2e+110) tmp = fma(Float64(Float64(-t) / z), y, x); else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(t - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(y / a), $MachinePrecision] * t + x), $MachinePrecision]}, If[LessEqual[t$95$1, 2e-10], t$95$2, If[LessEqual[t$95$1, 45000.0], N[(y + x), $MachinePrecision], If[LessEqual[t$95$1, 2e+110], N[(N[((-t) / z), $MachinePrecision] * y + x), $MachinePrecision], t$95$2]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{t - z}{a - z}\\
t_2 := \mathsf{fma}\left(\frac{y}{a}, t, x\right)\\
\mathbf{if}\;t\_1 \leq 2 \cdot 10^{-10}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_1 \leq 45000:\\
\;\;\;\;y + x\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+110}:\\
\;\;\;\;\mathsf{fma}\left(\frac{-t}{z}, y, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if (/.f64 (-.f64 z t) (-.f64 z a)) < 2.00000000000000007e-10 or 2e110 < (/.f64 (-.f64 z t) (-.f64 z a)) Initial program 96.9%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-/.f6478.0
Applied rewrites78.0%
if 2.00000000000000007e-10 < (/.f64 (-.f64 z t) (-.f64 z a)) < 45000Initial program 99.9%
Taylor expanded in z around inf
+-commutativeN/A
lower-+.f6496.7
Applied rewrites96.7%
if 45000 < (/.f64 (-.f64 z t) (-.f64 z a)) < 2e110Initial program 99.9%
Taylor expanded in a around 0
+-commutativeN/A
associate-/l*N/A
*-commutativeN/A
div-subN/A
sub-negN/A
*-inversesN/A
mul-1-negN/A
lower-fma.f64N/A
*-inversesN/A
mul-1-negN/A
sub-negN/A
div-subN/A
lower-/.f64N/A
lower--.f6486.9
Applied rewrites86.9%
Taylor expanded in t around inf
Applied rewrites86.4%
Final simplification84.1%
(FPCore (x y z t a) :precision binary64 (let* ((t_1 (/ (- t z) (- a z))) (t_2 (fma (/ y a) t x))) (if (<= t_1 2e-10) t_2 (if (<= t_1 2e+110) (+ y x) t_2))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (t - z) / (a - z);
double t_2 = fma((y / a), t, x);
double tmp;
if (t_1 <= 2e-10) {
tmp = t_2;
} else if (t_1 <= 2e+110) {
tmp = y + x;
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = Float64(Float64(t - z) / Float64(a - z)) t_2 = fma(Float64(y / a), t, x) tmp = 0.0 if (t_1 <= 2e-10) tmp = t_2; elseif (t_1 <= 2e+110) tmp = Float64(y + x); else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(t - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(y / a), $MachinePrecision] * t + x), $MachinePrecision]}, If[LessEqual[t$95$1, 2e-10], t$95$2, If[LessEqual[t$95$1, 2e+110], N[(y + x), $MachinePrecision], t$95$2]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{t - z}{a - z}\\
t_2 := \mathsf{fma}\left(\frac{y}{a}, t, x\right)\\
\mathbf{if}\;t\_1 \leq 2 \cdot 10^{-10}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+110}:\\
\;\;\;\;y + x\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if (/.f64 (-.f64 z t) (-.f64 z a)) < 2.00000000000000007e-10 or 2e110 < (/.f64 (-.f64 z t) (-.f64 z a)) Initial program 96.9%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-/.f6478.0
Applied rewrites78.0%
if 2.00000000000000007e-10 < (/.f64 (-.f64 z t) (-.f64 z a)) < 2e110Initial program 99.9%
Taylor expanded in z around inf
+-commutativeN/A
lower-+.f6488.6
Applied rewrites88.6%
Final simplification81.9%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ (- t z) (- a z))))
(if (<= t_1 -5e+46)
(* (/ y a) t)
(if (<= t_1 2e+110) (+ y x) (/ (* t y) a)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (t - z) / (a - z);
double tmp;
if (t_1 <= -5e+46) {
tmp = (y / a) * t;
} else if (t_1 <= 2e+110) {
tmp = y + x;
} else {
tmp = (t * y) / a;
}
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) :: t_1
real(8) :: tmp
t_1 = (t - z) / (a - z)
if (t_1 <= (-5d+46)) then
tmp = (y / a) * t
else if (t_1 <= 2d+110) then
tmp = y + x
else
tmp = (t * y) / a
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = (t - z) / (a - z);
double tmp;
if (t_1 <= -5e+46) {
tmp = (y / a) * t;
} else if (t_1 <= 2e+110) {
tmp = y + x;
} else {
tmp = (t * y) / a;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = (t - z) / (a - z) tmp = 0 if t_1 <= -5e+46: tmp = (y / a) * t elif t_1 <= 2e+110: tmp = y + x else: tmp = (t * y) / a return tmp
function code(x, y, z, t, a) t_1 = Float64(Float64(t - z) / Float64(a - z)) tmp = 0.0 if (t_1 <= -5e+46) tmp = Float64(Float64(y / a) * t); elseif (t_1 <= 2e+110) tmp = Float64(y + x); else tmp = Float64(Float64(t * y) / a); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = (t - z) / (a - z); tmp = 0.0; if (t_1 <= -5e+46) tmp = (y / a) * t; elseif (t_1 <= 2e+110) tmp = y + x; else tmp = (t * y) / a; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(t - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -5e+46], N[(N[(y / a), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[t$95$1, 2e+110], N[(y + x), $MachinePrecision], N[(N[(t * y), $MachinePrecision] / a), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{t - z}{a - z}\\
\mathbf{if}\;t\_1 \leq -5 \cdot 10^{+46}:\\
\;\;\;\;\frac{y}{a} \cdot t\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+110}:\\
\;\;\;\;y + x\\
\mathbf{else}:\\
\;\;\;\;\frac{t \cdot y}{a}\\
\end{array}
\end{array}
if (/.f64 (-.f64 z t) (-.f64 z a)) < -5.0000000000000002e46Initial program 97.5%
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
frac-2negN/A
lower-/.f64N/A
neg-sub0N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
associate--r+N/A
neg-sub0N/A
remove-double-negN/A
lower--.f64N/A
neg-sub0N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
associate--r+N/A
neg-sub0N/A
remove-double-negN/A
lower--.f6497.5
Applied rewrites97.5%
Taylor expanded in t around inf
*-commutativeN/A
associate-*l/N/A
lower-*.f64N/A
lower-/.f64N/A
lower--.f6480.9
Applied rewrites80.9%
Taylor expanded in a around inf
Applied rewrites55.6%
if -5.0000000000000002e46 < (/.f64 (-.f64 z t) (-.f64 z a)) < 2e110Initial program 99.9%
Taylor expanded in z around inf
+-commutativeN/A
lower-+.f6472.4
Applied rewrites72.4%
if 2e110 < (/.f64 (-.f64 z t) (-.f64 z a)) Initial program 83.1%
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
frac-2negN/A
lower-/.f64N/A
neg-sub0N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
associate--r+N/A
neg-sub0N/A
remove-double-negN/A
lower--.f64N/A
neg-sub0N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
associate--r+N/A
neg-sub0N/A
remove-double-negN/A
lower--.f6483.2
Applied rewrites83.2%
Taylor expanded in t around inf
*-commutativeN/A
associate-*l/N/A
lower-*.f64N/A
lower-/.f64N/A
lower--.f6478.3
Applied rewrites78.3%
Taylor expanded in a around inf
Applied rewrites52.4%
Final simplification67.9%
(FPCore (x y z t a) :precision binary64 (let* ((t_1 (/ (- t z) (- a z))) (t_2 (/ (* t y) a))) (if (<= t_1 -5e+68) t_2 (if (<= t_1 2e+110) (+ y x) t_2))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (t - z) / (a - z);
double t_2 = (t * y) / a;
double tmp;
if (t_1 <= -5e+68) {
tmp = t_2;
} else if (t_1 <= 2e+110) {
tmp = y + x;
} else {
tmp = t_2;
}
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) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = (t - z) / (a - z)
t_2 = (t * y) / a
if (t_1 <= (-5d+68)) then
tmp = t_2
else if (t_1 <= 2d+110) then
tmp = y + x
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double t_1 = (t - z) / (a - z);
double t_2 = (t * y) / a;
double tmp;
if (t_1 <= -5e+68) {
tmp = t_2;
} else if (t_1 <= 2e+110) {
tmp = y + x;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = (t - z) / (a - z) t_2 = (t * y) / a tmp = 0 if t_1 <= -5e+68: tmp = t_2 elif t_1 <= 2e+110: tmp = y + x else: tmp = t_2 return tmp
function code(x, y, z, t, a) t_1 = Float64(Float64(t - z) / Float64(a - z)) t_2 = Float64(Float64(t * y) / a) tmp = 0.0 if (t_1 <= -5e+68) tmp = t_2; elseif (t_1 <= 2e+110) tmp = Float64(y + x); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = (t - z) / (a - z); t_2 = (t * y) / a; tmp = 0.0; if (t_1 <= -5e+68) tmp = t_2; elseif (t_1 <= 2e+110) tmp = y + x; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(t - z), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(t * y), $MachinePrecision] / a), $MachinePrecision]}, If[LessEqual[t$95$1, -5e+68], t$95$2, If[LessEqual[t$95$1, 2e+110], N[(y + x), $MachinePrecision], t$95$2]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{t - z}{a - z}\\
t_2 := \frac{t \cdot y}{a}\\
\mathbf{if}\;t\_1 \leq -5 \cdot 10^{+68}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+110}:\\
\;\;\;\;y + x\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if (/.f64 (-.f64 z t) (-.f64 z a)) < -5.0000000000000004e68 or 2e110 < (/.f64 (-.f64 z t) (-.f64 z a)) Initial program 91.8%
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
frac-2negN/A
lower-/.f64N/A
neg-sub0N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
associate--r+N/A
neg-sub0N/A
remove-double-negN/A
lower--.f64N/A
neg-sub0N/A
lift--.f64N/A
sub-negN/A
+-commutativeN/A
associate--r+N/A
neg-sub0N/A
remove-double-negN/A
lower--.f6491.9
Applied rewrites91.9%
Taylor expanded in t around inf
*-commutativeN/A
associate-*l/N/A
lower-*.f64N/A
lower-/.f64N/A
lower--.f6480.2
Applied rewrites80.2%
Taylor expanded in a around inf
Applied rewrites52.8%
if -5.0000000000000004e68 < (/.f64 (-.f64 z t) (-.f64 z a)) < 2e110Initial program 99.9%
Taylor expanded in z around inf
+-commutativeN/A
lower-+.f6471.5
Applied rewrites71.5%
Final simplification67.1%
(FPCore (x y z t a) :precision binary64 (+ y x))
double code(double x, double y, double z, double t, double a) {
return y + x;
}
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 = y + x
end function
public static double code(double x, double y, double z, double t, double a) {
return y + x;
}
def code(x, y, z, t, a): return y + x
function code(x, y, z, t, a) return Float64(y + x) end
function tmp = code(x, y, z, t, a) tmp = y + x; end
code[x_, y_, z_, t_, a_] := N[(y + x), $MachinePrecision]
\begin{array}{l}
\\
y + x
\end{array}
Initial program 98.0%
Taylor expanded in z around inf
+-commutativeN/A
lower-+.f6459.6
Applied rewrites59.6%
(FPCore (x y z t a) :precision binary64 (+ x (/ y (/ (- z a) (- z t)))))
double code(double x, double y, double z, double t, double a) {
return x + (y / ((z - a) / (z - 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 = x + (y / ((z - a) / (z - t)))
end function
public static double code(double x, double y, double z, double t, double a) {
return x + (y / ((z - a) / (z - t)));
}
def code(x, y, z, t, a): return x + (y / ((z - a) / (z - t)))
function code(x, y, z, t, a) return Float64(x + Float64(y / Float64(Float64(z - a) / Float64(z - t)))) end
function tmp = code(x, y, z, t, a) tmp = x + (y / ((z - a) / (z - t))); end
code[x_, y_, z_, t_, a_] := N[(x + N[(y / N[(N[(z - a), $MachinePrecision] / N[(z - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \frac{y}{\frac{z - a}{z - t}}
\end{array}
herbie shell --seed 2024276
(FPCore (x y z t a)
:name "Graphics.Rendering.Plot.Render.Plot.Axis:renderAxisLine from plot-0.2.3.4, A"
:precision binary64
:alt
(! :herbie-platform default (+ x (/ y (/ (- z a) (- z t)))))
(+ x (* y (/ (- z t) (- z a)))))