
(FPCore (x y z t a b) :precision binary64 (* x (exp (+ (* y (- (log z) t)) (* a (- (log (- 1.0 z)) b))))))
double code(double x, double y, double z, double t, double a, double b) {
return x * exp(((y * (log(z) - t)) + (a * (log((1.0 - z)) - b))));
}
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)) + (a * (log((1.0d0 - z)) - b))))
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)) + (a * (Math.log((1.0 - z)) - b))));
}
def code(x, y, z, t, a, b): return x * math.exp(((y * (math.log(z) - t)) + (a * (math.log((1.0 - z)) - b))))
function code(x, y, z, t, a, b) return Float64(x * exp(Float64(Float64(y * Float64(log(z) - t)) + Float64(a * Float64(log(Float64(1.0 - z)) - b))))) end
function tmp = code(x, y, z, t, a, b) tmp = x * exp(((y * (log(z) - t)) + (a * (log((1.0 - z)) - b)))); end
code[x_, y_, z_, t_, a_, b_] := N[(x * N[Exp[N[(N[(y * N[(N[Log[z], $MachinePrecision] - t), $MachinePrecision]), $MachinePrecision] + N[(a * N[(N[Log[N[(1.0 - z), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot e^{y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 19 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t a b) :precision binary64 (* x (exp (+ (* y (- (log z) t)) (* a (- (log (- 1.0 z)) b))))))
double code(double x, double y, double z, double t, double a, double b) {
return x * exp(((y * (log(z) - t)) + (a * (log((1.0 - z)) - b))));
}
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)) + (a * (log((1.0d0 - z)) - b))))
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)) + (a * (Math.log((1.0 - z)) - b))));
}
def code(x, y, z, t, a, b): return x * math.exp(((y * (math.log(z) - t)) + (a * (math.log((1.0 - z)) - b))))
function code(x, y, z, t, a, b) return Float64(x * exp(Float64(Float64(y * Float64(log(z) - t)) + Float64(a * Float64(log(Float64(1.0 - z)) - b))))) end
function tmp = code(x, y, z, t, a, b) tmp = x * exp(((y * (log(z) - t)) + (a * (log((1.0 - z)) - b)))); end
code[x_, y_, z_, t_, a_, b_] := N[(x * N[Exp[N[(N[(y * N[(N[Log[z], $MachinePrecision] - t), $MachinePrecision]), $MachinePrecision] + N[(a * N[(N[Log[N[(1.0 - z), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot e^{y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)}
\end{array}
(FPCore (x y z t a b) :precision binary64 (* x (exp (+ (* y (- (log z) t)) (* a (- (log (- 1.0 z)) b))))))
double code(double x, double y, double z, double t, double a, double b) {
return x * exp(((y * (log(z) - t)) + (a * (log((1.0 - z)) - b))));
}
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)) + (a * (log((1.0d0 - z)) - b))))
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)) + (a * (Math.log((1.0 - z)) - b))));
}
def code(x, y, z, t, a, b): return x * math.exp(((y * (math.log(z) - t)) + (a * (math.log((1.0 - z)) - b))))
function code(x, y, z, t, a, b) return Float64(x * exp(Float64(Float64(y * Float64(log(z) - t)) + Float64(a * Float64(log(Float64(1.0 - z)) - b))))) end
function tmp = code(x, y, z, t, a, b) tmp = x * exp(((y * (log(z) - t)) + (a * (log((1.0 - z)) - b)))); end
code[x_, y_, z_, t_, a_, b_] := N[(x * N[Exp[N[(N[(y * N[(N[Log[z], $MachinePrecision] - t), $MachinePrecision]), $MachinePrecision] + N[(a * N[(N[Log[N[(1.0 - z), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot e^{y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)}
\end{array}
Initial program 95.8%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ (* y (- (log z) t)) (* a (- (log (- 1.0 z)) b)))))
(if (<= t_1 -5e+269)
(* t (/ x t))
(if (<= t_1 -5e+211)
(* (* x (* y y)) (* t (* t 0.5)))
(if (<= t_1 -5e+135)
(* (* 0.5 (* a a)) (* x (* b b)))
(if (<= t_1 -4000000000.0)
(* x (* (* y (* y y)) (* -0.16666666666666666 (* t (* t t)))))
(if (<= t_1 4e-10)
(* x (fma b (fma 0.5 (* b (* a a)) (- a)) 1.0))
(*
t
(* t (fma x (* (* y y) 0.5) (/ (fma x (- y) (/ x t)) t)))))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (y * (log(z) - t)) + (a * (log((1.0 - z)) - b));
double tmp;
if (t_1 <= -5e+269) {
tmp = t * (x / t);
} else if (t_1 <= -5e+211) {
tmp = (x * (y * y)) * (t * (t * 0.5));
} else if (t_1 <= -5e+135) {
tmp = (0.5 * (a * a)) * (x * (b * b));
} else if (t_1 <= -4000000000.0) {
tmp = x * ((y * (y * y)) * (-0.16666666666666666 * (t * (t * t))));
} else if (t_1 <= 4e-10) {
tmp = x * fma(b, fma(0.5, (b * (a * a)), -a), 1.0);
} else {
tmp = t * (t * fma(x, ((y * y) * 0.5), (fma(x, -y, (x / t)) / t)));
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(Float64(y * Float64(log(z) - t)) + Float64(a * Float64(log(Float64(1.0 - z)) - b))) tmp = 0.0 if (t_1 <= -5e+269) tmp = Float64(t * Float64(x / t)); elseif (t_1 <= -5e+211) tmp = Float64(Float64(x * Float64(y * y)) * Float64(t * Float64(t * 0.5))); elseif (t_1 <= -5e+135) tmp = Float64(Float64(0.5 * Float64(a * a)) * Float64(x * Float64(b * b))); elseif (t_1 <= -4000000000.0) tmp = Float64(x * Float64(Float64(y * Float64(y * y)) * Float64(-0.16666666666666666 * Float64(t * Float64(t * t))))); elseif (t_1 <= 4e-10) tmp = Float64(x * fma(b, fma(0.5, Float64(b * Float64(a * a)), Float64(-a)), 1.0)); else tmp = Float64(t * Float64(t * fma(x, Float64(Float64(y * y) * 0.5), Float64(fma(x, Float64(-y), Float64(x / t)) / t)))); end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(y * N[(N[Log[z], $MachinePrecision] - t), $MachinePrecision]), $MachinePrecision] + N[(a * N[(N[Log[N[(1.0 - z), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -5e+269], N[(t * N[(x / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, -5e+211], N[(N[(x * N[(y * y), $MachinePrecision]), $MachinePrecision] * N[(t * N[(t * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, -5e+135], N[(N[(0.5 * N[(a * a), $MachinePrecision]), $MachinePrecision] * N[(x * N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, -4000000000.0], N[(x * N[(N[(y * N[(y * y), $MachinePrecision]), $MachinePrecision] * N[(-0.16666666666666666 * N[(t * N[(t * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 4e-10], N[(x * N[(b * N[(0.5 * N[(b * N[(a * a), $MachinePrecision]), $MachinePrecision] + (-a)), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(t * N[(t * N[(x * N[(N[(y * y), $MachinePrecision] * 0.5), $MachinePrecision] + N[(N[(x * (-y) + N[(x / t), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)\\
\mathbf{if}\;t\_1 \leq -5 \cdot 10^{+269}:\\
\;\;\;\;t \cdot \frac{x}{t}\\
\mathbf{elif}\;t\_1 \leq -5 \cdot 10^{+211}:\\
\;\;\;\;\left(x \cdot \left(y \cdot y\right)\right) \cdot \left(t \cdot \left(t \cdot 0.5\right)\right)\\
\mathbf{elif}\;t\_1 \leq -5 \cdot 10^{+135}:\\
\;\;\;\;\left(0.5 \cdot \left(a \cdot a\right)\right) \cdot \left(x \cdot \left(b \cdot b\right)\right)\\
\mathbf{elif}\;t\_1 \leq -4000000000:\\
\;\;\;\;x \cdot \left(\left(y \cdot \left(y \cdot y\right)\right) \cdot \left(-0.16666666666666666 \cdot \left(t \cdot \left(t \cdot t\right)\right)\right)\right)\\
\mathbf{elif}\;t\_1 \leq 4 \cdot 10^{-10}:\\
\;\;\;\;x \cdot \mathsf{fma}\left(b, \mathsf{fma}\left(0.5, b \cdot \left(a \cdot a\right), -a\right), 1\right)\\
\mathbf{else}:\\
\;\;\;\;t \cdot \left(t \cdot \mathsf{fma}\left(x, \left(y \cdot y\right) \cdot 0.5, \frac{\mathsf{fma}\left(x, -y, \frac{x}{t}\right)}{t}\right)\right)\\
\end{array}
\end{array}
if (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < -5.0000000000000002e269Initial program 100.0%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6465.7
Simplified65.7%
Taylor expanded in y around 0
+-commutativeN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f642.8
Simplified2.8%
Taylor expanded in t around inf
lower-*.f64N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
lower-/.f64N/A
lower-*.f6411.6
Simplified11.6%
Taylor expanded in t around 0
lower-/.f6437.8
Simplified37.8%
if -5.0000000000000002e269 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < -4.9999999999999995e211Initial program 100.0%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6428.5
Simplified28.5%
Taylor expanded in t around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f642.6
Simplified2.6%
Taylor expanded in t around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6437.7
Simplified37.7%
if -4.9999999999999995e211 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < -5.00000000000000029e135Initial program 100.0%
Taylor expanded in b around inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6429.7
Simplified29.7%
Taylor expanded in a around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f642.8
Simplified2.8%
Taylor expanded in a around inf
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f6446.3
Simplified46.3%
if -5.00000000000000029e135 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < -4e9Initial program 100.0%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6425.3
Simplified25.3%
Taylor expanded in t around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
cube-multN/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f643.1
Simplified3.1%
Taylor expanded in t around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
cube-multN/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower-*.f64N/A
cube-multN/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6459.6
Simplified59.6%
if -4e9 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < 4.00000000000000015e-10Initial program 87.2%
Taylor expanded in b around inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6484.9
Simplified84.9%
Taylor expanded in b around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6490.4
Simplified90.4%
if 4.00000000000000015e-10 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) Initial program 96.0%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6459.4
Simplified59.4%
Taylor expanded in t around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6463.4
Simplified63.4%
Taylor expanded in t around -inf
unpow2N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
associate-*l*N/A
lower-fma.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
associate-*r/N/A
Simplified74.3%
Final simplification65.2%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* y (* y y)))
(t_2 (+ (* y (- (log z) t)) (* a (- (log (- 1.0 z)) b)))))
(if (<= t_2 -5e+269)
(* t (/ x t))
(if (<= t_2 -5e+211)
(* (* x (* y y)) (* t (* t 0.5)))
(if (<= t_2 -5e+135)
(* (* 0.5 (* a a)) (* x (* b b)))
(if (<= t_2 -4000000000.0)
(* x (* t_1 (* -0.16666666666666666 (* t (* t t)))))
(if (<= t_2 4e+203)
(*
x
(fma
t
(fma t (* t_1 (fma -0.16666666666666666 t (/ 0.5 y))) (- y))
1.0))
(fma t (* t (* x (* (* y y) 0.5))) x))))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = y * (y * y);
double t_2 = (y * (log(z) - t)) + (a * (log((1.0 - z)) - b));
double tmp;
if (t_2 <= -5e+269) {
tmp = t * (x / t);
} else if (t_2 <= -5e+211) {
tmp = (x * (y * y)) * (t * (t * 0.5));
} else if (t_2 <= -5e+135) {
tmp = (0.5 * (a * a)) * (x * (b * b));
} else if (t_2 <= -4000000000.0) {
tmp = x * (t_1 * (-0.16666666666666666 * (t * (t * t))));
} else if (t_2 <= 4e+203) {
tmp = x * fma(t, fma(t, (t_1 * fma(-0.16666666666666666, t, (0.5 / y))), -y), 1.0);
} else {
tmp = fma(t, (t * (x * ((y * y) * 0.5))), x);
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(y * Float64(y * y)) t_2 = Float64(Float64(y * Float64(log(z) - t)) + Float64(a * Float64(log(Float64(1.0 - z)) - b))) tmp = 0.0 if (t_2 <= -5e+269) tmp = Float64(t * Float64(x / t)); elseif (t_2 <= -5e+211) tmp = Float64(Float64(x * Float64(y * y)) * Float64(t * Float64(t * 0.5))); elseif (t_2 <= -5e+135) tmp = Float64(Float64(0.5 * Float64(a * a)) * Float64(x * Float64(b * b))); elseif (t_2 <= -4000000000.0) tmp = Float64(x * Float64(t_1 * Float64(-0.16666666666666666 * Float64(t * Float64(t * t))))); elseif (t_2 <= 4e+203) tmp = Float64(x * fma(t, fma(t, Float64(t_1 * fma(-0.16666666666666666, t, Float64(0.5 / y))), Float64(-y)), 1.0)); else tmp = fma(t, Float64(t * Float64(x * Float64(Float64(y * y) * 0.5))), x); end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(y * N[(y * y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(y * N[(N[Log[z], $MachinePrecision] - t), $MachinePrecision]), $MachinePrecision] + N[(a * N[(N[Log[N[(1.0 - z), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, -5e+269], N[(t * N[(x / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, -5e+211], N[(N[(x * N[(y * y), $MachinePrecision]), $MachinePrecision] * N[(t * N[(t * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, -5e+135], N[(N[(0.5 * N[(a * a), $MachinePrecision]), $MachinePrecision] * N[(x * N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, -4000000000.0], N[(x * N[(t$95$1 * N[(-0.16666666666666666 * N[(t * N[(t * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 4e+203], N[(x * N[(t * N[(t * N[(t$95$1 * N[(-0.16666666666666666 * t + N[(0.5 / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + (-y)), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], N[(t * N[(t * N[(x * N[(N[(y * y), $MachinePrecision] * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(y \cdot y\right)\\
t_2 := y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)\\
\mathbf{if}\;t\_2 \leq -5 \cdot 10^{+269}:\\
\;\;\;\;t \cdot \frac{x}{t}\\
\mathbf{elif}\;t\_2 \leq -5 \cdot 10^{+211}:\\
\;\;\;\;\left(x \cdot \left(y \cdot y\right)\right) \cdot \left(t \cdot \left(t \cdot 0.5\right)\right)\\
\mathbf{elif}\;t\_2 \leq -5 \cdot 10^{+135}:\\
\;\;\;\;\left(0.5 \cdot \left(a \cdot a\right)\right) \cdot \left(x \cdot \left(b \cdot b\right)\right)\\
\mathbf{elif}\;t\_2 \leq -4000000000:\\
\;\;\;\;x \cdot \left(t\_1 \cdot \left(-0.16666666666666666 \cdot \left(t \cdot \left(t \cdot t\right)\right)\right)\right)\\
\mathbf{elif}\;t\_2 \leq 4 \cdot 10^{+203}:\\
\;\;\;\;x \cdot \mathsf{fma}\left(t, \mathsf{fma}\left(t, t\_1 \cdot \mathsf{fma}\left(-0.16666666666666666, t, \frac{0.5}{y}\right), -y\right), 1\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(t, t \cdot \left(x \cdot \left(\left(y \cdot y\right) \cdot 0.5\right)\right), x\right)\\
\end{array}
\end{array}
if (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < -5.0000000000000002e269Initial program 100.0%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6465.7
Simplified65.7%
Taylor expanded in y around 0
+-commutativeN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f642.8
Simplified2.8%
Taylor expanded in t around inf
lower-*.f64N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
lower-/.f64N/A
lower-*.f6411.6
Simplified11.6%
Taylor expanded in t around 0
lower-/.f6437.8
Simplified37.8%
if -5.0000000000000002e269 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < -4.9999999999999995e211Initial program 100.0%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6428.5
Simplified28.5%
Taylor expanded in t around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f642.6
Simplified2.6%
Taylor expanded in t around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6437.7
Simplified37.7%
if -4.9999999999999995e211 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < -5.00000000000000029e135Initial program 100.0%
Taylor expanded in b around inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6429.7
Simplified29.7%
Taylor expanded in a around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f642.8
Simplified2.8%
Taylor expanded in a around inf
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f6446.3
Simplified46.3%
if -5.00000000000000029e135 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < -4e9Initial program 100.0%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6425.3
Simplified25.3%
Taylor expanded in t around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
cube-multN/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f643.1
Simplified3.1%
Taylor expanded in t around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
cube-multN/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower-*.f64N/A
cube-multN/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6459.6
Simplified59.6%
if -4e9 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < 4e203Initial program 89.6%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6472.2
Simplified72.2%
Taylor expanded in t around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
cube-multN/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6471.4
Simplified71.4%
Taylor expanded in y around inf
lower-*.f64N/A
cube-multN/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower-fma.f64N/A
associate-*r/N/A
metadata-evalN/A
lower-/.f6473.8
Simplified73.8%
if 4e203 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) Initial program 97.0%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6463.7
Simplified63.7%
Taylor expanded in t around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6472.4
Simplified72.4%
Taylor expanded in t around inf
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6481.4
Simplified81.4%
Final simplification63.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ (* y (- (log z) t)) (* a (- (log (- 1.0 z)) b)))))
(if (<= t_1 -5e+269)
(* t (/ x t))
(if (<= t_1 -5e+211)
(* (* x (* y y)) (* t (* t 0.5)))
(if (<= t_1 -5e+135)
(* (* 0.5 (* a a)) (* x (* b b)))
(if (<= t_1 -4000000000.0)
(* x (* (* y (* y y)) (* -0.16666666666666666 (* t (* t t)))))
(fma t (* t (* x (* (* y y) 0.5))) x)))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (y * (log(z) - t)) + (a * (log((1.0 - z)) - b));
double tmp;
if (t_1 <= -5e+269) {
tmp = t * (x / t);
} else if (t_1 <= -5e+211) {
tmp = (x * (y * y)) * (t * (t * 0.5));
} else if (t_1 <= -5e+135) {
tmp = (0.5 * (a * a)) * (x * (b * b));
} else if (t_1 <= -4000000000.0) {
tmp = x * ((y * (y * y)) * (-0.16666666666666666 * (t * (t * t))));
} else {
tmp = fma(t, (t * (x * ((y * y) * 0.5))), x);
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(Float64(y * Float64(log(z) - t)) + Float64(a * Float64(log(Float64(1.0 - z)) - b))) tmp = 0.0 if (t_1 <= -5e+269) tmp = Float64(t * Float64(x / t)); elseif (t_1 <= -5e+211) tmp = Float64(Float64(x * Float64(y * y)) * Float64(t * Float64(t * 0.5))); elseif (t_1 <= -5e+135) tmp = Float64(Float64(0.5 * Float64(a * a)) * Float64(x * Float64(b * b))); elseif (t_1 <= -4000000000.0) tmp = Float64(x * Float64(Float64(y * Float64(y * y)) * Float64(-0.16666666666666666 * Float64(t * Float64(t * t))))); else tmp = fma(t, Float64(t * Float64(x * Float64(Float64(y * y) * 0.5))), x); end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(y * N[(N[Log[z], $MachinePrecision] - t), $MachinePrecision]), $MachinePrecision] + N[(a * N[(N[Log[N[(1.0 - z), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -5e+269], N[(t * N[(x / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, -5e+211], N[(N[(x * N[(y * y), $MachinePrecision]), $MachinePrecision] * N[(t * N[(t * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, -5e+135], N[(N[(0.5 * N[(a * a), $MachinePrecision]), $MachinePrecision] * N[(x * N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, -4000000000.0], N[(x * N[(N[(y * N[(y * y), $MachinePrecision]), $MachinePrecision] * N[(-0.16666666666666666 * N[(t * N[(t * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t * N[(t * N[(x * N[(N[(y * y), $MachinePrecision] * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)\\
\mathbf{if}\;t\_1 \leq -5 \cdot 10^{+269}:\\
\;\;\;\;t \cdot \frac{x}{t}\\
\mathbf{elif}\;t\_1 \leq -5 \cdot 10^{+211}:\\
\;\;\;\;\left(x \cdot \left(y \cdot y\right)\right) \cdot \left(t \cdot \left(t \cdot 0.5\right)\right)\\
\mathbf{elif}\;t\_1 \leq -5 \cdot 10^{+135}:\\
\;\;\;\;\left(0.5 \cdot \left(a \cdot a\right)\right) \cdot \left(x \cdot \left(b \cdot b\right)\right)\\
\mathbf{elif}\;t\_1 \leq -4000000000:\\
\;\;\;\;x \cdot \left(\left(y \cdot \left(y \cdot y\right)\right) \cdot \left(-0.16666666666666666 \cdot \left(t \cdot \left(t \cdot t\right)\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(t, t \cdot \left(x \cdot \left(\left(y \cdot y\right) \cdot 0.5\right)\right), x\right)\\
\end{array}
\end{array}
if (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < -5.0000000000000002e269Initial program 100.0%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6465.7
Simplified65.7%
Taylor expanded in y around 0
+-commutativeN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f642.8
Simplified2.8%
Taylor expanded in t around inf
lower-*.f64N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
lower-/.f64N/A
lower-*.f6411.6
Simplified11.6%
Taylor expanded in t around 0
lower-/.f6437.8
Simplified37.8%
if -5.0000000000000002e269 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < -4.9999999999999995e211Initial program 100.0%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6428.5
Simplified28.5%
Taylor expanded in t around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f642.6
Simplified2.6%
Taylor expanded in t around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6437.7
Simplified37.7%
if -4.9999999999999995e211 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < -5.00000000000000029e135Initial program 100.0%
Taylor expanded in b around inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6429.7
Simplified29.7%
Taylor expanded in a around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f642.8
Simplified2.8%
Taylor expanded in a around inf
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f6446.3
Simplified46.3%
if -5.00000000000000029e135 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < -4e9Initial program 100.0%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6425.3
Simplified25.3%
Taylor expanded in t around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
cube-multN/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f643.1
Simplified3.1%
Taylor expanded in t around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
cube-multN/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower-*.f64N/A
cube-multN/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6459.6
Simplified59.6%
if -4e9 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) Initial program 92.9%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6468.5
Simplified68.5%
Taylor expanded in t around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6470.4
Simplified70.4%
Taylor expanded in t around inf
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6474.4
Simplified74.4%
Final simplification62.0%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ (* y (- (log z) t)) (* a (- (log (- 1.0 z)) b))))
(t_2 (* (* x (* y y)) (* t (* t 0.5)))))
(if (<= t_1 -5e+269)
(* t (/ x t))
(if (<= t_1 -5e+211)
t_2
(if (<= t_1 -4e+16)
(* (* 0.5 (* a a)) (* x (* b b)))
(if (<= t_1 5000000000.0) (* x (fma a (- (- z) b) 1.0)) t_2))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (y * (log(z) - t)) + (a * (log((1.0 - z)) - b));
double t_2 = (x * (y * y)) * (t * (t * 0.5));
double tmp;
if (t_1 <= -5e+269) {
tmp = t * (x / t);
} else if (t_1 <= -5e+211) {
tmp = t_2;
} else if (t_1 <= -4e+16) {
tmp = (0.5 * (a * a)) * (x * (b * b));
} else if (t_1 <= 5000000000.0) {
tmp = x * fma(a, (-z - b), 1.0);
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(Float64(y * Float64(log(z) - t)) + Float64(a * Float64(log(Float64(1.0 - z)) - b))) t_2 = Float64(Float64(x * Float64(y * y)) * Float64(t * Float64(t * 0.5))) tmp = 0.0 if (t_1 <= -5e+269) tmp = Float64(t * Float64(x / t)); elseif (t_1 <= -5e+211) tmp = t_2; elseif (t_1 <= -4e+16) tmp = Float64(Float64(0.5 * Float64(a * a)) * Float64(x * Float64(b * b))); elseif (t_1 <= 5000000000.0) tmp = Float64(x * fma(a, Float64(Float64(-z) - b), 1.0)); else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(y * N[(N[Log[z], $MachinePrecision] - t), $MachinePrecision]), $MachinePrecision] + N[(a * N[(N[Log[N[(1.0 - z), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * N[(y * y), $MachinePrecision]), $MachinePrecision] * N[(t * N[(t * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -5e+269], N[(t * N[(x / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, -5e+211], t$95$2, If[LessEqual[t$95$1, -4e+16], N[(N[(0.5 * N[(a * a), $MachinePrecision]), $MachinePrecision] * N[(x * N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 5000000000.0], N[(x * N[(a * N[((-z) - b), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)\\
t_2 := \left(x \cdot \left(y \cdot y\right)\right) \cdot \left(t \cdot \left(t \cdot 0.5\right)\right)\\
\mathbf{if}\;t\_1 \leq -5 \cdot 10^{+269}:\\
\;\;\;\;t \cdot \frac{x}{t}\\
\mathbf{elif}\;t\_1 \leq -5 \cdot 10^{+211}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_1 \leq -4 \cdot 10^{+16}:\\
\;\;\;\;\left(0.5 \cdot \left(a \cdot a\right)\right) \cdot \left(x \cdot \left(b \cdot b\right)\right)\\
\mathbf{elif}\;t\_1 \leq 5000000000:\\
\;\;\;\;x \cdot \mathsf{fma}\left(a, \left(-z\right) - b, 1\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < -5.0000000000000002e269Initial program 100.0%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6465.7
Simplified65.7%
Taylor expanded in y around 0
+-commutativeN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f642.8
Simplified2.8%
Taylor expanded in t around inf
lower-*.f64N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
lower-/.f64N/A
lower-*.f6411.6
Simplified11.6%
Taylor expanded in t around 0
lower-/.f6437.8
Simplified37.8%
if -5.0000000000000002e269 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < -4.9999999999999995e211 or 5e9 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) Initial program 96.6%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6454.8
Simplified54.8%
Taylor expanded in t around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6454.0
Simplified54.0%
Taylor expanded in t around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6457.4
Simplified57.4%
if -4.9999999999999995e211 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < -4e16Initial program 100.0%
Taylor expanded in b around inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6435.5
Simplified35.5%
Taylor expanded in a around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f642.7
Simplified2.7%
Taylor expanded in a around inf
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f6443.8
Simplified43.8%
if -4e16 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < 5e9Initial program 87.9%
Taylor expanded in y around 0
lower-*.f64N/A
lower--.f64N/A
sub-negN/A
lower-log1p.f64N/A
lower-neg.f6494.1
Simplified94.1%
Taylor expanded in z around 0
+-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-lft-outN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-+.f6494.1
Simplified94.1%
Taylor expanded in a around 0
+-commutativeN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
distribute-lft-inN/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
mul-1-negN/A
lower-neg.f6481.2
Simplified81.2%
Final simplification57.2%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ (* y (- (log z) t)) (* a (- (log (- 1.0 z)) b))))
(t_2 (* (* 0.5 (* a a)) (* x (* b b)))))
(if (<= t_1 -4e+215)
(* t (/ x t))
(if (<= t_1 -4e+16)
t_2
(if (<= t_1 4e-10)
(* x (fma a (- (- z) b) 1.0))
(if (<= t_1 5e+242) (* y (fma x (- t) (/ x y))) t_2))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (y * (log(z) - t)) + (a * (log((1.0 - z)) - b));
double t_2 = (0.5 * (a * a)) * (x * (b * b));
double tmp;
if (t_1 <= -4e+215) {
tmp = t * (x / t);
} else if (t_1 <= -4e+16) {
tmp = t_2;
} else if (t_1 <= 4e-10) {
tmp = x * fma(a, (-z - b), 1.0);
} else if (t_1 <= 5e+242) {
tmp = y * fma(x, -t, (x / y));
} else {
tmp = t_2;
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(Float64(y * Float64(log(z) - t)) + Float64(a * Float64(log(Float64(1.0 - z)) - b))) t_2 = Float64(Float64(0.5 * Float64(a * a)) * Float64(x * Float64(b * b))) tmp = 0.0 if (t_1 <= -4e+215) tmp = Float64(t * Float64(x / t)); elseif (t_1 <= -4e+16) tmp = t_2; elseif (t_1 <= 4e-10) tmp = Float64(x * fma(a, Float64(Float64(-z) - b), 1.0)); elseif (t_1 <= 5e+242) tmp = Float64(y * fma(x, Float64(-t), Float64(x / y))); else tmp = t_2; end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(y * N[(N[Log[z], $MachinePrecision] - t), $MachinePrecision]), $MachinePrecision] + N[(a * N[(N[Log[N[(1.0 - z), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(0.5 * N[(a * a), $MachinePrecision]), $MachinePrecision] * N[(x * N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -4e+215], N[(t * N[(x / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, -4e+16], t$95$2, If[LessEqual[t$95$1, 4e-10], N[(x * N[(a * N[((-z) - b), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 5e+242], N[(y * N[(x * (-t) + N[(x / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)\\
t_2 := \left(0.5 \cdot \left(a \cdot a\right)\right) \cdot \left(x \cdot \left(b \cdot b\right)\right)\\
\mathbf{if}\;t\_1 \leq -4 \cdot 10^{+215}:\\
\;\;\;\;t \cdot \frac{x}{t}\\
\mathbf{elif}\;t\_1 \leq -4 \cdot 10^{+16}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_1 \leq 4 \cdot 10^{-10}:\\
\;\;\;\;x \cdot \mathsf{fma}\left(a, \left(-z\right) - b, 1\right)\\
\mathbf{elif}\;t\_1 \leq 5 \cdot 10^{+242}:\\
\;\;\;\;y \cdot \mathsf{fma}\left(x, -t, \frac{x}{y}\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < -3.99999999999999963e215Initial program 100.0%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6455.1
Simplified55.1%
Taylor expanded in y around 0
+-commutativeN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f643.0
Simplified3.0%
Taylor expanded in t around inf
lower-*.f64N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
lower-/.f64N/A
lower-*.f6412.5
Simplified12.5%
Taylor expanded in t around 0
lower-/.f6431.6
Simplified31.6%
if -3.99999999999999963e215 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < -4e16 or 5.0000000000000004e242 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) Initial program 98.0%
Taylor expanded in b around inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6448.1
Simplified48.1%
Taylor expanded in a around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6438.2
Simplified38.2%
Taylor expanded in a around inf
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f6453.4
Simplified53.4%
if -4e16 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < 4.00000000000000015e-10Initial program 87.7%
Taylor expanded in y around 0
lower-*.f64N/A
lower--.f64N/A
sub-negN/A
lower-log1p.f64N/A
lower-neg.f6493.9
Simplified93.9%
Taylor expanded in z around 0
+-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-lft-outN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-+.f6493.9
Simplified93.9%
Taylor expanded in a around 0
+-commutativeN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
distribute-lft-inN/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
mul-1-negN/A
lower-neg.f6482.6
Simplified82.6%
if 4.00000000000000015e-10 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < 5.0000000000000004e242Initial program 95.5%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6453.9
Simplified53.9%
Taylor expanded in y around 0
+-commutativeN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6425.8
Simplified25.8%
Taylor expanded in y around inf
lower-*.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-/.f6434.6
Simplified34.6%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ (* y (- (log z) t)) (* a (- (log (- 1.0 z)) b)))))
(if (<= t_1 -5e+269)
(* t (/ x t))
(if (<= t_1 -5e+211)
(* (* x (* y y)) (* t (* t 0.5)))
(if (<= t_1 -4e+16)
(* (* 0.5 (* a a)) (* x (* b b)))
(fma t (* t (* x (* (* y y) 0.5))) x))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (y * (log(z) - t)) + (a * (log((1.0 - z)) - b));
double tmp;
if (t_1 <= -5e+269) {
tmp = t * (x / t);
} else if (t_1 <= -5e+211) {
tmp = (x * (y * y)) * (t * (t * 0.5));
} else if (t_1 <= -4e+16) {
tmp = (0.5 * (a * a)) * (x * (b * b));
} else {
tmp = fma(t, (t * (x * ((y * y) * 0.5))), x);
}
return tmp;
}
function code(x, y, z, t, a, b) t_1 = Float64(Float64(y * Float64(log(z) - t)) + Float64(a * Float64(log(Float64(1.0 - z)) - b))) tmp = 0.0 if (t_1 <= -5e+269) tmp = Float64(t * Float64(x / t)); elseif (t_1 <= -5e+211) tmp = Float64(Float64(x * Float64(y * y)) * Float64(t * Float64(t * 0.5))); elseif (t_1 <= -4e+16) tmp = Float64(Float64(0.5 * Float64(a * a)) * Float64(x * Float64(b * b))); else tmp = fma(t, Float64(t * Float64(x * Float64(Float64(y * y) * 0.5))), x); end return tmp end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(y * N[(N[Log[z], $MachinePrecision] - t), $MachinePrecision]), $MachinePrecision] + N[(a * N[(N[Log[N[(1.0 - z), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -5e+269], N[(t * N[(x / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, -5e+211], N[(N[(x * N[(y * y), $MachinePrecision]), $MachinePrecision] * N[(t * N[(t * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, -4e+16], N[(N[(0.5 * N[(a * a), $MachinePrecision]), $MachinePrecision] * N[(x * N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t * N[(t * N[(x * N[(N[(y * y), $MachinePrecision] * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + x), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)\\
\mathbf{if}\;t\_1 \leq -5 \cdot 10^{+269}:\\
\;\;\;\;t \cdot \frac{x}{t}\\
\mathbf{elif}\;t\_1 \leq -5 \cdot 10^{+211}:\\
\;\;\;\;\left(x \cdot \left(y \cdot y\right)\right) \cdot \left(t \cdot \left(t \cdot 0.5\right)\right)\\
\mathbf{elif}\;t\_1 \leq -4 \cdot 10^{+16}:\\
\;\;\;\;\left(0.5 \cdot \left(a \cdot a\right)\right) \cdot \left(x \cdot \left(b \cdot b\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(t, t \cdot \left(x \cdot \left(\left(y \cdot y\right) \cdot 0.5\right)\right), x\right)\\
\end{array}
\end{array}
if (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < -5.0000000000000002e269Initial program 100.0%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6465.7
Simplified65.7%
Taylor expanded in y around 0
+-commutativeN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f642.8
Simplified2.8%
Taylor expanded in t around inf
lower-*.f64N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
lower-/.f64N/A
lower-*.f6411.6
Simplified11.6%
Taylor expanded in t around 0
lower-/.f6437.8
Simplified37.8%
if -5.0000000000000002e269 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < -4.9999999999999995e211Initial program 100.0%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6428.5
Simplified28.5%
Taylor expanded in t around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f642.6
Simplified2.6%
Taylor expanded in t around inf
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6437.7
Simplified37.7%
if -4.9999999999999995e211 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < -4e16Initial program 100.0%
Taylor expanded in b around inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6435.5
Simplified35.5%
Taylor expanded in a around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f642.7
Simplified2.7%
Taylor expanded in a around inf
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
unpow2N/A
lower-*.f6443.8
Simplified43.8%
if -4e16 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) Initial program 93.0%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6467.6
Simplified67.6%
Taylor expanded in t around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6469.5
Simplified69.5%
Taylor expanded in t around inf
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6473.4
Simplified73.4%
Final simplification60.1%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (+ (* y (- (log z) t)) (* a (- (log (- 1.0 z)) b)))))
(if (<= t_1 -5e+269)
(* t (/ x t))
(if (<= t_1 -4000000000.0) (* t (* x (- y))) (* x (- 1.0 (* y t)))))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = (y * (log(z) - t)) + (a * (log((1.0 - z)) - b));
double tmp;
if (t_1 <= -5e+269) {
tmp = t * (x / t);
} else if (t_1 <= -4000000000.0) {
tmp = t * (x * -y);
} else {
tmp = x * (1.0 - (y * t));
}
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 = (y * (log(z) - t)) + (a * (log((1.0d0 - z)) - b))
if (t_1 <= (-5d+269)) then
tmp = t * (x / t)
else if (t_1 <= (-4000000000.0d0)) then
tmp = t * (x * -y)
else
tmp = x * (1.0d0 - (y * t))
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 = (y * (Math.log(z) - t)) + (a * (Math.log((1.0 - z)) - b));
double tmp;
if (t_1 <= -5e+269) {
tmp = t * (x / t);
} else if (t_1 <= -4000000000.0) {
tmp = t * (x * -y);
} else {
tmp = x * (1.0 - (y * t));
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = (y * (math.log(z) - t)) + (a * (math.log((1.0 - z)) - b)) tmp = 0 if t_1 <= -5e+269: tmp = t * (x / t) elif t_1 <= -4000000000.0: tmp = t * (x * -y) else: tmp = x * (1.0 - (y * t)) return tmp
function code(x, y, z, t, a, b) t_1 = Float64(Float64(y * Float64(log(z) - t)) + Float64(a * Float64(log(Float64(1.0 - z)) - b))) tmp = 0.0 if (t_1 <= -5e+269) tmp = Float64(t * Float64(x / t)); elseif (t_1 <= -4000000000.0) tmp = Float64(t * Float64(x * Float64(-y))); else tmp = Float64(x * Float64(1.0 - Float64(y * t))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = (y * (log(z) - t)) + (a * (log((1.0 - z)) - b)); tmp = 0.0; if (t_1 <= -5e+269) tmp = t * (x / t); elseif (t_1 <= -4000000000.0) tmp = t * (x * -y); else tmp = x * (1.0 - (y * t)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(N[(y * N[(N[Log[z], $MachinePrecision] - t), $MachinePrecision]), $MachinePrecision] + N[(a * N[(N[Log[N[(1.0 - z), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -5e+269], N[(t * N[(x / t), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, -4000000000.0], N[(t * N[(x * (-y)), $MachinePrecision]), $MachinePrecision], N[(x * N[(1.0 - N[(y * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)\\
\mathbf{if}\;t\_1 \leq -5 \cdot 10^{+269}:\\
\;\;\;\;t \cdot \frac{x}{t}\\
\mathbf{elif}\;t\_1 \leq -4000000000:\\
\;\;\;\;t \cdot \left(x \cdot \left(-y\right)\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(1 - y \cdot t\right)\\
\end{array}
\end{array}
if (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < -5.0000000000000002e269Initial program 100.0%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6465.7
Simplified65.7%
Taylor expanded in y around 0
+-commutativeN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f642.8
Simplified2.8%
Taylor expanded in t around inf
lower-*.f64N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
lower-/.f64N/A
lower-*.f6411.6
Simplified11.6%
Taylor expanded in t around 0
lower-/.f6437.8
Simplified37.8%
if -5.0000000000000002e269 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < -4e9Initial program 100.0%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6441.7
Simplified41.7%
Taylor expanded in y around 0
+-commutativeN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f643.2
Simplified3.2%
Taylor expanded in t around inf
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
lower-*.f64N/A
neg-mul-1N/A
lower-neg.f6422.4
Simplified22.4%
if -4e9 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) Initial program 92.9%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6468.5
Simplified68.5%
Taylor expanded in y around 0
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
*-commutativeN/A
lower-*.f6451.6
Simplified51.6%
Final simplification42.1%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* t (* x (- y))))
(t_2 (+ (* y (- (log z) t)) (* a (- (log (- 1.0 z)) b)))))
(if (<= t_2 -4000000000.0)
t_1
(if (<= t_2 5000000000.0) (* x (- 1.0 (* a b))) t_1))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = t * (x * -y);
double t_2 = (y * (log(z) - t)) + (a * (log((1.0 - z)) - b));
double tmp;
if (t_2 <= -4000000000.0) {
tmp = t_1;
} else if (t_2 <= 5000000000.0) {
tmp = x * (1.0 - (a * 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) :: t_2
real(8) :: tmp
t_1 = t * (x * -y)
t_2 = (y * (log(z) - t)) + (a * (log((1.0d0 - z)) - b))
if (t_2 <= (-4000000000.0d0)) then
tmp = t_1
else if (t_2 <= 5000000000.0d0) then
tmp = x * (1.0d0 - (a * 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 = t * (x * -y);
double t_2 = (y * (Math.log(z) - t)) + (a * (Math.log((1.0 - z)) - b));
double tmp;
if (t_2 <= -4000000000.0) {
tmp = t_1;
} else if (t_2 <= 5000000000.0) {
tmp = x * (1.0 - (a * b));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = t * (x * -y) t_2 = (y * (math.log(z) - t)) + (a * (math.log((1.0 - z)) - b)) tmp = 0 if t_2 <= -4000000000.0: tmp = t_1 elif t_2 <= 5000000000.0: tmp = x * (1.0 - (a * b)) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(t * Float64(x * Float64(-y))) t_2 = Float64(Float64(y * Float64(log(z) - t)) + Float64(a * Float64(log(Float64(1.0 - z)) - b))) tmp = 0.0 if (t_2 <= -4000000000.0) tmp = t_1; elseif (t_2 <= 5000000000.0) tmp = Float64(x * Float64(1.0 - Float64(a * b))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = t * (x * -y); t_2 = (y * (log(z) - t)) + (a * (log((1.0 - z)) - b)); tmp = 0.0; if (t_2 <= -4000000000.0) tmp = t_1; elseif (t_2 <= 5000000000.0) tmp = x * (1.0 - (a * b)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(t * N[(x * (-y)), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(y * N[(N[Log[z], $MachinePrecision] - t), $MachinePrecision]), $MachinePrecision] + N[(a * N[(N[Log[N[(1.0 - z), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, -4000000000.0], t$95$1, If[LessEqual[t$95$2, 5000000000.0], N[(x * N[(1.0 - N[(a * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(x \cdot \left(-y\right)\right)\\
t_2 := y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)\\
\mathbf{if}\;t\_2 \leq -4000000000:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq 5000000000:\\
\;\;\;\;x \cdot \left(1 - a \cdot b\right)\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < -4e9 or 5e9 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) Initial program 98.0%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6455.4
Simplified55.4%
Taylor expanded in y around 0
+-commutativeN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6417.6
Simplified17.6%
Taylor expanded in t around inf
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
lower-*.f64N/A
neg-mul-1N/A
lower-neg.f6426.8
Simplified26.8%
if -4e9 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < 5e9Initial program 87.5%
Taylor expanded in b around inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6485.1
Simplified85.1%
Taylor expanded in a around 0
neg-mul-1N/A
unsub-negN/A
lower--.f64N/A
lower-*.f6483.4
Simplified83.4%
Final simplification38.7%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* t (* x (- y))))
(t_2 (+ (* y (- (log z) t)) (* a (- (log (- 1.0 z)) b)))))
(if (<= t_2 -4000000000.0) t_1 (if (<= t_2 5000000000.0) x t_1))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = t * (x * -y);
double t_2 = (y * (log(z) - t)) + (a * (log((1.0 - z)) - b));
double tmp;
if (t_2 <= -4000000000.0) {
tmp = t_1;
} else if (t_2 <= 5000000000.0) {
tmp = x;
} 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) :: t_2
real(8) :: tmp
t_1 = t * (x * -y)
t_2 = (y * (log(z) - t)) + (a * (log((1.0d0 - z)) - b))
if (t_2 <= (-4000000000.0d0)) then
tmp = t_1
else if (t_2 <= 5000000000.0d0) then
tmp = x
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 = t * (x * -y);
double t_2 = (y * (Math.log(z) - t)) + (a * (Math.log((1.0 - z)) - b));
double tmp;
if (t_2 <= -4000000000.0) {
tmp = t_1;
} else if (t_2 <= 5000000000.0) {
tmp = x;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = t * (x * -y) t_2 = (y * (math.log(z) - t)) + (a * (math.log((1.0 - z)) - b)) tmp = 0 if t_2 <= -4000000000.0: tmp = t_1 elif t_2 <= 5000000000.0: tmp = x else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(t * Float64(x * Float64(-y))) t_2 = Float64(Float64(y * Float64(log(z) - t)) + Float64(a * Float64(log(Float64(1.0 - z)) - b))) tmp = 0.0 if (t_2 <= -4000000000.0) tmp = t_1; elseif (t_2 <= 5000000000.0) tmp = x; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = t * (x * -y); t_2 = (y * (log(z) - t)) + (a * (log((1.0 - z)) - b)); tmp = 0.0; if (t_2 <= -4000000000.0) tmp = t_1; elseif (t_2 <= 5000000000.0) tmp = x; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(t * N[(x * (-y)), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(y * N[(N[Log[z], $MachinePrecision] - t), $MachinePrecision]), $MachinePrecision] + N[(a * N[(N[Log[N[(1.0 - z), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, -4000000000.0], t$95$1, If[LessEqual[t$95$2, 5000000000.0], x, t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := t \cdot \left(x \cdot \left(-y\right)\right)\\
t_2 := y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)\\
\mathbf{if}\;t\_2 \leq -4000000000:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t\_2 \leq 5000000000:\\
\;\;\;\;x\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < -4e9 or 5e9 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) Initial program 98.0%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6455.4
Simplified55.4%
Taylor expanded in y around 0
+-commutativeN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6417.6
Simplified17.6%
Taylor expanded in t around inf
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
lower-*.f64N/A
neg-mul-1N/A
lower-neg.f6426.8
Simplified26.8%
if -4e9 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < 5e9Initial program 87.5%
Taylor expanded in y around inf
lower-*.f64N/A
lower--.f64N/A
lower-log.f6484.1
Simplified84.1%
Taylor expanded in y around 0
Simplified81.8%
*-rgt-identity81.8
Applied egg-rr81.8%
Final simplification38.4%
(FPCore (x y z t a b) :precision binary64 (if (<= (exp (+ (* y (- (log z) t)) (* a (- (log (- 1.0 z)) b)))) 0.0) (* t (* x (- y))) (* x (- 1.0 (* y t)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (exp(((y * (log(z) - t)) + (a * (log((1.0 - z)) - b)))) <= 0.0) {
tmp = t * (x * -y);
} else {
tmp = x * (1.0 - (y * t));
}
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 (exp(((y * (log(z) - t)) + (a * (log((1.0d0 - z)) - b)))) <= 0.0d0) then
tmp = t * (x * -y)
else
tmp = x * (1.0d0 - (y * t))
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 (Math.exp(((y * (Math.log(z) - t)) + (a * (Math.log((1.0 - z)) - b)))) <= 0.0) {
tmp = t * (x * -y);
} else {
tmp = x * (1.0 - (y * t));
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if math.exp(((y * (math.log(z) - t)) + (a * (math.log((1.0 - z)) - b)))) <= 0.0: tmp = t * (x * -y) else: tmp = x * (1.0 - (y * t)) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (exp(Float64(Float64(y * Float64(log(z) - t)) + Float64(a * Float64(log(Float64(1.0 - z)) - b)))) <= 0.0) tmp = Float64(t * Float64(x * Float64(-y))); else tmp = Float64(x * Float64(1.0 - Float64(y * t))); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (exp(((y * (log(z) - t)) + (a * (log((1.0 - z)) - b)))) <= 0.0) tmp = t * (x * -y); else tmp = x * (1.0 - (y * t)); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[N[Exp[N[(N[(y * N[(N[Log[z], $MachinePrecision] - t), $MachinePrecision]), $MachinePrecision] + N[(a * N[(N[Log[N[(1.0 - z), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], 0.0], N[(t * N[(x * (-y)), $MachinePrecision]), $MachinePrecision], N[(x * N[(1.0 - N[(y * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;e^{y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)} \leq 0:\\
\;\;\;\;t \cdot \left(x \cdot \left(-y\right)\right)\\
\mathbf{else}:\\
\;\;\;\;x \cdot \left(1 - y \cdot t\right)\\
\end{array}
\end{array}
if (exp.f64 (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b)))) < 0.0Initial program 100.0%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6451.3
Simplified51.3%
Taylor expanded in y around 0
+-commutativeN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f643.0
Simplified3.0%
Taylor expanded in t around inf
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
neg-mul-1N/A
lower-*.f64N/A
neg-mul-1N/A
lower-neg.f6420.9
Simplified20.9%
if 0.0 < (exp.f64 (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b)))) Initial program 92.9%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6468.5
Simplified68.5%
Taylor expanded in y around 0
mul-1-negN/A
unsub-negN/A
lower--.f64N/A
*-commutativeN/A
lower-*.f6451.6
Simplified51.6%
Final simplification39.0%
(FPCore (x y z t a b) :precision binary64 (if (<= (exp (+ (* y (- (log z) t)) (* a (- (log (- 1.0 z)) b)))) 0.0) (* y (* x t)) (fma (* x y) t x)))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (exp(((y * (log(z) - t)) + (a * (log((1.0 - z)) - b)))) <= 0.0) {
tmp = y * (x * t);
} else {
tmp = fma((x * y), t, x);
}
return tmp;
}
function code(x, y, z, t, a, b) tmp = 0.0 if (exp(Float64(Float64(y * Float64(log(z) - t)) + Float64(a * Float64(log(Float64(1.0 - z)) - b)))) <= 0.0) tmp = Float64(y * Float64(x * t)); else tmp = fma(Float64(x * y), t, x); end return tmp end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[N[Exp[N[(N[(y * N[(N[Log[z], $MachinePrecision] - t), $MachinePrecision]), $MachinePrecision] + N[(a * N[(N[Log[N[(1.0 - z), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], 0.0], N[(y * N[(x * t), $MachinePrecision]), $MachinePrecision], N[(N[(x * y), $MachinePrecision] * t + x), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;e^{y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)} \leq 0:\\
\;\;\;\;y \cdot \left(x \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(x \cdot y, t, x\right)\\
\end{array}
\end{array}
if (exp.f64 (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b)))) < 0.0Initial program 100.0%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6451.3
Simplified51.3%
Taylor expanded in y around 0
+-commutativeN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f643.0
Simplified3.0%
neg-sub0N/A
sub-negN/A
lift-neg.f64N/A
flip3-+N/A
lower-/.f64N/A
metadata-evalN/A
sqr-powN/A
pow-prod-downN/A
lift-neg.f64N/A
lift-neg.f64N/A
sqr-negN/A
pow-prod-downN/A
sqr-powN/A
cube-unmultN/A
lift-*.f64N/A
lift-*.f64N/A
lower-+.f64N/A
metadata-evalN/A
lower-+.f64N/A
lift-neg.f64N/A
lift-neg.f64N/A
sqr-negN/A
lift-*.f64N/A
Applied egg-rr1.5%
Taylor expanded in t around inf
*-commutativeN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6417.2
Simplified17.2%
if 0.0 < (exp.f64 (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b)))) Initial program 92.9%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6468.5
Simplified68.5%
Taylor expanded in y around 0
+-commutativeN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6450.8
Simplified50.8%
neg-sub0N/A
sub-negN/A
lift-neg.f64N/A
flip3-+N/A
lower-/.f64N/A
metadata-evalN/A
sqr-powN/A
pow-prod-downN/A
lift-neg.f64N/A
lift-neg.f64N/A
sqr-negN/A
pow-prod-downN/A
sqr-powN/A
cube-unmultN/A
lift-*.f64N/A
lift-*.f64N/A
lower-+.f64N/A
metadata-evalN/A
lower-+.f64N/A
lift-neg.f64N/A
lift-neg.f64N/A
sqr-negN/A
lift-*.f64N/A
Applied egg-rr11.8%
lift-*.f64N/A
lift-*.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-neg.f64N/A
lift-*.f64N/A
lift--.f64N/A
lift-+.f64N/A
lift-/.f64N/A
lift-*.f64N/A
Applied egg-rr34.0%
(FPCore (x y z t a b) :precision binary64 (if (<= (exp (+ (* y (- (log z) t)) (* a (- (log (- 1.0 z)) b)))) 0.0) (* y (* x t)) x))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (exp(((y * (log(z) - t)) + (a * (log((1.0 - z)) - b)))) <= 0.0) {
tmp = y * (x * t);
} else {
tmp = x;
}
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 (exp(((y * (log(z) - t)) + (a * (log((1.0d0 - z)) - b)))) <= 0.0d0) then
tmp = y * (x * t)
else
tmp = x
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 (Math.exp(((y * (Math.log(z) - t)) + (a * (Math.log((1.0 - z)) - b)))) <= 0.0) {
tmp = y * (x * t);
} else {
tmp = x;
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if math.exp(((y * (math.log(z) - t)) + (a * (math.log((1.0 - z)) - b)))) <= 0.0: tmp = y * (x * t) else: tmp = x return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (exp(Float64(Float64(y * Float64(log(z) - t)) + Float64(a * Float64(log(Float64(1.0 - z)) - b)))) <= 0.0) tmp = Float64(y * Float64(x * t)); else tmp = x; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (exp(((y * (log(z) - t)) + (a * (log((1.0 - z)) - b)))) <= 0.0) tmp = y * (x * t); else tmp = x; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[N[Exp[N[(N[(y * N[(N[Log[z], $MachinePrecision] - t), $MachinePrecision]), $MachinePrecision] + N[(a * N[(N[Log[N[(1.0 - z), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], 0.0], N[(y * N[(x * t), $MachinePrecision]), $MachinePrecision], x]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;e^{y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right)} \leq 0:\\
\;\;\;\;y \cdot \left(x \cdot t\right)\\
\mathbf{else}:\\
\;\;\;\;x\\
\end{array}
\end{array}
if (exp.f64 (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b)))) < 0.0Initial program 100.0%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6451.3
Simplified51.3%
Taylor expanded in y around 0
+-commutativeN/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-fma.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f643.0
Simplified3.0%
neg-sub0N/A
sub-negN/A
lift-neg.f64N/A
flip3-+N/A
lower-/.f64N/A
metadata-evalN/A
sqr-powN/A
pow-prod-downN/A
lift-neg.f64N/A
lift-neg.f64N/A
sqr-negN/A
pow-prod-downN/A
sqr-powN/A
cube-unmultN/A
lift-*.f64N/A
lift-*.f64N/A
lower-+.f64N/A
metadata-evalN/A
lower-+.f64N/A
lift-neg.f64N/A
lift-neg.f64N/A
sqr-negN/A
lift-*.f64N/A
Applied egg-rr1.5%
Taylor expanded in t around inf
*-commutativeN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6417.2
Simplified17.2%
if 0.0 < (exp.f64 (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b)))) Initial program 92.9%
Taylor expanded in y around inf
lower-*.f64N/A
lower--.f64N/A
lower-log.f6476.8
Simplified76.8%
Taylor expanded in y around 0
Simplified32.1%
*-rgt-identity32.1
Applied egg-rr32.1%
(FPCore (x y z t a b) :precision binary64 (if (<= (+ (* y (- (log z) t)) (* a (- (log (- 1.0 z)) b))) 2e+75) (* x (pow z y)) (* t (* t (fma x (* (* y y) 0.5) (/ (fma x (- y) (/ x t)) t))))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (((y * (log(z) - t)) + (a * (log((1.0 - z)) - b))) <= 2e+75) {
tmp = x * pow(z, y);
} else {
tmp = t * (t * fma(x, ((y * y) * 0.5), (fma(x, -y, (x / t)) / t)));
}
return tmp;
}
function code(x, y, z, t, a, b) tmp = 0.0 if (Float64(Float64(y * Float64(log(z) - t)) + Float64(a * Float64(log(Float64(1.0 - z)) - b))) <= 2e+75) tmp = Float64(x * (z ^ y)); else tmp = Float64(t * Float64(t * fma(x, Float64(Float64(y * y) * 0.5), Float64(fma(x, Float64(-y), Float64(x / t)) / t)))); end return tmp end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[N[(N[(y * N[(N[Log[z], $MachinePrecision] - t), $MachinePrecision]), $MachinePrecision] + N[(a * N[(N[Log[N[(1.0 - z), $MachinePrecision]], $MachinePrecision] - b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2e+75], N[(x * N[Power[z, y], $MachinePrecision]), $MachinePrecision], N[(t * N[(t * N[(x * N[(N[(y * y), $MachinePrecision] * 0.5), $MachinePrecision] + N[(N[(x * (-y) + N[(x / t), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \cdot \left(\log z - t\right) + a \cdot \left(\log \left(1 - z\right) - b\right) \leq 2 \cdot 10^{+75}:\\
\;\;\;\;x \cdot {z}^{y}\\
\mathbf{else}:\\
\;\;\;\;t \cdot \left(t \cdot \mathsf{fma}\left(x, \left(y \cdot y\right) \cdot 0.5, \frac{\mathsf{fma}\left(x, -y, \frac{x}{t}\right)}{t}\right)\right)\\
\end{array}
\end{array}
if (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) < 1.99999999999999985e75Initial program 95.4%
Taylor expanded in y around inf
lower-*.f64N/A
lower--.f64N/A
lower-log.f6475.9
Simplified75.9%
Taylor expanded in t around 0
lower-*.f64N/A
lower-pow.f6457.9
Simplified57.9%
if 1.99999999999999985e75 < (+.f64 (*.f64 y (-.f64 (log.f64 z) t)) (*.f64 a (-.f64 (log.f64 (-.f64 #s(literal 1 binary64) z)) b))) Initial program 96.6%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6462.5
Simplified62.5%
Taylor expanded in t around 0
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
mul-1-negN/A
distribute-rgt-neg-inN/A
mul-1-negN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6469.2
Simplified69.2%
Taylor expanded in t around -inf
unpow2N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
associate-*l*N/A
lower-fma.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
associate-*r/N/A
Simplified79.1%
(FPCore (x y z t a b)
:precision binary64
(let* ((t_1 (* x (exp (* y (- (log z) t))))))
(if (<= y -6.8e-45)
t_1
(if (<= y 2.2e-47) (* x (exp (- (* a (+ z b))))) t_1))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x * exp((y * (log(z) - t)));
double tmp;
if (y <= -6.8e-45) {
tmp = t_1;
} else if (y <= 2.2e-47) {
tmp = x * exp(-(a * (z + 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 * exp((y * (log(z) - t)))
if (y <= (-6.8d-45)) then
tmp = t_1
else if (y <= 2.2d-47) then
tmp = x * exp(-(a * (z + 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.exp((y * (Math.log(z) - t)));
double tmp;
if (y <= -6.8e-45) {
tmp = t_1;
} else if (y <= 2.2e-47) {
tmp = x * Math.exp(-(a * (z + b)));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x * math.exp((y * (math.log(z) - t))) tmp = 0 if y <= -6.8e-45: tmp = t_1 elif y <= 2.2e-47: tmp = x * math.exp(-(a * (z + b))) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x * exp(Float64(y * Float64(log(z) - t)))) tmp = 0.0 if (y <= -6.8e-45) tmp = t_1; elseif (y <= 2.2e-47) tmp = Float64(x * exp(Float64(-Float64(a * Float64(z + b))))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x * exp((y * (log(z) - t))); tmp = 0.0; if (y <= -6.8e-45) tmp = t_1; elseif (y <= 2.2e-47) tmp = x * exp(-(a * (z + b))); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x * N[Exp[N[(y * N[(N[Log[z], $MachinePrecision] - t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -6.8e-45], t$95$1, If[LessEqual[y, 2.2e-47], N[(x * N[Exp[(-N[(a * N[(z + b), $MachinePrecision]), $MachinePrecision])], $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot e^{y \cdot \left(\log z - t\right)}\\
\mathbf{if}\;y \leq -6.8 \cdot 10^{-45}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 2.2 \cdot 10^{-47}:\\
\;\;\;\;x \cdot e^{-a \cdot \left(z + b\right)}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -6.80000000000000008e-45 or 2.20000000000000019e-47 < y Initial program 98.7%
Taylor expanded in y around inf
lower-*.f64N/A
lower--.f64N/A
lower-log.f6488.2
Simplified88.2%
if -6.80000000000000008e-45 < y < 2.20000000000000019e-47Initial program 91.8%
Taylor expanded in y around 0
lower-*.f64N/A
lower--.f64N/A
sub-negN/A
lower-log1p.f64N/A
lower-neg.f6490.1
Simplified90.1%
Taylor expanded in z around 0
+-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-lft-outN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-+.f6490.1
Simplified90.1%
Final simplification89.0%
(FPCore (x y z t a b) :precision binary64 (if (<= y -6.8e-45) (* x (exp (* t (- y)))) (if (<= y 3.7) (* x (exp (- (* a (+ z b))))) (* x (pow z y)))))
double code(double x, double y, double z, double t, double a, double b) {
double tmp;
if (y <= -6.8e-45) {
tmp = x * exp((t * -y));
} else if (y <= 3.7) {
tmp = x * exp(-(a * (z + b)));
} else {
tmp = x * pow(z, y);
}
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 (y <= (-6.8d-45)) then
tmp = x * exp((t * -y))
else if (y <= 3.7d0) then
tmp = x * exp(-(a * (z + b)))
else
tmp = x * (z ** y)
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 (y <= -6.8e-45) {
tmp = x * Math.exp((t * -y));
} else if (y <= 3.7) {
tmp = x * Math.exp(-(a * (z + b)));
} else {
tmp = x * Math.pow(z, y);
}
return tmp;
}
def code(x, y, z, t, a, b): tmp = 0 if y <= -6.8e-45: tmp = x * math.exp((t * -y)) elif y <= 3.7: tmp = x * math.exp(-(a * (z + b))) else: tmp = x * math.pow(z, y) return tmp
function code(x, y, z, t, a, b) tmp = 0.0 if (y <= -6.8e-45) tmp = Float64(x * exp(Float64(t * Float64(-y)))); elseif (y <= 3.7) tmp = Float64(x * exp(Float64(-Float64(a * Float64(z + b))))); else tmp = Float64(x * (z ^ y)); end return tmp end
function tmp_2 = code(x, y, z, t, a, b) tmp = 0.0; if (y <= -6.8e-45) tmp = x * exp((t * -y)); elseif (y <= 3.7) tmp = x * exp(-(a * (z + b))); else tmp = x * (z ^ y); end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := If[LessEqual[y, -6.8e-45], N[(x * N[Exp[N[(t * (-y)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 3.7], N[(x * N[Exp[(-N[(a * N[(z + b), $MachinePrecision]), $MachinePrecision])], $MachinePrecision]), $MachinePrecision], N[(x * N[Power[z, y], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -6.8 \cdot 10^{-45}:\\
\;\;\;\;x \cdot e^{t \cdot \left(-y\right)}\\
\mathbf{elif}\;y \leq 3.7:\\
\;\;\;\;x \cdot e^{-a \cdot \left(z + b\right)}\\
\mathbf{else}:\\
\;\;\;\;x \cdot {z}^{y}\\
\end{array}
\end{array}
if y < -6.80000000000000008e-45Initial program 97.3%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6469.6
Simplified69.6%
if -6.80000000000000008e-45 < y < 3.7000000000000002Initial program 92.1%
Taylor expanded in y around 0
lower-*.f64N/A
lower--.f64N/A
sub-negN/A
lower-log1p.f64N/A
lower-neg.f6488.8
Simplified88.8%
Taylor expanded in z around 0
+-commutativeN/A
associate-*r*N/A
associate-*r*N/A
distribute-lft-outN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-+.f6488.8
Simplified88.8%
if 3.7000000000000002 < y Initial program 100.0%
Taylor expanded in y around inf
lower-*.f64N/A
lower--.f64N/A
lower-log.f6487.5
Simplified87.5%
Taylor expanded in t around 0
lower-*.f64N/A
lower-pow.f6468.1
Simplified68.1%
Final simplification77.5%
(FPCore (x y z t a b) :precision binary64 (let* ((t_1 (* x (exp (* t (- y)))))) (if (<= t -270000000.0) t_1 (if (<= t 5e-48) (* x (pow z y)) t_1))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x * exp((t * -y));
double tmp;
if (t <= -270000000.0) {
tmp = t_1;
} else if (t <= 5e-48) {
tmp = x * pow(z, y);
} 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 * exp((t * -y))
if (t <= (-270000000.0d0)) then
tmp = t_1
else if (t <= 5d-48) then
tmp = x * (z ** y)
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.exp((t * -y));
double tmp;
if (t <= -270000000.0) {
tmp = t_1;
} else if (t <= 5e-48) {
tmp = x * Math.pow(z, y);
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x * math.exp((t * -y)) tmp = 0 if t <= -270000000.0: tmp = t_1 elif t <= 5e-48: tmp = x * math.pow(z, y) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x * exp(Float64(t * Float64(-y)))) tmp = 0.0 if (t <= -270000000.0) tmp = t_1; elseif (t <= 5e-48) tmp = Float64(x * (z ^ y)); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x * exp((t * -y)); tmp = 0.0; if (t <= -270000000.0) tmp = t_1; elseif (t <= 5e-48) tmp = x * (z ^ y); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x * N[Exp[N[(t * (-y)), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -270000000.0], t$95$1, If[LessEqual[t, 5e-48], N[(x * N[Power[z, y], $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot e^{t \cdot \left(-y\right)}\\
\mathbf{if}\;t \leq -270000000:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;t \leq 5 \cdot 10^{-48}:\\
\;\;\;\;x \cdot {z}^{y}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if t < -2.7e8 or 4.9999999999999999e-48 < t Initial program 95.7%
Taylor expanded in t around inf
mul-1-negN/A
*-commutativeN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
lower-neg.f6482.5
Simplified82.5%
if -2.7e8 < t < 4.9999999999999999e-48Initial program 95.9%
Taylor expanded in y around inf
lower-*.f64N/A
lower--.f64N/A
lower-log.f6467.2
Simplified67.2%
Taylor expanded in t around 0
lower-*.f64N/A
lower-pow.f6467.1
Simplified67.1%
Final simplification75.4%
(FPCore (x y z t a b) :precision binary64 (let* ((t_1 (* x (pow z y)))) (if (<= y -1.4e+22) t_1 (if (<= y 0.002) (* x (exp (- (* a b)))) t_1))))
double code(double x, double y, double z, double t, double a, double b) {
double t_1 = x * pow(z, y);
double tmp;
if (y <= -1.4e+22) {
tmp = t_1;
} else if (y <= 0.002) {
tmp = x * exp(-(a * 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 * (z ** y)
if (y <= (-1.4d+22)) then
tmp = t_1
else if (y <= 0.002d0) then
tmp = x * exp(-(a * 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(z, y);
double tmp;
if (y <= -1.4e+22) {
tmp = t_1;
} else if (y <= 0.002) {
tmp = x * Math.exp(-(a * b));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, t, a, b): t_1 = x * math.pow(z, y) tmp = 0 if y <= -1.4e+22: tmp = t_1 elif y <= 0.002: tmp = x * math.exp(-(a * b)) else: tmp = t_1 return tmp
function code(x, y, z, t, a, b) t_1 = Float64(x * (z ^ y)) tmp = 0.0 if (y <= -1.4e+22) tmp = t_1; elseif (y <= 0.002) tmp = Float64(x * exp(Float64(-Float64(a * b)))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, t, a, b) t_1 = x * (z ^ y); tmp = 0.0; if (y <= -1.4e+22) tmp = t_1; elseif (y <= 0.002) tmp = x * exp(-(a * b)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, t_, a_, b_] := Block[{t$95$1 = N[(x * N[Power[z, y], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.4e+22], t$95$1, If[LessEqual[y, 0.002], N[(x * N[Exp[(-N[(a * b), $MachinePrecision])], $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := x \cdot {z}^{y}\\
\mathbf{if}\;y \leq -1.4 \cdot 10^{+22}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 0.002:\\
\;\;\;\;x \cdot e^{-a \cdot b}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -1.4e22 or 2e-3 < y Initial program 98.5%
Taylor expanded in y around inf
lower-*.f64N/A
lower--.f64N/A
lower-log.f6489.6
Simplified89.6%
Taylor expanded in t around 0
lower-*.f64N/A
lower-pow.f6469.4
Simplified69.4%
if -1.4e22 < y < 2e-3Initial program 92.9%
Taylor expanded in b around inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f6477.3
Simplified77.3%
(FPCore (x y z t a b) :precision binary64 x)
double code(double x, double y, double z, double t, double a, double b) {
return x;
}
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
end function
public static double code(double x, double y, double z, double t, double a, double b) {
return x;
}
def code(x, y, z, t, a, b): return x
function code(x, y, z, t, a, b) return x end
function tmp = code(x, y, z, t, a, b) tmp = x; end
code[x_, y_, z_, t_, a_, b_] := x
\begin{array}{l}
\\
x
\end{array}
Initial program 95.8%
Taylor expanded in y around inf
lower-*.f64N/A
lower--.f64N/A
lower-log.f6475.4
Simplified75.4%
Taylor expanded in y around 0
Simplified20.5%
*-rgt-identity20.5
Applied egg-rr20.5%
herbie shell --seed 2024207
(FPCore (x y z t a b)
:name "Numeric.SpecFunctions:incompleteBetaApprox from math-functions-0.1.5.2, B"
:precision binary64
(* x (exp (+ (* y (- (log z) t)) (* a (- (log (- 1.0 z)) b))))))