
(FPCore (x y z t a) :precision binary64 (- x (/ (- y z) (/ (+ (- t z) 1.0) a))))
double code(double x, double y, double z, double t, double a) {
return x - ((y - z) / (((t - z) + 1.0) / 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) + 1.0d0) / a))
end function
public static double code(double x, double y, double z, double t, double a) {
return x - ((y - z) / (((t - z) + 1.0) / a));
}
def code(x, y, z, t, a): return x - ((y - z) / (((t - z) + 1.0) / a))
function code(x, y, z, t, a) return Float64(x - Float64(Float64(y - z) / Float64(Float64(Float64(t - z) + 1.0) / a))) end
function tmp = code(x, y, z, t, a) tmp = x - ((y - z) / (((t - z) + 1.0) / a)); end
code[x_, y_, z_, t_, a_] := N[(x - N[(N[(y - z), $MachinePrecision] / N[(N[(N[(t - z), $MachinePrecision] + 1.0), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x - \frac{y - z}{\frac{\left(t - z\right) + 1}{a}}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 16 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a) :precision binary64 (- x (/ (- y z) (/ (+ (- t z) 1.0) a))))
double code(double x, double y, double z, double t, double a) {
return x - ((y - z) / (((t - z) + 1.0) / 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) + 1.0d0) / a))
end function
public static double code(double x, double y, double z, double t, double a) {
return x - ((y - z) / (((t - z) + 1.0) / a));
}
def code(x, y, z, t, a): return x - ((y - z) / (((t - z) + 1.0) / a))
function code(x, y, z, t, a) return Float64(x - Float64(Float64(y - z) / Float64(Float64(Float64(t - z) + 1.0) / a))) end
function tmp = code(x, y, z, t, a) tmp = x - ((y - z) / (((t - z) + 1.0) / a)); end
code[x_, y_, z_, t_, a_] := N[(x - N[(N[(y - z), $MachinePrecision] / N[(N[(N[(t - z), $MachinePrecision] + 1.0), $MachinePrecision] / a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x - \frac{y - z}{\frac{\left(t - z\right) + 1}{a}}
\end{array}
(FPCore (x y z t a) :precision binary64 (fma (/ (- y z) (+ -1.0 (- z t))) a x))
double code(double x, double y, double z, double t, double a) {
return fma(((y - z) / (-1.0 + (z - t))), a, x);
}
function code(x, y, z, t, a) return fma(Float64(Float64(y - z) / Float64(-1.0 + Float64(z - t))), a, x) end
code[x_, y_, z_, t_, a_] := N[(N[(N[(y - z), $MachinePrecision] / N[(-1.0 + N[(z - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * a + x), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(\frac{y - z}{-1 + \left(z - t\right)}, a, x\right)
\end{array}
Initial program 98.0%
lift--.f64N/A
lift--.f64N/A
lift-+.f64N/A
frac-2negN/A
frac-2negN/A
lift-/.f64N/A
lift-/.f64N/A
sub-negN/A
+-commutativeN/A
lift-/.f64N/A
lift-/.f64N/A
associate-/r/N/A
distribute-lft-neg-inN/A
distribute-frac-neg2N/A
lower-fma.f64N/A
Applied egg-rr99.9%
Final simplification99.9%
(FPCore (x y z t a)
:precision binary64
(if (<= z -1.72e+62)
(- x a)
(if (<= z -5.6e-86)
(- x (/ (* y a) t))
(if (<= z 0.00023) (fma (- y z) (- (fma a z a)) x) (- x a)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.72e+62) {
tmp = x - a;
} else if (z <= -5.6e-86) {
tmp = x - ((y * a) / t);
} else if (z <= 0.00023) {
tmp = fma((y - z), -fma(a, z, a), x);
} else {
tmp = x - a;
}
return tmp;
}
function code(x, y, z, t, a) tmp = 0.0 if (z <= -1.72e+62) tmp = Float64(x - a); elseif (z <= -5.6e-86) tmp = Float64(x - Float64(Float64(y * a) / t)); elseif (z <= 0.00023) tmp = fma(Float64(y - z), Float64(-fma(a, z, a)), x); else tmp = Float64(x - a); end return tmp end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1.72e+62], N[(x - a), $MachinePrecision], If[LessEqual[z, -5.6e-86], N[(x - N[(N[(y * a), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 0.00023], N[(N[(y - z), $MachinePrecision] * (-N[(a * z + a), $MachinePrecision]) + x), $MachinePrecision], N[(x - a), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.72 \cdot 10^{+62}:\\
\;\;\;\;x - a\\
\mathbf{elif}\;z \leq -5.6 \cdot 10^{-86}:\\
\;\;\;\;x - \frac{y \cdot a}{t}\\
\mathbf{elif}\;z \leq 0.00023:\\
\;\;\;\;\mathsf{fma}\left(y - z, -\mathsf{fma}\left(a, z, a\right), x\right)\\
\mathbf{else}:\\
\;\;\;\;x - a\\
\end{array}
\end{array}
if z < -1.7200000000000001e62 or 2.3000000000000001e-4 < z Initial program 96.7%
Taylor expanded in z around inf
lower--.f6478.0
Simplified78.0%
if -1.7200000000000001e62 < z < -5.60000000000000019e-86Initial program 97.3%
lift--.f64N/A
lift--.f64N/A
lift-+.f64N/A
frac-2negN/A
frac-2negN/A
lift-/.f64N/A
lift-/.f64N/A
sub-negN/A
+-commutativeN/A
lift-/.f64N/A
lift-/.f64N/A
associate-/r/N/A
distribute-lft-neg-inN/A
distribute-frac-neg2N/A
lower-fma.f64N/A
Applied egg-rr99.8%
Taylor expanded in y around inf
lower-/.f64N/A
sub-negN/A
mul-1-negN/A
lower-+.f64N/A
distribute-lft-inN/A
metadata-evalN/A
mul-1-negN/A
unsub-negN/A
lower--.f6483.5
Simplified83.5%
Taylor expanded in t around inf
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
lower-/.f64N/A
lower-*.f6467.6
Simplified67.6%
if -5.60000000000000019e-86 < z < 2.3000000000000001e-4Initial program 99.8%
Taylor expanded in t around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower--.f64N/A
lower-neg.f64N/A
lower-/.f64N/A
lower--.f6472.5
Simplified72.5%
Taylor expanded in z around 0
sub-negN/A
mul-1-negN/A
distribute-neg-outN/A
+-commutativeN/A
lower-neg.f64N/A
+-commutativeN/A
lower-fma.f6472.5
Simplified72.5%
Final simplification74.4%
(FPCore (x y z t a)
:precision binary64
(if (<= z -9.2e+45)
(- x a)
(if (<= z -1.8e-83)
(fma a (/ z t) x)
(if (<= z 0.00023) (fma (- y z) (- (fma a z a)) x) (- x a)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -9.2e+45) {
tmp = x - a;
} else if (z <= -1.8e-83) {
tmp = fma(a, (z / t), x);
} else if (z <= 0.00023) {
tmp = fma((y - z), -fma(a, z, a), x);
} else {
tmp = x - a;
}
return tmp;
}
function code(x, y, z, t, a) tmp = 0.0 if (z <= -9.2e+45) tmp = Float64(x - a); elseif (z <= -1.8e-83) tmp = fma(a, Float64(z / t), x); elseif (z <= 0.00023) tmp = fma(Float64(y - z), Float64(-fma(a, z, a)), x); else tmp = Float64(x - a); end return tmp end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -9.2e+45], N[(x - a), $MachinePrecision], If[LessEqual[z, -1.8e-83], N[(a * N[(z / t), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[z, 0.00023], N[(N[(y - z), $MachinePrecision] * (-N[(a * z + a), $MachinePrecision]) + x), $MachinePrecision], N[(x - a), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -9.2 \cdot 10^{+45}:\\
\;\;\;\;x - a\\
\mathbf{elif}\;z \leq -1.8 \cdot 10^{-83}:\\
\;\;\;\;\mathsf{fma}\left(a, \frac{z}{t}, x\right)\\
\mathbf{elif}\;z \leq 0.00023:\\
\;\;\;\;\mathsf{fma}\left(y - z, -\mathsf{fma}\left(a, z, a\right), x\right)\\
\mathbf{else}:\\
\;\;\;\;x - a\\
\end{array}
\end{array}
if z < -9.20000000000000049e45 or 2.3000000000000001e-4 < z Initial program 96.8%
Taylor expanded in z around inf
lower--.f6477.2
Simplified77.2%
if -9.20000000000000049e45 < z < -1.80000000000000006e-83Initial program 97.0%
Taylor expanded in y around 0
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
associate--l+N/A
lower-+.f64N/A
lower--.f6475.1
Simplified75.1%
Taylor expanded in t around inf
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6469.3
Simplified69.3%
if -1.80000000000000006e-83 < z < 2.3000000000000001e-4Initial program 99.8%
Taylor expanded in t around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower--.f64N/A
lower-neg.f64N/A
lower-/.f64N/A
lower--.f6472.5
Simplified72.5%
Taylor expanded in z around 0
sub-negN/A
mul-1-negN/A
distribute-neg-outN/A
+-commutativeN/A
lower-neg.f64N/A
+-commutativeN/A
lower-fma.f6472.5
Simplified72.5%
(FPCore (x y z t a)
:precision binary64
(if (<= y -2.3e-28)
(fma y (/ a (+ -1.0 (- z t))) x)
(if (<= y 2.2e+99)
(fma a (/ z (+ t (- 1.0 z))) x)
(fma (/ y (+ z (- -1.0 t))) a x))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (y <= -2.3e-28) {
tmp = fma(y, (a / (-1.0 + (z - t))), x);
} else if (y <= 2.2e+99) {
tmp = fma(a, (z / (t + (1.0 - z))), x);
} else {
tmp = fma((y / (z + (-1.0 - t))), a, x);
}
return tmp;
}
function code(x, y, z, t, a) tmp = 0.0 if (y <= -2.3e-28) tmp = fma(y, Float64(a / Float64(-1.0 + Float64(z - t))), x); elseif (y <= 2.2e+99) tmp = fma(a, Float64(z / Float64(t + Float64(1.0 - z))), x); else tmp = fma(Float64(y / Float64(z + Float64(-1.0 - t))), a, x); end return tmp end
code[x_, y_, z_, t_, a_] := If[LessEqual[y, -2.3e-28], N[(y * N[(a / N[(-1.0 + N[(z - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[y, 2.2e+99], N[(a * N[(z / N[(t + N[(1.0 - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision], N[(N[(y / N[(z + N[(-1.0 - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * a + x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -2.3 \cdot 10^{-28}:\\
\;\;\;\;\mathsf{fma}\left(y, \frac{a}{-1 + \left(z - t\right)}, x\right)\\
\mathbf{elif}\;y \leq 2.2 \cdot 10^{+99}:\\
\;\;\;\;\mathsf{fma}\left(a, \frac{z}{t + \left(1 - z\right)}, x\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\frac{y}{z + \left(-1 - t\right)}, a, x\right)\\
\end{array}
\end{array}
if y < -2.29999999999999986e-28Initial program 99.9%
lift--.f64N/A
lift--.f64N/A
lift-+.f64N/A
frac-2negN/A
frac-2negN/A
lift-/.f64N/A
lift-/.f64N/A
sub-negN/A
+-commutativeN/A
lift-/.f64N/A
lift-/.f64N/A
associate-/r/N/A
distribute-lft-neg-inN/A
distribute-frac-neg2N/A
lower-fma.f64N/A
Applied egg-rr99.9%
Taylor expanded in y around inf
lower-/.f64N/A
sub-negN/A
mul-1-negN/A
lower-+.f64N/A
distribute-lft-inN/A
metadata-evalN/A
mul-1-negN/A
unsub-negN/A
lower--.f6495.6
Simplified95.6%
lift--.f64N/A
lift-+.f64N/A
lift-/.f64N/A
lift-/.f64N/A
associate-*l/N/A
associate-/l*N/A
lift-+.f64N/A
+-commutativeN/A
lift--.f64N/A
associate--r-N/A
lift--.f64N/A
lift--.f64N/A
lift-/.f64N/A
lower-fma.f6495.7
Applied egg-rr95.7%
if -2.29999999999999986e-28 < y < 2.19999999999999978e99Initial program 98.5%
Taylor expanded in y around 0
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
associate--l+N/A
lower-+.f64N/A
lower--.f6494.7
Simplified94.7%
if 2.19999999999999978e99 < y Initial program 92.5%
lift--.f64N/A
lift--.f64N/A
lift-+.f64N/A
frac-2negN/A
frac-2negN/A
lift-/.f64N/A
lift-/.f64N/A
sub-negN/A
+-commutativeN/A
lift-/.f64N/A
lift-/.f64N/A
associate-/r/N/A
distribute-lft-neg-inN/A
distribute-frac-neg2N/A
lower-fma.f64N/A
Applied egg-rr99.8%
Taylor expanded in y around inf
lower-/.f64N/A
sub-negN/A
mul-1-negN/A
lower-+.f64N/A
distribute-lft-inN/A
metadata-evalN/A
mul-1-negN/A
unsub-negN/A
lower--.f6496.3
Simplified96.3%
Final simplification95.3%
(FPCore (x y z t a)
:precision binary64
(let* ((t_1 (fma y (/ a (+ -1.0 (- z t))) x)))
(if (<= y -2.3e-28)
t_1
(if (<= y 2.2e+99) (fma a (/ z (+ t (- 1.0 z))) x) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = fma(y, (a / (-1.0 + (z - t))), x);
double tmp;
if (y <= -2.3e-28) {
tmp = t_1;
} else if (y <= 2.2e+99) {
tmp = fma(a, (z / (t + (1.0 - z))), x);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = fma(y, Float64(a / Float64(-1.0 + Float64(z - t))), x) tmp = 0.0 if (y <= -2.3e-28) tmp = t_1; elseif (y <= 2.2e+99) tmp = fma(a, Float64(z / Float64(t + Float64(1.0 - z))), x); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(y * N[(a / N[(-1.0 + N[(z - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision]}, If[LessEqual[y, -2.3e-28], t$95$1, If[LessEqual[y, 2.2e+99], N[(a * N[(z / N[(t + N[(1.0 - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(y, \frac{a}{-1 + \left(z - t\right)}, x\right)\\
\mathbf{if}\;y \leq -2.3 \cdot 10^{-28}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 2.2 \cdot 10^{+99}:\\
\;\;\;\;\mathsf{fma}\left(a, \frac{z}{t + \left(1 - z\right)}, x\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -2.29999999999999986e-28 or 2.19999999999999978e99 < y Initial program 97.5%
lift--.f64N/A
lift--.f64N/A
lift-+.f64N/A
frac-2negN/A
frac-2negN/A
lift-/.f64N/A
lift-/.f64N/A
sub-negN/A
+-commutativeN/A
lift-/.f64N/A
lift-/.f64N/A
associate-/r/N/A
distribute-lft-neg-inN/A
distribute-frac-neg2N/A
lower-fma.f64N/A
Applied egg-rr99.9%
Taylor expanded in y around inf
lower-/.f64N/A
sub-negN/A
mul-1-negN/A
lower-+.f64N/A
distribute-lft-inN/A
metadata-evalN/A
mul-1-negN/A
unsub-negN/A
lower--.f6495.8
Simplified95.8%
lift--.f64N/A
lift-+.f64N/A
lift-/.f64N/A
lift-/.f64N/A
associate-*l/N/A
associate-/l*N/A
lift-+.f64N/A
+-commutativeN/A
lift--.f64N/A
associate--r-N/A
lift--.f64N/A
lift--.f64N/A
lift-/.f64N/A
lower-fma.f6494.3
Applied egg-rr94.3%
if -2.29999999999999986e-28 < y < 2.19999999999999978e99Initial program 98.5%
Taylor expanded in y around 0
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
associate--l+N/A
lower-+.f64N/A
lower--.f6494.7
Simplified94.7%
Final simplification94.5%
(FPCore (x y z t a)
:precision binary64
(if (<= y -2.3e-28)
(fma a (/ y (- -1.0 t)) x)
(if (<= y 3.7e+99)
(fma a (/ z (+ t (- 1.0 z))) x)
(fma (/ y (- z t)) a x))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (y <= -2.3e-28) {
tmp = fma(a, (y / (-1.0 - t)), x);
} else if (y <= 3.7e+99) {
tmp = fma(a, (z / (t + (1.0 - z))), x);
} else {
tmp = fma((y / (z - t)), a, x);
}
return tmp;
}
function code(x, y, z, t, a) tmp = 0.0 if (y <= -2.3e-28) tmp = fma(a, Float64(y / Float64(-1.0 - t)), x); elseif (y <= 3.7e+99) tmp = fma(a, Float64(z / Float64(t + Float64(1.0 - z))), x); else tmp = fma(Float64(y / Float64(z - t)), a, x); end return tmp end
code[x_, y_, z_, t_, a_] := If[LessEqual[y, -2.3e-28], N[(a * N[(y / N[(-1.0 - t), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[y, 3.7e+99], N[(a * N[(z / N[(t + N[(1.0 - z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision], N[(N[(y / N[(z - t), $MachinePrecision]), $MachinePrecision] * a + x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -2.3 \cdot 10^{-28}:\\
\;\;\;\;\mathsf{fma}\left(a, \frac{y}{-1 - t}, x\right)\\
\mathbf{elif}\;y \leq 3.7 \cdot 10^{+99}:\\
\;\;\;\;\mathsf{fma}\left(a, \frac{z}{t + \left(1 - z\right)}, x\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\frac{y}{z - t}, a, x\right)\\
\end{array}
\end{array}
if y < -2.29999999999999986e-28Initial program 99.9%
Taylor expanded in z around 0
sub-negN/A
+-commutativeN/A
associate-/l*N/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
distribute-neg-frac2N/A
lower-/.f64N/A
distribute-neg-inN/A
metadata-evalN/A
unsub-negN/A
lower--.f6487.4
Simplified87.4%
if -2.29999999999999986e-28 < y < 3.7000000000000001e99Initial program 98.5%
Taylor expanded in y around 0
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
associate--l+N/A
lower-+.f64N/A
lower--.f6494.7
Simplified94.7%
if 3.7000000000000001e99 < y Initial program 92.5%
lift--.f64N/A
lift--.f64N/A
lift-+.f64N/A
frac-2negN/A
frac-2negN/A
lift-/.f64N/A
lift-/.f64N/A
sub-negN/A
+-commutativeN/A
lift-/.f64N/A
lift-/.f64N/A
associate-/r/N/A
distribute-lft-neg-inN/A
distribute-frac-neg2N/A
lower-fma.f64N/A
Applied egg-rr99.8%
Taylor expanded in y around inf
lower-/.f64N/A
sub-negN/A
mul-1-negN/A
lower-+.f64N/A
distribute-lft-inN/A
metadata-evalN/A
mul-1-negN/A
unsub-negN/A
lower--.f6496.3
Simplified96.3%
Taylor expanded in t around inf
mul-1-negN/A
lower-neg.f6485.4
Simplified85.4%
Final simplification91.1%
(FPCore (x y z t a) :precision binary64 (if (<= y -2.05e-28) (fma a (/ y (- -1.0 t)) x) (if (<= y 3.7e+99) (fma a (/ z (- 1.0 z)) x) (fma (/ y (- z t)) a x))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (y <= -2.05e-28) {
tmp = fma(a, (y / (-1.0 - t)), x);
} else if (y <= 3.7e+99) {
tmp = fma(a, (z / (1.0 - z)), x);
} else {
tmp = fma((y / (z - t)), a, x);
}
return tmp;
}
function code(x, y, z, t, a) tmp = 0.0 if (y <= -2.05e-28) tmp = fma(a, Float64(y / Float64(-1.0 - t)), x); elseif (y <= 3.7e+99) tmp = fma(a, Float64(z / Float64(1.0 - z)), x); else tmp = fma(Float64(y / Float64(z - t)), a, x); end return tmp end
code[x_, y_, z_, t_, a_] := If[LessEqual[y, -2.05e-28], N[(a * N[(y / N[(-1.0 - t), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[y, 3.7e+99], N[(a * N[(z / N[(1.0 - z), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision], N[(N[(y / N[(z - t), $MachinePrecision]), $MachinePrecision] * a + x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -2.05 \cdot 10^{-28}:\\
\;\;\;\;\mathsf{fma}\left(a, \frac{y}{-1 - t}, x\right)\\
\mathbf{elif}\;y \leq 3.7 \cdot 10^{+99}:\\
\;\;\;\;\mathsf{fma}\left(a, \frac{z}{1 - z}, x\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(\frac{y}{z - t}, a, x\right)\\
\end{array}
\end{array}
if y < -2.0500000000000001e-28Initial program 99.9%
Taylor expanded in z around 0
sub-negN/A
+-commutativeN/A
associate-/l*N/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
distribute-neg-frac2N/A
lower-/.f64N/A
distribute-neg-inN/A
metadata-evalN/A
unsub-negN/A
lower--.f6487.4
Simplified87.4%
if -2.0500000000000001e-28 < y < 3.7000000000000001e99Initial program 98.5%
Taylor expanded in y around 0
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
associate--l+N/A
lower-+.f64N/A
lower--.f6494.7
Simplified94.7%
Taylor expanded in t around 0
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
lower--.f6484.6
Simplified84.6%
if 3.7000000000000001e99 < y Initial program 92.5%
lift--.f64N/A
lift--.f64N/A
lift-+.f64N/A
frac-2negN/A
frac-2negN/A
lift-/.f64N/A
lift-/.f64N/A
sub-negN/A
+-commutativeN/A
lift-/.f64N/A
lift-/.f64N/A
associate-/r/N/A
distribute-lft-neg-inN/A
distribute-frac-neg2N/A
lower-fma.f64N/A
Applied egg-rr99.8%
Taylor expanded in y around inf
lower-/.f64N/A
sub-negN/A
mul-1-negN/A
lower-+.f64N/A
distribute-lft-inN/A
metadata-evalN/A
mul-1-negN/A
unsub-negN/A
lower--.f6496.3
Simplified96.3%
Taylor expanded in t around inf
mul-1-negN/A
lower-neg.f6485.4
Simplified85.4%
Final simplification85.6%
(FPCore (x y z t a) :precision binary64 (if (<= z -2.6e+77) (- x a) (if (<= z 4.5e+24) (fma a (/ y (- -1.0 t)) x) (- x a))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -2.6e+77) {
tmp = x - a;
} else if (z <= 4.5e+24) {
tmp = fma(a, (y / (-1.0 - t)), x);
} else {
tmp = x - a;
}
return tmp;
}
function code(x, y, z, t, a) tmp = 0.0 if (z <= -2.6e+77) tmp = Float64(x - a); elseif (z <= 4.5e+24) tmp = fma(a, Float64(y / Float64(-1.0 - t)), x); else tmp = Float64(x - a); end return tmp end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -2.6e+77], N[(x - a), $MachinePrecision], If[LessEqual[z, 4.5e+24], N[(a * N[(y / N[(-1.0 - t), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision], N[(x - a), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2.6 \cdot 10^{+77}:\\
\;\;\;\;x - a\\
\mathbf{elif}\;z \leq 4.5 \cdot 10^{+24}:\\
\;\;\;\;\mathsf{fma}\left(a, \frac{y}{-1 - t}, x\right)\\
\mathbf{else}:\\
\;\;\;\;x - a\\
\end{array}
\end{array}
if z < -2.6000000000000002e77 or 4.50000000000000019e24 < z Initial program 96.6%
Taylor expanded in z around inf
lower--.f6481.3
Simplified81.3%
if -2.6000000000000002e77 < z < 4.50000000000000019e24Initial program 99.2%
Taylor expanded in z around 0
sub-negN/A
+-commutativeN/A
associate-/l*N/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
distribute-neg-frac2N/A
lower-/.f64N/A
distribute-neg-inN/A
metadata-evalN/A
unsub-negN/A
lower--.f6488.7
Simplified88.7%
(FPCore (x y z t a) :precision binary64 (let* ((t_1 (fma (/ y (- t)) a x))) (if (<= t -1.15e-5) t_1 (if (<= t 4e-19) (- x (* y a)) t_1))))
double code(double x, double y, double z, double t, double a) {
double t_1 = fma((y / -t), a, x);
double tmp;
if (t <= -1.15e-5) {
tmp = t_1;
} else if (t <= 4e-19) {
tmp = x - (y * a);
} else {
tmp = t_1;
}
return tmp;
}
function code(x, y, z, t, a) t_1 = fma(Float64(y / Float64(-t)), a, x) tmp = 0.0 if (t <= -1.15e-5) tmp = t_1; elseif (t <= 4e-19) tmp = Float64(x - Float64(y * a)); else tmp = t_1; end return tmp end
code[x_, y_, z_, t_, a_] := Block[{t$95$1 = N[(N[(y / (-t)), $MachinePrecision] * a + x), $MachinePrecision]}, If[LessEqual[t, -1.15e-5], t$95$1, If[LessEqual[t, 4e-19], N[(x - N[(y * a), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(\frac{y}{-t}, a, x\right)\\
\mathbf{if}\;t \leq -1.15 \cdot 10^{-5}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 4 \cdot 10^{-19}:\\
\;\;\;\;x - y \cdot a\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -1.15e-5 or 3.9999999999999999e-19 < t Initial program 96.8%
lift--.f64N/A
lift--.f64N/A
lift-+.f64N/A
frac-2negN/A
frac-2negN/A
lift-/.f64N/A
lift-/.f64N/A
sub-negN/A
+-commutativeN/A
lift-/.f64N/A
lift-/.f64N/A
associate-/r/N/A
distribute-lft-neg-inN/A
distribute-frac-neg2N/A
lower-fma.f64N/A
Applied egg-rr99.9%
Taylor expanded in y around inf
lower-/.f64N/A
sub-negN/A
mul-1-negN/A
lower-+.f64N/A
distribute-lft-inN/A
metadata-evalN/A
mul-1-negN/A
unsub-negN/A
lower--.f6485.3
Simplified85.3%
Taylor expanded in t around inf
associate-*r/N/A
lower-/.f64N/A
mul-1-negN/A
lower-neg.f6480.7
Simplified80.7%
if -1.15e-5 < t < 3.9999999999999999e-19Initial program 99.8%
Taylor expanded in t around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower--.f64N/A
lower-neg.f64N/A
lower-/.f64N/A
lower--.f6499.7
Simplified99.7%
Taylor expanded in z around 0
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
lower-*.f6472.4
Simplified72.4%
Final simplification77.3%
(FPCore (x y z t a)
:precision binary64
(if (<= z -9.2e+45)
(- x a)
(if (<= z -1.8e-83)
(fma a (/ z t) x)
(if (<= z 0.00023) (fma (- y z) (- a) x) (- x a)))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -9.2e+45) {
tmp = x - a;
} else if (z <= -1.8e-83) {
tmp = fma(a, (z / t), x);
} else if (z <= 0.00023) {
tmp = fma((y - z), -a, x);
} else {
tmp = x - a;
}
return tmp;
}
function code(x, y, z, t, a) tmp = 0.0 if (z <= -9.2e+45) tmp = Float64(x - a); elseif (z <= -1.8e-83) tmp = fma(a, Float64(z / t), x); elseif (z <= 0.00023) tmp = fma(Float64(y - z), Float64(-a), x); else tmp = Float64(x - a); end return tmp end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -9.2e+45], N[(x - a), $MachinePrecision], If[LessEqual[z, -1.8e-83], N[(a * N[(z / t), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[z, 0.00023], N[(N[(y - z), $MachinePrecision] * (-a) + x), $MachinePrecision], N[(x - a), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -9.2 \cdot 10^{+45}:\\
\;\;\;\;x - a\\
\mathbf{elif}\;z \leq -1.8 \cdot 10^{-83}:\\
\;\;\;\;\mathsf{fma}\left(a, \frac{z}{t}, x\right)\\
\mathbf{elif}\;z \leq 0.00023:\\
\;\;\;\;\mathsf{fma}\left(y - z, -a, x\right)\\
\mathbf{else}:\\
\;\;\;\;x - a\\
\end{array}
\end{array}
if z < -9.20000000000000049e45 or 2.3000000000000001e-4 < z Initial program 96.8%
Taylor expanded in z around inf
lower--.f6477.2
Simplified77.2%
if -9.20000000000000049e45 < z < -1.80000000000000006e-83Initial program 97.0%
Taylor expanded in y around 0
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
associate--l+N/A
lower-+.f64N/A
lower--.f6475.1
Simplified75.1%
Taylor expanded in t around inf
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f6469.3
Simplified69.3%
if -1.80000000000000006e-83 < z < 2.3000000000000001e-4Initial program 99.8%
Taylor expanded in t around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower--.f64N/A
lower-neg.f64N/A
lower-/.f64N/A
lower--.f6472.5
Simplified72.5%
Taylor expanded in z around 0
mul-1-negN/A
lower-neg.f6472.3
Simplified72.3%
(FPCore (x y z t a) :precision binary64 (fma (/ a (+ -1.0 (- z t))) (- y z) x))
double code(double x, double y, double z, double t, double a) {
return fma((a / (-1.0 + (z - t))), (y - z), x);
}
function code(x, y, z, t, a) return fma(Float64(a / Float64(-1.0 + Float64(z - t))), Float64(y - z), x) end
code[x_, y_, z_, t_, a_] := N[(N[(a / N[(-1.0 + N[(z - t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(y - z), $MachinePrecision] + x), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(\frac{a}{-1 + \left(z - t\right)}, y - z, x\right)
\end{array}
Initial program 98.0%
lift--.f64N/A
lift--.f64N/A
lift-+.f64N/A
frac-2negN/A
frac-2negN/A
lift-/.f64N/A
lift-/.f64N/A
sub-negN/A
+-commutativeN/A
Applied egg-rr98.2%
Final simplification98.2%
(FPCore (x y z t a) :precision binary64 (if (<= z -8e-15) (- x a) (if (<= z 0.00023) (fma (- y z) (- a) x) (- x a))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -8e-15) {
tmp = x - a;
} else if (z <= 0.00023) {
tmp = fma((y - z), -a, x);
} else {
tmp = x - a;
}
return tmp;
}
function code(x, y, z, t, a) tmp = 0.0 if (z <= -8e-15) tmp = Float64(x - a); elseif (z <= 0.00023) tmp = fma(Float64(y - z), Float64(-a), x); else tmp = Float64(x - a); end return tmp end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -8e-15], N[(x - a), $MachinePrecision], If[LessEqual[z, 0.00023], N[(N[(y - z), $MachinePrecision] * (-a) + x), $MachinePrecision], N[(x - a), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -8 \cdot 10^{-15}:\\
\;\;\;\;x - a\\
\mathbf{elif}\;z \leq 0.00023:\\
\;\;\;\;\mathsf{fma}\left(y - z, -a, x\right)\\
\mathbf{else}:\\
\;\;\;\;x - a\\
\end{array}
\end{array}
if z < -8.0000000000000006e-15 or 2.3000000000000001e-4 < z Initial program 97.2%
Taylor expanded in z around inf
lower--.f6472.2
Simplified72.2%
if -8.0000000000000006e-15 < z < 2.3000000000000001e-4Initial program 99.1%
Taylor expanded in t around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower--.f64N/A
lower-neg.f64N/A
lower-/.f64N/A
lower--.f6471.8
Simplified71.8%
Taylor expanded in z around 0
mul-1-negN/A
lower-neg.f6471.6
Simplified71.6%
(FPCore (x y z t a) :precision binary64 (if (<= z -3.3e-14) (- x a) (if (<= z 3.6e+15) (- x (* y a)) (- x a))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -3.3e-14) {
tmp = x - a;
} else if (z <= 3.6e+15) {
tmp = x - (y * a);
} else {
tmp = x - 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) :: tmp
if (z <= (-3.3d-14)) then
tmp = x - a
else if (z <= 3.6d+15) then
tmp = x - (y * a)
else
tmp = x - a
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -3.3e-14) {
tmp = x - a;
} else if (z <= 3.6e+15) {
tmp = x - (y * a);
} else {
tmp = x - a;
}
return tmp;
}
def code(x, y, z, t, a): tmp = 0 if z <= -3.3e-14: tmp = x - a elif z <= 3.6e+15: tmp = x - (y * a) else: tmp = x - a return tmp
function code(x, y, z, t, a) tmp = 0.0 if (z <= -3.3e-14) tmp = Float64(x - a); elseif (z <= 3.6e+15) tmp = Float64(x - Float64(y * a)); else tmp = Float64(x - a); end return tmp end
function tmp_2 = code(x, y, z, t, a) tmp = 0.0; if (z <= -3.3e-14) tmp = x - a; elseif (z <= 3.6e+15) tmp = x - (y * a); else tmp = x - a; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -3.3e-14], N[(x - a), $MachinePrecision], If[LessEqual[z, 3.6e+15], N[(x - N[(y * a), $MachinePrecision]), $MachinePrecision], N[(x - a), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -3.3 \cdot 10^{-14}:\\
\;\;\;\;x - a\\
\mathbf{elif}\;z \leq 3.6 \cdot 10^{+15}:\\
\;\;\;\;x - y \cdot a\\
\mathbf{else}:\\
\;\;\;\;x - a\\
\end{array}
\end{array}
if z < -3.2999999999999998e-14 or 3.6e15 < z Initial program 97.1%
Taylor expanded in z around inf
lower--.f6474.7
Simplified74.7%
if -3.2999999999999998e-14 < z < 3.6e15Initial program 99.1%
Taylor expanded in t around 0
sub-negN/A
+-commutativeN/A
*-commutativeN/A
associate-/l*N/A
distribute-rgt-neg-inN/A
lower-fma.f64N/A
lower--.f64N/A
lower-neg.f64N/A
lower-/.f64N/A
lower--.f6470.0
Simplified70.0%
Taylor expanded in z around 0
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
lower-*.f6465.5
Simplified65.5%
Final simplification70.3%
(FPCore (x y z t a) :precision binary64 (if (<= z -1.0) (- x a) (if (<= z 0.00023) (fma a z x) (- x a))))
double code(double x, double y, double z, double t, double a) {
double tmp;
if (z <= -1.0) {
tmp = x - a;
} else if (z <= 0.00023) {
tmp = fma(a, z, x);
} else {
tmp = x - a;
}
return tmp;
}
function code(x, y, z, t, a) tmp = 0.0 if (z <= -1.0) tmp = Float64(x - a); elseif (z <= 0.00023) tmp = fma(a, z, x); else tmp = Float64(x - a); end return tmp end
code[x_, y_, z_, t_, a_] := If[LessEqual[z, -1.0], N[(x - a), $MachinePrecision], If[LessEqual[z, 0.00023], N[(a * z + x), $MachinePrecision], N[(x - a), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1:\\
\;\;\;\;x - a\\
\mathbf{elif}\;z \leq 0.00023:\\
\;\;\;\;\mathsf{fma}\left(a, z, x\right)\\
\mathbf{else}:\\
\;\;\;\;x - a\\
\end{array}
\end{array}
if z < -1 or 2.3000000000000001e-4 < z Initial program 97.1%
Taylor expanded in z around inf
lower--.f6472.8
Simplified72.8%
if -1 < z < 2.3000000000000001e-4Initial program 99.1%
Taylor expanded in y around 0
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
+-commutativeN/A
associate-/l*N/A
lower-fma.f64N/A
lower-/.f64N/A
+-commutativeN/A
associate--l+N/A
lower-+.f64N/A
lower--.f6461.1
Simplified61.1%
Taylor expanded in z around 0
Simplified60.3%
Taylor expanded in t around 0
+-commutativeN/A
lower-fma.f6458.1
Simplified58.1%
(FPCore (x y z t a) :precision binary64 (- x a))
double code(double x, double y, double z, double t, double a) {
return x - 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 - a
end function
public static double code(double x, double y, double z, double t, double a) {
return x - a;
}
def code(x, y, z, t, a): return x - a
function code(x, y, z, t, a) return Float64(x - a) end
function tmp = code(x, y, z, t, a) tmp = x - a; end
code[x_, y_, z_, t_, a_] := N[(x - a), $MachinePrecision]
\begin{array}{l}
\\
x - a
\end{array}
Initial program 98.0%
Taylor expanded in z around inf
lower--.f6459.3
Simplified59.3%
(FPCore (x y z t a) :precision binary64 (- a))
double code(double x, double y, double z, double t, double a) {
return -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 = -a
end function
public static double code(double x, double y, double z, double t, double a) {
return -a;
}
def code(x, y, z, t, a): return -a
function code(x, y, z, t, a) return Float64(-a) end
function tmp = code(x, y, z, t, a) tmp = -a; end
code[x_, y_, z_, t_, a_] := (-a)
\begin{array}{l}
\\
-a
\end{array}
Initial program 98.0%
Taylor expanded in z around inf
lower--.f6459.3
Simplified59.3%
Taylor expanded in x around 0
mul-1-negN/A
lower-neg.f6412.8
Simplified12.8%
(FPCore (x y z t a) :precision binary64 (- x (* (/ (- y z) (+ (- t z) 1.0)) a)))
double code(double x, double y, double z, double t, double a) {
return x - (((y - z) / ((t - z) + 1.0)) * 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) + 1.0d0)) * a)
end function
public static double code(double x, double y, double z, double t, double a) {
return x - (((y - z) / ((t - z) + 1.0)) * a);
}
def code(x, y, z, t, a): return x - (((y - z) / ((t - z) + 1.0)) * a)
function code(x, y, z, t, a) return Float64(x - Float64(Float64(Float64(y - z) / Float64(Float64(t - z) + 1.0)) * a)) end
function tmp = code(x, y, z, t, a) tmp = x - (((y - z) / ((t - z) + 1.0)) * a); end
code[x_, y_, z_, t_, a_] := N[(x - N[(N[(N[(y - z), $MachinePrecision] / N[(N[(t - z), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x - \frac{y - z}{\left(t - z\right) + 1} \cdot a
\end{array}
herbie shell --seed 2024207
(FPCore (x y z t a)
:name "Graphics.Rendering.Chart.SparkLine:renderSparkLine from Chart-1.5.3"
:precision binary64
:alt
(! :herbie-platform default (- x (* (/ (- y z) (+ (- t z) 1)) a)))
(- x (/ (- y z) (/ (+ (- t z) 1.0) a))))