
(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 14 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 (+ (/ y (/ (- a z) (- t z))) x))
double code(double x, double y, double z, double t, double a) {
return (y / ((a - z) / (t - z))) + 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 / ((a - z) / (t - z))) + x
end function
public static double code(double x, double y, double z, double t, double a) {
return (y / ((a - z) / (t - z))) + x;
}
def code(x, y, z, t, a): return (y / ((a - z) / (t - z))) + x
function code(x, y, z, t, a) return Float64(Float64(y / Float64(Float64(a - z) / Float64(t - z))) + x) end
function tmp = code(x, y, z, t, a) tmp = (y / ((a - z) / (t - z))) + x; end
code[x_, y_, z_, t_, a_] := N[(N[(y / N[(N[(a - z), $MachinePrecision] / N[(t - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision]
\begin{array}{l}
\\
\frac{y}{\frac{a - z}{t - z}} + x
\end{array}
Initial program 98.0%
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--.f6498.3
Applied rewrites98.3%
Final simplification98.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ (- z t) (- z a))) (t_2 (* (/ y (- a z)) t)))
(if (<= t_1 -5e+33)
t_2
(if (<= t_1 2e-13)
(fma (/ t a) y x)
(if (<= t_1 4e+18)
(+ y x)
(if (<= t_1 5e+133) (fma (/ (- t) z) y x) t_2))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (z - t) / (z - a);
double t_2 = (y / (a - z)) * t;
double tmp;
if (t_1 <= -5e+33) {
tmp = t_2;
} else if (t_1 <= 2e-13) {
tmp = fma((t / a), y, x);
} else if (t_1 <= 4e+18) {
tmp = y + x;
} else if (t_1 <= 5e+133) {
tmp = fma((-t / z), y, x);
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = Float64(Float64(z - t) / Float64(z - a)) t_2 = Float64(Float64(y / Float64(a - z)) * t) tmp = 0.0 if (t_1 <= -5e+33) tmp = t_2; elseif (t_1 <= 2e-13) tmp = fma(Float64(t / a), y, x); elseif (t_1 <= 4e+18) tmp = Float64(y + x); elseif (t_1 <= 5e+133) 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[(z - t), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]}, If[LessEqual[t$95$1, -5e+33], t$95$2, If[LessEqual[t$95$1, 2e-13], N[(N[(t / a), $MachinePrecision] * y + x), $MachinePrecision], If[LessEqual[t$95$1, 4e+18], N[(y + x), $MachinePrecision], If[LessEqual[t$95$1, 5e+133], N[(N[((-t) / z), $MachinePrecision] * y + x), $MachinePrecision], t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{z - t}{z - a}\\
t_2 := \frac{y}{a - z} \cdot t\\
\mathbf{if}\;t\_1 \leq -5 \cdot 10^{+33}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{-13}:\\
\;\;\;\;\mathsf{fma}\left(\frac{t}{a}, y, x\right)\\
\mathbf{elif}\;t\_1 \leq 4 \cdot 10^{+18}:\\
\;\;\;\;y + x\\
\mathbf{elif}\;t\_1 \leq 5 \cdot 10^{+133}:\\
\;\;\;\;\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)) < -4.99999999999999973e33 or 4.99999999999999961e133 < (/.f64 (-.f64 z t) (-.f64 z a)) Initial program 90.3%
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--.f6476.0
Applied rewrites76.0%
if -4.99999999999999973e33 < (/.f64 (-.f64 z t) (-.f64 z a)) < 2.0000000000000001e-13Initial program 99.8%
Taylor expanded in z around 0
lower-/.f6484.4
Applied rewrites84.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6484.4
Applied rewrites84.4%
if 2.0000000000000001e-13 < (/.f64 (-.f64 z t) (-.f64 z a)) < 4e18Initial program 100.0%
Taylor expanded in z around inf
+-commutativeN/A
lower-+.f6494.3
Applied rewrites94.3%
if 4e18 < (/.f64 (-.f64 z t) (-.f64 z a)) < 4.99999999999999961e133Initial program 99.7%
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--.f6474.9
Applied rewrites74.9%
Taylor expanded in t around inf
Applied rewrites74.9%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ (- z t) (- z a))))
(if (<= t_1 -5e+33)
(* (/ y (- a z)) t)
(if (<= t_1 2e-13)
(fma (- t z) (/ y a) x)
(if (<= t_1 2e+127)
(fma (/ (- z t) z) y x)
(/ (* (- t z) y) (- a z)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (z - t) / (z - a);
double tmp;
if (t_1 <= -5e+33) {
tmp = (y / (a - z)) * t;
} else if (t_1 <= 2e-13) {
tmp = fma((t - z), (y / a), x);
} else if (t_1 <= 2e+127) {
tmp = fma(((z - t) / z), y, x);
} else {
tmp = ((t - z) * y) / (a - z);
}
return tmp;
}
function code(x, y, z, t, a) t_1 = Float64(Float64(z - t) / Float64(z - a)) tmp = 0.0 if (t_1 <= -5e+33) tmp = Float64(Float64(y / Float64(a - z)) * t); elseif (t_1 <= 2e-13) tmp = fma(Float64(t - z), Float64(y / a), x); elseif (t_1 <= 2e+127) tmp = fma(Float64(Float64(z - t) / z), y, x); else tmp = Float64(Float64(Float64(t - z) * y) / Float64(a - z)); end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(z - t), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -5e+33], N[(N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[t$95$1, 2e-13], N[(N[(t - z), $MachinePrecision] * N[(y / a), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[t$95$1, 2e+127], N[(N[(N[(z - t), $MachinePrecision] / z), $MachinePrecision] * y + x), $MachinePrecision], N[(N[(N[(t - z), $MachinePrecision] * y), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{z - t}{z - a}\\
\mathbf{if}\;t\_1 \leq -5 \cdot 10^{+33}:\\
\;\;\;\;\frac{y}{a - z} \cdot t\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{-13}:\\
\;\;\;\;\mathsf{fma}\left(t - z, \frac{y}{a}, x\right)\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+127}:\\
\;\;\;\;\mathsf{fma}\left(\frac{z - t}{z}, y, x\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\left(t - z\right) \cdot y}{a - z}\\
\end{array}
\end{array}
if (/.f64 (-.f64 z t) (-.f64 z a)) < -4.99999999999999973e33Initial program 90.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.1
Applied rewrites92.1%
Taylor expanded in t around inf
*-commutativeN/A
associate-*l/N/A
lower-*.f64N/A
lower-/.f64N/A
lower--.f6473.1
Applied rewrites73.1%
if -4.99999999999999973e33 < (/.f64 (-.f64 z t) (-.f64 z a)) < 2.0000000000000001e-13Initial program 99.8%
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-/.f6497.5
Applied rewrites97.5%
if 2.0000000000000001e-13 < (/.f64 (-.f64 z t) (-.f64 z a)) < 1.99999999999999991e127Initial 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--.f6491.8
Applied rewrites91.8%
if 1.99999999999999991e127 < (/.f64 (-.f64 z t) (-.f64 z a)) Initial program 91.3%
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.1
Applied rewrites92.1%
Taylor expanded in y around inf
div-subN/A
associate-/l*N/A
*-commutativeN/A
associate-/l*N/A
lower-*.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower--.f6473.6
Applied rewrites73.6%
Taylor expanded in y around inf
div-subN/A
associate-/l*N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
lower--.f6482.3
Applied rewrites82.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ (- z t) (- z a))))
(if (<= t_1 -5e+33)
(* (/ y (- a z)) t)
(if (<= t_1 2e-13)
(fma (- t z) (/ y a) x)
(if (<= t_1 2e+127) (fma (/ (- z t) z) y x) (/ (* t y) (- a z)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (z - t) / (z - a);
double tmp;
if (t_1 <= -5e+33) {
tmp = (y / (a - z)) * t;
} else if (t_1 <= 2e-13) {
tmp = fma((t - z), (y / a), x);
} else if (t_1 <= 2e+127) {
tmp = fma(((z - t) / z), y, x);
} else {
tmp = (t * y) / (a - z);
}
return tmp;
}
function code(x, y, z, t, a) t_1 = Float64(Float64(z - t) / Float64(z - a)) tmp = 0.0 if (t_1 <= -5e+33) tmp = Float64(Float64(y / Float64(a - z)) * t); elseif (t_1 <= 2e-13) tmp = fma(Float64(t - z), Float64(y / a), x); elseif (t_1 <= 2e+127) tmp = fma(Float64(Float64(z - 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[(z - t), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -5e+33], N[(N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[t$95$1, 2e-13], N[(N[(t - z), $MachinePrecision] * N[(y / a), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[t$95$1, 2e+127], N[(N[(N[(z - t), $MachinePrecision] / z), $MachinePrecision] * y + x), $MachinePrecision], N[(N[(t * y), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{z - t}{z - a}\\
\mathbf{if}\;t\_1 \leq -5 \cdot 10^{+33}:\\
\;\;\;\;\frac{y}{a - z} \cdot t\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{-13}:\\
\;\;\;\;\mathsf{fma}\left(t - z, \frac{y}{a}, x\right)\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+127}:\\
\;\;\;\;\mathsf{fma}\left(\frac{z - 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)) < -4.99999999999999973e33Initial program 90.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.1
Applied rewrites92.1%
Taylor expanded in t around inf
*-commutativeN/A
associate-*l/N/A
lower-*.f64N/A
lower-/.f64N/A
lower--.f6473.1
Applied rewrites73.1%
if -4.99999999999999973e33 < (/.f64 (-.f64 z t) (-.f64 z a)) < 2.0000000000000001e-13Initial program 99.8%
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-/.f6497.5
Applied rewrites97.5%
if 2.0000000000000001e-13 < (/.f64 (-.f64 z t) (-.f64 z a)) < 1.99999999999999991e127Initial 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--.f6491.8
Applied rewrites91.8%
if 1.99999999999999991e127 < (/.f64 (-.f64 z t) (-.f64 z a)) Initial program 91.3%
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.1
Applied rewrites92.1%
Taylor expanded in t around inf
*-commutativeN/A
associate-*l/N/A
lower-*.f64N/A
lower-/.f64N/A
lower--.f6473.6
Applied rewrites73.6%
Applied rewrites82.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ (- z t) (- z a))))
(if (<= t_1 -5e+33)
(* (/ y (- a z)) t)
(if (<= t_1 1e-37)
(fma (- t z) (/ y a) x)
(if (<= t_1 2.0) (fma (/ z (- z a)) y x) (/ (* t y) (- a z)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (z - t) / (z - a);
double tmp;
if (t_1 <= -5e+33) {
tmp = (y / (a - z)) * t;
} else if (t_1 <= 1e-37) {
tmp = fma((t - z), (y / a), x);
} else if (t_1 <= 2.0) {
tmp = fma((z / (z - a)), y, x);
} else {
tmp = (t * y) / (a - z);
}
return tmp;
}
function code(x, y, z, t, a) t_1 = Float64(Float64(z - t) / Float64(z - a)) tmp = 0.0 if (t_1 <= -5e+33) tmp = Float64(Float64(y / Float64(a - z)) * t); elseif (t_1 <= 1e-37) tmp = fma(Float64(t - z), Float64(y / a), x); elseif (t_1 <= 2.0) tmp = fma(Float64(z / Float64(z - a)), 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[(z - t), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -5e+33], N[(N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[t$95$1, 1e-37], N[(N[(t - z), $MachinePrecision] * N[(y / a), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[t$95$1, 2.0], N[(N[(z / N[(z - a), $MachinePrecision]), $MachinePrecision] * y + x), $MachinePrecision], N[(N[(t * y), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{z - t}{z - a}\\
\mathbf{if}\;t\_1 \leq -5 \cdot 10^{+33}:\\
\;\;\;\;\frac{y}{a - z} \cdot t\\
\mathbf{elif}\;t\_1 \leq 10^{-37}:\\
\;\;\;\;\mathsf{fma}\left(t - z, \frac{y}{a}, x\right)\\
\mathbf{elif}\;t\_1 \leq 2:\\
\;\;\;\;\mathsf{fma}\left(\frac{z}{z - a}, y, x\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{t \cdot y}{a - z}\\
\end{array}
\end{array}
if (/.f64 (-.f64 z t) (-.f64 z a)) < -4.99999999999999973e33Initial program 90.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.1
Applied rewrites92.1%
Taylor expanded in t around inf
*-commutativeN/A
associate-*l/N/A
lower-*.f64N/A
lower-/.f64N/A
lower--.f6473.1
Applied rewrites73.1%
if -4.99999999999999973e33 < (/.f64 (-.f64 z t) (-.f64 z a)) < 1.00000000000000007e-37Initial 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-/.f6498.6
Applied rewrites98.6%
if 1.00000000000000007e-37 < (/.f64 (-.f64 z t) (-.f64 z a)) < 2Initial program 99.9%
Taylor expanded in t around 0
+-commutativeN/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
lower--.f6498.7
Applied rewrites98.7%
if 2 < (/.f64 (-.f64 z t) (-.f64 z a)) Initial program 95.7%
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--.f6496.1
Applied rewrites96.1%
Taylor expanded in t around inf
*-commutativeN/A
associate-*l/N/A
lower-*.f64N/A
lower-/.f64N/A
lower--.f6457.5
Applied rewrites57.5%
Applied rewrites65.9%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ (- z t) (- z a))))
(if (<= t_1 -5e+33)
(* (/ y (- a z)) t)
(if (<= t_1 2e-13)
(fma (- t z) (/ y a) x)
(if (<= t_1 2.0) (+ y x) (/ (* t y) (- a z)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (z - t) / (z - a);
double tmp;
if (t_1 <= -5e+33) {
tmp = (y / (a - z)) * t;
} else if (t_1 <= 2e-13) {
tmp = fma((t - z), (y / a), x);
} else if (t_1 <= 2.0) {
tmp = y + x;
} else {
tmp = (t * y) / (a - z);
}
return tmp;
}
function code(x, y, z, t, a) t_1 = Float64(Float64(z - t) / Float64(z - a)) tmp = 0.0 if (t_1 <= -5e+33) tmp = Float64(Float64(y / Float64(a - z)) * t); elseif (t_1 <= 2e-13) tmp = fma(Float64(t - z), Float64(y / a), x); elseif (t_1 <= 2.0) tmp = Float64(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[(z - t), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -5e+33], N[(N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[t$95$1, 2e-13], N[(N[(t - z), $MachinePrecision] * N[(y / a), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[t$95$1, 2.0], N[(y + x), $MachinePrecision], N[(N[(t * y), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{z - t}{z - a}\\
\mathbf{if}\;t\_1 \leq -5 \cdot 10^{+33}:\\
\;\;\;\;\frac{y}{a - z} \cdot t\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{-13}:\\
\;\;\;\;\mathsf{fma}\left(t - z, \frac{y}{a}, x\right)\\
\mathbf{elif}\;t\_1 \leq 2:\\
\;\;\;\;y + x\\
\mathbf{else}:\\
\;\;\;\;\frac{t \cdot y}{a - z}\\
\end{array}
\end{array}
if (/.f64 (-.f64 z t) (-.f64 z a)) < -4.99999999999999973e33Initial program 90.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.1
Applied rewrites92.1%
Taylor expanded in t around inf
*-commutativeN/A
associate-*l/N/A
lower-*.f64N/A
lower-/.f64N/A
lower--.f6473.1
Applied rewrites73.1%
if -4.99999999999999973e33 < (/.f64 (-.f64 z t) (-.f64 z a)) < 2.0000000000000001e-13Initial program 99.8%
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-/.f6497.5
Applied rewrites97.5%
if 2.0000000000000001e-13 < (/.f64 (-.f64 z t) (-.f64 z a)) < 2Initial program 100.0%
Taylor expanded in z around inf
+-commutativeN/A
lower-+.f6498.4
Applied rewrites98.4%
if 2 < (/.f64 (-.f64 z t) (-.f64 z a)) Initial program 95.7%
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--.f6496.1
Applied rewrites96.1%
Taylor expanded in t around inf
*-commutativeN/A
associate-*l/N/A
lower-*.f64N/A
lower-/.f64N/A
lower--.f6457.5
Applied rewrites57.5%
Applied rewrites65.9%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ (- z t) (- z a))))
(if (<= t_1 -5e+33)
(* (/ y (- a z)) t)
(if (<= t_1 2e-13)
(fma (/ t a) y x)
(if (<= t_1 2.0) (+ y x) (/ (* t y) (- a z)))))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (z - t) / (z - a);
double tmp;
if (t_1 <= -5e+33) {
tmp = (y / (a - z)) * t;
} else if (t_1 <= 2e-13) {
tmp = fma((t / a), y, x);
} else if (t_1 <= 2.0) {
tmp = y + x;
} else {
tmp = (t * y) / (a - z);
}
return tmp;
}
function code(x, y, z, t, a) t_1 = Float64(Float64(z - t) / Float64(z - a)) tmp = 0.0 if (t_1 <= -5e+33) tmp = Float64(Float64(y / Float64(a - z)) * t); elseif (t_1 <= 2e-13) tmp = fma(Float64(t / a), y, x); elseif (t_1 <= 2.0) tmp = Float64(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[(z - t), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -5e+33], N[(N[(y / N[(a - z), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision], If[LessEqual[t$95$1, 2e-13], N[(N[(t / a), $MachinePrecision] * y + x), $MachinePrecision], If[LessEqual[t$95$1, 2.0], N[(y + x), $MachinePrecision], N[(N[(t * y), $MachinePrecision] / N[(a - z), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{z - t}{z - a}\\
\mathbf{if}\;t\_1 \leq -5 \cdot 10^{+33}:\\
\;\;\;\;\frac{y}{a - z} \cdot t\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{-13}:\\
\;\;\;\;\mathsf{fma}\left(\frac{t}{a}, y, x\right)\\
\mathbf{elif}\;t\_1 \leq 2:\\
\;\;\;\;y + x\\
\mathbf{else}:\\
\;\;\;\;\frac{t \cdot y}{a - z}\\
\end{array}
\end{array}
if (/.f64 (-.f64 z t) (-.f64 z a)) < -4.99999999999999973e33Initial program 90.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.1
Applied rewrites92.1%
Taylor expanded in t around inf
*-commutativeN/A
associate-*l/N/A
lower-*.f64N/A
lower-/.f64N/A
lower--.f6473.1
Applied rewrites73.1%
if -4.99999999999999973e33 < (/.f64 (-.f64 z t) (-.f64 z a)) < 2.0000000000000001e-13Initial program 99.8%
Taylor expanded in z around 0
lower-/.f6484.4
Applied rewrites84.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6484.4
Applied rewrites84.4%
if 2.0000000000000001e-13 < (/.f64 (-.f64 z t) (-.f64 z a)) < 2Initial program 100.0%
Taylor expanded in z around inf
+-commutativeN/A
lower-+.f6498.4
Applied rewrites98.4%
if 2 < (/.f64 (-.f64 z t) (-.f64 z a)) Initial program 95.7%
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--.f6496.1
Applied rewrites96.1%
Taylor expanded in t around inf
*-commutativeN/A
associate-*l/N/A
lower-*.f64N/A
lower-/.f64N/A
lower--.f6457.5
Applied rewrites57.5%
Applied rewrites65.9%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (fma (/ t a) y x)) (t_2 (/ (- z t) (- z a))))
(if (<= t_2 -5e+33)
(fma (/ (- t) z) y x)
(if (<= t_2 2e-13) t_1 (if (<= t_2 2.0) (+ y x) t_1)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = fma((t / a), y, x);
double t_2 = (z - t) / (z - a);
double tmp;
if (t_2 <= -5e+33) {
tmp = fma((-t / z), y, x);
} else if (t_2 <= 2e-13) {
tmp = t_1;
} else if (t_2 <= 2.0) {
tmp = y + x;
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = fma(Float64(t / a), y, x) t_2 = Float64(Float64(z - t) / Float64(z - a)) tmp = 0.0 if (t_2 <= -5e+33) tmp = fma(Float64(Float64(-t) / z), y, x); elseif (t_2 <= 2e-13) tmp = t_1; elseif (t_2 <= 2.0) tmp = Float64(y + x); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(t / a), $MachinePrecision] * y + x), $MachinePrecision]}, Block[{t$95$2 = N[(N[(z - t), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, -5e+33], N[(N[((-t) / z), $MachinePrecision] * y + x), $MachinePrecision], If[LessEqual[t$95$2, 2e-13], t$95$1, If[LessEqual[t$95$2, 2.0], N[(y + x), $MachinePrecision], t$95$1]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(\frac{t}{a}, y, x\right)\\
t_2 := \frac{z - t}{z - a}\\
\mathbf{if}\;t\_2 \leq -5 \cdot 10^{+33}:\\
\;\;\;\;\mathsf{fma}\left(\frac{-t}{z}, y, x\right)\\
\mathbf{elif}\;t\_2 \leq 2 \cdot 10^{-13}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq 2:\\
\;\;\;\;y + x\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (/.f64 (-.f64 z t) (-.f64 z a)) < -4.99999999999999973e33Initial program 90.2%
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--.f6462.9
Applied rewrites62.9%
Taylor expanded in t around inf
Applied rewrites62.9%
if -4.99999999999999973e33 < (/.f64 (-.f64 z t) (-.f64 z a)) < 2.0000000000000001e-13 or 2 < (/.f64 (-.f64 z t) (-.f64 z a)) Initial program 98.4%
Taylor expanded in z around 0
lower-/.f6474.9
Applied rewrites74.9%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6474.9
Applied rewrites74.9%
if 2.0000000000000001e-13 < (/.f64 (-.f64 z t) (-.f64 z a)) < 2Initial program 100.0%
Taylor expanded in z around inf
+-commutativeN/A
lower-+.f6498.4
Applied rewrites98.4%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ (- z t) (- z a))))
(if (<= t_1 2e-13)
(fma (/ y a) t x)
(if (<= t_1 2.0) (+ y x) (fma (/ t a) y x)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (z - t) / (z - a);
double tmp;
if (t_1 <= 2e-13) {
tmp = fma((y / a), t, x);
} else if (t_1 <= 2.0) {
tmp = y + x;
} else {
tmp = fma((t / a), y, x);
}
return tmp;
}
function code(x, y, z, t, a) t_1 = Float64(Float64(z - t) / Float64(z - a)) tmp = 0.0 if (t_1 <= 2e-13) tmp = fma(Float64(y / a), t, x); elseif (t_1 <= 2.0) tmp = Float64(y + x); else tmp = fma(Float64(t / a), y, x); end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(z - t), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, 2e-13], N[(N[(y / a), $MachinePrecision] * t + x), $MachinePrecision], If[LessEqual[t$95$1, 2.0], N[(y + x), $MachinePrecision], N[(N[(t / a), $MachinePrecision] * y + x), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{z - t}{z - a}\\
\mathbf{if}\;t\_1 \leq 2 \cdot 10^{-13}:\\
\;\;\;\;\mathsf{fma}\left(\frac{y}{a}, t, x\right)\\
\mathbf{elif}\;t\_1 \leq 2:\\
\;\;\;\;y + x\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\frac{t}{a}, y, x\right)\\
\end{array}
\end{array}
if (/.f64 (-.f64 z t) (-.f64 z a)) < 2.0000000000000001e-13Initial program 97.2%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-/.f6474.9
Applied rewrites74.9%
if 2.0000000000000001e-13 < (/.f64 (-.f64 z t) (-.f64 z a)) < 2Initial program 100.0%
Taylor expanded in z around inf
+-commutativeN/A
lower-+.f6498.4
Applied rewrites98.4%
if 2 < (/.f64 (-.f64 z t) (-.f64 z a)) Initial program 95.7%
Taylor expanded in z around 0
lower-/.f6457.4
Applied rewrites57.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lower-fma.f6457.4
Applied rewrites57.4%
(FPCore (x y z t a) :precision binary64 (let* ((t_1 (/ (- z t) (- z a))) (t_2 (fma (/ y a) t x))) (if (<= t_1 2e-13) t_2 (if (<= t_1 5e+60) (+ y x) t_2))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (z - t) / (z - a);
double t_2 = fma((y / a), t, x);
double tmp;
if (t_1 <= 2e-13) {
tmp = t_2;
} else if (t_1 <= 5e+60) {
tmp = y + x;
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = Float64(Float64(z - t) / Float64(z - a)) t_2 = fma(Float64(y / a), t, x) tmp = 0.0 if (t_1 <= 2e-13) tmp = t_2; elseif (t_1 <= 5e+60) tmp = Float64(y + x); else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(z - t), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(y / a), $MachinePrecision] * t + x), $MachinePrecision]}, If[LessEqual[t$95$1, 2e-13], t$95$2, If[LessEqual[t$95$1, 5e+60], N[(y + x), $MachinePrecision], t$95$2]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{z - t}{z - a}\\
t_2 := \mathsf{fma}\left(\frac{y}{a}, t, x\right)\\
\mathbf{if}\;t\_1 \leq 2 \cdot 10^{-13}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_1 \leq 5 \cdot 10^{+60}:\\
\;\;\;\;y + x\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if (/.f64 (-.f64 z t) (-.f64 z a)) < 2.0000000000000001e-13 or 4.99999999999999975e60 < (/.f64 (-.f64 z t) (-.f64 z a)) Initial program 96.5%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-/.f6470.9
Applied rewrites70.9%
if 2.0000000000000001e-13 < (/.f64 (-.f64 z t) (-.f64 z a)) < 4.99999999999999975e60Initial program 99.9%
Taylor expanded in z around inf
+-commutativeN/A
lower-+.f6492.3
Applied rewrites92.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ (- z t) (- z a))))
(if (<= t_1 4e-45)
(* -1.0 (- x))
(if (<= t_1 4e+133) (+ y x) (/ (* t y) a)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = (z - t) / (z - a);
double tmp;
if (t_1 <= 4e-45) {
tmp = -1.0 * -x;
} else if (t_1 <= 4e+133) {
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 = (z - t) / (z - a)
if (t_1 <= 4d-45) then
tmp = (-1.0d0) * -x
else if (t_1 <= 4d+133) 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 = (z - t) / (z - a);
double tmp;
if (t_1 <= 4e-45) {
tmp = -1.0 * -x;
} else if (t_1 <= 4e+133) {
tmp = y + x;
} else {
tmp = (t * y) / a;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = (z - t) / (z - a) tmp = 0 if t_1 <= 4e-45: tmp = -1.0 * -x elif t_1 <= 4e+133: tmp = y + x else: tmp = (t * y) / a return tmp
function code(x, y, z, t, a) t_1 = Float64(Float64(z - t) / Float64(z - a)) tmp = 0.0 if (t_1 <= 4e-45) tmp = Float64(-1.0 * Float64(-x)); elseif (t_1 <= 4e+133) 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 = (z - t) / (z - a); tmp = 0.0; if (t_1 <= 4e-45) tmp = -1.0 * -x; elseif (t_1 <= 4e+133) 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[(z - t), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, 4e-45], N[(-1.0 * (-x)), $MachinePrecision], If[LessEqual[t$95$1, 4e+133], N[(y + x), $MachinePrecision], N[(N[(t * y), $MachinePrecision] / a), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{z - t}{z - a}\\
\mathbf{if}\;t\_1 \leq 4 \cdot 10^{-45}:\\
\;\;\;\;-1 \cdot \left(-x\right)\\
\mathbf{elif}\;t\_1 \leq 4 \cdot 10^{+133}:\\
\;\;\;\;y + x\\
\mathbf{else}:\\
\;\;\;\;\frac{t \cdot y}{a}\\
\end{array}
\end{array}
if (/.f64 (-.f64 z t) (-.f64 z a)) < 3.99999999999999994e-45Initial program 96.9%
Taylor expanded in x around -inf
associate-*r*N/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f64N/A
sub-negN/A
mul-1-negN/A
times-fracN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
metadata-evalN/A
lower-fma.f64N/A
Applied rewrites82.6%
Taylor expanded in a around inf
Applied rewrites54.6%
if 3.99999999999999994e-45 < (/.f64 (-.f64 z t) (-.f64 z a)) < 4.0000000000000001e133Initial program 99.9%
Taylor expanded in z around inf
+-commutativeN/A
lower-+.f6483.4
Applied rewrites83.4%
if 4.0000000000000001e133 < (/.f64 (-.f64 z t) (-.f64 z a)) Initial program 91.0%
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.8
Applied rewrites91.8%
Taylor expanded in y around inf
div-subN/A
associate-/l*N/A
*-commutativeN/A
associate-/l*N/A
lower-*.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower--.f6476.9
Applied rewrites76.9%
Taylor expanded in z around 0
Applied rewrites55.1%
Final simplification69.8%
(FPCore (x y z t a) :precision binary64 (if (<= (/ (- z t) (- z a)) 8e-45) (* -1.0 (- x)) (+ y x)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (((z - t) / (z - a)) <= 8e-45) {
tmp = -1.0 * -x;
} else {
tmp = y + x;
}
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 - t) / (z - a)) <= 8d-45) then
tmp = (-1.0d0) * -x
else
tmp = y + x
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (((z - t) / (z - a)) <= 8e-45) {
tmp = -1.0 * -x;
} else {
tmp = y + x;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if ((z - t) / (z - a)) <= 8e-45: tmp = -1.0 * -x else: tmp = y + x return tmp
function code(x, y, z, t, a) tmp = 0.0 if (Float64(Float64(z - t) / Float64(z - a)) <= 8e-45) tmp = Float64(-1.0 * Float64(-x)); else tmp = Float64(y + x); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (((z - t) / (z - a)) <= 8e-45) tmp = -1.0 * -x; else tmp = y + x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[N[(N[(z - t), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision], 8e-45], N[(-1.0 * (-x)), $MachinePrecision], N[(y + x), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{z - t}{z - a} \leq 8 \cdot 10^{-45}:\\
\;\;\;\;-1 \cdot \left(-x\right)\\
\mathbf{else}:\\
\;\;\;\;y + x\\
\end{array}
\end{array}
if (/.f64 (-.f64 z t) (-.f64 z a)) < 7.99999999999999987e-45Initial program 96.9%
Taylor expanded in x around -inf
associate-*r*N/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f64N/A
sub-negN/A
mul-1-negN/A
times-fracN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
metadata-evalN/A
lower-fma.f64N/A
Applied rewrites82.6%
Taylor expanded in a around inf
Applied rewrites54.6%
if 7.99999999999999987e-45 < (/.f64 (-.f64 z t) (-.f64 z a)) Initial program 98.7%
Taylor expanded in z around inf
+-commutativeN/A
lower-+.f6475.3
Applied rewrites75.3%
Final simplification67.2%
(FPCore (x y z t a) :precision binary64 (+ (* (/ (- z t) (- z a)) y) x))
double code(double x, double y, double z, double t, double a) {
return (((z - t) / (z - a)) * 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 = (((z - t) / (z - a)) * y) + x
end function
public static double code(double x, double y, double z, double t, double a) {
return (((z - t) / (z - a)) * y) + x;
}
def code(x, y, z, t, a): return (((z - t) / (z - a)) * y) + x
function code(x, y, z, t, a) return Float64(Float64(Float64(Float64(z - t) / Float64(z - a)) * y) + x) end
function tmp = code(x, y, z, t, a) tmp = (((z - t) / (z - a)) * y) + x; end
code[x_, y_, z_, t_, a_] := N[(N[(N[(N[(z - t), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision] + x), $MachinePrecision]
\begin{array}{l}
\\
\frac{z - t}{z - a} \cdot y + x
\end{array}
Initial program 98.0%
Final simplification98.0%
(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-+.f6464.0
Applied rewrites64.0%
(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 2024268
(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)))))