
(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 17 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 (* 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}
Initial program 99.2%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* y (/ (- z t) (- z a)))))
(if (or (<= t_1 (- INFINITY)) (not (<= t_1 1e+279)))
(* (/ y a) t)
(+ y x))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y * ((z - t) / (z - a));
double tmp;
if ((t_1 <= -((double) INFINITY)) || !(t_1 <= 1e+279)) {
tmp = (y / a) * t;
} else {
tmp = y + x;
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a) {
double t_1 = y * ((z - t) / (z - a));
double tmp;
if ((t_1 <= -Double.POSITIVE_INFINITY) || !(t_1 <= 1e+279)) {
tmp = (y / a) * t;
} else {
tmp = y + x;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y * ((z - t) / (z - a)) tmp = 0 if (t_1 <= -math.inf) or not (t_1 <= 1e+279): tmp = (y / a) * t else: tmp = y + x return tmp
function code(x, y, z, t, a) t_1 = Float64(y * Float64(Float64(z - t) / Float64(z - a))) tmp = 0.0 if ((t_1 <= Float64(-Inf)) || !(t_1 <= 1e+279)) tmp = Float64(Float64(y / a) * t); else tmp = Float64(y + x); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y * ((z - t) / (z - a)); tmp = 0.0; if ((t_1 <= -Inf) || ~((t_1 <= 1e+279))) tmp = (y / a) * t; else tmp = y + x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y * N[(N[(z - t), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[t$95$1, (-Infinity)], N[Not[LessEqual[t$95$1, 1e+279]], $MachinePrecision]], N[(N[(y / a), $MachinePrecision] * t), $MachinePrecision], N[(y + x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \frac{z - t}{z - a}\\
\mathbf{if}\;t\_1 \leq -\infty \lor \neg \left(t\_1 \leq 10^{+279}\right):\\
\;\;\;\;\frac{y}{a} \cdot t\\
\mathbf{else}:\\
\;\;\;\;y + x\\
\end{array}
\end{array}
if (*.f64 y (/.f64 (-.f64 z t) (-.f64 z a))) < -inf.0 or 1.00000000000000006e279 < (*.f64 y (/.f64 (-.f64 z t) (-.f64 z a))) Initial program 93.8%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
lift--.f64N/A
flip--N/A
associate-/r/N/A
associate-*l*N/A
lower-fma.f64N/A
lower-/.f64N/A
difference-of-squaresN/A
lift--.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f6487.1
Applied rewrites87.1%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6468.0
Applied rewrites68.0%
Taylor expanded in x around 0
Applied rewrites65.1%
Taylor expanded in x around 0
Applied rewrites68.0%
if -inf.0 < (*.f64 y (/.f64 (-.f64 z t) (-.f64 z a))) < 1.00000000000000006e279Initial program 99.9%
Taylor expanded in z around inf
+-commutativeN/A
lower-+.f6468.0
Applied rewrites68.0%
Final simplification68.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* y (/ (- z t) (- z a)))))
(if (or (<= t_1 (- INFINITY)) (not (<= t_1 1e+279)))
(* (/ t a) y)
(+ y x))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y * ((z - t) / (z - a));
double tmp;
if ((t_1 <= -((double) INFINITY)) || !(t_1 <= 1e+279)) {
tmp = (t / a) * y;
} else {
tmp = y + x;
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a) {
double t_1 = y * ((z - t) / (z - a));
double tmp;
if ((t_1 <= -Double.POSITIVE_INFINITY) || !(t_1 <= 1e+279)) {
tmp = (t / a) * y;
} else {
tmp = y + x;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y * ((z - t) / (z - a)) tmp = 0 if (t_1 <= -math.inf) or not (t_1 <= 1e+279): tmp = (t / a) * y else: tmp = y + x return tmp
function code(x, y, z, t, a) t_1 = Float64(y * Float64(Float64(z - t) / Float64(z - a))) tmp = 0.0 if ((t_1 <= Float64(-Inf)) || !(t_1 <= 1e+279)) tmp = Float64(Float64(t / a) * y); else tmp = Float64(y + x); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y * ((z - t) / (z - a)); tmp = 0.0; if ((t_1 <= -Inf) || ~((t_1 <= 1e+279))) tmp = (t / a) * y; else tmp = y + x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y * N[(N[(z - t), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Or[LessEqual[t$95$1, (-Infinity)], N[Not[LessEqual[t$95$1, 1e+279]], $MachinePrecision]], N[(N[(t / a), $MachinePrecision] * y), $MachinePrecision], N[(y + x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \frac{z - t}{z - a}\\
\mathbf{if}\;t\_1 \leq -\infty \lor \neg \left(t\_1 \leq 10^{+279}\right):\\
\;\;\;\;\frac{t}{a} \cdot y\\
\mathbf{else}:\\
\;\;\;\;y + x\\
\end{array}
\end{array}
if (*.f64 y (/.f64 (-.f64 z t) (-.f64 z a))) < -inf.0 or 1.00000000000000006e279 < (*.f64 y (/.f64 (-.f64 z t) (-.f64 z a))) Initial program 93.8%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
lift--.f64N/A
flip--N/A
associate-/r/N/A
associate-*l*N/A
lower-fma.f64N/A
lower-/.f64N/A
difference-of-squaresN/A
lift--.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f6487.1
Applied rewrites87.1%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6468.0
Applied rewrites68.0%
Taylor expanded in x around 0
Applied rewrites65.1%
Applied rewrites64.9%
if -inf.0 < (*.f64 y (/.f64 (-.f64 z t) (-.f64 z a))) < 1.00000000000000006e279Initial program 99.9%
Taylor expanded in z around inf
+-commutativeN/A
lower-+.f6468.0
Applied rewrites68.0%
Final simplification67.6%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (* y (/ (- z t) (- z a)))))
(if (<= t_1 (- INFINITY))
(/ (* t y) a)
(if (<= t_1 1e+279) (+ y x) (* (/ y a) t)))))
double code(double x, double y, double z, double t, double a) {
double t_1 = y * ((z - t) / (z - a));
double tmp;
if (t_1 <= -((double) INFINITY)) {
tmp = (t * y) / a;
} else if (t_1 <= 1e+279) {
tmp = y + x;
} else {
tmp = (y / a) * t;
}
return tmp;
}
public static double code(double x, double y, double z, double t, double a) {
double t_1 = y * ((z - t) / (z - a));
double tmp;
if (t_1 <= -Double.POSITIVE_INFINITY) {
tmp = (t * y) / a;
} else if (t_1 <= 1e+279) {
tmp = y + x;
} else {
tmp = (y / a) * t;
}
return tmp;
}
def code(x, y, z, t, a): t_1 = y * ((z - t) / (z - a)) tmp = 0 if t_1 <= -math.inf: tmp = (t * y) / a elif t_1 <= 1e+279: tmp = y + x else: tmp = (y / a) * t return tmp
function code(x, y, z, t, a) t_1 = Float64(y * Float64(Float64(z - t) / Float64(z - a))) tmp = 0.0 if (t_1 <= Float64(-Inf)) tmp = Float64(Float64(t * y) / a); elseif (t_1 <= 1e+279) tmp = Float64(y + x); else tmp = Float64(Float64(y / a) * t); end return tmp end
function tmp_2 = code(x, y, z, t, a) t_1 = y * ((z - t) / (z - a)); tmp = 0.0; if (t_1 <= -Inf) tmp = (t * y) / a; elseif (t_1 <= 1e+279) tmp = y + x; else tmp = (y / a) * t; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y * N[(N[(z - t), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, (-Infinity)], N[(N[(t * y), $MachinePrecision] / a), $MachinePrecision], If[LessEqual[t$95$1, 1e+279], N[(y + x), $MachinePrecision], N[(N[(y / a), $MachinePrecision] * t), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \frac{z - t}{z - a}\\
\mathbf{if}\;t\_1 \leq -\infty:\\
\;\;\;\;\frac{t \cdot y}{a}\\
\mathbf{elif}\;t\_1 \leq 10^{+279}:\\
\;\;\;\;y + x\\
\mathbf{else}:\\
\;\;\;\;\frac{y}{a} \cdot t\\
\end{array}
\end{array}
if (*.f64 y (/.f64 (-.f64 z t) (-.f64 z a))) < -inf.0Initial program 91.2%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
lift--.f64N/A
flip--N/A
associate-/r/N/A
associate-*l*N/A
lower-fma.f64N/A
lower-/.f64N/A
difference-of-squaresN/A
lift--.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f6490.9
Applied rewrites90.9%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6481.7
Applied rewrites81.7%
Taylor expanded in x around 0
Applied rewrites81.8%
if -inf.0 < (*.f64 y (/.f64 (-.f64 z t) (-.f64 z a))) < 1.00000000000000006e279Initial program 99.9%
Taylor expanded in z around inf
+-commutativeN/A
lower-+.f6468.0
Applied rewrites68.0%
if 1.00000000000000006e279 < (*.f64 y (/.f64 (-.f64 z t) (-.f64 z a))) Initial program 95.2%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
lift--.f64N/A
flip--N/A
associate-/r/N/A
associate-*l*N/A
lower-fma.f64N/A
lower-/.f64N/A
difference-of-squaresN/A
lift--.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f6485.0
Applied rewrites85.0%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6460.5
Applied rewrites60.5%
Taylor expanded in x around 0
Applied rewrites55.9%
Taylor expanded in x around 0
Applied rewrites60.5%
Final simplification68.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ (- z t) (- z a))))
(if (<= t_1 -5e+66)
(* (- z t) (/ y (- z a)))
(if (<= t_1 2e-7) (fma (/ t a) y x) (+ x (fma (/ (- y) z) (- t a) y))))))
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+66) {
tmp = (z - t) * (y / (z - a));
} else if (t_1 <= 2e-7) {
tmp = fma((t / a), y, x);
} else {
tmp = x + fma((-y / z), (t - a), y);
}
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+66) tmp = Float64(Float64(z - t) * Float64(y / Float64(z - a))); elseif (t_1 <= 2e-7) tmp = fma(Float64(t / a), y, x); else tmp = Float64(x + fma(Float64(Float64(-y) / z), Float64(t - a), y)); 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+66], N[(N[(z - t), $MachinePrecision] * N[(y / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 2e-7], N[(N[(t / a), $MachinePrecision] * y + x), $MachinePrecision], N[(x + N[(N[((-y) / z), $MachinePrecision] * N[(t - a), $MachinePrecision] + y), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{z - t}{z - a}\\
\mathbf{if}\;t\_1 \leq -5 \cdot 10^{+66}:\\
\;\;\;\;\left(z - t\right) \cdot \frac{y}{z - a}\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{-7}:\\
\;\;\;\;\mathsf{fma}\left(\frac{t}{a}, y, x\right)\\
\mathbf{else}:\\
\;\;\;\;x + \mathsf{fma}\left(\frac{-y}{z}, t - a, y\right)\\
\end{array}
\end{array}
if (/.f64 (-.f64 z t) (-.f64 z a)) < -4.99999999999999991e66Initial program 93.3%
Taylor expanded in x around 0
*-commutativeN/A
associate-/l*N/A
lower-*.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower--.f6480.6
Applied rewrites80.6%
if -4.99999999999999991e66 < (/.f64 (-.f64 z t) (-.f64 z a)) < 1.9999999999999999e-7Initial program 99.9%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
lift--.f64N/A
flip--N/A
associate-/r/N/A
associate-*l*N/A
lower-fma.f64N/A
lower-/.f64N/A
difference-of-squaresN/A
lift--.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f6476.9
Applied rewrites76.9%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6488.3
Applied rewrites88.3%
Taylor expanded in x around 0
Applied rewrites89.8%
if 1.9999999999999999e-7 < (/.f64 (-.f64 z t) (-.f64 z a)) Initial program 99.9%
Taylor expanded in z around inf
associate--l+N/A
distribute-lft-out--N/A
div-subN/A
+-commutativeN/A
mul-1-negN/A
div-subN/A
associate-/l*N/A
associate-/l*N/A
distribute-rgt-out--N/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
distribute-frac-negN/A
lower-/.f64N/A
lower-neg.f64N/A
lower--.f6494.3
Applied rewrites94.3%
Final simplification90.9%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ (- z t) (- z a))))
(if (<= t_1 -5e+66)
(* (- z t) (/ y (- z a)))
(if (<= t_1 2e-7) (fma (/ t a) y x) (fma y (- 1.0 (/ t z)) 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 <= -5e+66) {
tmp = (z - t) * (y / (z - a));
} else if (t_1 <= 2e-7) {
tmp = fma((t / a), y, x);
} else {
tmp = fma(y, (1.0 - (t / z)), 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 <= -5e+66) tmp = Float64(Float64(z - t) * Float64(y / Float64(z - a))); elseif (t_1 <= 2e-7) tmp = fma(Float64(t / a), y, x); else tmp = fma(y, Float64(1.0 - Float64(t / z)), 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, -5e+66], N[(N[(z - t), $MachinePrecision] * N[(y / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 2e-7], N[(N[(t / a), $MachinePrecision] * y + x), $MachinePrecision], N[(y * N[(1.0 - N[(t / z), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{z - t}{z - a}\\
\mathbf{if}\;t\_1 \leq -5 \cdot 10^{+66}:\\
\;\;\;\;\left(z - t\right) \cdot \frac{y}{z - a}\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{-7}:\\
\;\;\;\;\mathsf{fma}\left(\frac{t}{a}, y, x\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(y, 1 - \frac{t}{z}, x\right)\\
\end{array}
\end{array}
if (/.f64 (-.f64 z t) (-.f64 z a)) < -4.99999999999999991e66Initial program 93.3%
Taylor expanded in x around 0
*-commutativeN/A
associate-/l*N/A
lower-*.f64N/A
lower--.f64N/A
lower-/.f64N/A
lower--.f6480.6
Applied rewrites80.6%
if -4.99999999999999991e66 < (/.f64 (-.f64 z t) (-.f64 z a)) < 1.9999999999999999e-7Initial program 99.9%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
lift--.f64N/A
flip--N/A
associate-/r/N/A
associate-*l*N/A
lower-fma.f64N/A
lower-/.f64N/A
difference-of-squaresN/A
lift--.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f6476.9
Applied rewrites76.9%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6488.3
Applied rewrites88.3%
Taylor expanded in x around 0
Applied rewrites89.8%
if 1.9999999999999999e-7 < (/.f64 (-.f64 z t) (-.f64 z a)) Initial program 99.9%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
lift--.f64N/A
flip--N/A
associate-/r/N/A
associate-*l*N/A
lower-fma.f64N/A
lower-/.f64N/A
difference-of-squaresN/A
lift--.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f6476.1
Applied rewrites76.1%
Taylor expanded in a around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower--.f6493.4
Applied rewrites93.4%
Applied rewrites93.4%
Final simplification90.5%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ (- z t) (- z a))))
(if (<= t_1 -5e+66)
(* (- y) (/ t (- z a)))
(if (<= t_1 2e-7) (fma (/ t a) y x) (fma y (- 1.0 (/ t z)) 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 <= -5e+66) {
tmp = -y * (t / (z - a));
} else if (t_1 <= 2e-7) {
tmp = fma((t / a), y, x);
} else {
tmp = fma(y, (1.0 - (t / z)), 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 <= -5e+66) tmp = Float64(Float64(-y) * Float64(t / Float64(z - a))); elseif (t_1 <= 2e-7) tmp = fma(Float64(t / a), y, x); else tmp = fma(y, Float64(1.0 - Float64(t / z)), 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, -5e+66], N[((-y) * N[(t / N[(z - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 2e-7], N[(N[(t / a), $MachinePrecision] * y + x), $MachinePrecision], N[(y * N[(1.0 - N[(t / z), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{z - t}{z - a}\\
\mathbf{if}\;t\_1 \leq -5 \cdot 10^{+66}:\\
\;\;\;\;\left(-y\right) \cdot \frac{t}{z - a}\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{-7}:\\
\;\;\;\;\mathsf{fma}\left(\frac{t}{a}, y, x\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(y, 1 - \frac{t}{z}, x\right)\\
\end{array}
\end{array}
if (/.f64 (-.f64 z t) (-.f64 z a)) < -4.99999999999999991e66Initial program 93.3%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
associate-/l*N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-/.f64N/A
lower--.f6474.1
Applied rewrites74.1%
if -4.99999999999999991e66 < (/.f64 (-.f64 z t) (-.f64 z a)) < 1.9999999999999999e-7Initial program 99.9%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
lift--.f64N/A
flip--N/A
associate-/r/N/A
associate-*l*N/A
lower-fma.f64N/A
lower-/.f64N/A
difference-of-squaresN/A
lift--.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f6476.9
Applied rewrites76.9%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6488.3
Applied rewrites88.3%
Taylor expanded in x around 0
Applied rewrites89.8%
if 1.9999999999999999e-7 < (/.f64 (-.f64 z t) (-.f64 z a)) Initial program 99.9%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
lift--.f64N/A
flip--N/A
associate-/r/N/A
associate-*l*N/A
lower-fma.f64N/A
lower-/.f64N/A
difference-of-squaresN/A
lift--.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f6476.1
Applied rewrites76.1%
Taylor expanded in a around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower--.f6493.4
Applied rewrites93.4%
Applied rewrites93.4%
Final simplification89.8%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ (- z t) (- z a))))
(if (<= t_1 2e-7)
(fma (/ t a) y x)
(if (<= t_1 200.0) (fma (/ z (- z a)) y x) (fma y (/ (- t) z) 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-7) {
tmp = fma((t / a), y, x);
} else if (t_1 <= 200.0) {
tmp = fma((z / (z - a)), y, x);
} else {
tmp = fma(y, (-t / z), 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-7) tmp = fma(Float64(t / a), y, x); elseif (t_1 <= 200.0) tmp = fma(Float64(z / Float64(z - a)), y, x); else tmp = fma(y, Float64(Float64(-t) / z), 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-7], N[(N[(t / a), $MachinePrecision] * y + x), $MachinePrecision], If[LessEqual[t$95$1, 200.0], N[(N[(z / N[(z - a), $MachinePrecision]), $MachinePrecision] * y + x), $MachinePrecision], N[(y * N[((-t) / z), $MachinePrecision] + x), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{z - t}{z - a}\\
\mathbf{if}\;t\_1 \leq 2 \cdot 10^{-7}:\\
\;\;\;\;\mathsf{fma}\left(\frac{t}{a}, y, x\right)\\
\mathbf{elif}\;t\_1 \leq 200:\\
\;\;\;\;\mathsf{fma}\left(\frac{z}{z - a}, y, x\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(y, \frac{-t}{z}, x\right)\\
\end{array}
\end{array}
if (/.f64 (-.f64 z t) (-.f64 z a)) < 1.9999999999999999e-7Initial program 98.5%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
lift--.f64N/A
flip--N/A
associate-/r/N/A
associate-*l*N/A
lower-fma.f64N/A
lower-/.f64N/A
difference-of-squaresN/A
lift--.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f6475.3
Applied rewrites75.3%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6481.9
Applied rewrites81.9%
Taylor expanded in x around 0
Applied rewrites82.4%
if 1.9999999999999999e-7 < (/.f64 (-.f64 z t) (-.f64 z a)) < 200Initial program 100.0%
Taylor expanded in t around 0
+-commutativeN/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
lower--.f6498.8
Applied rewrites98.8%
if 200 < (/.f64 (-.f64 z t) (-.f64 z a)) Initial program 99.8%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
lift--.f64N/A
flip--N/A
associate-/r/N/A
associate-*l*N/A
lower-fma.f64N/A
lower-/.f64N/A
difference-of-squaresN/A
lift--.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f6492.0
Applied rewrites92.0%
Taylor expanded in a around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower--.f6482.8
Applied rewrites82.8%
Taylor expanded in z around 0
Applied rewrites81.6%
Final simplification87.5%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ (- z t) (- z a))))
(if (<= t_1 2e-7)
(fma (/ t a) y x)
(if (<= t_1 200.0) (+ y x) (fma y (/ (- t) z) 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-7) {
tmp = fma((t / a), y, x);
} else if (t_1 <= 200.0) {
tmp = y + x;
} else {
tmp = fma(y, (-t / z), 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-7) tmp = fma(Float64(t / a), y, x); elseif (t_1 <= 200.0) tmp = Float64(y + x); else tmp = fma(y, Float64(Float64(-t) / z), 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-7], N[(N[(t / a), $MachinePrecision] * y + x), $MachinePrecision], If[LessEqual[t$95$1, 200.0], N[(y + x), $MachinePrecision], N[(y * N[((-t) / z), $MachinePrecision] + x), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{z - t}{z - a}\\
\mathbf{if}\;t\_1 \leq 2 \cdot 10^{-7}:\\
\;\;\;\;\mathsf{fma}\left(\frac{t}{a}, y, x\right)\\
\mathbf{elif}\;t\_1 \leq 200:\\
\;\;\;\;y + x\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(y, \frac{-t}{z}, x\right)\\
\end{array}
\end{array}
if (/.f64 (-.f64 z t) (-.f64 z a)) < 1.9999999999999999e-7Initial program 98.5%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
lift--.f64N/A
flip--N/A
associate-/r/N/A
associate-*l*N/A
lower-fma.f64N/A
lower-/.f64N/A
difference-of-squaresN/A
lift--.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f6475.3
Applied rewrites75.3%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6481.9
Applied rewrites81.9%
Taylor expanded in x around 0
Applied rewrites82.4%
if 1.9999999999999999e-7 < (/.f64 (-.f64 z t) (-.f64 z a)) < 200Initial program 100.0%
Taylor expanded in z around inf
+-commutativeN/A
lower-+.f6498.6
Applied rewrites98.6%
if 200 < (/.f64 (-.f64 z t) (-.f64 z a)) Initial program 99.8%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
lift--.f64N/A
flip--N/A
associate-/r/N/A
associate-*l*N/A
lower-fma.f64N/A
lower-/.f64N/A
difference-of-squaresN/A
lift--.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f6492.0
Applied rewrites92.0%
Taylor expanded in a around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower--.f6482.8
Applied rewrites82.8%
Taylor expanded in z around 0
Applied rewrites81.6%
Final simplification87.5%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ (- z t) (- z a))))
(if (<= t_1 2e-7)
(fma (/ t a) y x)
(if (<= t_1 200.0) (+ y x) (- y (* y (/ t 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 <= 2e-7) {
tmp = fma((t / a), y, x);
} else if (t_1 <= 200.0) {
tmp = y + x;
} else {
tmp = y - (y * (t / 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 <= 2e-7) tmp = fma(Float64(t / a), y, x); elseif (t_1 <= 200.0) tmp = Float64(y + x); else tmp = Float64(y - Float64(y * Float64(t / 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, 2e-7], N[(N[(t / a), $MachinePrecision] * y + x), $MachinePrecision], If[LessEqual[t$95$1, 200.0], N[(y + x), $MachinePrecision], N[(y - N[(y * N[(t / z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{z - t}{z - a}\\
\mathbf{if}\;t\_1 \leq 2 \cdot 10^{-7}:\\
\;\;\;\;\mathsf{fma}\left(\frac{t}{a}, y, x\right)\\
\mathbf{elif}\;t\_1 \leq 200:\\
\;\;\;\;y + x\\
\mathbf{else}:\\
\;\;\;\;y - y \cdot \frac{t}{z}\\
\end{array}
\end{array}
if (/.f64 (-.f64 z t) (-.f64 z a)) < 1.9999999999999999e-7Initial program 98.5%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
lift--.f64N/A
flip--N/A
associate-/r/N/A
associate-*l*N/A
lower-fma.f64N/A
lower-/.f64N/A
difference-of-squaresN/A
lift--.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f6475.3
Applied rewrites75.3%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6481.9
Applied rewrites81.9%
Taylor expanded in x around 0
Applied rewrites82.4%
if 1.9999999999999999e-7 < (/.f64 (-.f64 z t) (-.f64 z a)) < 200Initial program 100.0%
Taylor expanded in z around inf
+-commutativeN/A
lower-+.f6498.6
Applied rewrites98.6%
if 200 < (/.f64 (-.f64 z t) (-.f64 z a)) Initial program 99.8%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
lift--.f64N/A
flip--N/A
associate-/r/N/A
associate-*l*N/A
lower-fma.f64N/A
lower-/.f64N/A
difference-of-squaresN/A
lift--.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f6492.0
Applied rewrites92.0%
Taylor expanded in a around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower--.f6482.8
Applied rewrites82.8%
Taylor expanded in x around 0
Applied rewrites64.5%
Taylor expanded in z around inf
Applied rewrites66.8%
Final simplification85.1%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ (- z t) (- z a))))
(if (<= t_1 2e-7)
(fma (/ t a) y x)
(if (<= t_1 200.0) (+ y x) (* (- y) (/ t 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 <= 2e-7) {
tmp = fma((t / a), y, x);
} else if (t_1 <= 200.0) {
tmp = y + x;
} else {
tmp = -y * (t / 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 <= 2e-7) tmp = fma(Float64(t / a), y, x); elseif (t_1 <= 200.0) tmp = Float64(y + x); else tmp = Float64(Float64(-y) * Float64(t / 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, 2e-7], N[(N[(t / a), $MachinePrecision] * y + x), $MachinePrecision], If[LessEqual[t$95$1, 200.0], N[(y + x), $MachinePrecision], N[((-y) * N[(t / z), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{z - t}{z - a}\\
\mathbf{if}\;t\_1 \leq 2 \cdot 10^{-7}:\\
\;\;\;\;\mathsf{fma}\left(\frac{t}{a}, y, x\right)\\
\mathbf{elif}\;t\_1 \leq 200:\\
\;\;\;\;y + x\\
\mathbf{else}:\\
\;\;\;\;\left(-y\right) \cdot \frac{t}{z}\\
\end{array}
\end{array}
if (/.f64 (-.f64 z t) (-.f64 z a)) < 1.9999999999999999e-7Initial program 98.5%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
lift--.f64N/A
flip--N/A
associate-/r/N/A
associate-*l*N/A
lower-fma.f64N/A
lower-/.f64N/A
difference-of-squaresN/A
lift--.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f6475.3
Applied rewrites75.3%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6481.9
Applied rewrites81.9%
Taylor expanded in x around 0
Applied rewrites82.4%
if 1.9999999999999999e-7 < (/.f64 (-.f64 z t) (-.f64 z a)) < 200Initial program 100.0%
Taylor expanded in z around inf
+-commutativeN/A
lower-+.f6498.6
Applied rewrites98.6%
if 200 < (/.f64 (-.f64 z t) (-.f64 z a)) Initial program 99.8%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
associate-/l*N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-/.f64N/A
lower--.f6478.3
Applied rewrites78.3%
Taylor expanded in z around inf
Applied rewrites65.9%
Final simplification85.0%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (/ (- z t) (- z a))))
(if (<= t_1 2e-7)
(fma (/ t a) y x)
(if (<= t_1 200.0) (+ y x) (* t (/ (- y) 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 <= 2e-7) {
tmp = fma((t / a), y, x);
} else if (t_1 <= 200.0) {
tmp = y + x;
} else {
tmp = t * (-y / 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 <= 2e-7) tmp = fma(Float64(t / a), y, x); elseif (t_1 <= 200.0) tmp = Float64(y + x); else tmp = Float64(t * Float64(Float64(-y) / 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, 2e-7], N[(N[(t / a), $MachinePrecision] * y + x), $MachinePrecision], If[LessEqual[t$95$1, 200.0], N[(y + x), $MachinePrecision], N[(t * N[((-y) / z), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{z - t}{z - a}\\
\mathbf{if}\;t\_1 \leq 2 \cdot 10^{-7}:\\
\;\;\;\;\mathsf{fma}\left(\frac{t}{a}, y, x\right)\\
\mathbf{elif}\;t\_1 \leq 200:\\
\;\;\;\;y + x\\
\mathbf{else}:\\
\;\;\;\;t \cdot \frac{-y}{z}\\
\end{array}
\end{array}
if (/.f64 (-.f64 z t) (-.f64 z a)) < 1.9999999999999999e-7Initial program 98.5%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
lift--.f64N/A
flip--N/A
associate-/r/N/A
associate-*l*N/A
lower-fma.f64N/A
lower-/.f64N/A
difference-of-squaresN/A
lift--.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f6475.3
Applied rewrites75.3%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6481.9
Applied rewrites81.9%
Taylor expanded in x around 0
Applied rewrites82.4%
if 1.9999999999999999e-7 < (/.f64 (-.f64 z t) (-.f64 z a)) < 200Initial program 100.0%
Taylor expanded in z around inf
+-commutativeN/A
lower-+.f6498.6
Applied rewrites98.6%
if 200 < (/.f64 (-.f64 z t) (-.f64 z a)) Initial program 99.8%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
associate-/l*N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-/.f64N/A
lower--.f6478.3
Applied rewrites78.3%
Taylor expanded in z around inf
Applied rewrites65.9%
Final simplification85.0%
(FPCore (x y z t a) :precision binary64 (let* ((t_1 (/ (- z t) (- z a)))) (if (or (<= t_1 2e-7) (not (<= t_1 5e+152))) (fma (/ t a) y x) (+ 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-7) || !(t_1 <= 5e+152)) {
tmp = fma((t / a), y, x);
} else {
tmp = 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-7) || !(t_1 <= 5e+152)) tmp = fma(Float64(t / a), y, x); else tmp = Float64(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[Or[LessEqual[t$95$1, 2e-7], N[Not[LessEqual[t$95$1, 5e+152]], $MachinePrecision]], N[(N[(t / a), $MachinePrecision] * y + x), $MachinePrecision], N[(y + x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{z - t}{z - a}\\
\mathbf{if}\;t\_1 \leq 2 \cdot 10^{-7} \lor \neg \left(t\_1 \leq 5 \cdot 10^{+152}\right):\\
\;\;\;\;\mathsf{fma}\left(\frac{t}{a}, y, x\right)\\
\mathbf{else}:\\
\;\;\;\;y + x\\
\end{array}
\end{array}
if (/.f64 (-.f64 z t) (-.f64 z a)) < 1.9999999999999999e-7 or 5e152 < (/.f64 (-.f64 z t) (-.f64 z a)) Initial program 98.7%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
lift--.f64N/A
flip--N/A
associate-/r/N/A
associate-*l*N/A
lower-fma.f64N/A
lower-/.f64N/A
difference-of-squaresN/A
lift--.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f6477.3
Applied rewrites77.3%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6480.4
Applied rewrites80.4%
Taylor expanded in x around 0
Applied rewrites80.8%
if 1.9999999999999999e-7 < (/.f64 (-.f64 z t) (-.f64 z a)) < 5e152Initial program 99.9%
Taylor expanded in z around inf
+-commutativeN/A
lower-+.f6485.6
Applied rewrites85.6%
Final simplification82.7%
(FPCore (x y z t a) :precision binary64 (let* ((t_1 (/ (- z t) (- z a)))) (if (or (<= t_1 2e-7) (not (<= t_1 5e+152))) (fma (/ y a) t x) (+ 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-7) || !(t_1 <= 5e+152)) {
tmp = fma((y / a), t, x);
} else {
tmp = 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-7) || !(t_1 <= 5e+152)) tmp = fma(Float64(y / a), t, x); else tmp = Float64(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[Or[LessEqual[t$95$1, 2e-7], N[Not[LessEqual[t$95$1, 5e+152]], $MachinePrecision]], N[(N[(y / a), $MachinePrecision] * t + x), $MachinePrecision], N[(y + x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{z - t}{z - a}\\
\mathbf{if}\;t\_1 \leq 2 \cdot 10^{-7} \lor \neg \left(t\_1 \leq 5 \cdot 10^{+152}\right):\\
\;\;\;\;\mathsf{fma}\left(\frac{y}{a}, t, x\right)\\
\mathbf{else}:\\
\;\;\;\;y + x\\
\end{array}
\end{array}
if (/.f64 (-.f64 z t) (-.f64 z a)) < 1.9999999999999999e-7 or 5e152 < (/.f64 (-.f64 z t) (-.f64 z a)) Initial program 98.7%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
*-commutativeN/A
lower-fma.f64N/A
lower-/.f6480.4
Applied rewrites80.4%
if 1.9999999999999999e-7 < (/.f64 (-.f64 z t) (-.f64 z a)) < 5e152Initial program 99.9%
Taylor expanded in z around inf
+-commutativeN/A
lower-+.f6485.6
Applied rewrites85.6%
Final simplification82.5%
(FPCore (x y z t a) :precision binary64 (if (<= (/ (- z t) (- z a)) 2e-7) (fma (/ t a) y x) (fma y (- 1.0 (/ t z)) x)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (((z - t) / (z - a)) <= 2e-7) {
tmp = fma((t / a), y, x);
} else {
tmp = fma(y, (1.0 - (t / z)), x);
}
return tmp;
}
function code(x, y, z, t, a) tmp = 0.0 if (Float64(Float64(z - t) / Float64(z - a)) <= 2e-7) tmp = fma(Float64(t / a), y, x); else tmp = fma(y, Float64(1.0 - Float64(t / z)), x); end return tmp end
code[x_, y_, z_, t_, a_] := If[LessEqual[N[(N[(z - t), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision], 2e-7], N[(N[(t / a), $MachinePrecision] * y + x), $MachinePrecision], N[(y * N[(1.0 - N[(t / z), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{z - t}{z - a} \leq 2 \cdot 10^{-7}:\\
\;\;\;\;\mathsf{fma}\left(\frac{t}{a}, y, x\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(y, 1 - \frac{t}{z}, x\right)\\
\end{array}
\end{array}
if (/.f64 (-.f64 z t) (-.f64 z a)) < 1.9999999999999999e-7Initial program 98.5%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
lift--.f64N/A
flip--N/A
associate-/r/N/A
associate-*l*N/A
lower-fma.f64N/A
lower-/.f64N/A
difference-of-squaresN/A
lift--.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f6475.3
Applied rewrites75.3%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6481.9
Applied rewrites81.9%
Taylor expanded in x around 0
Applied rewrites82.4%
if 1.9999999999999999e-7 < (/.f64 (-.f64 z t) (-.f64 z a)) Initial program 99.9%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
lift--.f64N/A
flip--N/A
associate-/r/N/A
associate-*l*N/A
lower-fma.f64N/A
lower-/.f64N/A
difference-of-squaresN/A
lift--.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f6476.1
Applied rewrites76.1%
Taylor expanded in a around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower--.f6493.4
Applied rewrites93.4%
Applied rewrites93.4%
(FPCore (x y z t a) :precision binary64 (if (<= (/ (- z t) (- z a)) 2e-7) (fma (/ t a) y x) (fma (/ (- z t) z) y x)))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (((z - t) / (z - a)) <= 2e-7) {
tmp = fma((t / a), y, x);
} else {
tmp = fma(((z - t) / z), y, x);
}
return tmp;
}
function code(x, y, z, t, a) tmp = 0.0 if (Float64(Float64(z - t) / Float64(z - a)) <= 2e-7) tmp = fma(Float64(t / a), y, x); else tmp = fma(Float64(Float64(z - t) / z), y, x); end return tmp end
code[x_, y_, z_, t_, a_] := If[LessEqual[N[(N[(z - t), $MachinePrecision] / N[(z - a), $MachinePrecision]), $MachinePrecision], 2e-7], N[(N[(t / a), $MachinePrecision] * y + x), $MachinePrecision], N[(N[(N[(z - t), $MachinePrecision] / z), $MachinePrecision] * y + x), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{z - t}{z - a} \leq 2 \cdot 10^{-7}:\\
\;\;\;\;\mathsf{fma}\left(\frac{t}{a}, y, x\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\frac{z - t}{z}, y, x\right)\\
\end{array}
\end{array}
if (/.f64 (-.f64 z t) (-.f64 z a)) < 1.9999999999999999e-7Initial program 98.5%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
lift--.f64N/A
flip--N/A
associate-/r/N/A
associate-*l*N/A
lower-fma.f64N/A
lower-/.f64N/A
difference-of-squaresN/A
lift--.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f6475.3
Applied rewrites75.3%
Taylor expanded in z around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6481.9
Applied rewrites81.9%
Taylor expanded in x around 0
Applied rewrites82.4%
if 1.9999999999999999e-7 < (/.f64 (-.f64 z t) (-.f64 z a)) Initial program 99.9%
Taylor expanded in a around 0
+-commutativeN/A
associate-/l*N/A
*-commutativeN/A
div-subN/A
*-inversesN/A
*-lft-identityN/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
lower-fma.f64N/A
fp-cancel-sign-sub-invN/A
*-inversesN/A
metadata-evalN/A
*-lft-identityN/A
div-subN/A
lower-/.f64N/A
lower--.f6493.4
Applied rewrites93.4%
Final simplification87.6%
(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 99.2%
Taylor expanded in z around inf
+-commutativeN/A
lower-+.f6460.6
Applied rewrites60.6%
Final simplification60.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 2024339
(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)))))