
(FPCore (x y) :precision binary64 (/ (* x y) (* (* (+ x y) (+ x y)) (+ (+ x y) 1.0))))
double code(double x, double y) {
return (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0d0))
end function
public static double code(double x, double y) {
return (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0));
}
def code(x, y): return (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0))
function code(x, y) return Float64(Float64(x * y) / Float64(Float64(Float64(x + y) * Float64(x + y)) * Float64(Float64(x + y) + 1.0))) end
function tmp = code(x, y) tmp = (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0)); end
code[x_, y_] := N[(N[(x * y), $MachinePrecision] / N[(N[(N[(x + y), $MachinePrecision] * N[(x + y), $MachinePrecision]), $MachinePrecision] * N[(N[(x + y), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 19 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y) :precision binary64 (/ (* x y) (* (* (+ x y) (+ x y)) (+ (+ x y) 1.0))))
double code(double x, double y) {
return (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0d0))
end function
public static double code(double x, double y) {
return (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0));
}
def code(x, y): return (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0))
function code(x, y) return Float64(Float64(x * y) / Float64(Float64(Float64(x + y) * Float64(x + y)) * Float64(Float64(x + y) + 1.0))) end
function tmp = code(x, y) tmp = (x * y) / (((x + y) * (x + y)) * ((x + y) + 1.0)); end
code[x_, y_] := N[(N[(x * y), $MachinePrecision] / N[(N[(N[(x + y), $MachinePrecision] * N[(x + y), $MachinePrecision]), $MachinePrecision] * N[(N[(x + y), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{x \cdot y}{\left(\left(x + y\right) \cdot \left(x + y\right)\right) \cdot \left(\left(x + y\right) + 1\right)}
\end{array}
NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y) :precision binary64 (* (/ (/ x (+ x y)) (+ (+ 1.0 x) y)) (/ y (+ x y))))
assert(x < y);
double code(double x, double y) {
return ((x / (x + y)) / ((1.0 + x) + y)) * (y / (x + y));
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = ((x / (x + y)) / ((1.0d0 + x) + y)) * (y / (x + y))
end function
assert x < y;
public static double code(double x, double y) {
return ((x / (x + y)) / ((1.0 + x) + y)) * (y / (x + y));
}
[x, y] = sort([x, y]) def code(x, y): return ((x / (x + y)) / ((1.0 + x) + y)) * (y / (x + y))
x, y = sort([x, y]) function code(x, y) return Float64(Float64(Float64(x / Float64(x + y)) / Float64(Float64(1.0 + x) + y)) * Float64(y / Float64(x + y))) end
x, y = num2cell(sort([x, y])){:}
function tmp = code(x, y)
tmp = ((x / (x + y)) / ((1.0 + x) + y)) * (y / (x + y));
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := N[(N[(N[(x / N[(x + y), $MachinePrecision]), $MachinePrecision] / N[(N[(1.0 + x), $MachinePrecision] + y), $MachinePrecision]), $MachinePrecision] * N[(y / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\frac{\frac{x}{x + y}}{\left(1 + x\right) + y} \cdot \frac{y}{x + y}
\end{array}
Initial program 67.1%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
associate-*l/N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-/.f64N/A
lower-/.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
Applied rewrites99.8%
lift-*.f64N/A
lift-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
associate-*r/N/A
lift-/.f64N/A
associate-*r/N/A
*-commutativeN/A
associate-/r*N/A
*-commutativeN/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
+-commutativeN/A
lift-+.f64N/A
lower-/.f6499.8
lift-+.f64N/A
lift-+.f64N/A
+-commutativeN/A
Applied rewrites99.8%
Final simplification99.8%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y)
:precision binary64
(let* ((t_0 (+ (+ 1.0 x) y)))
(if (<= y -1.32e-256)
(* 1.0 (/ (/ y (+ 1.0 (+ x y))) (+ x y)))
(if (<= y 1.5e+146)
(* (/ (/ y (* t_0 (+ x y))) (+ x y)) x)
(* 1.0 (/ (/ x (+ x y)) t_0))))))assert(x < y);
double code(double x, double y) {
double t_0 = (1.0 + x) + y;
double tmp;
if (y <= -1.32e-256) {
tmp = 1.0 * ((y / (1.0 + (x + y))) / (x + y));
} else if (y <= 1.5e+146) {
tmp = ((y / (t_0 * (x + y))) / (x + y)) * x;
} else {
tmp = 1.0 * ((x / (x + y)) / t_0);
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
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 <= (-1.32d-256)) then
tmp = 1.0d0 * ((y / (1.0d0 + (x + y))) / (x + y))
else if (y <= 1.5d+146) then
tmp = ((y / (t_0 * (x + y))) / (x + y)) * x
else
tmp = 1.0d0 * ((x / (x + y)) / t_0)
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y) {
double t_0 = (1.0 + x) + y;
double tmp;
if (y <= -1.32e-256) {
tmp = 1.0 * ((y / (1.0 + (x + y))) / (x + y));
} else if (y <= 1.5e+146) {
tmp = ((y / (t_0 * (x + y))) / (x + y)) * x;
} else {
tmp = 1.0 * ((x / (x + y)) / t_0);
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y): t_0 = (1.0 + x) + y tmp = 0 if y <= -1.32e-256: tmp = 1.0 * ((y / (1.0 + (x + y))) / (x + y)) elif y <= 1.5e+146: tmp = ((y / (t_0 * (x + y))) / (x + y)) * x else: tmp = 1.0 * ((x / (x + y)) / t_0) return tmp
x, y = sort([x, y]) function code(x, y) t_0 = Float64(Float64(1.0 + x) + y) tmp = 0.0 if (y <= -1.32e-256) tmp = Float64(1.0 * Float64(Float64(y / Float64(1.0 + Float64(x + y))) / Float64(x + y))); elseif (y <= 1.5e+146) tmp = Float64(Float64(Float64(y / Float64(t_0 * Float64(x + y))) / Float64(x + y)) * x); else tmp = Float64(1.0 * Float64(Float64(x / Float64(x + y)) / t_0)); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y)
t_0 = (1.0 + x) + y;
tmp = 0.0;
if (y <= -1.32e-256)
tmp = 1.0 * ((y / (1.0 + (x + y))) / (x + y));
elseif (y <= 1.5e+146)
tmp = ((y / (t_0 * (x + y))) / (x + y)) * x;
else
tmp = 1.0 * ((x / (x + y)) / t_0);
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function.
code[x_, y_] := Block[{t$95$0 = N[(N[(1.0 + x), $MachinePrecision] + y), $MachinePrecision]}, If[LessEqual[y, -1.32e-256], N[(1.0 * N[(N[(y / N[(1.0 + N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.5e+146], N[(N[(N[(y / N[(t$95$0 * N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(x + y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], N[(1.0 * N[(N[(x / N[(x + y), $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
t_0 := \left(1 + x\right) + y\\
\mathbf{if}\;y \leq -1.32 \cdot 10^{-256}:\\
\;\;\;\;1 \cdot \frac{\frac{y}{1 + \left(x + y\right)}}{x + y}\\
\mathbf{elif}\;y \leq 1.5 \cdot 10^{+146}:\\
\;\;\;\;\frac{\frac{y}{t\_0 \cdot \left(x + y\right)}}{x + y} \cdot x\\
\mathbf{else}:\\
\;\;\;\;1 \cdot \frac{\frac{x}{x + y}}{t\_0}\\
\end{array}
\end{array}
if y < -1.32e-256Initial program 66.2%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
associate-*l/N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-/.f64N/A
lower-/.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
Applied rewrites99.8%
Taylor expanded in x around inf
Applied rewrites50.7%
if -1.32e-256 < y < 1.50000000000000001e146Initial program 68.9%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
associate-*l/N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-/.f64N/A
lower-/.f6499.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.9
Applied rewrites99.9%
lift-*.f64N/A
lift-/.f64N/A
associate-*l/N/A
lift-/.f64N/A
lift-/.f64N/A
associate-/r*N/A
lift-*.f64N/A
lift-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
Applied rewrites94.8%
lift-/.f64N/A
lift-/.f64N/A
associate-/l/N/A
lower-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-*.f64N/A
lift-+.f6494.8
Applied rewrites94.8%
if 1.50000000000000001e146 < y Initial program 63.8%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
associate-*l/N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-/.f64N/A
lower-/.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
Applied rewrites99.8%
lift-*.f64N/A
lift-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
associate-*r/N/A
lift-/.f64N/A
associate-*r/N/A
*-commutativeN/A
associate-/r*N/A
*-commutativeN/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
+-commutativeN/A
lift-+.f64N/A
lower-/.f6499.9
lift-+.f64N/A
lift-+.f64N/A
+-commutativeN/A
Applied rewrites99.9%
Taylor expanded in x around 0
Applied rewrites99.9%
Final simplification75.4%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y)
:precision binary64
(let* ((t_0 (+ 1.0 (+ x y))))
(if (<= x -1.35e+170)
(* 1.0 (/ (/ y t_0) (+ x y)))
(if (<= x -8e-8)
(* 1.0 (/ y (* t_0 (+ x y))))
(* (/ x (* (+ 1.0 y) (+ x y))) (/ y (+ x y)))))))assert(x < y);
double code(double x, double y) {
double t_0 = 1.0 + (x + y);
double tmp;
if (x <= -1.35e+170) {
tmp = 1.0 * ((y / t_0) / (x + y));
} else if (x <= -8e-8) {
tmp = 1.0 * (y / (t_0 * (x + y)));
} else {
tmp = (x / ((1.0 + y) * (x + y))) * (y / (x + y));
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
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 (x <= (-1.35d+170)) then
tmp = 1.0d0 * ((y / t_0) / (x + y))
else if (x <= (-8d-8)) then
tmp = 1.0d0 * (y / (t_0 * (x + y)))
else
tmp = (x / ((1.0d0 + y) * (x + y))) * (y / (x + y))
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y) {
double t_0 = 1.0 + (x + y);
double tmp;
if (x <= -1.35e+170) {
tmp = 1.0 * ((y / t_0) / (x + y));
} else if (x <= -8e-8) {
tmp = 1.0 * (y / (t_0 * (x + y)));
} else {
tmp = (x / ((1.0 + y) * (x + y))) * (y / (x + y));
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y): t_0 = 1.0 + (x + y) tmp = 0 if x <= -1.35e+170: tmp = 1.0 * ((y / t_0) / (x + y)) elif x <= -8e-8: tmp = 1.0 * (y / (t_0 * (x + y))) else: tmp = (x / ((1.0 + y) * (x + y))) * (y / (x + y)) return tmp
x, y = sort([x, y]) function code(x, y) t_0 = Float64(1.0 + Float64(x + y)) tmp = 0.0 if (x <= -1.35e+170) tmp = Float64(1.0 * Float64(Float64(y / t_0) / Float64(x + y))); elseif (x <= -8e-8) tmp = Float64(1.0 * Float64(y / Float64(t_0 * Float64(x + y)))); else tmp = Float64(Float64(x / Float64(Float64(1.0 + y) * Float64(x + y))) * Float64(y / Float64(x + y))); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y)
t_0 = 1.0 + (x + y);
tmp = 0.0;
if (x <= -1.35e+170)
tmp = 1.0 * ((y / t_0) / (x + y));
elseif (x <= -8e-8)
tmp = 1.0 * (y / (t_0 * (x + y)));
else
tmp = (x / ((1.0 + y) * (x + y))) * (y / (x + y));
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function.
code[x_, y_] := Block[{t$95$0 = N[(1.0 + N[(x + y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1.35e+170], N[(1.0 * N[(N[(y / t$95$0), $MachinePrecision] / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -8e-8], N[(1.0 * N[(y / N[(t$95$0 * N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / N[(N[(1.0 + y), $MachinePrecision] * N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(y / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
t_0 := 1 + \left(x + y\right)\\
\mathbf{if}\;x \leq -1.35 \cdot 10^{+170}:\\
\;\;\;\;1 \cdot \frac{\frac{y}{t\_0}}{x + y}\\
\mathbf{elif}\;x \leq -8 \cdot 10^{-8}:\\
\;\;\;\;1 \cdot \frac{y}{t\_0 \cdot \left(x + y\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{\left(1 + y\right) \cdot \left(x + y\right)} \cdot \frac{y}{x + y}\\
\end{array}
\end{array}
if x < -1.3500000000000001e170Initial program 68.8%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
associate-*l/N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-/.f64N/A
lower-/.f6499.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.9
Applied rewrites99.9%
Taylor expanded in x around inf
Applied rewrites86.0%
if -1.3500000000000001e170 < x < -8.0000000000000002e-8Initial program 62.7%
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-/.f6497.3
lift-+.f64N/A
+-commutativeN/A
Applied rewrites97.3%
Taylor expanded in x around inf
Applied rewrites87.1%
if -8.0000000000000002e-8 < x Initial program 67.6%
Taylor expanded in x around 0
lower-+.f6461.8
Applied rewrites61.8%
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
lift-+.f64N/A
lift-+.f64N/A
lift-*.f64N/A
associate-*l*N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
+-commutativeN/A
lift-+.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lift-+.f6484.5
Applied rewrites84.5%
Final simplification85.0%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y)
:precision binary64
(let* ((t_0 (+ 1.0 (+ x y))))
(if (<= x -1.35e+170)
(* 1.0 (/ (/ y t_0) (+ x y)))
(if (<= x -8e-8)
(* 1.0 (/ y (* t_0 (+ x y))))
(* (/ (/ y (* (+ 1.0 y) (+ x y))) (+ x y)) x)))))assert(x < y);
double code(double x, double y) {
double t_0 = 1.0 + (x + y);
double tmp;
if (x <= -1.35e+170) {
tmp = 1.0 * ((y / t_0) / (x + y));
} else if (x <= -8e-8) {
tmp = 1.0 * (y / (t_0 * (x + y)));
} else {
tmp = ((y / ((1.0 + y) * (x + y))) / (x + y)) * x;
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
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 (x <= (-1.35d+170)) then
tmp = 1.0d0 * ((y / t_0) / (x + y))
else if (x <= (-8d-8)) then
tmp = 1.0d0 * (y / (t_0 * (x + y)))
else
tmp = ((y / ((1.0d0 + y) * (x + y))) / (x + y)) * x
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y) {
double t_0 = 1.0 + (x + y);
double tmp;
if (x <= -1.35e+170) {
tmp = 1.0 * ((y / t_0) / (x + y));
} else if (x <= -8e-8) {
tmp = 1.0 * (y / (t_0 * (x + y)));
} else {
tmp = ((y / ((1.0 + y) * (x + y))) / (x + y)) * x;
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y): t_0 = 1.0 + (x + y) tmp = 0 if x <= -1.35e+170: tmp = 1.0 * ((y / t_0) / (x + y)) elif x <= -8e-8: tmp = 1.0 * (y / (t_0 * (x + y))) else: tmp = ((y / ((1.0 + y) * (x + y))) / (x + y)) * x return tmp
x, y = sort([x, y]) function code(x, y) t_0 = Float64(1.0 + Float64(x + y)) tmp = 0.0 if (x <= -1.35e+170) tmp = Float64(1.0 * Float64(Float64(y / t_0) / Float64(x + y))); elseif (x <= -8e-8) tmp = Float64(1.0 * Float64(y / Float64(t_0 * Float64(x + y)))); else tmp = Float64(Float64(Float64(y / Float64(Float64(1.0 + y) * Float64(x + y))) / Float64(x + y)) * x); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y)
t_0 = 1.0 + (x + y);
tmp = 0.0;
if (x <= -1.35e+170)
tmp = 1.0 * ((y / t_0) / (x + y));
elseif (x <= -8e-8)
tmp = 1.0 * (y / (t_0 * (x + y)));
else
tmp = ((y / ((1.0 + y) * (x + y))) / (x + y)) * x;
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function.
code[x_, y_] := Block[{t$95$0 = N[(1.0 + N[(x + y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[x, -1.35e+170], N[(1.0 * N[(N[(y / t$95$0), $MachinePrecision] / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -8e-8], N[(1.0 * N[(y / N[(t$95$0 * N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(y / N[(N[(1.0 + y), $MachinePrecision] * N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(x + y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
t_0 := 1 + \left(x + y\right)\\
\mathbf{if}\;x \leq -1.35 \cdot 10^{+170}:\\
\;\;\;\;1 \cdot \frac{\frac{y}{t\_0}}{x + y}\\
\mathbf{elif}\;x \leq -8 \cdot 10^{-8}:\\
\;\;\;\;1 \cdot \frac{y}{t\_0 \cdot \left(x + y\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{y}{\left(1 + y\right) \cdot \left(x + y\right)}}{x + y} \cdot x\\
\end{array}
\end{array}
if x < -1.3500000000000001e170Initial program 68.8%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
associate-*l/N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-/.f64N/A
lower-/.f6499.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.9
Applied rewrites99.9%
Taylor expanded in x around inf
Applied rewrites86.0%
if -1.3500000000000001e170 < x < -8.0000000000000002e-8Initial program 62.7%
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-/.f6497.3
lift-+.f64N/A
+-commutativeN/A
Applied rewrites97.3%
Taylor expanded in x around inf
Applied rewrites87.1%
if -8.0000000000000002e-8 < x Initial program 67.6%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
associate-*l/N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-/.f64N/A
lower-/.f6499.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.9
Applied rewrites99.9%
lift-*.f64N/A
lift-/.f64N/A
associate-*l/N/A
lift-/.f64N/A
lift-/.f64N/A
associate-/r*N/A
lift-*.f64N/A
lift-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f64N/A
Applied rewrites93.9%
lift-/.f64N/A
lift-/.f64N/A
associate-/l/N/A
lower-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-*.f64N/A
lift-+.f6493.7
Applied rewrites93.7%
Taylor expanded in x around 0
lower-+.f6488.3
Applied rewrites88.3%
Final simplification87.8%
NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y) :precision binary64 (if (<= y 1.5e+146) (* (/ x (* (+ 1.0 (+ x y)) (+ x y))) (/ y (+ x y))) (* 1.0 (/ (/ x (+ x y)) (+ (+ 1.0 x) y)))))
assert(x < y);
double code(double x, double y) {
double tmp;
if (y <= 1.5e+146) {
tmp = (x / ((1.0 + (x + y)) * (x + y))) * (y / (x + y));
} else {
tmp = 1.0 * ((x / (x + y)) / ((1.0 + x) + y));
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (y <= 1.5d+146) then
tmp = (x / ((1.0d0 + (x + y)) * (x + y))) * (y / (x + y))
else
tmp = 1.0d0 * ((x / (x + y)) / ((1.0d0 + x) + y))
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y) {
double tmp;
if (y <= 1.5e+146) {
tmp = (x / ((1.0 + (x + y)) * (x + y))) * (y / (x + y));
} else {
tmp = 1.0 * ((x / (x + y)) / ((1.0 + x) + y));
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y): tmp = 0 if y <= 1.5e+146: tmp = (x / ((1.0 + (x + y)) * (x + y))) * (y / (x + y)) else: tmp = 1.0 * ((x / (x + y)) / ((1.0 + x) + y)) return tmp
x, y = sort([x, y]) function code(x, y) tmp = 0.0 if (y <= 1.5e+146) tmp = Float64(Float64(x / Float64(Float64(1.0 + Float64(x + y)) * Float64(x + y))) * Float64(y / Float64(x + y))); else tmp = Float64(1.0 * Float64(Float64(x / Float64(x + y)) / Float64(Float64(1.0 + x) + y))); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y)
tmp = 0.0;
if (y <= 1.5e+146)
tmp = (x / ((1.0 + (x + y)) * (x + y))) * (y / (x + y));
else
tmp = 1.0 * ((x / (x + y)) / ((1.0 + x) + y));
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := If[LessEqual[y, 1.5e+146], N[(N[(x / N[(N[(1.0 + N[(x + y), $MachinePrecision]), $MachinePrecision] * N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(y / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 * N[(N[(x / N[(x + y), $MachinePrecision]), $MachinePrecision] / N[(N[(1.0 + x), $MachinePrecision] + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;y \leq 1.5 \cdot 10^{+146}:\\
\;\;\;\;\frac{x}{\left(1 + \left(x + y\right)\right) \cdot \left(x + y\right)} \cdot \frac{y}{x + y}\\
\mathbf{else}:\\
\;\;\;\;1 \cdot \frac{\frac{x}{x + y}}{\left(1 + x\right) + y}\\
\end{array}
\end{array}
if y < 1.50000000000000001e146Initial program 67.5%
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f6495.6
lift-+.f64N/A
+-commutativeN/A
lower-+.f6495.6
lift-+.f64N/A
+-commutativeN/A
lower-+.f6495.6
lift-+.f64N/A
+-commutativeN/A
lower-+.f6495.6
Applied rewrites95.6%
if 1.50000000000000001e146 < y Initial program 63.8%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
associate-*l/N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-/.f64N/A
lower-/.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
Applied rewrites99.8%
lift-*.f64N/A
lift-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
associate-*r/N/A
lift-/.f64N/A
associate-*r/N/A
*-commutativeN/A
associate-/r*N/A
*-commutativeN/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
+-commutativeN/A
lift-+.f64N/A
lower-/.f6499.9
lift-+.f64N/A
lift-+.f64N/A
+-commutativeN/A
Applied rewrites99.9%
Taylor expanded in x around 0
Applied rewrites99.9%
Final simplification96.1%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y)
:precision binary64
(let* ((t_0 (/ x (+ x y))))
(if (<= y 1.5e+146)
(* (/ y (* (+ 1.0 (+ x y)) (+ x y))) t_0)
(* 1.0 (/ t_0 (+ (+ 1.0 x) y))))))assert(x < y);
double code(double x, double y) {
double t_0 = x / (x + y);
double tmp;
if (y <= 1.5e+146) {
tmp = (y / ((1.0 + (x + y)) * (x + y))) * t_0;
} else {
tmp = 1.0 * (t_0 / ((1.0 + x) + y));
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
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 = x / (x + y)
if (y <= 1.5d+146) then
tmp = (y / ((1.0d0 + (x + y)) * (x + y))) * t_0
else
tmp = 1.0d0 * (t_0 / ((1.0d0 + x) + y))
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y) {
double t_0 = x / (x + y);
double tmp;
if (y <= 1.5e+146) {
tmp = (y / ((1.0 + (x + y)) * (x + y))) * t_0;
} else {
tmp = 1.0 * (t_0 / ((1.0 + x) + y));
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y): t_0 = x / (x + y) tmp = 0 if y <= 1.5e+146: tmp = (y / ((1.0 + (x + y)) * (x + y))) * t_0 else: tmp = 1.0 * (t_0 / ((1.0 + x) + y)) return tmp
x, y = sort([x, y]) function code(x, y) t_0 = Float64(x / Float64(x + y)) tmp = 0.0 if (y <= 1.5e+146) tmp = Float64(Float64(y / Float64(Float64(1.0 + Float64(x + y)) * Float64(x + y))) * t_0); else tmp = Float64(1.0 * Float64(t_0 / Float64(Float64(1.0 + x) + y))); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y)
t_0 = x / (x + y);
tmp = 0.0;
if (y <= 1.5e+146)
tmp = (y / ((1.0 + (x + y)) * (x + y))) * t_0;
else
tmp = 1.0 * (t_0 / ((1.0 + x) + y));
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function.
code[x_, y_] := Block[{t$95$0 = N[(x / N[(x + y), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, 1.5e+146], N[(N[(y / N[(N[(1.0 + N[(x + y), $MachinePrecision]), $MachinePrecision] * N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * t$95$0), $MachinePrecision], N[(1.0 * N[(t$95$0 / N[(N[(1.0 + x), $MachinePrecision] + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
t_0 := \frac{x}{x + y}\\
\mathbf{if}\;y \leq 1.5 \cdot 10^{+146}:\\
\;\;\;\;\frac{y}{\left(1 + \left(x + y\right)\right) \cdot \left(x + y\right)} \cdot t\_0\\
\mathbf{else}:\\
\;\;\;\;1 \cdot \frac{t\_0}{\left(1 + x\right) + y}\\
\end{array}
\end{array}
if y < 1.50000000000000001e146Initial program 67.5%
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-/.f6495.6
lift-+.f64N/A
+-commutativeN/A
Applied rewrites95.6%
if 1.50000000000000001e146 < y Initial program 63.8%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
associate-*l/N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-/.f64N/A
lower-/.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
Applied rewrites99.8%
lift-*.f64N/A
lift-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
associate-*r/N/A
lift-/.f64N/A
associate-*r/N/A
*-commutativeN/A
associate-/r*N/A
*-commutativeN/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
+-commutativeN/A
lift-+.f64N/A
lower-/.f6499.9
lift-+.f64N/A
lift-+.f64N/A
+-commutativeN/A
Applied rewrites99.9%
Taylor expanded in x around 0
Applied rewrites99.9%
Final simplification96.1%
NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y) :precision binary64 (* (/ (/ y (+ 1.0 (+ x y))) (+ x y)) (/ x (+ x y))))
assert(x < y);
double code(double x, double y) {
return ((y / (1.0 + (x + y))) / (x + y)) * (x / (x + y));
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = ((y / (1.0d0 + (x + y))) / (x + y)) * (x / (x + y))
end function
assert x < y;
public static double code(double x, double y) {
return ((y / (1.0 + (x + y))) / (x + y)) * (x / (x + y));
}
[x, y] = sort([x, y]) def code(x, y): return ((y / (1.0 + (x + y))) / (x + y)) * (x / (x + y))
x, y = sort([x, y]) function code(x, y) return Float64(Float64(Float64(y / Float64(1.0 + Float64(x + y))) / Float64(x + y)) * Float64(x / Float64(x + y))) end
x, y = num2cell(sort([x, y])){:}
function tmp = code(x, y)
tmp = ((y / (1.0 + (x + y))) / (x + y)) * (x / (x + y));
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := N[(N[(N[(y / N[(1.0 + N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(x + y), $MachinePrecision]), $MachinePrecision] * N[(x / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\frac{\frac{y}{1 + \left(x + y\right)}}{x + y} \cdot \frac{x}{x + y}
\end{array}
Initial program 67.1%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
associate-*l/N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-/.f64N/A
lower-/.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
Applied rewrites99.8%
Final simplification99.8%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y)
:precision binary64
(let* ((t_0 (+ (+ 1.0 x) y)))
(if (<= y 1.15e-139)
(* 1.0 (/ (/ y (+ 1.0 (+ x y))) (+ x y)))
(if (<= y 1.5e+146)
(/ (* 1.0 x) (* t_0 (+ x y)))
(* 1.0 (/ (/ x (+ x y)) t_0))))))assert(x < y);
double code(double x, double y) {
double t_0 = (1.0 + x) + y;
double tmp;
if (y <= 1.15e-139) {
tmp = 1.0 * ((y / (1.0 + (x + y))) / (x + y));
} else if (y <= 1.5e+146) {
tmp = (1.0 * x) / (t_0 * (x + y));
} else {
tmp = 1.0 * ((x / (x + y)) / t_0);
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
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 <= 1.15d-139) then
tmp = 1.0d0 * ((y / (1.0d0 + (x + y))) / (x + y))
else if (y <= 1.5d+146) then
tmp = (1.0d0 * x) / (t_0 * (x + y))
else
tmp = 1.0d0 * ((x / (x + y)) / t_0)
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y) {
double t_0 = (1.0 + x) + y;
double tmp;
if (y <= 1.15e-139) {
tmp = 1.0 * ((y / (1.0 + (x + y))) / (x + y));
} else if (y <= 1.5e+146) {
tmp = (1.0 * x) / (t_0 * (x + y));
} else {
tmp = 1.0 * ((x / (x + y)) / t_0);
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y): t_0 = (1.0 + x) + y tmp = 0 if y <= 1.15e-139: tmp = 1.0 * ((y / (1.0 + (x + y))) / (x + y)) elif y <= 1.5e+146: tmp = (1.0 * x) / (t_0 * (x + y)) else: tmp = 1.0 * ((x / (x + y)) / t_0) return tmp
x, y = sort([x, y]) function code(x, y) t_0 = Float64(Float64(1.0 + x) + y) tmp = 0.0 if (y <= 1.15e-139) tmp = Float64(1.0 * Float64(Float64(y / Float64(1.0 + Float64(x + y))) / Float64(x + y))); elseif (y <= 1.5e+146) tmp = Float64(Float64(1.0 * x) / Float64(t_0 * Float64(x + y))); else tmp = Float64(1.0 * Float64(Float64(x / Float64(x + y)) / t_0)); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y)
t_0 = (1.0 + x) + y;
tmp = 0.0;
if (y <= 1.15e-139)
tmp = 1.0 * ((y / (1.0 + (x + y))) / (x + y));
elseif (y <= 1.5e+146)
tmp = (1.0 * x) / (t_0 * (x + y));
else
tmp = 1.0 * ((x / (x + y)) / t_0);
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function.
code[x_, y_] := Block[{t$95$0 = N[(N[(1.0 + x), $MachinePrecision] + y), $MachinePrecision]}, If[LessEqual[y, 1.15e-139], N[(1.0 * N[(N[(y / N[(1.0 + N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.5e+146], N[(N[(1.0 * x), $MachinePrecision] / N[(t$95$0 * N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 * N[(N[(x / N[(x + y), $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
t_0 := \left(1 + x\right) + y\\
\mathbf{if}\;y \leq 1.15 \cdot 10^{-139}:\\
\;\;\;\;1 \cdot \frac{\frac{y}{1 + \left(x + y\right)}}{x + y}\\
\mathbf{elif}\;y \leq 1.5 \cdot 10^{+146}:\\
\;\;\;\;\frac{1 \cdot x}{t\_0 \cdot \left(x + y\right)}\\
\mathbf{else}:\\
\;\;\;\;1 \cdot \frac{\frac{x}{x + y}}{t\_0}\\
\end{array}
\end{array}
if y < 1.15000000000000006e-139Initial program 67.3%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
associate-*l/N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-/.f64N/A
lower-/.f6499.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.9
Applied rewrites99.9%
Taylor expanded in x around inf
Applied rewrites65.0%
if 1.15000000000000006e-139 < y < 1.50000000000000001e146Initial program 68.1%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
associate-*l/N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-/.f64N/A
lower-/.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
Applied rewrites99.8%
lift-*.f64N/A
lift-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
associate-*r/N/A
lift-/.f64N/A
associate-*r/N/A
*-commutativeN/A
associate-/r*N/A
*-commutativeN/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
+-commutativeN/A
lift-+.f64N/A
lower-/.f6499.8
lift-+.f64N/A
lift-+.f64N/A
+-commutativeN/A
Applied rewrites99.8%
Taylor expanded in x around 0
Applied rewrites59.6%
lift-*.f64N/A
lift-/.f64N/A
lift-/.f64N/A
associate-/l/N/A
lift-+.f64N/A
lift-+.f64N/A
associate-+l+N/A
+-commutativeN/A
lift-+.f64N/A
lift-+.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*r/N/A
lower-/.f64N/A
lower-*.f6477.8
Applied rewrites77.8%
if 1.50000000000000001e146 < y Initial program 63.8%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
associate-*l/N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-/.f64N/A
lower-/.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
Applied rewrites99.8%
lift-*.f64N/A
lift-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
associate-*r/N/A
lift-/.f64N/A
associate-*r/N/A
*-commutativeN/A
associate-/r*N/A
*-commutativeN/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
+-commutativeN/A
lift-+.f64N/A
lower-/.f6499.9
lift-+.f64N/A
lift-+.f64N/A
+-commutativeN/A
Applied rewrites99.9%
Taylor expanded in x around 0
Applied rewrites99.9%
Final simplification71.9%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y)
:precision binary64
(if (<= y 1.15e-139)
(* 1.0 (/ (/ y (+ 1.0 (+ x y))) (+ x y)))
(if (<= y 1.5e+146)
(/ (* 1.0 x) (* (+ (+ 1.0 x) y) (+ x y)))
(/ (/ x y) y))))assert(x < y);
double code(double x, double y) {
double tmp;
if (y <= 1.15e-139) {
tmp = 1.0 * ((y / (1.0 + (x + y))) / (x + y));
} else if (y <= 1.5e+146) {
tmp = (1.0 * x) / (((1.0 + x) + y) * (x + y));
} else {
tmp = (x / y) / y;
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (y <= 1.15d-139) then
tmp = 1.0d0 * ((y / (1.0d0 + (x + y))) / (x + y))
else if (y <= 1.5d+146) then
tmp = (1.0d0 * x) / (((1.0d0 + x) + y) * (x + y))
else
tmp = (x / y) / y
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y) {
double tmp;
if (y <= 1.15e-139) {
tmp = 1.0 * ((y / (1.0 + (x + y))) / (x + y));
} else if (y <= 1.5e+146) {
tmp = (1.0 * x) / (((1.0 + x) + y) * (x + y));
} else {
tmp = (x / y) / y;
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y): tmp = 0 if y <= 1.15e-139: tmp = 1.0 * ((y / (1.0 + (x + y))) / (x + y)) elif y <= 1.5e+146: tmp = (1.0 * x) / (((1.0 + x) + y) * (x + y)) else: tmp = (x / y) / y return tmp
x, y = sort([x, y]) function code(x, y) tmp = 0.0 if (y <= 1.15e-139) tmp = Float64(1.0 * Float64(Float64(y / Float64(1.0 + Float64(x + y))) / Float64(x + y))); elseif (y <= 1.5e+146) tmp = Float64(Float64(1.0 * x) / Float64(Float64(Float64(1.0 + x) + y) * Float64(x + y))); else tmp = Float64(Float64(x / y) / y); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y)
tmp = 0.0;
if (y <= 1.15e-139)
tmp = 1.0 * ((y / (1.0 + (x + y))) / (x + y));
elseif (y <= 1.5e+146)
tmp = (1.0 * x) / (((1.0 + x) + y) * (x + y));
else
tmp = (x / y) / y;
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := If[LessEqual[y, 1.15e-139], N[(1.0 * N[(N[(y / N[(1.0 + N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.5e+146], N[(N[(1.0 * x), $MachinePrecision] / N[(N[(N[(1.0 + x), $MachinePrecision] + y), $MachinePrecision] * N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / y), $MachinePrecision] / y), $MachinePrecision]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;y \leq 1.15 \cdot 10^{-139}:\\
\;\;\;\;1 \cdot \frac{\frac{y}{1 + \left(x + y\right)}}{x + y}\\
\mathbf{elif}\;y \leq 1.5 \cdot 10^{+146}:\\
\;\;\;\;\frac{1 \cdot x}{\left(\left(1 + x\right) + y\right) \cdot \left(x + y\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y}}{y}\\
\end{array}
\end{array}
if y < 1.15000000000000006e-139Initial program 67.3%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
associate-*l/N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-/.f64N/A
lower-/.f6499.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.9
Applied rewrites99.9%
Taylor expanded in x around inf
Applied rewrites65.0%
if 1.15000000000000006e-139 < y < 1.50000000000000001e146Initial program 68.1%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
associate-*l/N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-/.f64N/A
lower-/.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
Applied rewrites99.8%
lift-*.f64N/A
lift-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
associate-*r/N/A
lift-/.f64N/A
associate-*r/N/A
*-commutativeN/A
associate-/r*N/A
*-commutativeN/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
+-commutativeN/A
lift-+.f64N/A
lower-/.f6499.8
lift-+.f64N/A
lift-+.f64N/A
+-commutativeN/A
Applied rewrites99.8%
Taylor expanded in x around 0
Applied rewrites59.6%
lift-*.f64N/A
lift-/.f64N/A
lift-/.f64N/A
associate-/l/N/A
lift-+.f64N/A
lift-+.f64N/A
associate-+l+N/A
+-commutativeN/A
lift-+.f64N/A
lift-+.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*r/N/A
lower-/.f64N/A
lower-*.f6477.8
Applied rewrites77.8%
if 1.50000000000000001e146 < y Initial program 63.8%
Taylor expanded in y around inf
lower-/.f64N/A
unpow2N/A
lower-*.f6484.6
Applied rewrites84.6%
Applied rewrites99.9%
Final simplification71.9%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y)
:precision binary64
(if (<= y 1.15e-139)
(* (/ 1.0 (+ 1.0 x)) (/ y (+ x y)))
(if (<= y 1.5e+146)
(/ (* 1.0 x) (* (+ (+ 1.0 x) y) (+ x y)))
(/ (/ x y) y))))assert(x < y);
double code(double x, double y) {
double tmp;
if (y <= 1.15e-139) {
tmp = (1.0 / (1.0 + x)) * (y / (x + y));
} else if (y <= 1.5e+146) {
tmp = (1.0 * x) / (((1.0 + x) + y) * (x + y));
} else {
tmp = (x / y) / y;
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (y <= 1.15d-139) then
tmp = (1.0d0 / (1.0d0 + x)) * (y / (x + y))
else if (y <= 1.5d+146) then
tmp = (1.0d0 * x) / (((1.0d0 + x) + y) * (x + y))
else
tmp = (x / y) / y
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y) {
double tmp;
if (y <= 1.15e-139) {
tmp = (1.0 / (1.0 + x)) * (y / (x + y));
} else if (y <= 1.5e+146) {
tmp = (1.0 * x) / (((1.0 + x) + y) * (x + y));
} else {
tmp = (x / y) / y;
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y): tmp = 0 if y <= 1.15e-139: tmp = (1.0 / (1.0 + x)) * (y / (x + y)) elif y <= 1.5e+146: tmp = (1.0 * x) / (((1.0 + x) + y) * (x + y)) else: tmp = (x / y) / y return tmp
x, y = sort([x, y]) function code(x, y) tmp = 0.0 if (y <= 1.15e-139) tmp = Float64(Float64(1.0 / Float64(1.0 + x)) * Float64(y / Float64(x + y))); elseif (y <= 1.5e+146) tmp = Float64(Float64(1.0 * x) / Float64(Float64(Float64(1.0 + x) + y) * Float64(x + y))); else tmp = Float64(Float64(x / y) / y); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y)
tmp = 0.0;
if (y <= 1.15e-139)
tmp = (1.0 / (1.0 + x)) * (y / (x + y));
elseif (y <= 1.5e+146)
tmp = (1.0 * x) / (((1.0 + x) + y) * (x + y));
else
tmp = (x / y) / y;
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := If[LessEqual[y, 1.15e-139], N[(N[(1.0 / N[(1.0 + x), $MachinePrecision]), $MachinePrecision] * N[(y / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.5e+146], N[(N[(1.0 * x), $MachinePrecision] / N[(N[(N[(1.0 + x), $MachinePrecision] + y), $MachinePrecision] * N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / y), $MachinePrecision] / y), $MachinePrecision]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;y \leq 1.15 \cdot 10^{-139}:\\
\;\;\;\;\frac{1}{1 + x} \cdot \frac{y}{x + y}\\
\mathbf{elif}\;y \leq 1.5 \cdot 10^{+146}:\\
\;\;\;\;\frac{1 \cdot x}{\left(\left(1 + x\right) + y\right) \cdot \left(x + y\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y}}{y}\\
\end{array}
\end{array}
if y < 1.15000000000000006e-139Initial program 67.3%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
associate-*l/N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-/.f64N/A
lower-/.f6499.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.9
Applied rewrites99.9%
lift-*.f64N/A
lift-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
associate-*r/N/A
lift-/.f64N/A
associate-*r/N/A
*-commutativeN/A
associate-/r*N/A
*-commutativeN/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
+-commutativeN/A
lift-+.f64N/A
lower-/.f6499.8
lift-+.f64N/A
lift-+.f64N/A
+-commutativeN/A
Applied rewrites99.8%
Taylor expanded in y around 0
lower-/.f64N/A
lower-+.f6464.6
Applied rewrites64.6%
if 1.15000000000000006e-139 < y < 1.50000000000000001e146Initial program 68.1%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
associate-*l/N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-/.f64N/A
lower-/.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
Applied rewrites99.8%
lift-*.f64N/A
lift-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
associate-*r/N/A
lift-/.f64N/A
associate-*r/N/A
*-commutativeN/A
associate-/r*N/A
*-commutativeN/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
+-commutativeN/A
lift-+.f64N/A
lower-/.f6499.8
lift-+.f64N/A
lift-+.f64N/A
+-commutativeN/A
Applied rewrites99.8%
Taylor expanded in x around 0
Applied rewrites59.6%
lift-*.f64N/A
lift-/.f64N/A
lift-/.f64N/A
associate-/l/N/A
lift-+.f64N/A
lift-+.f64N/A
associate-+l+N/A
+-commutativeN/A
lift-+.f64N/A
lift-+.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*r/N/A
lower-/.f64N/A
lower-*.f6477.8
Applied rewrites77.8%
if 1.50000000000000001e146 < y Initial program 63.8%
Taylor expanded in y around inf
lower-/.f64N/A
unpow2N/A
lower-*.f6484.6
Applied rewrites84.6%
Applied rewrites99.9%
Final simplification71.6%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y)
:precision binary64
(if (<= y 1.15e-139)
(/ y (fma x x x))
(if (<= y 1.5e+146)
(/ (* 1.0 x) (* (+ (+ 1.0 x) y) (+ x y)))
(/ (/ x y) y))))assert(x < y);
double code(double x, double y) {
double tmp;
if (y <= 1.15e-139) {
tmp = y / fma(x, x, x);
} else if (y <= 1.5e+146) {
tmp = (1.0 * x) / (((1.0 + x) + y) * (x + y));
} else {
tmp = (x / y) / y;
}
return tmp;
}
x, y = sort([x, y]) function code(x, y) tmp = 0.0 if (y <= 1.15e-139) tmp = Float64(y / fma(x, x, x)); elseif (y <= 1.5e+146) tmp = Float64(Float64(1.0 * x) / Float64(Float64(Float64(1.0 + x) + y) * Float64(x + y))); else tmp = Float64(Float64(x / y) / y); end return tmp end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := If[LessEqual[y, 1.15e-139], N[(y / N[(x * x + x), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 1.5e+146], N[(N[(1.0 * x), $MachinePrecision] / N[(N[(N[(1.0 + x), $MachinePrecision] + y), $MachinePrecision] * N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(x / y), $MachinePrecision] / y), $MachinePrecision]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;y \leq 1.15 \cdot 10^{-139}:\\
\;\;\;\;\frac{y}{\mathsf{fma}\left(x, x, x\right)}\\
\mathbf{elif}\;y \leq 1.5 \cdot 10^{+146}:\\
\;\;\;\;\frac{1 \cdot x}{\left(\left(1 + x\right) + y\right) \cdot \left(x + y\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y}}{y}\\
\end{array}
\end{array}
if y < 1.15000000000000006e-139Initial program 67.3%
Taylor expanded in y around 0
lower-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
lower-fma.f6462.8
Applied rewrites62.8%
if 1.15000000000000006e-139 < y < 1.50000000000000001e146Initial program 68.1%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
associate-*l/N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-/.f64N/A
lower-/.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.8
Applied rewrites99.8%
lift-*.f64N/A
lift-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
associate-*r/N/A
lift-/.f64N/A
associate-*r/N/A
*-commutativeN/A
associate-/r*N/A
*-commutativeN/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
+-commutativeN/A
lift-+.f64N/A
lower-/.f6499.8
lift-+.f64N/A
lift-+.f64N/A
+-commutativeN/A
Applied rewrites99.8%
Taylor expanded in x around 0
Applied rewrites59.6%
lift-*.f64N/A
lift-/.f64N/A
lift-/.f64N/A
associate-/l/N/A
lift-+.f64N/A
lift-+.f64N/A
associate-+l+N/A
+-commutativeN/A
lift-+.f64N/A
lift-+.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*r/N/A
lower-/.f64N/A
lower-*.f6477.8
Applied rewrites77.8%
if 1.50000000000000001e146 < y Initial program 63.8%
Taylor expanded in y around inf
lower-/.f64N/A
unpow2N/A
lower-*.f6484.6
Applied rewrites84.6%
Applied rewrites99.9%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y)
:precision binary64
(if (<= x -1.35e+170)
(* (/ 1.0 x) (/ y (+ x y)))
(if (<= x -2.05e-170)
(* 1.0 (/ y (* (+ 1.0 (+ x y)) (+ x y))))
(/ x (fma y y y)))))assert(x < y);
double code(double x, double y) {
double tmp;
if (x <= -1.35e+170) {
tmp = (1.0 / x) * (y / (x + y));
} else if (x <= -2.05e-170) {
tmp = 1.0 * (y / ((1.0 + (x + y)) * (x + y)));
} else {
tmp = x / fma(y, y, y);
}
return tmp;
}
x, y = sort([x, y]) function code(x, y) tmp = 0.0 if (x <= -1.35e+170) tmp = Float64(Float64(1.0 / x) * Float64(y / Float64(x + y))); elseif (x <= -2.05e-170) tmp = Float64(1.0 * Float64(y / Float64(Float64(1.0 + Float64(x + y)) * Float64(x + y)))); else tmp = Float64(x / fma(y, y, y)); end return tmp end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := If[LessEqual[x, -1.35e+170], N[(N[(1.0 / x), $MachinePrecision] * N[(y / N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[x, -2.05e-170], N[(1.0 * N[(y / N[(N[(1.0 + N[(x + y), $MachinePrecision]), $MachinePrecision] * N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x / N[(y * y + y), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.35 \cdot 10^{+170}:\\
\;\;\;\;\frac{1}{x} \cdot \frac{y}{x + y}\\
\mathbf{elif}\;x \leq -2.05 \cdot 10^{-170}:\\
\;\;\;\;1 \cdot \frac{y}{\left(1 + \left(x + y\right)\right) \cdot \left(x + y\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{\mathsf{fma}\left(y, y, y\right)}\\
\end{array}
\end{array}
if x < -1.3500000000000001e170Initial program 68.8%
lift-/.f64N/A
lift-*.f64N/A
lift-*.f64N/A
times-fracN/A
associate-*l/N/A
lift-*.f64N/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-/.f64N/A
lower-/.f6499.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.9
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.9
Applied rewrites99.9%
lift-*.f64N/A
lift-/.f64N/A
lift-+.f64N/A
+-commutativeN/A
associate-*r/N/A
lift-/.f64N/A
associate-*r/N/A
*-commutativeN/A
associate-/r*N/A
*-commutativeN/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
+-commutativeN/A
lift-+.f64N/A
lower-/.f6499.9
lift-+.f64N/A
lift-+.f64N/A
+-commutativeN/A
Applied rewrites99.9%
Taylor expanded in x around inf
lower-/.f6485.5
Applied rewrites85.5%
if -1.3500000000000001e170 < x < -2.04999999999999983e-170Initial program 72.2%
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-/.f6498.6
lift-+.f64N/A
+-commutativeN/A
Applied rewrites98.6%
Taylor expanded in x around inf
Applied rewrites76.6%
if -2.04999999999999983e-170 < x Initial program 64.5%
Taylor expanded in x around 0
lower-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
lower-fma.f6455.6
Applied rewrites55.6%
Final simplification65.0%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y)
:precision binary64
(if (<= x -1.35e+170)
(/ (/ y x) x)
(if (<= x -2.05e-170)
(* 1.0 (/ y (* (+ 1.0 (+ x y)) (+ x y))))
(/ x (fma y y y)))))assert(x < y);
double code(double x, double y) {
double tmp;
if (x <= -1.35e+170) {
tmp = (y / x) / x;
} else if (x <= -2.05e-170) {
tmp = 1.0 * (y / ((1.0 + (x + y)) * (x + y)));
} else {
tmp = x / fma(y, y, y);
}
return tmp;
}
x, y = sort([x, y]) function code(x, y) tmp = 0.0 if (x <= -1.35e+170) tmp = Float64(Float64(y / x) / x); elseif (x <= -2.05e-170) tmp = Float64(1.0 * Float64(y / Float64(Float64(1.0 + Float64(x + y)) * Float64(x + y)))); else tmp = Float64(x / fma(y, y, y)); end return tmp end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := If[LessEqual[x, -1.35e+170], N[(N[(y / x), $MachinePrecision] / x), $MachinePrecision], If[LessEqual[x, -2.05e-170], N[(1.0 * N[(y / N[(N[(1.0 + N[(x + y), $MachinePrecision]), $MachinePrecision] * N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x / N[(y * y + y), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.35 \cdot 10^{+170}:\\
\;\;\;\;\frac{\frac{y}{x}}{x}\\
\mathbf{elif}\;x \leq -2.05 \cdot 10^{-170}:\\
\;\;\;\;1 \cdot \frac{y}{\left(1 + \left(x + y\right)\right) \cdot \left(x + y\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{\mathsf{fma}\left(y, y, y\right)}\\
\end{array}
\end{array}
if x < -1.3500000000000001e170Initial program 68.8%
Taylor expanded in x around inf
lower-/.f64N/A
unpow2N/A
lower-*.f6485.5
Applied rewrites85.5%
Applied rewrites85.4%
if -1.3500000000000001e170 < x < -2.04999999999999983e-170Initial program 72.2%
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-/.f6498.6
lift-+.f64N/A
+-commutativeN/A
Applied rewrites98.6%
Taylor expanded in x around inf
Applied rewrites76.6%
if -2.04999999999999983e-170 < x Initial program 64.5%
Taylor expanded in x around 0
lower-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
lower-fma.f6455.6
Applied rewrites55.6%
Final simplification65.0%
NOTE: x and y should be sorted in increasing order before calling this function.
(FPCore (x y)
:precision binary64
(if (<= x -1.35e+170)
(/ (/ y x) x)
(if (<= x -2.05e-170)
(* (/ 1.0 (* (+ (+ 1.0 x) y) (+ x y))) y)
(/ x (fma y y y)))))assert(x < y);
double code(double x, double y) {
double tmp;
if (x <= -1.35e+170) {
tmp = (y / x) / x;
} else if (x <= -2.05e-170) {
tmp = (1.0 / (((1.0 + x) + y) * (x + y))) * y;
} else {
tmp = x / fma(y, y, y);
}
return tmp;
}
x, y = sort([x, y]) function code(x, y) tmp = 0.0 if (x <= -1.35e+170) tmp = Float64(Float64(y / x) / x); elseif (x <= -2.05e-170) tmp = Float64(Float64(1.0 / Float64(Float64(Float64(1.0 + x) + y) * Float64(x + y))) * y); else tmp = Float64(x / fma(y, y, y)); end return tmp end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := If[LessEqual[x, -1.35e+170], N[(N[(y / x), $MachinePrecision] / x), $MachinePrecision], If[LessEqual[x, -2.05e-170], N[(N[(1.0 / N[(N[(N[(1.0 + x), $MachinePrecision] + y), $MachinePrecision] * N[(x + y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * y), $MachinePrecision], N[(x / N[(y * y + y), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.35 \cdot 10^{+170}:\\
\;\;\;\;\frac{\frac{y}{x}}{x}\\
\mathbf{elif}\;x \leq -2.05 \cdot 10^{-170}:\\
\;\;\;\;\frac{1}{\left(\left(1 + x\right) + y\right) \cdot \left(x + y\right)} \cdot y\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{\mathsf{fma}\left(y, y, y\right)}\\
\end{array}
\end{array}
if x < -1.3500000000000001e170Initial program 68.8%
Taylor expanded in x around inf
lower-/.f64N/A
unpow2N/A
lower-*.f6485.5
Applied rewrites85.5%
Applied rewrites85.4%
if -1.3500000000000001e170 < x < -2.04999999999999983e-170Initial program 72.2%
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
times-fracN/A
lower-*.f64N/A
lower-/.f64N/A
*-commutativeN/A
lower-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-/.f6498.6
lift-+.f64N/A
+-commutativeN/A
Applied rewrites98.6%
Taylor expanded in x around inf
Applied rewrites76.6%
lift-*.f64N/A
lift-/.f64N/A
associate-*l/N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f6476.5
lift-+.f64N/A
lift-+.f64N/A
+-commutativeN/A
associate-+l+N/A
lift-+.f64N/A
lift-+.f6476.5
lift-+.f64N/A
+-commutativeN/A
lift-+.f6476.5
Applied rewrites76.5%
if -2.04999999999999983e-170 < x Initial program 64.5%
Taylor expanded in x around 0
lower-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
lower-fma.f6455.6
Applied rewrites55.6%
Final simplification65.0%
NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y) :precision binary64 (if (<= y 1.15e-139) (/ y (fma x x x)) (if (<= y 2e+42) (/ x (fma y y y)) (/ (/ x y) y))))
assert(x < y);
double code(double x, double y) {
double tmp;
if (y <= 1.15e-139) {
tmp = y / fma(x, x, x);
} else if (y <= 2e+42) {
tmp = x / fma(y, y, y);
} else {
tmp = (x / y) / y;
}
return tmp;
}
x, y = sort([x, y]) function code(x, y) tmp = 0.0 if (y <= 1.15e-139) tmp = Float64(y / fma(x, x, x)); elseif (y <= 2e+42) tmp = Float64(x / fma(y, y, y)); else tmp = Float64(Float64(x / y) / y); end return tmp end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := If[LessEqual[y, 1.15e-139], N[(y / N[(x * x + x), $MachinePrecision]), $MachinePrecision], If[LessEqual[y, 2e+42], N[(x / N[(y * y + y), $MachinePrecision]), $MachinePrecision], N[(N[(x / y), $MachinePrecision] / y), $MachinePrecision]]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;y \leq 1.15 \cdot 10^{-139}:\\
\;\;\;\;\frac{y}{\mathsf{fma}\left(x, x, x\right)}\\
\mathbf{elif}\;y \leq 2 \cdot 10^{+42}:\\
\;\;\;\;\frac{x}{\mathsf{fma}\left(y, y, y\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{x}{y}}{y}\\
\end{array}
\end{array}
if y < 1.15000000000000006e-139Initial program 67.3%
Taylor expanded in y around 0
lower-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
lower-fma.f6462.8
Applied rewrites62.8%
if 1.15000000000000006e-139 < y < 2.00000000000000009e42Initial program 77.4%
Taylor expanded in x around 0
lower-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
lower-fma.f6453.4
Applied rewrites53.4%
if 2.00000000000000009e42 < y Initial program 59.7%
Taylor expanded in y around inf
lower-/.f64N/A
unpow2N/A
lower-*.f6476.3
Applied rewrites76.3%
Applied rewrites85.0%
NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y) :precision binary64 (if (<= y 1.15e-139) (/ y (fma x x x)) (/ x (fma y y y))))
assert(x < y);
double code(double x, double y) {
double tmp;
if (y <= 1.15e-139) {
tmp = y / fma(x, x, x);
} else {
tmp = x / fma(y, y, y);
}
return tmp;
}
x, y = sort([x, y]) function code(x, y) tmp = 0.0 if (y <= 1.15e-139) tmp = Float64(y / fma(x, x, x)); else tmp = Float64(x / fma(y, y, y)); end return tmp end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := If[LessEqual[y, 1.15e-139], N[(y / N[(x * x + x), $MachinePrecision]), $MachinePrecision], N[(x / N[(y * y + y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;y \leq 1.15 \cdot 10^{-139}:\\
\;\;\;\;\frac{y}{\mathsf{fma}\left(x, x, x\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{\mathsf{fma}\left(y, y, y\right)}\\
\end{array}
\end{array}
if y < 1.15000000000000006e-139Initial program 67.3%
Taylor expanded in y around 0
lower-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
lower-fma.f6462.8
Applied rewrites62.8%
if 1.15000000000000006e-139 < y Initial program 66.6%
Taylor expanded in x around 0
lower-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
lower-fma.f6467.3
Applied rewrites67.3%
NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y) :precision binary64 (if (<= x -1.1e+14) (/ y (* x x)) (/ x (fma y y y))))
assert(x < y);
double code(double x, double y) {
double tmp;
if (x <= -1.1e+14) {
tmp = y / (x * x);
} else {
tmp = x / fma(y, y, y);
}
return tmp;
}
x, y = sort([x, y]) function code(x, y) tmp = 0.0 if (x <= -1.1e+14) tmp = Float64(y / Float64(x * x)); else tmp = Float64(x / fma(y, y, y)); end return tmp end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := If[LessEqual[x, -1.1e+14], N[(y / N[(x * x), $MachinePrecision]), $MachinePrecision], N[(x / N[(y * y + y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;x \leq -1.1 \cdot 10^{+14}:\\
\;\;\;\;\frac{y}{x \cdot x}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{\mathsf{fma}\left(y, y, y\right)}\\
\end{array}
\end{array}
if x < -1.1e14Initial program 64.5%
Taylor expanded in x around inf
lower-/.f64N/A
unpow2N/A
lower-*.f6478.4
Applied rewrites78.4%
if -1.1e14 < x Initial program 68.0%
Taylor expanded in x around 0
lower-/.f64N/A
+-commutativeN/A
distribute-lft-inN/A
*-rgt-identityN/A
lower-fma.f6455.2
Applied rewrites55.2%
NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y) :precision binary64 (if (<= y 3e+20) (/ y (* x x)) (/ x (* y y))))
assert(x < y);
double code(double x, double y) {
double tmp;
if (y <= 3e+20) {
tmp = y / (x * x);
} else {
tmp = x / (y * y);
}
return tmp;
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8) :: tmp
if (y <= 3d+20) then
tmp = y / (x * x)
else
tmp = x / (y * y)
end if
code = tmp
end function
assert x < y;
public static double code(double x, double y) {
double tmp;
if (y <= 3e+20) {
tmp = y / (x * x);
} else {
tmp = x / (y * y);
}
return tmp;
}
[x, y] = sort([x, y]) def code(x, y): tmp = 0 if y <= 3e+20: tmp = y / (x * x) else: tmp = x / (y * y) return tmp
x, y = sort([x, y]) function code(x, y) tmp = 0.0 if (y <= 3e+20) tmp = Float64(y / Float64(x * x)); else tmp = Float64(x / Float64(y * y)); end return tmp end
x, y = num2cell(sort([x, y])){:}
function tmp_2 = code(x, y)
tmp = 0.0;
if (y <= 3e+20)
tmp = y / (x * x);
else
tmp = x / (y * y);
end
tmp_2 = tmp;
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := If[LessEqual[y, 3e+20], N[(y / N[(x * x), $MachinePrecision]), $MachinePrecision], N[(x / N[(y * y), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\begin{array}{l}
\mathbf{if}\;y \leq 3 \cdot 10^{+20}:\\
\;\;\;\;\frac{y}{x \cdot x}\\
\mathbf{else}:\\
\;\;\;\;\frac{x}{y \cdot y}\\
\end{array}
\end{array}
if y < 3e20Initial program 68.3%
Taylor expanded in x around inf
lower-/.f64N/A
unpow2N/A
lower-*.f6441.2
Applied rewrites41.2%
if 3e20 < y Initial program 63.1%
Taylor expanded in y around inf
lower-/.f64N/A
unpow2N/A
lower-*.f6477.8
Applied rewrites77.8%
NOTE: x and y should be sorted in increasing order before calling this function. (FPCore (x y) :precision binary64 (/ x (* y y)))
assert(x < y);
double code(double x, double y) {
return x / (y * y);
}
NOTE: x and y should be sorted in increasing order before calling this function.
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = x / (y * y)
end function
assert x < y;
public static double code(double x, double y) {
return x / (y * y);
}
[x, y] = sort([x, y]) def code(x, y): return x / (y * y)
x, y = sort([x, y]) function code(x, y) return Float64(x / Float64(y * y)) end
x, y = num2cell(sort([x, y])){:}
function tmp = code(x, y)
tmp = x / (y * y);
end
NOTE: x and y should be sorted in increasing order before calling this function. code[x_, y_] := N[(x / N[(y * y), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
[x, y] = \mathsf{sort}([x, y])\\
\\
\frac{x}{y \cdot y}
\end{array}
Initial program 67.1%
Taylor expanded in y around inf
lower-/.f64N/A
unpow2N/A
lower-*.f6434.8
Applied rewrites34.8%
(FPCore (x y) :precision binary64 (/ (/ (/ x (+ (+ y 1.0) x)) (+ y x)) (/ 1.0 (/ y (+ y x)))))
double code(double x, double y) {
return ((x / ((y + 1.0) + x)) / (y + x)) / (1.0 / (y / (y + x)));
}
real(8) function code(x, y)
real(8), intent (in) :: x
real(8), intent (in) :: y
code = ((x / ((y + 1.0d0) + x)) / (y + x)) / (1.0d0 / (y / (y + x)))
end function
public static double code(double x, double y) {
return ((x / ((y + 1.0) + x)) / (y + x)) / (1.0 / (y / (y + x)));
}
def code(x, y): return ((x / ((y + 1.0) + x)) / (y + x)) / (1.0 / (y / (y + x)))
function code(x, y) return Float64(Float64(Float64(x / Float64(Float64(y + 1.0) + x)) / Float64(y + x)) / Float64(1.0 / Float64(y / Float64(y + x)))) end
function tmp = code(x, y) tmp = ((x / ((y + 1.0) + x)) / (y + x)) / (1.0 / (y / (y + x))); end
code[x_, y_] := N[(N[(N[(x / N[(N[(y + 1.0), $MachinePrecision] + x), $MachinePrecision]), $MachinePrecision] / N[(y + x), $MachinePrecision]), $MachinePrecision] / N[(1.0 / N[(y / N[(y + x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\frac{\frac{x}{\left(y + 1\right) + x}}{y + x}}{\frac{1}{\frac{y}{y + x}}}
\end{array}
herbie shell --seed 2024298
(FPCore (x y)
:name "Numeric.SpecFunctions:incompleteBetaApprox from math-functions-0.1.5.2, A"
:precision binary64
:alt
(! :herbie-platform default (/ (/ (/ x (+ (+ y 1) x)) (+ y x)) (/ 1 (/ y (+ y x)))))
(/ (* x y) (* (* (+ x y) (+ x y)) (+ (+ x y) 1.0))))