
(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 19 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))) z)))
(if (<= t_0 -5e+146)
(/ -1.0 (fma z (fma z 0.5 -1.0) -1.0))
(if (<= t_0 -1e+14)
(* -0.16666666666666666 (* z (* z z)))
(if (<= t_0 5e+17)
(fma x (fma x (fma x 0.16666666666666666 0.5) 1.0) 1.0)
(fma
(* z (fma 0.25 (* z z) -1.0))
(/ (+ 2.0 (/ (- -4.0 (/ (+ (/ 16.0 z) -8.0) z)) z)) z)
1.0))))))
double code(double x, double y, double z) {
double t_0 = (x + (y * log(y))) - z;
double tmp;
if (t_0 <= -5e+146) {
tmp = -1.0 / fma(z, fma(z, 0.5, -1.0), -1.0);
} else if (t_0 <= -1e+14) {
tmp = -0.16666666666666666 * (z * (z * z));
} else if (t_0 <= 5e+17) {
tmp = fma(x, fma(x, fma(x, 0.16666666666666666, 0.5), 1.0), 1.0);
} else {
tmp = fma((z * fma(0.25, (z * z), -1.0)), ((2.0 + ((-4.0 - (((16.0 / z) + -8.0) / z)) / z)) / z), 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 <= -5e+146) tmp = Float64(-1.0 / fma(z, fma(z, 0.5, -1.0), -1.0)); elseif (t_0 <= -1e+14) tmp = Float64(-0.16666666666666666 * Float64(z * Float64(z * z))); elseif (t_0 <= 5e+17) tmp = fma(x, fma(x, fma(x, 0.16666666666666666, 0.5), 1.0), 1.0); else tmp = fma(Float64(z * fma(0.25, Float64(z * z), -1.0)), Float64(Float64(2.0 + Float64(Float64(-4.0 - Float64(Float64(Float64(16.0 / z) + -8.0) / z)) / z)) / z), 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, -5e+146], N[(-1.0 / N[(z * N[(z * 0.5 + -1.0), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, -1e+14], N[(-0.16666666666666666 * N[(z * N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, 5e+17], N[(x * N[(x * N[(x * 0.16666666666666666 + 0.5), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision], N[(N[(z * N[(0.25 * N[(z * z), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision] * N[(N[(2.0 + N[(N[(-4.0 - N[(N[(N[(16.0 / z), $MachinePrecision] + -8.0), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision] / z), $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 -5 \cdot 10^{+146}:\\
\;\;\;\;\frac{-1}{\mathsf{fma}\left(z, \mathsf{fma}\left(z, 0.5, -1\right), -1\right)}\\
\mathbf{elif}\;t\_0 \leq -1 \cdot 10^{+14}:\\
\;\;\;\;-0.16666666666666666 \cdot \left(z \cdot \left(z \cdot z\right)\right)\\
\mathbf{elif}\;t\_0 \leq 5 \cdot 10^{+17}:\\
\;\;\;\;\mathsf{fma}\left(x, \mathsf{fma}\left(x, \mathsf{fma}\left(x, 0.16666666666666666, 0.5\right), 1\right), 1\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(z \cdot \mathsf{fma}\left(0.25, z \cdot z, -1\right), \frac{2 + \frac{-4 - \frac{\frac{16}{z} + -8}{z}}{z}}{z}, 1\right)\\
\end{array}
\end{array}
if (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z) < -4.9999999999999999e146Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-lowering-neg.f6460.6
Simplified60.6%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f642.1
Simplified2.1%
flip-+N/A
/-lowering-/.f64N/A
metadata-evalN/A
sub-negN/A
swap-sqrN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
Applied egg-rr1.3%
Taylor expanded in z around 0
Simplified51.3%
if -4.9999999999999999e146 < (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z) < -1e14Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-lowering-neg.f6443.8
Simplified43.8%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f642.6
Simplified2.6%
Taylor expanded in z around inf
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6449.3
Simplified49.3%
if -1e14 < (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z) < 5e17Initial program 100.0%
Taylor expanded in x around inf
Simplified86.6%
Taylor expanded in x around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6480.4
Simplified80.4%
if 5e17 < (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z) Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-lowering-neg.f6435.8
Simplified35.8%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f6423.9
Simplified23.9%
*-commutativeN/A
flip-+N/A
associate-*l/N/A
div-invN/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
sub-negN/A
swap-sqrN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
metadata-evalN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
accelerator-lowering-fma.f6432.0
Applied egg-rr32.0%
Taylor expanded in z around inf
Simplified55.1%
Final simplification57.1%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (- (+ x (* y (log y))) z)))
(if (<= t_0 -5e+146)
(/ -1.0 (fma z (fma z 0.5 -1.0) -1.0))
(if (<= t_0 -1e+14)
(* -0.16666666666666666 (* z (* z z)))
(if (<= t_0 5e+17)
(fma x (fma x (fma x 0.16666666666666666 0.5) 1.0) 1.0)
(fma (* z (fma 0.25 (* z z) -1.0)) (/ (+ 2.0 (/ -4.0 z)) z) 1.0))))))
double code(double x, double y, double z) {
double t_0 = (x + (y * log(y))) - z;
double tmp;
if (t_0 <= -5e+146) {
tmp = -1.0 / fma(z, fma(z, 0.5, -1.0), -1.0);
} else if (t_0 <= -1e+14) {
tmp = -0.16666666666666666 * (z * (z * z));
} else if (t_0 <= 5e+17) {
tmp = fma(x, fma(x, fma(x, 0.16666666666666666, 0.5), 1.0), 1.0);
} else {
tmp = fma((z * fma(0.25, (z * z), -1.0)), ((2.0 + (-4.0 / z)) / z), 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 <= -5e+146) tmp = Float64(-1.0 / fma(z, fma(z, 0.5, -1.0), -1.0)); elseif (t_0 <= -1e+14) tmp = Float64(-0.16666666666666666 * Float64(z * Float64(z * z))); elseif (t_0 <= 5e+17) tmp = fma(x, fma(x, fma(x, 0.16666666666666666, 0.5), 1.0), 1.0); else tmp = fma(Float64(z * fma(0.25, Float64(z * z), -1.0)), Float64(Float64(2.0 + Float64(-4.0 / z)) / z), 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, -5e+146], N[(-1.0 / N[(z * N[(z * 0.5 + -1.0), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, -1e+14], N[(-0.16666666666666666 * N[(z * N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, 5e+17], N[(x * N[(x * N[(x * 0.16666666666666666 + 0.5), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision], N[(N[(z * N[(0.25 * N[(z * z), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision] * N[(N[(2.0 + N[(-4.0 / z), $MachinePrecision]), $MachinePrecision] / z), $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 -5 \cdot 10^{+146}:\\
\;\;\;\;\frac{-1}{\mathsf{fma}\left(z, \mathsf{fma}\left(z, 0.5, -1\right), -1\right)}\\
\mathbf{elif}\;t\_0 \leq -1 \cdot 10^{+14}:\\
\;\;\;\;-0.16666666666666666 \cdot \left(z \cdot \left(z \cdot z\right)\right)\\
\mathbf{elif}\;t\_0 \leq 5 \cdot 10^{+17}:\\
\;\;\;\;\mathsf{fma}\left(x, \mathsf{fma}\left(x, \mathsf{fma}\left(x, 0.16666666666666666, 0.5\right), 1\right), 1\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(z \cdot \mathsf{fma}\left(0.25, z \cdot z, -1\right), \frac{2 + \frac{-4}{z}}{z}, 1\right)\\
\end{array}
\end{array}
if (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z) < -4.9999999999999999e146Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-lowering-neg.f6460.6
Simplified60.6%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f642.1
Simplified2.1%
flip-+N/A
/-lowering-/.f64N/A
metadata-evalN/A
sub-negN/A
swap-sqrN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
Applied egg-rr1.3%
Taylor expanded in z around 0
Simplified51.3%
if -4.9999999999999999e146 < (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z) < -1e14Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-lowering-neg.f6443.8
Simplified43.8%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f642.6
Simplified2.6%
Taylor expanded in z around inf
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6449.3
Simplified49.3%
if -1e14 < (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z) < 5e17Initial program 100.0%
Taylor expanded in x around inf
Simplified86.6%
Taylor expanded in x around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6480.4
Simplified80.4%
if 5e17 < (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z) Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-lowering-neg.f6435.8
Simplified35.8%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f6423.9
Simplified23.9%
*-commutativeN/A
flip-+N/A
associate-*l/N/A
div-invN/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
sub-negN/A
swap-sqrN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
metadata-evalN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
accelerator-lowering-fma.f6432.0
Applied egg-rr32.0%
Taylor expanded in z around inf
/-lowering-/.f64N/A
sub-negN/A
+-lowering-+.f64N/A
associate-*r/N/A
metadata-evalN/A
distribute-neg-fracN/A
/-lowering-/.f64N/A
metadata-eval50.3
Simplified50.3%
Final simplification54.0%
(FPCore (x y z) :precision binary64 (let* ((t_0 (+ x (* y (log y))))) (if (<= t_0 -1e+14) (exp x) (if (<= t_0 1e+69) (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 <= -1e+14) {
tmp = exp(x);
} else if (t_0 <= 1e+69) {
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 <= (-1d+14)) then
tmp = exp(x)
else if (t_0 <= 1d+69) 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 <= -1e+14) {
tmp = Math.exp(x);
} else if (t_0 <= 1e+69) {
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 <= -1e+14: tmp = math.exp(x) elif t_0 <= 1e+69: 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 <= -1e+14) tmp = exp(x); elseif (t_0 <= 1e+69) 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 <= -1e+14) tmp = exp(x); elseif (t_0 <= 1e+69) 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, -1e+14], N[Exp[x], $MachinePrecision], If[LessEqual[t$95$0, 1e+69], 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 -1 \cdot 10^{+14}:\\
\;\;\;\;e^{x}\\
\mathbf{elif}\;t\_0 \leq 10^{+69}:\\
\;\;\;\;e^{-z}\\
\mathbf{else}:\\
\;\;\;\;{y}^{y}\\
\end{array}
\end{array}
if (+.f64 x (*.f64 y (log.f64 y))) < -1e14Initial program 100.0%
Taylor expanded in x around inf
Simplified93.7%
if -1e14 < (+.f64 x (*.f64 y (log.f64 y))) < 1.0000000000000001e69Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-lowering-neg.f6478.6
Simplified78.6%
if 1.0000000000000001e69 < (+.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
*-lowering-*.f64N/A
log-lowering-log.f6482.8
Simplified82.8%
*-commutativeN/A
exp-to-powN/A
pow-lowering-pow.f6482.8
Applied egg-rr82.8%
(FPCore (x y z) :precision binary64 (let* ((t_0 (- (+ x (* y (log y))) z)) (t_1 (* (* z z) 0.5))) (if (<= t_0 -1e+14) t_1 (if (<= t_0 4e+125) (+ x 1.0) 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 <= -1e+14) {
tmp = t_1;
} else if (t_0 <= 4e+125) {
tmp = x + 1.0;
} 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 <= (-1d+14)) then
tmp = t_1
else if (t_0 <= 4d+125) then
tmp = x + 1.0d0
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 <= -1e+14) {
tmp = t_1;
} else if (t_0 <= 4e+125) {
tmp = x + 1.0;
} 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 <= -1e+14: tmp = t_1 elif t_0 <= 4e+125: tmp = x + 1.0 else: tmp = t_1 return tmp
function code(x, y, z) t_0 = Float64(Float64(x + Float64(y * log(y))) - z) t_1 = Float64(Float64(z * z) * 0.5) tmp = 0.0 if (t_0 <= -1e+14) tmp = t_1; elseif (t_0 <= 4e+125) tmp = Float64(x + 1.0); 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 <= -1e+14) tmp = t_1; elseif (t_0 <= 4e+125) tmp = x + 1.0; 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[(N[(z * z), $MachinePrecision] * 0.5), $MachinePrecision]}, If[LessEqual[t$95$0, -1e+14], t$95$1, If[LessEqual[t$95$0, 4e+125], N[(x + 1.0), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(x + y \cdot \log y\right) - z\\
t_1 := \left(z \cdot z\right) \cdot 0.5\\
\mathbf{if}\;t\_0 \leq -1 \cdot 10^{+14}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_0 \leq 4 \cdot 10^{+125}:\\
\;\;\;\;x + 1\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z) < -1e14 or 3.9999999999999997e125 < (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z) Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-lowering-neg.f6446.2
Simplified46.2%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f6420.4
Simplified20.4%
Taylor expanded in z around inf
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6426.4
Simplified26.4%
if -1e14 < (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z) < 3.9999999999999997e125Initial program 100.0%
Taylor expanded in x around inf
Simplified65.3%
Taylor expanded in x around 0
+-lowering-+.f6437.4
Simplified37.4%
Final simplification29.3%
(FPCore (x y z) :precision binary64 (if (<= (+ x (* y (log y))) -1e+14) (* (* 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))) <= -1e+14) {
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))) <= -1e+14) tmp = Float64(Float64(z * 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], -1e+14], N[(N[(z * z), $MachinePrecision] * 0.5), $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 -1 \cdot 10^{+14}:\\
\;\;\;\;\left(z \cdot z\right) \cdot 0.5\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(z, z \cdot 0.5, 1\right)\\
\end{array}
\end{array}
if (+.f64 x (*.f64 y (log.f64 y))) < -1e14Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-lowering-neg.f6437.9
Simplified37.9%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f648.8
Simplified8.8%
Taylor expanded in z around inf
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6434.4
Simplified34.4%
if -1e14 < (+.f64 x (*.f64 y (log.f64 y))) Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-lowering-neg.f6448.2
Simplified48.2%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f6428.6
Simplified28.6%
Taylor expanded in z around inf
*-lowering-*.f6428.3
Simplified28.3%
Final simplification29.4%
(FPCore (x y z) :precision binary64 (if (<= z -1.02e+121) (* -0.16666666666666666 (* z (* z z))) (if (<= z 1.95e+183) (exp x) (/ -1.0 (fma z (fma z 0.5 -1.0) -1.0)))))
double code(double x, double y, double z) {
double tmp;
if (z <= -1.02e+121) {
tmp = -0.16666666666666666 * (z * (z * z));
} else if (z <= 1.95e+183) {
tmp = exp(x);
} else {
tmp = -1.0 / fma(z, fma(z, 0.5, -1.0), -1.0);
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (z <= -1.02e+121) tmp = Float64(-0.16666666666666666 * Float64(z * Float64(z * z))); elseif (z <= 1.95e+183) tmp = exp(x); else tmp = Float64(-1.0 / fma(z, fma(z, 0.5, -1.0), -1.0)); end return tmp end
code[x_, y_, z_] := If[LessEqual[z, -1.02e+121], N[(-0.16666666666666666 * N[(z * N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.95e+183], N[Exp[x], $MachinePrecision], N[(-1.0 / N[(z * N[(z * 0.5 + -1.0), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.02 \cdot 10^{+121}:\\
\;\;\;\;-0.16666666666666666 \cdot \left(z \cdot \left(z \cdot z\right)\right)\\
\mathbf{elif}\;z \leq 1.95 \cdot 10^{+183}:\\
\;\;\;\;e^{x}\\
\mathbf{else}:\\
\;\;\;\;\frac{-1}{\mathsf{fma}\left(z, \mathsf{fma}\left(z, 0.5, -1\right), -1\right)}\\
\end{array}
\end{array}
if z < -1.02000000000000005e121Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-lowering-neg.f6497.3
Simplified97.3%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6497.3
Simplified97.3%
Taylor expanded in z around inf
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6497.3
Simplified97.3%
if -1.02000000000000005e121 < z < 1.9499999999999999e183Initial program 100.0%
Taylor expanded in x around inf
Simplified59.2%
if 1.9499999999999999e183 < z Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-lowering-neg.f6487.7
Simplified87.7%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f6413.9
Simplified13.9%
flip-+N/A
/-lowering-/.f64N/A
metadata-evalN/A
sub-negN/A
swap-sqrN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
Applied egg-rr0.0%
Taylor expanded in z around 0
Simplified87.7%
(FPCore (x y z) :precision binary64 (if (<= y 82000000.0) (exp x) (pow y y)))
double code(double x, double y, double z) {
double tmp;
if (y <= 82000000.0) {
tmp = exp(x);
} 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 <= 82000000.0d0) then
tmp = exp(x)
else
tmp = y ** y
end if
code = tmp
end function
public static double code(double x, double y, double z) {
double tmp;
if (y <= 82000000.0) {
tmp = Math.exp(x);
} else {
tmp = Math.pow(y, y);
}
return tmp;
}
def code(x, y, z): tmp = 0 if y <= 82000000.0: tmp = math.exp(x) else: tmp = math.pow(y, y) return tmp
function code(x, y, z) tmp = 0.0 if (y <= 82000000.0) tmp = exp(x); else tmp = y ^ y; end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (y <= 82000000.0) tmp = exp(x); else tmp = y ^ y; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[y, 82000000.0], N[Exp[x], $MachinePrecision], N[Power[y, y], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 82000000:\\
\;\;\;\;e^{x}\\
\mathbf{else}:\\
\;\;\;\;{y}^{y}\\
\end{array}
\end{array}
if y < 8.2e7Initial program 100.0%
Taylor expanded in x around inf
Simplified72.3%
if 8.2e7 < 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
*-lowering-*.f64N/A
log-lowering-log.f6481.4
Simplified81.4%
*-commutativeN/A
exp-to-powN/A
pow-lowering-pow.f6481.4
Applied egg-rr81.4%
(FPCore (x y z)
:precision binary64
(if (<= z -1.5e+73)
(* -0.16666666666666666 (* z (* z z)))
(if (<= z 8.2e+45)
(fma x (fma x (fma x 0.16666666666666666 0.5) 1.0) 1.0)
(if (<= z 2e+183)
(fma (* z (fma 0.25 (* z z) -1.0)) (fma z (fma z 0.25 -0.5) 1.0) 1.0)
(/ -1.0 (fma z (fma z 0.5 -1.0) -1.0))))))
double code(double x, double y, double z) {
double tmp;
if (z <= -1.5e+73) {
tmp = -0.16666666666666666 * (z * (z * z));
} else if (z <= 8.2e+45) {
tmp = fma(x, fma(x, fma(x, 0.16666666666666666, 0.5), 1.0), 1.0);
} else if (z <= 2e+183) {
tmp = fma((z * fma(0.25, (z * z), -1.0)), fma(z, fma(z, 0.25, -0.5), 1.0), 1.0);
} else {
tmp = -1.0 / fma(z, fma(z, 0.5, -1.0), -1.0);
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (z <= -1.5e+73) tmp = Float64(-0.16666666666666666 * Float64(z * Float64(z * z))); elseif (z <= 8.2e+45) tmp = fma(x, fma(x, fma(x, 0.16666666666666666, 0.5), 1.0), 1.0); elseif (z <= 2e+183) tmp = fma(Float64(z * fma(0.25, Float64(z * z), -1.0)), fma(z, fma(z, 0.25, -0.5), 1.0), 1.0); else tmp = Float64(-1.0 / fma(z, fma(z, 0.5, -1.0), -1.0)); end return tmp end
code[x_, y_, z_] := If[LessEqual[z, -1.5e+73], N[(-0.16666666666666666 * N[(z * N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 8.2e+45], N[(x * N[(x * N[(x * 0.16666666666666666 + 0.5), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision], If[LessEqual[z, 2e+183], N[(N[(z * N[(0.25 * N[(z * z), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision] * N[(z * N[(z * 0.25 + -0.5), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision], N[(-1.0 / N[(z * N[(z * 0.5 + -1.0), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.5 \cdot 10^{+73}:\\
\;\;\;\;-0.16666666666666666 \cdot \left(z \cdot \left(z \cdot z\right)\right)\\
\mathbf{elif}\;z \leq 8.2 \cdot 10^{+45}:\\
\;\;\;\;\mathsf{fma}\left(x, \mathsf{fma}\left(x, \mathsf{fma}\left(x, 0.16666666666666666, 0.5\right), 1\right), 1\right)\\
\mathbf{elif}\;z \leq 2 \cdot 10^{+183}:\\
\;\;\;\;\mathsf{fma}\left(z \cdot \mathsf{fma}\left(0.25, z \cdot z, -1\right), \mathsf{fma}\left(z, \mathsf{fma}\left(z, 0.25, -0.5\right), 1\right), 1\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{-1}{\mathsf{fma}\left(z, \mathsf{fma}\left(z, 0.5, -1\right), -1\right)}\\
\end{array}
\end{array}
if z < -1.50000000000000005e73Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-lowering-neg.f6489.1
Simplified89.1%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6480.9
Simplified80.9%
Taylor expanded in z around inf
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6480.9
Simplified80.9%
if -1.50000000000000005e73 < z < 8.20000000000000025e45Initial program 100.0%
Taylor expanded in x around inf
Simplified61.5%
Taylor expanded in x around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6435.4
Simplified35.4%
if 8.20000000000000025e45 < z < 1.99999999999999989e183Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-lowering-neg.f6444.2
Simplified44.2%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f6420.0
Simplified20.0%
*-commutativeN/A
flip-+N/A
associate-*l/N/A
div-invN/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
metadata-evalN/A
sub-negN/A
swap-sqrN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
metadata-evalN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
accelerator-lowering-fma.f6428.9
Applied egg-rr28.9%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
accelerator-lowering-fma.f6448.0
Simplified48.0%
if 1.99999999999999989e183 < z Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-lowering-neg.f6487.7
Simplified87.7%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f6413.9
Simplified13.9%
flip-+N/A
/-lowering-/.f64N/A
metadata-evalN/A
sub-negN/A
swap-sqrN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
Applied egg-rr0.0%
Taylor expanded in z around 0
Simplified87.7%
Final simplification49.8%
(FPCore (x y z)
:precision binary64
(if (<= z -1.5e+73)
(* -0.16666666666666666 (* z (* z z)))
(if (<= z 1.15e+183)
(fma x (fma x (fma x 0.16666666666666666 0.5) 1.0) 1.0)
(/ -1.0 (fma z (fma z 0.5 -1.0) -1.0)))))
double code(double x, double y, double z) {
double tmp;
if (z <= -1.5e+73) {
tmp = -0.16666666666666666 * (z * (z * z));
} else if (z <= 1.15e+183) {
tmp = fma(x, fma(x, fma(x, 0.16666666666666666, 0.5), 1.0), 1.0);
} else {
tmp = -1.0 / fma(z, fma(z, 0.5, -1.0), -1.0);
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (z <= -1.5e+73) tmp = Float64(-0.16666666666666666 * Float64(z * Float64(z * z))); elseif (z <= 1.15e+183) tmp = fma(x, fma(x, fma(x, 0.16666666666666666, 0.5), 1.0), 1.0); else tmp = Float64(-1.0 / fma(z, fma(z, 0.5, -1.0), -1.0)); end return tmp end
code[x_, y_, z_] := If[LessEqual[z, -1.5e+73], N[(-0.16666666666666666 * N[(z * N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[z, 1.15e+183], N[(x * N[(x * N[(x * 0.16666666666666666 + 0.5), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision], N[(-1.0 / N[(z * N[(z * 0.5 + -1.0), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.5 \cdot 10^{+73}:\\
\;\;\;\;-0.16666666666666666 \cdot \left(z \cdot \left(z \cdot z\right)\right)\\
\mathbf{elif}\;z \leq 1.15 \cdot 10^{+183}:\\
\;\;\;\;\mathsf{fma}\left(x, \mathsf{fma}\left(x, \mathsf{fma}\left(x, 0.16666666666666666, 0.5\right), 1\right), 1\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{-1}{\mathsf{fma}\left(z, \mathsf{fma}\left(z, 0.5, -1\right), -1\right)}\\
\end{array}
\end{array}
if z < -1.50000000000000005e73Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-lowering-neg.f6489.1
Simplified89.1%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6480.9
Simplified80.9%
Taylor expanded in z around inf
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6480.9
Simplified80.9%
if -1.50000000000000005e73 < z < 1.1499999999999999e183Initial program 100.0%
Taylor expanded in x around inf
Simplified59.3%
Taylor expanded in x around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6434.3
Simplified34.3%
if 1.1499999999999999e183 < z Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-lowering-neg.f6487.7
Simplified87.7%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f6413.9
Simplified13.9%
flip-+N/A
/-lowering-/.f64N/A
metadata-evalN/A
sub-negN/A
swap-sqrN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
Applied egg-rr0.0%
Taylor expanded in z around 0
Simplified87.7%
(FPCore (x y z)
:precision binary64
(if (<= x -35000000000.0)
(* -0.16666666666666666 (* z (* z z)))
(if (<= x 4.6e+87)
(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 <= -35000000000.0) {
tmp = -0.16666666666666666 * (z * (z * z));
} else if (x <= 4.6e+87) {
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 <= -35000000000.0) tmp = Float64(-0.16666666666666666 * Float64(z * Float64(z * z))); elseif (x <= 4.6e+87) 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, -35000000000.0], N[(-0.16666666666666666 * N[(z * N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 4.6e+87], 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 -35000000000:\\
\;\;\;\;-0.16666666666666666 \cdot \left(z \cdot \left(z \cdot z\right)\right)\\
\mathbf{elif}\;x \leq 4.6 \cdot 10^{+87}:\\
\;\;\;\;\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 < -3.5e10Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-lowering-neg.f6433.6
Simplified33.6%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6410.3
Simplified10.3%
Taylor expanded in z around inf
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6436.6
Simplified36.6%
if -3.5e10 < x < 4.6000000000000003e87Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-lowering-neg.f6455.1
Simplified55.1%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6433.5
Simplified33.5%
if 4.6000000000000003e87 < x Initial program 100.0%
Taylor expanded in x around inf
Simplified97.9%
Taylor expanded in x around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6495.9
Simplified95.9%
(FPCore (x y z)
:precision binary64
(if (<= x -35000000000.0)
(* -0.16666666666666666 (* z (* z z)))
(if (<= x 3.05e+87)
(fma z (* -0.16666666666666666 (* z z)) 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 <= -35000000000.0) {
tmp = -0.16666666666666666 * (z * (z * z));
} else if (x <= 3.05e+87) {
tmp = fma(z, (-0.16666666666666666 * (z * z)), 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 <= -35000000000.0) tmp = Float64(-0.16666666666666666 * Float64(z * Float64(z * z))); elseif (x <= 3.05e+87) tmp = fma(z, Float64(-0.16666666666666666 * Float64(z * z)), 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, -35000000000.0], N[(-0.16666666666666666 * N[(z * N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 3.05e+87], N[(z * N[(-0.16666666666666666 * N[(z * z), $MachinePrecision]), $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 -35000000000:\\
\;\;\;\;-0.16666666666666666 \cdot \left(z \cdot \left(z \cdot z\right)\right)\\
\mathbf{elif}\;x \leq 3.05 \cdot 10^{+87}:\\
\;\;\;\;\mathsf{fma}\left(z, -0.16666666666666666 \cdot \left(z \cdot z\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 < -3.5e10Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-lowering-neg.f6433.6
Simplified33.6%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6410.3
Simplified10.3%
Taylor expanded in z around inf
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6436.6
Simplified36.6%
if -3.5e10 < x < 3.0499999999999999e87Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-lowering-neg.f6455.1
Simplified55.1%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6433.5
Simplified33.5%
Taylor expanded in z around inf
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6433.1
Simplified33.1%
if 3.0499999999999999e87 < x Initial program 100.0%
Taylor expanded in x around inf
Simplified97.9%
Taylor expanded in x around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6495.9
Simplified95.9%
Final simplification45.5%
(FPCore (x y z)
:precision binary64
(if (<= x -2500000000000.0)
(* -0.16666666666666666 (* z (* z z)))
(if (<= x 3.2e+122)
(fma z (* -0.16666666666666666 (* z z)) 1.0)
(fma x (fma x 0.5 1.0) 1.0))))
double code(double x, double y, double z) {
double tmp;
if (x <= -2500000000000.0) {
tmp = -0.16666666666666666 * (z * (z * z));
} else if (x <= 3.2e+122) {
tmp = fma(z, (-0.16666666666666666 * (z * z)), 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 <= -2500000000000.0) tmp = Float64(-0.16666666666666666 * Float64(z * Float64(z * z))); elseif (x <= 3.2e+122) tmp = fma(z, Float64(-0.16666666666666666 * Float64(z * z)), 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, -2500000000000.0], N[(-0.16666666666666666 * N[(z * N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 3.2e+122], N[(z * N[(-0.16666666666666666 * N[(z * z), $MachinePrecision]), $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 -2500000000000:\\
\;\;\;\;-0.16666666666666666 \cdot \left(z \cdot \left(z \cdot z\right)\right)\\
\mathbf{elif}\;x \leq 3.2 \cdot 10^{+122}:\\
\;\;\;\;\mathsf{fma}\left(z, -0.16666666666666666 \cdot \left(z \cdot z\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 < -2.5e12Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-lowering-neg.f6433.6
Simplified33.6%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6410.3
Simplified10.3%
Taylor expanded in z around inf
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6436.6
Simplified36.6%
if -2.5e12 < x < 3.20000000000000012e122Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-lowering-neg.f6454.0
Simplified54.0%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6433.2
Simplified33.2%
Taylor expanded in z around inf
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6432.7
Simplified32.7%
if 3.20000000000000012e122 < x Initial program 100.0%
Taylor expanded in x around inf
Simplified97.7%
Taylor expanded in x around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6491.0
Simplified91.0%
Final simplification43.2%
(FPCore (x y z)
:precision binary64
(if (<= x -35000000000.0)
(* -0.16666666666666666 (* z (* z z)))
(if (<= x 4.6e+87)
(fma (* z z) 0.5 (- 1.0 z))
(fma x (fma x 0.5 1.0) 1.0))))
double code(double x, double y, double z) {
double tmp;
if (x <= -35000000000.0) {
tmp = -0.16666666666666666 * (z * (z * z));
} else if (x <= 4.6e+87) {
tmp = fma((z * z), 0.5, (1.0 - z));
} else {
tmp = fma(x, fma(x, 0.5, 1.0), 1.0);
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (x <= -35000000000.0) tmp = Float64(-0.16666666666666666 * Float64(z * Float64(z * z))); elseif (x <= 4.6e+87) tmp = fma(Float64(z * z), 0.5, Float64(1.0 - z)); else tmp = fma(x, fma(x, 0.5, 1.0), 1.0); end return tmp end
code[x_, y_, z_] := If[LessEqual[x, -35000000000.0], N[(-0.16666666666666666 * N[(z * N[(z * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 4.6e+87], N[(N[(z * z), $MachinePrecision] * 0.5 + N[(1.0 - z), $MachinePrecision]), $MachinePrecision], N[(x * N[(x * 0.5 + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -35000000000:\\
\;\;\;\;-0.16666666666666666 \cdot \left(z \cdot \left(z \cdot z\right)\right)\\
\mathbf{elif}\;x \leq 4.6 \cdot 10^{+87}:\\
\;\;\;\;\mathsf{fma}\left(z \cdot z, 0.5, 1 - z\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(x, \mathsf{fma}\left(x, 0.5, 1\right), 1\right)\\
\end{array}
\end{array}
if x < -3.5e10Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-lowering-neg.f6433.6
Simplified33.6%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6410.3
Simplified10.3%
Taylor expanded in z around inf
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6436.6
Simplified36.6%
if -3.5e10 < x < 4.6000000000000003e87Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-lowering-neg.f6455.1
Simplified55.1%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f6431.3
Simplified31.3%
distribute-lft-inN/A
associate-+l+N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
neg-mul-1N/A
sub-negN/A
--lowering--.f6431.3
Applied egg-rr31.3%
if 4.6000000000000003e87 < x Initial program 100.0%
Taylor expanded in x around inf
Simplified97.9%
Taylor expanded in x around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6482.0
Simplified82.0%
(FPCore (x y z)
:precision binary64
(if (<= x -860000000000.0)
(* (* z z) 0.5)
(if (<= x 4.6e+87)
(fma (* z z) 0.5 (- 1.0 z))
(fma x (fma x 0.5 1.0) 1.0))))
double code(double x, double y, double z) {
double tmp;
if (x <= -860000000000.0) {
tmp = (z * z) * 0.5;
} else if (x <= 4.6e+87) {
tmp = fma((z * z), 0.5, (1.0 - z));
} else {
tmp = fma(x, fma(x, 0.5, 1.0), 1.0);
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (x <= -860000000000.0) tmp = Float64(Float64(z * z) * 0.5); elseif (x <= 4.6e+87) tmp = fma(Float64(z * z), 0.5, Float64(1.0 - z)); else tmp = fma(x, fma(x, 0.5, 1.0), 1.0); end return tmp end
code[x_, y_, z_] := If[LessEqual[x, -860000000000.0], N[(N[(z * z), $MachinePrecision] * 0.5), $MachinePrecision], If[LessEqual[x, 4.6e+87], N[(N[(z * z), $MachinePrecision] * 0.5 + N[(1.0 - z), $MachinePrecision]), $MachinePrecision], N[(x * N[(x * 0.5 + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -860000000000:\\
\;\;\;\;\left(z \cdot z\right) \cdot 0.5\\
\mathbf{elif}\;x \leq 4.6 \cdot 10^{+87}:\\
\;\;\;\;\mathsf{fma}\left(z \cdot z, 0.5, 1 - z\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(x, \mathsf{fma}\left(x, 0.5, 1\right), 1\right)\\
\end{array}
\end{array}
if x < -8.6e11Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-lowering-neg.f6433.6
Simplified33.6%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f6415.1
Simplified15.1%
Taylor expanded in z around inf
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6434.1
Simplified34.1%
if -8.6e11 < x < 4.6000000000000003e87Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-lowering-neg.f6455.1
Simplified55.1%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f6431.3
Simplified31.3%
distribute-lft-inN/A
associate-+l+N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
neg-mul-1N/A
sub-negN/A
--lowering--.f6431.3
Applied egg-rr31.3%
if 4.6000000000000003e87 < x Initial program 100.0%
Taylor expanded in x around inf
Simplified97.9%
Taylor expanded in x around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6482.0
Simplified82.0%
Final simplification41.3%
(FPCore (x y z) :precision binary64 (if (<= x -48000000000.0) (* (* z z) 0.5) (if (<= x 4e+87) (fma z (fma 0.5 z -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 <= -48000000000.0) {
tmp = (z * z) * 0.5;
} else if (x <= 4e+87) {
tmp = fma(z, fma(0.5, z, -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 <= -48000000000.0) tmp = Float64(Float64(z * z) * 0.5); elseif (x <= 4e+87) tmp = fma(z, fma(0.5, z, -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, -48000000000.0], N[(N[(z * z), $MachinePrecision] * 0.5), $MachinePrecision], If[LessEqual[x, 4e+87], N[(z * N[(0.5 * z + -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 -48000000000:\\
\;\;\;\;\left(z \cdot z\right) \cdot 0.5\\
\mathbf{elif}\;x \leq 4 \cdot 10^{+87}:\\
\;\;\;\;\mathsf{fma}\left(z, \mathsf{fma}\left(0.5, z, -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 < -4.8e10Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-lowering-neg.f6433.6
Simplified33.6%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f6415.1
Simplified15.1%
Taylor expanded in z around inf
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6434.1
Simplified34.1%
if -4.8e10 < x < 3.9999999999999998e87Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-lowering-neg.f6455.1
Simplified55.1%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f6431.3
Simplified31.3%
if 3.9999999999999998e87 < x Initial program 100.0%
Taylor expanded in x around inf
Simplified97.9%
Taylor expanded in x around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6482.0
Simplified82.0%
Final simplification41.3%
(FPCore (x y z) :precision binary64 (if (<= x -62000000000.0) (* (* z z) 0.5) (if (<= x 2.7e+87) (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 <= -62000000000.0) {
tmp = (z * z) * 0.5;
} else if (x <= 2.7e+87) {
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 <= -62000000000.0) tmp = Float64(Float64(z * z) * 0.5); elseif (x <= 2.7e+87) 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, -62000000000.0], N[(N[(z * z), $MachinePrecision] * 0.5), $MachinePrecision], If[LessEqual[x, 2.7e+87], 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 -62000000000:\\
\;\;\;\;\left(z \cdot z\right) \cdot 0.5\\
\mathbf{elif}\;x \leq 2.7 \cdot 10^{+87}:\\
\;\;\;\;\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 < -6.2e10Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-lowering-neg.f6433.6
Simplified33.6%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f6415.1
Simplified15.1%
Taylor expanded in z around inf
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6434.1
Simplified34.1%
if -6.2e10 < x < 2.70000000000000007e87Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-lowering-neg.f6455.1
Simplified55.1%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f6431.3
Simplified31.3%
Taylor expanded in z around inf
*-lowering-*.f6430.9
Simplified30.9%
if 2.70000000000000007e87 < x Initial program 100.0%
Taylor expanded in x around inf
Simplified97.9%
Taylor expanded in x around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6482.0
Simplified82.0%
Final simplification41.1%
(FPCore (x y z) :precision binary64 (+ x 1.0))
double code(double x, double y, double z) {
return x + 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 = x + 1.0d0
end function
public static double code(double x, double y, double z) {
return x + 1.0;
}
def code(x, y, z): return x + 1.0
function code(x, y, z) return Float64(x + 1.0) end
function tmp = code(x, y, z) tmp = x + 1.0; end
code[x_, y_, z_] := N[(x + 1.0), $MachinePrecision]
\begin{array}{l}
\\
x + 1
\end{array}
Initial program 100.0%
Taylor expanded in x around inf
Simplified53.6%
Taylor expanded in x around 0
+-lowering-+.f6412.4
Simplified12.4%
Final simplification12.4%
(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 x around inf
Simplified53.6%
Taylor expanded in x around 0
Simplified12.0%
(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 2024204
(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)))