
(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 -1e+55)
(exp x)
(if (<= t_0 0.0005) (exp (- 0.0 z)) (exp (fma y (log y) x))))))
double code(double x, double y, double z) {
double t_0 = x + (y * log(y));
double tmp;
if (t_0 <= -1e+55) {
tmp = exp(x);
} else if (t_0 <= 0.0005) {
tmp = exp((0.0 - z));
} else {
tmp = exp(fma(y, log(y), x));
}
return tmp;
}
function code(x, y, z) t_0 = Float64(x + Float64(y * log(y))) tmp = 0.0 if (t_0 <= -1e+55) tmp = exp(x); elseif (t_0 <= 0.0005) tmp = exp(Float64(0.0 - z)); else tmp = exp(fma(y, log(y), x)); 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, -1e+55], N[Exp[x], $MachinePrecision], If[LessEqual[t$95$0, 0.0005], N[Exp[N[(0.0 - z), $MachinePrecision]], $MachinePrecision], N[Exp[N[(y * N[Log[y], $MachinePrecision] + x), $MachinePrecision]], $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := x + y \cdot \log y\\
\mathbf{if}\;t\_0 \leq -1 \cdot 10^{+55}:\\
\;\;\;\;e^{x}\\
\mathbf{elif}\;t\_0 \leq 0.0005:\\
\;\;\;\;e^{0 - z}\\
\mathbf{else}:\\
\;\;\;\;e^{\mathsf{fma}\left(y, \log y, x\right)}\\
\end{array}
\end{array}
if (+.f64 x (*.f64 y (log.f64 y))) < -1.00000000000000001e55Initial program 100.0%
Taylor expanded in x around inf
Simplified97.5%
if -1.00000000000000001e55 < (+.f64 x (*.f64 y (log.f64 y))) < 5.0000000000000001e-4Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f6499.0
Simplified99.0%
sub0-negN/A
neg-lowering-neg.f6499.0
Applied egg-rr99.0%
if 5.0000000000000001e-4 < (+.f64 x (*.f64 y (log.f64 y))) Initial program 99.9%
Taylor expanded in z around 0
exp-lowering-exp.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
log-lowering-log.f6490.9
Simplified90.9%
Final simplification94.3%
(FPCore (x y z) :precision binary64 (let* ((t_0 (+ x (* y (log y))))) (if (<= t_0 -1e+55) (exp x) (if (<= t_0 1e+50) (exp (- 0.0 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+55) {
tmp = exp(x);
} else if (t_0 <= 1e+50) {
tmp = exp((0.0 - 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+55)) then
tmp = exp(x)
else if (t_0 <= 1d+50) then
tmp = exp((0.0d0 - 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+55) {
tmp = Math.exp(x);
} else if (t_0 <= 1e+50) {
tmp = Math.exp((0.0 - 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+55: tmp = math.exp(x) elif t_0 <= 1e+50: tmp = math.exp((0.0 - 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+55) tmp = exp(x); elseif (t_0 <= 1e+50) tmp = exp(Float64(0.0 - 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+55) tmp = exp(x); elseif (t_0 <= 1e+50) tmp = exp((0.0 - 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+55], N[Exp[x], $MachinePrecision], If[LessEqual[t$95$0, 1e+50], N[Exp[N[(0.0 - z), $MachinePrecision]], $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^{+55}:\\
\;\;\;\;e^{x}\\
\mathbf{elif}\;t\_0 \leq 10^{+50}:\\
\;\;\;\;e^{0 - z}\\
\mathbf{else}:\\
\;\;\;\;{y}^{y}\\
\end{array}
\end{array}
if (+.f64 x (*.f64 y (log.f64 y))) < -1.00000000000000001e55Initial program 100.0%
Taylor expanded in x around inf
Simplified97.5%
if -1.00000000000000001e55 < (+.f64 x (*.f64 y (log.f64 y))) < 1.0000000000000001e50Initial program 99.9%
Taylor expanded in z around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f6492.9
Simplified92.9%
sub0-negN/A
neg-lowering-neg.f6492.9
Applied egg-rr92.9%
if 1.0000000000000001e50 < (+.f64 x (*.f64 y (log.f64 y))) Initial program 100.0%
Taylor expanded in z around 0
exp-lowering-exp.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
log-lowering-log.f6493.7
Simplified93.7%
Taylor expanded in x around 0
pow-lowering-pow.f6476.7
Simplified76.7%
Final simplification85.7%
(FPCore (x y z) :precision binary64 (if (<= (* y (log y)) 200.0) (* (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)) <= 200.0) {
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)) <= 200.0) 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], 200.0], 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 200:\\
\;\;\;\;{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)) < 200Initial program 99.9%
+-commutativeN/A
associate--l+N/A
exp-sumN/A
*-lowering-*.f64N/A
*-commutativeN/A
exp-to-powN/A
pow-lowering-pow.f64N/A
exp-lowering-exp.f64N/A
--lowering--.f64100.0
Applied egg-rr100.0%
if 200 < (*.f64 y (log.f64 y)) Initial program 100.0%
Taylor expanded in z around 0
exp-lowering-exp.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
log-lowering-log.f6492.4
Simplified92.4%
(FPCore (x y z) :precision binary64 (let* ((t_0 (- (+ x (* y (log y))) z)) (t_1 (fma 0.5 (* z z) 0.0))) (if (<= t_0 -1e+55) t_1 (if (<= t_0 5e+120) (- 1.0 z) t_1))))
double code(double x, double y, double z) {
double t_0 = (x + (y * log(y))) - z;
double t_1 = fma(0.5, (z * z), 0.0);
double tmp;
if (t_0 <= -1e+55) {
tmp = t_1;
} else if (t_0 <= 5e+120) {
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 = fma(0.5, Float64(z * z), 0.0) tmp = 0.0 if (t_0 <= -1e+55) tmp = t_1; elseif (t_0 <= 5e+120) tmp = Float64(1.0 - z); else tmp = t_1; 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]}, Block[{t$95$1 = N[(0.5 * N[(z * z), $MachinePrecision] + 0.0), $MachinePrecision]}, If[LessEqual[t$95$0, -1e+55], t$95$1, If[LessEqual[t$95$0, 5e+120], 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 := \mathsf{fma}\left(0.5, z \cdot z, 0\right)\\
\mathbf{if}\;t\_0 \leq -1 \cdot 10^{+55}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_0 \leq 5 \cdot 10^{+120}:\\
\;\;\;\;1 - z\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z) < -1.00000000000000001e55 or 5.00000000000000019e120 < (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z) Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f6445.4
Simplified45.4%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f6421.2
Simplified21.2%
Taylor expanded in z around inf
+-rgt-identityN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f6427.0
Simplified27.0%
if -1.00000000000000001e55 < (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z) < 5.00000000000000019e120Initial program 99.9%
Taylor expanded in z around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f6470.5
Simplified70.5%
Taylor expanded in z around 0
neg-mul-1N/A
unsub-negN/A
--lowering--.f6447.1
Simplified47.1%
(FPCore (x y z) :precision binary64 (if (<= (exp (- (+ x (* y (log y))) z)) 1e-300) (fma 0.5 (* z z) 0.0) (fma z (* z 0.5) 1.0)))
double code(double x, double y, double z) {
double tmp;
if (exp(((x + (y * log(y))) - z)) <= 1e-300) {
tmp = fma(0.5, (z * z), 0.0);
} else {
tmp = fma(z, (z * 0.5), 1.0);
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (exp(Float64(Float64(x + Float64(y * log(y))) - z)) <= 1e-300) tmp = fma(0.5, Float64(z * z), 0.0); else tmp = fma(z, Float64(z * 0.5), 1.0); end return tmp end
code[x_, y_, z_] := If[LessEqual[N[Exp[N[(N[(x + N[(y * N[Log[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - z), $MachinePrecision]], $MachinePrecision], 1e-300], N[(0.5 * N[(z * z), $MachinePrecision] + 0.0), $MachinePrecision], N[(z * N[(z * 0.5), $MachinePrecision] + 1.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;e^{\left(x + y \cdot \log y\right) - z} \leq 10^{-300}:\\
\;\;\;\;\mathsf{fma}\left(0.5, z \cdot z, 0\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(z, z \cdot 0.5, 1\right)\\
\end{array}
\end{array}
if (exp.f64 (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z)) < 1.00000000000000003e-300Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f6457.9
Simplified57.9%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f642.3
Simplified2.3%
Taylor expanded in z around inf
+-rgt-identityN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f6418.4
Simplified18.4%
if 1.00000000000000003e-300 < (exp.f64 (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z)) Initial program 99.9%
Taylor expanded in z around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f6451.3
Simplified51.3%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f6438.8
Simplified38.8%
Taylor expanded in z around inf
*-lowering-*.f6438.5
Simplified38.5%
Final simplification33.2%
(FPCore (x y z) :precision binary64 (if (<= (- (+ x (* y (log y))) z) 2e+117) (- 1.0 z) (* z (fma 0.5 z -1.0))))
double code(double x, double y, double z) {
double tmp;
if (((x + (y * log(y))) - z) <= 2e+117) {
tmp = 1.0 - z;
} else {
tmp = z * fma(0.5, z, -1.0);
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (Float64(Float64(x + Float64(y * log(y))) - z) <= 2e+117) tmp = Float64(1.0 - z); else tmp = Float64(z * fma(0.5, z, -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+117], N[(1.0 - z), $MachinePrecision], N[(z * N[(0.5 * z + -1.0), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\left(x + y \cdot \log y\right) - z \leq 2 \cdot 10^{+117}:\\
\;\;\;\;1 - z\\
\mathbf{else}:\\
\;\;\;\;z \cdot \mathsf{fma}\left(0.5, z, -1\right)\\
\end{array}
\end{array}
if (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z) < 2.0000000000000001e117Initial program 99.9%
Taylor expanded in z around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f6464.1
Simplified64.1%
Taylor expanded in z around 0
neg-mul-1N/A
unsub-negN/A
--lowering--.f6427.3
Simplified27.3%
if 2.0000000000000001e117 < (-.f64 (+.f64 x (*.f64 y (log.f64 y))) z) Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f6439.6
Simplified39.6%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f6431.4
Simplified31.4%
Taylor expanded in z around inf
Simplified30.7%
(FPCore (x y z)
:precision binary64
(if (<= z -1.02e+86)
(fma
z
(fma (* z (fma (* z (* z z)) -0.004629629629629629 0.125)) 4.0 -1.0)
1.0)
(if (<= z 4.45e+102)
(exp x)
(/ 1.0 (fma z (fma z (fma z 0.16666666666666666 0.5) 1.0) 1.0)))))
double code(double x, double y, double z) {
double tmp;
if (z <= -1.02e+86) {
tmp = fma(z, fma((z * fma((z * (z * z)), -0.004629629629629629, 0.125)), 4.0, -1.0), 1.0);
} else if (z <= 4.45e+102) {
tmp = exp(x);
} else {
tmp = 1.0 / fma(z, fma(z, fma(z, 0.16666666666666666, 0.5), 1.0), 1.0);
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (z <= -1.02e+86) tmp = fma(z, fma(Float64(z * fma(Float64(z * Float64(z * z)), -0.004629629629629629, 0.125)), 4.0, -1.0), 1.0); elseif (z <= 4.45e+102) tmp = exp(x); else tmp = Float64(1.0 / fma(z, fma(z, fma(z, 0.16666666666666666, 0.5), 1.0), 1.0)); end return tmp end
code[x_, y_, z_] := If[LessEqual[z, -1.02e+86], N[(z * N[(N[(z * N[(N[(z * N[(z * z), $MachinePrecision]), $MachinePrecision] * -0.004629629629629629 + 0.125), $MachinePrecision]), $MachinePrecision] * 4.0 + -1.0), $MachinePrecision] + 1.0), $MachinePrecision], If[LessEqual[z, 4.45e+102], N[Exp[x], $MachinePrecision], N[(1.0 / N[(z * N[(z * N[(z * 0.16666666666666666 + 0.5), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.02 \cdot 10^{+86}:\\
\;\;\;\;\mathsf{fma}\left(z, \mathsf{fma}\left(z \cdot \mathsf{fma}\left(z \cdot \left(z \cdot z\right), -0.004629629629629629, 0.125\right), 4, -1\right), 1\right)\\
\mathbf{elif}\;z \leq 4.45 \cdot 10^{+102}:\\
\;\;\;\;e^{x}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\mathsf{fma}\left(z, \mathsf{fma}\left(z, \mathsf{fma}\left(z, 0.16666666666666666, 0.5\right), 1\right), 1\right)}\\
\end{array}
\end{array}
if z < -1.01999999999999996e86Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f6490.4
Simplified90.4%
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.f6488.2
Simplified88.2%
*-commutativeN/A
flip3-+N/A
associate-*l/N/A
div-invN/A
accelerator-lowering-fma.f64N/A
Applied egg-rr19.6%
Taylor expanded in z around 0
Simplified90.4%
if -1.01999999999999996e86 < z < 4.4499999999999999e102Initial program 99.9%
Taylor expanded in x around inf
Simplified61.0%
if 4.4499999999999999e102 < z Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f6474.8
Simplified74.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.f641.2
Simplified1.2%
flip3-+N/A
clear-numN/A
/-lowering-/.f64N/A
clear-numN/A
flip3-+N/A
Applied egg-rr1.2%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6472.6
Simplified72.6%
Final simplification67.5%
(FPCore (x y z) :precision binary64 (if (<= y 8.4e+47) (exp x) (pow y y)))
double code(double x, double y, double z) {
double tmp;
if (y <= 8.4e+47) {
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 <= 8.4d+47) 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 <= 8.4e+47) {
tmp = Math.exp(x);
} else {
tmp = Math.pow(y, y);
}
return tmp;
}
def code(x, y, z): tmp = 0 if y <= 8.4e+47: tmp = math.exp(x) else: tmp = math.pow(y, y) return tmp
function code(x, y, z) tmp = 0.0 if (y <= 8.4e+47) tmp = exp(x); else tmp = y ^ y; end return tmp end
function tmp_2 = code(x, y, z) tmp = 0.0; if (y <= 8.4e+47) tmp = exp(x); else tmp = y ^ y; end tmp_2 = tmp; end
code[x_, y_, z_] := If[LessEqual[y, 8.4e+47], N[Exp[x], $MachinePrecision], N[Power[y, y], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq 8.4 \cdot 10^{+47}:\\
\;\;\;\;e^{x}\\
\mathbf{else}:\\
\;\;\;\;{y}^{y}\\
\end{array}
\end{array}
if y < 8.4e47Initial program 99.9%
Taylor expanded in x around inf
Simplified67.0%
if 8.4e47 < y Initial program 100.0%
Taylor expanded in z around 0
exp-lowering-exp.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
log-lowering-log.f6494.3
Simplified94.3%
Taylor expanded in x around 0
pow-lowering-pow.f6486.7
Simplified86.7%
(FPCore (x y z)
:precision binary64
(let* ((t_0 (fma x (fma x (fma x 0.16666666666666666 0.5) 1.0) 1.0))
(t_1 (* z (fma (* z (* z z)) -0.004629629629629629 0.125))))
(if (<= z -4.4e+51)
(fma z (fma t_1 (fma z -1.3333333333333333 4.0) -1.0) 1.0)
(if (<= z 1.06e-231)
t_0
(if (<= z 3.9e-47)
(fma
z
(fma
t_1
(/ (+ 36.0 (/ (+ (/ 972.0 (* z z)) -108.0) z)) (* z z))
-1.0)
1.0)
(if (<= z 1.6e+80)
t_0
(/
1.0
(fma z (fma z (fma z 0.16666666666666666 0.5) 1.0) 1.0))))))))
double code(double x, double y, double z) {
double t_0 = fma(x, fma(x, fma(x, 0.16666666666666666, 0.5), 1.0), 1.0);
double t_1 = z * fma((z * (z * z)), -0.004629629629629629, 0.125);
double tmp;
if (z <= -4.4e+51) {
tmp = fma(z, fma(t_1, fma(z, -1.3333333333333333, 4.0), -1.0), 1.0);
} else if (z <= 1.06e-231) {
tmp = t_0;
} else if (z <= 3.9e-47) {
tmp = fma(z, fma(t_1, ((36.0 + (((972.0 / (z * z)) + -108.0) / z)) / (z * z)), -1.0), 1.0);
} else if (z <= 1.6e+80) {
tmp = t_0;
} else {
tmp = 1.0 / fma(z, fma(z, fma(z, 0.16666666666666666, 0.5), 1.0), 1.0);
}
return tmp;
}
function code(x, y, z) t_0 = fma(x, fma(x, fma(x, 0.16666666666666666, 0.5), 1.0), 1.0) t_1 = Float64(z * fma(Float64(z * Float64(z * z)), -0.004629629629629629, 0.125)) tmp = 0.0 if (z <= -4.4e+51) tmp = fma(z, fma(t_1, fma(z, -1.3333333333333333, 4.0), -1.0), 1.0); elseif (z <= 1.06e-231) tmp = t_0; elseif (z <= 3.9e-47) tmp = fma(z, fma(t_1, Float64(Float64(36.0 + Float64(Float64(Float64(972.0 / Float64(z * z)) + -108.0) / z)) / Float64(z * z)), -1.0), 1.0); elseif (z <= 1.6e+80) tmp = t_0; else tmp = Float64(1.0 / fma(z, fma(z, fma(z, 0.16666666666666666, 0.5), 1.0), 1.0)); end return tmp end
code[x_, y_, z_] := Block[{t$95$0 = N[(x * N[(x * N[(x * 0.16666666666666666 + 0.5), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]}, Block[{t$95$1 = N[(z * N[(N[(z * N[(z * z), $MachinePrecision]), $MachinePrecision] * -0.004629629629629629 + 0.125), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -4.4e+51], N[(z * N[(t$95$1 * N[(z * -1.3333333333333333 + 4.0), $MachinePrecision] + -1.0), $MachinePrecision] + 1.0), $MachinePrecision], If[LessEqual[z, 1.06e-231], t$95$0, If[LessEqual[z, 3.9e-47], N[(z * N[(t$95$1 * N[(N[(36.0 + N[(N[(N[(972.0 / N[(z * z), $MachinePrecision]), $MachinePrecision] + -108.0), $MachinePrecision] / z), $MachinePrecision]), $MachinePrecision] / N[(z * z), $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision] + 1.0), $MachinePrecision], If[LessEqual[z, 1.6e+80], t$95$0, N[(1.0 / N[(z * N[(z * N[(z * 0.16666666666666666 + 0.5), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(x, \mathsf{fma}\left(x, \mathsf{fma}\left(x, 0.16666666666666666, 0.5\right), 1\right), 1\right)\\
t_1 := z \cdot \mathsf{fma}\left(z \cdot \left(z \cdot z\right), -0.004629629629629629, 0.125\right)\\
\mathbf{if}\;z \leq -4.4 \cdot 10^{+51}:\\
\;\;\;\;\mathsf{fma}\left(z, \mathsf{fma}\left(t\_1, \mathsf{fma}\left(z, -1.3333333333333333, 4\right), -1\right), 1\right)\\
\mathbf{elif}\;z \leq 1.06 \cdot 10^{-231}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;z \leq 3.9 \cdot 10^{-47}:\\
\;\;\;\;\mathsf{fma}\left(z, \mathsf{fma}\left(t\_1, \frac{36 + \frac{\frac{972}{z \cdot z} + -108}{z}}{z \cdot z}, -1\right), 1\right)\\
\mathbf{elif}\;z \leq 1.6 \cdot 10^{+80}:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\mathsf{fma}\left(z, \mathsf{fma}\left(z, \mathsf{fma}\left(z, 0.16666666666666666, 0.5\right), 1\right), 1\right)}\\
\end{array}
\end{array}
if z < -4.39999999999999984e51Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f6487.4
Simplified87.4%
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.f6477.5
Simplified77.5%
*-commutativeN/A
flip3-+N/A
associate-*l/N/A
div-invN/A
accelerator-lowering-fma.f64N/A
Applied egg-rr19.6%
Taylor expanded in z around 0
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6487.4
Simplified87.4%
if -4.39999999999999984e51 < z < 1.0600000000000001e-231 or 3.89999999999999978e-47 < z < 1.59999999999999995e80Initial program 100.0%
Taylor expanded in x around inf
Simplified63.1%
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.f6443.2
Simplified43.2%
if 1.0600000000000001e-231 < z < 3.89999999999999978e-47Initial program 99.8%
Taylor expanded in z around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f6418.0
Simplified18.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.f6418.0
Simplified18.0%
*-commutativeN/A
flip3-+N/A
associate-*l/N/A
div-invN/A
accelerator-lowering-fma.f64N/A
Applied egg-rr18.0%
Taylor expanded in z around inf
/-lowering-/.f64N/A
Simplified64.2%
if 1.59999999999999995e80 < z Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f6475.4
Simplified75.4%
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.f641.2
Simplified1.2%
flip3-+N/A
clear-numN/A
/-lowering-/.f64N/A
clear-numN/A
flip3-+N/A
Applied egg-rr1.2%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6471.0
Simplified71.0%
Final simplification59.4%
(FPCore (x y z)
:precision binary64
(if (<= z -5.4e+51)
(fma
z
(fma
(* z (fma (* z (* z z)) -0.004629629629629629 0.125))
(fma z -1.3333333333333333 4.0)
-1.0)
1.0)
(if (<= z 6.3e+81)
(fma x (fma x (fma x 0.16666666666666666 0.5) 1.0) 1.0)
(/ 1.0 (fma z (fma z (fma z 0.16666666666666666 0.5) 1.0) 1.0)))))
double code(double x, double y, double z) {
double tmp;
if (z <= -5.4e+51) {
tmp = fma(z, fma((z * fma((z * (z * z)), -0.004629629629629629, 0.125)), fma(z, -1.3333333333333333, 4.0), -1.0), 1.0);
} else if (z <= 6.3e+81) {
tmp = fma(x, fma(x, fma(x, 0.16666666666666666, 0.5), 1.0), 1.0);
} else {
tmp = 1.0 / fma(z, fma(z, fma(z, 0.16666666666666666, 0.5), 1.0), 1.0);
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (z <= -5.4e+51) tmp = fma(z, fma(Float64(z * fma(Float64(z * Float64(z * z)), -0.004629629629629629, 0.125)), fma(z, -1.3333333333333333, 4.0), -1.0), 1.0); elseif (z <= 6.3e+81) tmp = fma(x, fma(x, fma(x, 0.16666666666666666, 0.5), 1.0), 1.0); else tmp = Float64(1.0 / fma(z, fma(z, fma(z, 0.16666666666666666, 0.5), 1.0), 1.0)); end return tmp end
code[x_, y_, z_] := If[LessEqual[z, -5.4e+51], N[(z * N[(N[(z * N[(N[(z * N[(z * z), $MachinePrecision]), $MachinePrecision] * -0.004629629629629629 + 0.125), $MachinePrecision]), $MachinePrecision] * N[(z * -1.3333333333333333 + 4.0), $MachinePrecision] + -1.0), $MachinePrecision] + 1.0), $MachinePrecision], If[LessEqual[z, 6.3e+81], N[(x * N[(x * N[(x * 0.16666666666666666 + 0.5), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision], N[(1.0 / N[(z * N[(z * N[(z * 0.16666666666666666 + 0.5), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -5.4 \cdot 10^{+51}:\\
\;\;\;\;\mathsf{fma}\left(z, \mathsf{fma}\left(z \cdot \mathsf{fma}\left(z \cdot \left(z \cdot z\right), -0.004629629629629629, 0.125\right), \mathsf{fma}\left(z, -1.3333333333333333, 4\right), -1\right), 1\right)\\
\mathbf{elif}\;z \leq 6.3 \cdot 10^{+81}:\\
\;\;\;\;\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, \mathsf{fma}\left(z, 0.16666666666666666, 0.5\right), 1\right), 1\right)}\\
\end{array}
\end{array}
if z < -5.39999999999999983e51Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f6487.4
Simplified87.4%
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.f6477.5
Simplified77.5%
*-commutativeN/A
flip3-+N/A
associate-*l/N/A
div-invN/A
accelerator-lowering-fma.f64N/A
Applied egg-rr19.6%
Taylor expanded in z around 0
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6487.4
Simplified87.4%
if -5.39999999999999983e51 < z < 6.3000000000000004e81Initial program 99.9%
Taylor expanded in x around inf
Simplified60.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.f6440.9
Simplified40.9%
if 6.3000000000000004e81 < z Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f6475.4
Simplified75.4%
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.f641.2
Simplified1.2%
flip3-+N/A
clear-numN/A
/-lowering-/.f64N/A
clear-numN/A
flip3-+N/A
Applied egg-rr1.2%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6471.0
Simplified71.0%
Final simplification54.1%
(FPCore (x y z)
:precision binary64
(if (<= z -2e+55)
(fma
z
(fma (* z (fma (* z (* z z)) -0.004629629629629629 0.125)) 4.0 -1.0)
1.0)
(if (<= z 6.2e+81)
(fma x (fma x (fma x 0.16666666666666666 0.5) 1.0) 1.0)
(/ 1.0 (fma z (fma z (fma z 0.16666666666666666 0.5) 1.0) 1.0)))))
double code(double x, double y, double z) {
double tmp;
if (z <= -2e+55) {
tmp = fma(z, fma((z * fma((z * (z * z)), -0.004629629629629629, 0.125)), 4.0, -1.0), 1.0);
} else if (z <= 6.2e+81) {
tmp = fma(x, fma(x, fma(x, 0.16666666666666666, 0.5), 1.0), 1.0);
} else {
tmp = 1.0 / fma(z, fma(z, fma(z, 0.16666666666666666, 0.5), 1.0), 1.0);
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (z <= -2e+55) tmp = fma(z, fma(Float64(z * fma(Float64(z * Float64(z * z)), -0.004629629629629629, 0.125)), 4.0, -1.0), 1.0); elseif (z <= 6.2e+81) tmp = fma(x, fma(x, fma(x, 0.16666666666666666, 0.5), 1.0), 1.0); else tmp = Float64(1.0 / fma(z, fma(z, fma(z, 0.16666666666666666, 0.5), 1.0), 1.0)); end return tmp end
code[x_, y_, z_] := If[LessEqual[z, -2e+55], N[(z * N[(N[(z * N[(N[(z * N[(z * z), $MachinePrecision]), $MachinePrecision] * -0.004629629629629629 + 0.125), $MachinePrecision]), $MachinePrecision] * 4.0 + -1.0), $MachinePrecision] + 1.0), $MachinePrecision], If[LessEqual[z, 6.2e+81], N[(x * N[(x * N[(x * 0.16666666666666666 + 0.5), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision], N[(1.0 / N[(z * N[(z * N[(z * 0.16666666666666666 + 0.5), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -2 \cdot 10^{+55}:\\
\;\;\;\;\mathsf{fma}\left(z, \mathsf{fma}\left(z \cdot \mathsf{fma}\left(z \cdot \left(z \cdot z\right), -0.004629629629629629, 0.125\right), 4, -1\right), 1\right)\\
\mathbf{elif}\;z \leq 6.2 \cdot 10^{+81}:\\
\;\;\;\;\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, \mathsf{fma}\left(z, 0.16666666666666666, 0.5\right), 1\right), 1\right)}\\
\end{array}
\end{array}
if z < -2.00000000000000002e55Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f6487.4
Simplified87.4%
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.f6477.5
Simplified77.5%
*-commutativeN/A
flip3-+N/A
associate-*l/N/A
div-invN/A
accelerator-lowering-fma.f64N/A
Applied egg-rr19.6%
Taylor expanded in z around 0
Simplified83.6%
if -2.00000000000000002e55 < z < 6.2e81Initial program 99.9%
Taylor expanded in x around inf
Simplified60.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.f6440.9
Simplified40.9%
if 6.2e81 < z Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f6475.4
Simplified75.4%
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.f641.2
Simplified1.2%
flip3-+N/A
clear-numN/A
/-lowering-/.f64N/A
clear-numN/A
flip3-+N/A
Applied egg-rr1.2%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6471.0
Simplified71.0%
Final simplification53.4%
(FPCore (x y z)
:precision binary64
(if (<= z -1.18e+95)
(* (* z (* z z)) -0.16666666666666666)
(if (<= z 6.2e+81)
(fma x (fma x (fma x 0.16666666666666666 0.5) 1.0) 1.0)
(/ 1.0 (fma z (fma z (fma z 0.16666666666666666 0.5) 1.0) 1.0)))))
double code(double x, double y, double z) {
double tmp;
if (z <= -1.18e+95) {
tmp = (z * (z * z)) * -0.16666666666666666;
} else if (z <= 6.2e+81) {
tmp = fma(x, fma(x, fma(x, 0.16666666666666666, 0.5), 1.0), 1.0);
} else {
tmp = 1.0 / fma(z, fma(z, fma(z, 0.16666666666666666, 0.5), 1.0), 1.0);
}
return tmp;
}
function code(x, y, z) tmp = 0.0 if (z <= -1.18e+95) tmp = Float64(Float64(z * Float64(z * z)) * -0.16666666666666666); elseif (z <= 6.2e+81) tmp = fma(x, fma(x, fma(x, 0.16666666666666666, 0.5), 1.0), 1.0); else tmp = Float64(1.0 / fma(z, fma(z, fma(z, 0.16666666666666666, 0.5), 1.0), 1.0)); end return tmp end
code[x_, y_, z_] := If[LessEqual[z, -1.18e+95], N[(N[(z * N[(z * z), $MachinePrecision]), $MachinePrecision] * -0.16666666666666666), $MachinePrecision], If[LessEqual[z, 6.2e+81], N[(x * N[(x * N[(x * 0.16666666666666666 + 0.5), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision], N[(1.0 / N[(z * N[(z * N[(z * 0.16666666666666666 + 0.5), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -1.18 \cdot 10^{+95}:\\
\;\;\;\;\left(z \cdot \left(z \cdot z\right)\right) \cdot -0.16666666666666666\\
\mathbf{elif}\;z \leq 6.2 \cdot 10^{+81}:\\
\;\;\;\;\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, \mathsf{fma}\left(z, 0.16666666666666666, 0.5\right), 1\right), 1\right)}\\
\end{array}
\end{array}
if z < -1.17999999999999998e95Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f6490.4
Simplified90.4%
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.f6488.2
Simplified88.2%
Taylor expanded in z around inf
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6488.2
Simplified88.2%
if -1.17999999999999998e95 < z < 6.2e81Initial program 99.9%
Taylor expanded in x around inf
Simplified60.8%
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.f6440.1
Simplified40.1%
if 6.2e81 < z Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f6475.4
Simplified75.4%
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.f641.2
Simplified1.2%
flip3-+N/A
clear-numN/A
/-lowering-/.f64N/A
clear-numN/A
flip3-+N/A
Applied egg-rr1.2%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6471.0
Simplified71.0%
Final simplification52.6%
(FPCore (x y z)
:precision binary64
(if (<= z -2.3e+96)
(* (* z (* z z)) -0.16666666666666666)
(if (<= z 1.95e+142)
(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 <= -2.3e+96) {
tmp = (z * (z * z)) * -0.16666666666666666;
} else if (z <= 1.95e+142) {
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 <= -2.3e+96) tmp = Float64(Float64(z * Float64(z * z)) * -0.16666666666666666); elseif (z <= 1.95e+142) 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, -2.3e+96], N[(N[(z * N[(z * z), $MachinePrecision]), $MachinePrecision] * -0.16666666666666666), $MachinePrecision], If[LessEqual[z, 1.95e+142], 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 -2.3 \cdot 10^{+96}:\\
\;\;\;\;\left(z \cdot \left(z \cdot z\right)\right) \cdot -0.16666666666666666\\
\mathbf{elif}\;z \leq 1.95 \cdot 10^{+142}:\\
\;\;\;\;\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 < -2.30000000000000015e96Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f6490.4
Simplified90.4%
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.f6488.2
Simplified88.2%
Taylor expanded in z around inf
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6488.2
Simplified88.2%
if -2.30000000000000015e96 < z < 1.95e142Initial program 99.9%
Taylor expanded in x around inf
Simplified60.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.f6439.5
Simplified39.5%
if 1.95e142 < z Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f6479.6
Simplified79.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.f641.2
Simplified1.2%
flip3-+N/A
clear-numN/A
/-lowering-/.f64N/A
clear-numN/A
flip3-+N/A
Applied egg-rr1.2%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6473.4
Simplified73.4%
Final simplification51.1%
(FPCore (x y z)
:precision binary64
(if (<= x -1.8e+39)
(* (* z (* z z)) -0.16666666666666666)
(if (<= x 6.8e+84)
(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 <= -1.8e+39) {
tmp = (z * (z * z)) * -0.16666666666666666;
} else if (x <= 6.8e+84) {
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 <= -1.8e+39) tmp = Float64(Float64(z * Float64(z * z)) * -0.16666666666666666); elseif (x <= 6.8e+84) 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, -1.8e+39], N[(N[(z * N[(z * z), $MachinePrecision]), $MachinePrecision] * -0.16666666666666666), $MachinePrecision], If[LessEqual[x, 6.8e+84], 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 -1.8 \cdot 10^{+39}:\\
\;\;\;\;\left(z \cdot \left(z \cdot z\right)\right) \cdot -0.16666666666666666\\
\mathbf{elif}\;x \leq 6.8 \cdot 10^{+84}:\\
\;\;\;\;\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 < -1.79999999999999992e39Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f6437.1
Simplified37.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.f6414.1
Simplified14.1%
Taylor expanded in z around inf
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6440.6
Simplified40.6%
if -1.79999999999999992e39 < x < 6.7999999999999996e84Initial program 99.9%
Taylor expanded in z around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f6464.9
Simplified64.9%
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.f6439.7
Simplified39.7%
if 6.7999999999999996e84 < x Initial program 100.0%
Taylor expanded in x around inf
Simplified93.8%
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.f6486.2
Simplified86.2%
Final simplification48.6%
(FPCore (x y z)
:precision binary64
(if (<= x -1.5e+39)
(* (* z (* z z)) -0.16666666666666666)
(if (<= x 4.4e+84)
(fma z (fma 0.5 z -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 <= -1.5e+39) {
tmp = (z * (z * z)) * -0.16666666666666666;
} else if (x <= 4.4e+84) {
tmp = fma(z, fma(0.5, z, -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 <= -1.5e+39) tmp = Float64(Float64(z * Float64(z * z)) * -0.16666666666666666); elseif (x <= 4.4e+84) tmp = fma(z, fma(0.5, z, -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, -1.5e+39], N[(N[(z * N[(z * z), $MachinePrecision]), $MachinePrecision] * -0.16666666666666666), $MachinePrecision], If[LessEqual[x, 4.4e+84], N[(z * N[(0.5 * z + -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 -1.5 \cdot 10^{+39}:\\
\;\;\;\;\left(z \cdot \left(z \cdot z\right)\right) \cdot -0.16666666666666666\\
\mathbf{elif}\;x \leq 4.4 \cdot 10^{+84}:\\
\;\;\;\;\mathsf{fma}\left(z, \mathsf{fma}\left(0.5, z, -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 < -1.5e39Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f6437.1
Simplified37.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.f6414.1
Simplified14.1%
Taylor expanded in z around inf
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6440.6
Simplified40.6%
if -1.5e39 < x < 4.3999999999999997e84Initial program 99.9%
Taylor expanded in z around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f6464.9
Simplified64.9%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f6439.5
Simplified39.5%
if 4.3999999999999997e84 < x Initial program 100.0%
Taylor expanded in x around inf
Simplified93.8%
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.f6486.2
Simplified86.2%
Final simplification48.5%
(FPCore (x y z)
:precision binary64
(if (<= x -1.5e+39)
(* (* z (* z z)) -0.16666666666666666)
(if (<= x 3.6e+108)
(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 <= -1.5e+39) {
tmp = (z * (z * z)) * -0.16666666666666666;
} else if (x <= 3.6e+108) {
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 <= -1.5e+39) tmp = Float64(Float64(z * Float64(z * z)) * -0.16666666666666666); elseif (x <= 3.6e+108) 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, -1.5e+39], N[(N[(z * N[(z * z), $MachinePrecision]), $MachinePrecision] * -0.16666666666666666), $MachinePrecision], If[LessEqual[x, 3.6e+108], 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 -1.5 \cdot 10^{+39}:\\
\;\;\;\;\left(z \cdot \left(z \cdot z\right)\right) \cdot -0.16666666666666666\\
\mathbf{elif}\;x \leq 3.6 \cdot 10^{+108}:\\
\;\;\;\;\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 < -1.5e39Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f6437.1
Simplified37.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.f6414.1
Simplified14.1%
Taylor expanded in z around inf
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6440.6
Simplified40.6%
if -1.5e39 < x < 3.6e108Initial program 99.9%
Taylor expanded in z around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f6463.2
Simplified63.2%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f6438.7
Simplified38.7%
if 3.6e108 < x Initial program 100.0%
Taylor expanded in x around inf
Simplified93.0%
Taylor expanded in x around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6470.9
Simplified70.9%
Final simplification44.4%
(FPCore (x y z)
:precision binary64
(if (<= x -1.5e+39)
(fma 0.5 (* z z) 0.0)
(if (<= x 3.6e+108)
(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 <= -1.5e+39) {
tmp = fma(0.5, (z * z), 0.0);
} else if (x <= 3.6e+108) {
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 <= -1.5e+39) tmp = fma(0.5, Float64(z * z), 0.0); elseif (x <= 3.6e+108) 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, -1.5e+39], N[(0.5 * N[(z * z), $MachinePrecision] + 0.0), $MachinePrecision], If[LessEqual[x, 3.6e+108], 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 -1.5 \cdot 10^{+39}:\\
\;\;\;\;\mathsf{fma}\left(0.5, z \cdot z, 0\right)\\
\mathbf{elif}\;x \leq 3.6 \cdot 10^{+108}:\\
\;\;\;\;\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 < -1.5e39Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f6437.1
Simplified37.1%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f6412.3
Simplified12.3%
Taylor expanded in z around inf
+-rgt-identityN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f6433.5
Simplified33.5%
if -1.5e39 < x < 3.6e108Initial program 99.9%
Taylor expanded in z around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f6463.2
Simplified63.2%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f6438.7
Simplified38.7%
if 3.6e108 < x Initial program 100.0%
Taylor expanded in x around inf
Simplified93.0%
Taylor expanded in x around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6470.9
Simplified70.9%
(FPCore (x y z) :precision binary64 (if (<= x -1.65e+39) (fma 0.5 (* z z) 0.0) (if (<= x 3.6e+108) (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 <= -1.65e+39) {
tmp = fma(0.5, (z * z), 0.0);
} else if (x <= 3.6e+108) {
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 <= -1.65e+39) tmp = fma(0.5, Float64(z * z), 0.0); elseif (x <= 3.6e+108) 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, -1.65e+39], N[(0.5 * N[(z * z), $MachinePrecision] + 0.0), $MachinePrecision], If[LessEqual[x, 3.6e+108], 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 -1.65 \cdot 10^{+39}:\\
\;\;\;\;\mathsf{fma}\left(0.5, z \cdot z, 0\right)\\
\mathbf{elif}\;x \leq 3.6 \cdot 10^{+108}:\\
\;\;\;\;\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 < -1.6500000000000001e39Initial program 100.0%
Taylor expanded in z around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f6437.1
Simplified37.1%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f6412.3
Simplified12.3%
Taylor expanded in z around inf
+-rgt-identityN/A
accelerator-lowering-fma.f64N/A
unpow2N/A
*-lowering-*.f6433.5
Simplified33.5%
if -1.6500000000000001e39 < x < 3.6e108Initial program 99.9%
Taylor expanded in z around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f6463.2
Simplified63.2%
Taylor expanded in z around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
sub-negN/A
metadata-evalN/A
accelerator-lowering-fma.f6438.7
Simplified38.7%
Taylor expanded in z around inf
*-lowering-*.f6438.3
Simplified38.3%
if 3.6e108 < x Initial program 100.0%
Taylor expanded in x around inf
Simplified93.0%
Taylor expanded in x around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6470.9
Simplified70.9%
Final simplification42.7%
(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
neg-sub0N/A
--lowering--.f6453.0
Simplified53.0%
Taylor expanded in z around 0
neg-mul-1N/A
unsub-negN/A
--lowering--.f6416.6
Simplified16.6%
(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
Simplified52.3%
Taylor expanded in x around 0
+-lowering-+.f6416.6
Simplified16.6%
Final simplification16.6%
(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
Simplified52.3%
Taylor expanded in x around 0
Simplified16.4%
(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 2024196
(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)))