
(FPCore (x y) :precision binary64 (+ (- (* x (- y 1.0)) (* y 0.5)) 0.918938533204673))
double code(double x, double y) {
return ((x * (y - 1.0)) - (y * 0.5)) + 0.918938533204673;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = ((x * (y - 1.0d0)) - (y * 0.5d0)) + 0.918938533204673d0
end function
public static double code(double x, double y) {
return ((x * (y - 1.0)) - (y * 0.5)) + 0.918938533204673;
}
def code(x, y): return ((x * (y - 1.0)) - (y * 0.5)) + 0.918938533204673
function code(x, y) return Float64(Float64(Float64(x * Float64(y - 1.0)) - Float64(y * 0.5)) + 0.918938533204673) end
function tmp = code(x, y) tmp = ((x * (y - 1.0)) - (y * 0.5)) + 0.918938533204673; end
code[x_, y_] := N[(N[(N[(x * N[(y - 1.0), $MachinePrecision]), $MachinePrecision] - N[(y * 0.5), $MachinePrecision]), $MachinePrecision] + 0.918938533204673), $MachinePrecision]
\begin{array}{l}
\\
\left(x \cdot \left(y - 1\right) - y \cdot 0.5\right) + 0.918938533204673
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 11 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y) :precision binary64 (+ (- (* x (- y 1.0)) (* y 0.5)) 0.918938533204673))
double code(double x, double y) {
return ((x * (y - 1.0)) - (y * 0.5)) + 0.918938533204673;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = ((x * (y - 1.0d0)) - (y * 0.5d0)) + 0.918938533204673d0
end function
public static double code(double x, double y) {
return ((x * (y - 1.0)) - (y * 0.5)) + 0.918938533204673;
}
def code(x, y): return ((x * (y - 1.0)) - (y * 0.5)) + 0.918938533204673
function code(x, y) return Float64(Float64(Float64(x * Float64(y - 1.0)) - Float64(y * 0.5)) + 0.918938533204673) end
function tmp = code(x, y) tmp = ((x * (y - 1.0)) - (y * 0.5)) + 0.918938533204673; end
code[x_, y_] := N[(N[(N[(x * N[(y - 1.0), $MachinePrecision]), $MachinePrecision] - N[(y * 0.5), $MachinePrecision]), $MachinePrecision] + 0.918938533204673), $MachinePrecision]
\begin{array}{l}
\\
\left(x \cdot \left(y - 1\right) - y \cdot 0.5\right) + 0.918938533204673
\end{array}
(FPCore (x y) :precision binary64 (+ (fma x (+ y -1.0) (* y -0.5)) 0.918938533204673))
double code(double x, double y) {
return fma(x, (y + -1.0), (y * -0.5)) + 0.918938533204673;
}
function code(x, y) return Float64(fma(x, Float64(y + -1.0), Float64(y * -0.5)) + 0.918938533204673) end
code[x_, y_] := N[(N[(x * N[(y + -1.0), $MachinePrecision] + N[(y * -0.5), $MachinePrecision]), $MachinePrecision] + 0.918938533204673), $MachinePrecision]
\begin{array}{l}
\\
\mathsf{fma}\left(x, y + -1, y \cdot -0.5\right) + 0.918938533204673
\end{array}
Initial program 100.0%
fma-neg100.0%
sub-neg100.0%
metadata-eval100.0%
distribute-rgt-neg-in100.0%
metadata-eval100.0%
Simplified100.0%
Final simplification100.0%
(FPCore (x y)
:precision binary64
(if (<= x -0.5)
(* x y)
(if (<= x -5.1e-235)
(* y -0.5)
(if (<= x 3.05e-288)
0.918938533204673
(if (<= x 9e+17) (* y -0.5) (* x y))))))
double code(double x, double y) {
double tmp;
if (x <= -0.5) {
tmp = x * y;
} else if (x <= -5.1e-235) {
tmp = y * -0.5;
} else if (x <= 3.05e-288) {
tmp = 0.918938533204673;
} else if (x <= 9e+17) {
tmp = y * -0.5;
} else {
tmp = x * y;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (x <= (-0.5d0)) then
tmp = x * y
else if (x <= (-5.1d-235)) then
tmp = y * (-0.5d0)
else if (x <= 3.05d-288) then
tmp = 0.918938533204673d0
else if (x <= 9d+17) then
tmp = y * (-0.5d0)
else
tmp = x * y
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (x <= -0.5) {
tmp = x * y;
} else if (x <= -5.1e-235) {
tmp = y * -0.5;
} else if (x <= 3.05e-288) {
tmp = 0.918938533204673;
} else if (x <= 9e+17) {
tmp = y * -0.5;
} else {
tmp = x * y;
}
return tmp;
}
def code(x, y): tmp = 0 if x <= -0.5: tmp = x * y elif x <= -5.1e-235: tmp = y * -0.5 elif x <= 3.05e-288: tmp = 0.918938533204673 elif x <= 9e+17: tmp = y * -0.5 else: tmp = x * y return tmp
function code(x, y) tmp = 0.0 if (x <= -0.5) tmp = Float64(x * y); elseif (x <= -5.1e-235) tmp = Float64(y * -0.5); elseif (x <= 3.05e-288) tmp = 0.918938533204673; elseif (x <= 9e+17) tmp = Float64(y * -0.5); else tmp = Float64(x * y); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (x <= -0.5) tmp = x * y; elseif (x <= -5.1e-235) tmp = y * -0.5; elseif (x <= 3.05e-288) tmp = 0.918938533204673; elseif (x <= 9e+17) tmp = y * -0.5; else tmp = x * y; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[x, -0.5], N[(x * y), $MachinePrecision], If[LessEqual[x, -5.1e-235], N[(y * -0.5), $MachinePrecision], If[LessEqual[x, 3.05e-288], 0.918938533204673, If[LessEqual[x, 9e+17], N[(y * -0.5), $MachinePrecision], N[(x * y), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -0.5:\\
\;\;\;\;x \cdot y\\
\mathbf{elif}\;x \leq -5.1 \cdot 10^{-235}:\\
\;\;\;\;y \cdot -0.5\\
\mathbf{elif}\;x \leq 3.05 \cdot 10^{-288}:\\
\;\;\;\;0.918938533204673\\
\mathbf{elif}\;x \leq 9 \cdot 10^{+17}:\\
\;\;\;\;y \cdot -0.5\\
\mathbf{else}:\\
\;\;\;\;x \cdot y\\
\end{array}
\end{array}
if x < -0.5 or 9e17 < x Initial program 100.0%
+-commutative100.0%
cancel-sign-sub-inv100.0%
+-commutative100.0%
associate-+r+100.0%
cancel-sign-sub-inv100.0%
associate-+l-100.0%
sub-neg100.0%
distribute-rgt-in100.0%
metadata-eval100.0%
neg-mul-1100.0%
associate--r+100.0%
distribute-lft-out--100.0%
unsub-neg100.0%
fma-neg100.0%
unsub-neg100.0%
remove-double-neg100.0%
Simplified100.0%
Taylor expanded in y around inf 55.7%
Taylor expanded in x around inf 55.2%
*-commutative55.2%
Simplified55.2%
if -0.5 < x < -5.09999999999999993e-235 or 3.04999999999999991e-288 < x < 9e17Initial program 100.0%
+-commutative100.0%
cancel-sign-sub-inv100.0%
+-commutative100.0%
associate-+r+100.0%
cancel-sign-sub-inv100.0%
associate-+l-100.0%
sub-neg100.0%
distribute-rgt-in100.0%
metadata-eval100.0%
neg-mul-1100.0%
associate--r+100.0%
distribute-lft-out--99.9%
unsub-neg99.9%
fma-neg99.9%
unsub-neg99.9%
remove-double-neg99.9%
Simplified99.9%
Taylor expanded in y around inf 96.8%
Taylor expanded in y around inf 61.6%
Taylor expanded in x around 0 59.3%
if -5.09999999999999993e-235 < x < 3.04999999999999991e-288Initial program 100.0%
+-commutative100.0%
cancel-sign-sub-inv100.0%
+-commutative100.0%
associate-+r+100.0%
cancel-sign-sub-inv100.0%
associate-+l-100.0%
sub-neg100.0%
distribute-rgt-in100.0%
metadata-eval100.0%
neg-mul-1100.0%
associate--r+100.0%
distribute-lft-out--100.0%
unsub-neg100.0%
fma-neg100.0%
unsub-neg100.0%
remove-double-neg100.0%
Simplified100.0%
Taylor expanded in y around inf 100.0%
Taylor expanded in y around 0 67.4%
Final simplification57.7%
(FPCore (x y)
:precision binary64
(if (<= y -8e+198)
(* x y)
(if (<= y -520000000000.0)
(* y -0.5)
(if (<= y 1.05)
(- 0.918938533204673 x)
(if (<= y 1.4e+73) (* x y) (* y -0.5))))))
double code(double x, double y) {
double tmp;
if (y <= -8e+198) {
tmp = x * y;
} else if (y <= -520000000000.0) {
tmp = y * -0.5;
} else if (y <= 1.05) {
tmp = 0.918938533204673 - x;
} else if (y <= 1.4e+73) {
tmp = x * y;
} else {
tmp = y * -0.5;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (y <= (-8d+198)) then
tmp = x * y
else if (y <= (-520000000000.0d0)) then
tmp = y * (-0.5d0)
else if (y <= 1.05d0) then
tmp = 0.918938533204673d0 - x
else if (y <= 1.4d+73) then
tmp = x * y
else
tmp = y * (-0.5d0)
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (y <= -8e+198) {
tmp = x * y;
} else if (y <= -520000000000.0) {
tmp = y * -0.5;
} else if (y <= 1.05) {
tmp = 0.918938533204673 - x;
} else if (y <= 1.4e+73) {
tmp = x * y;
} else {
tmp = y * -0.5;
}
return tmp;
}
def code(x, y): tmp = 0 if y <= -8e+198: tmp = x * y elif y <= -520000000000.0: tmp = y * -0.5 elif y <= 1.05: tmp = 0.918938533204673 - x elif y <= 1.4e+73: tmp = x * y else: tmp = y * -0.5 return tmp
function code(x, y) tmp = 0.0 if (y <= -8e+198) tmp = Float64(x * y); elseif (y <= -520000000000.0) tmp = Float64(y * -0.5); elseif (y <= 1.05) tmp = Float64(0.918938533204673 - x); elseif (y <= 1.4e+73) tmp = Float64(x * y); else tmp = Float64(y * -0.5); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (y <= -8e+198) tmp = x * y; elseif (y <= -520000000000.0) tmp = y * -0.5; elseif (y <= 1.05) tmp = 0.918938533204673 - x; elseif (y <= 1.4e+73) tmp = x * y; else tmp = y * -0.5; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[y, -8e+198], N[(x * y), $MachinePrecision], If[LessEqual[y, -520000000000.0], N[(y * -0.5), $MachinePrecision], If[LessEqual[y, 1.05], N[(0.918938533204673 - x), $MachinePrecision], If[LessEqual[y, 1.4e+73], N[(x * y), $MachinePrecision], N[(y * -0.5), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -8 \cdot 10^{+198}:\\
\;\;\;\;x \cdot y\\
\mathbf{elif}\;y \leq -520000000000:\\
\;\;\;\;y \cdot -0.5\\
\mathbf{elif}\;y \leq 1.05:\\
\;\;\;\;0.918938533204673 - x\\
\mathbf{elif}\;y \leq 1.4 \cdot 10^{+73}:\\
\;\;\;\;x \cdot y\\
\mathbf{else}:\\
\;\;\;\;y \cdot -0.5\\
\end{array}
\end{array}
if y < -8.00000000000000014e198 or 1.05000000000000004 < y < 1.40000000000000004e73Initial program 100.0%
+-commutative100.0%
cancel-sign-sub-inv100.0%
+-commutative100.0%
associate-+r+100.0%
cancel-sign-sub-inv100.0%
associate-+l-100.0%
sub-neg100.0%
distribute-rgt-in100.0%
metadata-eval100.0%
neg-mul-1100.0%
associate--r+100.0%
distribute-lft-out--100.0%
unsub-neg100.0%
fma-neg100.0%
unsub-neg100.0%
remove-double-neg100.0%
Simplified100.0%
Taylor expanded in y around inf 99.6%
Taylor expanded in x around inf 65.3%
*-commutative65.3%
Simplified65.3%
if -8.00000000000000014e198 < y < -5.2e11 or 1.40000000000000004e73 < y Initial program 100.0%
+-commutative100.0%
cancel-sign-sub-inv100.0%
+-commutative100.0%
associate-+r+100.0%
cancel-sign-sub-inv100.0%
associate-+l-100.0%
sub-neg100.0%
distribute-rgt-in100.0%
metadata-eval100.0%
neg-mul-1100.0%
associate--r+100.0%
distribute-lft-out--99.9%
unsub-neg99.9%
fma-neg99.9%
unsub-neg99.9%
remove-double-neg99.9%
Simplified99.9%
Taylor expanded in y around inf 99.9%
Taylor expanded in y around inf 99.9%
Taylor expanded in x around 0 58.4%
if -5.2e11 < y < 1.05000000000000004Initial program 100.0%
+-commutative100.0%
cancel-sign-sub-inv100.0%
+-commutative100.0%
associate-+r+100.0%
cancel-sign-sub-inv100.0%
associate-+l-100.0%
sub-neg100.0%
distribute-rgt-in100.0%
metadata-eval100.0%
neg-mul-1100.0%
associate--r+100.0%
distribute-lft-out--100.0%
unsub-neg100.0%
fma-neg100.0%
unsub-neg100.0%
remove-double-neg100.0%
Simplified100.0%
Taylor expanded in y around 0 98.2%
Final simplification77.5%
(FPCore (x y) :precision binary64 (if (or (<= y -520000000000.0) (not (<= y 54000.0))) (* y (- x 0.5)) (+ 0.918938533204673 (* x (+ y -1.0)))))
double code(double x, double y) {
double tmp;
if ((y <= -520000000000.0) || !(y <= 54000.0)) {
tmp = y * (x - 0.5);
} else {
tmp = 0.918938533204673 + (x * (y + -1.0));
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if ((y <= (-520000000000.0d0)) .or. (.not. (y <= 54000.0d0))) then
tmp = y * (x - 0.5d0)
else
tmp = 0.918938533204673d0 + (x * (y + (-1.0d0)))
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if ((y <= -520000000000.0) || !(y <= 54000.0)) {
tmp = y * (x - 0.5);
} else {
tmp = 0.918938533204673 + (x * (y + -1.0));
}
return tmp;
}
def code(x, y): tmp = 0 if (y <= -520000000000.0) or not (y <= 54000.0): tmp = y * (x - 0.5) else: tmp = 0.918938533204673 + (x * (y + -1.0)) return tmp
function code(x, y) tmp = 0.0 if ((y <= -520000000000.0) || !(y <= 54000.0)) tmp = Float64(y * Float64(x - 0.5)); else tmp = Float64(0.918938533204673 + Float64(x * Float64(y + -1.0))); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if ((y <= -520000000000.0) || ~((y <= 54000.0))) tmp = y * (x - 0.5); else tmp = 0.918938533204673 + (x * (y + -1.0)); end tmp_2 = tmp; end
code[x_, y_] := If[Or[LessEqual[y, -520000000000.0], N[Not[LessEqual[y, 54000.0]], $MachinePrecision]], N[(y * N[(x - 0.5), $MachinePrecision]), $MachinePrecision], N[(0.918938533204673 + N[(x * N[(y + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -520000000000 \lor \neg \left(y \leq 54000\right):\\
\;\;\;\;y \cdot \left(x - 0.5\right)\\
\mathbf{else}:\\
\;\;\;\;0.918938533204673 + x \cdot \left(y + -1\right)\\
\end{array}
\end{array}
if y < -5.2e11 or 54000 < y Initial program 100.0%
+-commutative100.0%
cancel-sign-sub-inv100.0%
+-commutative100.0%
associate-+r+100.0%
cancel-sign-sub-inv100.0%
associate-+l-100.0%
sub-neg100.0%
distribute-rgt-in100.0%
metadata-eval100.0%
neg-mul-1100.0%
associate--r+100.0%
distribute-lft-out--99.9%
unsub-neg99.9%
fma-neg99.9%
unsub-neg99.9%
remove-double-neg99.9%
Simplified99.9%
Taylor expanded in y around inf 99.8%
Taylor expanded in y around inf 99.4%
if -5.2e11 < y < 54000Initial program 100.0%
+-commutative100.0%
cancel-sign-sub-inv100.0%
+-commutative100.0%
associate-+r+100.0%
cancel-sign-sub-inv100.0%
associate-+l-100.0%
sub-neg100.0%
distribute-rgt-in100.0%
metadata-eval100.0%
neg-mul-1100.0%
associate--r+100.0%
distribute-lft-out--100.0%
unsub-neg100.0%
fma-neg100.0%
unsub-neg100.0%
remove-double-neg100.0%
Simplified100.0%
Taylor expanded in x around inf 99.9%
neg-mul-199.9%
unsub-neg99.9%
Simplified99.9%
Final simplification99.6%
(FPCore (x y) :precision binary64 (if (or (<= y -520000000000.0) (not (<= y 0.05))) (+ 0.918938533204673 (* y (- x 0.5))) (+ 0.918938533204673 (* x (+ y -1.0)))))
double code(double x, double y) {
double tmp;
if ((y <= -520000000000.0) || !(y <= 0.05)) {
tmp = 0.918938533204673 + (y * (x - 0.5));
} else {
tmp = 0.918938533204673 + (x * (y + -1.0));
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if ((y <= (-520000000000.0d0)) .or. (.not. (y <= 0.05d0))) then
tmp = 0.918938533204673d0 + (y * (x - 0.5d0))
else
tmp = 0.918938533204673d0 + (x * (y + (-1.0d0)))
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if ((y <= -520000000000.0) || !(y <= 0.05)) {
tmp = 0.918938533204673 + (y * (x - 0.5));
} else {
tmp = 0.918938533204673 + (x * (y + -1.0));
}
return tmp;
}
def code(x, y): tmp = 0 if (y <= -520000000000.0) or not (y <= 0.05): tmp = 0.918938533204673 + (y * (x - 0.5)) else: tmp = 0.918938533204673 + (x * (y + -1.0)) return tmp
function code(x, y) tmp = 0.0 if ((y <= -520000000000.0) || !(y <= 0.05)) tmp = Float64(0.918938533204673 + Float64(y * Float64(x - 0.5))); else tmp = Float64(0.918938533204673 + Float64(x * Float64(y + -1.0))); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if ((y <= -520000000000.0) || ~((y <= 0.05))) tmp = 0.918938533204673 + (y * (x - 0.5)); else tmp = 0.918938533204673 + (x * (y + -1.0)); end tmp_2 = tmp; end
code[x_, y_] := If[Or[LessEqual[y, -520000000000.0], N[Not[LessEqual[y, 0.05]], $MachinePrecision]], N[(0.918938533204673 + N[(y * N[(x - 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.918938533204673 + N[(x * N[(y + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -520000000000 \lor \neg \left(y \leq 0.05\right):\\
\;\;\;\;0.918938533204673 + y \cdot \left(x - 0.5\right)\\
\mathbf{else}:\\
\;\;\;\;0.918938533204673 + x \cdot \left(y + -1\right)\\
\end{array}
\end{array}
if y < -5.2e11 or 0.050000000000000003 < y Initial program 100.0%
+-commutative100.0%
cancel-sign-sub-inv100.0%
+-commutative100.0%
associate-+r+100.0%
cancel-sign-sub-inv100.0%
associate-+l-100.0%
sub-neg100.0%
distribute-rgt-in100.0%
metadata-eval100.0%
neg-mul-1100.0%
associate--r+100.0%
distribute-lft-out--99.9%
unsub-neg99.9%
fma-neg99.9%
unsub-neg99.9%
remove-double-neg99.9%
Simplified99.9%
Taylor expanded in y around inf 99.8%
if -5.2e11 < y < 0.050000000000000003Initial program 100.0%
+-commutative100.0%
cancel-sign-sub-inv100.0%
+-commutative100.0%
associate-+r+100.0%
cancel-sign-sub-inv100.0%
associate-+l-100.0%
sub-neg100.0%
distribute-rgt-in100.0%
metadata-eval100.0%
neg-mul-1100.0%
associate--r+100.0%
distribute-lft-out--100.0%
unsub-neg100.0%
fma-neg100.0%
unsub-neg100.0%
remove-double-neg100.0%
Simplified100.0%
Taylor expanded in x around inf 99.9%
neg-mul-199.9%
unsub-neg99.9%
Simplified99.9%
Final simplification99.9%
(FPCore (x y) :precision binary64 (if (or (<= y -520000000000.0) (not (<= y 3.5))) (+ 0.918938533204673 (* y (- x 0.5))) (+ 0.918938533204673 (- (* x y) x))))
double code(double x, double y) {
double tmp;
if ((y <= -520000000000.0) || !(y <= 3.5)) {
tmp = 0.918938533204673 + (y * (x - 0.5));
} else {
tmp = 0.918938533204673 + ((x * y) - x);
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if ((y <= (-520000000000.0d0)) .or. (.not. (y <= 3.5d0))) then
tmp = 0.918938533204673d0 + (y * (x - 0.5d0))
else
tmp = 0.918938533204673d0 + ((x * y) - x)
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if ((y <= -520000000000.0) || !(y <= 3.5)) {
tmp = 0.918938533204673 + (y * (x - 0.5));
} else {
tmp = 0.918938533204673 + ((x * y) - x);
}
return tmp;
}
def code(x, y): tmp = 0 if (y <= -520000000000.0) or not (y <= 3.5): tmp = 0.918938533204673 + (y * (x - 0.5)) else: tmp = 0.918938533204673 + ((x * y) - x) return tmp
function code(x, y) tmp = 0.0 if ((y <= -520000000000.0) || !(y <= 3.5)) tmp = Float64(0.918938533204673 + Float64(y * Float64(x - 0.5))); else tmp = Float64(0.918938533204673 + Float64(Float64(x * y) - x)); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if ((y <= -520000000000.0) || ~((y <= 3.5))) tmp = 0.918938533204673 + (y * (x - 0.5)); else tmp = 0.918938533204673 + ((x * y) - x); end tmp_2 = tmp; end
code[x_, y_] := If[Or[LessEqual[y, -520000000000.0], N[Not[LessEqual[y, 3.5]], $MachinePrecision]], N[(0.918938533204673 + N[(y * N[(x - 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.918938533204673 + N[(N[(x * y), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -520000000000 \lor \neg \left(y \leq 3.5\right):\\
\;\;\;\;0.918938533204673 + y \cdot \left(x - 0.5\right)\\
\mathbf{else}:\\
\;\;\;\;0.918938533204673 + \left(x \cdot y - x\right)\\
\end{array}
\end{array}
if y < -5.2e11 or 3.5 < y Initial program 100.0%
+-commutative100.0%
cancel-sign-sub-inv100.0%
+-commutative100.0%
associate-+r+100.0%
cancel-sign-sub-inv100.0%
associate-+l-100.0%
sub-neg100.0%
distribute-rgt-in100.0%
metadata-eval100.0%
neg-mul-1100.0%
associate--r+100.0%
distribute-lft-out--99.9%
unsub-neg99.9%
fma-neg99.9%
unsub-neg99.9%
remove-double-neg99.9%
Simplified99.9%
Taylor expanded in y around inf 99.8%
if -5.2e11 < y < 3.5Initial program 100.0%
+-commutative100.0%
cancel-sign-sub-inv100.0%
+-commutative100.0%
associate-+r+100.0%
cancel-sign-sub-inv100.0%
associate-+l-100.0%
sub-neg100.0%
distribute-rgt-in100.0%
metadata-eval100.0%
neg-mul-1100.0%
associate--r+100.0%
distribute-lft-out--100.0%
unsub-neg100.0%
fma-neg100.0%
unsub-neg100.0%
remove-double-neg100.0%
Simplified100.0%
fma-udef100.0%
Applied egg-rr100.0%
Taylor expanded in x around inf 100.0%
mul-1-neg100.0%
distribute-lft-neg-out100.0%
*-commutative100.0%
Simplified100.0%
Final simplification99.9%
(FPCore (x y) :precision binary64 (+ 0.918938533204673 (- (* x (+ y -1.0)) (* y 0.5))))
double code(double x, double y) {
return 0.918938533204673 + ((x * (y + -1.0)) - (y * 0.5));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = 0.918938533204673d0 + ((x * (y + (-1.0d0))) - (y * 0.5d0))
end function
public static double code(double x, double y) {
return 0.918938533204673 + ((x * (y + -1.0)) - (y * 0.5));
}
def code(x, y): return 0.918938533204673 + ((x * (y + -1.0)) - (y * 0.5))
function code(x, y) return Float64(0.918938533204673 + Float64(Float64(x * Float64(y + -1.0)) - Float64(y * 0.5))) end
function tmp = code(x, y) tmp = 0.918938533204673 + ((x * (y + -1.0)) - (y * 0.5)); end
code[x_, y_] := N[(0.918938533204673 + N[(N[(x * N[(y + -1.0), $MachinePrecision]), $MachinePrecision] - N[(y * 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
0.918938533204673 + \left(x \cdot \left(y + -1\right) - y \cdot 0.5\right)
\end{array}
Initial program 100.0%
Final simplification100.0%
(FPCore (x y) :precision binary64 (if (or (<= y -1.35) (not (<= y 1.05))) (* y (- x 0.5)) (- 0.918938533204673 x)))
double code(double x, double y) {
double tmp;
if ((y <= -1.35) || !(y <= 1.05)) {
tmp = y * (x - 0.5);
} else {
tmp = 0.918938533204673 - x;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if ((y <= (-1.35d0)) .or. (.not. (y <= 1.05d0))) then
tmp = y * (x - 0.5d0)
else
tmp = 0.918938533204673d0 - x
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if ((y <= -1.35) || !(y <= 1.05)) {
tmp = y * (x - 0.5);
} else {
tmp = 0.918938533204673 - x;
}
return tmp;
}
def code(x, y): tmp = 0 if (y <= -1.35) or not (y <= 1.05): tmp = y * (x - 0.5) else: tmp = 0.918938533204673 - x return tmp
function code(x, y) tmp = 0.0 if ((y <= -1.35) || !(y <= 1.05)) tmp = Float64(y * Float64(x - 0.5)); else tmp = Float64(0.918938533204673 - x); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if ((y <= -1.35) || ~((y <= 1.05))) tmp = y * (x - 0.5); else tmp = 0.918938533204673 - x; end tmp_2 = tmp; end
code[x_, y_] := If[Or[LessEqual[y, -1.35], N[Not[LessEqual[y, 1.05]], $MachinePrecision]], N[(y * N[(x - 0.5), $MachinePrecision]), $MachinePrecision], N[(0.918938533204673 - x), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -1.35 \lor \neg \left(y \leq 1.05\right):\\
\;\;\;\;y \cdot \left(x - 0.5\right)\\
\mathbf{else}:\\
\;\;\;\;0.918938533204673 - x\\
\end{array}
\end{array}
if y < -1.3500000000000001 or 1.05000000000000004 < y Initial program 100.0%
+-commutative100.0%
cancel-sign-sub-inv100.0%
+-commutative100.0%
associate-+r+100.0%
cancel-sign-sub-inv100.0%
associate-+l-100.0%
sub-neg100.0%
distribute-rgt-in100.0%
metadata-eval100.0%
neg-mul-1100.0%
associate--r+100.0%
distribute-lft-out--99.9%
unsub-neg99.9%
fma-neg99.9%
unsub-neg99.9%
remove-double-neg99.9%
Simplified99.9%
Taylor expanded in y around inf 99.3%
Taylor expanded in y around inf 98.8%
if -1.3500000000000001 < y < 1.05000000000000004Initial program 100.0%
+-commutative100.0%
cancel-sign-sub-inv100.0%
+-commutative100.0%
associate-+r+100.0%
cancel-sign-sub-inv100.0%
associate-+l-100.0%
sub-neg100.0%
distribute-rgt-in100.0%
metadata-eval100.0%
neg-mul-1100.0%
associate--r+100.0%
distribute-lft-out--100.0%
unsub-neg100.0%
fma-neg100.0%
unsub-neg100.0%
remove-double-neg100.0%
Simplified100.0%
Taylor expanded in y around 0 99.8%
Final simplification99.2%
(FPCore (x y) :precision binary64 (+ 0.918938533204673 (- (* y (- x 0.5)) x)))
double code(double x, double y) {
return 0.918938533204673 + ((y * (x - 0.5)) - x);
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = 0.918938533204673d0 + ((y * (x - 0.5d0)) - x)
end function
public static double code(double x, double y) {
return 0.918938533204673 + ((y * (x - 0.5)) - x);
}
def code(x, y): return 0.918938533204673 + ((y * (x - 0.5)) - x)
function code(x, y) return Float64(0.918938533204673 + Float64(Float64(y * Float64(x - 0.5)) - x)) end
function tmp = code(x, y) tmp = 0.918938533204673 + ((y * (x - 0.5)) - x); end
code[x_, y_] := N[(0.918938533204673 + N[(N[(y * N[(x - 0.5), $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
0.918938533204673 + \left(y \cdot \left(x - 0.5\right) - x\right)
\end{array}
Initial program 100.0%
+-commutative100.0%
cancel-sign-sub-inv100.0%
+-commutative100.0%
associate-+r+100.0%
cancel-sign-sub-inv100.0%
associate-+l-100.0%
sub-neg100.0%
distribute-rgt-in100.0%
metadata-eval100.0%
neg-mul-1100.0%
associate--r+100.0%
distribute-lft-out--100.0%
unsub-neg100.0%
fma-neg100.0%
unsub-neg100.0%
remove-double-neg100.0%
Simplified100.0%
fma-udef100.0%
Applied egg-rr100.0%
Final simplification100.0%
(FPCore (x y) :precision binary64 (if (or (<= y -78000.0) (not (<= y 2.25e-14))) (* y -0.5) 0.918938533204673))
double code(double x, double y) {
double tmp;
if ((y <= -78000.0) || !(y <= 2.25e-14)) {
tmp = y * -0.5;
} else {
tmp = 0.918938533204673;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if ((y <= (-78000.0d0)) .or. (.not. (y <= 2.25d-14))) then
tmp = y * (-0.5d0)
else
tmp = 0.918938533204673d0
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if ((y <= -78000.0) || !(y <= 2.25e-14)) {
tmp = y * -0.5;
} else {
tmp = 0.918938533204673;
}
return tmp;
}
def code(x, y): tmp = 0 if (y <= -78000.0) or not (y <= 2.25e-14): tmp = y * -0.5 else: tmp = 0.918938533204673 return tmp
function code(x, y) tmp = 0.0 if ((y <= -78000.0) || !(y <= 2.25e-14)) tmp = Float64(y * -0.5); else tmp = 0.918938533204673; end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if ((y <= -78000.0) || ~((y <= 2.25e-14))) tmp = y * -0.5; else tmp = 0.918938533204673; end tmp_2 = tmp; end
code[x_, y_] := If[Or[LessEqual[y, -78000.0], N[Not[LessEqual[y, 2.25e-14]], $MachinePrecision]], N[(y * -0.5), $MachinePrecision], 0.918938533204673]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -78000 \lor \neg \left(y \leq 2.25 \cdot 10^{-14}\right):\\
\;\;\;\;y \cdot -0.5\\
\mathbf{else}:\\
\;\;\;\;0.918938533204673\\
\end{array}
\end{array}
if y < -78000 or 2.2499999999999999e-14 < y Initial program 100.0%
+-commutative100.0%
cancel-sign-sub-inv100.0%
+-commutative100.0%
associate-+r+100.0%
cancel-sign-sub-inv100.0%
associate-+l-100.0%
sub-neg100.0%
distribute-rgt-in100.0%
metadata-eval100.0%
neg-mul-1100.0%
associate--r+100.0%
distribute-lft-out--99.9%
unsub-neg99.9%
fma-neg99.9%
unsub-neg99.9%
remove-double-neg99.9%
Simplified99.9%
Taylor expanded in y around inf 99.0%
Taylor expanded in y around inf 98.5%
Taylor expanded in x around 0 50.6%
if -78000 < y < 2.2499999999999999e-14Initial program 100.0%
+-commutative100.0%
cancel-sign-sub-inv100.0%
+-commutative100.0%
associate-+r+100.0%
cancel-sign-sub-inv100.0%
associate-+l-100.0%
sub-neg100.0%
distribute-rgt-in100.0%
metadata-eval100.0%
neg-mul-1100.0%
associate--r+100.0%
distribute-lft-out--100.0%
unsub-neg100.0%
fma-neg100.0%
unsub-neg100.0%
remove-double-neg100.0%
Simplified100.0%
Taylor expanded in y around inf 47.8%
Taylor expanded in y around 0 47.2%
Final simplification49.1%
(FPCore (x y) :precision binary64 0.918938533204673)
double code(double x, double y) {
return 0.918938533204673;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = 0.918938533204673d0
end function
public static double code(double x, double y) {
return 0.918938533204673;
}
def code(x, y): return 0.918938533204673
function code(x, y) return 0.918938533204673 end
function tmp = code(x, y) tmp = 0.918938533204673; end
code[x_, y_] := 0.918938533204673
\begin{array}{l}
\\
0.918938533204673
\end{array}
Initial program 100.0%
+-commutative100.0%
cancel-sign-sub-inv100.0%
+-commutative100.0%
associate-+r+100.0%
cancel-sign-sub-inv100.0%
associate-+l-100.0%
sub-neg100.0%
distribute-rgt-in100.0%
metadata-eval100.0%
neg-mul-1100.0%
associate--r+100.0%
distribute-lft-out--100.0%
unsub-neg100.0%
fma-neg100.0%
unsub-neg100.0%
remove-double-neg100.0%
Simplified100.0%
Taylor expanded in y around inf 76.4%
Taylor expanded in y around 0 22.3%
Final simplification22.3%
herbie shell --seed 2023310
(FPCore (x y)
:name "Numeric.SpecFunctions:logGamma from math-functions-0.1.5.2, A"
:precision binary64
(+ (- (* x (- y 1.0)) (* y 0.5)) 0.918938533204673))