
(FPCore (x y) :precision binary64 (- (pow x 4.0) (pow y 4.0)))
double code(double x, double y) {
return pow(x, 4.0) - pow(y, 4.0);
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = (x ** 4.0d0) - (y ** 4.0d0)
end function
public static double code(double x, double y) {
return Math.pow(x, 4.0) - Math.pow(y, 4.0);
}
def code(x, y): return math.pow(x, 4.0) - math.pow(y, 4.0)
function code(x, y) return Float64((x ^ 4.0) - (y ^ 4.0)) end
function tmp = code(x, y) tmp = (x ^ 4.0) - (y ^ 4.0); end
code[x_, y_] := N[(N[Power[x, 4.0], $MachinePrecision] - N[Power[y, 4.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
{x}^{4} - {y}^{4}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 11 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y) :precision binary64 (- (pow x 4.0) (pow y 4.0)))
double code(double x, double y) {
return pow(x, 4.0) - pow(y, 4.0);
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = (x ** 4.0d0) - (y ** 4.0d0)
end function
public static double code(double x, double y) {
return Math.pow(x, 4.0) - Math.pow(y, 4.0);
}
def code(x, y): return math.pow(x, 4.0) - math.pow(y, 4.0)
function code(x, y) return Float64((x ^ 4.0) - (y ^ 4.0)) end
function tmp = code(x, y) tmp = (x ^ 4.0) - (y ^ 4.0); end
code[x_, y_] := N[(N[Power[x, 4.0], $MachinePrecision] - N[Power[y, 4.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
{x}^{4} - {y}^{4}
\end{array}
(FPCore (x y)
:precision binary64
(let* ((t_0 (/ 1.0 (+ x y))))
(if (<= y -8.6e-42)
(/ 1.0 (/ (/ t_0 (- x y)) (* y y)))
(if (<= y 1.5e+24)
(- (* x (* x (* x x))) (* y (* y (* y y))))
(* (* y y) (/ (- x y) t_0))))))
double code(double x, double y) {
double t_0 = 1.0 / (x + y);
double tmp;
if (y <= -8.6e-42) {
tmp = 1.0 / ((t_0 / (x - y)) / (y * y));
} else if (y <= 1.5e+24) {
tmp = (x * (x * (x * x))) - (y * (y * (y * y)));
} else {
tmp = (y * y) * ((x - y) / t_0);
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: t_0
real(8) :: tmp
t_0 = 1.0d0 / (x + y)
if (y <= (-8.6d-42)) then
tmp = 1.0d0 / ((t_0 / (x - y)) / (y * y))
else if (y <= 1.5d+24) then
tmp = (x * (x * (x * x))) - (y * (y * (y * y)))
else
tmp = (y * y) * ((x - y) / t_0)
end if
code = tmp
end function
public static double code(double x, double y) {
double t_0 = 1.0 / (x + y);
double tmp;
if (y <= -8.6e-42) {
tmp = 1.0 / ((t_0 / (x - y)) / (y * y));
} else if (y <= 1.5e+24) {
tmp = (x * (x * (x * x))) - (y * (y * (y * y)));
} else {
tmp = (y * y) * ((x - y) / t_0);
}
return tmp;
}
def code(x, y): t_0 = 1.0 / (x + y) tmp = 0 if y <= -8.6e-42: tmp = 1.0 / ((t_0 / (x - y)) / (y * y)) elif y <= 1.5e+24: tmp = (x * (x * (x * x))) - (y * (y * (y * y))) else: tmp = (y * y) * ((x - y) / t_0) return tmp
function code(x, y) t_0 = Float64(1.0 / Float64(x + y)) tmp = 0.0 if (y <= -8.6e-42) tmp = Float64(1.0 / Float64(Float64(t_0 / Float64(x - y)) / Float64(y * y))); elseif (y <= 1.5e+24) tmp = Float64(Float64(x * Float64(x * Float64(x * x))) - Float64(y * Float64(y * Float64(y * y)))); else tmp = Float64(Float64(y * y) * Float64(Float64(x - y) / t_0)); end return tmp end
function tmp_2 = code(x, y) t_0 = 1.0 / (x + y); tmp = 0.0; if (y <= -8.6e-42) tmp = 1.0 / ((t_0 / (x - y)) / (y * y)); elseif (y <= 1.5e+24) tmp = (x * (x * (x * x))) - (y * (y * (y * y))); else tmp = (y * y) * ((x - y) / t_0); end tmp_2 = tmp; end
code[x_, y_] := Block[{t$95$0 = N[(1.0 / N[(x + y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -8.6e-42], N[(1.0 / N[(N[(t$95$0 / N[(x - y), $MachinePrecision]), $MachinePrecision] / N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.5e+24], N[(N[(x * N[(x * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(y * N[(y * N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(y * y), $MachinePrecision] * N[(N[(x - y), $MachinePrecision] / t$95$0), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{1}{x + y}\\
\mathbf{if}\;y \leq -8.6 \cdot 10^{-42}:\\
\;\;\;\;\frac{1}{\frac{\frac{t\_0}{x - y}}{y \cdot y}}\\
\mathbf{elif}\;y \leq 1.5 \cdot 10^{+24}:\\
\;\;\;\;x \cdot \left(x \cdot \left(x \cdot x\right)\right) - y \cdot \left(y \cdot \left(y \cdot y\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(y \cdot y\right) \cdot \frac{x - y}{t\_0}\\
\end{array}
\end{array}
if y < -8.6000000000000002e-42Initial program 70.6%
sqr-powN/A
sqr-powN/A
difference-of-squaresN/A
metadata-evalN/A
unpow2N/A
fmm-defN/A
metadata-evalN/A
unpow2N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr86.5%
*-commutativeN/A
flip-+N/A
associate-*r*N/A
associate-*r*N/A
fmm-defN/A
*-commutativeN/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr40.1%
*-commutativeN/A
associate-*r/N/A
flip--N/A
associate-*r*N/A
associate-*r*N/A
clear-numN/A
associate-*r*N/A
associate-*r*N/A
flip-+N/A
Applied egg-rr99.9%
Taylor expanded in x around 0
unpow2N/A
*-lowering-*.f6499.9%
Simplified99.9%
if -8.6000000000000002e-42 < y < 1.49999999999999997e24Initial program 100.0%
--lowering--.f64N/A
sqr-powN/A
metadata-evalN/A
unpow2N/A
associate-*l*N/A
metadata-evalN/A
unpow2N/A
cube-unmultN/A
*-lowering-*.f64N/A
cube-unmultN/A
unpow2N/A
metadata-evalN/A
*-lowering-*.f64N/A
metadata-evalN/A
unpow2N/A
*-lowering-*.f64N/A
sqr-powN/A
metadata-evalN/A
unpow2N/A
associate-*l*N/A
metadata-evalN/A
unpow2N/A
cube-unmultN/A
*-lowering-*.f64N/A
cube-unmultN/A
unpow2N/A
metadata-evalN/A
Applied egg-rr99.8%
if 1.49999999999999997e24 < y Initial program 63.3%
sqr-powN/A
sqr-powN/A
difference-of-squaresN/A
metadata-evalN/A
unpow2N/A
fmm-defN/A
metadata-evalN/A
unpow2N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr79.9%
Taylor expanded in y around inf
unpow2N/A
*-lowering-*.f6479.9%
Simplified79.9%
difference-of-squaresN/A
*-commutativeN/A
/-rgt-identityN/A
associate-/r/N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6499.9%
Applied egg-rr99.9%
Final simplification99.8%
(FPCore (x y)
:precision binary64
(let* ((t_0 (* y (* y (- 0.0 (* y y)))))
(t_1 (* x (* x (* x x))))
(t_2 (* (* x x) (- (* x x) (* y y)))))
(if (<= x -3.1e+159)
t_1
(if (<= x -9.5e-79)
t_2
(if (<= x 2.6e-13)
t_0
(if (<= x 1.22e+173) t_2 (if (<= x 1.7e+200) t_0 t_1)))))))
double code(double x, double y) {
double t_0 = y * (y * (0.0 - (y * y)));
double t_1 = x * (x * (x * x));
double t_2 = (x * x) * ((x * x) - (y * y));
double tmp;
if (x <= -3.1e+159) {
tmp = t_1;
} else if (x <= -9.5e-79) {
tmp = t_2;
} else if (x <= 2.6e-13) {
tmp = t_0;
} else if (x <= 1.22e+173) {
tmp = t_2;
} else if (x <= 1.7e+200) {
tmp = t_0;
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: t_0
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_0 = y * (y * (0.0d0 - (y * y)))
t_1 = x * (x * (x * x))
t_2 = (x * x) * ((x * x) - (y * y))
if (x <= (-3.1d+159)) then
tmp = t_1
else if (x <= (-9.5d-79)) then
tmp = t_2
else if (x <= 2.6d-13) then
tmp = t_0
else if (x <= 1.22d+173) then
tmp = t_2
else if (x <= 1.7d+200) then
tmp = t_0
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y) {
double t_0 = y * (y * (0.0 - (y * y)));
double t_1 = x * (x * (x * x));
double t_2 = (x * x) * ((x * x) - (y * y));
double tmp;
if (x <= -3.1e+159) {
tmp = t_1;
} else if (x <= -9.5e-79) {
tmp = t_2;
} else if (x <= 2.6e-13) {
tmp = t_0;
} else if (x <= 1.22e+173) {
tmp = t_2;
} else if (x <= 1.7e+200) {
tmp = t_0;
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y): t_0 = y * (y * (0.0 - (y * y))) t_1 = x * (x * (x * x)) t_2 = (x * x) * ((x * x) - (y * y)) tmp = 0 if x <= -3.1e+159: tmp = t_1 elif x <= -9.5e-79: tmp = t_2 elif x <= 2.6e-13: tmp = t_0 elif x <= 1.22e+173: tmp = t_2 elif x <= 1.7e+200: tmp = t_0 else: tmp = t_1 return tmp
function code(x, y) t_0 = Float64(y * Float64(y * Float64(0.0 - Float64(y * y)))) t_1 = Float64(x * Float64(x * Float64(x * x))) t_2 = Float64(Float64(x * x) * Float64(Float64(x * x) - Float64(y * y))) tmp = 0.0 if (x <= -3.1e+159) tmp = t_1; elseif (x <= -9.5e-79) tmp = t_2; elseif (x <= 2.6e-13) tmp = t_0; elseif (x <= 1.22e+173) tmp = t_2; elseif (x <= 1.7e+200) tmp = t_0; else tmp = t_1; end return tmp end
function tmp_2 = code(x, y) t_0 = y * (y * (0.0 - (y * y))); t_1 = x * (x * (x * x)); t_2 = (x * x) * ((x * x) - (y * y)); tmp = 0.0; if (x <= -3.1e+159) tmp = t_1; elseif (x <= -9.5e-79) tmp = t_2; elseif (x <= 2.6e-13) tmp = t_0; elseif (x <= 1.22e+173) tmp = t_2; elseif (x <= 1.7e+200) tmp = t_0; else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_] := Block[{t$95$0 = N[(y * N[(y * N[(0.0 - N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(x * N[(x * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(x * x), $MachinePrecision] * N[(N[(x * x), $MachinePrecision] - N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -3.1e+159], t$95$1, If[LessEqual[x, -9.5e-79], t$95$2, If[LessEqual[x, 2.6e-13], t$95$0, If[LessEqual[x, 1.22e+173], t$95$2, If[LessEqual[x, 1.7e+200], t$95$0, t$95$1]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := y \cdot \left(y \cdot \left(0 - y \cdot y\right)\right)\\
t_1 := x \cdot \left(x \cdot \left(x \cdot x\right)\right)\\
t_2 := \left(x \cdot x\right) \cdot \left(x \cdot x - y \cdot y\right)\\
\mathbf{if}\;x \leq -3.1 \cdot 10^{+159}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;x \leq -9.5 \cdot 10^{-79}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x \leq 2.6 \cdot 10^{-13}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;x \leq 1.22 \cdot 10^{+173}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;x \leq 1.7 \cdot 10^{+200}:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if x < -3.0999999999999998e159 or 1.69999999999999985e200 < x Initial program 65.0%
sqr-powN/A
sqr-powN/A
difference-of-squaresN/A
metadata-evalN/A
unpow2N/A
fmm-defN/A
metadata-evalN/A
unpow2N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr76.7%
Taylor expanded in x around inf
metadata-evalN/A
pow-sqrN/A
+-lft-identityN/A
mul0-lftN/A
metadata-evalN/A
distribute-lft1-inN/A
associate-+r+N/A
+-commutativeN/A
unpow2N/A
associate-*l*N/A
+-commutativeN/A
associate-+r+N/A
distribute-lft1-inN/A
metadata-evalN/A
mul0-lftN/A
+-lft-identityN/A
unpow2N/A
cube-multN/A
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
Simplified95.0%
if -3.0999999999999998e159 < x < -9.4999999999999997e-79 or 2.6e-13 < x < 1.22e173Initial program 84.1%
sqr-powN/A
sqr-powN/A
difference-of-squaresN/A
metadata-evalN/A
unpow2N/A
fmm-defN/A
metadata-evalN/A
unpow2N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr99.7%
Taylor expanded in y around 0
unpow2N/A
*-lowering-*.f6491.2%
Simplified91.2%
if -9.4999999999999997e-79 < x < 2.6e-13 or 1.22e173 < x < 1.69999999999999985e200Initial program 93.5%
sqr-powN/A
sqr-powN/A
difference-of-squaresN/A
metadata-evalN/A
unpow2N/A
fmm-defN/A
metadata-evalN/A
unpow2N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr93.2%
*-commutativeN/A
flip-+N/A
associate-*r*N/A
associate-*r*N/A
fmm-defN/A
*-commutativeN/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr54.0%
Taylor expanded in y around inf
metadata-evalN/A
pow-sqrN/A
associate-*l*N/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f6492.7%
Simplified92.7%
Final simplification92.7%
(FPCore (x y)
:precision binary64
(let* ((t_0 (* y (* y (- 0.0 (* y y)))))
(t_1 (* (* y y) (- (* x x) (* y y)))))
(if (<= y -1.32e+154)
t_0
(if (<= y -3.4e-65)
t_1
(if (<= y 2e-46) (* x (* x (* x x))) (if (<= y 6.5e+136) t_1 t_0))))))
double code(double x, double y) {
double t_0 = y * (y * (0.0 - (y * y)));
double t_1 = (y * y) * ((x * x) - (y * y));
double tmp;
if (y <= -1.32e+154) {
tmp = t_0;
} else if (y <= -3.4e-65) {
tmp = t_1;
} else if (y <= 2e-46) {
tmp = x * (x * (x * x));
} else if (y <= 6.5e+136) {
tmp = t_1;
} else {
tmp = t_0;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = y * (y * (0.0d0 - (y * y)))
t_1 = (y * y) * ((x * x) - (y * y))
if (y <= (-1.32d+154)) then
tmp = t_0
else if (y <= (-3.4d-65)) then
tmp = t_1
else if (y <= 2d-46) then
tmp = x * (x * (x * x))
else if (y <= 6.5d+136) then
tmp = t_1
else
tmp = t_0
end if
code = tmp
end function
public static double code(double x, double y) {
double t_0 = y * (y * (0.0 - (y * y)));
double t_1 = (y * y) * ((x * x) - (y * y));
double tmp;
if (y <= -1.32e+154) {
tmp = t_0;
} else if (y <= -3.4e-65) {
tmp = t_1;
} else if (y <= 2e-46) {
tmp = x * (x * (x * x));
} else if (y <= 6.5e+136) {
tmp = t_1;
} else {
tmp = t_0;
}
return tmp;
}
def code(x, y): t_0 = y * (y * (0.0 - (y * y))) t_1 = (y * y) * ((x * x) - (y * y)) tmp = 0 if y <= -1.32e+154: tmp = t_0 elif y <= -3.4e-65: tmp = t_1 elif y <= 2e-46: tmp = x * (x * (x * x)) elif y <= 6.5e+136: tmp = t_1 else: tmp = t_0 return tmp
function code(x, y) t_0 = Float64(y * Float64(y * Float64(0.0 - Float64(y * y)))) t_1 = Float64(Float64(y * y) * Float64(Float64(x * x) - Float64(y * y))) tmp = 0.0 if (y <= -1.32e+154) tmp = t_0; elseif (y <= -3.4e-65) tmp = t_1; elseif (y <= 2e-46) tmp = Float64(x * Float64(x * Float64(x * x))); elseif (y <= 6.5e+136) tmp = t_1; else tmp = t_0; end return tmp end
function tmp_2 = code(x, y) t_0 = y * (y * (0.0 - (y * y))); t_1 = (y * y) * ((x * x) - (y * y)); tmp = 0.0; if (y <= -1.32e+154) tmp = t_0; elseif (y <= -3.4e-65) tmp = t_1; elseif (y <= 2e-46) tmp = x * (x * (x * x)); elseif (y <= 6.5e+136) tmp = t_1; else tmp = t_0; end tmp_2 = tmp; end
code[x_, y_] := Block[{t$95$0 = N[(y * N[(y * N[(0.0 - N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(y * y), $MachinePrecision] * N[(N[(x * x), $MachinePrecision] - N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.32e+154], t$95$0, If[LessEqual[y, -3.4e-65], t$95$1, If[LessEqual[y, 2e-46], N[(x * N[(x * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 6.5e+136], t$95$1, t$95$0]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := y \cdot \left(y \cdot \left(0 - y \cdot y\right)\right)\\
t_1 := \left(y \cdot y\right) \cdot \left(x \cdot x - y \cdot y\right)\\
\mathbf{if}\;y \leq -1.32 \cdot 10^{+154}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;y \leq -3.4 \cdot 10^{-65}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 2 \cdot 10^{-46}:\\
\;\;\;\;x \cdot \left(x \cdot \left(x \cdot x\right)\right)\\
\mathbf{elif}\;y \leq 6.5 \cdot 10^{+136}:\\
\;\;\;\;t\_1\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if y < -1.31999999999999998e154 or 6.4999999999999998e136 < y Initial program 50.0%
sqr-powN/A
sqr-powN/A
difference-of-squaresN/A
metadata-evalN/A
unpow2N/A
fmm-defN/A
metadata-evalN/A
unpow2N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr65.0%
*-commutativeN/A
flip-+N/A
associate-*r*N/A
associate-*r*N/A
fmm-defN/A
*-commutativeN/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr3.3%
Taylor expanded in y around inf
metadata-evalN/A
pow-sqrN/A
associate-*l*N/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f6481.7%
Simplified81.7%
if -1.31999999999999998e154 < y < -3.39999999999999987e-65 or 2.00000000000000005e-46 < y < 6.4999999999999998e136Initial program 86.2%
sqr-powN/A
sqr-powN/A
difference-of-squaresN/A
metadata-evalN/A
unpow2N/A
fmm-defN/A
metadata-evalN/A
unpow2N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr99.6%
Taylor expanded in y around inf
unpow2N/A
*-lowering-*.f6495.4%
Simplified95.4%
if -3.39999999999999987e-65 < y < 2.00000000000000005e-46Initial program 100.0%
sqr-powN/A
sqr-powN/A
difference-of-squaresN/A
metadata-evalN/A
unpow2N/A
fmm-defN/A
metadata-evalN/A
unpow2N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr99.7%
Taylor expanded in x around inf
metadata-evalN/A
pow-sqrN/A
+-lft-identityN/A
mul0-lftN/A
metadata-evalN/A
distribute-lft1-inN/A
associate-+r+N/A
+-commutativeN/A
unpow2N/A
associate-*l*N/A
+-commutativeN/A
associate-+r+N/A
distribute-lft1-inN/A
metadata-evalN/A
mul0-lftN/A
+-lft-identityN/A
unpow2N/A
cube-multN/A
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
Simplified98.0%
Final simplification93.3%
(FPCore (x y)
:precision binary64
(let* ((t_0 (* (* y y) (/ (- x y) (/ 1.0 (+ x y))))))
(if (<= y -3.2e-62)
t_0
(if (<= y 1.6e+24) (- (* x (* x (* x x))) (* y (* y (* y y)))) t_0))))
double code(double x, double y) {
double t_0 = (y * y) * ((x - y) / (1.0 / (x + y)));
double tmp;
if (y <= -3.2e-62) {
tmp = t_0;
} else if (y <= 1.6e+24) {
tmp = (x * (x * (x * x))) - (y * (y * (y * y)));
} else {
tmp = t_0;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: t_0
real(8) :: tmp
t_0 = (y * y) * ((x - y) / (1.0d0 / (x + y)))
if (y <= (-3.2d-62)) then
tmp = t_0
else if (y <= 1.6d+24) then
tmp = (x * (x * (x * x))) - (y * (y * (y * y)))
else
tmp = t_0
end if
code = tmp
end function
public static double code(double x, double y) {
double t_0 = (y * y) * ((x - y) / (1.0 / (x + y)));
double tmp;
if (y <= -3.2e-62) {
tmp = t_0;
} else if (y <= 1.6e+24) {
tmp = (x * (x * (x * x))) - (y * (y * (y * y)));
} else {
tmp = t_0;
}
return tmp;
}
def code(x, y): t_0 = (y * y) * ((x - y) / (1.0 / (x + y))) tmp = 0 if y <= -3.2e-62: tmp = t_0 elif y <= 1.6e+24: tmp = (x * (x * (x * x))) - (y * (y * (y * y))) else: tmp = t_0 return tmp
function code(x, y) t_0 = Float64(Float64(y * y) * Float64(Float64(x - y) / Float64(1.0 / Float64(x + y)))) tmp = 0.0 if (y <= -3.2e-62) tmp = t_0; elseif (y <= 1.6e+24) tmp = Float64(Float64(x * Float64(x * Float64(x * x))) - Float64(y * Float64(y * Float64(y * y)))); else tmp = t_0; end return tmp end
function tmp_2 = code(x, y) t_0 = (y * y) * ((x - y) / (1.0 / (x + y))); tmp = 0.0; if (y <= -3.2e-62) tmp = t_0; elseif (y <= 1.6e+24) tmp = (x * (x * (x * x))) - (y * (y * (y * y))); else tmp = t_0; end tmp_2 = tmp; end
code[x_, y_] := Block[{t$95$0 = N[(N[(y * y), $MachinePrecision] * N[(N[(x - y), $MachinePrecision] / N[(1.0 / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -3.2e-62], t$95$0, If[LessEqual[y, 1.6e+24], N[(N[(x * N[(x * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(y * N[(y * N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(y \cdot y\right) \cdot \frac{x - y}{\frac{1}{x + y}}\\
\mathbf{if}\;y \leq -3.2 \cdot 10^{-62}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;y \leq 1.6 \cdot 10^{+24}:\\
\;\;\;\;x \cdot \left(x \cdot \left(x \cdot x\right)\right) - y \cdot \left(y \cdot \left(y \cdot y\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if y < -3.20000000000000021e-62 or 1.5999999999999999e24 < y Initial program 68.2%
sqr-powN/A
sqr-powN/A
difference-of-squaresN/A
metadata-evalN/A
unpow2N/A
fmm-defN/A
metadata-evalN/A
unpow2N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr83.9%
Taylor expanded in y around inf
unpow2N/A
*-lowering-*.f6483.9%
Simplified83.9%
difference-of-squaresN/A
*-commutativeN/A
/-rgt-identityN/A
associate-/r/N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6499.9%
Applied egg-rr99.9%
if -3.20000000000000021e-62 < y < 1.5999999999999999e24Initial program 100.0%
--lowering--.f64N/A
sqr-powN/A
metadata-evalN/A
unpow2N/A
associate-*l*N/A
metadata-evalN/A
unpow2N/A
cube-unmultN/A
*-lowering-*.f64N/A
cube-unmultN/A
unpow2N/A
metadata-evalN/A
*-lowering-*.f64N/A
metadata-evalN/A
unpow2N/A
*-lowering-*.f64N/A
sqr-powN/A
metadata-evalN/A
unpow2N/A
associate-*l*N/A
metadata-evalN/A
unpow2N/A
cube-unmultN/A
*-lowering-*.f64N/A
cube-unmultN/A
unpow2N/A
metadata-evalN/A
Applied egg-rr99.8%
Final simplification99.8%
(FPCore (x y)
:precision binary64
(let* ((t_0 (/ 1.0 (+ x y))))
(if (<= y -7.2e-22)
(/ (* y y) (/ t_0 (- x y)))
(if (<= y 1e+41)
(* (- (* x x) (* y y)) (+ (* x x) (* y y)))
(* (* y y) (/ (- x y) t_0))))))
double code(double x, double y) {
double t_0 = 1.0 / (x + y);
double tmp;
if (y <= -7.2e-22) {
tmp = (y * y) / (t_0 / (x - y));
} else if (y <= 1e+41) {
tmp = ((x * x) - (y * y)) * ((x * x) + (y * y));
} else {
tmp = (y * y) * ((x - y) / t_0);
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: t_0
real(8) :: tmp
t_0 = 1.0d0 / (x + y)
if (y <= (-7.2d-22)) then
tmp = (y * y) / (t_0 / (x - y))
else if (y <= 1d+41) then
tmp = ((x * x) - (y * y)) * ((x * x) + (y * y))
else
tmp = (y * y) * ((x - y) / t_0)
end if
code = tmp
end function
public static double code(double x, double y) {
double t_0 = 1.0 / (x + y);
double tmp;
if (y <= -7.2e-22) {
tmp = (y * y) / (t_0 / (x - y));
} else if (y <= 1e+41) {
tmp = ((x * x) - (y * y)) * ((x * x) + (y * y));
} else {
tmp = (y * y) * ((x - y) / t_0);
}
return tmp;
}
def code(x, y): t_0 = 1.0 / (x + y) tmp = 0 if y <= -7.2e-22: tmp = (y * y) / (t_0 / (x - y)) elif y <= 1e+41: tmp = ((x * x) - (y * y)) * ((x * x) + (y * y)) else: tmp = (y * y) * ((x - y) / t_0) return tmp
function code(x, y) t_0 = Float64(1.0 / Float64(x + y)) tmp = 0.0 if (y <= -7.2e-22) tmp = Float64(Float64(y * y) / Float64(t_0 / Float64(x - y))); elseif (y <= 1e+41) tmp = Float64(Float64(Float64(x * x) - Float64(y * y)) * Float64(Float64(x * x) + Float64(y * y))); else tmp = Float64(Float64(y * y) * Float64(Float64(x - y) / t_0)); end return tmp end
function tmp_2 = code(x, y) t_0 = 1.0 / (x + y); tmp = 0.0; if (y <= -7.2e-22) tmp = (y * y) / (t_0 / (x - y)); elseif (y <= 1e+41) tmp = ((x * x) - (y * y)) * ((x * x) + (y * y)); else tmp = (y * y) * ((x - y) / t_0); end tmp_2 = tmp; end
code[x_, y_] := Block[{t$95$0 = N[(1.0 / N[(x + y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -7.2e-22], N[(N[(y * y), $MachinePrecision] / N[(t$95$0 / N[(x - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1e+41], N[(N[(N[(x * x), $MachinePrecision] - N[(y * y), $MachinePrecision]), $MachinePrecision] * N[(N[(x * x), $MachinePrecision] + N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(y * y), $MachinePrecision] * N[(N[(x - y), $MachinePrecision] / t$95$0), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{1}{x + y}\\
\mathbf{if}\;y \leq -7.2 \cdot 10^{-22}:\\
\;\;\;\;\frac{y \cdot y}{\frac{t\_0}{x - y}}\\
\mathbf{elif}\;y \leq 10^{+41}:\\
\;\;\;\;\left(x \cdot x - y \cdot y\right) \cdot \left(x \cdot x + y \cdot y\right)\\
\mathbf{else}:\\
\;\;\;\;\left(y \cdot y\right) \cdot \frac{x - y}{t\_0}\\
\end{array}
\end{array}
if y < -7.1999999999999996e-22Initial program 69.7%
sqr-powN/A
sqr-powN/A
difference-of-squaresN/A
metadata-evalN/A
unpow2N/A
fmm-defN/A
metadata-evalN/A
unpow2N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr86.1%
Taylor expanded in y around inf
unpow2N/A
*-lowering-*.f6486.1%
Simplified86.1%
*-commutativeN/A
difference-of-squaresN/A
remove-double-divN/A
associate-/r/N/A
un-div-invN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6499.9%
Applied egg-rr99.9%
if -7.1999999999999996e-22 < y < 1.00000000000000001e41Initial program 100.0%
sqr-powN/A
sqr-powN/A
difference-of-squaresN/A
metadata-evalN/A
unpow2N/A
fmm-defN/A
metadata-evalN/A
unpow2N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr99.7%
if 1.00000000000000001e41 < y Initial program 60.7%
sqr-powN/A
sqr-powN/A
difference-of-squaresN/A
metadata-evalN/A
unpow2N/A
fmm-defN/A
metadata-evalN/A
unpow2N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr78.5%
Taylor expanded in y around inf
unpow2N/A
*-lowering-*.f6478.5%
Simplified78.5%
difference-of-squaresN/A
*-commutativeN/A
/-rgt-identityN/A
associate-/r/N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6499.9%
Applied egg-rr99.9%
Final simplification99.8%
(FPCore (x y)
:precision binary64
(let* ((t_0 (/ 1.0 (+ x y))) (t_1 (/ t_0 (- x y))))
(if (<= y -3.2e-65)
(* (* y y) (/ (- x y) t_0))
(if (<= y 1.85e-48) (/ (* x x) t_1) (/ (* y y) t_1)))))
double code(double x, double y) {
double t_0 = 1.0 / (x + y);
double t_1 = t_0 / (x - y);
double tmp;
if (y <= -3.2e-65) {
tmp = (y * y) * ((x - y) / t_0);
} else if (y <= 1.85e-48) {
tmp = (x * x) / t_1;
} else {
tmp = (y * y) / t_1;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = 1.0d0 / (x + y)
t_1 = t_0 / (x - y)
if (y <= (-3.2d-65)) then
tmp = (y * y) * ((x - y) / t_0)
else if (y <= 1.85d-48) then
tmp = (x * x) / t_1
else
tmp = (y * y) / t_1
end if
code = tmp
end function
public static double code(double x, double y) {
double t_0 = 1.0 / (x + y);
double t_1 = t_0 / (x - y);
double tmp;
if (y <= -3.2e-65) {
tmp = (y * y) * ((x - y) / t_0);
} else if (y <= 1.85e-48) {
tmp = (x * x) / t_1;
} else {
tmp = (y * y) / t_1;
}
return tmp;
}
def code(x, y): t_0 = 1.0 / (x + y) t_1 = t_0 / (x - y) tmp = 0 if y <= -3.2e-65: tmp = (y * y) * ((x - y) / t_0) elif y <= 1.85e-48: tmp = (x * x) / t_1 else: tmp = (y * y) / t_1 return tmp
function code(x, y) t_0 = Float64(1.0 / Float64(x + y)) t_1 = Float64(t_0 / Float64(x - y)) tmp = 0.0 if (y <= -3.2e-65) tmp = Float64(Float64(y * y) * Float64(Float64(x - y) / t_0)); elseif (y <= 1.85e-48) tmp = Float64(Float64(x * x) / t_1); else tmp = Float64(Float64(y * y) / t_1); end return tmp end
function tmp_2 = code(x, y) t_0 = 1.0 / (x + y); t_1 = t_0 / (x - y); tmp = 0.0; if (y <= -3.2e-65) tmp = (y * y) * ((x - y) / t_0); elseif (y <= 1.85e-48) tmp = (x * x) / t_1; else tmp = (y * y) / t_1; end tmp_2 = tmp; end
code[x_, y_] := Block[{t$95$0 = N[(1.0 / N[(x + y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 / N[(x - y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -3.2e-65], N[(N[(y * y), $MachinePrecision] * N[(N[(x - y), $MachinePrecision] / t$95$0), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.85e-48], N[(N[(x * x), $MachinePrecision] / t$95$1), $MachinePrecision], N[(N[(y * y), $MachinePrecision] / t$95$1), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{1}{x + y}\\
t_1 := \frac{t\_0}{x - y}\\
\mathbf{if}\;y \leq -3.2 \cdot 10^{-65}:\\
\;\;\;\;\left(y \cdot y\right) \cdot \frac{x - y}{t\_0}\\
\mathbf{elif}\;y \leq 1.85 \cdot 10^{-48}:\\
\;\;\;\;\frac{x \cdot x}{t\_1}\\
\mathbf{else}:\\
\;\;\;\;\frac{y \cdot y}{t\_1}\\
\end{array}
\end{array}
if y < -3.1999999999999999e-65Initial program 72.2%
sqr-powN/A
sqr-powN/A
difference-of-squaresN/A
metadata-evalN/A
unpow2N/A
fmm-defN/A
metadata-evalN/A
unpow2N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr87.2%
Taylor expanded in y around inf
unpow2N/A
*-lowering-*.f6487.2%
Simplified87.2%
difference-of-squaresN/A
*-commutativeN/A
/-rgt-identityN/A
associate-/r/N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6499.8%
Applied egg-rr99.8%
if -3.1999999999999999e-65 < y < 1.8499999999999999e-48Initial program 100.0%
sqr-powN/A
sqr-powN/A
difference-of-squaresN/A
metadata-evalN/A
unpow2N/A
fmm-defN/A
metadata-evalN/A
unpow2N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr99.7%
Taylor expanded in y around 0
unpow2N/A
*-lowering-*.f6497.9%
Simplified97.9%
*-commutativeN/A
flip--N/A
associate-*r*N/A
associate-*r*N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
clear-numN/A
associate-*r*N/A
associate-*r*N/A
flip--N/A
difference-of-squaresN/A
Applied egg-rr98.0%
if 1.8499999999999999e-48 < y Initial program 70.7%
sqr-powN/A
sqr-powN/A
difference-of-squaresN/A
metadata-evalN/A
unpow2N/A
fmm-defN/A
metadata-evalN/A
unpow2N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr83.8%
Taylor expanded in y around inf
unpow2N/A
*-lowering-*.f6478.9%
Simplified78.9%
*-commutativeN/A
difference-of-squaresN/A
remove-double-divN/A
associate-/r/N/A
un-div-invN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
--lowering--.f6494.9%
Applied egg-rr94.9%
Final simplification97.6%
(FPCore (x y) :precision binary64 (let* ((t_0 (/ 1.0 (+ x y))) (t_1 (* (* y y) (/ (- x y) t_0)))) (if (<= y -6.1e-64) t_1 (if (<= y 1e-46) (/ (* x x) (/ t_0 (- x y))) t_1))))
double code(double x, double y) {
double t_0 = 1.0 / (x + y);
double t_1 = (y * y) * ((x - y) / t_0);
double tmp;
if (y <= -6.1e-64) {
tmp = t_1;
} else if (y <= 1e-46) {
tmp = (x * x) / (t_0 / (x - y));
} else {
tmp = t_1;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = 1.0d0 / (x + y)
t_1 = (y * y) * ((x - y) / t_0)
if (y <= (-6.1d-64)) then
tmp = t_1
else if (y <= 1d-46) then
tmp = (x * x) / (t_0 / (x - y))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y) {
double t_0 = 1.0 / (x + y);
double t_1 = (y * y) * ((x - y) / t_0);
double tmp;
if (y <= -6.1e-64) {
tmp = t_1;
} else if (y <= 1e-46) {
tmp = (x * x) / (t_0 / (x - y));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y): t_0 = 1.0 / (x + y) t_1 = (y * y) * ((x - y) / t_0) tmp = 0 if y <= -6.1e-64: tmp = t_1 elif y <= 1e-46: tmp = (x * x) / (t_0 / (x - y)) else: tmp = t_1 return tmp
function code(x, y) t_0 = Float64(1.0 / Float64(x + y)) t_1 = Float64(Float64(y * y) * Float64(Float64(x - y) / t_0)) tmp = 0.0 if (y <= -6.1e-64) tmp = t_1; elseif (y <= 1e-46) tmp = Float64(Float64(x * x) / Float64(t_0 / Float64(x - y))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y) t_0 = 1.0 / (x + y); t_1 = (y * y) * ((x - y) / t_0); tmp = 0.0; if (y <= -6.1e-64) tmp = t_1; elseif (y <= 1e-46) tmp = (x * x) / (t_0 / (x - y)); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_] := Block[{t$95$0 = N[(1.0 / N[(x + y), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(y * y), $MachinePrecision] * N[(N[(x - y), $MachinePrecision] / t$95$0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -6.1e-64], t$95$1, If[LessEqual[y, 1e-46], N[(N[(x * x), $MachinePrecision] / N[(t$95$0 / N[(x - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{1}{x + y}\\
t_1 := \left(y \cdot y\right) \cdot \frac{x - y}{t\_0}\\
\mathbf{if}\;y \leq -6.1 \cdot 10^{-64}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;y \leq 10^{-46}:\\
\;\;\;\;\frac{x \cdot x}{\frac{t\_0}{x - y}}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if y < -6.0999999999999996e-64 or 1.00000000000000002e-46 < y Initial program 71.4%
sqr-powN/A
sqr-powN/A
difference-of-squaresN/A
metadata-evalN/A
unpow2N/A
fmm-defN/A
metadata-evalN/A
unpow2N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr85.5%
Taylor expanded in y around inf
unpow2N/A
*-lowering-*.f6483.0%
Simplified83.0%
difference-of-squaresN/A
*-commutativeN/A
/-rgt-identityN/A
associate-/r/N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6497.3%
Applied egg-rr97.3%
if -6.0999999999999996e-64 < y < 1.00000000000000002e-46Initial program 100.0%
sqr-powN/A
sqr-powN/A
difference-of-squaresN/A
metadata-evalN/A
unpow2N/A
fmm-defN/A
metadata-evalN/A
unpow2N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr99.7%
Taylor expanded in y around 0
unpow2N/A
*-lowering-*.f6497.9%
Simplified97.9%
*-commutativeN/A
flip--N/A
associate-*r*N/A
associate-*r*N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
clear-numN/A
associate-*r*N/A
associate-*r*N/A
flip--N/A
difference-of-squaresN/A
Applied egg-rr98.0%
Final simplification97.6%
(FPCore (x y) :precision binary64 (let* ((t_0 (* (* y y) (/ (- x y) (/ 1.0 (+ x y)))))) (if (<= y -1.4e-62) t_0 (if (<= y 5e-48) (* x (* x (* x x))) t_0))))
double code(double x, double y) {
double t_0 = (y * y) * ((x - y) / (1.0 / (x + y)));
double tmp;
if (y <= -1.4e-62) {
tmp = t_0;
} else if (y <= 5e-48) {
tmp = x * (x * (x * x));
} else {
tmp = t_0;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: t_0
real(8) :: tmp
t_0 = (y * y) * ((x - y) / (1.0d0 / (x + y)))
if (y <= (-1.4d-62)) then
tmp = t_0
else if (y <= 5d-48) then
tmp = x * (x * (x * x))
else
tmp = t_0
end if
code = tmp
end function
public static double code(double x, double y) {
double t_0 = (y * y) * ((x - y) / (1.0 / (x + y)));
double tmp;
if (y <= -1.4e-62) {
tmp = t_0;
} else if (y <= 5e-48) {
tmp = x * (x * (x * x));
} else {
tmp = t_0;
}
return tmp;
}
def code(x, y): t_0 = (y * y) * ((x - y) / (1.0 / (x + y))) tmp = 0 if y <= -1.4e-62: tmp = t_0 elif y <= 5e-48: tmp = x * (x * (x * x)) else: tmp = t_0 return tmp
function code(x, y) t_0 = Float64(Float64(y * y) * Float64(Float64(x - y) / Float64(1.0 / Float64(x + y)))) tmp = 0.0 if (y <= -1.4e-62) tmp = t_0; elseif (y <= 5e-48) tmp = Float64(x * Float64(x * Float64(x * x))); else tmp = t_0; end return tmp end
function tmp_2 = code(x, y) t_0 = (y * y) * ((x - y) / (1.0 / (x + y))); tmp = 0.0; if (y <= -1.4e-62) tmp = t_0; elseif (y <= 5e-48) tmp = x * (x * (x * x)); else tmp = t_0; end tmp_2 = tmp; end
code[x_, y_] := Block[{t$95$0 = N[(N[(y * y), $MachinePrecision] * N[(N[(x - y), $MachinePrecision] / N[(1.0 / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -1.4e-62], t$95$0, If[LessEqual[y, 5e-48], N[(x * N[(x * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(y \cdot y\right) \cdot \frac{x - y}{\frac{1}{x + y}}\\
\mathbf{if}\;y \leq -1.4 \cdot 10^{-62}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;y \leq 5 \cdot 10^{-48}:\\
\;\;\;\;x \cdot \left(x \cdot \left(x \cdot x\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if y < -1.40000000000000001e-62 or 4.9999999999999999e-48 < y Initial program 71.4%
sqr-powN/A
sqr-powN/A
difference-of-squaresN/A
metadata-evalN/A
unpow2N/A
fmm-defN/A
metadata-evalN/A
unpow2N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr85.5%
Taylor expanded in y around inf
unpow2N/A
*-lowering-*.f6483.0%
Simplified83.0%
difference-of-squaresN/A
*-commutativeN/A
/-rgt-identityN/A
associate-/r/N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f6497.3%
Applied egg-rr97.3%
if -1.40000000000000001e-62 < y < 4.9999999999999999e-48Initial program 100.0%
sqr-powN/A
sqr-powN/A
difference-of-squaresN/A
metadata-evalN/A
unpow2N/A
fmm-defN/A
metadata-evalN/A
unpow2N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr99.7%
Taylor expanded in x around inf
metadata-evalN/A
pow-sqrN/A
+-lft-identityN/A
mul0-lftN/A
metadata-evalN/A
distribute-lft1-inN/A
associate-+r+N/A
+-commutativeN/A
unpow2N/A
associate-*l*N/A
+-commutativeN/A
associate-+r+N/A
distribute-lft1-inN/A
metadata-evalN/A
mul0-lftN/A
+-lft-identityN/A
unpow2N/A
cube-multN/A
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
Simplified98.0%
Final simplification97.6%
(FPCore (x y) :precision binary64 (let* ((t_0 (* y (* y (- 0.0 (* y y)))))) (if (<= y -8.6e-42) t_0 (if (<= y 2.1e+40) (* x (* x (* x x))) t_0))))
double code(double x, double y) {
double t_0 = y * (y * (0.0 - (y * y)));
double tmp;
if (y <= -8.6e-42) {
tmp = t_0;
} else if (y <= 2.1e+40) {
tmp = x * (x * (x * x));
} else {
tmp = t_0;
}
return tmp;
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: t_0
real(8) :: tmp
t_0 = y * (y * (0.0d0 - (y * y)))
if (y <= (-8.6d-42)) then
tmp = t_0
else if (y <= 2.1d+40) then
tmp = x * (x * (x * x))
else
tmp = t_0
end if
code = tmp
end function
public static double code(double x, double y) {
double t_0 = y * (y * (0.0 - (y * y)));
double tmp;
if (y <= -8.6e-42) {
tmp = t_0;
} else if (y <= 2.1e+40) {
tmp = x * (x * (x * x));
} else {
tmp = t_0;
}
return tmp;
}
def code(x, y): t_0 = y * (y * (0.0 - (y * y))) tmp = 0 if y <= -8.6e-42: tmp = t_0 elif y <= 2.1e+40: tmp = x * (x * (x * x)) else: tmp = t_0 return tmp
function code(x, y) t_0 = Float64(y * Float64(y * Float64(0.0 - Float64(y * y)))) tmp = 0.0 if (y <= -8.6e-42) tmp = t_0; elseif (y <= 2.1e+40) tmp = Float64(x * Float64(x * Float64(x * x))); else tmp = t_0; end return tmp end
function tmp_2 = code(x, y) t_0 = y * (y * (0.0 - (y * y))); tmp = 0.0; if (y <= -8.6e-42) tmp = t_0; elseif (y <= 2.1e+40) tmp = x * (x * (x * x)); else tmp = t_0; end tmp_2 = tmp; end
code[x_, y_] := Block[{t$95$0 = N[(y * N[(y * N[(0.0 - N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -8.6e-42], t$95$0, If[LessEqual[y, 2.1e+40], N[(x * N[(x * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := y \cdot \left(y \cdot \left(0 - y \cdot y\right)\right)\\
\mathbf{if}\;y \leq -8.6 \cdot 10^{-42}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;y \leq 2.1 \cdot 10^{+40}:\\
\;\;\;\;x \cdot \left(x \cdot \left(x \cdot x\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if y < -8.6000000000000002e-42 or 2.1000000000000001e40 < y Initial program 66.4%
sqr-powN/A
sqr-powN/A
difference-of-squaresN/A
metadata-evalN/A
unpow2N/A
fmm-defN/A
metadata-evalN/A
unpow2N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr83.0%
*-commutativeN/A
flip-+N/A
associate-*r*N/A
associate-*r*N/A
fmm-defN/A
*-commutativeN/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr32.5%
Taylor expanded in y around inf
metadata-evalN/A
pow-sqrN/A
associate-*l*N/A
unpow2N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f6475.9%
Simplified75.9%
if -8.6000000000000002e-42 < y < 2.1000000000000001e40Initial program 100.0%
sqr-powN/A
sqr-powN/A
difference-of-squaresN/A
metadata-evalN/A
unpow2N/A
fmm-defN/A
metadata-evalN/A
unpow2N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr99.7%
Taylor expanded in x around inf
metadata-evalN/A
pow-sqrN/A
+-lft-identityN/A
mul0-lftN/A
metadata-evalN/A
distribute-lft1-inN/A
associate-+r+N/A
+-commutativeN/A
unpow2N/A
associate-*l*N/A
+-commutativeN/A
associate-+r+N/A
distribute-lft1-inN/A
metadata-evalN/A
mul0-lftN/A
+-lft-identityN/A
unpow2N/A
cube-multN/A
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
Simplified90.2%
(FPCore (x y) :precision binary64 (/ (+ (* x x) (* y y)) (/ (/ 1.0 (+ x y)) (- x y))))
double code(double x, double y) {
return ((x * x) + (y * y)) / ((1.0 / (x + y)) / (x - y));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = ((x * x) + (y * y)) / ((1.0d0 / (x + y)) / (x - y))
end function
public static double code(double x, double y) {
return ((x * x) + (y * y)) / ((1.0 / (x + y)) / (x - y));
}
def code(x, y): return ((x * x) + (y * y)) / ((1.0 / (x + y)) / (x - y))
function code(x, y) return Float64(Float64(Float64(x * x) + Float64(y * y)) / Float64(Float64(1.0 / Float64(x + y)) / Float64(x - y))) end
function tmp = code(x, y) tmp = ((x * x) + (y * y)) / ((1.0 / (x + y)) / (x - y)); end
code[x_, y_] := N[(N[(N[(x * x), $MachinePrecision] + N[(y * y), $MachinePrecision]), $MachinePrecision] / N[(N[(1.0 / N[(x + y), $MachinePrecision]), $MachinePrecision] / N[(x - y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x \cdot x + y \cdot y}{\frac{\frac{1}{x + y}}{x - y}}
\end{array}
Initial program 83.6%
sqr-powN/A
sqr-powN/A
difference-of-squaresN/A
metadata-evalN/A
unpow2N/A
fmm-defN/A
metadata-evalN/A
unpow2N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr91.6%
*-commutativeN/A
flip-+N/A
associate-*r*N/A
associate-*r*N/A
fmm-defN/A
*-commutativeN/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr44.0%
associate-*l/N/A
associate-*r*N/A
associate-*r*N/A
flip-+N/A
+-commutativeN/A
flip--N/A
associate-*r*N/A
associate-*r*N/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
Applied egg-rr99.8%
(FPCore (x y) :precision binary64 (* x (* x (* x x))))
double code(double x, double y) {
return x * (x * (x * x));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = x * (x * (x * x))
end function
public static double code(double x, double y) {
return x * (x * (x * x));
}
def code(x, y): return x * (x * (x * x))
function code(x, y) return Float64(x * Float64(x * Float64(x * x))) end
function tmp = code(x, y) tmp = x * (x * (x * x)); end
code[x_, y_] := N[(x * N[(x * N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot \left(x \cdot \left(x \cdot x\right)\right)
\end{array}
Initial program 83.6%
sqr-powN/A
sqr-powN/A
difference-of-squaresN/A
metadata-evalN/A
unpow2N/A
fmm-defN/A
metadata-evalN/A
unpow2N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr91.6%
Taylor expanded in x around inf
metadata-evalN/A
pow-sqrN/A
+-lft-identityN/A
mul0-lftN/A
metadata-evalN/A
distribute-lft1-inN/A
associate-+r+N/A
+-commutativeN/A
unpow2N/A
associate-*l*N/A
+-commutativeN/A
associate-+r+N/A
distribute-lft1-inN/A
metadata-evalN/A
mul0-lftN/A
+-lft-identityN/A
unpow2N/A
cube-multN/A
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
Simplified58.3%
herbie shell --seed 2024150
(FPCore (x y)
:name "Radioactive exchange between two surfaces"
:precision binary64
(- (pow x 4.0) (pow y 4.0)))