
(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 12 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 (+ 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 (<= y -0.06)
(* y -0.5)
(if (<= y -2.7e-180)
(- x)
(if (<= y -4.8e-279)
0.918938533204673
(if (<= y 7e-255)
(- x)
(if (<= y 2.8e-150)
0.918938533204673
(if (<= y 3.2e-17)
(- x)
(if (<= y 8.2e-5)
0.918938533204673
(if (<= y 0.46)
(- x)
(if (<= y 1.85e+208) (* y x) (* y -0.5)))))))))))
double code(double x, double y) {
double tmp;
if (y <= -0.06) {
tmp = y * -0.5;
} else if (y <= -2.7e-180) {
tmp = -x;
} else if (y <= -4.8e-279) {
tmp = 0.918938533204673;
} else if (y <= 7e-255) {
tmp = -x;
} else if (y <= 2.8e-150) {
tmp = 0.918938533204673;
} else if (y <= 3.2e-17) {
tmp = -x;
} else if (y <= 8.2e-5) {
tmp = 0.918938533204673;
} else if (y <= 0.46) {
tmp = -x;
} else if (y <= 1.85e+208) {
tmp = y * x;
} 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 <= (-0.06d0)) then
tmp = y * (-0.5d0)
else if (y <= (-2.7d-180)) then
tmp = -x
else if (y <= (-4.8d-279)) then
tmp = 0.918938533204673d0
else if (y <= 7d-255) then
tmp = -x
else if (y <= 2.8d-150) then
tmp = 0.918938533204673d0
else if (y <= 3.2d-17) then
tmp = -x
else if (y <= 8.2d-5) then
tmp = 0.918938533204673d0
else if (y <= 0.46d0) then
tmp = -x
else if (y <= 1.85d+208) then
tmp = y * x
else
tmp = y * (-0.5d0)
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (y <= -0.06) {
tmp = y * -0.5;
} else if (y <= -2.7e-180) {
tmp = -x;
} else if (y <= -4.8e-279) {
tmp = 0.918938533204673;
} else if (y <= 7e-255) {
tmp = -x;
} else if (y <= 2.8e-150) {
tmp = 0.918938533204673;
} else if (y <= 3.2e-17) {
tmp = -x;
} else if (y <= 8.2e-5) {
tmp = 0.918938533204673;
} else if (y <= 0.46) {
tmp = -x;
} else if (y <= 1.85e+208) {
tmp = y * x;
} else {
tmp = y * -0.5;
}
return tmp;
}
def code(x, y): tmp = 0 if y <= -0.06: tmp = y * -0.5 elif y <= -2.7e-180: tmp = -x elif y <= -4.8e-279: tmp = 0.918938533204673 elif y <= 7e-255: tmp = -x elif y <= 2.8e-150: tmp = 0.918938533204673 elif y <= 3.2e-17: tmp = -x elif y <= 8.2e-5: tmp = 0.918938533204673 elif y <= 0.46: tmp = -x elif y <= 1.85e+208: tmp = y * x else: tmp = y * -0.5 return tmp
function code(x, y) tmp = 0.0 if (y <= -0.06) tmp = Float64(y * -0.5); elseif (y <= -2.7e-180) tmp = Float64(-x); elseif (y <= -4.8e-279) tmp = 0.918938533204673; elseif (y <= 7e-255) tmp = Float64(-x); elseif (y <= 2.8e-150) tmp = 0.918938533204673; elseif (y <= 3.2e-17) tmp = Float64(-x); elseif (y <= 8.2e-5) tmp = 0.918938533204673; elseif (y <= 0.46) tmp = Float64(-x); elseif (y <= 1.85e+208) tmp = Float64(y * x); else tmp = Float64(y * -0.5); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (y <= -0.06) tmp = y * -0.5; elseif (y <= -2.7e-180) tmp = -x; elseif (y <= -4.8e-279) tmp = 0.918938533204673; elseif (y <= 7e-255) tmp = -x; elseif (y <= 2.8e-150) tmp = 0.918938533204673; elseif (y <= 3.2e-17) tmp = -x; elseif (y <= 8.2e-5) tmp = 0.918938533204673; elseif (y <= 0.46) tmp = -x; elseif (y <= 1.85e+208) tmp = y * x; else tmp = y * -0.5; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[y, -0.06], N[(y * -0.5), $MachinePrecision], If[LessEqual[y, -2.7e-180], (-x), If[LessEqual[y, -4.8e-279], 0.918938533204673, If[LessEqual[y, 7e-255], (-x), If[LessEqual[y, 2.8e-150], 0.918938533204673, If[LessEqual[y, 3.2e-17], (-x), If[LessEqual[y, 8.2e-5], 0.918938533204673, If[LessEqual[y, 0.46], (-x), If[LessEqual[y, 1.85e+208], N[(y * x), $MachinePrecision], N[(y * -0.5), $MachinePrecision]]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -0.06:\\
\;\;\;\;y \cdot -0.5\\
\mathbf{elif}\;y \leq -2.7 \cdot 10^{-180}:\\
\;\;\;\;-x\\
\mathbf{elif}\;y \leq -4.8 \cdot 10^{-279}:\\
\;\;\;\;0.918938533204673\\
\mathbf{elif}\;y \leq 7 \cdot 10^{-255}:\\
\;\;\;\;-x\\
\mathbf{elif}\;y \leq 2.8 \cdot 10^{-150}:\\
\;\;\;\;0.918938533204673\\
\mathbf{elif}\;y \leq 3.2 \cdot 10^{-17}:\\
\;\;\;\;-x\\
\mathbf{elif}\;y \leq 8.2 \cdot 10^{-5}:\\
\;\;\;\;0.918938533204673\\
\mathbf{elif}\;y \leq 0.46:\\
\;\;\;\;-x\\
\mathbf{elif}\;y \leq 1.85 \cdot 10^{+208}:\\
\;\;\;\;y \cdot x\\
\mathbf{else}:\\
\;\;\;\;y \cdot -0.5\\
\end{array}
\end{array}
if y < -0.059999999999999998 or 1.84999999999999994e208 < y Initial program 100.0%
associate-+l-100.0%
sub-neg100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in y around inf 98.6%
Taylor expanded in x around 0 58.0%
*-commutative58.0%
Simplified58.0%
if -0.059999999999999998 < y < -2.70000000000000014e-180 or -4.7999999999999998e-279 < y < 6.99999999999999958e-255 or 2.79999999999999996e-150 < y < 3.2000000000000002e-17 or 8.20000000000000009e-5 < y < 0.46000000000000002Initial 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.4%
mul-1-neg99.4%
unsub-neg99.4%
Simplified99.4%
Taylor expanded in x around inf 69.6%
Taylor expanded in y around 0 68.2%
mul-1-neg68.2%
Simplified68.2%
if -2.70000000000000014e-180 < y < -4.7999999999999998e-279 or 6.99999999999999958e-255 < y < 2.79999999999999996e-150 or 3.2000000000000002e-17 < y < 8.20000000000000009e-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%
Taylor expanded in x around inf 96.1%
mul-1-neg96.1%
unsub-neg96.1%
Simplified96.1%
Taylor expanded in x around 0 72.9%
if 0.46000000000000002 < y < 1.84999999999999994e208Initial program 100.0%
associate-+l-100.0%
sub-neg100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in y around inf 94.7%
Taylor expanded in x around inf 58.5%
*-commutative58.5%
Simplified58.5%
Final simplification63.9%
(FPCore (x y)
:precision binary64
(if (<= x -0.92)
(- x)
(if (<= x -6.2e-133)
(* y -0.5)
(if (<= x -7e-302) 0.918938533204673 (if (<= x 0.5) (* y -0.5) (- x))))))
double code(double x, double y) {
double tmp;
if (x <= -0.92) {
tmp = -x;
} else if (x <= -6.2e-133) {
tmp = y * -0.5;
} else if (x <= -7e-302) {
tmp = 0.918938533204673;
} else if (x <= 0.5) {
tmp = y * -0.5;
} else {
tmp = -x;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (x <= (-0.92d0)) then
tmp = -x
else if (x <= (-6.2d-133)) then
tmp = y * (-0.5d0)
else if (x <= (-7d-302)) then
tmp = 0.918938533204673d0
else if (x <= 0.5d0) then
tmp = y * (-0.5d0)
else
tmp = -x
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (x <= -0.92) {
tmp = -x;
} else if (x <= -6.2e-133) {
tmp = y * -0.5;
} else if (x <= -7e-302) {
tmp = 0.918938533204673;
} else if (x <= 0.5) {
tmp = y * -0.5;
} else {
tmp = -x;
}
return tmp;
}
def code(x, y): tmp = 0 if x <= -0.92: tmp = -x elif x <= -6.2e-133: tmp = y * -0.5 elif x <= -7e-302: tmp = 0.918938533204673 elif x <= 0.5: tmp = y * -0.5 else: tmp = -x return tmp
function code(x, y) tmp = 0.0 if (x <= -0.92) tmp = Float64(-x); elseif (x <= -6.2e-133) tmp = Float64(y * -0.5); elseif (x <= -7e-302) tmp = 0.918938533204673; elseif (x <= 0.5) tmp = Float64(y * -0.5); else tmp = Float64(-x); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (x <= -0.92) tmp = -x; elseif (x <= -6.2e-133) tmp = y * -0.5; elseif (x <= -7e-302) tmp = 0.918938533204673; elseif (x <= 0.5) tmp = y * -0.5; else tmp = -x; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[x, -0.92], (-x), If[LessEqual[x, -6.2e-133], N[(y * -0.5), $MachinePrecision], If[LessEqual[x, -7e-302], 0.918938533204673, If[LessEqual[x, 0.5], N[(y * -0.5), $MachinePrecision], (-x)]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -0.92:\\
\;\;\;\;-x\\
\mathbf{elif}\;x \leq -6.2 \cdot 10^{-133}:\\
\;\;\;\;y \cdot -0.5\\
\mathbf{elif}\;x \leq -7 \cdot 10^{-302}:\\
\;\;\;\;0.918938533204673\\
\mathbf{elif}\;x \leq 0.5:\\
\;\;\;\;y \cdot -0.5\\
\mathbf{else}:\\
\;\;\;\;-x\\
\end{array}
\end{array}
if x < -0.92000000000000004 or 0.5 < 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 x around inf 98.6%
mul-1-neg98.6%
unsub-neg98.6%
Simplified98.6%
Taylor expanded in x around inf 97.4%
Taylor expanded in y around 0 50.8%
mul-1-neg50.8%
Simplified50.8%
if -0.92000000000000004 < x < -6.20000000000000032e-133 or -7.0000000000000003e-302 < x < 0.5Initial program 100.0%
associate-+l-100.0%
sub-neg100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in y around inf 59.3%
Taylor expanded in x around 0 56.9%
*-commutative56.9%
Simplified56.9%
if -6.20000000000000032e-133 < x < -7.0000000000000003e-302Initial 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 63.9%
mul-1-neg63.9%
unsub-neg63.9%
Simplified63.9%
Taylor expanded in x around 0 63.6%
Final simplification54.7%
(FPCore (x y)
:precision binary64
(if (<= y -95000000000.0)
(* y -0.5)
(if (<= y 3.6e-5)
(- 0.918938533204673 x)
(if (<= y 1.9e+197) (* x (+ y -1.0)) (* y -0.5)))))
double code(double x, double y) {
double tmp;
if (y <= -95000000000.0) {
tmp = y * -0.5;
} else if (y <= 3.6e-5) {
tmp = 0.918938533204673 - x;
} else if (y <= 1.9e+197) {
tmp = x * (y + -1.0);
} 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 <= (-95000000000.0d0)) then
tmp = y * (-0.5d0)
else if (y <= 3.6d-5) then
tmp = 0.918938533204673d0 - x
else if (y <= 1.9d+197) then
tmp = x * (y + (-1.0d0))
else
tmp = y * (-0.5d0)
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (y <= -95000000000.0) {
tmp = y * -0.5;
} else if (y <= 3.6e-5) {
tmp = 0.918938533204673 - x;
} else if (y <= 1.9e+197) {
tmp = x * (y + -1.0);
} else {
tmp = y * -0.5;
}
return tmp;
}
def code(x, y): tmp = 0 if y <= -95000000000.0: tmp = y * -0.5 elif y <= 3.6e-5: tmp = 0.918938533204673 - x elif y <= 1.9e+197: tmp = x * (y + -1.0) else: tmp = y * -0.5 return tmp
function code(x, y) tmp = 0.0 if (y <= -95000000000.0) tmp = Float64(y * -0.5); elseif (y <= 3.6e-5) tmp = Float64(0.918938533204673 - x); elseif (y <= 1.9e+197) tmp = Float64(x * Float64(y + -1.0)); else tmp = Float64(y * -0.5); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (y <= -95000000000.0) tmp = y * -0.5; elseif (y <= 3.6e-5) tmp = 0.918938533204673 - x; elseif (y <= 1.9e+197) tmp = x * (y + -1.0); else tmp = y * -0.5; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[y, -95000000000.0], N[(y * -0.5), $MachinePrecision], If[LessEqual[y, 3.6e-5], N[(0.918938533204673 - x), $MachinePrecision], If[LessEqual[y, 1.9e+197], N[(x * N[(y + -1.0), $MachinePrecision]), $MachinePrecision], N[(y * -0.5), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -95000000000:\\
\;\;\;\;y \cdot -0.5\\
\mathbf{elif}\;y \leq 3.6 \cdot 10^{-5}:\\
\;\;\;\;0.918938533204673 - x\\
\mathbf{elif}\;y \leq 1.9 \cdot 10^{+197}:\\
\;\;\;\;x \cdot \left(y + -1\right)\\
\mathbf{else}:\\
\;\;\;\;y \cdot -0.5\\
\end{array}
\end{array}
if y < -9.5e10 or 1.9000000000000001e197 < y Initial program 100.0%
associate-+l-100.0%
sub-neg100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in y around inf 100.0%
Taylor expanded in x around 0 59.2%
*-commutative59.2%
Simplified59.2%
if -9.5e10 < y < 3.60000000000000009e-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%
Taylor expanded in y around 0 96.6%
if 3.60000000000000009e-5 < y < 1.9000000000000001e197Initial program 99.9%
+-commutative99.9%
cancel-sign-sub-inv99.9%
+-commutative99.9%
associate-+r+99.9%
cancel-sign-sub-inv99.9%
associate-+l-99.9%
sub-neg99.9%
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 x around inf 60.5%
mul-1-neg60.5%
unsub-neg60.5%
Simplified60.5%
Taylor expanded in x around inf 60.5%
Final simplification78.0%
(FPCore (x y)
:precision binary64
(if (<= y -95000000000.0)
(* y -0.5)
(if (<= y 1.05)
(- 0.918938533204673 x)
(if (<= y 3.6e+199) (* y x) (* y -0.5)))))
double code(double x, double y) {
double tmp;
if (y <= -95000000000.0) {
tmp = y * -0.5;
} else if (y <= 1.05) {
tmp = 0.918938533204673 - x;
} else if (y <= 3.6e+199) {
tmp = y * x;
} 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 <= (-95000000000.0d0)) then
tmp = y * (-0.5d0)
else if (y <= 1.05d0) then
tmp = 0.918938533204673d0 - x
else if (y <= 3.6d+199) then
tmp = y * x
else
tmp = y * (-0.5d0)
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (y <= -95000000000.0) {
tmp = y * -0.5;
} else if (y <= 1.05) {
tmp = 0.918938533204673 - x;
} else if (y <= 3.6e+199) {
tmp = y * x;
} else {
tmp = y * -0.5;
}
return tmp;
}
def code(x, y): tmp = 0 if y <= -95000000000.0: tmp = y * -0.5 elif y <= 1.05: tmp = 0.918938533204673 - x elif y <= 3.6e+199: tmp = y * x else: tmp = y * -0.5 return tmp
function code(x, y) tmp = 0.0 if (y <= -95000000000.0) tmp = Float64(y * -0.5); elseif (y <= 1.05) tmp = Float64(0.918938533204673 - x); elseif (y <= 3.6e+199) tmp = Float64(y * x); else tmp = Float64(y * -0.5); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (y <= -95000000000.0) tmp = y * -0.5; elseif (y <= 1.05) tmp = 0.918938533204673 - x; elseif (y <= 3.6e+199) tmp = y * x; else tmp = y * -0.5; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[y, -95000000000.0], N[(y * -0.5), $MachinePrecision], If[LessEqual[y, 1.05], N[(0.918938533204673 - x), $MachinePrecision], If[LessEqual[y, 3.6e+199], N[(y * x), $MachinePrecision], N[(y * -0.5), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y \leq -95000000000:\\
\;\;\;\;y \cdot -0.5\\
\mathbf{elif}\;y \leq 1.05:\\
\;\;\;\;0.918938533204673 - x\\
\mathbf{elif}\;y \leq 3.6 \cdot 10^{+199}:\\
\;\;\;\;y \cdot x\\
\mathbf{else}:\\
\;\;\;\;y \cdot -0.5\\
\end{array}
\end{array}
if y < -9.5e10 or 3.60000000000000001e199 < y Initial program 100.0%
associate-+l-100.0%
sub-neg100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in y around inf 100.0%
Taylor expanded in x around 0 59.2%
*-commutative59.2%
Simplified59.2%
if -9.5e10 < 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 95.5%
if 1.05000000000000004 < y < 3.60000000000000001e199Initial program 100.0%
associate-+l-100.0%
sub-neg100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in y around inf 96.6%
Taylor expanded in x around inf 59.5%
*-commutative59.5%
Simplified59.5%
Final simplification77.6%
(FPCore (x y) :precision binary64 (if (or (<= x -1.95e-6) (not (<= x 0.0028))) (+ 0.918938533204673 (* x (+ y -1.0))) (- 0.918938533204673 (* y 0.5))))
double code(double x, double y) {
double tmp;
if ((x <= -1.95e-6) || !(x <= 0.0028)) {
tmp = 0.918938533204673 + (x * (y + -1.0));
} else {
tmp = 0.918938533204673 - (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 ((x <= (-1.95d-6)) .or. (.not. (x <= 0.0028d0))) then
tmp = 0.918938533204673d0 + (x * (y + (-1.0d0)))
else
tmp = 0.918938533204673d0 - (y * 0.5d0)
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if ((x <= -1.95e-6) || !(x <= 0.0028)) {
tmp = 0.918938533204673 + (x * (y + -1.0));
} else {
tmp = 0.918938533204673 - (y * 0.5);
}
return tmp;
}
def code(x, y): tmp = 0 if (x <= -1.95e-6) or not (x <= 0.0028): tmp = 0.918938533204673 + (x * (y + -1.0)) else: tmp = 0.918938533204673 - (y * 0.5) return tmp
function code(x, y) tmp = 0.0 if ((x <= -1.95e-6) || !(x <= 0.0028)) tmp = Float64(0.918938533204673 + Float64(x * Float64(y + -1.0))); else tmp = Float64(0.918938533204673 - Float64(y * 0.5)); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if ((x <= -1.95e-6) || ~((x <= 0.0028))) tmp = 0.918938533204673 + (x * (y + -1.0)); else tmp = 0.918938533204673 - (y * 0.5); end tmp_2 = tmp; end
code[x_, y_] := If[Or[LessEqual[x, -1.95e-6], N[Not[LessEqual[x, 0.0028]], $MachinePrecision]], N[(0.918938533204673 + N[(x * N[(y + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.918938533204673 - N[(y * 0.5), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.95 \cdot 10^{-6} \lor \neg \left(x \leq 0.0028\right):\\
\;\;\;\;0.918938533204673 + x \cdot \left(y + -1\right)\\
\mathbf{else}:\\
\;\;\;\;0.918938533204673 - y \cdot 0.5\\
\end{array}
\end{array}
if x < -1.95e-6 or 0.00279999999999999997 < 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 x around inf 98.0%
mul-1-neg98.0%
unsub-neg98.0%
Simplified98.0%
if -1.95e-6 < x < 0.00279999999999999997Initial 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 0 98.8%
*-commutative98.8%
Simplified98.8%
Final simplification98.4%
(FPCore (x y)
:precision binary64
(if (<= x -5e-8)
(+ 0.918938533204673 (* x (+ y -1.0)))
(if (<= x 0.0028)
(- 0.918938533204673 (* y 0.5))
(- (+ 0.918938533204673 (* y x)) x))))
double code(double x, double y) {
double tmp;
if (x <= -5e-8) {
tmp = 0.918938533204673 + (x * (y + -1.0));
} else if (x <= 0.0028) {
tmp = 0.918938533204673 - (y * 0.5);
} else {
tmp = (0.918938533204673 + (y * x)) - x;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (x <= (-5d-8)) then
tmp = 0.918938533204673d0 + (x * (y + (-1.0d0)))
else if (x <= 0.0028d0) then
tmp = 0.918938533204673d0 - (y * 0.5d0)
else
tmp = (0.918938533204673d0 + (y * x)) - x
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (x <= -5e-8) {
tmp = 0.918938533204673 + (x * (y + -1.0));
} else if (x <= 0.0028) {
tmp = 0.918938533204673 - (y * 0.5);
} else {
tmp = (0.918938533204673 + (y * x)) - x;
}
return tmp;
}
def code(x, y): tmp = 0 if x <= -5e-8: tmp = 0.918938533204673 + (x * (y + -1.0)) elif x <= 0.0028: tmp = 0.918938533204673 - (y * 0.5) else: tmp = (0.918938533204673 + (y * x)) - x return tmp
function code(x, y) tmp = 0.0 if (x <= -5e-8) tmp = Float64(0.918938533204673 + Float64(x * Float64(y + -1.0))); elseif (x <= 0.0028) tmp = Float64(0.918938533204673 - Float64(y * 0.5)); else tmp = Float64(Float64(0.918938533204673 + Float64(y * x)) - x); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (x <= -5e-8) tmp = 0.918938533204673 + (x * (y + -1.0)); elseif (x <= 0.0028) tmp = 0.918938533204673 - (y * 0.5); else tmp = (0.918938533204673 + (y * x)) - x; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[x, -5e-8], N[(0.918938533204673 + N[(x * N[(y + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 0.0028], N[(0.918938533204673 - N[(y * 0.5), $MachinePrecision]), $MachinePrecision], N[(N[(0.918938533204673 + N[(y * x), $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -5 \cdot 10^{-8}:\\
\;\;\;\;0.918938533204673 + x \cdot \left(y + -1\right)\\
\mathbf{elif}\;x \leq 0.0028:\\
\;\;\;\;0.918938533204673 - y \cdot 0.5\\
\mathbf{else}:\\
\;\;\;\;\left(0.918938533204673 + y \cdot x\right) - x\\
\end{array}
\end{array}
if x < -4.9999999999999998e-8Initial 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 98.2%
mul-1-neg98.2%
unsub-neg98.2%
Simplified98.2%
if -4.9999999999999998e-8 < x < 0.00279999999999999997Initial 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 0 98.8%
*-commutative98.8%
Simplified98.8%
if 0.00279999999999999997 < x Initial program 99.9%
+-commutative99.9%
cancel-sign-sub-inv99.9%
+-commutative99.9%
associate-+r+99.9%
cancel-sign-sub-inv99.9%
associate-+l-99.9%
sub-neg99.9%
distribute-rgt-in99.9%
metadata-eval99.9%
neg-mul-199.9%
associate--r+99.9%
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 97.7%
mul-1-neg97.7%
unsub-neg97.7%
Simplified97.7%
Taylor expanded in y around 0 97.8%
Final simplification98.4%
(FPCore (x y) :precision binary64 (if (or (<= y -1.4) (not (<= y 1.06))) (* y (- x 0.5)) (- 0.918938533204673 x)))
double code(double x, double y) {
double tmp;
if ((y <= -1.4) || !(y <= 1.06)) {
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.4d0)) .or. (.not. (y <= 1.06d0))) 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.4) || !(y <= 1.06)) {
tmp = y * (x - 0.5);
} else {
tmp = 0.918938533204673 - x;
}
return tmp;
}
def code(x, y): tmp = 0 if (y <= -1.4) or not (y <= 1.06): tmp = y * (x - 0.5) else: tmp = 0.918938533204673 - x return tmp
function code(x, y) tmp = 0.0 if ((y <= -1.4) || !(y <= 1.06)) 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.4) || ~((y <= 1.06))) tmp = y * (x - 0.5); else tmp = 0.918938533204673 - x; end tmp_2 = tmp; end
code[x_, y_] := If[Or[LessEqual[y, -1.4], N[Not[LessEqual[y, 1.06]], $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.4 \lor \neg \left(y \leq 1.06\right):\\
\;\;\;\;y \cdot \left(x - 0.5\right)\\
\mathbf{else}:\\
\;\;\;\;0.918938533204673 - x\\
\end{array}
\end{array}
if y < -1.3999999999999999 or 1.0600000000000001 < y Initial program 100.0%
associate-+l-100.0%
sub-neg100.0%
metadata-eval100.0%
Simplified100.0%
Taylor expanded in y around inf 98.4%
if -1.3999999999999999 < y < 1.0600000000000001Initial 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 96.2%
Final simplification97.3%
(FPCore (x y) :precision binary64 (if (or (<= x -0.72) (not (<= x 0.5))) (* x (+ y -1.0)) (- 0.918938533204673 (* y 0.5))))
double code(double x, double y) {
double tmp;
if ((x <= -0.72) || !(x <= 0.5)) {
tmp = x * (y + -1.0);
} else {
tmp = 0.918938533204673 - (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 ((x <= (-0.72d0)) .or. (.not. (x <= 0.5d0))) then
tmp = x * (y + (-1.0d0))
else
tmp = 0.918938533204673d0 - (y * 0.5d0)
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if ((x <= -0.72) || !(x <= 0.5)) {
tmp = x * (y + -1.0);
} else {
tmp = 0.918938533204673 - (y * 0.5);
}
return tmp;
}
def code(x, y): tmp = 0 if (x <= -0.72) or not (x <= 0.5): tmp = x * (y + -1.0) else: tmp = 0.918938533204673 - (y * 0.5) return tmp
function code(x, y) tmp = 0.0 if ((x <= -0.72) || !(x <= 0.5)) tmp = Float64(x * Float64(y + -1.0)); else tmp = Float64(0.918938533204673 - Float64(y * 0.5)); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if ((x <= -0.72) || ~((x <= 0.5))) tmp = x * (y + -1.0); else tmp = 0.918938533204673 - (y * 0.5); end tmp_2 = tmp; end
code[x_, y_] := If[Or[LessEqual[x, -0.72], N[Not[LessEqual[x, 0.5]], $MachinePrecision]], N[(x * N[(y + -1.0), $MachinePrecision]), $MachinePrecision], N[(0.918938533204673 - N[(y * 0.5), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -0.72 \lor \neg \left(x \leq 0.5\right):\\
\;\;\;\;x \cdot \left(y + -1\right)\\
\mathbf{else}:\\
\;\;\;\;0.918938533204673 - y \cdot 0.5\\
\end{array}
\end{array}
if x < -0.71999999999999997 or 0.5 < 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 x around inf 98.6%
mul-1-neg98.6%
unsub-neg98.6%
Simplified98.6%
Taylor expanded in x around inf 97.4%
if -0.71999999999999997 < x < 0.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%
Taylor expanded in x around 0 97.8%
*-commutative97.8%
Simplified97.8%
Final simplification97.6%
(FPCore (x y) :precision binary64 (if (<= x -0.74) (* x (+ y -1.0)) (if (<= x 0.62) (- 0.918938533204673 (* y 0.5)) (- (* y x) x))))
double code(double x, double y) {
double tmp;
if (x <= -0.74) {
tmp = x * (y + -1.0);
} else if (x <= 0.62) {
tmp = 0.918938533204673 - (y * 0.5);
} else {
tmp = (y * x) - x;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (x <= (-0.74d0)) then
tmp = x * (y + (-1.0d0))
else if (x <= 0.62d0) then
tmp = 0.918938533204673d0 - (y * 0.5d0)
else
tmp = (y * x) - x
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if (x <= -0.74) {
tmp = x * (y + -1.0);
} else if (x <= 0.62) {
tmp = 0.918938533204673 - (y * 0.5);
} else {
tmp = (y * x) - x;
}
return tmp;
}
def code(x, y): tmp = 0 if x <= -0.74: tmp = x * (y + -1.0) elif x <= 0.62: tmp = 0.918938533204673 - (y * 0.5) else: tmp = (y * x) - x return tmp
function code(x, y) tmp = 0.0 if (x <= -0.74) tmp = Float64(x * Float64(y + -1.0)); elseif (x <= 0.62) tmp = Float64(0.918938533204673 - Float64(y * 0.5)); else tmp = Float64(Float64(y * x) - x); end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if (x <= -0.74) tmp = x * (y + -1.0); elseif (x <= 0.62) tmp = 0.918938533204673 - (y * 0.5); else tmp = (y * x) - x; end tmp_2 = tmp; end
code[x_, y_] := If[LessEqual[x, -0.74], N[(x * N[(y + -1.0), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, 0.62], N[(0.918938533204673 - N[(y * 0.5), $MachinePrecision]), $MachinePrecision], N[(N[(y * x), $MachinePrecision] - x), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -0.74:\\
\;\;\;\;x \cdot \left(y + -1\right)\\
\mathbf{elif}\;x \leq 0.62:\\
\;\;\;\;0.918938533204673 - y \cdot 0.5\\
\mathbf{else}:\\
\;\;\;\;y \cdot x - x\\
\end{array}
\end{array}
if x < -0.73999999999999999Initial 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.4%
mul-1-neg99.4%
unsub-neg99.4%
Simplified99.4%
Taylor expanded in x around inf 98.5%
if -0.73999999999999999 < x < 0.619999999999999996Initial 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 0 97.8%
*-commutative97.8%
Simplified97.8%
if 0.619999999999999996 < x Initial program 99.9%
+-commutative99.9%
cancel-sign-sub-inv99.9%
+-commutative99.9%
associate-+r+99.9%
cancel-sign-sub-inv99.9%
associate-+l-99.9%
sub-neg99.9%
distribute-rgt-in99.9%
metadata-eval99.9%
neg-mul-199.9%
associate--r+99.9%
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 97.7%
mul-1-neg97.7%
unsub-neg97.7%
Simplified97.7%
Taylor expanded in y around 0 97.8%
Taylor expanded in x around inf 96.2%
Final simplification97.6%
(FPCore (x y) :precision binary64 (if (or (<= x -0.0065) (not (<= x 0.0027))) (- x) 0.918938533204673))
double code(double x, double y) {
double tmp;
if ((x <= -0.0065) || !(x <= 0.0027)) {
tmp = -x;
} 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 ((x <= (-0.0065d0)) .or. (.not. (x <= 0.0027d0))) then
tmp = -x
else
tmp = 0.918938533204673d0
end if
code = tmp
end function
public static double code(double x, double y) {
double tmp;
if ((x <= -0.0065) || !(x <= 0.0027)) {
tmp = -x;
} else {
tmp = 0.918938533204673;
}
return tmp;
}
def code(x, y): tmp = 0 if (x <= -0.0065) or not (x <= 0.0027): tmp = -x else: tmp = 0.918938533204673 return tmp
function code(x, y) tmp = 0.0 if ((x <= -0.0065) || !(x <= 0.0027)) tmp = Float64(-x); else tmp = 0.918938533204673; end return tmp end
function tmp_2 = code(x, y) tmp = 0.0; if ((x <= -0.0065) || ~((x <= 0.0027))) tmp = -x; else tmp = 0.918938533204673; end tmp_2 = tmp; end
code[x_, y_] := If[Or[LessEqual[x, -0.0065], N[Not[LessEqual[x, 0.0027]], $MachinePrecision]], (-x), 0.918938533204673]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;x \leq -0.0065 \lor \neg \left(x \leq 0.0027\right):\\
\;\;\;\;-x\\
\mathbf{else}:\\
\;\;\;\;0.918938533204673\\
\end{array}
\end{array}
if x < -0.0064999999999999997 or 0.0027000000000000001 < 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 x around inf 97.2%
mul-1-neg97.2%
unsub-neg97.2%
Simplified97.2%
Taylor expanded in x around inf 96.1%
Taylor expanded in y around 0 50.1%
mul-1-neg50.1%
Simplified50.1%
if -0.0064999999999999997 < x < 0.0027000000000000001Initial 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 47.7%
mul-1-neg47.7%
unsub-neg47.7%
Simplified47.7%
Taylor expanded in x around 0 46.9%
Final simplification48.6%
(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 x around inf 73.4%
mul-1-neg73.4%
unsub-neg73.4%
Simplified73.4%
Taylor expanded in x around 0 23.9%
Final simplification23.9%
herbie shell --seed 2024018
(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))