
(FPCore (x y z) :precision binary64 (exp (- (+ x (* y (log y))) z)))
double code(double x, double y, double z) {
return exp(((x + (y * log(y))) - z));
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = exp(((x + (y * log(y))) - z))
end function
public static double code(double x, double y, double z) {
return Math.exp(((x + (y * Math.log(y))) - z));
}
def code(x, y, z): return math.exp(((x + (y * math.log(y))) - z))
function code(x, y, z) return exp(Float64(Float64(x + Float64(y * log(y))) - z)) end
function tmp = code(x, y, z) tmp = exp(((x + (y * log(y))) - z)); end
code[x_, y_, z_] := N[Exp[N[(N[(x + N[(y * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
e^{\left(x + y \cdot \log y\right) - z}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 22 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z) :precision binary64 (exp (- (+ x (* y (log y))) z)))
double code(double x, double y, double z) {
return exp(((x + (y * log(y))) - z));
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = exp(((x + (y * log(y))) - z))
end function
public static double code(double x, double y, double z) {
return Math.exp(((x + (y * Math.log(y))) - z));
}
def code(x, y, z): return math.exp(((x + (y * math.log(y))) - z))
function code(x, y, z) return exp(Float64(Float64(x + Float64(y * log(y))) - z)) end
function tmp = code(x, y, z) tmp = exp(((x + (y * log(y))) - z)); end
code[x_, y_, z_] := N[Exp[N[(N[(x + N[(y * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
e^{\left(x + y \cdot \log y\right) - z}
\end{array}
(FPCore (x y z) :precision binary64 (exp (- (+ x (* y (log y))) z)))
double code(double x, double y, double z) {
return exp(((x + (y * log(y))) - z));
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = exp(((x + (y * log(y))) - z))
end function
public static double code(double x, double y, double z) {
return Math.exp(((x + (y * Math.log(y))) - z));
}
def code(x, y, z): return math.exp(((x + (y * math.log(y))) - z))
function code(x, y, z) return exp(Float64(Float64(x + Float64(y * log(y))) - z)) end
function tmp = code(x, y, z) tmp = exp(((x + (y * log(y))) - z)); end
code[x_, y_, z_] := N[Exp[N[(N[(x + N[(y * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
e^{\left(x + y \cdot \log y\right) - z}
\end{array}
Initial program 100.0%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (+ x (* y (log y)))))
(if (<= t_0 -50.0)
(exp x)
(if (<= t_0 -1e-147)
(/ 1.0 (fma z (fma z (fma z (* z -0.25) 0.5) 1.0) 1.0))
(if (<= t_0 50000.0)
(fma z (fma z (fma z -0.16666666666666666 0.5) -1.0) 1.0)
(pow y y))))))
double code(double x, double y, double z) {
double t_0 = x + (y * log(y));
double tmp;
if (t_0 <= -50.0) {
tmp = exp(x);
} else if (t_0 <= -1e-147) {
tmp = 1.0 / fma(z, fma(z, fma(z, (z * -0.25), 0.5), 1.0), 1.0);
} else if (t_0 <= 50000.0) {
tmp = fma(z, fma(z, fma(z, -0.16666666666666666, 0.5), -1.0), 1.0);
} else {
tmp = pow(y, y);
}
return tmp;
}
function code(x, y, z) t_0 = Float64(x + Float64(y * log(y))) tmp = 0.0 if (t_0 <= -50.0) tmp = exp(x); elseif (t_0 <= -1e-147) tmp = Float64(1.0 / fma(z, fma(z, fma(z, Float64(z * -0.25), 0.5), 1.0), 1.0)); elseif (t_0 <= 50000.0) tmp = fma(z, fma(z, fma(z, -0.16666666666666666, 0.5), -1.0), 1.0); else tmp = y ^ y; end return tmp end
code[x_, y_, z_] := Block[{t$95$0 = N[(x + N[(y * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, -50.0], N[Exp[x], $MachinePrecision], If[LessEqual[t$95$0, -1e-147], N[(1.0 / N[(z * N[(z * N[(z * N[(z * -0.25), $MachinePrecision] + 0.5), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, 50000.0], N[(z * N[(z * N[(z * -0.16666666666666666 + 0.5), $MachinePrecision] + -1.0), $MachinePrecision] + 1.0), $MachinePrecision], N[Power[y, y], $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := x + y \cdot \log y\\
\mathbf{if}\;t\_0 \leq -50:\\
\;\;\;\;e^{x}\\
\mathbf{elif}\;t\_0 \leq -1 \cdot 10^{-147}:\\
\;\;\;\;\frac{1}{\mathsf{fma}\left(z, \mathsf{fma}\left(z, \mathsf{fma}\left(z, z \cdot -0.25, 0.5\right), 1\right), 1\right)}\\
\mathbf{elif}\;t\_0 \leq 50000:\\
\;\;\;\;\mathsf{fma}\left(z, \mathsf{fma}\left(z, \mathsf{fma}\left(z, -0.16666666666666666, 0.5\right), -1\right), 1\right)\\
\mathbf{else}:\\
\;\;\;\;{y}^{y}\\
\end{array}
\end{array}
if (+.f64 x (*.f64 y (log.f64 y))) < -50Initial program 99.9%
Taylor expanded in y around 0
lower-exp.f64N/A
lower--.f6498.7
Simplified98.7%
Taylor expanded in z around 0
lower-exp.f6489.4
Simplified89.4%
if -50 < (+.f64 x (*.f64 y (log.f64 y))) < -9.9999999999999997e-148Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6495.6
Simplified95.6%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f6456.5
Simplified56.5%
lift-fma.f64N/A
flip-+N/A
clear-numN/A
lower-/.f64N/A
clear-numN/A
flip-+N/A
lift-fma.f64N/A
lower-/.f6456.5
Applied egg-rr56.5%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6481.8
Simplified81.8%
if -9.9999999999999997e-148 < (+.f64 x (*.f64 y (log.f64 y))) < 5e4Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f64100.0
Simplified100.0%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
metadata-evalN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f6474.9
Simplified74.9%
if 5e4 < (+.f64 x (*.f64 y (log.f64 y))) Initial program 100.0%
Taylor expanded in y around inf
mul-1-negN/A
distribute-rgt-neg-inN/A
log-recN/A
remove-double-negN/A
lower-*.f64N/A
lower-log.f6476.5
Simplified76.5%
lift-log.f64N/A
*-commutativeN/A
lift-log.f64N/A
pow-to-expN/A
lift-pow.f6476.5
Applied egg-rr76.5%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (- (+ x (* y (log y))) z)))
(if (<= t_0 -4e+107)
(/ 1.0 (fma z (fma z (fma z (* z -0.25) 0.5) 1.0) 1.0))
(if (<= t_0 -5e+21)
(/ 1.0 (/ (+ 2.0 (/ (+ 4.0 (/ (+ 4.0 (/ -8.0 (* z z))) z)) z)) (* z z)))
(if (<= t_0 2e+139)
(/
(fma z (* z (* (fma z 0.5 -1.0) (fma z 0.5 -1.0))) -1.0)
(fma z (fma z 0.5 -1.0) -1.0))
(fma (* z (fma (* z z) 0.25 -1.0)) (/ 1.0 (fma z 0.5 1.0)) 1.0))))))
double code(double x, double y, double z) {
double t_0 = (x + (y * log(y))) - z;
double tmp;
if (t_0 <= -4e+107) {
tmp = 1.0 / fma(z, fma(z, fma(z, (z * -0.25), 0.5), 1.0), 1.0);
} else if (t_0 <= -5e+21) {
tmp = 1.0 / ((2.0 + ((4.0 + ((4.0 + (-8.0 / (z * z))) / z)) / z)) / (z * z));
} else if (t_0 <= 2e+139) {
tmp = fma(z, (z * (fma(z, 0.5, -1.0) * fma(z, 0.5, -1.0))), -1.0) / fma(z, fma(z, 0.5, -1.0), -1.0);
} else {
tmp = fma((z * fma((z * z), 0.25, -1.0)), (1.0 / fma(z, 0.5, 1.0)), 1.0);
}
return tmp;
}
function code(x, y, z) t_0 = Float64(Float64(x + Float64(y * log(y))) - z) tmp = 0.0 if (t_0 <= -4e+107) tmp = Float64(1.0 / fma(z, fma(z, fma(z, Float64(z * -0.25), 0.5), 1.0), 1.0)); elseif (t_0 <= -5e+21) tmp = Float64(1.0 / Float64(Float64(2.0 + Float64(Float64(4.0 + Float64(Float64(4.0 + Float64(-8.0 / Float64(z * z))) / z)) / z)) / Float64(z * z))); elseif (t_0 <= 2e+139) tmp = Float64(fma(z, Float64(z * Float64(fma(z, 0.5, -1.0) * fma(z, 0.5, -1.0))), -1.0) / fma(z, fma(z, 0.5, -1.0), -1.0)); else tmp = fma(Float64(z * fma(Float64(z * z), 0.25, -1.0)), Float64(1.0 / fma(z, 0.5, 1.0)), 1.0); end return tmp end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[(x + N[(y * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision]}, If[LessEqual[t$95$0, -4e+107], N[(1.0 / N[(z * N[(z * N[(z * N[(z * -0.25), $MachinePrecision] + 0.5), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, -5e+21], N[(1.0 / N[(N[(2.0 + N[(N[(4.0 + N[(N[(4.0 + N[(-8.0 / N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision] / N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, 2e+139], N[(N[(z * N[(z * N[(N[(z * 0.5 + -1.0), $MachinePrecision] * N[(z * 0.5 + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision] / N[(z * N[(z * 0.5 + -1.0), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision], N[(N[(z * N[(N[(z * z), $MachinePrecision] * 0.25 + -1.0), $MachinePrecision]), $MachinePrecision] * N[(1.0 / N[(z * 0.5 + 1.0), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(x + y \cdot \log y\right) - z\\
\mathbf{if}\;t\_0 \leq -4 \cdot 10^{+107}:\\
\;\;\;\;\frac{1}{\mathsf{fma}\left(z, \mathsf{fma}\left(z, \mathsf{fma}\left(z, z \cdot -0.25, 0.5\right), 1\right), 1\right)}\\
\mathbf{elif}\;t\_0 \leq -5 \cdot 10^{+21}:\\
\;\;\;\;\frac{1}{\frac{2 + \frac{4 + \frac{4 + \frac{-8}{z \cdot z}}{z}}{z}}{z \cdot z}}\\
\mathbf{elif}\;t\_0 \leq 2 \cdot 10^{+139}:\\
\;\;\;\;\frac{\mathsf{fma}\left(z, z \cdot \left(\mathsf{fma}\left(z, 0.5, -1\right) \cdot \mathsf{fma}\left(z, 0.5, -1\right)\right), -1\right)}{\mathsf{fma}\left(z, \mathsf{fma}\left(z, 0.5, -1\right), -1\right)}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(z \cdot \mathsf{fma}\left(z \cdot z, 0.25, -1\right), \frac{1}{\mathsf{fma}\left(z, 0.5, 1\right)}, 1\right)\\
\end{array}
\end{array}
if (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z) < -3.9999999999999999e107Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6464.9
Simplified64.9%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f642.1
Simplified2.1%
lift-fma.f64N/A
flip-+N/A
clear-numN/A
lower-/.f64N/A
clear-numN/A
flip-+N/A
lift-fma.f64N/A
lower-/.f642.1
Applied egg-rr2.1%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6468.5
Simplified68.5%
if -3.9999999999999999e107 < (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z) < -5e21Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6431.4
Simplified31.4%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f642.9
Simplified2.9%
lift-fma.f64N/A
flip-+N/A
clear-numN/A
lower-/.f64N/A
clear-numN/A
flip-+N/A
lift-fma.f64N/A
lower-/.f642.9
Applied egg-rr2.9%
Taylor expanded in z around -inf
lower-/.f64N/A
Simplified37.8%
if -5e21 < (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z) < 2.00000000000000007e139Initial program 99.9%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6449.0
Simplified49.0%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f6438.0
Simplified38.0%
lift-fma.f64N/A
flip-+N/A
lower-/.f64N/A
metadata-evalN/A
sub-negN/A
swap-sqrN/A
associate-*l*N/A
associate-*l*N/A
metadata-evalN/A
lower-fma.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f64N/A
sub-negN/A
metadata-evalN/A
lower-fma.f6446.6
Applied egg-rr46.6%
if 2.00000000000000007e139 < (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z) Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6441.2
Simplified41.2%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f6444.7
Simplified44.7%
lift-fma.f64N/A
*-commutativeN/A
lift-fma.f64N/A
flip-+N/A
associate-*l/N/A
div-invN/A
lower-fma.f64N/A
Applied egg-rr49.2%
(FPCore (x y z) :precision binary64 (let* ((t_0 (+ x (* y (log y))))) (if (<= t_0 -50.0) (exp x) (if (<= t_0 50000.0) (exp (- z)) (pow y y)))))
double code(double x, double y, double z) {
double t_0 = x + (y * log(y));
double tmp;
if (t_0 <= -50.0) {
tmp = exp(x);
} else if (t_0 <= 50000.0) {
tmp = exp(-z);
} else {
tmp = pow(y, y);
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: t_0
real(8) :: tmp
t_0 = x + (y * log(y))
if (t_0 <= (-50.0d0)) then
tmp = exp(x)
else if (t_0 <= 50000.0d0) then
tmp = exp(-z)
else
tmp = y ** y
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = x + (y * Math.log(y));
double tmp;
if (t_0 <= -50.0) {
tmp = Math.exp(x);
} else if (t_0 <= 50000.0) {
tmp = Math.exp(-z);
} else {
tmp = Math.pow(y, y);
}
return tmp;
}
def code(x, y, z): t_0 = x + (y * math.log(y)) tmp = 0 if t_0 <= -50.0: tmp = math.exp(x) elif t_0 <= 50000.0: tmp = math.exp(-z) else: tmp = math.pow(y, y) return tmp
function code(x, y, z) t_0 = Float64(x + Float64(y * log(y))) tmp = 0.0 if (t_0 <= -50.0) tmp = exp(x); elseif (t_0 <= 50000.0) tmp = exp(Float64(-z)); else tmp = y ^ y; end return tmp end
function tmp_2 = code(x, y, z) t_0 = x + (y * log(y)); tmp = 0.0; if (t_0 <= -50.0) tmp = exp(x); elseif (t_0 <= 50000.0) tmp = exp(-z); else tmp = y ^ y; end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(x + N[(y * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, -50.0], N[Exp[x], $MachinePrecision], If[LessEqual[t$95$0, 50000.0], N[Exp[(-z)], $MachinePrecision], N[Power[y, y], $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := x + y \cdot \log y\\
\mathbf{if}\;t\_0 \leq -50:\\
\;\;\;\;e^{x}\\
\mathbf{elif}\;t\_0 \leq 50000:\\
\;\;\;\;e^{-z}\\
\mathbf{else}:\\
\;\;\;\;{y}^{y}\\
\end{array}
\end{array}
if (+.f64 x (*.f64 y (log.f64 y))) < -50Initial program 99.9%
Taylor expanded in y around 0
lower-exp.f64N/A
lower--.f6498.7
Simplified98.7%
Taylor expanded in z around 0
lower-exp.f6489.4
Simplified89.4%
if -50 < (+.f64 x (*.f64 y (log.f64 y))) < 5e4Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6497.7
Simplified97.7%
if 5e4 < (+.f64 x (*.f64 y (log.f64 y))) Initial program 100.0%
Taylor expanded in y around inf
mul-1-negN/A
distribute-rgt-neg-inN/A
log-recN/A
remove-double-negN/A
lower-*.f64N/A
lower-log.f6476.5
Simplified76.5%
lift-log.f64N/A
*-commutativeN/A
lift-log.f64N/A
pow-to-expN/A
lift-pow.f6476.5
Applied egg-rr76.5%
(FPCore (x y z) :precision binary64 (if (<= (* y (log y)) -5e-303) (* (pow y y) (exp (- x z))) (exp (fma y (log y) x))))
double code(double x, double y, double z) {
double tmp;
if ((y * log(y)) <= -5e-303) {
tmp = pow(y, y) * exp((x - z));
} else {
tmp = exp(fma(y, log(y), x));
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (Float64(y * log(y)) <= -5e-303) tmp = Float64((y ^ y) * exp(Float64(x - z))); else tmp = exp(fma(y, log(y), x)); end return tmp end
code[x_, y_, z_] := If[LessEqual[N[(y * N[Log[y], $MachinePrecision]), $MachinePrecision], -5e-303], N[(N[Power[y, y], $MachinePrecision] * N[Exp[N[(x - z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[Exp[N[(y * N[Log[y], $MachinePrecision] + x), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \cdot \log y \leq -5 \cdot 10^{-303}:\\
\;\;\;\;{y}^{y} \cdot e^{x - z}\\
\mathbf{else}:\\
\;\;\;\;e^{\mathsf{fma}\left(y, \log y, x\right)}\\
\end{array}
\end{array}
if (*.f64 y (log.f64 y)) < -4.9999999999999998e-303Initial program 99.9%
lift-log.f64N/A
lift-*.f64N/A
+-commutativeN/A
associate--l+N/A
exp-sumN/A
lower-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-log.f64N/A
exp-to-powN/A
lower-pow.f64N/A
lower-exp.f64N/A
lower--.f64100.0
Applied egg-rr100.0%
if -4.9999999999999998e-303 < (*.f64 y (log.f64 y)) Initial program 100.0%
Taylor expanded in z around 0
lower-exp.f64N/A
+-commutativeN/A
lower-fma.f64N/A
lower-log.f6490.9
Simplified90.9%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (- (+ x (* y (log y))) z)))
(if (<= t_0 -2e+34)
(/ 1.0 (fma z (fma z (fma z (* z -0.25) 0.5) 1.0) 1.0))
(if (<= t_0 2e+139)
(/
(fma z (* z (* (fma z 0.5 -1.0) (fma z 0.5 -1.0))) -1.0)
(fma z (fma z 0.5 -1.0) -1.0))
(fma (* z (fma (* z z) 0.25 -1.0)) (/ 1.0 (fma z 0.5 1.0)) 1.0)))))
double code(double x, double y, double z) {
double t_0 = (x + (y * log(y))) - z;
double tmp;
if (t_0 <= -2e+34) {
tmp = 1.0 / fma(z, fma(z, fma(z, (z * -0.25), 0.5), 1.0), 1.0);
} else if (t_0 <= 2e+139) {
tmp = fma(z, (z * (fma(z, 0.5, -1.0) * fma(z, 0.5, -1.0))), -1.0) / fma(z, fma(z, 0.5, -1.0), -1.0);
} else {
tmp = fma((z * fma((z * z), 0.25, -1.0)), (1.0 / fma(z, 0.5, 1.0)), 1.0);
}
return tmp;
}
function code(x, y, z) t_0 = Float64(Float64(x + Float64(y * log(y))) - z) tmp = 0.0 if (t_0 <= -2e+34) tmp = Float64(1.0 / fma(z, fma(z, fma(z, Float64(z * -0.25), 0.5), 1.0), 1.0)); elseif (t_0 <= 2e+139) tmp = Float64(fma(z, Float64(z * Float64(fma(z, 0.5, -1.0) * fma(z, 0.5, -1.0))), -1.0) / fma(z, fma(z, 0.5, -1.0), -1.0)); else tmp = fma(Float64(z * fma(Float64(z * z), 0.25, -1.0)), Float64(1.0 / fma(z, 0.5, 1.0)), 1.0); end return tmp end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[(x + N[(y * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision]}, If[LessEqual[t$95$0, -2e+34], N[(1.0 / N[(z * N[(z * N[(z * N[(z * -0.25), $MachinePrecision] + 0.5), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, 2e+139], N[(N[(z * N[(z * N[(N[(z * 0.5 + -1.0), $MachinePrecision] * N[(z * 0.5 + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision] / N[(z * N[(z * 0.5 + -1.0), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision], N[(N[(z * N[(N[(z * z), $MachinePrecision] * 0.25 + -1.0), $MachinePrecision]), $MachinePrecision] * N[(1.0 / N[(z * 0.5 + 1.0), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(x + y \cdot \log y\right) - z\\
\mathbf{if}\;t\_0 \leq -2 \cdot 10^{+34}:\\
\;\;\;\;\frac{1}{\mathsf{fma}\left(z, \mathsf{fma}\left(z, \mathsf{fma}\left(z, z \cdot -0.25, 0.5\right), 1\right), 1\right)}\\
\mathbf{elif}\;t\_0 \leq 2 \cdot 10^{+139}:\\
\;\;\;\;\frac{\mathsf{fma}\left(z, z \cdot \left(\mathsf{fma}\left(z, 0.5, -1\right) \cdot \mathsf{fma}\left(z, 0.5, -1\right)\right), -1\right)}{\mathsf{fma}\left(z, \mathsf{fma}\left(z, 0.5, -1\right), -1\right)}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(z \cdot \mathsf{fma}\left(z \cdot z, 0.25, -1\right), \frac{1}{\mathsf{fma}\left(z, 0.5, 1\right)}, 1\right)\\
\end{array}
\end{array}
if (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z) < -1.99999999999999989e34Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6460.5
Simplified60.5%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f642.2
Simplified2.2%
lift-fma.f64N/A
flip-+N/A
clear-numN/A
lower-/.f64N/A
clear-numN/A
flip-+N/A
lift-fma.f64N/A
lower-/.f642.2
Applied egg-rr2.2%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6458.6
Simplified58.6%
if -1.99999999999999989e34 < (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z) < 2.00000000000000007e139Initial program 99.9%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6446.7
Simplified46.7%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f6436.3
Simplified36.3%
lift-fma.f64N/A
flip-+N/A
lower-/.f64N/A
metadata-evalN/A
sub-negN/A
swap-sqrN/A
associate-*l*N/A
associate-*l*N/A
metadata-evalN/A
lower-fma.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f64N/A
sub-negN/A
metadata-evalN/A
lower-fma.f6444.4
Applied egg-rr44.4%
if 2.00000000000000007e139 < (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z) Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6441.2
Simplified41.2%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f6444.7
Simplified44.7%
lift-fma.f64N/A
*-commutativeN/A
lift-fma.f64N/A
flip-+N/A
associate-*l/N/A
div-invN/A
lower-fma.f64N/A
Applied egg-rr49.2%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (- (+ x (* y (log y))) z)))
(if (<= t_0 2e-12)
(/ 1.0 (fma z (fma z (fma z (* z -0.25) 0.5) 1.0) 1.0))
(if (<= t_0 2e+139)
(/ (fma 0.25 (* (* z z) (* z z)) -1.0) (fma z (* z 0.5) -1.0))
(fma (* z (fma (* z z) 0.25 -1.0)) (/ 1.0 (fma z 0.5 1.0)) 1.0)))))
double code(double x, double y, double z) {
double t_0 = (x + (y * log(y))) - z;
double tmp;
if (t_0 <= 2e-12) {
tmp = 1.0 / fma(z, fma(z, fma(z, (z * -0.25), 0.5), 1.0), 1.0);
} else if (t_0 <= 2e+139) {
tmp = fma(0.25, ((z * z) * (z * z)), -1.0) / fma(z, (z * 0.5), -1.0);
} else {
tmp = fma((z * fma((z * z), 0.25, -1.0)), (1.0 / fma(z, 0.5, 1.0)), 1.0);
}
return tmp;
}
function code(x, y, z) t_0 = Float64(Float64(x + Float64(y * log(y))) - z) tmp = 0.0 if (t_0 <= 2e-12) tmp = Float64(1.0 / fma(z, fma(z, fma(z, Float64(z * -0.25), 0.5), 1.0), 1.0)); elseif (t_0 <= 2e+139) tmp = Float64(fma(0.25, Float64(Float64(z * z) * Float64(z * z)), -1.0) / fma(z, Float64(z * 0.5), -1.0)); else tmp = fma(Float64(z * fma(Float64(z * z), 0.25, -1.0)), Float64(1.0 / fma(z, 0.5, 1.0)), 1.0); end return tmp end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[(x + N[(y * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision]}, If[LessEqual[t$95$0, 2e-12], N[(1.0 / N[(z * N[(z * N[(z * N[(z * -0.25), $MachinePrecision] + 0.5), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, 2e+139], N[(N[(0.25 * N[(N[(z * z), $MachinePrecision] * N[(z * z), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision] / N[(z * N[(z * 0.5), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision], N[(N[(z * N[(N[(z * z), $MachinePrecision] * 0.25 + -1.0), $MachinePrecision]), $MachinePrecision] * N[(1.0 / N[(z * 0.5 + 1.0), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(x + y \cdot \log y\right) - z\\
\mathbf{if}\;t\_0 \leq 2 \cdot 10^{-12}:\\
\;\;\;\;\frac{1}{\mathsf{fma}\left(z, \mathsf{fma}\left(z, \mathsf{fma}\left(z, z \cdot -0.25, 0.5\right), 1\right), 1\right)}\\
\mathbf{elif}\;t\_0 \leq 2 \cdot 10^{+139}:\\
\;\;\;\;\frac{\mathsf{fma}\left(0.25, \left(z \cdot z\right) \cdot \left(z \cdot z\right), -1\right)}{\mathsf{fma}\left(z, z \cdot 0.5, -1\right)}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(z \cdot \mathsf{fma}\left(z \cdot z, 0.25, -1\right), \frac{1}{\mathsf{fma}\left(z, 0.5, 1\right)}, 1\right)\\
\end{array}
\end{array}
if (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z) < 1.99999999999999996e-12Initial program 99.9%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6466.5
Simplified66.5%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f6426.9
Simplified26.9%
lift-fma.f64N/A
flip-+N/A
clear-numN/A
lower-/.f64N/A
clear-numN/A
flip-+N/A
lift-fma.f64N/A
lower-/.f6426.9
Applied egg-rr26.9%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6465.2
Simplified65.2%
if 1.99999999999999996e-12 < (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z) < 2.00000000000000007e139Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6422.0
Simplified22.0%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f643.6
Simplified3.6%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f643.6
Simplified3.6%
lift-*.f64N/A
flip-+N/A
lower-/.f64N/A
metadata-evalN/A
sub-negN/A
pow2N/A
lift-*.f64N/A
associate-*r*N/A
lift-*.f64N/A
*-commutativeN/A
unpow-prod-downN/A
metadata-evalN/A
metadata-evalN/A
lower-fma.f64N/A
pow2N/A
lower-*.f64N/A
sub-negN/A
metadata-evalN/A
lower-fma.f6418.0
Applied egg-rr18.0%
if 2.00000000000000007e139 < (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z) Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6441.2
Simplified41.2%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f6444.7
Simplified44.7%
lift-fma.f64N/A
*-commutativeN/A
lift-fma.f64N/A
flip-+N/A
associate-*l/N/A
div-invN/A
lower-fma.f64N/A
Applied egg-rr49.2%
(FPCore (x y z) :precision binary64 (let* ((t_0 (- (+ x (* y (log y))) z)) (t_1 (* z (* z 0.5)))) (if (<= t_0 -200.0) t_1 (if (<= t_0 1.6e+108) (- 1.0 z) t_1))))
double code(double x, double y, double z) {
double t_0 = (x + (y * log(y))) - z;
double t_1 = z * (z * 0.5);
double tmp;
if (t_0 <= -200.0) {
tmp = t_1;
} else if (t_0 <= 1.6e+108) {
tmp = 1.0 - z;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = (x + (y * log(y))) - z
t_1 = z * (z * 0.5d0)
if (t_0 <= (-200.0d0)) then
tmp = t_1
else if (t_0 <= 1.6d+108) then
tmp = 1.0d0 - z
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double t_0 = (x + (y * Math.log(y))) - z;
double t_1 = z * (z * 0.5);
double tmp;
if (t_0 <= -200.0) {
tmp = t_1;
} else if (t_0 <= 1.6e+108) {
tmp = 1.0 - z;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z): t_0 = (x + (y * math.log(y))) - z t_1 = z * (z * 0.5) tmp = 0 if t_0 <= -200.0: tmp = t_1 elif t_0 <= 1.6e+108: tmp = 1.0 - z else: tmp = t_1 return tmp
function code(x, y, z) t_0 = Float64(Float64(x + Float64(y * log(y))) - z) t_1 = Float64(z * Float64(z * 0.5)) tmp = 0.0 if (t_0 <= -200.0) tmp = t_1; elseif (t_0 <= 1.6e+108) tmp = Float64(1.0 - z); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z) t_0 = (x + (y * log(y))) - z; t_1 = z * (z * 0.5); tmp = 0.0; if (t_0 <= -200.0) tmp = t_1; elseif (t_0 <= 1.6e+108) tmp = 1.0 - z; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_] := Block[{t$95$0 = N[(N[(x + N[(y * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision]}, Block[{t$95$1 = N[(z * N[(z * 0.5), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, -200.0], t$95$1, If[LessEqual[t$95$0, 1.6e+108], N[(1.0 - z), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(x + y \cdot \log y\right) - z\\
t_1 := z \cdot \left(z \cdot 0.5\right)\\
\mathbf{if}\;t\_0 \leq -200:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_0 \leq 1.6 \cdot 10^{+108}:\\
\;\;\;\;1 - z\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z) < -200 or 1.6e108 < (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z) Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6447.6
Simplified47.6%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f6424.8
Simplified24.8%
Taylor expanded in z around inf
unpow2N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6431.2
Simplified31.2%
if -200 < (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z) < 1.6e108Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6451.5
Simplified51.5%
Taylor expanded in z around 0
neg-mul-1N/A
unsub-negN/A
lower--.f6444.1
Simplified44.1%
(FPCore (x y z) :precision binary64 (if (<= z -1.9e+77) (exp (- x z)) (if (<= z 1e+19) (exp (fma y (log y) x)) (/ 1.0 (exp (- z x))))))
double code(double x, double y, double z) {
double tmp;
if (z <= -1.9e+77) {
tmp = exp((x - z));
} else if (z <= 1e+19) {
tmp = exp(fma(y, log(y), x));
} else {
tmp = 1.0 / exp((z - x));
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (z <= -1.9e+77) tmp = exp(Float64(x - z)); elseif (z <= 1e+19) tmp = exp(fma(y, log(y), x)); else tmp = Float64(1.0 / exp(Float64(z - x))); end return tmp end
code[x_, y_, z_] := If[LessEqual[z, -1.9e+77], N[Exp[N[(x - z), $MachinePrecision]], $MachinePrecision], If[LessEqual[z, 1e+19], N[Exp[N[(y * N[Log[y], $MachinePrecision] + x), $MachinePrecision]], $MachinePrecision], N[(1.0 / N[Exp[N[(z - x), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.9 \cdot 10^{+77}:\\
\;\;\;\;e^{x - z}\\
\mathbf{elif}\;z \leq 10^{+19}:\\
\;\;\;\;e^{\mathsf{fma}\left(y, \log y, x\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{e^{z - x}}\\
\end{array}
\end{array}
if z < -1.9000000000000001e77Initial program 100.0%
Taylor expanded in y around 0
lower-exp.f64N/A
lower--.f64100.0
Simplified100.0%
if -1.9000000000000001e77 < z < 1e19Initial program 100.0%
Taylor expanded in z around 0
lower-exp.f64N/A
+-commutativeN/A
lower-fma.f64N/A
lower-log.f6499.2
Simplified99.2%
if 1e19 < z Initial program 100.0%
Taylor expanded in y around 0
lower-exp.f64N/A
lower--.f6488.9
Simplified88.9%
exp-diffN/A
clear-numN/A
lower-/.f64N/A
div-expN/A
unpow1N/A
metadata-evalN/A
pow-divN/A
sqr-powN/A
pow-prod-downN/A
sqr-negN/A
lift-neg.f64N/A
lift-neg.f64N/A
unpow-prod-downN/A
sqr-powN/A
pow2N/A
lift-neg.f64N/A
cube-negN/A
neg-sub0N/A
metadata-evalN/A
+-lft-identityN/A
+-commutativeN/A
distribute-rgt-outN/A
+-lft-identityN/A
metadata-evalN/A
flip3--N/A
neg-sub0N/A
lift-neg.f64N/A
Applied egg-rr88.9%
(FPCore (x y z)
:precision binary64
(if (<= (- (+ x (* y (log y))) z) 2e+34)
(/ 1.0 (fma z (fma z (fma z (* z -0.25) 0.5) 1.0) 1.0))
(fma
z
(fma
(/ (+ 2.0 (/ -16.0 (* z (* z z)))) z)
(fma z (* z 0.25) (fma z -0.5 1.0))
(/ -1.0 (fma z 0.5 1.0)))
1.0)))
double code(double x, double y, double z) {
double tmp;
if (((x + (y * log(y))) - z) <= 2e+34) {
tmp = 1.0 / fma(z, fma(z, fma(z, (z * -0.25), 0.5), 1.0), 1.0);
} else {
tmp = fma(z, fma(((2.0 + (-16.0 / (z * (z * z)))) / z), fma(z, (z * 0.25), fma(z, -0.5, 1.0)), (-1.0 / fma(z, 0.5, 1.0))), 1.0);
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (Float64(Float64(x + Float64(y * log(y))) - z) <= 2e+34) tmp = Float64(1.0 / fma(z, fma(z, fma(z, Float64(z * -0.25), 0.5), 1.0), 1.0)); else tmp = fma(z, fma(Float64(Float64(2.0 + Float64(-16.0 / Float64(z * Float64(z * z)))) / z), fma(z, Float64(z * 0.25), fma(z, -0.5, 1.0)), Float64(-1.0 / fma(z, 0.5, 1.0))), 1.0); end return tmp end
code[x_, y_, z_] := If[LessEqual[N[(N[(x + N[(y * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision], 2e+34], N[(1.0 / N[(z * N[(z * N[(z * N[(z * -0.25), $MachinePrecision] + 0.5), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(z * N[(N[(N[(2.0 + N[(-16.0 / N[(z * N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision] * N[(z * N[(z * 0.25), $MachinePrecision] + N[(z * -0.5 + 1.0), $MachinePrecision]), $MachinePrecision] + N[(-1.0 / N[(z * 0.5 + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\left(x + y \cdot \log y\right) - z \leq 2 \cdot 10^{+34}:\\
\;\;\;\;\frac{1}{\mathsf{fma}\left(z, \mathsf{fma}\left(z, \mathsf{fma}\left(z, z \cdot -0.25, 0.5\right), 1\right), 1\right)}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(z, \mathsf{fma}\left(\frac{2 + \frac{-16}{z \cdot \left(z \cdot z\right)}}{z}, \mathsf{fma}\left(z, z \cdot 0.25, \mathsf{fma}\left(z, -0.5, 1\right)\right), \frac{-1}{\mathsf{fma}\left(z, 0.5, 1\right)}\right), 1\right)\\
\end{array}
\end{array}
if (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z) < 1.99999999999999989e34Initial program 99.9%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6462.2
Simplified62.2%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f6425.3
Simplified25.3%
lift-fma.f64N/A
flip-+N/A
clear-numN/A
lower-/.f64N/A
clear-numN/A
flip-+N/A
lift-fma.f64N/A
lower-/.f6425.3
Applied egg-rr25.3%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6461.0
Simplified61.0%
if 1.99999999999999989e34 < (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z) Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6437.1
Simplified37.1%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f6433.5
Simplified33.5%
flip-+N/A
metadata-evalN/A
div-subN/A
sub-negN/A
flip3--N/A
associate-/r/N/A
lower-fma.f64N/A
Applied egg-rr2.2%
Taylor expanded in z around inf
lower-/.f64N/A
sub-negN/A
lower-+.f64N/A
associate-*r/N/A
metadata-evalN/A
distribute-neg-fracN/A
lower-/.f64N/A
metadata-evalN/A
cube-multN/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6450.9
Simplified50.9%
Final simplification55.5%
(FPCore (x y z) :precision binary64 (if (<= (- (+ x (* y (log y))) z) -2e+34) (/ 1.0 (fma z (fma z (fma z (* z -0.25) 0.5) 1.0) 1.0)) (fma (* z (fma (* z z) 0.25 -1.0)) (/ 1.0 (fma z 0.5 1.0)) 1.0)))
double code(double x, double y, double z) {
double tmp;
if (((x + (y * log(y))) - z) <= -2e+34) {
tmp = 1.0 / fma(z, fma(z, fma(z, (z * -0.25), 0.5), 1.0), 1.0);
} else {
tmp = fma((z * fma((z * z), 0.25, -1.0)), (1.0 / fma(z, 0.5, 1.0)), 1.0);
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (Float64(Float64(x + Float64(y * log(y))) - z) <= -2e+34) tmp = Float64(1.0 / fma(z, fma(z, fma(z, Float64(z * -0.25), 0.5), 1.0), 1.0)); else tmp = fma(Float64(z * fma(Float64(z * z), 0.25, -1.0)), Float64(1.0 / fma(z, 0.5, 1.0)), 1.0); end return tmp end
code[x_, y_, z_] := If[LessEqual[N[(N[(x + N[(y * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision], -2e+34], N[(1.0 / N[(z * N[(z * N[(z * N[(z * -0.25), $MachinePrecision] + 0.5), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(N[(z * N[(N[(z * z), $MachinePrecision] * 0.25 + -1.0), $MachinePrecision]), $MachinePrecision] * N[(1.0 / N[(z * 0.5 + 1.0), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\left(x + y \cdot \log y\right) - z \leq -2 \cdot 10^{+34}:\\
\;\;\;\;\frac{1}{\mathsf{fma}\left(z, \mathsf{fma}\left(z, \mathsf{fma}\left(z, z \cdot -0.25, 0.5\right), 1\right), 1\right)}\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(z \cdot \mathsf{fma}\left(z \cdot z, 0.25, -1\right), \frac{1}{\mathsf{fma}\left(z, 0.5, 1\right)}, 1\right)\\
\end{array}
\end{array}
if (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z) < -1.99999999999999989e34Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6460.5
Simplified60.5%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f642.2
Simplified2.2%
lift-fma.f64N/A
flip-+N/A
clear-numN/A
lower-/.f64N/A
clear-numN/A
flip-+N/A
lift-fma.f64N/A
lower-/.f642.2
Applied egg-rr2.2%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6458.6
Simplified58.6%
if -1.99999999999999989e34 < (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z) Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6443.7
Simplified43.7%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f6440.9
Simplified40.9%
lift-fma.f64N/A
*-commutativeN/A
lift-fma.f64N/A
flip-+N/A
associate-*l/N/A
div-invN/A
lower-fma.f64N/A
Applied egg-rr44.5%
(FPCore (x y z) :precision binary64 (if (<= (+ x (* y (log y))) -200.0) (* z (* z 0.5)) (fma z (* z 0.5) 1.0)))
double code(double x, double y, double z) {
double tmp;
if ((x + (y * log(y))) <= -200.0) {
tmp = z * (z * 0.5);
} else {
tmp = fma(z, (z * 0.5), 1.0);
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (Float64(x + Float64(y * log(y))) <= -200.0) tmp = Float64(z * Float64(z * 0.5)); else tmp = fma(z, Float64(z * 0.5), 1.0); end return tmp end
code[x_, y_, z_] := If[LessEqual[N[(x + N[(y * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], -200.0], N[(z * N[(z * 0.5), $MachinePrecision]), $MachinePrecision], N[(z * N[(z * 0.5), $MachinePrecision] + 1.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x + y \cdot \log y \leq -200:\\
\;\;\;\;z \cdot \left(z \cdot 0.5\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(z, z \cdot 0.5, 1\right)\\
\end{array}
\end{array}
if (+.f64 x (*.f64 y (log.f64 y))) < -200Initial program 99.9%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6434.6
Simplified34.6%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f6412.0
Simplified12.0%
Taylor expanded in z around inf
unpow2N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6436.5
Simplified36.5%
if -200 < (+.f64 x (*.f64 y (log.f64 y))) Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6452.1
Simplified52.1%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f6434.2
Simplified34.2%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f6434.2
Simplified34.2%
(FPCore (x y z)
:precision binary64
(if (<= z -1.9e+154)
(* z (* z 0.5))
(if (<= z -1.15e+77)
(/ (fma 0.25 (* (* z z) (* z z)) -1.0) (fma z (* z 0.5) -1.0))
(if (<= z 6.5e+107)
(exp x)
(/ 1.0 (fma z (fma z (fma z (* z -0.25) 0.5) 1.0) 1.0))))))
double code(double x, double y, double z) {
double tmp;
if (z <= -1.9e+154) {
tmp = z * (z * 0.5);
} else if (z <= -1.15e+77) {
tmp = fma(0.25, ((z * z) * (z * z)), -1.0) / fma(z, (z * 0.5), -1.0);
} else if (z <= 6.5e+107) {
tmp = exp(x);
} else {
tmp = 1.0 / fma(z, fma(z, fma(z, (z * -0.25), 0.5), 1.0), 1.0);
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (z <= -1.9e+154) tmp = Float64(z * Float64(z * 0.5)); elseif (z <= -1.15e+77) tmp = Float64(fma(0.25, Float64(Float64(z * z) * Float64(z * z)), -1.0) / fma(z, Float64(z * 0.5), -1.0)); elseif (z <= 6.5e+107) tmp = exp(x); else tmp = Float64(1.0 / fma(z, fma(z, fma(z, Float64(z * -0.25), 0.5), 1.0), 1.0)); end return tmp end
code[x_, y_, z_] := If[LessEqual[z, -1.9e+154], N[(z * N[(z * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, -1.15e+77], N[(N[(0.25 * N[(N[(z * z), $MachinePrecision] * N[(z * z), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision] / N[(z * N[(z * 0.5), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 6.5e+107], N[Exp[x], $MachinePrecision], N[(1.0 / N[(z * N[(z * N[(z * N[(z * -0.25), $MachinePrecision] + 0.5), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.9 \cdot 10^{+154}:\\
\;\;\;\;z \cdot \left(z \cdot 0.5\right)\\
\mathbf{elif}\;z \leq -1.15 \cdot 10^{+77}:\\
\;\;\;\;\frac{\mathsf{fma}\left(0.25, \left(z \cdot z\right) \cdot \left(z \cdot z\right), -1\right)}{\mathsf{fma}\left(z, z \cdot 0.5, -1\right)}\\
\mathbf{elif}\;z \leq 6.5 \cdot 10^{+107}:\\
\;\;\;\;e^{x}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\mathsf{fma}\left(z, \mathsf{fma}\left(z, \mathsf{fma}\left(z, z \cdot -0.25, 0.5\right), 1\right), 1\right)}\\
\end{array}
\end{array}
if z < -1.8999999999999999e154Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6489.6
Simplified89.6%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f6489.6
Simplified89.6%
Taylor expanded in z around inf
unpow2N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6489.6
Simplified89.6%
if -1.8999999999999999e154 < z < -1.14999999999999997e77Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6490.2
Simplified90.2%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f645.7
Simplified5.7%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f645.7
Simplified5.7%
lift-*.f64N/A
flip-+N/A
lower-/.f64N/A
metadata-evalN/A
sub-negN/A
pow2N/A
lift-*.f64N/A
associate-*r*N/A
lift-*.f64N/A
*-commutativeN/A
unpow-prod-downN/A
metadata-evalN/A
metadata-evalN/A
lower-fma.f64N/A
pow2N/A
lower-*.f64N/A
sub-negN/A
metadata-evalN/A
lower-fma.f6490.2
Applied egg-rr90.2%
if -1.14999999999999997e77 < z < 6.5000000000000006e107Initial program 100.0%
Taylor expanded in y around 0
lower-exp.f64N/A
lower--.f6462.0
Simplified62.0%
Taylor expanded in z around 0
lower-exp.f6457.1
Simplified57.1%
if 6.5000000000000006e107 < z Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6476.5
Simplified76.5%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f6421.1
Simplified21.1%
lift-fma.f64N/A
flip-+N/A
clear-numN/A
lower-/.f64N/A
clear-numN/A
flip-+N/A
lift-fma.f64N/A
lower-/.f6421.1
Applied egg-rr21.1%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6476.5
Simplified76.5%
(FPCore (x y z) :precision binary64 (if (<= y 1.7e+66) (exp (- x z)) (pow y y)))
double code(double x, double y, double z) {
double tmp;
if (y <= 1.7e+66) {
tmp = exp((x - z));
} else {
tmp = pow(y, y);
}
return tmp;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: tmp
if (y <= 1.7d+66) then
tmp = exp((x - z))
else
tmp = y ** y
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (y <= 1.7e+66) {
tmp = Math.exp((x - z));
} else {
tmp = Math.pow(y, y);
}
return tmp;
}
def code(x, y, z): tmp = 0 if y <= 1.7e+66: tmp = math.exp((x - z)) else: tmp = math.pow(y, y) return tmp
function code(x, y, z) tmp = 0.0 if (y <= 1.7e+66) tmp = exp(Float64(x - z)); else tmp = y ^ y; end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (y <= 1.7e+66) tmp = exp((x - z)); else tmp = y ^ y; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[y, 1.7e+66], N[Exp[N[(x - z), $MachinePrecision]], $MachinePrecision], N[Power[y, y], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 1.7 \cdot 10^{+66}:\\
\;\;\;\;e^{x - z}\\
\mathbf{else}:\\
\;\;\;\;{y}^{y}\\
\end{array}
\end{array}
if y < 1.70000000000000015e66Initial program 100.0%
Taylor expanded in y around 0
lower-exp.f64N/A
lower--.f6491.9
Simplified91.9%
if 1.70000000000000015e66 < y Initial program 100.0%
Taylor expanded in y around inf
mul-1-negN/A
distribute-rgt-neg-inN/A
log-recN/A
remove-double-negN/A
lower-*.f64N/A
lower-log.f6485.8
Simplified85.8%
lift-log.f64N/A
*-commutativeN/A
lift-log.f64N/A
pow-to-expN/A
lift-pow.f6485.8
Applied egg-rr85.8%
(FPCore (x y z)
:precision binary64
(if (<= z -3.1e+88)
(fma z (fma z (fma z -0.16666666666666666 0.5) -1.0) 1.0)
(if (<= z 3.15e+106)
(fma x (fma x 0.5 1.0) 1.0)
(/ 1.0 (fma z (fma z (fma z (* z -0.25) 0.5) 1.0) 1.0)))))
double code(double x, double y, double z) {
double tmp;
if (z <= -3.1e+88) {
tmp = fma(z, fma(z, fma(z, -0.16666666666666666, 0.5), -1.0), 1.0);
} else if (z <= 3.15e+106) {
tmp = fma(x, fma(x, 0.5, 1.0), 1.0);
} else {
tmp = 1.0 / fma(z, fma(z, fma(z, (z * -0.25), 0.5), 1.0), 1.0);
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (z <= -3.1e+88) tmp = fma(z, fma(z, fma(z, -0.16666666666666666, 0.5), -1.0), 1.0); elseif (z <= 3.15e+106) tmp = fma(x, fma(x, 0.5, 1.0), 1.0); else tmp = Float64(1.0 / fma(z, fma(z, fma(z, Float64(z * -0.25), 0.5), 1.0), 1.0)); end return tmp end
code[x_, y_, z_] := If[LessEqual[z, -3.1e+88], N[(z * N[(z * N[(z * -0.16666666666666666 + 0.5), $MachinePrecision] + -1.0), $MachinePrecision] + 1.0), $MachinePrecision], If[LessEqual[z, 3.15e+106], N[(x * N[(x * 0.5 + 1.0), $MachinePrecision] + 1.0), $MachinePrecision], N[(1.0 / N[(z * N[(z * N[(z * N[(z * -0.25), $MachinePrecision] + 0.5), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -3.1 \cdot 10^{+88}:\\
\;\;\;\;\mathsf{fma}\left(z, \mathsf{fma}\left(z, \mathsf{fma}\left(z, -0.16666666666666666, 0.5\right), -1\right), 1\right)\\
\mathbf{elif}\;z \leq 3.15 \cdot 10^{+106}:\\
\;\;\;\;\mathsf{fma}\left(x, \mathsf{fma}\left(x, 0.5, 1\right), 1\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\mathsf{fma}\left(z, \mathsf{fma}\left(z, \mathsf{fma}\left(z, z \cdot -0.25, 0.5\right), 1\right), 1\right)}\\
\end{array}
\end{array}
if z < -3.1000000000000001e88Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6489.5
Simplified89.5%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
metadata-evalN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f6481.7
Simplified81.7%
if -3.1000000000000001e88 < z < 3.14999999999999987e106Initial program 100.0%
Taylor expanded in y around 0
lower-exp.f64N/A
lower--.f6461.6
Simplified61.6%
Taylor expanded in z around 0
lower-exp.f6456.8
Simplified56.8%
Taylor expanded in x around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f6432.4
Simplified32.4%
if 3.14999999999999987e106 < z Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6476.5
Simplified76.5%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f6421.1
Simplified21.1%
lift-fma.f64N/A
flip-+N/A
clear-numN/A
lower-/.f64N/A
clear-numN/A
flip-+N/A
lift-fma.f64N/A
lower-/.f6421.1
Applied egg-rr21.1%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f6476.5
Simplified76.5%
(FPCore (x y z)
:precision binary64
(if (<= z -3.1e+88)
(fma z (fma z (fma z -0.16666666666666666 0.5) -1.0) 1.0)
(if (<= z 5e+154)
(fma x (fma x 0.5 1.0) 1.0)
(/ 1.0 (fma z (fma 0.5 z 1.0) 1.0)))))
double code(double x, double y, double z) {
double tmp;
if (z <= -3.1e+88) {
tmp = fma(z, fma(z, fma(z, -0.16666666666666666, 0.5), -1.0), 1.0);
} else if (z <= 5e+154) {
tmp = fma(x, fma(x, 0.5, 1.0), 1.0);
} else {
tmp = 1.0 / fma(z, fma(0.5, z, 1.0), 1.0);
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (z <= -3.1e+88) tmp = fma(z, fma(z, fma(z, -0.16666666666666666, 0.5), -1.0), 1.0); elseif (z <= 5e+154) tmp = fma(x, fma(x, 0.5, 1.0), 1.0); else tmp = Float64(1.0 / fma(z, fma(0.5, z, 1.0), 1.0)); end return tmp end
code[x_, y_, z_] := If[LessEqual[z, -3.1e+88], N[(z * N[(z * N[(z * -0.16666666666666666 + 0.5), $MachinePrecision] + -1.0), $MachinePrecision] + 1.0), $MachinePrecision], If[LessEqual[z, 5e+154], N[(x * N[(x * 0.5 + 1.0), $MachinePrecision] + 1.0), $MachinePrecision], N[(1.0 / N[(z * N[(0.5 * z + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -3.1 \cdot 10^{+88}:\\
\;\;\;\;\mathsf{fma}\left(z, \mathsf{fma}\left(z, \mathsf{fma}\left(z, -0.16666666666666666, 0.5\right), -1\right), 1\right)\\
\mathbf{elif}\;z \leq 5 \cdot 10^{+154}:\\
\;\;\;\;\mathsf{fma}\left(x, \mathsf{fma}\left(x, 0.5, 1\right), 1\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\mathsf{fma}\left(z, \mathsf{fma}\left(0.5, z, 1\right), 1\right)}\\
\end{array}
\end{array}
if z < -3.1000000000000001e88Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6489.5
Simplified89.5%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
metadata-evalN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f6481.7
Simplified81.7%
if -3.1000000000000001e88 < z < 5.00000000000000004e154Initial program 100.0%
Taylor expanded in y around 0
lower-exp.f64N/A
lower--.f6462.5
Simplified62.5%
Taylor expanded in z around 0
lower-exp.f6455.1
Simplified55.1%
Taylor expanded in x around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f6431.4
Simplified31.4%
if 5.00000000000000004e154 < z Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6478.7
Simplified78.7%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f6422.8
Simplified22.8%
lift-fma.f64N/A
flip-+N/A
clear-numN/A
lower-/.f64N/A
clear-numN/A
flip-+N/A
lift-fma.f64N/A
lower-/.f6422.8
Applied egg-rr22.8%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f6478.7
Simplified78.7%
(FPCore (x y z)
:precision binary64
(if (<= x -185.0)
(* z (* z 0.5))
(if (<= x 9e+102)
(fma z (fma z (fma z -0.16666666666666666 0.5) -1.0) 1.0)
(fma x (fma x (fma x 0.16666666666666666 0.5) 1.0) 1.0))))
double code(double x, double y, double z) {
double tmp;
if (x <= -185.0) {
tmp = z * (z * 0.5);
} else if (x <= 9e+102) {
tmp = fma(z, fma(z, fma(z, -0.16666666666666666, 0.5), -1.0), 1.0);
} else {
tmp = fma(x, fma(x, fma(x, 0.16666666666666666, 0.5), 1.0), 1.0);
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (x <= -185.0) tmp = Float64(z * Float64(z * 0.5)); elseif (x <= 9e+102) tmp = fma(z, fma(z, fma(z, -0.16666666666666666, 0.5), -1.0), 1.0); else tmp = fma(x, fma(x, fma(x, 0.16666666666666666, 0.5), 1.0), 1.0); end return tmp end
code[x_, y_, z_] := If[LessEqual[x, -185.0], N[(z * N[(z * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 9e+102], N[(z * N[(z * N[(z * -0.16666666666666666 + 0.5), $MachinePrecision] + -1.0), $MachinePrecision] + 1.0), $MachinePrecision], N[(x * N[(x * N[(x * 0.16666666666666666 + 0.5), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -185:\\
\;\;\;\;z \cdot \left(z \cdot 0.5\right)\\
\mathbf{elif}\;x \leq 9 \cdot 10^{+102}:\\
\;\;\;\;\mathsf{fma}\left(z, \mathsf{fma}\left(z, \mathsf{fma}\left(z, -0.16666666666666666, 0.5\right), -1\right), 1\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(x, \mathsf{fma}\left(x, \mathsf{fma}\left(x, 0.16666666666666666, 0.5\right), 1\right), 1\right)\\
\end{array}
\end{array}
if x < -185Initial program 99.9%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6433.8
Simplified33.8%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f6414.1
Simplified14.1%
Taylor expanded in z around inf
unpow2N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6432.4
Simplified32.4%
if -185 < x < 9.00000000000000042e102Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6459.9
Simplified59.9%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
metadata-evalN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f6437.0
Simplified37.0%
if 9.00000000000000042e102 < x Initial program 100.0%
Taylor expanded in y around 0
lower-exp.f64N/A
lower--.f6497.4
Simplified97.4%
Taylor expanded in z around 0
lower-exp.f6487.0
Simplified87.0%
Taylor expanded in x around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f6487.0
Simplified87.0%
(FPCore (x y z)
:precision binary64
(if (<= x -210.0)
(* z (* z 0.5))
(if (<= x 9.5e+102)
(fma z (fma z 0.5 -1.0) 1.0)
(fma x (fma x (fma x 0.16666666666666666 0.5) 1.0) 1.0))))
double code(double x, double y, double z) {
double tmp;
if (x <= -210.0) {
tmp = z * (z * 0.5);
} else if (x <= 9.5e+102) {
tmp = fma(z, fma(z, 0.5, -1.0), 1.0);
} else {
tmp = fma(x, fma(x, fma(x, 0.16666666666666666, 0.5), 1.0), 1.0);
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (x <= -210.0) tmp = Float64(z * Float64(z * 0.5)); elseif (x <= 9.5e+102) tmp = fma(z, fma(z, 0.5, -1.0), 1.0); else tmp = fma(x, fma(x, fma(x, 0.16666666666666666, 0.5), 1.0), 1.0); end return tmp end
code[x_, y_, z_] := If[LessEqual[x, -210.0], N[(z * N[(z * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 9.5e+102], N[(z * N[(z * 0.5 + -1.0), $MachinePrecision] + 1.0), $MachinePrecision], N[(x * N[(x * N[(x * 0.16666666666666666 + 0.5), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -210:\\
\;\;\;\;z \cdot \left(z \cdot 0.5\right)\\
\mathbf{elif}\;x \leq 9.5 \cdot 10^{+102}:\\
\;\;\;\;\mathsf{fma}\left(z, \mathsf{fma}\left(z, 0.5, -1\right), 1\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(x, \mathsf{fma}\left(x, \mathsf{fma}\left(x, 0.16666666666666666, 0.5\right), 1\right), 1\right)\\
\end{array}
\end{array}
if x < -210Initial program 99.9%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6433.8
Simplified33.8%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f6414.1
Simplified14.1%
Taylor expanded in z around inf
unpow2N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6432.4
Simplified32.4%
if -210 < x < 9.4999999999999992e102Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6459.9
Simplified59.9%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f6436.6
Simplified36.6%
if 9.4999999999999992e102 < x Initial program 100.0%
Taylor expanded in y around 0
lower-exp.f64N/A
lower--.f6497.4
Simplified97.4%
Taylor expanded in z around 0
lower-exp.f6487.0
Simplified87.0%
Taylor expanded in x around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f6487.0
Simplified87.0%
(FPCore (x y z)
:precision binary64
(if (<= x -210.0)
(* z (* z 0.5))
(if (<= x 1.95e+142)
(fma z (fma z 0.5 -1.0) 1.0)
(fma x (fma x 0.5 1.0) 1.0))))
double code(double x, double y, double z) {
double tmp;
if (x <= -210.0) {
tmp = z * (z * 0.5);
} else if (x <= 1.95e+142) {
tmp = fma(z, fma(z, 0.5, -1.0), 1.0);
} else {
tmp = fma(x, fma(x, 0.5, 1.0), 1.0);
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (x <= -210.0) tmp = Float64(z * Float64(z * 0.5)); elseif (x <= 1.95e+142) tmp = fma(z, fma(z, 0.5, -1.0), 1.0); else tmp = fma(x, fma(x, 0.5, 1.0), 1.0); end return tmp end
code[x_, y_, z_] := If[LessEqual[x, -210.0], N[(z * N[(z * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1.95e+142], N[(z * N[(z * 0.5 + -1.0), $MachinePrecision] + 1.0), $MachinePrecision], N[(x * N[(x * 0.5 + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -210:\\
\;\;\;\;z \cdot \left(z \cdot 0.5\right)\\
\mathbf{elif}\;x \leq 1.95 \cdot 10^{+142}:\\
\;\;\;\;\mathsf{fma}\left(z, \mathsf{fma}\left(z, 0.5, -1\right), 1\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(x, \mathsf{fma}\left(x, 0.5, 1\right), 1\right)\\
\end{array}
\end{array}
if x < -210Initial program 99.9%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6433.8
Simplified33.8%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f6414.1
Simplified14.1%
Taylor expanded in z around inf
unpow2N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6432.4
Simplified32.4%
if -210 < x < 1.95e142Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6459.0
Simplified59.0%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f6435.9
Simplified35.9%
if 1.95e142 < x Initial program 100.0%
Taylor expanded in y around 0
lower-exp.f64N/A
lower--.f64100.0
Simplified100.0%
Taylor expanded in z around 0
lower-exp.f6490.8
Simplified90.8%
Taylor expanded in x around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f6485.1
Simplified85.1%
(FPCore (x y z) :precision binary64 (if (<= x -210.0) (* z (* z 0.5)) (if (<= x 1.95e+142) (fma z (* z 0.5) 1.0) (fma x (fma x 0.5 1.0) 1.0))))
double code(double x, double y, double z) {
double tmp;
if (x <= -210.0) {
tmp = z * (z * 0.5);
} else if (x <= 1.95e+142) {
tmp = fma(z, (z * 0.5), 1.0);
} else {
tmp = fma(x, fma(x, 0.5, 1.0), 1.0);
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (x <= -210.0) tmp = Float64(z * Float64(z * 0.5)); elseif (x <= 1.95e+142) tmp = fma(z, Float64(z * 0.5), 1.0); else tmp = fma(x, fma(x, 0.5, 1.0), 1.0); end return tmp end
code[x_, y_, z_] := If[LessEqual[x, -210.0], N[(z * N[(z * 0.5), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 1.95e+142], N[(z * N[(z * 0.5), $MachinePrecision] + 1.0), $MachinePrecision], N[(x * N[(x * 0.5 + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -210:\\
\;\;\;\;z \cdot \left(z \cdot 0.5\right)\\
\mathbf{elif}\;x \leq 1.95 \cdot 10^{+142}:\\
\;\;\;\;\mathsf{fma}\left(z, z \cdot 0.5, 1\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(x, \mathsf{fma}\left(x, 0.5, 1\right), 1\right)\\
\end{array}
\end{array}
if x < -210Initial program 99.9%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6433.8
Simplified33.8%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f6414.1
Simplified14.1%
Taylor expanded in z around inf
unpow2N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6432.4
Simplified32.4%
if -210 < x < 1.95e142Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6459.0
Simplified59.0%
Taylor expanded in z around 0
+-commutativeN/A
lower-fma.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
lower-fma.f6435.9
Simplified35.9%
Taylor expanded in z around inf
*-commutativeN/A
lower-*.f6435.8
Simplified35.8%
if 1.95e142 < x Initial program 100.0%
Taylor expanded in y around 0
lower-exp.f64N/A
lower--.f64100.0
Simplified100.0%
Taylor expanded in z around 0
lower-exp.f6490.8
Simplified90.8%
Taylor expanded in x around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f6485.1
Simplified85.1%
(FPCore (x y z) :precision binary64 (- 1.0 z))
double code(double x, double y, double z) {
return 1.0 - z;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = 1.0d0 - z
end function
public static double code(double x, double y, double z) {
return 1.0 - z;
}
def code(x, y, z): return 1.0 - z
function code(x, y, z) return Float64(1.0 - z) end
function tmp = code(x, y, z) tmp = 1.0 - z; end
code[x_, y_, z_] := N[(1.0 - z), $MachinePrecision]
\begin{array}{l}
\\
1 - z
\end{array}
Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6448.6
Simplified48.6%
Taylor expanded in z around 0
neg-mul-1N/A
unsub-negN/A
lower--.f6413.7
Simplified13.7%
(FPCore (x y z) :precision binary64 1.0)
double code(double x, double y, double z) {
return 1.0;
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = 1.0d0
end function
public static double code(double x, double y, double z) {
return 1.0;
}
def code(x, y, z): return 1.0
function code(x, y, z) return 1.0 end
function tmp = code(x, y, z) tmp = 1.0; end
code[x_, y_, z_] := 1.0
\begin{array}{l}
\\
1
\end{array}
Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
lower-neg.f6448.6
Simplified48.6%
Taylor expanded in z around 0
Simplified13.5%
(FPCore (x y z) :precision binary64 (exp (+ (- x z) (* (log y) y))))
double code(double x, double y, double z) {
return exp(((x - z) + (log(y) * y)));
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = exp(((x - z) + (log(y) * y)))
end function
public static double code(double x, double y, double z) {
return Math.exp(((x - z) + (Math.log(y) * y)));
}
def code(x, y, z): return math.exp(((x - z) + (math.log(y) * y)))
function code(x, y, z) return exp(Float64(Float64(x - z) + Float64(log(y) * y))) end
function tmp = code(x, y, z) tmp = exp(((x - z) + (log(y) * y))); end
code[x_, y_, z_] := N[Exp[N[(N[(x - z), $MachinePrecision] + N[(N[Log[y], $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
e^{\left(x - z\right) + \log y \cdot y}
\end{array}
herbie shell --seed 2024208
(FPCore (x y z)
:name "Statistics.Distribution.Poisson.Internal:probability from math-functions-0.1.5.2"
:precision binary64
:alt
(! :herbie-platform default (exp (+ (- x z) (* (log y) y))))
(exp (- (+ x (* y (log y))) z)))