
(FPCore (x y z t a b) :precision binary64 (/ (* x (exp (- (+ (* y (log z)) (* (- t 1.0) (log a))) b))) y))
double code(double x, double y, double z, double t, double a, double b) {
return (x * exp((((y * log(z)) + ((t - 1.0) * log(a))) - b))) / y;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = (x * exp((((y * log(z)) + ((t - 1.0d0) * log(a))) - b))) / y
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return (x * Math.exp((((y * Math.log(z)) + ((t - 1.0) * Math.log(a))) - b))) / y;
}
def code(x, y, z, t, a, b): return (x * math.exp((((y * math.log(z)) + ((t - 1.0) * math.log(a))) - b))) / y
function code(x, y, z, t, a, b) return Float64(Float64(x * exp(Float64(Float64(Float64(y * log(z)) + Float64(Float64(t - 1.0) * log(a))) - b))) / y) end
function tmp = code(x, y, z, t, a, b) tmp = (x * exp((((y * log(z)) + ((t - 1.0) * log(a))) - b))) / y; end
code[x_, y_, z_, t_, a_, b_] := N[(N[(x * N[Exp[N[(N[(N[(y * N[Log[z], $MachinePrecision]), $MachinePrecision] + N[(N[(t - 1.0), $MachinePrecision] * N[Log[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]
\begin{array}{l}
\\
\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 27 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b) :precision binary64 (/ (* x (exp (- (+ (* y (log z)) (* (- t 1.0) (log a))) b))) y))
double code(double x, double y, double z, double t, double a, double b) {
return (x * exp((((y * log(z)) + ((t - 1.0) * log(a))) - b))) / y;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = (x * exp((((y * log(z)) + ((t - 1.0d0) * log(a))) - b))) / y
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return (x * Math.exp((((y * Math.log(z)) + ((t - 1.0) * Math.log(a))) - b))) / y;
}
def code(x, y, z, t, a, b): return (x * math.exp((((y * math.log(z)) + ((t - 1.0) * math.log(a))) - b))) / y
function code(x, y, z, t, a, b) return Float64(Float64(x * exp(Float64(Float64(Float64(y * log(z)) + Float64(Float64(t - 1.0) * log(a))) - b))) / y) end
function tmp = code(x, y, z, t, a, b) tmp = (x * exp((((y * log(z)) + ((t - 1.0) * log(a))) - b))) / y; end
code[x_, y_, z_, t_, a_, b_] := N[(N[(x * N[Exp[N[(N[(N[(y * N[Log[z], $MachinePrecision]), $MachinePrecision] + N[(N[(t - 1.0), $MachinePrecision] * N[Log[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]
\begin{array}{l}
\\
\frac{x \cdot e^{\left(y \cdot \log z + \left(t - 1\right) \cdot \log a\right) - b}}{y}
\end{array}
(FPCore (x y z t a b) :precision binary64 (/ (* x (exp (- (+ (* y (log z)) (* (+ t -1.0) (log a))) b))) y))
double code(double x, double y, double z, double t, double a, double b) {
return (x * exp((((y * log(z)) + ((t + -1.0) * log(a))) - b))) / y;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = (x * exp((((y * log(z)) + ((t + (-1.0d0)) * log(a))) - b))) / y
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return (x * Math.exp((((y * Math.log(z)) + ((t + -1.0) * Math.log(a))) - b))) / y;
}
def code(x, y, z, t, a, b): return (x * math.exp((((y * math.log(z)) + ((t + -1.0) * math.log(a))) - b))) / y
function code(x, y, z, t, a, b) return Float64(Float64(x * exp(Float64(Float64(Float64(y * log(z)) + Float64(Float64(t + -1.0) * log(a))) - b))) / y) end
function tmp = code(x, y, z, t, a, b) tmp = (x * exp((((y * log(z)) + ((t + -1.0) * log(a))) - b))) / y; end
code[x_, y_, z_, t_, a_, b_] := N[(N[(x * N[Exp[N[(N[(N[(y * N[Log[z], $MachinePrecision]), $MachinePrecision] + N[(N[(t + -1.0), $MachinePrecision] * N[Log[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]
\begin{array}{l}
\\
\frac{x \cdot e^{\left(y \cdot \log z + \left(t + -1\right) \cdot \log a\right) - b}}{y}
\end{array}
Initial program 99.2%
Final simplification99.2%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* (+ t -1.0) (log a)))
(t_2 (/ (* x (exp (- (* t (log a)) b))) y)))
(if (<= t_1 -4e+16)
t_2
(if (<= t_1 -152.0)
(/ x (* a (* y (exp b))))
(if (<= t_1 2e+99) (/ (* x (exp (- (* y (log z)) b))) y) t_2)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (t + -1.0) * log(a);
double t_2 = (x * exp(((t * log(a)) - b))) / y;
double tmp;
if (t_1 <= -4e+16) {
tmp = t_2;
} else if (t_1 <= -152.0) {
tmp = x / (a * (y * exp(b)));
} else if (t_1 <= 2e+99) {
tmp = (x * exp(((y * log(z)) - b))) / y;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = (t + (-1.0d0)) * log(a)
t_2 = (x * exp(((t * log(a)) - b))) / y
if (t_1 <= (-4d+16)) then
tmp = t_2
else if (t_1 <= (-152.0d0)) then
tmp = x / (a * (y * exp(b)))
else if (t_1 <= 2d+99) then
tmp = (x * exp(((y * log(z)) - b))) / y
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (t + -1.0) * Math.log(a);
double t_2 = (x * Math.exp(((t * Math.log(a)) - b))) / y;
double tmp;
if (t_1 <= -4e+16) {
tmp = t_2;
} else if (t_1 <= -152.0) {
tmp = x / (a * (y * Math.exp(b)));
} else if (t_1 <= 2e+99) {
tmp = (x * Math.exp(((y * Math.log(z)) - b))) / y;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (t + -1.0) * math.log(a) t_2 = (x * math.exp(((t * math.log(a)) - b))) / y tmp = 0 if t_1 <= -4e+16: tmp = t_2 elif t_1 <= -152.0: tmp = x / (a * (y * math.exp(b))) elif t_1 <= 2e+99: tmp = (x * math.exp(((y * math.log(z)) - b))) / y else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(t + -1.0) * log(a)) t_2 = Float64(Float64(x * exp(Float64(Float64(t * log(a)) - b))) / y) tmp = 0.0 if (t_1 <= -4e+16) tmp = t_2; elseif (t_1 <= -152.0) tmp = Float64(x / Float64(a * Float64(y * exp(b)))); elseif (t_1 <= 2e+99) tmp = Float64(Float64(x * exp(Float64(Float64(y * log(z)) - b))) / y); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (t + -1.0) * log(a); t_2 = (x * exp(((t * log(a)) - b))) / y; tmp = 0.0; if (t_1 <= -4e+16) tmp = t_2; elseif (t_1 <= -152.0) tmp = x / (a * (y * exp(b))); elseif (t_1 <= 2e+99) tmp = (x * exp(((y * log(z)) - b))) / y; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(t + -1.0), $MachinePrecision] * N[Log[a], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * N[Exp[N[(N[(t * N[Log[a], $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, If[LessEqual[t$95$1, -4e+16], t$95$2, If[LessEqual[t$95$1, -152.0], N[(x / N[(a * N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 2e+99], N[(N[(x * N[Exp[N[(N[(y * N[Log[z], $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], t$95$2]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(t + -1\right) \cdot \log a\\
t_2 := \frac{x \cdot e^{t \cdot \log a - b}}{y}\\
\mathbf{if}\;t\_1 \leq -4 \cdot 10^{+16}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_1 \leq -152:\\
\;\;\;\;\frac{x}{a \cdot \left(y \cdot e^{b}\right)}\\
\mathbf{elif}\;t\_1 \leq 2 \cdot 10^{+99}:\\
\;\;\;\;\frac{x \cdot e^{y \cdot \log z - b}}{y}\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a)) < -4e16 or 1.9999999999999999e99 < (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a)) Initial program 100.0%
Taylor expanded in t around inf
*-commutativeN/A
*-lowering-*.f64N/A
rem-exp-logN/A
log-lowering-log.f64N/A
rem-exp-log94.3
Simplified94.3%
if -4e16 < (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a)) < -152Initial program 96.4%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6484.2
Simplified84.2%
Taylor expanded in t around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6490.5
Simplified90.5%
if -152 < (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a)) < 1.9999999999999999e99Initial program 99.8%
Taylor expanded in y around inf
*-lowering-*.f64N/A
log-lowering-log.f6490.5
Simplified90.5%
Final simplification92.0%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* (+ t -1.0) (log a))) (t_2 (* x (/ (pow a t) y))))
(if (<= t_1 -1e+105)
t_2
(if (<= t_1 -152.0)
(/ x (* a (* y (exp b))))
(if (<= t_1 5e+100) (/ (* x (exp (- (* y (log z)) b))) y) t_2)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (t + -1.0) * log(a);
double t_2 = x * (pow(a, t) / y);
double tmp;
if (t_1 <= -1e+105) {
tmp = t_2;
} else if (t_1 <= -152.0) {
tmp = x / (a * (y * exp(b)));
} else if (t_1 <= 5e+100) {
tmp = (x * exp(((y * log(z)) - b))) / y;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = (t + (-1.0d0)) * log(a)
t_2 = x * ((a ** t) / y)
if (t_1 <= (-1d+105)) then
tmp = t_2
else if (t_1 <= (-152.0d0)) then
tmp = x / (a * (y * exp(b)))
else if (t_1 <= 5d+100) then
tmp = (x * exp(((y * log(z)) - b))) / y
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (t + -1.0) * Math.log(a);
double t_2 = x * (Math.pow(a, t) / y);
double tmp;
if (t_1 <= -1e+105) {
tmp = t_2;
} else if (t_1 <= -152.0) {
tmp = x / (a * (y * Math.exp(b)));
} else if (t_1 <= 5e+100) {
tmp = (x * Math.exp(((y * Math.log(z)) - b))) / y;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (t + -1.0) * math.log(a) t_2 = x * (math.pow(a, t) / y) tmp = 0 if t_1 <= -1e+105: tmp = t_2 elif t_1 <= -152.0: tmp = x / (a * (y * math.exp(b))) elif t_1 <= 5e+100: tmp = (x * math.exp(((y * math.log(z)) - b))) / y else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(t + -1.0) * log(a)) t_2 = Float64(x * Float64((a ^ t) / y)) tmp = 0.0 if (t_1 <= -1e+105) tmp = t_2; elseif (t_1 <= -152.0) tmp = Float64(x / Float64(a * Float64(y * exp(b)))); elseif (t_1 <= 5e+100) tmp = Float64(Float64(x * exp(Float64(Float64(y * log(z)) - b))) / y); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (t + -1.0) * log(a); t_2 = x * ((a ^ t) / y); tmp = 0.0; if (t_1 <= -1e+105) tmp = t_2; elseif (t_1 <= -152.0) tmp = x / (a * (y * exp(b))); elseif (t_1 <= 5e+100) tmp = (x * exp(((y * log(z)) - b))) / y; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(t + -1.0), $MachinePrecision] * N[Log[a], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x * N[(N[Power[a, t], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -1e+105], t$95$2, If[LessEqual[t$95$1, -152.0], N[(x / N[(a * N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 5e+100], N[(N[(x * N[Exp[N[(N[(y * N[Log[z], $MachinePrecision]), $MachinePrecision] - b), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], t$95$2]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(t + -1\right) \cdot \log a\\
t_2 := x \cdot \frac{{a}^{t}}{y}\\
\mathbf{if}\;t\_1 \leq -1 \cdot 10^{+105}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_1 \leq -152:\\
\;\;\;\;\frac{x}{a \cdot \left(y \cdot e^{b}\right)}\\
\mathbf{elif}\;t\_1 \leq 5 \cdot 10^{+100}:\\
\;\;\;\;\frac{x \cdot e^{y \cdot \log z - b}}{y}\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a)) < -9.9999999999999994e104 or 4.9999999999999999e100 < (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a)) Initial program 100.0%
Taylor expanded in t around inf
*-commutativeN/A
*-lowering-*.f64N/A
rem-exp-logN/A
log-lowering-log.f64N/A
rem-exp-log94.0
Simplified94.0%
Taylor expanded in b around 0
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
pow-lowering-pow.f6491.6
Simplified91.6%
if -9.9999999999999994e104 < (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a)) < -152Initial program 97.4%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6477.5
Simplified77.5%
Taylor expanded in t around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6482.3
Simplified82.3%
if -152 < (*.f64 (-.f64 t #s(literal 1 binary64)) (log.f64 a)) < 4.9999999999999999e100Initial program 99.8%
Taylor expanded in y around inf
*-lowering-*.f64N/A
log-lowering-log.f6489.8
Simplified89.8%
Final simplification88.3%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ (* x (pow a (+ t -1.0))) y)) (t_2 (/ (* x (pow z y)) y)))
(if (<= y -3.8e+39)
t_2
(if (<= y -1.95e-177)
t_1
(if (<= y -1.05e-300)
(/ x (* y (exp b)))
(if (<= y 4.6e+43) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x * pow(a, (t + -1.0))) / y;
double t_2 = (x * pow(z, y)) / y;
double tmp;
if (y <= -3.8e+39) {
tmp = t_2;
} else if (y <= -1.95e-177) {
tmp = t_1;
} else if (y <= -1.05e-300) {
tmp = x / (y * exp(b));
} else if (y <= 4.6e+43) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = (x * (a ** (t + (-1.0d0)))) / y
t_2 = (x * (z ** y)) / y
if (y <= (-3.8d+39)) then
tmp = t_2
else if (y <= (-1.95d-177)) then
tmp = t_1
else if (y <= (-1.05d-300)) then
tmp = x / (y * exp(b))
else if (y <= 4.6d+43) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (x * Math.pow(a, (t + -1.0))) / y;
double t_2 = (x * Math.pow(z, y)) / y;
double tmp;
if (y <= -3.8e+39) {
tmp = t_2;
} else if (y <= -1.95e-177) {
tmp = t_1;
} else if (y <= -1.05e-300) {
tmp = x / (y * Math.exp(b));
} else if (y <= 4.6e+43) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (x * math.pow(a, (t + -1.0))) / y t_2 = (x * math.pow(z, y)) / y tmp = 0 if y <= -3.8e+39: tmp = t_2 elif y <= -1.95e-177: tmp = t_1 elif y <= -1.05e-300: tmp = x / (y * math.exp(b)) elif y <= 4.6e+43: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(x * (a ^ Float64(t + -1.0))) / y) t_2 = Float64(Float64(x * (z ^ y)) / y) tmp = 0.0 if (y <= -3.8e+39) tmp = t_2; elseif (y <= -1.95e-177) tmp = t_1; elseif (y <= -1.05e-300) tmp = Float64(x / Float64(y * exp(b))); elseif (y <= 4.6e+43) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (x * (a ^ (t + -1.0))) / y; t_2 = (x * (z ^ y)) / y; tmp = 0.0; if (y <= -3.8e+39) tmp = t_2; elseif (y <= -1.95e-177) tmp = t_1; elseif (y <= -1.05e-300) tmp = x / (y * exp(b)); elseif (y <= 4.6e+43) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(x * N[Power[a, N[(t + -1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * N[Power[z, y], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, If[LessEqual[y, -3.8e+39], t$95$2, If[LessEqual[y, -1.95e-177], t$95$1, If[LessEqual[y, -1.05e-300], N[(x / N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 4.6e+43], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x \cdot {a}^{\left(t + -1\right)}}{y}\\
t_2 := \frac{x \cdot {z}^{y}}{y}\\
\mathbf{if}\;y \leq -3.8 \cdot 10^{+39}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq -1.95 \cdot 10^{-177}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq -1.05 \cdot 10^{-300}:\\
\;\;\;\;\frac{x}{y \cdot e^{b}}\\
\mathbf{elif}\;y \leq 4.6 \cdot 10^{+43}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if y < -3.7999999999999998e39 or 4.6000000000000005e43 < y Initial program 100.0%
Taylor expanded in y around inf
*-lowering-*.f64N/A
log-lowering-log.f6496.2
Simplified96.2%
Taylor expanded in b around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
pow-lowering-pow.f6488.6
Simplified88.6%
if -3.7999999999999998e39 < y < -1.95000000000000007e-177 or -1.05000000000000002e-300 < y < 4.6000000000000005e43Initial program 98.4%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6482.6
Simplified82.6%
Taylor expanded in b around 0
Simplified73.2%
if -1.95000000000000007e-177 < y < -1.05000000000000002e-300Initial program 100.0%
Taylor expanded in t around inf
*-commutativeN/A
*-lowering-*.f64N/A
rem-exp-logN/A
log-lowering-log.f64N/A
rem-exp-log100.0
Simplified100.0%
Taylor expanded in t around 0
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
neg-lowering-neg.f6489.1
Simplified89.1%
exp-negN/A
un-div-invN/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6489.1
Applied egg-rr89.1%
Final simplification80.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* (pow a (+ t -1.0)) (/ x y))) (t_2 (/ (* x (pow z y)) y)))
(if (<= y -3.3e+40)
t_2
(if (<= y -1.15e-138)
t_1
(if (<= y 1.25e-204)
(/ x (* y (exp b)))
(if (<= y 3.1e+44) t_1 t_2))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = pow(a, (t + -1.0)) * (x / y);
double t_2 = (x * pow(z, y)) / y;
double tmp;
if (y <= -3.3e+40) {
tmp = t_2;
} else if (y <= -1.15e-138) {
tmp = t_1;
} else if (y <= 1.25e-204) {
tmp = x / (y * exp(b));
} else if (y <= 3.1e+44) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = (a ** (t + (-1.0d0))) * (x / y)
t_2 = (x * (z ** y)) / y
if (y <= (-3.3d+40)) then
tmp = t_2
else if (y <= (-1.15d-138)) then
tmp = t_1
else if (y <= 1.25d-204) then
tmp = x / (y * exp(b))
else if (y <= 3.1d+44) then
tmp = t_1
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = Math.pow(a, (t + -1.0)) * (x / y);
double t_2 = (x * Math.pow(z, y)) / y;
double tmp;
if (y <= -3.3e+40) {
tmp = t_2;
} else if (y <= -1.15e-138) {
tmp = t_1;
} else if (y <= 1.25e-204) {
tmp = x / (y * Math.exp(b));
} else if (y <= 3.1e+44) {
tmp = t_1;
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = math.pow(a, (t + -1.0)) * (x / y) t_2 = (x * math.pow(z, y)) / y tmp = 0 if y <= -3.3e+40: tmp = t_2 elif y <= -1.15e-138: tmp = t_1 elif y <= 1.25e-204: tmp = x / (y * math.exp(b)) elif y <= 3.1e+44: tmp = t_1 else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = Float64((a ^ Float64(t + -1.0)) * Float64(x / y)) t_2 = Float64(Float64(x * (z ^ y)) / y) tmp = 0.0 if (y <= -3.3e+40) tmp = t_2; elseif (y <= -1.15e-138) tmp = t_1; elseif (y <= 1.25e-204) tmp = Float64(x / Float64(y * exp(b))); elseif (y <= 3.1e+44) tmp = t_1; else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (a ^ (t + -1.0)) * (x / y); t_2 = (x * (z ^ y)) / y; tmp = 0.0; if (y <= -3.3e+40) tmp = t_2; elseif (y <= -1.15e-138) tmp = t_1; elseif (y <= 1.25e-204) tmp = x / (y * exp(b)); elseif (y <= 3.1e+44) tmp = t_1; else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[Power[a, N[(t + -1.0), $MachinePrecision]], $MachinePrecision] * N[(x / y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * N[Power[z, y], $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]}, If[LessEqual[y, -3.3e+40], t$95$2, If[LessEqual[y, -1.15e-138], t$95$1, If[LessEqual[y, 1.25e-204], N[(x / N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3.1e+44], t$95$1, t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := {a}^{\left(t + -1\right)} \cdot \frac{x}{y}\\
t_2 := \frac{x \cdot {z}^{y}}{y}\\
\mathbf{if}\;y \leq -3.3 \cdot 10^{+40}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;y \leq -1.15 \cdot 10^{-138}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 1.25 \cdot 10^{-204}:\\
\;\;\;\;\frac{x}{y \cdot e^{b}}\\
\mathbf{elif}\;y \leq 3.1 \cdot 10^{+44}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if y < -3.2999999999999998e40 or 3.09999999999999996e44 < y Initial program 100.0%
Taylor expanded in y around inf
*-lowering-*.f64N/A
log-lowering-log.f6496.2
Simplified96.2%
Taylor expanded in b around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
pow-lowering-pow.f6488.6
Simplified88.6%
if -3.2999999999999998e40 < y < -1.14999999999999995e-138 or 1.25e-204 < y < 3.09999999999999996e44Initial program 98.4%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6481.6
Simplified81.6%
Taylor expanded in b around 0
*-commutativeN/A
associate-/l*N/A
*-lowering-*.f64N/A
exp-to-powN/A
pow-lowering-pow.f64N/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
/-lowering-/.f6467.4
Simplified67.4%
if -1.14999999999999995e-138 < y < 1.25e-204Initial program 99.0%
Taylor expanded in t around inf
*-commutativeN/A
*-lowering-*.f64N/A
rem-exp-logN/A
log-lowering-log.f64N/A
rem-exp-log87.6
Simplified87.6%
Taylor expanded in t around 0
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
neg-lowering-neg.f6467.6
Simplified67.6%
exp-negN/A
un-div-invN/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6467.6
Applied egg-rr67.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* x (/ (pow a t) y))))
(if (<= (+ t -1.0) -2e+104)
t_1
(if (<= (+ t -1.0) 10000000000000.0) (/ x (* y (exp b))) t_1))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x * (pow(a, t) / y);
double tmp;
if ((t + -1.0) <= -2e+104) {
tmp = t_1;
} else if ((t + -1.0) <= 10000000000000.0) {
tmp = x / (y * exp(b));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = x * ((a ** t) / y)
if ((t + (-1.0d0)) <= (-2d+104)) then
tmp = t_1
else if ((t + (-1.0d0)) <= 10000000000000.0d0) then
tmp = x / (y * exp(b))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x * (Math.pow(a, t) / y);
double tmp;
if ((t + -1.0) <= -2e+104) {
tmp = t_1;
} else if ((t + -1.0) <= 10000000000000.0) {
tmp = x / (y * Math.exp(b));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x * (math.pow(a, t) / y) tmp = 0 if (t + -1.0) <= -2e+104: tmp = t_1 elif (t + -1.0) <= 10000000000000.0: tmp = x / (y * math.exp(b)) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x * Float64((a ^ t) / y)) tmp = 0.0 if (Float64(t + -1.0) <= -2e+104) tmp = t_1; elseif (Float64(t + -1.0) <= 10000000000000.0) tmp = Float64(x / Float64(y * exp(b))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x * ((a ^ t) / y); tmp = 0.0; if ((t + -1.0) <= -2e+104) tmp = t_1; elseif ((t + -1.0) <= 10000000000000.0) tmp = x / (y * exp(b)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x * N[(N[Power[a, t], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(t + -1.0), $MachinePrecision], -2e+104], t$95$1, If[LessEqual[N[(t + -1.0), $MachinePrecision], 10000000000000.0], N[(x / N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \frac{{a}^{t}}{y}\\
\mathbf{if}\;t + -1 \leq -2 \cdot 10^{+104}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t + -1 \leq 10000000000000:\\
\;\;\;\;\frac{x}{y \cdot e^{b}}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (-.f64 t #s(literal 1 binary64)) < -2e104 or 1e13 < (-.f64 t #s(literal 1 binary64)) Initial program 100.0%
Taylor expanded in t around inf
*-commutativeN/A
*-lowering-*.f64N/A
rem-exp-logN/A
log-lowering-log.f64N/A
rem-exp-log92.1
Simplified92.1%
Taylor expanded in b around 0
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
pow-lowering-pow.f6488.2
Simplified88.2%
if -2e104 < (-.f64 t #s(literal 1 binary64)) < 1e13Initial program 98.7%
Taylor expanded in t around inf
*-commutativeN/A
*-lowering-*.f64N/A
rem-exp-logN/A
log-lowering-log.f64N/A
rem-exp-log62.4
Simplified62.4%
Taylor expanded in t around 0
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
neg-lowering-neg.f6461.8
Simplified61.8%
exp-negN/A
un-div-invN/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6461.8
Applied egg-rr61.8%
Final simplification72.1%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ x (* y a))) (t_2 (/ x (* y (exp b)))))
(if (<= b -520000000000.0)
t_2
(if (<= b -3.4e-292)
(/ (fma t_1 2.0 (/ (* 4.0 (- (/ x (* y (* a b))) t_1)) b)) (* b b))
(if (<= b 0.062) (/ x (* b (* a (+ y (/ y b))))) t_2)))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x / (y * a);
double t_2 = x / (y * exp(b));
double tmp;
if (b <= -520000000000.0) {
tmp = t_2;
} else if (b <= -3.4e-292) {
tmp = fma(t_1, 2.0, ((4.0 * ((x / (y * (a * b))) - t_1)) / b)) / (b * b);
} else if (b <= 0.062) {
tmp = x / (b * (a * (y + (y / b))));
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(x / Float64(y * a)) t_2 = Float64(x / Float64(y * exp(b))) tmp = 0.0 if (b <= -520000000000.0) tmp = t_2; elseif (b <= -3.4e-292) tmp = Float64(fma(t_1, 2.0, Float64(Float64(4.0 * Float64(Float64(x / Float64(y * Float64(a * b))) - t_1)) / b)) / Float64(b * b)); elseif (b <= 0.062) tmp = Float64(x / Float64(b * Float64(a * Float64(y + Float64(y / b))))); else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x / N[(y * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(x / N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -520000000000.0], t$95$2, If[LessEqual[b, -3.4e-292], N[(N[(t$95$1 * 2.0 + N[(N[(4.0 * N[(N[(x / N[(y * N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision]), $MachinePrecision] / N[(b * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 0.062], N[(x / N[(b * N[(a * N[(y + N[(y / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x}{y \cdot a}\\
t_2 := \frac{x}{y \cdot e^{b}}\\
\mathbf{if}\;b \leq -520000000000:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;b \leq -3.4 \cdot 10^{-292}:\\
\;\;\;\;\frac{\mathsf{fma}\left(t\_1, 2, \frac{4 \cdot \left(\frac{x}{y \cdot \left(a \cdot b\right)} - t\_1\right)}{b}\right)}{b \cdot b}\\
\mathbf{elif}\;b \leq 0.062:\\
\;\;\;\;\frac{x}{b \cdot \left(a \cdot \left(y + \frac{y}{b}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if b < -5.2e11 or 0.062 < b Initial program 100.0%
Taylor expanded in t around inf
*-commutativeN/A
*-lowering-*.f64N/A
rem-exp-logN/A
log-lowering-log.f64N/A
rem-exp-log90.3
Simplified90.3%
Taylor expanded in t around 0
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
neg-lowering-neg.f6479.3
Simplified79.3%
exp-negN/A
un-div-invN/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6479.3
Applied egg-rr79.3%
if -5.2e11 < b < -3.40000000000000017e-292Initial program 99.3%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6477.0
Simplified77.0%
Taylor expanded in t around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6429.5
Simplified29.5%
Taylor expanded in b around 0
+-commutativeN/A
distribute-lft-inN/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-outN/A
*-rgt-identityN/A
distribute-lft-inN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f6429.5
Simplified29.5%
Taylor expanded in b around inf
Simplified52.1%
if -3.40000000000000017e-292 < b < 0.062Initial program 97.2%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6471.6
Simplified71.6%
Taylor expanded in t around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6443.0
Simplified43.0%
Taylor expanded in b around 0
distribute-lft-outN/A
*-lowering-*.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6443.1
Simplified43.1%
Taylor expanded in b around inf
*-lowering-*.f64N/A
associate-/l*N/A
distribute-lft-outN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f6455.2
Simplified55.2%
Final simplification67.9%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* x (/ (pow a t) y))))
(if (<= t -1e+99)
t_1
(if (<= t 58000000000000.0) (/ x (* a (* y (exp b)))) t_1))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x * (pow(a, t) / y);
double tmp;
if (t <= -1e+99) {
tmp = t_1;
} else if (t <= 58000000000000.0) {
tmp = x / (a * (y * exp(b)));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: tmp
t_1 = x * ((a ** t) / y)
if (t <= (-1d+99)) then
tmp = t_1
else if (t <= 58000000000000.0d0) then
tmp = x / (a * (y * exp(b)))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x * (Math.pow(a, t) / y);
double tmp;
if (t <= -1e+99) {
tmp = t_1;
} else if (t <= 58000000000000.0) {
tmp = x / (a * (y * Math.exp(b)));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x * (math.pow(a, t) / y) tmp = 0 if t <= -1e+99: tmp = t_1 elif t <= 58000000000000.0: tmp = x / (a * (y * math.exp(b))) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x * Float64((a ^ t) / y)) tmp = 0.0 if (t <= -1e+99) tmp = t_1; elseif (t <= 58000000000000.0) tmp = Float64(x / Float64(a * Float64(y * exp(b)))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x * ((a ^ t) / y); tmp = 0.0; if (t <= -1e+99) tmp = t_1; elseif (t <= 58000000000000.0) tmp = x / (a * (y * exp(b))); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x * N[(N[Power[a, t], $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1e+99], t$95$1, If[LessEqual[t, 58000000000000.0], N[(x / N[(a * N[(y * N[Exp[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot \frac{{a}^{t}}{y}\\
\mathbf{if}\;t \leq -1 \cdot 10^{+99}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 58000000000000:\\
\;\;\;\;\frac{x}{a \cdot \left(y \cdot e^{b}\right)}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -9.9999999999999997e98 or 5.8e13 < t Initial program 100.0%
Taylor expanded in t around inf
*-commutativeN/A
*-lowering-*.f64N/A
rem-exp-logN/A
log-lowering-log.f64N/A
rem-exp-log92.1
Simplified92.1%
Taylor expanded in b around 0
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
pow-lowering-pow.f6488.2
Simplified88.2%
if -9.9999999999999997e98 < t < 5.8e13Initial program 98.7%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6466.3
Simplified66.3%
Taylor expanded in t around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6475.6
Simplified75.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (/ x (* y a))) (t_2 (+ y (/ y b))))
(if (<= b -8.5e+80)
(/ (* x (fma b (fma b (fma b -0.16666666666666666 0.5) -1.0) 1.0)) y)
(if (<= b -1.4e-294)
(/ (fma t_1 2.0 (/ (* 4.0 (- (/ x (* y (* a b))) t_1)) b)) (* b b))
(if (<= b 3100.0)
(/ x (* b (* a t_2)))
(/
x
(*
a
(*
(* b (* b b))
(- (/ (fma y 0.5 (/ t_2 b)) b) (* y -0.16666666666666666))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x / (y * a);
double t_2 = y + (y / b);
double tmp;
if (b <= -8.5e+80) {
tmp = (x * fma(b, fma(b, fma(b, -0.16666666666666666, 0.5), -1.0), 1.0)) / y;
} else if (b <= -1.4e-294) {
tmp = fma(t_1, 2.0, ((4.0 * ((x / (y * (a * b))) - t_1)) / b)) / (b * b);
} else if (b <= 3100.0) {
tmp = x / (b * (a * t_2));
} else {
tmp = x / (a * ((b * (b * b)) * ((fma(y, 0.5, (t_2 / b)) / b) - (y * -0.16666666666666666))));
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(x / Float64(y * a)) t_2 = Float64(y + Float64(y / b)) tmp = 0.0 if (b <= -8.5e+80) tmp = Float64(Float64(x * fma(b, fma(b, fma(b, -0.16666666666666666, 0.5), -1.0), 1.0)) / y); elseif (b <= -1.4e-294) tmp = Float64(fma(t_1, 2.0, Float64(Float64(4.0 * Float64(Float64(x / Float64(y * Float64(a * b))) - t_1)) / b)) / Float64(b * b)); elseif (b <= 3100.0) tmp = Float64(x / Float64(b * Float64(a * t_2))); else tmp = Float64(x / Float64(a * Float64(Float64(b * Float64(b * b)) * Float64(Float64(fma(y, 0.5, Float64(t_2 / b)) / b) - Float64(y * -0.16666666666666666))))); end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x / N[(y * a), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(y + N[(y / b), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -8.5e+80], N[(N[(x * N[(b * N[(b * N[(b * -0.16666666666666666 + 0.5), $MachinePrecision] + -1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, -1.4e-294], N[(N[(t$95$1 * 2.0 + N[(N[(4.0 * N[(N[(x / N[(y * N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision]), $MachinePrecision] / N[(b * b), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 3100.0], N[(x / N[(b * N[(a * t$95$2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x / N[(a * N[(N[(b * N[(b * b), $MachinePrecision]), $MachinePrecision] * N[(N[(N[(y * 0.5 + N[(t$95$2 / b), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision] - N[(y * -0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{x}{y \cdot a}\\
t_2 := y + \frac{y}{b}\\
\mathbf{if}\;b \leq -8.5 \cdot 10^{+80}:\\
\;\;\;\;\frac{x \cdot \mathsf{fma}\left(b, \mathsf{fma}\left(b, \mathsf{fma}\left(b, -0.16666666666666666, 0.5\right), -1\right), 1\right)}{y}\\
\mathbf{elif}\;b \leq -1.4 \cdot 10^{-294}:\\
\;\;\;\;\frac{\mathsf{fma}\left(t\_1, 2, \frac{4 \cdot \left(\frac{x}{y \cdot \left(a \cdot b\right)} - t\_1\right)}{b}\right)}{b \cdot b}\\
\mathbf{elif}\;b \leq 3100:\\
\;\;\;\;\frac{x}{b \cdot \left(a \cdot t\_2\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{a \cdot \left(\left(b \cdot \left(b \cdot b\right)\right) \cdot \left(\frac{\mathsf{fma}\left(y, 0.5, \frac{t\_2}{b}\right)}{b} - y \cdot -0.16666666666666666\right)\right)}\\
\end{array}
\end{array}
if b < -8.50000000000000007e80Initial program 100.0%
Taylor expanded in t around inf
*-commutativeN/A
*-lowering-*.f64N/A
rem-exp-logN/A
log-lowering-log.f64N/A
rem-exp-log98.2
Simplified98.2%
Taylor expanded in t around 0
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
neg-lowering-neg.f6492.7
Simplified92.7%
Taylor expanded in b 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.f6489.1
Simplified89.1%
if -8.50000000000000007e80 < b < -1.39999999999999995e-294Initial program 99.5%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6467.6
Simplified67.6%
Taylor expanded in t around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6433.1
Simplified33.1%
Taylor expanded in b around 0
+-commutativeN/A
distribute-lft-inN/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-outN/A
*-rgt-identityN/A
distribute-lft-inN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f6431.8
Simplified31.8%
Taylor expanded in b around inf
Simplified47.6%
if -1.39999999999999995e-294 < b < 3100Initial program 97.4%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6469.9
Simplified69.9%
Taylor expanded in t around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6441.2
Simplified41.2%
Taylor expanded in b around 0
distribute-lft-outN/A
*-lowering-*.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6441.3
Simplified41.3%
Taylor expanded in b around inf
*-lowering-*.f64N/A
associate-/l*N/A
distribute-lft-outN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f6452.8
Simplified52.8%
if 3100 < b Initial program 100.0%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6463.9
Simplified63.9%
Taylor expanded in t around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6480.0
Simplified80.0%
Taylor expanded in b around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
distribute-lft-inN/A
associate-*r*N/A
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
distribute-rgt-outN/A
*-commutativeN/A
distribute-lft-inN/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6466.2
Simplified66.2%
Taylor expanded in b around -inf
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
Simplified67.5%
Final simplification63.1%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ y (/ y b))))
(if (<= b -2.8e+75)
(/ (* x (fma b (fma b (fma b -0.16666666666666666 0.5) -1.0) 1.0)) y)
(if (<= b -1.35e-297)
(/ (* x 2.0) (* y (* a (* b b))))
(if (<= b 3600.0)
(/ x (* b (* a t_1)))
(/
x
(*
a
(*
(* b (* b b))
(- (/ (fma y 0.5 (/ t_1 b)) b) (* y -0.16666666666666666))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y + (y / b);
double tmp;
if (b <= -2.8e+75) {
tmp = (x * fma(b, fma(b, fma(b, -0.16666666666666666, 0.5), -1.0), 1.0)) / y;
} else if (b <= -1.35e-297) {
tmp = (x * 2.0) / (y * (a * (b * b)));
} else if (b <= 3600.0) {
tmp = x / (b * (a * t_1));
} else {
tmp = x / (a * ((b * (b * b)) * ((fma(y, 0.5, (t_1 / b)) / b) - (y * -0.16666666666666666))));
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(y + Float64(y / b)) tmp = 0.0 if (b <= -2.8e+75) tmp = Float64(Float64(x * fma(b, fma(b, fma(b, -0.16666666666666666, 0.5), -1.0), 1.0)) / y); elseif (b <= -1.35e-297) tmp = Float64(Float64(x * 2.0) / Float64(y * Float64(a * Float64(b * b)))); elseif (b <= 3600.0) tmp = Float64(x / Float64(b * Float64(a * t_1))); else tmp = Float64(x / Float64(a * Float64(Float64(b * Float64(b * b)) * Float64(Float64(fma(y, 0.5, Float64(t_1 / b)) / b) - Float64(y * -0.16666666666666666))))); end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(y + N[(y / b), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[b, -2.8e+75], N[(N[(x * N[(b * N[(b * N[(b * -0.16666666666666666 + 0.5), $MachinePrecision] + -1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, -1.35e-297], N[(N[(x * 2.0), $MachinePrecision] / N[(y * N[(a * N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 3600.0], N[(x / N[(b * N[(a * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x / N[(a * N[(N[(b * N[(b * b), $MachinePrecision]), $MachinePrecision] * N[(N[(N[(y * 0.5 + N[(t$95$1 / b), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision] - N[(y * -0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y + \frac{y}{b}\\
\mathbf{if}\;b \leq -2.8 \cdot 10^{+75}:\\
\;\;\;\;\frac{x \cdot \mathsf{fma}\left(b, \mathsf{fma}\left(b, \mathsf{fma}\left(b, -0.16666666666666666, 0.5\right), -1\right), 1\right)}{y}\\
\mathbf{elif}\;b \leq -1.35 \cdot 10^{-297}:\\
\;\;\;\;\frac{x \cdot 2}{y \cdot \left(a \cdot \left(b \cdot b\right)\right)}\\
\mathbf{elif}\;b \leq 3600:\\
\;\;\;\;\frac{x}{b \cdot \left(a \cdot t\_1\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{a \cdot \left(\left(b \cdot \left(b \cdot b\right)\right) \cdot \left(\frac{\mathsf{fma}\left(y, 0.5, \frac{t\_1}{b}\right)}{b} - y \cdot -0.16666666666666666\right)\right)}\\
\end{array}
\end{array}
if b < -2.80000000000000012e75Initial program 100.0%
Taylor expanded in t around inf
*-commutativeN/A
*-lowering-*.f64N/A
rem-exp-logN/A
log-lowering-log.f64N/A
rem-exp-log98.2
Simplified98.2%
Taylor expanded in t around 0
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
neg-lowering-neg.f6492.7
Simplified92.7%
Taylor expanded in b 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.f6489.1
Simplified89.1%
if -2.80000000000000012e75 < b < -1.3500000000000001e-297Initial program 99.5%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6467.6
Simplified67.6%
Taylor expanded in t around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6433.1
Simplified33.1%
Taylor expanded in b around 0
+-commutativeN/A
distribute-lft-inN/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-outN/A
*-rgt-identityN/A
distribute-lft-inN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f6431.8
Simplified31.8%
Taylor expanded in b around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6446.1
Simplified46.1%
if -1.3500000000000001e-297 < b < 3600Initial program 97.4%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6469.9
Simplified69.9%
Taylor expanded in t around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6441.2
Simplified41.2%
Taylor expanded in b around 0
distribute-lft-outN/A
*-lowering-*.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6441.3
Simplified41.3%
Taylor expanded in b around inf
*-lowering-*.f64N/A
associate-/l*N/A
distribute-lft-outN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f6452.8
Simplified52.8%
if 3600 < b Initial program 100.0%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6463.9
Simplified63.9%
Taylor expanded in t around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6480.0
Simplified80.0%
Taylor expanded in b around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
distribute-lft-inN/A
associate-*r*N/A
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
distribute-rgt-outN/A
*-commutativeN/A
distribute-lft-inN/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6466.2
Simplified66.2%
Taylor expanded in b around -inf
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
Simplified67.5%
Final simplification62.7%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -3.5e+75)
(/ (* x (fma b (fma b (fma b -0.16666666666666666 0.5) -1.0) 1.0)) y)
(if (<= b -7.5e-297)
(/ (* x 2.0) (* y (* a (* b b))))
(if (<= b 3300.0)
(/ x (* b (* a (+ y (/ y b)))))
(/
x
(*
a
(* y (fma b (fma b (fma b 0.16666666666666666 0.5) 1.0) 1.0))))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -3.5e+75) {
tmp = (x * fma(b, fma(b, fma(b, -0.16666666666666666, 0.5), -1.0), 1.0)) / y;
} else if (b <= -7.5e-297) {
tmp = (x * 2.0) / (y * (a * (b * b)));
} else if (b <= 3300.0) {
tmp = x / (b * (a * (y + (y / b))));
} else {
tmp = x / (a * (y * fma(b, fma(b, fma(b, 0.16666666666666666, 0.5), 1.0), 1.0)));
}
return tmp;
}
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -3.5e+75) tmp = Float64(Float64(x * fma(b, fma(b, fma(b, -0.16666666666666666, 0.5), -1.0), 1.0)) / y); elseif (b <= -7.5e-297) tmp = Float64(Float64(x * 2.0) / Float64(y * Float64(a * Float64(b * b)))); elseif (b <= 3300.0) tmp = Float64(x / Float64(b * Float64(a * Float64(y + Float64(y / b))))); else tmp = Float64(x / Float64(a * Float64(y * fma(b, fma(b, fma(b, 0.16666666666666666, 0.5), 1.0), 1.0)))); end return tmp end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -3.5e+75], N[(N[(x * N[(b * N[(b * N[(b * -0.16666666666666666 + 0.5), $MachinePrecision] + -1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, -7.5e-297], N[(N[(x * 2.0), $MachinePrecision] / N[(y * N[(a * N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 3300.0], N[(x / N[(b * N[(a * N[(y + N[(y / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x / N[(a * N[(y * N[(b * N[(b * N[(b * 0.16666666666666666 + 0.5), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -3.5 \cdot 10^{+75}:\\
\;\;\;\;\frac{x \cdot \mathsf{fma}\left(b, \mathsf{fma}\left(b, \mathsf{fma}\left(b, -0.16666666666666666, 0.5\right), -1\right), 1\right)}{y}\\
\mathbf{elif}\;b \leq -7.5 \cdot 10^{-297}:\\
\;\;\;\;\frac{x \cdot 2}{y \cdot \left(a \cdot \left(b \cdot b\right)\right)}\\
\mathbf{elif}\;b \leq 3300:\\
\;\;\;\;\frac{x}{b \cdot \left(a \cdot \left(y + \frac{y}{b}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{a \cdot \left(y \cdot \mathsf{fma}\left(b, \mathsf{fma}\left(b, \mathsf{fma}\left(b, 0.16666666666666666, 0.5\right), 1\right), 1\right)\right)}\\
\end{array}
\end{array}
if b < -3.4999999999999998e75Initial program 100.0%
Taylor expanded in t around inf
*-commutativeN/A
*-lowering-*.f64N/A
rem-exp-logN/A
log-lowering-log.f64N/A
rem-exp-log98.2
Simplified98.2%
Taylor expanded in t around 0
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
neg-lowering-neg.f6492.7
Simplified92.7%
Taylor expanded in b 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.f6489.1
Simplified89.1%
if -3.4999999999999998e75 < b < -7.4999999999999994e-297Initial program 99.5%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6467.6
Simplified67.6%
Taylor expanded in t around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6433.1
Simplified33.1%
Taylor expanded in b around 0
+-commutativeN/A
distribute-lft-inN/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-outN/A
*-rgt-identityN/A
distribute-lft-inN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f6431.8
Simplified31.8%
Taylor expanded in b around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6446.1
Simplified46.1%
if -7.4999999999999994e-297 < b < 3300Initial program 97.4%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6469.9
Simplified69.9%
Taylor expanded in t around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6441.2
Simplified41.2%
Taylor expanded in b around 0
distribute-lft-outN/A
*-lowering-*.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6441.3
Simplified41.3%
Taylor expanded in b around inf
*-lowering-*.f64N/A
associate-/l*N/A
distribute-lft-outN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f6452.8
Simplified52.8%
if 3300 < b Initial program 100.0%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6463.9
Simplified63.9%
Taylor expanded in t around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6480.0
Simplified80.0%
Taylor expanded in b around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6467.5
Simplified67.5%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -2.9e+75)
(/ (* x (fma b (fma b (fma b -0.16666666666666666 0.5) -1.0) 1.0)) y)
(if (<= b -2.6e-292)
(/ (* x 2.0) (* y (* a (* b b))))
(if (<= b 0.032)
(/ x (* b (* a (+ y (/ y b)))))
(/ x (* a (* 0.16666666666666666 (* b (* y (* b b))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -2.9e+75) {
tmp = (x * fma(b, fma(b, fma(b, -0.16666666666666666, 0.5), -1.0), 1.0)) / y;
} else if (b <= -2.6e-292) {
tmp = (x * 2.0) / (y * (a * (b * b)));
} else if (b <= 0.032) {
tmp = x / (b * (a * (y + (y / b))));
} else {
tmp = x / (a * (0.16666666666666666 * (b * (y * (b * b)))));
}
return tmp;
}
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -2.9e+75) tmp = Float64(Float64(x * fma(b, fma(b, fma(b, -0.16666666666666666, 0.5), -1.0), 1.0)) / y); elseif (b <= -2.6e-292) tmp = Float64(Float64(x * 2.0) / Float64(y * Float64(a * Float64(b * b)))); elseif (b <= 0.032) tmp = Float64(x / Float64(b * Float64(a * Float64(y + Float64(y / b))))); else tmp = Float64(x / Float64(a * Float64(0.16666666666666666 * Float64(b * Float64(y * Float64(b * b)))))); end return tmp end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -2.9e+75], N[(N[(x * N[(b * N[(b * N[(b * -0.16666666666666666 + 0.5), $MachinePrecision] + -1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, -2.6e-292], N[(N[(x * 2.0), $MachinePrecision] / N[(y * N[(a * N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 0.032], N[(x / N[(b * N[(a * N[(y + N[(y / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x / N[(a * N[(0.16666666666666666 * N[(b * N[(y * N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -2.9 \cdot 10^{+75}:\\
\;\;\;\;\frac{x \cdot \mathsf{fma}\left(b, \mathsf{fma}\left(b, \mathsf{fma}\left(b, -0.16666666666666666, 0.5\right), -1\right), 1\right)}{y}\\
\mathbf{elif}\;b \leq -2.6 \cdot 10^{-292}:\\
\;\;\;\;\frac{x \cdot 2}{y \cdot \left(a \cdot \left(b \cdot b\right)\right)}\\
\mathbf{elif}\;b \leq 0.032:\\
\;\;\;\;\frac{x}{b \cdot \left(a \cdot \left(y + \frac{y}{b}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{a \cdot \left(0.16666666666666666 \cdot \left(b \cdot \left(y \cdot \left(b \cdot b\right)\right)\right)\right)}\\
\end{array}
\end{array}
if b < -2.8999999999999998e75Initial program 100.0%
Taylor expanded in t around inf
*-commutativeN/A
*-lowering-*.f64N/A
rem-exp-logN/A
log-lowering-log.f64N/A
rem-exp-log98.2
Simplified98.2%
Taylor expanded in t around 0
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
neg-lowering-neg.f6492.7
Simplified92.7%
Taylor expanded in b 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.f6489.1
Simplified89.1%
if -2.8999999999999998e75 < b < -2.60000000000000013e-292Initial program 99.5%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6467.6
Simplified67.6%
Taylor expanded in t around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6433.1
Simplified33.1%
Taylor expanded in b around 0
+-commutativeN/A
distribute-lft-inN/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-outN/A
*-rgt-identityN/A
distribute-lft-inN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f6431.8
Simplified31.8%
Taylor expanded in b around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6446.1
Simplified46.1%
if -2.60000000000000013e-292 < b < 0.032000000000000001Initial program 97.2%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6471.6
Simplified71.6%
Taylor expanded in t around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6443.0
Simplified43.0%
Taylor expanded in b around 0
distribute-lft-outN/A
*-lowering-*.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6443.1
Simplified43.1%
Taylor expanded in b around inf
*-lowering-*.f64N/A
associate-/l*N/A
distribute-lft-outN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f6455.2
Simplified55.2%
if 0.032000000000000001 < b Initial program 100.0%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6462.6
Simplified62.6%
Taylor expanded in t around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6476.8
Simplified76.8%
Taylor expanded in b around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
distribute-lft-inN/A
associate-*r*N/A
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
distribute-rgt-outN/A
*-commutativeN/A
distribute-lft-inN/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6463.6
Simplified63.6%
Taylor expanded in b around inf
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6463.6
Simplified63.6%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -3.5e+75)
(/ (* x (fma b (fma b (fma b -0.16666666666666666 0.5) -1.0) 1.0)) y)
(if (<= b -1.3e-291)
(/ (* x 2.0) (* y (* a (* b b))))
(if (<= b 7.2e+37)
(/ x (* b (* a (+ y (/ y b)))))
(/ x (* y (fma b (fma b (fma b 0.16666666666666666 0.5) 1.0) 1.0)))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -3.5e+75) {
tmp = (x * fma(b, fma(b, fma(b, -0.16666666666666666, 0.5), -1.0), 1.0)) / y;
} else if (b <= -1.3e-291) {
tmp = (x * 2.0) / (y * (a * (b * b)));
} else if (b <= 7.2e+37) {
tmp = x / (b * (a * (y + (y / b))));
} else {
tmp = x / (y * fma(b, fma(b, fma(b, 0.16666666666666666, 0.5), 1.0), 1.0));
}
return tmp;
}
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -3.5e+75) tmp = Float64(Float64(x * fma(b, fma(b, fma(b, -0.16666666666666666, 0.5), -1.0), 1.0)) / y); elseif (b <= -1.3e-291) tmp = Float64(Float64(x * 2.0) / Float64(y * Float64(a * Float64(b * b)))); elseif (b <= 7.2e+37) tmp = Float64(x / Float64(b * Float64(a * Float64(y + Float64(y / b))))); else tmp = Float64(x / Float64(y * fma(b, fma(b, fma(b, 0.16666666666666666, 0.5), 1.0), 1.0))); end return tmp end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -3.5e+75], N[(N[(x * N[(b * N[(b * N[(b * -0.16666666666666666 + 0.5), $MachinePrecision] + -1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, -1.3e-291], N[(N[(x * 2.0), $MachinePrecision] / N[(y * N[(a * N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 7.2e+37], N[(x / N[(b * N[(a * N[(y + N[(y / b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x / N[(y * N[(b * N[(b * N[(b * 0.16666666666666666 + 0.5), $MachinePrecision] + 1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -3.5 \cdot 10^{+75}:\\
\;\;\;\;\frac{x \cdot \mathsf{fma}\left(b, \mathsf{fma}\left(b, \mathsf{fma}\left(b, -0.16666666666666666, 0.5\right), -1\right), 1\right)}{y}\\
\mathbf{elif}\;b \leq -1.3 \cdot 10^{-291}:\\
\;\;\;\;\frac{x \cdot 2}{y \cdot \left(a \cdot \left(b \cdot b\right)\right)}\\
\mathbf{elif}\;b \leq 7.2 \cdot 10^{+37}:\\
\;\;\;\;\frac{x}{b \cdot \left(a \cdot \left(y + \frac{y}{b}\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y \cdot \mathsf{fma}\left(b, \mathsf{fma}\left(b, \mathsf{fma}\left(b, 0.16666666666666666, 0.5\right), 1\right), 1\right)}\\
\end{array}
\end{array}
if b < -3.4999999999999998e75Initial program 100.0%
Taylor expanded in t around inf
*-commutativeN/A
*-lowering-*.f64N/A
rem-exp-logN/A
log-lowering-log.f64N/A
rem-exp-log98.2
Simplified98.2%
Taylor expanded in t around 0
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
neg-lowering-neg.f6492.7
Simplified92.7%
Taylor expanded in b 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.f6489.1
Simplified89.1%
if -3.4999999999999998e75 < b < -1.2999999999999999e-291Initial program 99.5%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6467.6
Simplified67.6%
Taylor expanded in t around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6433.1
Simplified33.1%
Taylor expanded in b around 0
+-commutativeN/A
distribute-lft-inN/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-outN/A
*-rgt-identityN/A
distribute-lft-inN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f6431.8
Simplified31.8%
Taylor expanded in b around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6446.1
Simplified46.1%
if -1.2999999999999999e-291 < b < 7.19999999999999995e37Initial program 97.8%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6468.1
Simplified68.1%
Taylor expanded in t around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6446.0
Simplified46.0%
Taylor expanded in b around 0
distribute-lft-outN/A
*-lowering-*.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6437.3
Simplified37.3%
Taylor expanded in b around inf
*-lowering-*.f64N/A
associate-/l*N/A
distribute-lft-outN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f6446.7
Simplified46.7%
if 7.19999999999999995e37 < b Initial program 100.0%
Taylor expanded in t around inf
*-commutativeN/A
*-lowering-*.f64N/A
rem-exp-logN/A
log-lowering-log.f64N/A
rem-exp-log90.9
Simplified90.9%
Taylor expanded in t around 0
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
neg-lowering-neg.f6483.6
Simplified83.6%
exp-negN/A
un-div-invN/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6483.6
Applied egg-rr83.6%
Taylor expanded in b around 0
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6474.7
Simplified74.7%
(FPCore (x y z t a b)
:precision binary64
(if (<= b -2.4e+76)
(/ (fma x (* b (fma b 0.5 -1.0)) x) y)
(if (<= b 3.6e+113)
(/ x (* b (* b (* (* y a) 0.5))))
(/ x (fma y (fma b (* b 0.5) b) y)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -2.4e+76) {
tmp = fma(x, (b * fma(b, 0.5, -1.0)), x) / y;
} else if (b <= 3.6e+113) {
tmp = x / (b * (b * ((y * a) * 0.5)));
} else {
tmp = x / fma(y, fma(b, (b * 0.5), b), y);
}
return tmp;
}
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -2.4e+76) tmp = Float64(fma(x, Float64(b * fma(b, 0.5, -1.0)), x) / y); elseif (b <= 3.6e+113) tmp = Float64(x / Float64(b * Float64(b * Float64(Float64(y * a) * 0.5)))); else tmp = Float64(x / fma(y, fma(b, Float64(b * 0.5), b), y)); end return tmp end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -2.4e+76], N[(N[(x * N[(b * N[(b * 0.5 + -1.0), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, 3.6e+113], N[(x / N[(b * N[(b * N[(N[(y * a), $MachinePrecision] * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x / N[(y * N[(b * N[(b * 0.5), $MachinePrecision] + b), $MachinePrecision] + y), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -2.4 \cdot 10^{+76}:\\
\;\;\;\;\frac{\mathsf{fma}\left(x, b \cdot \mathsf{fma}\left(b, 0.5, -1\right), x\right)}{y}\\
\mathbf{elif}\;b \leq 3.6 \cdot 10^{+113}:\\
\;\;\;\;\frac{x}{b \cdot \left(b \cdot \left(\left(y \cdot a\right) \cdot 0.5\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{\mathsf{fma}\left(y, \mathsf{fma}\left(b, b \cdot 0.5, b\right), y\right)}\\
\end{array}
\end{array}
if b < -2.4e76Initial program 100.0%
Taylor expanded in t around inf
*-commutativeN/A
*-lowering-*.f64N/A
rem-exp-logN/A
log-lowering-log.f64N/A
rem-exp-log98.2
Simplified98.2%
Taylor expanded in t around 0
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
neg-lowering-neg.f6492.7
Simplified92.7%
Taylor expanded in b around 0
+-commutativeN/A
distribute-lft-inN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-outN/A
*-commutativeN/A
distribute-lft-inN/A
+-commutativeN/A
metadata-evalN/A
sub-negN/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
accelerator-lowering-fma.f6482.0
Simplified82.0%
if -2.4e76 < b < 3.59999999999999992e113Initial program 98.7%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6465.4
Simplified65.4%
Taylor expanded in t around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6442.6
Simplified42.6%
Taylor expanded in b around 0
+-commutativeN/A
distribute-lft-inN/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-outN/A
*-rgt-identityN/A
distribute-lft-inN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f6433.9
Simplified33.9%
Taylor expanded in b around inf
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6435.8
Simplified35.8%
if 3.59999999999999992e113 < b Initial program 100.0%
Taylor expanded in t around inf
*-commutativeN/A
*-lowering-*.f64N/A
rem-exp-logN/A
log-lowering-log.f64N/A
rem-exp-log95.0
Simplified95.0%
Taylor expanded in t around 0
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
neg-lowering-neg.f6489.9
Simplified89.9%
exp-negN/A
un-div-invN/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6489.9
Applied egg-rr89.9%
Taylor expanded in b around 0
distribute-rgt-inN/A
*-commutativeN/A
associate-+r+N/A
associate-*l*N/A
*-commutativeN/A
associate-*r*N/A
unpow2N/A
*-commutativeN/A
associate-*r*N/A
associate-+r+N/A
distribute-rgt-inN/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f6480.2
Simplified80.2%
Final simplification52.3%
(FPCore (x y z t a b) :precision binary64 (if (<= b -9.5e+60) (/ (fma x (* b (fma b 0.5 -1.0)) x) y) (if (<= b 2.7e+112) (/ (/ x a) y) (/ x (fma y (fma b (* b 0.5) b) y)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -9.5e+60) {
tmp = fma(x, (b * fma(b, 0.5, -1.0)), x) / y;
} else if (b <= 2.7e+112) {
tmp = (x / a) / y;
} else {
tmp = x / fma(y, fma(b, (b * 0.5), b), y);
}
return tmp;
}
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -9.5e+60) tmp = Float64(fma(x, Float64(b * fma(b, 0.5, -1.0)), x) / y); elseif (b <= 2.7e+112) tmp = Float64(Float64(x / a) / y); else tmp = Float64(x / fma(y, fma(b, Float64(b * 0.5), b), y)); end return tmp end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -9.5e+60], N[(N[(x * N[(b * N[(b * 0.5 + -1.0), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, 2.7e+112], N[(N[(x / a), $MachinePrecision] / y), $MachinePrecision], N[(x / N[(y * N[(b * N[(b * 0.5), $MachinePrecision] + b), $MachinePrecision] + y), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -9.5 \cdot 10^{+60}:\\
\;\;\;\;\frac{\mathsf{fma}\left(x, b \cdot \mathsf{fma}\left(b, 0.5, -1\right), x\right)}{y}\\
\mathbf{elif}\;b \leq 2.7 \cdot 10^{+112}:\\
\;\;\;\;\frac{\frac{x}{a}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{\mathsf{fma}\left(y, \mathsf{fma}\left(b, b \cdot 0.5, b\right), y\right)}\\
\end{array}
\end{array}
if b < -9.49999999999999988e60Initial program 100.0%
Taylor expanded in t around inf
*-commutativeN/A
*-lowering-*.f64N/A
rem-exp-logN/A
log-lowering-log.f64N/A
rem-exp-log94.9
Simplified94.9%
Taylor expanded in t around 0
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
neg-lowering-neg.f6488.1
Simplified88.1%
Taylor expanded in b around 0
+-commutativeN/A
distribute-lft-inN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-outN/A
*-commutativeN/A
distribute-lft-inN/A
+-commutativeN/A
metadata-evalN/A
sub-negN/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
accelerator-lowering-fma.f6478.2
Simplified78.2%
if -9.49999999999999988e60 < b < 2.7000000000000001e112Initial program 98.7%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6466.4
Simplified66.4%
Taylor expanded in b around 0
Simplified67.5%
Taylor expanded in t around 0
/-lowering-/.f6432.4
Simplified32.4%
if 2.7000000000000001e112 < b Initial program 100.0%
Taylor expanded in t around inf
*-commutativeN/A
*-lowering-*.f64N/A
rem-exp-logN/A
log-lowering-log.f64N/A
rem-exp-log95.0
Simplified95.0%
Taylor expanded in t around 0
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
neg-lowering-neg.f6489.9
Simplified89.9%
exp-negN/A
un-div-invN/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6489.9
Applied egg-rr89.9%
Taylor expanded in b around 0
distribute-rgt-inN/A
*-commutativeN/A
associate-+r+N/A
associate-*l*N/A
*-commutativeN/A
associate-*r*N/A
unpow2N/A
*-commutativeN/A
associate-*r*N/A
associate-+r+N/A
distribute-rgt-inN/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f6480.2
Simplified80.2%
(FPCore (x y z t a b) :precision binary64 (if (<= b -2.8e+75) (/ (* x (fma b (fma b (fma b -0.16666666666666666 0.5) -1.0) 1.0)) y) (/ (* x 2.0) (* y (* a (* b b))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -2.8e+75) {
tmp = (x * fma(b, fma(b, fma(b, -0.16666666666666666, 0.5), -1.0), 1.0)) / y;
} else {
tmp = (x * 2.0) / (y * (a * (b * b)));
}
return tmp;
}
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -2.8e+75) tmp = Float64(Float64(x * fma(b, fma(b, fma(b, -0.16666666666666666, 0.5), -1.0), 1.0)) / y); else tmp = Float64(Float64(x * 2.0) / Float64(y * Float64(a * Float64(b * b)))); end return tmp end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -2.8e+75], N[(N[(x * N[(b * N[(b * N[(b * -0.16666666666666666 + 0.5), $MachinePrecision] + -1.0), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], N[(N[(x * 2.0), $MachinePrecision] / N[(y * N[(a * N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -2.8 \cdot 10^{+75}:\\
\;\;\;\;\frac{x \cdot \mathsf{fma}\left(b, \mathsf{fma}\left(b, \mathsf{fma}\left(b, -0.16666666666666666, 0.5\right), -1\right), 1\right)}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot 2}{y \cdot \left(a \cdot \left(b \cdot b\right)\right)}\\
\end{array}
\end{array}
if b < -2.80000000000000012e75Initial program 100.0%
Taylor expanded in t around inf
*-commutativeN/A
*-lowering-*.f64N/A
rem-exp-logN/A
log-lowering-log.f64N/A
rem-exp-log98.2
Simplified98.2%
Taylor expanded in t around 0
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
neg-lowering-neg.f6492.7
Simplified92.7%
Taylor expanded in b 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.f6489.1
Simplified89.1%
if -2.80000000000000012e75 < b Initial program 99.0%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6467.1
Simplified67.1%
Taylor expanded in t around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6451.8
Simplified51.8%
Taylor expanded in b around 0
+-commutativeN/A
distribute-lft-inN/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-outN/A
*-rgt-identityN/A
distribute-lft-inN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f6442.8
Simplified42.8%
Taylor expanded in b around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6447.6
Simplified47.6%
(FPCore (x y z t a b) :precision binary64 (if (<= b -1.02e+76) (/ (fma x (* b (fma b 0.5 -1.0)) x) y) (/ (* x 2.0) (* y (* a (* b b))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.02e+76) {
tmp = fma(x, (b * fma(b, 0.5, -1.0)), x) / y;
} else {
tmp = (x * 2.0) / (y * (a * (b * b)));
}
return tmp;
}
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -1.02e+76) tmp = Float64(fma(x, Float64(b * fma(b, 0.5, -1.0)), x) / y); else tmp = Float64(Float64(x * 2.0) / Float64(y * Float64(a * Float64(b * b)))); end return tmp end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -1.02e+76], N[(N[(x * N[(b * N[(b * 0.5 + -1.0), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision] / y), $MachinePrecision], N[(N[(x * 2.0), $MachinePrecision] / N[(y * N[(a * N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.02 \cdot 10^{+76}:\\
\;\;\;\;\frac{\mathsf{fma}\left(x, b \cdot \mathsf{fma}\left(b, 0.5, -1\right), x\right)}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x \cdot 2}{y \cdot \left(a \cdot \left(b \cdot b\right)\right)}\\
\end{array}
\end{array}
if b < -1.02000000000000007e76Initial program 100.0%
Taylor expanded in t around inf
*-commutativeN/A
*-lowering-*.f64N/A
rem-exp-logN/A
log-lowering-log.f64N/A
rem-exp-log98.2
Simplified98.2%
Taylor expanded in t around 0
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
neg-lowering-neg.f6492.7
Simplified92.7%
Taylor expanded in b around 0
+-commutativeN/A
distribute-lft-inN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-outN/A
*-commutativeN/A
distribute-lft-inN/A
+-commutativeN/A
metadata-evalN/A
sub-negN/A
accelerator-lowering-fma.f64N/A
*-lowering-*.f64N/A
sub-negN/A
*-commutativeN/A
metadata-evalN/A
accelerator-lowering-fma.f6482.0
Simplified82.0%
if -1.02000000000000007e76 < b Initial program 99.0%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6467.1
Simplified67.1%
Taylor expanded in t around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6451.8
Simplified51.8%
Taylor expanded in b around 0
+-commutativeN/A
distribute-lft-inN/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-rgt-outN/A
*-rgt-identityN/A
distribute-lft-inN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f6442.8
Simplified42.8%
Taylor expanded in b around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6447.6
Simplified47.6%
(FPCore (x y z t a b) :precision binary64 (if (<= b -1.2e+86) (/ (- x (* x b)) y) (if (<= b 1.45e+23) (/ (/ x a) y) (/ x (* y (* a b))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.2e+86) {
tmp = (x - (x * b)) / y;
} else if (b <= 1.45e+23) {
tmp = (x / a) / y;
} else {
tmp = x / (y * (a * b));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (b <= (-1.2d+86)) then
tmp = (x - (x * b)) / y
else if (b <= 1.45d+23) then
tmp = (x / a) / y
else
tmp = x / (y * (a * b))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.2e+86) {
tmp = (x - (x * b)) / y;
} else if (b <= 1.45e+23) {
tmp = (x / a) / y;
} else {
tmp = x / (y * (a * b));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -1.2e+86: tmp = (x - (x * b)) / y elif b <= 1.45e+23: tmp = (x / a) / y else: tmp = x / (y * (a * b)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -1.2e+86) tmp = Float64(Float64(x - Float64(x * b)) / y); elseif (b <= 1.45e+23) tmp = Float64(Float64(x / a) / y); else tmp = Float64(x / Float64(y * Float64(a * b))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -1.2e+86) tmp = (x - (x * b)) / y; elseif (b <= 1.45e+23) tmp = (x / a) / y; else tmp = x / (y * (a * b)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -1.2e+86], N[(N[(x - N[(x * b), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, 1.45e+23], N[(N[(x / a), $MachinePrecision] / y), $MachinePrecision], N[(x / N[(y * N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.2 \cdot 10^{+86}:\\
\;\;\;\;\frac{x - x \cdot b}{y}\\
\mathbf{elif}\;b \leq 1.45 \cdot 10^{+23}:\\
\;\;\;\;\frac{\frac{x}{a}}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y \cdot \left(a \cdot b\right)}\\
\end{array}
\end{array}
if b < -1.2e86Initial program 100.0%
Taylor expanded in t around inf
*-commutativeN/A
*-lowering-*.f64N/A
rem-exp-logN/A
log-lowering-log.f64N/A
rem-exp-log98.1
Simplified98.1%
Taylor expanded in t around 0
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
neg-lowering-neg.f6492.6
Simplified92.6%
Taylor expanded in b around 0
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6442.2
Simplified42.2%
if -1.2e86 < b < 1.45000000000000006e23Initial program 98.5%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6468.9
Simplified68.9%
Taylor expanded in b around 0
Simplified68.0%
Taylor expanded in t around 0
/-lowering-/.f6435.0
Simplified35.0%
if 1.45000000000000006e23 < b Initial program 100.0%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6463.4
Simplified63.4%
Taylor expanded in t around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6482.0
Simplified82.0%
Taylor expanded in b around 0
distribute-lft-outN/A
*-lowering-*.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6437.9
Simplified37.9%
Taylor expanded in b around inf
/-lowering-/.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6442.8
Simplified42.8%
Final simplification38.3%
(FPCore (x y z t a b) :precision binary64 (if (<= b 38000000.0) (* (- 1.0 b) (/ x (* y a))) (/ x (fma y (fma b (* b 0.5) b) y))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= 38000000.0) {
tmp = (1.0 - b) * (x / (y * a));
} else {
tmp = x / fma(y, fma(b, (b * 0.5), b), y);
}
return tmp;
}
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= 38000000.0) tmp = Float64(Float64(1.0 - b) * Float64(x / Float64(y * a))); else tmp = Float64(x / fma(y, fma(b, Float64(b * 0.5), b), y)); end return tmp end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, 38000000.0], N[(N[(1.0 - b), $MachinePrecision] * N[(x / N[(y * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x / N[(y * N[(b * N[(b * 0.5), $MachinePrecision] + b), $MachinePrecision] + y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 38000000:\\
\;\;\;\;\left(1 - b\right) \cdot \frac{x}{y \cdot a}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{\mathsf{fma}\left(y, \mathsf{fma}\left(b, b \cdot 0.5, b\right), y\right)}\\
\end{array}
\end{array}
if b < 3.8e7Initial program 98.9%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6470.8
Simplified70.8%
Taylor expanded in t around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6453.9
Simplified53.9%
Taylor expanded in b around 0
associate-/l*N/A
associate-*r*N/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
neg-mul-1N/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f6435.8
Simplified35.8%
if 3.8e7 < b Initial program 100.0%
Taylor expanded in t around inf
*-commutativeN/A
*-lowering-*.f64N/A
rem-exp-logN/A
log-lowering-log.f64N/A
rem-exp-log89.6
Simplified89.6%
Taylor expanded in t around 0
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
neg-lowering-neg.f6479.1
Simplified79.1%
exp-negN/A
un-div-invN/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6479.1
Applied egg-rr79.1%
Taylor expanded in b around 0
distribute-rgt-inN/A
*-commutativeN/A
associate-+r+N/A
associate-*l*N/A
*-commutativeN/A
associate-*r*N/A
unpow2N/A
*-commutativeN/A
associate-*r*N/A
associate-+r+N/A
distribute-rgt-inN/A
+-commutativeN/A
accelerator-lowering-fma.f64N/A
+-commutativeN/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
accelerator-lowering-fma.f64N/A
*-commutativeN/A
*-lowering-*.f6453.1
Simplified53.1%
Final simplification40.2%
(FPCore (x y z t a b) :precision binary64 (if (<= b -1.35e+103) (/ (- x (* x b)) y) (if (<= b 2950.0) (/ x (* y a)) (/ x (* y (* a b))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.35e+103) {
tmp = (x - (x * b)) / y;
} else if (b <= 2950.0) {
tmp = x / (y * a);
} else {
tmp = x / (y * (a * b));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (b <= (-1.35d+103)) then
tmp = (x - (x * b)) / y
else if (b <= 2950.0d0) then
tmp = x / (y * a)
else
tmp = x / (y * (a * b))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.35e+103) {
tmp = (x - (x * b)) / y;
} else if (b <= 2950.0) {
tmp = x / (y * a);
} else {
tmp = x / (y * (a * b));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -1.35e+103: tmp = (x - (x * b)) / y elif b <= 2950.0: tmp = x / (y * a) else: tmp = x / (y * (a * b)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -1.35e+103) tmp = Float64(Float64(x - Float64(x * b)) / y); elseif (b <= 2950.0) tmp = Float64(x / Float64(y * a)); else tmp = Float64(x / Float64(y * Float64(a * b))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -1.35e+103) tmp = (x - (x * b)) / y; elseif (b <= 2950.0) tmp = x / (y * a); else tmp = x / (y * (a * b)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -1.35e+103], N[(N[(x - N[(x * b), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, 2950.0], N[(x / N[(y * a), $MachinePrecision]), $MachinePrecision], N[(x / N[(y * N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.35 \cdot 10^{+103}:\\
\;\;\;\;\frac{x - x \cdot b}{y}\\
\mathbf{elif}\;b \leq 2950:\\
\;\;\;\;\frac{x}{y \cdot a}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y \cdot \left(a \cdot b\right)}\\
\end{array}
\end{array}
if b < -1.34999999999999996e103Initial program 100.0%
Taylor expanded in t around inf
*-commutativeN/A
*-lowering-*.f64N/A
rem-exp-logN/A
log-lowering-log.f64N/A
rem-exp-log97.9
Simplified97.9%
Taylor expanded in t around 0
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
neg-lowering-neg.f6491.8
Simplified91.8%
Taylor expanded in b around 0
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6444.3
Simplified44.3%
if -1.34999999999999996e103 < b < 2950Initial program 98.5%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6470.1
Simplified70.1%
Taylor expanded in t around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6439.8
Simplified39.8%
Taylor expanded in b around 0
/-lowering-/.f64N/A
*-lowering-*.f6433.4
Simplified33.4%
if 2950 < b Initial program 100.0%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6463.9
Simplified63.9%
Taylor expanded in t around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6480.0
Simplified80.0%
Taylor expanded in b around 0
distribute-lft-outN/A
*-lowering-*.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6434.8
Simplified34.8%
Taylor expanded in b around inf
/-lowering-/.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6439.1
Simplified39.1%
Final simplification37.0%
(FPCore (x y z t a b) :precision binary64 (if (<= b -1.7e+103) (/ (- x (* x b)) y) (if (<= b 5700.0) (/ x (* y a)) (/ x (* a (* y b))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.7e+103) {
tmp = (x - (x * b)) / y;
} else if (b <= 5700.0) {
tmp = x / (y * a);
} else {
tmp = x / (a * (y * b));
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: tmp
if (b <= (-1.7d+103)) then
tmp = (x - (x * b)) / y
else if (b <= 5700.0d0) then
tmp = x / (y * a)
else
tmp = x / (a * (y * b))
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.7e+103) {
tmp = (x - (x * b)) / y;
} else if (b <= 5700.0) {
tmp = x / (y * a);
} else {
tmp = x / (a * (y * b));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if b <= -1.7e+103: tmp = (x - (x * b)) / y elif b <= 5700.0: tmp = x / (y * a) else: tmp = x / (a * (y * b)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -1.7e+103) tmp = Float64(Float64(x - Float64(x * b)) / y); elseif (b <= 5700.0) tmp = Float64(x / Float64(y * a)); else tmp = Float64(x / Float64(a * Float64(y * b))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (b <= -1.7e+103) tmp = (x - (x * b)) / y; elseif (b <= 5700.0) tmp = x / (y * a); else tmp = x / (a * (y * b)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -1.7e+103], N[(N[(x - N[(x * b), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, 5700.0], N[(x / N[(y * a), $MachinePrecision]), $MachinePrecision], N[(x / N[(a * N[(y * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.7 \cdot 10^{+103}:\\
\;\;\;\;\frac{x - x \cdot b}{y}\\
\mathbf{elif}\;b \leq 5700:\\
\;\;\;\;\frac{x}{y \cdot a}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{a \cdot \left(y \cdot b\right)}\\
\end{array}
\end{array}
if b < -1.6999999999999999e103Initial program 100.0%
Taylor expanded in t around inf
*-commutativeN/A
*-lowering-*.f64N/A
rem-exp-logN/A
log-lowering-log.f64N/A
rem-exp-log97.9
Simplified97.9%
Taylor expanded in t around 0
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
neg-lowering-neg.f6491.8
Simplified91.8%
Taylor expanded in b around 0
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6444.3
Simplified44.3%
if -1.6999999999999999e103 < b < 5700Initial program 98.5%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6470.1
Simplified70.1%
Taylor expanded in t around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6439.8
Simplified39.8%
Taylor expanded in b around 0
/-lowering-/.f64N/A
*-lowering-*.f6433.4
Simplified33.4%
if 5700 < b Initial program 100.0%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6463.9
Simplified63.9%
Taylor expanded in t around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6480.0
Simplified80.0%
Taylor expanded in b around 0
distribute-lft-outN/A
*-lowering-*.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6434.8
Simplified34.8%
Taylor expanded in b around inf
*-commutativeN/A
*-lowering-*.f6434.8
Simplified34.8%
Final simplification35.8%
(FPCore (x y z t a b) :precision binary64 (if (<= b -1.35e+103) (/ (- x (* x b)) y) (if (<= b 8.5e+90) (/ x (* y a)) (/ x (fma y b y)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.35e+103) {
tmp = (x - (x * b)) / y;
} else if (b <= 8.5e+90) {
tmp = x / (y * a);
} else {
tmp = x / fma(y, b, y);
}
return tmp;
}
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -1.35e+103) tmp = Float64(Float64(x - Float64(x * b)) / y); elseif (b <= 8.5e+90) tmp = Float64(x / Float64(y * a)); else tmp = Float64(x / fma(y, b, y)); end return tmp end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -1.35e+103], N[(N[(x - N[(x * b), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], If[LessEqual[b, 8.5e+90], N[(x / N[(y * a), $MachinePrecision]), $MachinePrecision], N[(x / N[(y * b + y), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.35 \cdot 10^{+103}:\\
\;\;\;\;\frac{x - x \cdot b}{y}\\
\mathbf{elif}\;b \leq 8.5 \cdot 10^{+90}:\\
\;\;\;\;\frac{x}{y \cdot a}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{\mathsf{fma}\left(y, b, y\right)}\\
\end{array}
\end{array}
if b < -1.34999999999999996e103Initial program 100.0%
Taylor expanded in t around inf
*-commutativeN/A
*-lowering-*.f64N/A
rem-exp-logN/A
log-lowering-log.f64N/A
rem-exp-log97.9
Simplified97.9%
Taylor expanded in t around 0
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
neg-lowering-neg.f6491.8
Simplified91.8%
Taylor expanded in b around 0
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6444.3
Simplified44.3%
if -1.34999999999999996e103 < b < 8.5000000000000002e90Initial program 98.7%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6466.6
Simplified66.6%
Taylor expanded in t around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6444.3
Simplified44.3%
Taylor expanded in b around 0
/-lowering-/.f64N/A
*-lowering-*.f6430.2
Simplified30.2%
if 8.5000000000000002e90 < b Initial program 100.0%
Taylor expanded in t around inf
*-commutativeN/A
*-lowering-*.f64N/A
rem-exp-logN/A
log-lowering-log.f64N/A
rem-exp-log93.0
Simplified93.0%
Taylor expanded in t around 0
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
neg-lowering-neg.f6488.3
Simplified88.3%
exp-negN/A
un-div-invN/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6488.3
Applied egg-rr88.3%
Taylor expanded in b around 0
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6431.6
Simplified31.6%
Final simplification33.1%
(FPCore (x y z t a b) :precision binary64 (if (<= b -1.4e+103) (* (/ x y) (- 1.0 b)) (if (<= b 4.6e+90) (/ x (* y a)) (/ x (fma y b y)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -1.4e+103) {
tmp = (x / y) * (1.0 - b);
} else if (b <= 4.6e+90) {
tmp = x / (y * a);
} else {
tmp = x / fma(y, b, y);
}
return tmp;
}
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -1.4e+103) tmp = Float64(Float64(x / y) * Float64(1.0 - b)); elseif (b <= 4.6e+90) tmp = Float64(x / Float64(y * a)); else tmp = Float64(x / fma(y, b, y)); end return tmp end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -1.4e+103], N[(N[(x / y), $MachinePrecision] * N[(1.0 - b), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 4.6e+90], N[(x / N[(y * a), $MachinePrecision]), $MachinePrecision], N[(x / N[(y * b + y), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.4 \cdot 10^{+103}:\\
\;\;\;\;\frac{x}{y} \cdot \left(1 - b\right)\\
\mathbf{elif}\;b \leq 4.6 \cdot 10^{+90}:\\
\;\;\;\;\frac{x}{y \cdot a}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{\mathsf{fma}\left(y, b, y\right)}\\
\end{array}
\end{array}
if b < -1.40000000000000004e103Initial program 100.0%
Taylor expanded in t around inf
*-commutativeN/A
*-lowering-*.f64N/A
rem-exp-logN/A
log-lowering-log.f64N/A
rem-exp-log97.9
Simplified97.9%
Taylor expanded in t around 0
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
neg-lowering-neg.f6491.8
Simplified91.8%
Taylor expanded in b around 0
associate-/l*N/A
associate-*r*N/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
neg-mul-1N/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f6436.4
Simplified36.4%
if -1.40000000000000004e103 < b < 4.6e90Initial program 98.7%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6466.6
Simplified66.6%
Taylor expanded in t around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6444.3
Simplified44.3%
Taylor expanded in b around 0
/-lowering-/.f64N/A
*-lowering-*.f6430.2
Simplified30.2%
if 4.6e90 < b Initial program 100.0%
Taylor expanded in t around inf
*-commutativeN/A
*-lowering-*.f64N/A
rem-exp-logN/A
log-lowering-log.f64N/A
rem-exp-log93.0
Simplified93.0%
Taylor expanded in t around 0
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
neg-lowering-neg.f6488.3
Simplified88.3%
exp-negN/A
un-div-invN/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6488.3
Applied egg-rr88.3%
Taylor expanded in b around 0
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6431.6
Simplified31.6%
Final simplification31.6%
(FPCore (x y z t a b) :precision binary64 (if (<= b -2.5e+76) (/ (- x (* x b)) y) (/ x (* a (fma y b y)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= -2.5e+76) {
tmp = (x - (x * b)) / y;
} else {
tmp = x / (a * fma(y, b, y));
}
return tmp;
}
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= -2.5e+76) tmp = Float64(Float64(x - Float64(x * b)) / y); else tmp = Float64(x / Float64(a * fma(y, b, y))); end return tmp end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, -2.5e+76], N[(N[(x - N[(x * b), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision], N[(x / N[(a * N[(y * b + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -2.5 \cdot 10^{+76}:\\
\;\;\;\;\frac{x - x \cdot b}{y}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{a \cdot \mathsf{fma}\left(y, b, y\right)}\\
\end{array}
\end{array}
if b < -2.49999999999999996e76Initial program 100.0%
Taylor expanded in t around inf
*-commutativeN/A
*-lowering-*.f64N/A
rem-exp-logN/A
log-lowering-log.f64N/A
rem-exp-log98.2
Simplified98.2%
Taylor expanded in t around 0
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
neg-lowering-neg.f6492.7
Simplified92.7%
Taylor expanded in b around 0
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f6441.5
Simplified41.5%
if -2.49999999999999996e76 < b Initial program 99.0%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6467.1
Simplified67.1%
Taylor expanded in t around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6451.8
Simplified51.8%
Taylor expanded in b around 0
distribute-lft-outN/A
*-lowering-*.f64N/A
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6434.0
Simplified34.0%
(FPCore (x y z t a b) :precision binary64 (if (<= b 2e+96) (/ x (* y a)) (/ x (fma y b y))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (b <= 2e+96) {
tmp = x / (y * a);
} else {
tmp = x / fma(y, b, y);
}
return tmp;
}
function code(x, y, z, t, a, b) tmp = 0.0 if (b <= 2e+96) tmp = Float64(x / Float64(y * a)); else tmp = Float64(x / fma(y, b, y)); end return tmp end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[b, 2e+96], N[(x / N[(y * a), $MachinePrecision]), $MachinePrecision], N[(x / N[(y * b + y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 2 \cdot 10^{+96}:\\
\;\;\;\;\frac{x}{y \cdot a}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{\mathsf{fma}\left(y, b, y\right)}\\
\end{array}
\end{array}
if b < 2.0000000000000001e96Initial program 99.0%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6467.5
Simplified67.5%
Taylor expanded in t around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6454.9
Simplified54.9%
Taylor expanded in b around 0
/-lowering-/.f64N/A
*-lowering-*.f6427.8
Simplified27.8%
if 2.0000000000000001e96 < b Initial program 100.0%
Taylor expanded in t around inf
*-commutativeN/A
*-lowering-*.f64N/A
rem-exp-logN/A
log-lowering-log.f64N/A
rem-exp-log93.0
Simplified93.0%
Taylor expanded in t around 0
*-lowering-*.f64N/A
exp-lowering-exp.f64N/A
neg-lowering-neg.f6488.3
Simplified88.3%
exp-negN/A
un-div-invN/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6488.3
Applied egg-rr88.3%
Taylor expanded in b around 0
+-commutativeN/A
*-commutativeN/A
accelerator-lowering-fma.f6431.6
Simplified31.6%
Final simplification28.4%
(FPCore (x y z t a b) :precision binary64 (/ x (* y a)))
double code(double x, double y, double z, double t, double a, double b) {
return x / (y * a);
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = x / (y * a)
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return x / (y * a);
}
def code(x, y, z, t, a, b): return x / (y * a)
function code(x, y, z, t, a, b) return Float64(x / Float64(y * a)) end
function tmp = code(x, y, z, t, a, b) tmp = x / (y * a); end
code[x_, y_, z_, t_, a_, b_] := N[(x / N[(y * a), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x}{y \cdot a}
\end{array}
Initial program 99.2%
Taylor expanded in y around 0
*-commutativeN/A
exp-diffN/A
associate-*l/N/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
exp-prodN/A
pow-lowering-pow.f64N/A
rem-exp-logN/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6468.6
Simplified68.6%
Taylor expanded in t around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
exp-lowering-exp.f6460.4
Simplified60.4%
Taylor expanded in b around 0
/-lowering-/.f64N/A
*-lowering-*.f6425.3
Simplified25.3%
Final simplification25.3%
(FPCore (x y z t a b) :precision binary64 (/ x y))
double code(double x, double y, double z, double t, double a, double b) {
return x / y;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
code = x / y
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return x / y;
}
def code(x, y, z, t, a, b): return x / y
function code(x, y, z, t, a, b) return Float64(x / y) end
function tmp = code(x, y, z, t, a, b) tmp = x / y; end
code[x_, y_, z_, t_, a_, b_] := N[(x / y), $MachinePrecision]
\begin{array}{l}
\\
\frac{x}{y}
\end{array}
Initial program 99.2%
Taylor expanded in t around inf
*-commutativeN/A
*-lowering-*.f64N/A
rem-exp-logN/A
log-lowering-log.f64N/A
rem-exp-log74.0
Simplified74.0%
Taylor expanded in b around 0
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
pow-lowering-pow.f6447.5
Simplified47.5%
Taylor expanded in t around 0
/-lowering-/.f6414.3
Simplified14.3%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (pow a (- t 1.0)))
(t_2 (/ (* x (/ t_1 y)) (- (+ b 1.0) (* y (log z))))))
(if (< t -0.8845848504127471)
t_2
(if (< t 852031.2288374073)
(/ (* (/ x y) t_1) (exp (- b (* (log z) y))))
t_2))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = pow(a, (t - 1.0));
double t_2 = (x * (t_1 / y)) / ((b + 1.0) - (y * log(z)));
double tmp;
if (t < -0.8845848504127471) {
tmp = t_2;
} else if (t < 852031.2288374073) {
tmp = ((x / y) * t_1) / exp((b - (log(z) * y)));
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(x, y, z, t, a, b)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = a ** (t - 1.0d0)
t_2 = (x * (t_1 / y)) / ((b + 1.0d0) - (y * log(z)))
if (t < (-0.8845848504127471d0)) then
tmp = t_2
else if (t < 852031.2288374073d0) then
tmp = ((x / y) * t_1) / exp((b - (log(z) * y)))
else
tmp = t_2
end if
code = tmp
end function
public static double code(double x, double y, double z, double t, double a, double b) {
double t_1 = Math.pow(a, (t - 1.0));
double t_2 = (x * (t_1 / y)) / ((b + 1.0) - (y * Math.log(z)));
double tmp;
if (t < -0.8845848504127471) {
tmp = t_2;
} else if (t < 852031.2288374073) {
tmp = ((x / y) * t_1) / Math.exp((b - (Math.log(z) * y)));
} else {
tmp = t_2;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = math.pow(a, (t - 1.0)) t_2 = (x * (t_1 / y)) / ((b + 1.0) - (y * math.log(z))) tmp = 0 if t < -0.8845848504127471: tmp = t_2 elif t < 852031.2288374073: tmp = ((x / y) * t_1) / math.exp((b - (math.log(z) * y))) else: tmp = t_2 return tmp
function code(x, y, z, t, a, b) t_1 = a ^ Float64(t - 1.0) t_2 = Float64(Float64(x * Float64(t_1 / y)) / Float64(Float64(b + 1.0) - Float64(y * log(z)))) tmp = 0.0 if (t < -0.8845848504127471) tmp = t_2; elseif (t < 852031.2288374073) tmp = Float64(Float64(Float64(x / y) * t_1) / exp(Float64(b - Float64(log(z) * y)))); else tmp = t_2; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = a ^ (t - 1.0); t_2 = (x * (t_1 / y)) / ((b + 1.0) - (y * log(z))); tmp = 0.0; if (t < -0.8845848504127471) tmp = t_2; elseif (t < 852031.2288374073) tmp = ((x / y) * t_1) / exp((b - (log(z) * y))); else tmp = t_2; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[Power[a, N[(t - 1.0), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * N[(t$95$1 / y), $MachinePrecision]), $MachinePrecision] / N[(N[(b + 1.0), $MachinePrecision] - N[(y * N[Log[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[Less[t, -0.8845848504127471], t$95$2, If[Less[t, 852031.2288374073], N[(N[(N[(x / y), $MachinePrecision] * t$95$1), $MachinePrecision] / N[Exp[N[(b - N[(N[Log[z], $MachinePrecision] * y), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], t$95$2]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := {a}^{\left(t - 1\right)}\\
t_2 := \frac{x \cdot \frac{t\_1}{y}}{\left(b + 1\right) - y \cdot \log z}\\
\mathbf{if}\;t < -0.8845848504127471:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t < 852031.2288374073:\\
\;\;\;\;\frac{\frac{x}{y} \cdot t\_1}{e^{b - \log z \cdot y}}\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
herbie shell --seed 2024204
(FPCore (x y z t a b)
:name "Numeric.SpecFunctions:incompleteBetaWorker from math-functions-0.1.5.2, A"
:precision binary64
:alt
(! :herbie-platform default (if (< t -8845848504127471/10000000000000000) (/ (* x (/ (pow a (- t 1)) y)) (- (+ b 1) (* y (log z)))) (if (< t 8520312288374073/10000000000) (/ (* (/ x y) (pow a (- t 1))) (exp (- b (* (log z) y)))) (/ (* x (/ (pow a (- t 1)) y)) (- (+ b 1) (* y (log z)))))))
(/ (* x (exp (- (+ (* y (log z)) (* (- t 1.0) (log a))) b))) y))