
(FPCore (x y z t) :precision binary64 (- (+ (* (- x 1.0) (log y)) (* (- z 1.0) (log (- 1.0 y)))) t))
double code(double x, double y, double z, double t) {
return (((x - 1.0) * log(y)) + ((z - 1.0) * log((1.0 - y)))) - t;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = (((x - 1.0d0) * log(y)) + ((z - 1.0d0) * log((1.0d0 - y)))) - t
end function
public static double code(double x, double y, double z, double t) {
return (((x - 1.0) * Math.log(y)) + ((z - 1.0) * Math.log((1.0 - y)))) - t;
}
def code(x, y, z, t): return (((x - 1.0) * math.log(y)) + ((z - 1.0) * math.log((1.0 - y)))) - t
function code(x, y, z, t) return Float64(Float64(Float64(Float64(x - 1.0) * log(y)) + Float64(Float64(z - 1.0) * log(Float64(1.0 - y)))) - t) end
function tmp = code(x, y, z, t) tmp = (((x - 1.0) * log(y)) + ((z - 1.0) * log((1.0 - y)))) - t; end
code[x_, y_, z_, t_] := N[(N[(N[(N[(x - 1.0), $MachinePrecision] * N[Log[y], $MachinePrecision]), $MachinePrecision] + N[(N[(z - 1.0), $MachinePrecision] * N[Log[N[(1.0 - y), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(x - 1\right) \cdot \log y + \left(z - 1\right) \cdot \log \left(1 - y\right)\right) - t
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 11 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t) :precision binary64 (- (+ (* (- x 1.0) (log y)) (* (- z 1.0) (log (- 1.0 y)))) t))
double code(double x, double y, double z, double t) {
return (((x - 1.0) * log(y)) + ((z - 1.0) * log((1.0 - y)))) - t;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = (((x - 1.0d0) * log(y)) + ((z - 1.0d0) * log((1.0d0 - y)))) - t
end function
public static double code(double x, double y, double z, double t) {
return (((x - 1.0) * Math.log(y)) + ((z - 1.0) * Math.log((1.0 - y)))) - t;
}
def code(x, y, z, t): return (((x - 1.0) * math.log(y)) + ((z - 1.0) * math.log((1.0 - y)))) - t
function code(x, y, z, t) return Float64(Float64(Float64(Float64(x - 1.0) * log(y)) + Float64(Float64(z - 1.0) * log(Float64(1.0 - y)))) - t) end
function tmp = code(x, y, z, t) tmp = (((x - 1.0) * log(y)) + ((z - 1.0) * log((1.0 - y)))) - t; end
code[x_, y_, z_, t_] := N[(N[(N[(N[(x - 1.0), $MachinePrecision] * N[Log[y], $MachinePrecision]), $MachinePrecision] + N[(N[(z - 1.0), $MachinePrecision] * N[Log[N[(1.0 - y), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(x - 1\right) \cdot \log y + \left(z - 1\right) \cdot \log \left(1 - y\right)\right) - t
\end{array}
(FPCore (x y z t) :precision binary64 (- (fma (+ z -1.0) (log1p (- y)) (* (log y) (+ -1.0 x))) t))
double code(double x, double y, double z, double t) {
return fma((z + -1.0), log1p(-y), (log(y) * (-1.0 + x))) - t;
}
function code(x, y, z, t) return Float64(fma(Float64(z + -1.0), log1p(Float64(-y)), Float64(log(y) * Float64(-1.0 + x))) - t) end
code[x_, y_, z_, t_] := N[(N[(N[(z + -1.0), $MachinePrecision] * N[Log[1 + (-y)], $MachinePrecision] + N[(N[Log[y], $MachinePrecision] * N[(-1.0 + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(z + -1, \mathsf{log1p}\left(-y\right), \log y \cdot \left(-1 + x\right)\right) - t
\end{array}
Initial program 88.7%
+-commutative88.7%
fma-def88.7%
sub-neg88.7%
metadata-eval88.7%
sub-neg88.7%
log1p-def99.8%
sub-neg99.8%
metadata-eval99.8%
Simplified99.8%
Final simplification99.8%
(FPCore (x y z t) :precision binary64 (- (+ (* (+ z -1.0) (- (* y (* y -0.5)) y)) (* (log y) (+ -1.0 x))) t))
double code(double x, double y, double z, double t) {
return (((z + -1.0) * ((y * (y * -0.5)) - y)) + (log(y) * (-1.0 + x))) - t;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = (((z + (-1.0d0)) * ((y * (y * (-0.5d0))) - y)) + (log(y) * ((-1.0d0) + x))) - t
end function
public static double code(double x, double y, double z, double t) {
return (((z + -1.0) * ((y * (y * -0.5)) - y)) + (Math.log(y) * (-1.0 + x))) - t;
}
def code(x, y, z, t): return (((z + -1.0) * ((y * (y * -0.5)) - y)) + (math.log(y) * (-1.0 + x))) - t
function code(x, y, z, t) return Float64(Float64(Float64(Float64(z + -1.0) * Float64(Float64(y * Float64(y * -0.5)) - y)) + Float64(log(y) * Float64(-1.0 + x))) - t) end
function tmp = code(x, y, z, t) tmp = (((z + -1.0) * ((y * (y * -0.5)) - y)) + (log(y) * (-1.0 + x))) - t; end
code[x_, y_, z_, t_] := N[(N[(N[(N[(z + -1.0), $MachinePrecision] * N[(N[(y * N[(y * -0.5), $MachinePrecision]), $MachinePrecision] - y), $MachinePrecision]), $MachinePrecision] + N[(N[Log[y], $MachinePrecision] * N[(-1.0 + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(z + -1\right) \cdot \left(y \cdot \left(y \cdot -0.5\right) - y\right) + \log y \cdot \left(-1 + x\right)\right) - t
\end{array}
Initial program 88.7%
Taylor expanded in y around 0 99.3%
+-commutative99.3%
mul-1-neg99.3%
unsub-neg99.3%
*-commutative99.3%
unpow299.3%
associate-*l*99.3%
Simplified99.3%
Final simplification99.3%
(FPCore (x y z t) :precision binary64 (if (or (<= (+ -1.0 x) -1e+19) (not (<= (+ -1.0 x) -0.5))) (- (- (* x (log y)) (* z y)) t) (- (- (* z (- y)) (log y)) t)))
double code(double x, double y, double z, double t) {
double tmp;
if (((-1.0 + x) <= -1e+19) || !((-1.0 + x) <= -0.5)) {
tmp = ((x * log(y)) - (z * y)) - t;
} else {
tmp = ((z * -y) - log(y)) - t;
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if ((((-1.0d0) + x) <= (-1d+19)) .or. (.not. (((-1.0d0) + x) <= (-0.5d0)))) then
tmp = ((x * log(y)) - (z * y)) - t
else
tmp = ((z * -y) - log(y)) - t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (((-1.0 + x) <= -1e+19) || !((-1.0 + x) <= -0.5)) {
tmp = ((x * Math.log(y)) - (z * y)) - t;
} else {
tmp = ((z * -y) - Math.log(y)) - t;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if ((-1.0 + x) <= -1e+19) or not ((-1.0 + x) <= -0.5): tmp = ((x * math.log(y)) - (z * y)) - t else: tmp = ((z * -y) - math.log(y)) - t return tmp
function code(x, y, z, t) tmp = 0.0 if ((Float64(-1.0 + x) <= -1e+19) || !(Float64(-1.0 + x) <= -0.5)) tmp = Float64(Float64(Float64(x * log(y)) - Float64(z * y)) - t); else tmp = Float64(Float64(Float64(z * Float64(-y)) - log(y)) - t); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (((-1.0 + x) <= -1e+19) || ~(((-1.0 + x) <= -0.5))) tmp = ((x * log(y)) - (z * y)) - t; else tmp = ((z * -y) - log(y)) - t; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[Or[LessEqual[N[(-1.0 + x), $MachinePrecision], -1e+19], N[Not[LessEqual[N[(-1.0 + x), $MachinePrecision], -0.5]], $MachinePrecision]], N[(N[(N[(x * N[Log[y], $MachinePrecision]), $MachinePrecision] - N[(z * y), $MachinePrecision]), $MachinePrecision] - t), $MachinePrecision], N[(N[(N[(z * (-y)), $MachinePrecision] - N[Log[y], $MachinePrecision]), $MachinePrecision] - t), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;-1 + x \leq -1 \cdot 10^{+19} \lor \neg \left(-1 + x \leq -0.5\right):\\
\;\;\;\;\left(x \cdot \log y - z \cdot y\right) - t\\
\mathbf{else}:\\
\;\;\;\;\left(z \cdot \left(-y\right) - \log y\right) - t\\
\end{array}
\end{array}
if (-.f64 x 1) < -1e19 or -0.5 < (-.f64 x 1) Initial program 93.6%
Taylor expanded in y around 0 99.2%
associate-+r+99.2%
sub-neg99.2%
metadata-eval99.2%
associate-*r*99.2%
sub-neg99.2%
metadata-eval99.2%
associate-*r*99.2%
distribute-rgt-out99.2%
+-commutative99.2%
+-commutative99.2%
mul-1-neg99.2%
unsub-neg99.2%
*-commutative99.2%
unpow299.2%
associate-*l*99.2%
Simplified99.2%
Taylor expanded in y around 0 98.3%
+-commutative98.3%
mul-1-neg98.3%
unsub-neg98.3%
sub-neg98.3%
metadata-eval98.3%
+-commutative98.3%
sub-neg98.3%
metadata-eval98.3%
Simplified98.3%
Taylor expanded in z around inf 98.3%
Taylor expanded in x around inf 98.0%
*-commutative98.0%
Simplified98.0%
if -1e19 < (-.f64 x 1) < -0.5Initial program 83.0%
Taylor expanded in x around 0 81.7%
+-commutative81.7%
mul-1-neg81.7%
unsub-neg81.7%
sub-neg81.7%
mul-1-neg81.7%
log1p-def98.7%
mul-1-neg98.7%
sub-neg98.7%
metadata-eval98.7%
+-commutative98.7%
Simplified98.7%
Taylor expanded in z around inf 81.7%
sub-neg81.7%
log1p-def98.7%
Simplified98.7%
Taylor expanded in y around 0 97.8%
neg-mul-197.8%
+-commutative97.8%
unsub-neg97.8%
*-commutative97.8%
neg-mul-197.8%
distribute-rgt-neg-in97.8%
Simplified97.8%
Final simplification97.9%
(FPCore (x y z t) :precision binary64 (if (or (<= (+ -1.0 x) -1.5) (not (<= (+ -1.0 x) -0.9999996))) (- (* (log y) (+ -1.0 x)) t) (- (- (* z (- y)) (log y)) t)))
double code(double x, double y, double z, double t) {
double tmp;
if (((-1.0 + x) <= -1.5) || !((-1.0 + x) <= -0.9999996)) {
tmp = (log(y) * (-1.0 + x)) - t;
} else {
tmp = ((z * -y) - log(y)) - t;
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if ((((-1.0d0) + x) <= (-1.5d0)) .or. (.not. (((-1.0d0) + x) <= (-0.9999996d0)))) then
tmp = (log(y) * ((-1.0d0) + x)) - t
else
tmp = ((z * -y) - log(y)) - t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (((-1.0 + x) <= -1.5) || !((-1.0 + x) <= -0.9999996)) {
tmp = (Math.log(y) * (-1.0 + x)) - t;
} else {
tmp = ((z * -y) - Math.log(y)) - t;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if ((-1.0 + x) <= -1.5) or not ((-1.0 + x) <= -0.9999996): tmp = (math.log(y) * (-1.0 + x)) - t else: tmp = ((z * -y) - math.log(y)) - t return tmp
function code(x, y, z, t) tmp = 0.0 if ((Float64(-1.0 + x) <= -1.5) || !(Float64(-1.0 + x) <= -0.9999996)) tmp = Float64(Float64(log(y) * Float64(-1.0 + x)) - t); else tmp = Float64(Float64(Float64(z * Float64(-y)) - log(y)) - t); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (((-1.0 + x) <= -1.5) || ~(((-1.0 + x) <= -0.9999996))) tmp = (log(y) * (-1.0 + x)) - t; else tmp = ((z * -y) - log(y)) - t; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[Or[LessEqual[N[(-1.0 + x), $MachinePrecision], -1.5], N[Not[LessEqual[N[(-1.0 + x), $MachinePrecision], -0.9999996]], $MachinePrecision]], N[(N[(N[Log[y], $MachinePrecision] * N[(-1.0 + x), $MachinePrecision]), $MachinePrecision] - t), $MachinePrecision], N[(N[(N[(z * (-y)), $MachinePrecision] - N[Log[y], $MachinePrecision]), $MachinePrecision] - t), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;-1 + x \leq -1.5 \lor \neg \left(-1 + x \leq -0.9999996\right):\\
\;\;\;\;\log y \cdot \left(-1 + x\right) - t\\
\mathbf{else}:\\
\;\;\;\;\left(z \cdot \left(-y\right) - \log y\right) - t\\
\end{array}
\end{array}
if (-.f64 x 1) < -1.5 or -0.99999959999999999 < (-.f64 x 1) Initial program 93.8%
associate--l+93.8%
fma-def93.8%
sub-neg93.8%
metadata-eval93.8%
fma-neg93.8%
sub-neg93.8%
metadata-eval93.8%
sub-neg93.8%
log1p-def99.7%
Simplified99.7%
Taylor expanded in y around 0 91.8%
if -1.5 < (-.f64 x 1) < -0.99999959999999999Initial program 82.4%
Taylor expanded in x around 0 82.4%
+-commutative82.4%
mul-1-neg82.4%
unsub-neg82.4%
sub-neg82.4%
mul-1-neg82.4%
log1p-def100.0%
mul-1-neg100.0%
sub-neg100.0%
metadata-eval100.0%
+-commutative100.0%
Simplified100.0%
Taylor expanded in z around inf 82.4%
sub-neg82.4%
log1p-def100.0%
Simplified100.0%
Taylor expanded in y around 0 99.0%
neg-mul-199.0%
+-commutative99.0%
unsub-neg99.0%
*-commutative99.0%
neg-mul-199.0%
distribute-rgt-neg-in99.0%
Simplified99.0%
Final simplification95.0%
(FPCore (x y z t) :precision binary64 (- (- (* (log y) (+ -1.0 x)) (* z y)) t))
double code(double x, double y, double z, double t) {
return ((log(y) * (-1.0 + x)) - (z * y)) - t;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = ((log(y) * ((-1.0d0) + x)) - (z * y)) - t
end function
public static double code(double x, double y, double z, double t) {
return ((Math.log(y) * (-1.0 + x)) - (z * y)) - t;
}
def code(x, y, z, t): return ((math.log(y) * (-1.0 + x)) - (z * y)) - t
function code(x, y, z, t) return Float64(Float64(Float64(log(y) * Float64(-1.0 + x)) - Float64(z * y)) - t) end
function tmp = code(x, y, z, t) tmp = ((log(y) * (-1.0 + x)) - (z * y)) - t; end
code[x_, y_, z_, t_] := N[(N[(N[(N[Log[y], $MachinePrecision] * N[(-1.0 + x), $MachinePrecision]), $MachinePrecision] - N[(z * y), $MachinePrecision]), $MachinePrecision] - t), $MachinePrecision]
\begin{array}{l}
\\
\left(\log y \cdot \left(-1 + x\right) - z \cdot y\right) - t
\end{array}
Initial program 88.7%
Taylor expanded in y around 0 99.5%
associate-+r+99.5%
sub-neg99.5%
metadata-eval99.5%
associate-*r*99.5%
sub-neg99.5%
metadata-eval99.5%
associate-*r*99.5%
distribute-rgt-out99.5%
+-commutative99.5%
+-commutative99.5%
mul-1-neg99.5%
unsub-neg99.5%
*-commutative99.5%
unpow299.5%
associate-*l*99.5%
Simplified99.5%
Taylor expanded in y around 0 98.6%
+-commutative98.6%
mul-1-neg98.6%
unsub-neg98.6%
sub-neg98.6%
metadata-eval98.6%
+-commutative98.6%
sub-neg98.6%
metadata-eval98.6%
Simplified98.6%
Taylor expanded in z around inf 98.6%
Final simplification98.6%
(FPCore (x y z t) :precision binary64 (if (or (<= x -3700000.0) (not (<= x 1.0))) (- (* x (log y)) t) (- (- (log y)) t)))
double code(double x, double y, double z, double t) {
double tmp;
if ((x <= -3700000.0) || !(x <= 1.0)) {
tmp = (x * log(y)) - t;
} else {
tmp = -log(y) - t;
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if ((x <= (-3700000.0d0)) .or. (.not. (x <= 1.0d0))) then
tmp = (x * log(y)) - t
else
tmp = -log(y) - t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if ((x <= -3700000.0) || !(x <= 1.0)) {
tmp = (x * Math.log(y)) - t;
} else {
tmp = -Math.log(y) - t;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if (x <= -3700000.0) or not (x <= 1.0): tmp = (x * math.log(y)) - t else: tmp = -math.log(y) - t return tmp
function code(x, y, z, t) tmp = 0.0 if ((x <= -3700000.0) || !(x <= 1.0)) tmp = Float64(Float64(x * log(y)) - t); else tmp = Float64(Float64(-log(y)) - t); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if ((x <= -3700000.0) || ~((x <= 1.0))) tmp = (x * log(y)) - t; else tmp = -log(y) - t; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[Or[LessEqual[x, -3700000.0], N[Not[LessEqual[x, 1.0]], $MachinePrecision]], N[(N[(x * N[Log[y], $MachinePrecision]), $MachinePrecision] - t), $MachinePrecision], N[((-N[Log[y], $MachinePrecision]) - t), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -3700000 \lor \neg \left(x \leq 1\right):\\
\;\;\;\;x \cdot \log y - t\\
\mathbf{else}:\\
\;\;\;\;\left(-\log y\right) - t\\
\end{array}
\end{array}
if x < -3.7e6 or 1 < x Initial program 93.6%
Taylor expanded in y around 0 99.2%
associate-+r+99.2%
sub-neg99.2%
metadata-eval99.2%
associate-*r*99.2%
sub-neg99.2%
metadata-eval99.2%
associate-*r*99.2%
distribute-rgt-out99.2%
+-commutative99.2%
+-commutative99.2%
mul-1-neg99.2%
unsub-neg99.2%
*-commutative99.2%
unpow299.2%
associate-*l*99.2%
Simplified99.2%
Taylor expanded in y around 0 98.3%
+-commutative98.3%
mul-1-neg98.3%
unsub-neg98.3%
sub-neg98.3%
metadata-eval98.3%
+-commutative98.3%
sub-neg98.3%
metadata-eval98.3%
Simplified98.3%
Taylor expanded in x around inf 91.3%
*-commutative91.3%
Simplified91.3%
if -3.7e6 < x < 1Initial program 83.0%
associate--l+83.0%
fma-def83.0%
sub-neg83.0%
metadata-eval83.0%
fma-neg83.0%
sub-neg83.0%
metadata-eval83.0%
sub-neg83.0%
log1p-def100.0%
Simplified100.0%
Taylor expanded in y around 0 81.5%
Taylor expanded in x around 0 80.2%
neg-mul-180.2%
Simplified80.2%
Final simplification86.2%
(FPCore (x y z t) :precision binary64 (if (<= z 1.6e+198) (- (* (log y) (+ -1.0 x)) t) (- (* z (- y)) t)))
double code(double x, double y, double z, double t) {
double tmp;
if (z <= 1.6e+198) {
tmp = (log(y) * (-1.0 + x)) - t;
} else {
tmp = (z * -y) - t;
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if (z <= 1.6d+198) then
tmp = (log(y) * ((-1.0d0) + x)) - t
else
tmp = (z * -y) - t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if (z <= 1.6e+198) {
tmp = (Math.log(y) * (-1.0 + x)) - t;
} else {
tmp = (z * -y) - t;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if z <= 1.6e+198: tmp = (math.log(y) * (-1.0 + x)) - t else: tmp = (z * -y) - t return tmp
function code(x, y, z, t) tmp = 0.0 if (z <= 1.6e+198) tmp = Float64(Float64(log(y) * Float64(-1.0 + x)) - t); else tmp = Float64(Float64(z * Float64(-y)) - t); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if (z <= 1.6e+198) tmp = (log(y) * (-1.0 + x)) - t; else tmp = (z * -y) - t; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[LessEqual[z, 1.6e+198], N[(N[(N[Log[y], $MachinePrecision] * N[(-1.0 + x), $MachinePrecision]), $MachinePrecision] - t), $MachinePrecision], N[(N[(z * (-y)), $MachinePrecision] - t), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq 1.6 \cdot 10^{+198}:\\
\;\;\;\;\log y \cdot \left(-1 + x\right) - t\\
\mathbf{else}:\\
\;\;\;\;z \cdot \left(-y\right) - t\\
\end{array}
\end{array}
if z < 1.5999999999999999e198Initial program 93.2%
associate--l+93.2%
fma-def93.2%
sub-neg93.2%
metadata-eval93.2%
fma-neg93.2%
sub-neg93.2%
metadata-eval93.2%
sub-neg93.2%
log1p-def99.8%
Simplified99.8%
Taylor expanded in y around 0 91.9%
if 1.5999999999999999e198 < z Initial program 51.4%
Taylor expanded in y around 0 99.8%
associate-+r+99.8%
sub-neg99.8%
metadata-eval99.8%
associate-*r*99.8%
sub-neg99.8%
metadata-eval99.8%
associate-*r*99.8%
distribute-rgt-out99.9%
+-commutative99.9%
+-commutative99.9%
mul-1-neg99.9%
unsub-neg99.9%
*-commutative99.9%
unpow299.9%
associate-*l*99.9%
Simplified99.9%
Taylor expanded in y around 0 96.8%
+-commutative96.8%
mul-1-neg96.8%
unsub-neg96.8%
sub-neg96.8%
metadata-eval96.8%
+-commutative96.8%
sub-neg96.8%
metadata-eval96.8%
Simplified96.8%
Taylor expanded in z around inf 65.7%
*-commutative65.7%
neg-mul-165.7%
distribute-rgt-neg-in65.7%
Simplified65.7%
Final simplification89.0%
(FPCore (x y z t) :precision binary64 (if (or (<= z -4e+121) (not (<= z 1.8e+197))) (- (* z (- y)) t) (- (- (log y)) t)))
double code(double x, double y, double z, double t) {
double tmp;
if ((z <= -4e+121) || !(z <= 1.8e+197)) {
tmp = (z * -y) - t;
} else {
tmp = -log(y) - t;
}
return tmp;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if ((z <= (-4d+121)) .or. (.not. (z <= 1.8d+197))) then
tmp = (z * -y) - t
else
tmp = -log(y) - t
end if
code = tmp
end function
public static double code(double x, double y, double z, double t) {
double tmp;
if ((z <= -4e+121) || !(z <= 1.8e+197)) {
tmp = (z * -y) - t;
} else {
tmp = -Math.log(y) - t;
}
return tmp;
}
def code(x, y, z, t): tmp = 0 if (z <= -4e+121) or not (z <= 1.8e+197): tmp = (z * -y) - t else: tmp = -math.log(y) - t return tmp
function code(x, y, z, t) tmp = 0.0 if ((z <= -4e+121) || !(z <= 1.8e+197)) tmp = Float64(Float64(z * Float64(-y)) - t); else tmp = Float64(Float64(-log(y)) - t); end return tmp end
function tmp_2 = code(x, y, z, t) tmp = 0.0; if ((z <= -4e+121) || ~((z <= 1.8e+197))) tmp = (z * -y) - t; else tmp = -log(y) - t; end tmp_2 = tmp; end
code[x_, y_, z_, t_] := If[Or[LessEqual[z, -4e+121], N[Not[LessEqual[z, 1.8e+197]], $MachinePrecision]], N[(N[(z * (-y)), $MachinePrecision] - t), $MachinePrecision], N[((-N[Log[y], $MachinePrecision]) - t), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;z \leq -4 \cdot 10^{+121} \lor \neg \left(z \leq 1.8 \cdot 10^{+197}\right):\\
\;\;\;\;z \cdot \left(-y\right) - t\\
\mathbf{else}:\\
\;\;\;\;\left(-\log y\right) - t\\
\end{array}
\end{array}
if z < -4.00000000000000015e121 or 1.79999999999999991e197 < z Initial program 64.6%
Taylor expanded in y around 0 99.9%
associate-+r+99.9%
sub-neg99.9%
metadata-eval99.9%
associate-*r*99.9%
sub-neg99.9%
metadata-eval99.9%
associate-*r*99.9%
distribute-rgt-out99.9%
+-commutative99.9%
+-commutative99.9%
mul-1-neg99.9%
unsub-neg99.9%
*-commutative99.9%
unpow299.9%
associate-*l*99.9%
Simplified99.9%
Taylor expanded in y around 0 97.9%
+-commutative97.9%
mul-1-neg97.9%
unsub-neg97.9%
sub-neg97.9%
metadata-eval97.9%
+-commutative97.9%
sub-neg97.9%
metadata-eval97.9%
Simplified97.9%
Taylor expanded in z around inf 64.4%
*-commutative64.4%
neg-mul-164.4%
distribute-rgt-neg-in64.4%
Simplified64.4%
if -4.00000000000000015e121 < z < 1.79999999999999991e197Initial program 97.7%
associate--l+97.7%
fma-def97.7%
sub-neg97.7%
metadata-eval97.7%
fma-neg97.7%
sub-neg97.7%
metadata-eval97.7%
sub-neg97.7%
log1p-def99.8%
Simplified99.8%
Taylor expanded in y around 0 96.5%
Taylor expanded in x around 0 56.4%
neg-mul-156.4%
Simplified56.4%
Final simplification58.6%
(FPCore (x y z t) :precision binary64 (- (* y (- 1.0 z)) t))
double code(double x, double y, double z, double t) {
return (y * (1.0 - z)) - t;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = (y * (1.0d0 - z)) - t
end function
public static double code(double x, double y, double z, double t) {
return (y * (1.0 - z)) - t;
}
def code(x, y, z, t): return (y * (1.0 - z)) - t
function code(x, y, z, t) return Float64(Float64(y * Float64(1.0 - z)) - t) end
function tmp = code(x, y, z, t) tmp = (y * (1.0 - z)) - t; end
code[x_, y_, z_, t_] := N[(N[(y * N[(1.0 - z), $MachinePrecision]), $MachinePrecision] - t), $MachinePrecision]
\begin{array}{l}
\\
y \cdot \left(1 - z\right) - t
\end{array}
Initial program 88.7%
Taylor expanded in y around 0 99.5%
associate-+r+99.5%
sub-neg99.5%
metadata-eval99.5%
associate-*r*99.5%
sub-neg99.5%
metadata-eval99.5%
associate-*r*99.5%
distribute-rgt-out99.5%
+-commutative99.5%
+-commutative99.5%
mul-1-neg99.5%
unsub-neg99.5%
*-commutative99.5%
unpow299.5%
associate-*l*99.5%
Simplified99.5%
Taylor expanded in y around 0 98.6%
+-commutative98.6%
mul-1-neg98.6%
unsub-neg98.6%
sub-neg98.6%
metadata-eval98.6%
+-commutative98.6%
sub-neg98.6%
metadata-eval98.6%
Simplified98.6%
Taylor expanded in y around inf 45.1%
Final simplification45.1%
(FPCore (x y z t) :precision binary64 (- (* z (- y)) t))
double code(double x, double y, double z, double t) {
return (z * -y) - t;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = (z * -y) - t
end function
public static double code(double x, double y, double z, double t) {
return (z * -y) - t;
}
def code(x, y, z, t): return (z * -y) - t
function code(x, y, z, t) return Float64(Float64(z * Float64(-y)) - t) end
function tmp = code(x, y, z, t) tmp = (z * -y) - t; end
code[x_, y_, z_, t_] := N[(N[(z * (-y)), $MachinePrecision] - t), $MachinePrecision]
\begin{array}{l}
\\
z \cdot \left(-y\right) - t
\end{array}
Initial program 88.7%
Taylor expanded in y around 0 99.5%
associate-+r+99.5%
sub-neg99.5%
metadata-eval99.5%
associate-*r*99.5%
sub-neg99.5%
metadata-eval99.5%
associate-*r*99.5%
distribute-rgt-out99.5%
+-commutative99.5%
+-commutative99.5%
mul-1-neg99.5%
unsub-neg99.5%
*-commutative99.5%
unpow299.5%
associate-*l*99.5%
Simplified99.5%
Taylor expanded in y around 0 98.6%
+-commutative98.6%
mul-1-neg98.6%
unsub-neg98.6%
sub-neg98.6%
metadata-eval98.6%
+-commutative98.6%
sub-neg98.6%
metadata-eval98.6%
Simplified98.6%
Taylor expanded in z around inf 45.0%
*-commutative45.0%
neg-mul-145.0%
distribute-rgt-neg-in45.0%
Simplified45.0%
Final simplification45.0%
(FPCore (x y z t) :precision binary64 (- t))
double code(double x, double y, double z, double t) {
return -t;
}
real(8) function code(x, y, z, t)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = -t
end function
public static double code(double x, double y, double z, double t) {
return -t;
}
def code(x, y, z, t): return -t
function code(x, y, z, t) return Float64(-t) end
function tmp = code(x, y, z, t) tmp = -t; end
code[x_, y_, z_, t_] := (-t)
\begin{array}{l}
\\
-t
\end{array}
Initial program 88.7%
associate--l+88.7%
fma-def88.7%
sub-neg88.7%
metadata-eval88.7%
fma-neg88.7%
sub-neg88.7%
metadata-eval88.7%
sub-neg88.7%
log1p-def99.8%
Simplified99.8%
Taylor expanded in t around inf 34.7%
mul-1-neg34.7%
Simplified34.7%
Final simplification34.7%
herbie shell --seed 2023293
(FPCore (x y z t)
:name "Statistics.Distribution.Beta:$cdensity from math-functions-0.1.5.2"
:precision binary64
(- (+ (* (- x 1.0) (log y)) (* (- z 1.0) (log (- 1.0 y)))) t))