
(FPCore (x y z t) :precision binary64 (+ (+ (+ (- (sqrt (+ x 1.0)) (sqrt x)) (- (sqrt (+ y 1.0)) (sqrt y))) (- (sqrt (+ z 1.0)) (sqrt z))) (- (sqrt (+ t 1.0)) (sqrt t))))
double code(double x, double y, double z, double t) {
return (((sqrt((x + 1.0)) - sqrt(x)) + (sqrt((y + 1.0)) - sqrt(y))) + (sqrt((z + 1.0)) - sqrt(z))) + (sqrt((t + 1.0)) - sqrt(t));
}
module fmin_fmax_functions
implicit none
private
public fmax
public fmin
interface fmax
module procedure fmax88
module procedure fmax44
module procedure fmax84
module procedure fmax48
end interface
interface fmin
module procedure fmin88
module procedure fmin44
module procedure fmin84
module procedure fmin48
end interface
contains
real(8) function fmax88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(4) function fmax44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(8) function fmax84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, max(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmax48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), max(dble(x), y), y /= y), x /= x)
end function
real(8) function fmin88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(4) function fmin44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(8) function fmin84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, min(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmin48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), min(dble(x), y), y /= y), x /= x)
end function
end module
real(8) function code(x, y, z, t)
use fmin_fmax_functions
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = (((sqrt((x + 1.0d0)) - sqrt(x)) + (sqrt((y + 1.0d0)) - sqrt(y))) + (sqrt((z + 1.0d0)) - sqrt(z))) + (sqrt((t + 1.0d0)) - sqrt(t))
end function
public static double code(double x, double y, double z, double t) {
return (((Math.sqrt((x + 1.0)) - Math.sqrt(x)) + (Math.sqrt((y + 1.0)) - Math.sqrt(y))) + (Math.sqrt((z + 1.0)) - Math.sqrt(z))) + (Math.sqrt((t + 1.0)) - Math.sqrt(t));
}
def code(x, y, z, t): return (((math.sqrt((x + 1.0)) - math.sqrt(x)) + (math.sqrt((y + 1.0)) - math.sqrt(y))) + (math.sqrt((z + 1.0)) - math.sqrt(z))) + (math.sqrt((t + 1.0)) - math.sqrt(t))
function code(x, y, z, t) return Float64(Float64(Float64(Float64(sqrt(Float64(x + 1.0)) - sqrt(x)) + Float64(sqrt(Float64(y + 1.0)) - sqrt(y))) + Float64(sqrt(Float64(z + 1.0)) - sqrt(z))) + Float64(sqrt(Float64(t + 1.0)) - sqrt(t))) end
function tmp = code(x, y, z, t) tmp = (((sqrt((x + 1.0)) - sqrt(x)) + (sqrt((y + 1.0)) - sqrt(y))) + (sqrt((z + 1.0)) - sqrt(z))) + (sqrt((t + 1.0)) - sqrt(t)); end
code[x_, y_, z_, t_] := N[(N[(N[(N[(N[Sqrt[N[(x + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(y + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(z + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(t + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[t], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(\left(\sqrt{x + 1} - \sqrt{x}\right) + \left(\sqrt{y + 1} - \sqrt{y}\right)\right) + \left(\sqrt{z + 1} - \sqrt{z}\right)\right) + \left(\sqrt{t + 1} - \sqrt{t}\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 23 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z t) :precision binary64 (+ (+ (+ (- (sqrt (+ x 1.0)) (sqrt x)) (- (sqrt (+ y 1.0)) (sqrt y))) (- (sqrt (+ z 1.0)) (sqrt z))) (- (sqrt (+ t 1.0)) (sqrt t))))
double code(double x, double y, double z, double t) {
return (((sqrt((x + 1.0)) - sqrt(x)) + (sqrt((y + 1.0)) - sqrt(y))) + (sqrt((z + 1.0)) - sqrt(z))) + (sqrt((t + 1.0)) - sqrt(t));
}
module fmin_fmax_functions
implicit none
private
public fmax
public fmin
interface fmax
module procedure fmax88
module procedure fmax44
module procedure fmax84
module procedure fmax48
end interface
interface fmin
module procedure fmin88
module procedure fmin44
module procedure fmin84
module procedure fmin48
end interface
contains
real(8) function fmax88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(4) function fmax44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(8) function fmax84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, max(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmax48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), max(dble(x), y), y /= y), x /= x)
end function
real(8) function fmin88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(4) function fmin44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(8) function fmin84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, min(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmin48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), min(dble(x), y), y /= y), x /= x)
end function
end module
real(8) function code(x, y, z, t)
use fmin_fmax_functions
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = (((sqrt((x + 1.0d0)) - sqrt(x)) + (sqrt((y + 1.0d0)) - sqrt(y))) + (sqrt((z + 1.0d0)) - sqrt(z))) + (sqrt((t + 1.0d0)) - sqrt(t))
end function
public static double code(double x, double y, double z, double t) {
return (((Math.sqrt((x + 1.0)) - Math.sqrt(x)) + (Math.sqrt((y + 1.0)) - Math.sqrt(y))) + (Math.sqrt((z + 1.0)) - Math.sqrt(z))) + (Math.sqrt((t + 1.0)) - Math.sqrt(t));
}
def code(x, y, z, t): return (((math.sqrt((x + 1.0)) - math.sqrt(x)) + (math.sqrt((y + 1.0)) - math.sqrt(y))) + (math.sqrt((z + 1.0)) - math.sqrt(z))) + (math.sqrt((t + 1.0)) - math.sqrt(t))
function code(x, y, z, t) return Float64(Float64(Float64(Float64(sqrt(Float64(x + 1.0)) - sqrt(x)) + Float64(sqrt(Float64(y + 1.0)) - sqrt(y))) + Float64(sqrt(Float64(z + 1.0)) - sqrt(z))) + Float64(sqrt(Float64(t + 1.0)) - sqrt(t))) end
function tmp = code(x, y, z, t) tmp = (((sqrt((x + 1.0)) - sqrt(x)) + (sqrt((y + 1.0)) - sqrt(y))) + (sqrt((z + 1.0)) - sqrt(z))) + (sqrt((t + 1.0)) - sqrt(t)); end
code[x_, y_, z_, t_] := N[(N[(N[(N[(N[Sqrt[N[(x + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(y + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(z + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(t + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[t], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(\left(\sqrt{x + 1} - \sqrt{x}\right) + \left(\sqrt{y + 1} - \sqrt{y}\right)\right) + \left(\sqrt{z + 1} - \sqrt{z}\right)\right) + \left(\sqrt{t + 1} - \sqrt{t}\right)
\end{array}
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (- (sqrt (+ t 1.0)) (sqrt t)))
(t_2
(+
(+
(+ (- (sqrt (+ x 1.0)) (sqrt x)) (- (sqrt (+ y 1.0)) (sqrt y)))
(- (sqrt (+ z 1.0)) (sqrt z)))
t_1))
(t_3 (sqrt (+ 1.0 y)))
(t_4 (/ 1.0 (+ t_3 (sqrt y)))))
(if (<= t_2 2e-6)
(+
(fma (sqrt (/ 1.0 (pow x 3.0))) -0.125 (fma (sqrt (/ 1.0 x)) 0.5 t_4))
t_1)
(if (<= t_2 2.0002)
(+ (- (+ (fma (sqrt (/ 1.0 z)) 0.5 t_4) (sqrt (+ 1.0 x))) (sqrt x)) t_1)
(+
1.0
(-
(+ (+ (/ 1.0 (+ (sqrt (+ 1.0 t)) (sqrt t))) (sqrt (+ 1.0 z))) t_3)
(+ (+ (sqrt z) (sqrt y)) (sqrt x))))))))assert(x < y && y < z && z < t);
double code(double x, double y, double z, double t) {
double t_1 = sqrt((t + 1.0)) - sqrt(t);
double t_2 = (((sqrt((x + 1.0)) - sqrt(x)) + (sqrt((y + 1.0)) - sqrt(y))) + (sqrt((z + 1.0)) - sqrt(z))) + t_1;
double t_3 = sqrt((1.0 + y));
double t_4 = 1.0 / (t_3 + sqrt(y));
double tmp;
if (t_2 <= 2e-6) {
tmp = fma(sqrt((1.0 / pow(x, 3.0))), -0.125, fma(sqrt((1.0 / x)), 0.5, t_4)) + t_1;
} else if (t_2 <= 2.0002) {
tmp = ((fma(sqrt((1.0 / z)), 0.5, t_4) + sqrt((1.0 + x))) - sqrt(x)) + t_1;
} else {
tmp = 1.0 + ((((1.0 / (sqrt((1.0 + t)) + sqrt(t))) + sqrt((1.0 + z))) + t_3) - ((sqrt(z) + sqrt(y)) + sqrt(x)));
}
return tmp;
}
x, y, z, t = sort([x, y, z, t]) function code(x, y, z, t) t_1 = Float64(sqrt(Float64(t + 1.0)) - sqrt(t)) t_2 = Float64(Float64(Float64(Float64(sqrt(Float64(x + 1.0)) - sqrt(x)) + Float64(sqrt(Float64(y + 1.0)) - sqrt(y))) + Float64(sqrt(Float64(z + 1.0)) - sqrt(z))) + t_1) t_3 = sqrt(Float64(1.0 + y)) t_4 = Float64(1.0 / Float64(t_3 + sqrt(y))) tmp = 0.0 if (t_2 <= 2e-6) tmp = Float64(fma(sqrt(Float64(1.0 / (x ^ 3.0))), -0.125, fma(sqrt(Float64(1.0 / x)), 0.5, t_4)) + t_1); elseif (t_2 <= 2.0002) tmp = Float64(Float64(Float64(fma(sqrt(Float64(1.0 / z)), 0.5, t_4) + sqrt(Float64(1.0 + x))) - sqrt(x)) + t_1); else tmp = Float64(1.0 + Float64(Float64(Float64(Float64(1.0 / Float64(sqrt(Float64(1.0 + t)) + sqrt(t))) + sqrt(Float64(1.0 + z))) + t_3) - Float64(Float64(sqrt(z) + sqrt(y)) + sqrt(x)))); end return tmp end
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[Sqrt[N[(t + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[t], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(N[(N[Sqrt[N[(x + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(y + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(z + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]}, Block[{t$95$3 = N[Sqrt[N[(1.0 + y), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$4 = N[(1.0 / N[(t$95$3 + N[Sqrt[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, 2e-6], N[(N[(N[Sqrt[N[(1.0 / N[Power[x, 3.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * -0.125 + N[(N[Sqrt[N[(1.0 / x), $MachinePrecision]], $MachinePrecision] * 0.5 + t$95$4), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[t$95$2, 2.0002], N[(N[(N[(N[(N[Sqrt[N[(1.0 / z), $MachinePrecision]], $MachinePrecision] * 0.5 + t$95$4), $MachinePrecision] + N[Sqrt[N[(1.0 + x), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], N[(1.0 + N[(N[(N[(N[(1.0 / N[(N[Sqrt[N[(1.0 + t), $MachinePrecision]], $MachinePrecision] + N[Sqrt[t], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[Sqrt[N[(1.0 + z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] + t$95$3), $MachinePrecision] - N[(N[(N[Sqrt[z], $MachinePrecision] + N[Sqrt[y], $MachinePrecision]), $MachinePrecision] + N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
[x, y, z, t] = \mathsf{sort}([x, y, z, t])\\
\\
\begin{array}{l}
t_1 := \sqrt{t + 1} - \sqrt{t}\\
t_2 := \left(\left(\left(\sqrt{x + 1} - \sqrt{x}\right) + \left(\sqrt{y + 1} - \sqrt{y}\right)\right) + \left(\sqrt{z + 1} - \sqrt{z}\right)\right) + t\_1\\
t_3 := \sqrt{1 + y}\\
t_4 := \frac{1}{t\_3 + \sqrt{y}}\\
\mathbf{if}\;t\_2 \leq 2 \cdot 10^{-6}:\\
\;\;\;\;\mathsf{fma}\left(\sqrt{\frac{1}{{x}^{3}}}, -0.125, \mathsf{fma}\left(\sqrt{\frac{1}{x}}, 0.5, t\_4\right)\right) + t\_1\\
\mathbf{elif}\;t\_2 \leq 2.0002:\\
\;\;\;\;\left(\left(\mathsf{fma}\left(\sqrt{\frac{1}{z}}, 0.5, t\_4\right) + \sqrt{1 + x}\right) - \sqrt{x}\right) + t\_1\\
\mathbf{else}:\\
\;\;\;\;1 + \left(\left(\left(\frac{1}{\sqrt{1 + t} + \sqrt{t}} + \sqrt{1 + z}\right) + t\_3\right) - \left(\left(\sqrt{z} + \sqrt{y}\right) + \sqrt{x}\right)\right)\\
\end{array}
\end{array}
if (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 1.99999999999999991e-6Initial program 10.2%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6415.7
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites15.7%
Taylor expanded in z around inf
lower--.f64N/A
Applied rewrites3.4%
Taylor expanded in x around inf
*-commutativeN/A
lower-fma.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
lower-pow.f64N/A
*-commutativeN/A
lower-fma.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
Applied rewrites46.9%
if 1.99999999999999991e-6 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 2.00019999999999998Initial program 95.3%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6495.5
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites95.5%
Taylor expanded in z around inf
lower--.f64N/A
Applied rewrites45.5%
if 2.00019999999999998 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) Initial program 98.5%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6498.6
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites98.6%
Taylor expanded in x around 0
associate--l+N/A
lower-+.f64N/A
lower--.f64N/A
Applied rewrites46.8%
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (sqrt (+ 1.0 x)))
(t_2 (- (sqrt (+ t 1.0)) (sqrt t)))
(t_3 (- (sqrt (+ y 1.0)) (sqrt y)))
(t_4
(+
(+
(+ (- (sqrt (+ x 1.0)) (sqrt x)) t_3)
(- (sqrt (+ z 1.0)) (sqrt z)))
t_2))
(t_5 (sqrt (+ 1.0 y))))
(if (<= t_4 2e-6)
(+ (fma (sqrt (/ 1.0 x)) 0.5 (/ 1.0 (+ t_5 (sqrt y)))) t_2)
(if (<= t_4 1.0001)
(+ (fma (sqrt (/ 1.0 y)) 0.5 (- t_1 (sqrt x))) t_2)
(if (<= t_4 2.0002)
(- (+ (fma (sqrt (/ 1.0 z)) 0.5 t_5) t_1) (+ (sqrt y) (sqrt x)))
(if (<= t_4 2.999999999999999)
(+
(- (sqrt (- z -1.0)) (+ (+ (sqrt z) (sqrt y)) (sqrt x)))
(+ (sqrt (- y -1.0)) (sqrt (- x -1.0))))
(+ (+ (+ (- 1.0 (sqrt x)) t_3) (- 1.0 (sqrt z))) t_2)))))))assert(x < y && y < z && z < t);
double code(double x, double y, double z, double t) {
double t_1 = sqrt((1.0 + x));
double t_2 = sqrt((t + 1.0)) - sqrt(t);
double t_3 = sqrt((y + 1.0)) - sqrt(y);
double t_4 = (((sqrt((x + 1.0)) - sqrt(x)) + t_3) + (sqrt((z + 1.0)) - sqrt(z))) + t_2;
double t_5 = sqrt((1.0 + y));
double tmp;
if (t_4 <= 2e-6) {
tmp = fma(sqrt((1.0 / x)), 0.5, (1.0 / (t_5 + sqrt(y)))) + t_2;
} else if (t_4 <= 1.0001) {
tmp = fma(sqrt((1.0 / y)), 0.5, (t_1 - sqrt(x))) + t_2;
} else if (t_4 <= 2.0002) {
tmp = (fma(sqrt((1.0 / z)), 0.5, t_5) + t_1) - (sqrt(y) + sqrt(x));
} else if (t_4 <= 2.999999999999999) {
tmp = (sqrt((z - -1.0)) - ((sqrt(z) + sqrt(y)) + sqrt(x))) + (sqrt((y - -1.0)) + sqrt((x - -1.0)));
} else {
tmp = (((1.0 - sqrt(x)) + t_3) + (1.0 - sqrt(z))) + t_2;
}
return tmp;
}
x, y, z, t = sort([x, y, z, t]) function code(x, y, z, t) t_1 = sqrt(Float64(1.0 + x)) t_2 = Float64(sqrt(Float64(t + 1.0)) - sqrt(t)) t_3 = Float64(sqrt(Float64(y + 1.0)) - sqrt(y)) t_4 = Float64(Float64(Float64(Float64(sqrt(Float64(x + 1.0)) - sqrt(x)) + t_3) + Float64(sqrt(Float64(z + 1.0)) - sqrt(z))) + t_2) t_5 = sqrt(Float64(1.0 + y)) tmp = 0.0 if (t_4 <= 2e-6) tmp = Float64(fma(sqrt(Float64(1.0 / x)), 0.5, Float64(1.0 / Float64(t_5 + sqrt(y)))) + t_2); elseif (t_4 <= 1.0001) tmp = Float64(fma(sqrt(Float64(1.0 / y)), 0.5, Float64(t_1 - sqrt(x))) + t_2); elseif (t_4 <= 2.0002) tmp = Float64(Float64(fma(sqrt(Float64(1.0 / z)), 0.5, t_5) + t_1) - Float64(sqrt(y) + sqrt(x))); elseif (t_4 <= 2.999999999999999) tmp = Float64(Float64(sqrt(Float64(z - -1.0)) - Float64(Float64(sqrt(z) + sqrt(y)) + sqrt(x))) + Float64(sqrt(Float64(y - -1.0)) + sqrt(Float64(x - -1.0)))); else tmp = Float64(Float64(Float64(Float64(1.0 - sqrt(x)) + t_3) + Float64(1.0 - sqrt(z))) + t_2); end return tmp end
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_] := Block[{t$95$1 = N[Sqrt[N[(1.0 + x), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[(N[Sqrt[N[(t + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[t], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[Sqrt[N[(y + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[y], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[(N[(N[(N[Sqrt[N[(x + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + t$95$3), $MachinePrecision] + N[(N[Sqrt[N[(z + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$2), $MachinePrecision]}, Block[{t$95$5 = N[Sqrt[N[(1.0 + y), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[t$95$4, 2e-6], N[(N[(N[Sqrt[N[(1.0 / x), $MachinePrecision]], $MachinePrecision] * 0.5 + N[(1.0 / N[(t$95$5 + N[Sqrt[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$2), $MachinePrecision], If[LessEqual[t$95$4, 1.0001], N[(N[(N[Sqrt[N[(1.0 / y), $MachinePrecision]], $MachinePrecision] * 0.5 + N[(t$95$1 - N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$2), $MachinePrecision], If[LessEqual[t$95$4, 2.0002], N[(N[(N[(N[Sqrt[N[(1.0 / z), $MachinePrecision]], $MachinePrecision] * 0.5 + t$95$5), $MachinePrecision] + t$95$1), $MachinePrecision] - N[(N[Sqrt[y], $MachinePrecision] + N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$4, 2.999999999999999], N[(N[(N[Sqrt[N[(z - -1.0), $MachinePrecision]], $MachinePrecision] - N[(N[(N[Sqrt[z], $MachinePrecision] + N[Sqrt[y], $MachinePrecision]), $MachinePrecision] + N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(y - -1.0), $MachinePrecision]], $MachinePrecision] + N[Sqrt[N[(x - -1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[(1.0 - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + t$95$3), $MachinePrecision] + N[(1.0 - N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$2), $MachinePrecision]]]]]]]]]]
\begin{array}{l}
[x, y, z, t] = \mathsf{sort}([x, y, z, t])\\
\\
\begin{array}{l}
t_1 := \sqrt{1 + x}\\
t_2 := \sqrt{t + 1} - \sqrt{t}\\
t_3 := \sqrt{y + 1} - \sqrt{y}\\
t_4 := \left(\left(\left(\sqrt{x + 1} - \sqrt{x}\right) + t\_3\right) + \left(\sqrt{z + 1} - \sqrt{z}\right)\right) + t\_2\\
t_5 := \sqrt{1 + y}\\
\mathbf{if}\;t\_4 \leq 2 \cdot 10^{-6}:\\
\;\;\;\;\mathsf{fma}\left(\sqrt{\frac{1}{x}}, 0.5, \frac{1}{t\_5 + \sqrt{y}}\right) + t\_2\\
\mathbf{elif}\;t\_4 \leq 1.0001:\\
\;\;\;\;\mathsf{fma}\left(\sqrt{\frac{1}{y}}, 0.5, t\_1 - \sqrt{x}\right) + t\_2\\
\mathbf{elif}\;t\_4 \leq 2.0002:\\
\;\;\;\;\left(\mathsf{fma}\left(\sqrt{\frac{1}{z}}, 0.5, t\_5\right) + t\_1\right) - \left(\sqrt{y} + \sqrt{x}\right)\\
\mathbf{elif}\;t\_4 \leq 2.999999999999999:\\
\;\;\;\;\left(\sqrt{z - -1} - \left(\left(\sqrt{z} + \sqrt{y}\right) + \sqrt{x}\right)\right) + \left(\sqrt{y - -1} + \sqrt{x - -1}\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(\left(1 - \sqrt{x}\right) + t\_3\right) + \left(1 - \sqrt{z}\right)\right) + t\_2\\
\end{array}
\end{array}
if (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 1.99999999999999991e-6Initial program 10.2%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6415.7
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites15.7%
Taylor expanded in z around inf
lower--.f64N/A
Applied rewrites3.4%
Taylor expanded in x around inf
*-commutativeN/A
lower-fma.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-sqrt.f6446.9
Applied rewrites46.9%
if 1.99999999999999991e-6 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 1.00009999999999999Initial program 94.5%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6495.1
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites95.1%
Taylor expanded in z around inf
lower--.f64N/A
Applied rewrites52.8%
Taylor expanded in y around inf
+-commutativeN/A
*-commutativeN/A
associate-+r-N/A
lower-fma.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
lower--.f64N/A
+-commutativeN/A
lower-sqrt.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-sqrt.f6456.0
Applied rewrites56.0%
if 1.00009999999999999 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 2.00019999999999998Initial program 95.7%
Taylor expanded in t around inf
lower--.f64N/A
Applied rewrites4.9%
Taylor expanded in z around inf
lower--.f64N/A
Applied rewrites18.5%
if 2.00019999999999998 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 2.9999999999999991Initial program 97.5%
Taylor expanded in t around inf
lower--.f64N/A
Applied rewrites23.9%
lift--.f64N/A
lift-+.f64N/A
associate--l+N/A
+-commutativeN/A
lower-+.f64N/A
lower--.f6426.9
lift-+.f64N/A
+-commutativeN/A
metadata-evalN/A
metadata-evalN/A
fp-cancel-sub-signN/A
metadata-evalN/A
lift--.f6426.9
lift-+.f64N/A
+-commutativeN/A
Applied rewrites26.9%
if 2.9999999999999991 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) Initial program 99.0%
Taylor expanded in x around 0
lower--.f64N/A
lower-sqrt.f6484.9
Applied rewrites84.9%
Taylor expanded in z around 0
lower--.f64N/A
lower-sqrt.f6465.6
Applied rewrites65.6%
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (- (sqrt (+ z 1.0)) (sqrt z)))
(t_2 (- (sqrt (+ t 1.0)) (sqrt t)))
(t_3 (sqrt (+ 1.0 x)))
(t_4 (- (sqrt (+ y 1.0)) (sqrt y)))
(t_5 (+ (+ (+ (- (sqrt (+ x 1.0)) (sqrt x)) t_4) t_1) t_2)))
(if (<= t_5 2e-6)
(+ (+ (* (sqrt (/ 1.0 x)) 0.5) t_1) t_2)
(if (<= t_5 1.0001)
(+ (fma (sqrt (/ 1.0 y)) 0.5 (- t_3 (sqrt x))) t_2)
(if (<= t_5 2.0002)
(-
(+ (fma (sqrt (/ 1.0 z)) 0.5 (sqrt (+ 1.0 y))) t_3)
(+ (sqrt y) (sqrt x)))
(if (<= t_5 2.999999999999999)
(+
(- (sqrt (- z -1.0)) (+ (+ (sqrt z) (sqrt y)) (sqrt x)))
(+ (sqrt (- y -1.0)) (sqrt (- x -1.0))))
(+ (+ (+ (- 1.0 (sqrt x)) t_4) (- 1.0 (sqrt z))) t_2)))))))assert(x < y && y < z && z < t);
double code(double x, double y, double z, double t) {
double t_1 = sqrt((z + 1.0)) - sqrt(z);
double t_2 = sqrt((t + 1.0)) - sqrt(t);
double t_3 = sqrt((1.0 + x));
double t_4 = sqrt((y + 1.0)) - sqrt(y);
double t_5 = (((sqrt((x + 1.0)) - sqrt(x)) + t_4) + t_1) + t_2;
double tmp;
if (t_5 <= 2e-6) {
tmp = ((sqrt((1.0 / x)) * 0.5) + t_1) + t_2;
} else if (t_5 <= 1.0001) {
tmp = fma(sqrt((1.0 / y)), 0.5, (t_3 - sqrt(x))) + t_2;
} else if (t_5 <= 2.0002) {
tmp = (fma(sqrt((1.0 / z)), 0.5, sqrt((1.0 + y))) + t_3) - (sqrt(y) + sqrt(x));
} else if (t_5 <= 2.999999999999999) {
tmp = (sqrt((z - -1.0)) - ((sqrt(z) + sqrt(y)) + sqrt(x))) + (sqrt((y - -1.0)) + sqrt((x - -1.0)));
} else {
tmp = (((1.0 - sqrt(x)) + t_4) + (1.0 - sqrt(z))) + t_2;
}
return tmp;
}
x, y, z, t = sort([x, y, z, t]) function code(x, y, z, t) t_1 = Float64(sqrt(Float64(z + 1.0)) - sqrt(z)) t_2 = Float64(sqrt(Float64(t + 1.0)) - sqrt(t)) t_3 = sqrt(Float64(1.0 + x)) t_4 = Float64(sqrt(Float64(y + 1.0)) - sqrt(y)) t_5 = Float64(Float64(Float64(Float64(sqrt(Float64(x + 1.0)) - sqrt(x)) + t_4) + t_1) + t_2) tmp = 0.0 if (t_5 <= 2e-6) tmp = Float64(Float64(Float64(sqrt(Float64(1.0 / x)) * 0.5) + t_1) + t_2); elseif (t_5 <= 1.0001) tmp = Float64(fma(sqrt(Float64(1.0 / y)), 0.5, Float64(t_3 - sqrt(x))) + t_2); elseif (t_5 <= 2.0002) tmp = Float64(Float64(fma(sqrt(Float64(1.0 / z)), 0.5, sqrt(Float64(1.0 + y))) + t_3) - Float64(sqrt(y) + sqrt(x))); elseif (t_5 <= 2.999999999999999) tmp = Float64(Float64(sqrt(Float64(z - -1.0)) - Float64(Float64(sqrt(z) + sqrt(y)) + sqrt(x))) + Float64(sqrt(Float64(y - -1.0)) + sqrt(Float64(x - -1.0)))); else tmp = Float64(Float64(Float64(Float64(1.0 - sqrt(x)) + t_4) + Float64(1.0 - sqrt(z))) + t_2); end return tmp end
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[Sqrt[N[(z + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[z], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[Sqrt[N[(t + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[t], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[Sqrt[N[(1.0 + x), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$4 = N[(N[Sqrt[N[(y + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[y], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$5 = N[(N[(N[(N[(N[Sqrt[N[(x + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + t$95$4), $MachinePrecision] + t$95$1), $MachinePrecision] + t$95$2), $MachinePrecision]}, If[LessEqual[t$95$5, 2e-6], N[(N[(N[(N[Sqrt[N[(1.0 / x), $MachinePrecision]], $MachinePrecision] * 0.5), $MachinePrecision] + t$95$1), $MachinePrecision] + t$95$2), $MachinePrecision], If[LessEqual[t$95$5, 1.0001], N[(N[(N[Sqrt[N[(1.0 / y), $MachinePrecision]], $MachinePrecision] * 0.5 + N[(t$95$3 - N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$2), $MachinePrecision], If[LessEqual[t$95$5, 2.0002], N[(N[(N[(N[Sqrt[N[(1.0 / z), $MachinePrecision]], $MachinePrecision] * 0.5 + N[Sqrt[N[(1.0 + y), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] + t$95$3), $MachinePrecision] - N[(N[Sqrt[y], $MachinePrecision] + N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$5, 2.999999999999999], N[(N[(N[Sqrt[N[(z - -1.0), $MachinePrecision]], $MachinePrecision] - N[(N[(N[Sqrt[z], $MachinePrecision] + N[Sqrt[y], $MachinePrecision]), $MachinePrecision] + N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(y - -1.0), $MachinePrecision]], $MachinePrecision] + N[Sqrt[N[(x - -1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[(1.0 - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + t$95$4), $MachinePrecision] + N[(1.0 - N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$2), $MachinePrecision]]]]]]]]]]
\begin{array}{l}
[x, y, z, t] = \mathsf{sort}([x, y, z, t])\\
\\
\begin{array}{l}
t_1 := \sqrt{z + 1} - \sqrt{z}\\
t_2 := \sqrt{t + 1} - \sqrt{t}\\
t_3 := \sqrt{1 + x}\\
t_4 := \sqrt{y + 1} - \sqrt{y}\\
t_5 := \left(\left(\left(\sqrt{x + 1} - \sqrt{x}\right) + t\_4\right) + t\_1\right) + t\_2\\
\mathbf{if}\;t\_5 \leq 2 \cdot 10^{-6}:\\
\;\;\;\;\left(\sqrt{\frac{1}{x}} \cdot 0.5 + t\_1\right) + t\_2\\
\mathbf{elif}\;t\_5 \leq 1.0001:\\
\;\;\;\;\mathsf{fma}\left(\sqrt{\frac{1}{y}}, 0.5, t\_3 - \sqrt{x}\right) + t\_2\\
\mathbf{elif}\;t\_5 \leq 2.0002:\\
\;\;\;\;\left(\mathsf{fma}\left(\sqrt{\frac{1}{z}}, 0.5, \sqrt{1 + y}\right) + t\_3\right) - \left(\sqrt{y} + \sqrt{x}\right)\\
\mathbf{elif}\;t\_5 \leq 2.999999999999999:\\
\;\;\;\;\left(\sqrt{z - -1} - \left(\left(\sqrt{z} + \sqrt{y}\right) + \sqrt{x}\right)\right) + \left(\sqrt{y - -1} + \sqrt{x - -1}\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(\left(1 - \sqrt{x}\right) + t\_4\right) + \left(1 - \sqrt{z}\right)\right) + t\_2\\
\end{array}
\end{array}
if (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 1.99999999999999991e-6Initial program 10.2%
Taylor expanded in x around inf
+-commutativeN/A
associate--l+N/A
*-commutativeN/A
+-commutativeN/A
lower-fma.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower--.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-sqrt.f6426.5
Applied rewrites26.5%
Taylor expanded in x around 0
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f6422.9
Applied rewrites22.9%
if 1.99999999999999991e-6 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 1.00009999999999999Initial program 94.5%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6495.1
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites95.1%
Taylor expanded in z around inf
lower--.f64N/A
Applied rewrites52.8%
Taylor expanded in y around inf
+-commutativeN/A
*-commutativeN/A
associate-+r-N/A
lower-fma.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
lower--.f64N/A
+-commutativeN/A
lower-sqrt.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-sqrt.f6456.0
Applied rewrites56.0%
if 1.00009999999999999 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 2.00019999999999998Initial program 95.7%
Taylor expanded in t around inf
lower--.f64N/A
Applied rewrites4.9%
Taylor expanded in z around inf
lower--.f64N/A
Applied rewrites18.5%
if 2.00019999999999998 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 2.9999999999999991Initial program 97.5%
Taylor expanded in t around inf
lower--.f64N/A
Applied rewrites23.9%
lift--.f64N/A
lift-+.f64N/A
associate--l+N/A
+-commutativeN/A
lower-+.f64N/A
lower--.f6426.9
lift-+.f64N/A
+-commutativeN/A
metadata-evalN/A
metadata-evalN/A
fp-cancel-sub-signN/A
metadata-evalN/A
lift--.f6426.9
lift-+.f64N/A
+-commutativeN/A
Applied rewrites26.9%
if 2.9999999999999991 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) Initial program 99.0%
Taylor expanded in x around 0
lower--.f64N/A
lower-sqrt.f6484.9
Applied rewrites84.9%
Taylor expanded in z around 0
lower--.f64N/A
lower-sqrt.f6465.6
Applied rewrites65.6%
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (sqrt (+ 1.0 z)))
(t_2 (- (sqrt (+ t 1.0)) (sqrt t)))
(t_3 (sqrt (+ 1.0 x)))
(t_4
(+
(+
(+ (- (sqrt (+ x 1.0)) (sqrt x)) (- (sqrt (+ y 1.0)) (sqrt y)))
(- (sqrt (+ z 1.0)) (sqrt z)))
t_2))
(t_5 (sqrt (+ 1.0 y)))
(t_6 (/ 1.0 (+ t_5 (sqrt y)))))
(if (<= t_4 2e-6)
(+ (fma (sqrt (/ 1.0 x)) 0.5 t_6) t_2)
(if (<= t_4 1.65)
(+ (- (+ t_3 t_6) (sqrt x)) t_2)
(if (<= t_4 2.2)
(- (+ (+ (/ 1.0 (+ t_1 (sqrt z))) t_5) t_3) (+ (sqrt y) (sqrt x)))
(+
1.0
(-
(+ (+ (/ 1.0 (+ (sqrt (+ 1.0 t)) (sqrt t))) t_1) t_5)
(+ (+ (sqrt z) (sqrt y)) (sqrt x)))))))))assert(x < y && y < z && z < t);
double code(double x, double y, double z, double t) {
double t_1 = sqrt((1.0 + z));
double t_2 = sqrt((t + 1.0)) - sqrt(t);
double t_3 = sqrt((1.0 + x));
double t_4 = (((sqrt((x + 1.0)) - sqrt(x)) + (sqrt((y + 1.0)) - sqrt(y))) + (sqrt((z + 1.0)) - sqrt(z))) + t_2;
double t_5 = sqrt((1.0 + y));
double t_6 = 1.0 / (t_5 + sqrt(y));
double tmp;
if (t_4 <= 2e-6) {
tmp = fma(sqrt((1.0 / x)), 0.5, t_6) + t_2;
} else if (t_4 <= 1.65) {
tmp = ((t_3 + t_6) - sqrt(x)) + t_2;
} else if (t_4 <= 2.2) {
tmp = (((1.0 / (t_1 + sqrt(z))) + t_5) + t_3) - (sqrt(y) + sqrt(x));
} else {
tmp = 1.0 + ((((1.0 / (sqrt((1.0 + t)) + sqrt(t))) + t_1) + t_5) - ((sqrt(z) + sqrt(y)) + sqrt(x)));
}
return tmp;
}
x, y, z, t = sort([x, y, z, t]) function code(x, y, z, t) t_1 = sqrt(Float64(1.0 + z)) t_2 = Float64(sqrt(Float64(t + 1.0)) - sqrt(t)) t_3 = sqrt(Float64(1.0 + x)) t_4 = Float64(Float64(Float64(Float64(sqrt(Float64(x + 1.0)) - sqrt(x)) + Float64(sqrt(Float64(y + 1.0)) - sqrt(y))) + Float64(sqrt(Float64(z + 1.0)) - sqrt(z))) + t_2) t_5 = sqrt(Float64(1.0 + y)) t_6 = Float64(1.0 / Float64(t_5 + sqrt(y))) tmp = 0.0 if (t_4 <= 2e-6) tmp = Float64(fma(sqrt(Float64(1.0 / x)), 0.5, t_6) + t_2); elseif (t_4 <= 1.65) tmp = Float64(Float64(Float64(t_3 + t_6) - sqrt(x)) + t_2); elseif (t_4 <= 2.2) tmp = Float64(Float64(Float64(Float64(1.0 / Float64(t_1 + sqrt(z))) + t_5) + t_3) - Float64(sqrt(y) + sqrt(x))); else tmp = Float64(1.0 + Float64(Float64(Float64(Float64(1.0 / Float64(sqrt(Float64(1.0 + t)) + sqrt(t))) + t_1) + t_5) - Float64(Float64(sqrt(z) + sqrt(y)) + sqrt(x)))); end return tmp end
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_] := Block[{t$95$1 = N[Sqrt[N[(1.0 + z), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[(N[Sqrt[N[(t + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[t], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[Sqrt[N[(1.0 + x), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$4 = N[(N[(N[(N[(N[Sqrt[N[(x + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(y + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(z + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$2), $MachinePrecision]}, Block[{t$95$5 = N[Sqrt[N[(1.0 + y), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$6 = N[(1.0 / N[(t$95$5 + N[Sqrt[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$4, 2e-6], N[(N[(N[Sqrt[N[(1.0 / x), $MachinePrecision]], $MachinePrecision] * 0.5 + t$95$6), $MachinePrecision] + t$95$2), $MachinePrecision], If[LessEqual[t$95$4, 1.65], N[(N[(N[(t$95$3 + t$95$6), $MachinePrecision] - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + t$95$2), $MachinePrecision], If[LessEqual[t$95$4, 2.2], N[(N[(N[(N[(1.0 / N[(t$95$1 + N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$5), $MachinePrecision] + t$95$3), $MachinePrecision] - N[(N[Sqrt[y], $MachinePrecision] + N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 + N[(N[(N[(N[(1.0 / N[(N[Sqrt[N[(1.0 + t), $MachinePrecision]], $MachinePrecision] + N[Sqrt[t], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision] + t$95$5), $MachinePrecision] - N[(N[(N[Sqrt[z], $MachinePrecision] + N[Sqrt[y], $MachinePrecision]), $MachinePrecision] + N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]]
\begin{array}{l}
[x, y, z, t] = \mathsf{sort}([x, y, z, t])\\
\\
\begin{array}{l}
t_1 := \sqrt{1 + z}\\
t_2 := \sqrt{t + 1} - \sqrt{t}\\
t_3 := \sqrt{1 + x}\\
t_4 := \left(\left(\left(\sqrt{x + 1} - \sqrt{x}\right) + \left(\sqrt{y + 1} - \sqrt{y}\right)\right) + \left(\sqrt{z + 1} - \sqrt{z}\right)\right) + t\_2\\
t_5 := \sqrt{1 + y}\\
t_6 := \frac{1}{t\_5 + \sqrt{y}}\\
\mathbf{if}\;t\_4 \leq 2 \cdot 10^{-6}:\\
\;\;\;\;\mathsf{fma}\left(\sqrt{\frac{1}{x}}, 0.5, t\_6\right) + t\_2\\
\mathbf{elif}\;t\_4 \leq 1.65:\\
\;\;\;\;\left(\left(t\_3 + t\_6\right) - \sqrt{x}\right) + t\_2\\
\mathbf{elif}\;t\_4 \leq 2.2:\\
\;\;\;\;\left(\left(\frac{1}{t\_1 + \sqrt{z}} + t\_5\right) + t\_3\right) - \left(\sqrt{y} + \sqrt{x}\right)\\
\mathbf{else}:\\
\;\;\;\;1 + \left(\left(\left(\frac{1}{\sqrt{1 + t} + \sqrt{t}} + t\_1\right) + t\_5\right) - \left(\left(\sqrt{z} + \sqrt{y}\right) + \sqrt{x}\right)\right)\\
\end{array}
\end{array}
if (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 1.99999999999999991e-6Initial program 10.2%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6415.7
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites15.7%
Taylor expanded in z around inf
lower--.f64N/A
Applied rewrites3.4%
Taylor expanded in x around inf
*-commutativeN/A
lower-fma.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-sqrt.f6446.9
Applied rewrites46.9%
if 1.99999999999999991e-6 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 1.6499999999999999Initial program 94.5%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6495.1
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites95.1%
Taylor expanded in z around inf
lower--.f64N/A
Applied rewrites52.8%
if 1.6499999999999999 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 2.2000000000000002Initial program 95.7%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6496.1
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites96.1%
Taylor expanded in t around inf
lower--.f64N/A
Applied rewrites18.6%
if 2.2000000000000002 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) Initial program 98.9%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6498.9
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites98.9%
Taylor expanded in x around 0
associate--l+N/A
lower-+.f64N/A
lower--.f64N/A
Applied rewrites47.8%
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (- (sqrt (+ t 1.0)) (sqrt t)))
(t_2 (sqrt (+ 1.0 x)))
(t_3 (- (sqrt (+ y 1.0)) (sqrt y)))
(t_4 (- (sqrt (+ z 1.0)) (sqrt z)))
(t_5 (+ (+ (+ (- (sqrt (+ x 1.0)) (sqrt x)) t_3) t_4) t_1))
(t_6 (sqrt (+ 1.0 y)))
(t_7 (/ 1.0 (+ t_6 (sqrt y)))))
(if (<= t_5 2e-6)
(+ (fma (sqrt (/ 1.0 x)) 0.5 t_7) t_1)
(if (<= t_5 1.65)
(+ (- (+ t_2 t_7) (sqrt x)) t_1)
(if (<= t_5 2.2)
(-
(+ (+ (/ 1.0 (+ (sqrt (+ 1.0 z)) (sqrt z))) t_6) t_2)
(+ (sqrt y) (sqrt x)))
(+ (+ (+ (- 1.0 (sqrt x)) t_3) t_4) t_1))))))assert(x < y && y < z && z < t);
double code(double x, double y, double z, double t) {
double t_1 = sqrt((t + 1.0)) - sqrt(t);
double t_2 = sqrt((1.0 + x));
double t_3 = sqrt((y + 1.0)) - sqrt(y);
double t_4 = sqrt((z + 1.0)) - sqrt(z);
double t_5 = (((sqrt((x + 1.0)) - sqrt(x)) + t_3) + t_4) + t_1;
double t_6 = sqrt((1.0 + y));
double t_7 = 1.0 / (t_6 + sqrt(y));
double tmp;
if (t_5 <= 2e-6) {
tmp = fma(sqrt((1.0 / x)), 0.5, t_7) + t_1;
} else if (t_5 <= 1.65) {
tmp = ((t_2 + t_7) - sqrt(x)) + t_1;
} else if (t_5 <= 2.2) {
tmp = (((1.0 / (sqrt((1.0 + z)) + sqrt(z))) + t_6) + t_2) - (sqrt(y) + sqrt(x));
} else {
tmp = (((1.0 - sqrt(x)) + t_3) + t_4) + t_1;
}
return tmp;
}
x, y, z, t = sort([x, y, z, t]) function code(x, y, z, t) t_1 = Float64(sqrt(Float64(t + 1.0)) - sqrt(t)) t_2 = sqrt(Float64(1.0 + x)) t_3 = Float64(sqrt(Float64(y + 1.0)) - sqrt(y)) t_4 = Float64(sqrt(Float64(z + 1.0)) - sqrt(z)) t_5 = Float64(Float64(Float64(Float64(sqrt(Float64(x + 1.0)) - sqrt(x)) + t_3) + t_4) + t_1) t_6 = sqrt(Float64(1.0 + y)) t_7 = Float64(1.0 / Float64(t_6 + sqrt(y))) tmp = 0.0 if (t_5 <= 2e-6) tmp = Float64(fma(sqrt(Float64(1.0 / x)), 0.5, t_7) + t_1); elseif (t_5 <= 1.65) tmp = Float64(Float64(Float64(t_2 + t_7) - sqrt(x)) + t_1); elseif (t_5 <= 2.2) tmp = Float64(Float64(Float64(Float64(1.0 / Float64(sqrt(Float64(1.0 + z)) + sqrt(z))) + t_6) + t_2) - Float64(sqrt(y) + sqrt(x))); else tmp = Float64(Float64(Float64(Float64(1.0 - sqrt(x)) + t_3) + t_4) + t_1); end return tmp end
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[Sqrt[N[(t + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[t], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Sqrt[N[(1.0 + x), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$3 = N[(N[Sqrt[N[(y + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[y], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[Sqrt[N[(z + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[z], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$5 = N[(N[(N[(N[(N[Sqrt[N[(x + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + t$95$3), $MachinePrecision] + t$95$4), $MachinePrecision] + t$95$1), $MachinePrecision]}, Block[{t$95$6 = N[Sqrt[N[(1.0 + y), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$7 = N[(1.0 / N[(t$95$6 + N[Sqrt[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$5, 2e-6], N[(N[(N[Sqrt[N[(1.0 / x), $MachinePrecision]], $MachinePrecision] * 0.5 + t$95$7), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[t$95$5, 1.65], N[(N[(N[(t$95$2 + t$95$7), $MachinePrecision] - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[t$95$5, 2.2], N[(N[(N[(N[(1.0 / N[(N[Sqrt[N[(1.0 + z), $MachinePrecision]], $MachinePrecision] + N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$6), $MachinePrecision] + t$95$2), $MachinePrecision] - N[(N[Sqrt[y], $MachinePrecision] + N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[(1.0 - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + t$95$3), $MachinePrecision] + t$95$4), $MachinePrecision] + t$95$1), $MachinePrecision]]]]]]]]]]]
\begin{array}{l}
[x, y, z, t] = \mathsf{sort}([x, y, z, t])\\
\\
\begin{array}{l}
t_1 := \sqrt{t + 1} - \sqrt{t}\\
t_2 := \sqrt{1 + x}\\
t_3 := \sqrt{y + 1} - \sqrt{y}\\
t_4 := \sqrt{z + 1} - \sqrt{z}\\
t_5 := \left(\left(\left(\sqrt{x + 1} - \sqrt{x}\right) + t\_3\right) + t\_4\right) + t\_1\\
t_6 := \sqrt{1 + y}\\
t_7 := \frac{1}{t\_6 + \sqrt{y}}\\
\mathbf{if}\;t\_5 \leq 2 \cdot 10^{-6}:\\
\;\;\;\;\mathsf{fma}\left(\sqrt{\frac{1}{x}}, 0.5, t\_7\right) + t\_1\\
\mathbf{elif}\;t\_5 \leq 1.65:\\
\;\;\;\;\left(\left(t\_2 + t\_7\right) - \sqrt{x}\right) + t\_1\\
\mathbf{elif}\;t\_5 \leq 2.2:\\
\;\;\;\;\left(\left(\frac{1}{\sqrt{1 + z} + \sqrt{z}} + t\_6\right) + t\_2\right) - \left(\sqrt{y} + \sqrt{x}\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(\left(1 - \sqrt{x}\right) + t\_3\right) + t\_4\right) + t\_1\\
\end{array}
\end{array}
if (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 1.99999999999999991e-6Initial program 10.2%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6415.7
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites15.7%
Taylor expanded in z around inf
lower--.f64N/A
Applied rewrites3.4%
Taylor expanded in x around inf
*-commutativeN/A
lower-fma.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-sqrt.f6446.9
Applied rewrites46.9%
if 1.99999999999999991e-6 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 1.6499999999999999Initial program 94.5%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6495.1
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites95.1%
Taylor expanded in z around inf
lower--.f64N/A
Applied rewrites52.8%
if 1.6499999999999999 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 2.2000000000000002Initial program 95.7%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6496.1
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites96.1%
Taylor expanded in t around inf
lower--.f64N/A
Applied rewrites18.6%
if 2.2000000000000002 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) Initial program 98.9%
Taylor expanded in x around 0
lower--.f64N/A
lower-sqrt.f6477.5
Applied rewrites77.5%
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (- (sqrt (+ t 1.0)) (sqrt t)))
(t_2 (sqrt (+ 1.0 x)))
(t_3 (- (sqrt (+ z 1.0)) (sqrt z)))
(t_4
(+
(+
(+ (- (sqrt (+ x 1.0)) (sqrt x)) (- (sqrt (+ y 1.0)) (sqrt y)))
t_3)
t_1))
(t_5 (sqrt (+ 1.0 y)))
(t_6 (/ 1.0 (+ t_5 (sqrt y)))))
(if (<= t_4 2e-6)
(+ (fma (sqrt (/ 1.0 x)) 0.5 t_6) t_1)
(if (<= t_4 1.65)
(+ (- (+ t_2 t_6) (sqrt x)) t_1)
(if (<= t_4 2.2)
(-
(+ (+ (/ 1.0 (+ (sqrt (+ 1.0 z)) (sqrt z))) t_5) t_2)
(+ (sqrt y) (sqrt x)))
(+ (+ (- (+ t_5 (- 1.0 (sqrt x))) (sqrt y)) t_3) t_1))))))assert(x < y && y < z && z < t);
double code(double x, double y, double z, double t) {
double t_1 = sqrt((t + 1.0)) - sqrt(t);
double t_2 = sqrt((1.0 + x));
double t_3 = sqrt((z + 1.0)) - sqrt(z);
double t_4 = (((sqrt((x + 1.0)) - sqrt(x)) + (sqrt((y + 1.0)) - sqrt(y))) + t_3) + t_1;
double t_5 = sqrt((1.0 + y));
double t_6 = 1.0 / (t_5 + sqrt(y));
double tmp;
if (t_4 <= 2e-6) {
tmp = fma(sqrt((1.0 / x)), 0.5, t_6) + t_1;
} else if (t_4 <= 1.65) {
tmp = ((t_2 + t_6) - sqrt(x)) + t_1;
} else if (t_4 <= 2.2) {
tmp = (((1.0 / (sqrt((1.0 + z)) + sqrt(z))) + t_5) + t_2) - (sqrt(y) + sqrt(x));
} else {
tmp = (((t_5 + (1.0 - sqrt(x))) - sqrt(y)) + t_3) + t_1;
}
return tmp;
}
x, y, z, t = sort([x, y, z, t]) function code(x, y, z, t) t_1 = Float64(sqrt(Float64(t + 1.0)) - sqrt(t)) t_2 = sqrt(Float64(1.0 + x)) t_3 = Float64(sqrt(Float64(z + 1.0)) - sqrt(z)) t_4 = Float64(Float64(Float64(Float64(sqrt(Float64(x + 1.0)) - sqrt(x)) + Float64(sqrt(Float64(y + 1.0)) - sqrt(y))) + t_3) + t_1) t_5 = sqrt(Float64(1.0 + y)) t_6 = Float64(1.0 / Float64(t_5 + sqrt(y))) tmp = 0.0 if (t_4 <= 2e-6) tmp = Float64(fma(sqrt(Float64(1.0 / x)), 0.5, t_6) + t_1); elseif (t_4 <= 1.65) tmp = Float64(Float64(Float64(t_2 + t_6) - sqrt(x)) + t_1); elseif (t_4 <= 2.2) tmp = Float64(Float64(Float64(Float64(1.0 / Float64(sqrt(Float64(1.0 + z)) + sqrt(z))) + t_5) + t_2) - Float64(sqrt(y) + sqrt(x))); else tmp = Float64(Float64(Float64(Float64(t_5 + Float64(1.0 - sqrt(x))) - sqrt(y)) + t_3) + t_1); end return tmp end
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[Sqrt[N[(t + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[t], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Sqrt[N[(1.0 + x), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$3 = N[(N[Sqrt[N[(z + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[z], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[(N[(N[(N[Sqrt[N[(x + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(y + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$3), $MachinePrecision] + t$95$1), $MachinePrecision]}, Block[{t$95$5 = N[Sqrt[N[(1.0 + y), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$6 = N[(1.0 / N[(t$95$5 + N[Sqrt[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$4, 2e-6], N[(N[(N[Sqrt[N[(1.0 / x), $MachinePrecision]], $MachinePrecision] * 0.5 + t$95$6), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[t$95$4, 1.65], N[(N[(N[(t$95$2 + t$95$6), $MachinePrecision] - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[t$95$4, 2.2], N[(N[(N[(N[(1.0 / N[(N[Sqrt[N[(1.0 + z), $MachinePrecision]], $MachinePrecision] + N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$5), $MachinePrecision] + t$95$2), $MachinePrecision] - N[(N[Sqrt[y], $MachinePrecision] + N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[(t$95$5 + N[(1.0 - N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[Sqrt[y], $MachinePrecision]), $MachinePrecision] + t$95$3), $MachinePrecision] + t$95$1), $MachinePrecision]]]]]]]]]]
\begin{array}{l}
[x, y, z, t] = \mathsf{sort}([x, y, z, t])\\
\\
\begin{array}{l}
t_1 := \sqrt{t + 1} - \sqrt{t}\\
t_2 := \sqrt{1 + x}\\
t_3 := \sqrt{z + 1} - \sqrt{z}\\
t_4 := \left(\left(\left(\sqrt{x + 1} - \sqrt{x}\right) + \left(\sqrt{y + 1} - \sqrt{y}\right)\right) + t\_3\right) + t\_1\\
t_5 := \sqrt{1 + y}\\
t_6 := \frac{1}{t\_5 + \sqrt{y}}\\
\mathbf{if}\;t\_4 \leq 2 \cdot 10^{-6}:\\
\;\;\;\;\mathsf{fma}\left(\sqrt{\frac{1}{x}}, 0.5, t\_6\right) + t\_1\\
\mathbf{elif}\;t\_4 \leq 1.65:\\
\;\;\;\;\left(\left(t\_2 + t\_6\right) - \sqrt{x}\right) + t\_1\\
\mathbf{elif}\;t\_4 \leq 2.2:\\
\;\;\;\;\left(\left(\frac{1}{\sqrt{1 + z} + \sqrt{z}} + t\_5\right) + t\_2\right) - \left(\sqrt{y} + \sqrt{x}\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(\left(t\_5 + \left(1 - \sqrt{x}\right)\right) - \sqrt{y}\right) + t\_3\right) + t\_1\\
\end{array}
\end{array}
if (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 1.99999999999999991e-6Initial program 10.2%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6415.7
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites15.7%
Taylor expanded in z around inf
lower--.f64N/A
Applied rewrites3.4%
Taylor expanded in x around inf
*-commutativeN/A
lower-fma.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-sqrt.f6446.9
Applied rewrites46.9%
if 1.99999999999999991e-6 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 1.6499999999999999Initial program 94.5%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6495.1
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites95.1%
Taylor expanded in z around inf
lower--.f64N/A
Applied rewrites52.8%
if 1.6499999999999999 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 2.2000000000000002Initial program 95.7%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6496.1
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites96.1%
Taylor expanded in t around inf
lower--.f64N/A
Applied rewrites18.6%
if 2.2000000000000002 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) Initial program 98.9%
Taylor expanded in x around 0
associate--r+N/A
lower--.f64N/A
+-commutativeN/A
associate--l+N/A
lower-+.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower--.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6459.3
Applied rewrites59.3%
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (- (sqrt (+ t 1.0)) (sqrt t)))
(t_2 (sqrt (+ 1.0 x)))
(t_3 (- (sqrt (+ y 1.0)) (sqrt y)))
(t_4
(+
(+
(+ (- (sqrt (+ x 1.0)) (sqrt x)) t_3)
(- (sqrt (+ z 1.0)) (sqrt z)))
t_1))
(t_5 (sqrt (+ 1.0 y)))
(t_6 (/ 1.0 (+ t_5 (sqrt y)))))
(if (<= t_4 2e-6)
(+ (fma (sqrt (/ 1.0 x)) 0.5 t_6) t_1)
(if (<= t_4 1.65)
(+ (- (+ t_2 t_6) (sqrt x)) t_1)
(if (<= t_4 2.9999995)
(-
(+ (+ (/ 1.0 (+ (sqrt (+ 1.0 z)) (sqrt z))) t_5) t_2)
(+ (sqrt y) (sqrt x)))
(+ (+ (+ (- 1.0 (sqrt x)) t_3) (- 1.0 (sqrt z))) t_1))))))assert(x < y && y < z && z < t);
double code(double x, double y, double z, double t) {
double t_1 = sqrt((t + 1.0)) - sqrt(t);
double t_2 = sqrt((1.0 + x));
double t_3 = sqrt((y + 1.0)) - sqrt(y);
double t_4 = (((sqrt((x + 1.0)) - sqrt(x)) + t_3) + (sqrt((z + 1.0)) - sqrt(z))) + t_1;
double t_5 = sqrt((1.0 + y));
double t_6 = 1.0 / (t_5 + sqrt(y));
double tmp;
if (t_4 <= 2e-6) {
tmp = fma(sqrt((1.0 / x)), 0.5, t_6) + t_1;
} else if (t_4 <= 1.65) {
tmp = ((t_2 + t_6) - sqrt(x)) + t_1;
} else if (t_4 <= 2.9999995) {
tmp = (((1.0 / (sqrt((1.0 + z)) + sqrt(z))) + t_5) + t_2) - (sqrt(y) + sqrt(x));
} else {
tmp = (((1.0 - sqrt(x)) + t_3) + (1.0 - sqrt(z))) + t_1;
}
return tmp;
}
x, y, z, t = sort([x, y, z, t]) function code(x, y, z, t) t_1 = Float64(sqrt(Float64(t + 1.0)) - sqrt(t)) t_2 = sqrt(Float64(1.0 + x)) t_3 = Float64(sqrt(Float64(y + 1.0)) - sqrt(y)) t_4 = Float64(Float64(Float64(Float64(sqrt(Float64(x + 1.0)) - sqrt(x)) + t_3) + Float64(sqrt(Float64(z + 1.0)) - sqrt(z))) + t_1) t_5 = sqrt(Float64(1.0 + y)) t_6 = Float64(1.0 / Float64(t_5 + sqrt(y))) tmp = 0.0 if (t_4 <= 2e-6) tmp = Float64(fma(sqrt(Float64(1.0 / x)), 0.5, t_6) + t_1); elseif (t_4 <= 1.65) tmp = Float64(Float64(Float64(t_2 + t_6) - sqrt(x)) + t_1); elseif (t_4 <= 2.9999995) tmp = Float64(Float64(Float64(Float64(1.0 / Float64(sqrt(Float64(1.0 + z)) + sqrt(z))) + t_5) + t_2) - Float64(sqrt(y) + sqrt(x))); else tmp = Float64(Float64(Float64(Float64(1.0 - sqrt(x)) + t_3) + Float64(1.0 - sqrt(z))) + t_1); end return tmp end
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[Sqrt[N[(t + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[t], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Sqrt[N[(1.0 + x), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$3 = N[(N[Sqrt[N[(y + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[y], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[(N[(N[(N[Sqrt[N[(x + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + t$95$3), $MachinePrecision] + N[(N[Sqrt[N[(z + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]}, Block[{t$95$5 = N[Sqrt[N[(1.0 + y), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$6 = N[(1.0 / N[(t$95$5 + N[Sqrt[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$4, 2e-6], N[(N[(N[Sqrt[N[(1.0 / x), $MachinePrecision]], $MachinePrecision] * 0.5 + t$95$6), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[t$95$4, 1.65], N[(N[(N[(t$95$2 + t$95$6), $MachinePrecision] - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[t$95$4, 2.9999995], N[(N[(N[(N[(1.0 / N[(N[Sqrt[N[(1.0 + z), $MachinePrecision]], $MachinePrecision] + N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$5), $MachinePrecision] + t$95$2), $MachinePrecision] - N[(N[Sqrt[y], $MachinePrecision] + N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[(1.0 - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + t$95$3), $MachinePrecision] + N[(1.0 - N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]]]]]]]]]]
\begin{array}{l}
[x, y, z, t] = \mathsf{sort}([x, y, z, t])\\
\\
\begin{array}{l}
t_1 := \sqrt{t + 1} - \sqrt{t}\\
t_2 := \sqrt{1 + x}\\
t_3 := \sqrt{y + 1} - \sqrt{y}\\
t_4 := \left(\left(\left(\sqrt{x + 1} - \sqrt{x}\right) + t\_3\right) + \left(\sqrt{z + 1} - \sqrt{z}\right)\right) + t\_1\\
t_5 := \sqrt{1 + y}\\
t_6 := \frac{1}{t\_5 + \sqrt{y}}\\
\mathbf{if}\;t\_4 \leq 2 \cdot 10^{-6}:\\
\;\;\;\;\mathsf{fma}\left(\sqrt{\frac{1}{x}}, 0.5, t\_6\right) + t\_1\\
\mathbf{elif}\;t\_4 \leq 1.65:\\
\;\;\;\;\left(\left(t\_2 + t\_6\right) - \sqrt{x}\right) + t\_1\\
\mathbf{elif}\;t\_4 \leq 2.9999995:\\
\;\;\;\;\left(\left(\frac{1}{\sqrt{1 + z} + \sqrt{z}} + t\_5\right) + t\_2\right) - \left(\sqrt{y} + \sqrt{x}\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(\left(1 - \sqrt{x}\right) + t\_3\right) + \left(1 - \sqrt{z}\right)\right) + t\_1\\
\end{array}
\end{array}
if (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 1.99999999999999991e-6Initial program 10.2%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6415.7
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites15.7%
Taylor expanded in z around inf
lower--.f64N/A
Applied rewrites3.4%
Taylor expanded in x around inf
*-commutativeN/A
lower-fma.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-sqrt.f6446.9
Applied rewrites46.9%
if 1.99999999999999991e-6 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 1.6499999999999999Initial program 94.5%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6495.1
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites95.1%
Taylor expanded in z around inf
lower--.f64N/A
Applied rewrites52.8%
if 1.6499999999999999 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 2.99999949999999993Initial program 96.1%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6496.4
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites96.4%
Taylor expanded in t around inf
lower--.f64N/A
Applied rewrites19.7%
if 2.99999949999999993 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) Initial program 98.7%
Taylor expanded in x around 0
lower--.f64N/A
lower-sqrt.f6479.9
Applied rewrites79.9%
Taylor expanded in z around 0
lower--.f64N/A
lower-sqrt.f6462.3
Applied rewrites62.3%
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (sqrt (+ 1.0 x)))
(t_2 (- (sqrt (+ t 1.0)) (sqrt t)))
(t_3 (- (sqrt (+ y 1.0)) (sqrt y)))
(t_4
(+
(+
(+ (- (sqrt (+ x 1.0)) (sqrt x)) t_3)
(- (sqrt (+ z 1.0)) (sqrt z)))
t_2))
(t_5 (sqrt (+ 1.0 y))))
(if (<= t_4 2e-6)
(+ (fma (sqrt (/ 1.0 x)) 0.5 (/ 1.0 (+ t_5 (sqrt y)))) t_2)
(if (<= t_4 1.0001)
(+ (fma (sqrt (/ 1.0 y)) 0.5 (- t_1 (sqrt x))) t_2)
(if (<= t_4 2.9999995)
(-
(+ (+ (/ 1.0 (+ (sqrt (+ 1.0 z)) (sqrt z))) t_5) t_1)
(+ (sqrt y) (sqrt x)))
(+ (+ (+ (- 1.0 (sqrt x)) t_3) (- 1.0 (sqrt z))) t_2))))))assert(x < y && y < z && z < t);
double code(double x, double y, double z, double t) {
double t_1 = sqrt((1.0 + x));
double t_2 = sqrt((t + 1.0)) - sqrt(t);
double t_3 = sqrt((y + 1.0)) - sqrt(y);
double t_4 = (((sqrt((x + 1.0)) - sqrt(x)) + t_3) + (sqrt((z + 1.0)) - sqrt(z))) + t_2;
double t_5 = sqrt((1.0 + y));
double tmp;
if (t_4 <= 2e-6) {
tmp = fma(sqrt((1.0 / x)), 0.5, (1.0 / (t_5 + sqrt(y)))) + t_2;
} else if (t_4 <= 1.0001) {
tmp = fma(sqrt((1.0 / y)), 0.5, (t_1 - sqrt(x))) + t_2;
} else if (t_4 <= 2.9999995) {
tmp = (((1.0 / (sqrt((1.0 + z)) + sqrt(z))) + t_5) + t_1) - (sqrt(y) + sqrt(x));
} else {
tmp = (((1.0 - sqrt(x)) + t_3) + (1.0 - sqrt(z))) + t_2;
}
return tmp;
}
x, y, z, t = sort([x, y, z, t]) function code(x, y, z, t) t_1 = sqrt(Float64(1.0 + x)) t_2 = Float64(sqrt(Float64(t + 1.0)) - sqrt(t)) t_3 = Float64(sqrt(Float64(y + 1.0)) - sqrt(y)) t_4 = Float64(Float64(Float64(Float64(sqrt(Float64(x + 1.0)) - sqrt(x)) + t_3) + Float64(sqrt(Float64(z + 1.0)) - sqrt(z))) + t_2) t_5 = sqrt(Float64(1.0 + y)) tmp = 0.0 if (t_4 <= 2e-6) tmp = Float64(fma(sqrt(Float64(1.0 / x)), 0.5, Float64(1.0 / Float64(t_5 + sqrt(y)))) + t_2); elseif (t_4 <= 1.0001) tmp = Float64(fma(sqrt(Float64(1.0 / y)), 0.5, Float64(t_1 - sqrt(x))) + t_2); elseif (t_4 <= 2.9999995) tmp = Float64(Float64(Float64(Float64(1.0 / Float64(sqrt(Float64(1.0 + z)) + sqrt(z))) + t_5) + t_1) - Float64(sqrt(y) + sqrt(x))); else tmp = Float64(Float64(Float64(Float64(1.0 - sqrt(x)) + t_3) + Float64(1.0 - sqrt(z))) + t_2); end return tmp end
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_] := Block[{t$95$1 = N[Sqrt[N[(1.0 + x), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[(N[Sqrt[N[(t + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[t], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[Sqrt[N[(y + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[y], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[(N[(N[(N[Sqrt[N[(x + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + t$95$3), $MachinePrecision] + N[(N[Sqrt[N[(z + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$2), $MachinePrecision]}, Block[{t$95$5 = N[Sqrt[N[(1.0 + y), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[t$95$4, 2e-6], N[(N[(N[Sqrt[N[(1.0 / x), $MachinePrecision]], $MachinePrecision] * 0.5 + N[(1.0 / N[(t$95$5 + N[Sqrt[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$2), $MachinePrecision], If[LessEqual[t$95$4, 1.0001], N[(N[(N[Sqrt[N[(1.0 / y), $MachinePrecision]], $MachinePrecision] * 0.5 + N[(t$95$1 - N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$2), $MachinePrecision], If[LessEqual[t$95$4, 2.9999995], N[(N[(N[(N[(1.0 / N[(N[Sqrt[N[(1.0 + z), $MachinePrecision]], $MachinePrecision] + N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$5), $MachinePrecision] + t$95$1), $MachinePrecision] - N[(N[Sqrt[y], $MachinePrecision] + N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[(1.0 - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + t$95$3), $MachinePrecision] + N[(1.0 - N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$2), $MachinePrecision]]]]]]]]]
\begin{array}{l}
[x, y, z, t] = \mathsf{sort}([x, y, z, t])\\
\\
\begin{array}{l}
t_1 := \sqrt{1 + x}\\
t_2 := \sqrt{t + 1} - \sqrt{t}\\
t_3 := \sqrt{y + 1} - \sqrt{y}\\
t_4 := \left(\left(\left(\sqrt{x + 1} - \sqrt{x}\right) + t\_3\right) + \left(\sqrt{z + 1} - \sqrt{z}\right)\right) + t\_2\\
t_5 := \sqrt{1 + y}\\
\mathbf{if}\;t\_4 \leq 2 \cdot 10^{-6}:\\
\;\;\;\;\mathsf{fma}\left(\sqrt{\frac{1}{x}}, 0.5, \frac{1}{t\_5 + \sqrt{y}}\right) + t\_2\\
\mathbf{elif}\;t\_4 \leq 1.0001:\\
\;\;\;\;\mathsf{fma}\left(\sqrt{\frac{1}{y}}, 0.5, t\_1 - \sqrt{x}\right) + t\_2\\
\mathbf{elif}\;t\_4 \leq 2.9999995:\\
\;\;\;\;\left(\left(\frac{1}{\sqrt{1 + z} + \sqrt{z}} + t\_5\right) + t\_1\right) - \left(\sqrt{y} + \sqrt{x}\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(\left(1 - \sqrt{x}\right) + t\_3\right) + \left(1 - \sqrt{z}\right)\right) + t\_2\\
\end{array}
\end{array}
if (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 1.99999999999999991e-6Initial program 10.2%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6415.7
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites15.7%
Taylor expanded in z around inf
lower--.f64N/A
Applied rewrites3.4%
Taylor expanded in x around inf
*-commutativeN/A
lower-fma.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-sqrt.f6446.9
Applied rewrites46.9%
if 1.99999999999999991e-6 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 1.00009999999999999Initial program 94.5%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6495.1
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites95.1%
Taylor expanded in z around inf
lower--.f64N/A
Applied rewrites52.8%
Taylor expanded in y around inf
+-commutativeN/A
*-commutativeN/A
associate-+r-N/A
lower-fma.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
lower--.f64N/A
+-commutativeN/A
lower-sqrt.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-sqrt.f6456.0
Applied rewrites56.0%
if 1.00009999999999999 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 2.99999949999999993Initial program 96.0%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6496.3
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites96.3%
Taylor expanded in t around inf
lower--.f64N/A
Applied rewrites20.1%
if 2.99999949999999993 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) Initial program 98.7%
Taylor expanded in x around 0
lower--.f64N/A
lower-sqrt.f6479.9
Applied rewrites79.9%
Taylor expanded in z around 0
lower--.f64N/A
lower-sqrt.f6462.3
Applied rewrites62.3%
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (- (sqrt (+ z 1.0)) (sqrt z)))
(t_2 (- (sqrt (+ t 1.0)) (sqrt t)))
(t_3
(+
(+
(+ (- (sqrt (+ x 1.0)) (sqrt x)) (- (sqrt (+ y 1.0)) (sqrt y)))
t_1)
t_2))
(t_4 (sqrt (+ 1.0 x))))
(if (<= t_3 2e-6)
(+ (+ (* (sqrt (/ 1.0 x)) 0.5) t_1) t_2)
(if (<= t_3 1.0001)
(+ (fma (sqrt (/ 1.0 y)) 0.5 (- t_4 (sqrt x))) t_2)
(if (<= t_3 2.0002)
(-
(+ (fma (sqrt (/ 1.0 z)) 0.5 (sqrt (+ 1.0 y))) t_4)
(+ (sqrt y) (sqrt x)))
(+
(- (sqrt (- z -1.0)) (+ (+ (sqrt z) (sqrt y)) (sqrt x)))
(+ (sqrt (- y -1.0)) (sqrt (- x -1.0)))))))))assert(x < y && y < z && z < t);
double code(double x, double y, double z, double t) {
double t_1 = sqrt((z + 1.0)) - sqrt(z);
double t_2 = sqrt((t + 1.0)) - sqrt(t);
double t_3 = (((sqrt((x + 1.0)) - sqrt(x)) + (sqrt((y + 1.0)) - sqrt(y))) + t_1) + t_2;
double t_4 = sqrt((1.0 + x));
double tmp;
if (t_3 <= 2e-6) {
tmp = ((sqrt((1.0 / x)) * 0.5) + t_1) + t_2;
} else if (t_3 <= 1.0001) {
tmp = fma(sqrt((1.0 / y)), 0.5, (t_4 - sqrt(x))) + t_2;
} else if (t_3 <= 2.0002) {
tmp = (fma(sqrt((1.0 / z)), 0.5, sqrt((1.0 + y))) + t_4) - (sqrt(y) + sqrt(x));
} else {
tmp = (sqrt((z - -1.0)) - ((sqrt(z) + sqrt(y)) + sqrt(x))) + (sqrt((y - -1.0)) + sqrt((x - -1.0)));
}
return tmp;
}
x, y, z, t = sort([x, y, z, t]) function code(x, y, z, t) t_1 = Float64(sqrt(Float64(z + 1.0)) - sqrt(z)) t_2 = Float64(sqrt(Float64(t + 1.0)) - sqrt(t)) t_3 = Float64(Float64(Float64(Float64(sqrt(Float64(x + 1.0)) - sqrt(x)) + Float64(sqrt(Float64(y + 1.0)) - sqrt(y))) + t_1) + t_2) t_4 = sqrt(Float64(1.0 + x)) tmp = 0.0 if (t_3 <= 2e-6) tmp = Float64(Float64(Float64(sqrt(Float64(1.0 / x)) * 0.5) + t_1) + t_2); elseif (t_3 <= 1.0001) tmp = Float64(fma(sqrt(Float64(1.0 / y)), 0.5, Float64(t_4 - sqrt(x))) + t_2); elseif (t_3 <= 2.0002) tmp = Float64(Float64(fma(sqrt(Float64(1.0 / z)), 0.5, sqrt(Float64(1.0 + y))) + t_4) - Float64(sqrt(y) + sqrt(x))); else tmp = Float64(Float64(sqrt(Float64(z - -1.0)) - Float64(Float64(sqrt(z) + sqrt(y)) + sqrt(x))) + Float64(sqrt(Float64(y - -1.0)) + sqrt(Float64(x - -1.0)))); end return tmp end
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[Sqrt[N[(z + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[z], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[Sqrt[N[(t + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[t], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(N[(N[(N[Sqrt[N[(x + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(y + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision] + t$95$2), $MachinePrecision]}, Block[{t$95$4 = N[Sqrt[N[(1.0 + x), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[t$95$3, 2e-6], N[(N[(N[(N[Sqrt[N[(1.0 / x), $MachinePrecision]], $MachinePrecision] * 0.5), $MachinePrecision] + t$95$1), $MachinePrecision] + t$95$2), $MachinePrecision], If[LessEqual[t$95$3, 1.0001], N[(N[(N[Sqrt[N[(1.0 / y), $MachinePrecision]], $MachinePrecision] * 0.5 + N[(t$95$4 - N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$2), $MachinePrecision], If[LessEqual[t$95$3, 2.0002], N[(N[(N[(N[Sqrt[N[(1.0 / z), $MachinePrecision]], $MachinePrecision] * 0.5 + N[Sqrt[N[(1.0 + y), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] + t$95$4), $MachinePrecision] - N[(N[Sqrt[y], $MachinePrecision] + N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Sqrt[N[(z - -1.0), $MachinePrecision]], $MachinePrecision] - N[(N[(N[Sqrt[z], $MachinePrecision] + N[Sqrt[y], $MachinePrecision]), $MachinePrecision] + N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(y - -1.0), $MachinePrecision]], $MachinePrecision] + N[Sqrt[N[(x - -1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]
\begin{array}{l}
[x, y, z, t] = \mathsf{sort}([x, y, z, t])\\
\\
\begin{array}{l}
t_1 := \sqrt{z + 1} - \sqrt{z}\\
t_2 := \sqrt{t + 1} - \sqrt{t}\\
t_3 := \left(\left(\left(\sqrt{x + 1} - \sqrt{x}\right) + \left(\sqrt{y + 1} - \sqrt{y}\right)\right) + t\_1\right) + t\_2\\
t_4 := \sqrt{1 + x}\\
\mathbf{if}\;t\_3 \leq 2 \cdot 10^{-6}:\\
\;\;\;\;\left(\sqrt{\frac{1}{x}} \cdot 0.5 + t\_1\right) + t\_2\\
\mathbf{elif}\;t\_3 \leq 1.0001:\\
\;\;\;\;\mathsf{fma}\left(\sqrt{\frac{1}{y}}, 0.5, t\_4 - \sqrt{x}\right) + t\_2\\
\mathbf{elif}\;t\_3 \leq 2.0002:\\
\;\;\;\;\left(\mathsf{fma}\left(\sqrt{\frac{1}{z}}, 0.5, \sqrt{1 + y}\right) + t\_4\right) - \left(\sqrt{y} + \sqrt{x}\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\sqrt{z - -1} - \left(\left(\sqrt{z} + \sqrt{y}\right) + \sqrt{x}\right)\right) + \left(\sqrt{y - -1} + \sqrt{x - -1}\right)\\
\end{array}
\end{array}
if (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 1.99999999999999991e-6Initial program 10.2%
Taylor expanded in x around inf
+-commutativeN/A
associate--l+N/A
*-commutativeN/A
+-commutativeN/A
lower-fma.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower--.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-sqrt.f6426.5
Applied rewrites26.5%
Taylor expanded in x around 0
*-commutativeN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f6422.9
Applied rewrites22.9%
if 1.99999999999999991e-6 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 1.00009999999999999Initial program 94.5%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6495.1
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites95.1%
Taylor expanded in z around inf
lower--.f64N/A
Applied rewrites52.8%
Taylor expanded in y around inf
+-commutativeN/A
*-commutativeN/A
associate-+r-N/A
lower-fma.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
lower--.f64N/A
+-commutativeN/A
lower-sqrt.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-sqrt.f6456.0
Applied rewrites56.0%
if 1.00009999999999999 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 2.00019999999999998Initial program 95.7%
Taylor expanded in t around inf
lower--.f64N/A
Applied rewrites4.9%
Taylor expanded in z around inf
lower--.f64N/A
Applied rewrites18.5%
if 2.00019999999999998 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) Initial program 98.5%
Taylor expanded in t around inf
lower--.f64N/A
Applied rewrites23.9%
lift--.f64N/A
lift-+.f64N/A
associate--l+N/A
+-commutativeN/A
lower-+.f64N/A
lower--.f6426.7
lift-+.f64N/A
+-commutativeN/A
metadata-evalN/A
metadata-evalN/A
fp-cancel-sub-signN/A
metadata-evalN/A
lift--.f6426.7
lift-+.f64N/A
+-commutativeN/A
Applied rewrites26.7%
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (- (sqrt (+ t 1.0)) (sqrt t)))
(t_2
(+
(+
(+ (- (sqrt (+ x 1.0)) (sqrt x)) (- (sqrt (+ y 1.0)) (sqrt y)))
(- (sqrt (+ z 1.0)) (sqrt z)))
t_1))
(t_3 (sqrt (+ 1.0 y)))
(t_4 (/ 1.0 (+ t_3 (sqrt y)))))
(if (<= t_2 2e-6)
(+ (fma (sqrt (/ 1.0 x)) 0.5 t_4) t_1)
(if (<= t_2 2.0002)
(+ (- (+ (fma (sqrt (/ 1.0 z)) 0.5 t_4) (sqrt (+ 1.0 x))) (sqrt x)) t_1)
(+
1.0
(-
(+ (+ (/ 1.0 (+ (sqrt (+ 1.0 t)) (sqrt t))) (sqrt (+ 1.0 z))) t_3)
(+ (+ (sqrt z) (sqrt y)) (sqrt x))))))))assert(x < y && y < z && z < t);
double code(double x, double y, double z, double t) {
double t_1 = sqrt((t + 1.0)) - sqrt(t);
double t_2 = (((sqrt((x + 1.0)) - sqrt(x)) + (sqrt((y + 1.0)) - sqrt(y))) + (sqrt((z + 1.0)) - sqrt(z))) + t_1;
double t_3 = sqrt((1.0 + y));
double t_4 = 1.0 / (t_3 + sqrt(y));
double tmp;
if (t_2 <= 2e-6) {
tmp = fma(sqrt((1.0 / x)), 0.5, t_4) + t_1;
} else if (t_2 <= 2.0002) {
tmp = ((fma(sqrt((1.0 / z)), 0.5, t_4) + sqrt((1.0 + x))) - sqrt(x)) + t_1;
} else {
tmp = 1.0 + ((((1.0 / (sqrt((1.0 + t)) + sqrt(t))) + sqrt((1.0 + z))) + t_3) - ((sqrt(z) + sqrt(y)) + sqrt(x)));
}
return tmp;
}
x, y, z, t = sort([x, y, z, t]) function code(x, y, z, t) t_1 = Float64(sqrt(Float64(t + 1.0)) - sqrt(t)) t_2 = Float64(Float64(Float64(Float64(sqrt(Float64(x + 1.0)) - sqrt(x)) + Float64(sqrt(Float64(y + 1.0)) - sqrt(y))) + Float64(sqrt(Float64(z + 1.0)) - sqrt(z))) + t_1) t_3 = sqrt(Float64(1.0 + y)) t_4 = Float64(1.0 / Float64(t_3 + sqrt(y))) tmp = 0.0 if (t_2 <= 2e-6) tmp = Float64(fma(sqrt(Float64(1.0 / x)), 0.5, t_4) + t_1); elseif (t_2 <= 2.0002) tmp = Float64(Float64(Float64(fma(sqrt(Float64(1.0 / z)), 0.5, t_4) + sqrt(Float64(1.0 + x))) - sqrt(x)) + t_1); else tmp = Float64(1.0 + Float64(Float64(Float64(Float64(1.0 / Float64(sqrt(Float64(1.0 + t)) + sqrt(t))) + sqrt(Float64(1.0 + z))) + t_3) - Float64(Float64(sqrt(z) + sqrt(y)) + sqrt(x)))); end return tmp end
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[Sqrt[N[(t + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[t], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(N[(N[Sqrt[N[(x + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(y + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(z + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]}, Block[{t$95$3 = N[Sqrt[N[(1.0 + y), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$4 = N[(1.0 / N[(t$95$3 + N[Sqrt[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, 2e-6], N[(N[(N[Sqrt[N[(1.0 / x), $MachinePrecision]], $MachinePrecision] * 0.5 + t$95$4), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[t$95$2, 2.0002], N[(N[(N[(N[(N[Sqrt[N[(1.0 / z), $MachinePrecision]], $MachinePrecision] * 0.5 + t$95$4), $MachinePrecision] + N[Sqrt[N[(1.0 + x), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], N[(1.0 + N[(N[(N[(N[(1.0 / N[(N[Sqrt[N[(1.0 + t), $MachinePrecision]], $MachinePrecision] + N[Sqrt[t], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[Sqrt[N[(1.0 + z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] + t$95$3), $MachinePrecision] - N[(N[(N[Sqrt[z], $MachinePrecision] + N[Sqrt[y], $MachinePrecision]), $MachinePrecision] + N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
[x, y, z, t] = \mathsf{sort}([x, y, z, t])\\
\\
\begin{array}{l}
t_1 := \sqrt{t + 1} - \sqrt{t}\\
t_2 := \left(\left(\left(\sqrt{x + 1} - \sqrt{x}\right) + \left(\sqrt{y + 1} - \sqrt{y}\right)\right) + \left(\sqrt{z + 1} - \sqrt{z}\right)\right) + t\_1\\
t_3 := \sqrt{1 + y}\\
t_4 := \frac{1}{t\_3 + \sqrt{y}}\\
\mathbf{if}\;t\_2 \leq 2 \cdot 10^{-6}:\\
\;\;\;\;\mathsf{fma}\left(\sqrt{\frac{1}{x}}, 0.5, t\_4\right) + t\_1\\
\mathbf{elif}\;t\_2 \leq 2.0002:\\
\;\;\;\;\left(\left(\mathsf{fma}\left(\sqrt{\frac{1}{z}}, 0.5, t\_4\right) + \sqrt{1 + x}\right) - \sqrt{x}\right) + t\_1\\
\mathbf{else}:\\
\;\;\;\;1 + \left(\left(\left(\frac{1}{\sqrt{1 + t} + \sqrt{t}} + \sqrt{1 + z}\right) + t\_3\right) - \left(\left(\sqrt{z} + \sqrt{y}\right) + \sqrt{x}\right)\right)\\
\end{array}
\end{array}
if (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 1.99999999999999991e-6Initial program 10.2%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6415.7
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites15.7%
Taylor expanded in z around inf
lower--.f64N/A
Applied rewrites3.4%
Taylor expanded in x around inf
*-commutativeN/A
lower-fma.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-sqrt.f6446.9
Applied rewrites46.9%
if 1.99999999999999991e-6 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 2.00019999999999998Initial program 95.3%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6495.5
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites95.5%
Taylor expanded in z around inf
lower--.f64N/A
Applied rewrites45.5%
if 2.00019999999999998 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) Initial program 98.5%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6498.6
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites98.6%
Taylor expanded in x around 0
associate--l+N/A
lower-+.f64N/A
lower--.f64N/A
Applied rewrites46.8%
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (- (sqrt (+ t 1.0)) (sqrt t)))
(t_2
(+
(+
(+ (- (sqrt (+ x 1.0)) (sqrt x)) (- (sqrt (+ y 1.0)) (sqrt y)))
(- (sqrt (+ z 1.0)) (sqrt z)))
t_1))
(t_3 (sqrt (+ 1.0 y)))
(t_4 (/ 1.0 (+ t_3 (sqrt y)))))
(if (<= t_2 2e-6)
(+ (fma (sqrt (/ 1.0 x)) 0.5 t_4) t_1)
(if (<= t_2 1.65)
(+ (- (+ (sqrt (+ 1.0 x)) t_4) (sqrt x)) t_1)
(+
(+
1.0
(-
(+ (/ 1.0 (+ (sqrt (+ 1.0 z)) (sqrt z))) t_3)
(+ (sqrt y) (sqrt x))))
t_1)))))assert(x < y && y < z && z < t);
double code(double x, double y, double z, double t) {
double t_1 = sqrt((t + 1.0)) - sqrt(t);
double t_2 = (((sqrt((x + 1.0)) - sqrt(x)) + (sqrt((y + 1.0)) - sqrt(y))) + (sqrt((z + 1.0)) - sqrt(z))) + t_1;
double t_3 = sqrt((1.0 + y));
double t_4 = 1.0 / (t_3 + sqrt(y));
double tmp;
if (t_2 <= 2e-6) {
tmp = fma(sqrt((1.0 / x)), 0.5, t_4) + t_1;
} else if (t_2 <= 1.65) {
tmp = ((sqrt((1.0 + x)) + t_4) - sqrt(x)) + t_1;
} else {
tmp = (1.0 + (((1.0 / (sqrt((1.0 + z)) + sqrt(z))) + t_3) - (sqrt(y) + sqrt(x)))) + t_1;
}
return tmp;
}
x, y, z, t = sort([x, y, z, t]) function code(x, y, z, t) t_1 = Float64(sqrt(Float64(t + 1.0)) - sqrt(t)) t_2 = Float64(Float64(Float64(Float64(sqrt(Float64(x + 1.0)) - sqrt(x)) + Float64(sqrt(Float64(y + 1.0)) - sqrt(y))) + Float64(sqrt(Float64(z + 1.0)) - sqrt(z))) + t_1) t_3 = sqrt(Float64(1.0 + y)) t_4 = Float64(1.0 / Float64(t_3 + sqrt(y))) tmp = 0.0 if (t_2 <= 2e-6) tmp = Float64(fma(sqrt(Float64(1.0 / x)), 0.5, t_4) + t_1); elseif (t_2 <= 1.65) tmp = Float64(Float64(Float64(sqrt(Float64(1.0 + x)) + t_4) - sqrt(x)) + t_1); else tmp = Float64(Float64(1.0 + Float64(Float64(Float64(1.0 / Float64(sqrt(Float64(1.0 + z)) + sqrt(z))) + t_3) - Float64(sqrt(y) + sqrt(x)))) + t_1); end return tmp end
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[Sqrt[N[(t + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[t], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(N[(N[Sqrt[N[(x + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(y + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(z + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]}, Block[{t$95$3 = N[Sqrt[N[(1.0 + y), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$4 = N[(1.0 / N[(t$95$3 + N[Sqrt[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, 2e-6], N[(N[(N[Sqrt[N[(1.0 / x), $MachinePrecision]], $MachinePrecision] * 0.5 + t$95$4), $MachinePrecision] + t$95$1), $MachinePrecision], If[LessEqual[t$95$2, 1.65], N[(N[(N[(N[Sqrt[N[(1.0 + x), $MachinePrecision]], $MachinePrecision] + t$95$4), $MachinePrecision] - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision], N[(N[(1.0 + N[(N[(N[(1.0 / N[(N[Sqrt[N[(1.0 + z), $MachinePrecision]], $MachinePrecision] + N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$3), $MachinePrecision] - N[(N[Sqrt[y], $MachinePrecision] + N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]]]]]]]
\begin{array}{l}
[x, y, z, t] = \mathsf{sort}([x, y, z, t])\\
\\
\begin{array}{l}
t_1 := \sqrt{t + 1} - \sqrt{t}\\
t_2 := \left(\left(\left(\sqrt{x + 1} - \sqrt{x}\right) + \left(\sqrt{y + 1} - \sqrt{y}\right)\right) + \left(\sqrt{z + 1} - \sqrt{z}\right)\right) + t\_1\\
t_3 := \sqrt{1 + y}\\
t_4 := \frac{1}{t\_3 + \sqrt{y}}\\
\mathbf{if}\;t\_2 \leq 2 \cdot 10^{-6}:\\
\;\;\;\;\mathsf{fma}\left(\sqrt{\frac{1}{x}}, 0.5, t\_4\right) + t\_1\\
\mathbf{elif}\;t\_2 \leq 1.65:\\
\;\;\;\;\left(\left(\sqrt{1 + x} + t\_4\right) - \sqrt{x}\right) + t\_1\\
\mathbf{else}:\\
\;\;\;\;\left(1 + \left(\left(\frac{1}{\sqrt{1 + z} + \sqrt{z}} + t\_3\right) - \left(\sqrt{y} + \sqrt{x}\right)\right)\right) + t\_1\\
\end{array}
\end{array}
if (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 1.99999999999999991e-6Initial program 10.2%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6415.7
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites15.7%
Taylor expanded in z around inf
lower--.f64N/A
Applied rewrites3.4%
Taylor expanded in x around inf
*-commutativeN/A
lower-fma.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-sqrt.f64N/A
lower-+.f64N/A
lower-sqrt.f6446.9
Applied rewrites46.9%
if 1.99999999999999991e-6 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 1.6499999999999999Initial program 94.5%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6495.1
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites95.1%
Taylor expanded in z around inf
lower--.f64N/A
Applied rewrites52.8%
if 1.6499999999999999 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) Initial program 97.1%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6497.3
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites97.3%
Taylor expanded in x around 0
associate--l+N/A
lower-+.f64N/A
lower--.f64N/A
Applied rewrites49.7%
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (sqrt (+ 1.0 x)))
(t_2 (- (sqrt (+ t 1.0)) (sqrt t)))
(t_3
(+
(+
(+ (- (sqrt (+ x 1.0)) (sqrt x)) (- (sqrt (+ y 1.0)) (sqrt y)))
(- (sqrt (+ z 1.0)) (sqrt z)))
t_2)))
(if (<= t_3 1.0001)
(+ (fma (sqrt (/ 1.0 y)) 0.5 (- t_1 (sqrt x))) t_2)
(if (<= t_3 2.0002)
(-
(+ (fma (sqrt (/ 1.0 z)) 0.5 (sqrt (+ 1.0 y))) t_1)
(+ (sqrt y) (sqrt x)))
(+
(- (sqrt (- z -1.0)) (+ (+ (sqrt z) (sqrt y)) (sqrt x)))
(+ (sqrt (- y -1.0)) (sqrt (- x -1.0))))))))assert(x < y && y < z && z < t);
double code(double x, double y, double z, double t) {
double t_1 = sqrt((1.0 + x));
double t_2 = sqrt((t + 1.0)) - sqrt(t);
double t_3 = (((sqrt((x + 1.0)) - sqrt(x)) + (sqrt((y + 1.0)) - sqrt(y))) + (sqrt((z + 1.0)) - sqrt(z))) + t_2;
double tmp;
if (t_3 <= 1.0001) {
tmp = fma(sqrt((1.0 / y)), 0.5, (t_1 - sqrt(x))) + t_2;
} else if (t_3 <= 2.0002) {
tmp = (fma(sqrt((1.0 / z)), 0.5, sqrt((1.0 + y))) + t_1) - (sqrt(y) + sqrt(x));
} else {
tmp = (sqrt((z - -1.0)) - ((sqrt(z) + sqrt(y)) + sqrt(x))) + (sqrt((y - -1.0)) + sqrt((x - -1.0)));
}
return tmp;
}
x, y, z, t = sort([x, y, z, t]) function code(x, y, z, t) t_1 = sqrt(Float64(1.0 + x)) t_2 = Float64(sqrt(Float64(t + 1.0)) - sqrt(t)) t_3 = Float64(Float64(Float64(Float64(sqrt(Float64(x + 1.0)) - sqrt(x)) + Float64(sqrt(Float64(y + 1.0)) - sqrt(y))) + Float64(sqrt(Float64(z + 1.0)) - sqrt(z))) + t_2) tmp = 0.0 if (t_3 <= 1.0001) tmp = Float64(fma(sqrt(Float64(1.0 / y)), 0.5, Float64(t_1 - sqrt(x))) + t_2); elseif (t_3 <= 2.0002) tmp = Float64(Float64(fma(sqrt(Float64(1.0 / z)), 0.5, sqrt(Float64(1.0 + y))) + t_1) - Float64(sqrt(y) + sqrt(x))); else tmp = Float64(Float64(sqrt(Float64(z - -1.0)) - Float64(Float64(sqrt(z) + sqrt(y)) + sqrt(x))) + Float64(sqrt(Float64(y - -1.0)) + sqrt(Float64(x - -1.0)))); end return tmp end
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_] := Block[{t$95$1 = N[Sqrt[N[(1.0 + x), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[(N[Sqrt[N[(t + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[t], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(N[(N[(N[Sqrt[N[(x + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(y + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(z + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$2), $MachinePrecision]}, If[LessEqual[t$95$3, 1.0001], N[(N[(N[Sqrt[N[(1.0 / y), $MachinePrecision]], $MachinePrecision] * 0.5 + N[(t$95$1 - N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$2), $MachinePrecision], If[LessEqual[t$95$3, 2.0002], N[(N[(N[(N[Sqrt[N[(1.0 / z), $MachinePrecision]], $MachinePrecision] * 0.5 + N[Sqrt[N[(1.0 + y), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision] - N[(N[Sqrt[y], $MachinePrecision] + N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Sqrt[N[(z - -1.0), $MachinePrecision]], $MachinePrecision] - N[(N[(N[Sqrt[z], $MachinePrecision] + N[Sqrt[y], $MachinePrecision]), $MachinePrecision] + N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(y - -1.0), $MachinePrecision]], $MachinePrecision] + N[Sqrt[N[(x - -1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
[x, y, z, t] = \mathsf{sort}([x, y, z, t])\\
\\
\begin{array}{l}
t_1 := \sqrt{1 + x}\\
t_2 := \sqrt{t + 1} - \sqrt{t}\\
t_3 := \left(\left(\left(\sqrt{x + 1} - \sqrt{x}\right) + \left(\sqrt{y + 1} - \sqrt{y}\right)\right) + \left(\sqrt{z + 1} - \sqrt{z}\right)\right) + t\_2\\
\mathbf{if}\;t\_3 \leq 1.0001:\\
\;\;\;\;\mathsf{fma}\left(\sqrt{\frac{1}{y}}, 0.5, t\_1 - \sqrt{x}\right) + t\_2\\
\mathbf{elif}\;t\_3 \leq 2.0002:\\
\;\;\;\;\left(\mathsf{fma}\left(\sqrt{\frac{1}{z}}, 0.5, \sqrt{1 + y}\right) + t\_1\right) - \left(\sqrt{y} + \sqrt{x}\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\sqrt{z - -1} - \left(\left(\sqrt{z} + \sqrt{y}\right) + \sqrt{x}\right)\right) + \left(\sqrt{y - -1} + \sqrt{x - -1}\right)\\
\end{array}
\end{array}
if (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 1.00009999999999999Initial program 82.2%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6483.6
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites83.6%
Taylor expanded in z around inf
lower--.f64N/A
Applied rewrites45.7%
Taylor expanded in y around inf
+-commutativeN/A
*-commutativeN/A
associate-+r-N/A
lower-fma.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
lower--.f64N/A
+-commutativeN/A
lower-sqrt.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-sqrt.f6452.0
Applied rewrites52.0%
if 1.00009999999999999 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 2.00019999999999998Initial program 95.7%
Taylor expanded in t around inf
lower--.f64N/A
Applied rewrites4.9%
Taylor expanded in z around inf
lower--.f64N/A
Applied rewrites18.5%
if 2.00019999999999998 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) Initial program 98.5%
Taylor expanded in t around inf
lower--.f64N/A
Applied rewrites23.9%
lift--.f64N/A
lift-+.f64N/A
associate--l+N/A
+-commutativeN/A
lower-+.f64N/A
lower--.f6426.7
lift-+.f64N/A
+-commutativeN/A
metadata-evalN/A
metadata-evalN/A
fp-cancel-sub-signN/A
metadata-evalN/A
lift--.f6426.7
lift-+.f64N/A
+-commutativeN/A
Applied rewrites26.7%
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (sqrt (+ 1.0 x)))
(t_2 (- (sqrt (+ t 1.0)) (sqrt t)))
(t_3
(+
(+
(+ (- (sqrt (+ x 1.0)) (sqrt x)) (- (sqrt (+ y 1.0)) (sqrt y)))
(- (sqrt (+ z 1.0)) (sqrt z)))
t_2))
(t_4 (sqrt (+ 1.0 y))))
(if (<= t_3 1.0001)
(+ (fma (sqrt (/ 1.0 y)) 0.5 (- t_1 (sqrt x))) t_2)
(if (<= t_3 2.0002)
(- (+ (fma (sqrt (/ 1.0 z)) 0.5 t_4) t_1) (+ (sqrt y) (sqrt x)))
(-
(+ (+ t_4 1.0) (sqrt (+ 1.0 z)))
(+ (+ (sqrt z) (sqrt y)) (sqrt x)))))))assert(x < y && y < z && z < t);
double code(double x, double y, double z, double t) {
double t_1 = sqrt((1.0 + x));
double t_2 = sqrt((t + 1.0)) - sqrt(t);
double t_3 = (((sqrt((x + 1.0)) - sqrt(x)) + (sqrt((y + 1.0)) - sqrt(y))) + (sqrt((z + 1.0)) - sqrt(z))) + t_2;
double t_4 = sqrt((1.0 + y));
double tmp;
if (t_3 <= 1.0001) {
tmp = fma(sqrt((1.0 / y)), 0.5, (t_1 - sqrt(x))) + t_2;
} else if (t_3 <= 2.0002) {
tmp = (fma(sqrt((1.0 / z)), 0.5, t_4) + t_1) - (sqrt(y) + sqrt(x));
} else {
tmp = ((t_4 + 1.0) + sqrt((1.0 + z))) - ((sqrt(z) + sqrt(y)) + sqrt(x));
}
return tmp;
}
x, y, z, t = sort([x, y, z, t]) function code(x, y, z, t) t_1 = sqrt(Float64(1.0 + x)) t_2 = Float64(sqrt(Float64(t + 1.0)) - sqrt(t)) t_3 = Float64(Float64(Float64(Float64(sqrt(Float64(x + 1.0)) - sqrt(x)) + Float64(sqrt(Float64(y + 1.0)) - sqrt(y))) + Float64(sqrt(Float64(z + 1.0)) - sqrt(z))) + t_2) t_4 = sqrt(Float64(1.0 + y)) tmp = 0.0 if (t_3 <= 1.0001) tmp = Float64(fma(sqrt(Float64(1.0 / y)), 0.5, Float64(t_1 - sqrt(x))) + t_2); elseif (t_3 <= 2.0002) tmp = Float64(Float64(fma(sqrt(Float64(1.0 / z)), 0.5, t_4) + t_1) - Float64(sqrt(y) + sqrt(x))); else tmp = Float64(Float64(Float64(t_4 + 1.0) + sqrt(Float64(1.0 + z))) - Float64(Float64(sqrt(z) + sqrt(y)) + sqrt(x))); end return tmp end
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_] := Block[{t$95$1 = N[Sqrt[N[(1.0 + x), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[(N[Sqrt[N[(t + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[t], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(N[(N[(N[Sqrt[N[(x + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(y + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(z + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$2), $MachinePrecision]}, Block[{t$95$4 = N[Sqrt[N[(1.0 + y), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[t$95$3, 1.0001], N[(N[(N[Sqrt[N[(1.0 / y), $MachinePrecision]], $MachinePrecision] * 0.5 + N[(t$95$1 - N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$2), $MachinePrecision], If[LessEqual[t$95$3, 2.0002], N[(N[(N[(N[Sqrt[N[(1.0 / z), $MachinePrecision]], $MachinePrecision] * 0.5 + t$95$4), $MachinePrecision] + t$95$1), $MachinePrecision] - N[(N[Sqrt[y], $MachinePrecision] + N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(t$95$4 + 1.0), $MachinePrecision] + N[Sqrt[N[(1.0 + z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - N[(N[(N[Sqrt[z], $MachinePrecision] + N[Sqrt[y], $MachinePrecision]), $MachinePrecision] + N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
[x, y, z, t] = \mathsf{sort}([x, y, z, t])\\
\\
\begin{array}{l}
t_1 := \sqrt{1 + x}\\
t_2 := \sqrt{t + 1} - \sqrt{t}\\
t_3 := \left(\left(\left(\sqrt{x + 1} - \sqrt{x}\right) + \left(\sqrt{y + 1} - \sqrt{y}\right)\right) + \left(\sqrt{z + 1} - \sqrt{z}\right)\right) + t\_2\\
t_4 := \sqrt{1 + y}\\
\mathbf{if}\;t\_3 \leq 1.0001:\\
\;\;\;\;\mathsf{fma}\left(\sqrt{\frac{1}{y}}, 0.5, t\_1 - \sqrt{x}\right) + t\_2\\
\mathbf{elif}\;t\_3 \leq 2.0002:\\
\;\;\;\;\left(\mathsf{fma}\left(\sqrt{\frac{1}{z}}, 0.5, t\_4\right) + t\_1\right) - \left(\sqrt{y} + \sqrt{x}\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(t\_4 + 1\right) + \sqrt{1 + z}\right) - \left(\left(\sqrt{z} + \sqrt{y}\right) + \sqrt{x}\right)\\
\end{array}
\end{array}
if (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 1.00009999999999999Initial program 82.2%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6483.6
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites83.6%
Taylor expanded in z around inf
lower--.f64N/A
Applied rewrites45.7%
Taylor expanded in y around inf
+-commutativeN/A
*-commutativeN/A
associate-+r-N/A
lower-fma.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
lower--.f64N/A
+-commutativeN/A
lower-sqrt.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-sqrt.f6452.0
Applied rewrites52.0%
if 1.00009999999999999 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 2.00019999999999998Initial program 95.7%
Taylor expanded in t around inf
lower--.f64N/A
Applied rewrites4.9%
Taylor expanded in z around inf
lower--.f64N/A
Applied rewrites18.5%
if 2.00019999999999998 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) Initial program 98.5%
Taylor expanded in t around inf
lower--.f64N/A
Applied rewrites23.9%
Taylor expanded in x around 0
+-commutativeN/A
lower-+.f64N/A
+-commutativeN/A
lower-sqrt.f64N/A
+-commutativeN/A
lower-+.f6422.7
Applied rewrites22.7%
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (sqrt (+ 1.0 x)))
(t_2 (- (sqrt (+ t 1.0)) (sqrt t)))
(t_3
(+
(+
(+ (- (sqrt (+ x 1.0)) (sqrt x)) (- (sqrt (+ y 1.0)) (sqrt y)))
(- (sqrt (+ z 1.0)) (sqrt z)))
t_2))
(t_4 (sqrt (+ 1.0 y))))
(if (<= t_3 1.00000005)
(+ (- t_1 (sqrt x)) t_2)
(if (<= t_3 2.0002)
(- (+ (fma (sqrt (/ 1.0 z)) 0.5 t_4) t_1) (+ (sqrt y) (sqrt x)))
(-
(+ (+ t_4 1.0) (sqrt (+ 1.0 z)))
(+ (+ (sqrt z) (sqrt y)) (sqrt x)))))))assert(x < y && y < z && z < t);
double code(double x, double y, double z, double t) {
double t_1 = sqrt((1.0 + x));
double t_2 = sqrt((t + 1.0)) - sqrt(t);
double t_3 = (((sqrt((x + 1.0)) - sqrt(x)) + (sqrt((y + 1.0)) - sqrt(y))) + (sqrt((z + 1.0)) - sqrt(z))) + t_2;
double t_4 = sqrt((1.0 + y));
double tmp;
if (t_3 <= 1.00000005) {
tmp = (t_1 - sqrt(x)) + t_2;
} else if (t_3 <= 2.0002) {
tmp = (fma(sqrt((1.0 / z)), 0.5, t_4) + t_1) - (sqrt(y) + sqrt(x));
} else {
tmp = ((t_4 + 1.0) + sqrt((1.0 + z))) - ((sqrt(z) + sqrt(y)) + sqrt(x));
}
return tmp;
}
x, y, z, t = sort([x, y, z, t]) function code(x, y, z, t) t_1 = sqrt(Float64(1.0 + x)) t_2 = Float64(sqrt(Float64(t + 1.0)) - sqrt(t)) t_3 = Float64(Float64(Float64(Float64(sqrt(Float64(x + 1.0)) - sqrt(x)) + Float64(sqrt(Float64(y + 1.0)) - sqrt(y))) + Float64(sqrt(Float64(z + 1.0)) - sqrt(z))) + t_2) t_4 = sqrt(Float64(1.0 + y)) tmp = 0.0 if (t_3 <= 1.00000005) tmp = Float64(Float64(t_1 - sqrt(x)) + t_2); elseif (t_3 <= 2.0002) tmp = Float64(Float64(fma(sqrt(Float64(1.0 / z)), 0.5, t_4) + t_1) - Float64(sqrt(y) + sqrt(x))); else tmp = Float64(Float64(Float64(t_4 + 1.0) + sqrt(Float64(1.0 + z))) - Float64(Float64(sqrt(z) + sqrt(y)) + sqrt(x))); end return tmp end
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_] := Block[{t$95$1 = N[Sqrt[N[(1.0 + x), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[(N[Sqrt[N[(t + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[t], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(N[(N[(N[Sqrt[N[(x + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(y + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(z + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$2), $MachinePrecision]}, Block[{t$95$4 = N[Sqrt[N[(1.0 + y), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[t$95$3, 1.00000005], N[(N[(t$95$1 - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + t$95$2), $MachinePrecision], If[LessEqual[t$95$3, 2.0002], N[(N[(N[(N[Sqrt[N[(1.0 / z), $MachinePrecision]], $MachinePrecision] * 0.5 + t$95$4), $MachinePrecision] + t$95$1), $MachinePrecision] - N[(N[Sqrt[y], $MachinePrecision] + N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(t$95$4 + 1.0), $MachinePrecision] + N[Sqrt[N[(1.0 + z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - N[(N[(N[Sqrt[z], $MachinePrecision] + N[Sqrt[y], $MachinePrecision]), $MachinePrecision] + N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
[x, y, z, t] = \mathsf{sort}([x, y, z, t])\\
\\
\begin{array}{l}
t_1 := \sqrt{1 + x}\\
t_2 := \sqrt{t + 1} - \sqrt{t}\\
t_3 := \left(\left(\left(\sqrt{x + 1} - \sqrt{x}\right) + \left(\sqrt{y + 1} - \sqrt{y}\right)\right) + \left(\sqrt{z + 1} - \sqrt{z}\right)\right) + t\_2\\
t_4 := \sqrt{1 + y}\\
\mathbf{if}\;t\_3 \leq 1.00000005:\\
\;\;\;\;\left(t\_1 - \sqrt{x}\right) + t\_2\\
\mathbf{elif}\;t\_3 \leq 2.0002:\\
\;\;\;\;\left(\mathsf{fma}\left(\sqrt{\frac{1}{z}}, 0.5, t\_4\right) + t\_1\right) - \left(\sqrt{y} + \sqrt{x}\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(t\_4 + 1\right) + \sqrt{1 + z}\right) - \left(\left(\sqrt{z} + \sqrt{y}\right) + \sqrt{x}\right)\\
\end{array}
\end{array}
if (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 1.00000004999999992Initial program 82.9%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6483.8
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites83.8%
Taylor expanded in z around inf
lower--.f64N/A
Applied rewrites45.8%
Taylor expanded in y around inf
+-commutativeN/A
lower-sqrt.f64N/A
+-commutativeN/A
lower-+.f6445.6
Applied rewrites45.6%
if 1.00000004999999992 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 2.00019999999999998Initial program 94.8%
Taylor expanded in t around inf
lower--.f64N/A
Applied rewrites4.8%
Taylor expanded in z around inf
lower--.f64N/A
Applied rewrites17.9%
if 2.00019999999999998 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) Initial program 98.5%
Taylor expanded in t around inf
lower--.f64N/A
Applied rewrites23.9%
Taylor expanded in x around 0
+-commutativeN/A
lower-+.f64N/A
+-commutativeN/A
lower-sqrt.f64N/A
+-commutativeN/A
lower-+.f6422.7
Applied rewrites22.7%
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (sqrt (+ 1.0 x)))
(t_2 (sqrt (+ 1.0 y)))
(t_3 (- (sqrt (+ t 1.0)) (sqrt t)))
(t_4
(+
(+
(+ (- (sqrt (+ x 1.0)) (sqrt x)) (- (sqrt (+ y 1.0)) (sqrt y)))
(- (sqrt (+ z 1.0)) (sqrt z)))
t_3)))
(if (<= t_4 1.00000005)
(+ (- t_1 (sqrt x)) t_3)
(if (<= t_4 2.0)
(- (+ t_1 t_2) (+ (sqrt y) (sqrt x)))
(-
(+ (+ t_2 1.0) (sqrt (+ 1.0 z)))
(+ (+ (sqrt z) (sqrt y)) (sqrt x)))))))assert(x < y && y < z && z < t);
double code(double x, double y, double z, double t) {
double t_1 = sqrt((1.0 + x));
double t_2 = sqrt((1.0 + y));
double t_3 = sqrt((t + 1.0)) - sqrt(t);
double t_4 = (((sqrt((x + 1.0)) - sqrt(x)) + (sqrt((y + 1.0)) - sqrt(y))) + (sqrt((z + 1.0)) - sqrt(z))) + t_3;
double tmp;
if (t_4 <= 1.00000005) {
tmp = (t_1 - sqrt(x)) + t_3;
} else if (t_4 <= 2.0) {
tmp = (t_1 + t_2) - (sqrt(y) + sqrt(x));
} else {
tmp = ((t_2 + 1.0) + sqrt((1.0 + z))) - ((sqrt(z) + sqrt(y)) + sqrt(x));
}
return tmp;
}
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
module fmin_fmax_functions
implicit none
private
public fmax
public fmin
interface fmax
module procedure fmax88
module procedure fmax44
module procedure fmax84
module procedure fmax48
end interface
interface fmin
module procedure fmin88
module procedure fmin44
module procedure fmin84
module procedure fmin48
end interface
contains
real(8) function fmax88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(4) function fmax44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(8) function fmax84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, max(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmax48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), max(dble(x), y), y /= y), x /= x)
end function
real(8) function fmin88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(4) function fmin44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(8) function fmin84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, min(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmin48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), min(dble(x), y), y /= y), x /= x)
end function
end module
real(8) function code(x, y, z, t)
use fmin_fmax_functions
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: t_4
real(8) :: tmp
t_1 = sqrt((1.0d0 + x))
t_2 = sqrt((1.0d0 + y))
t_3 = sqrt((t + 1.0d0)) - sqrt(t)
t_4 = (((sqrt((x + 1.0d0)) - sqrt(x)) + (sqrt((y + 1.0d0)) - sqrt(y))) + (sqrt((z + 1.0d0)) - sqrt(z))) + t_3
if (t_4 <= 1.00000005d0) then
tmp = (t_1 - sqrt(x)) + t_3
else if (t_4 <= 2.0d0) then
tmp = (t_1 + t_2) - (sqrt(y) + sqrt(x))
else
tmp = ((t_2 + 1.0d0) + sqrt((1.0d0 + z))) - ((sqrt(z) + sqrt(y)) + sqrt(x))
end if
code = tmp
end function
assert x < y && y < z && z < t;
public static double code(double x, double y, double z, double t) {
double t_1 = Math.sqrt((1.0 + x));
double t_2 = Math.sqrt((1.0 + y));
double t_3 = Math.sqrt((t + 1.0)) - Math.sqrt(t);
double t_4 = (((Math.sqrt((x + 1.0)) - Math.sqrt(x)) + (Math.sqrt((y + 1.0)) - Math.sqrt(y))) + (Math.sqrt((z + 1.0)) - Math.sqrt(z))) + t_3;
double tmp;
if (t_4 <= 1.00000005) {
tmp = (t_1 - Math.sqrt(x)) + t_3;
} else if (t_4 <= 2.0) {
tmp = (t_1 + t_2) - (Math.sqrt(y) + Math.sqrt(x));
} else {
tmp = ((t_2 + 1.0) + Math.sqrt((1.0 + z))) - ((Math.sqrt(z) + Math.sqrt(y)) + Math.sqrt(x));
}
return tmp;
}
[x, y, z, t] = sort([x, y, z, t]) def code(x, y, z, t): t_1 = math.sqrt((1.0 + x)) t_2 = math.sqrt((1.0 + y)) t_3 = math.sqrt((t + 1.0)) - math.sqrt(t) t_4 = (((math.sqrt((x + 1.0)) - math.sqrt(x)) + (math.sqrt((y + 1.0)) - math.sqrt(y))) + (math.sqrt((z + 1.0)) - math.sqrt(z))) + t_3 tmp = 0 if t_4 <= 1.00000005: tmp = (t_1 - math.sqrt(x)) + t_3 elif t_4 <= 2.0: tmp = (t_1 + t_2) - (math.sqrt(y) + math.sqrt(x)) else: tmp = ((t_2 + 1.0) + math.sqrt((1.0 + z))) - ((math.sqrt(z) + math.sqrt(y)) + math.sqrt(x)) return tmp
x, y, z, t = sort([x, y, z, t]) function code(x, y, z, t) t_1 = sqrt(Float64(1.0 + x)) t_2 = sqrt(Float64(1.0 + y)) t_3 = Float64(sqrt(Float64(t + 1.0)) - sqrt(t)) t_4 = Float64(Float64(Float64(Float64(sqrt(Float64(x + 1.0)) - sqrt(x)) + Float64(sqrt(Float64(y + 1.0)) - sqrt(y))) + Float64(sqrt(Float64(z + 1.0)) - sqrt(z))) + t_3) tmp = 0.0 if (t_4 <= 1.00000005) tmp = Float64(Float64(t_1 - sqrt(x)) + t_3); elseif (t_4 <= 2.0) tmp = Float64(Float64(t_1 + t_2) - Float64(sqrt(y) + sqrt(x))); else tmp = Float64(Float64(Float64(t_2 + 1.0) + sqrt(Float64(1.0 + z))) - Float64(Float64(sqrt(z) + sqrt(y)) + sqrt(x))); end return tmp end
x, y, z, t = num2cell(sort([x, y, z, t])){:}
function tmp_2 = code(x, y, z, t)
t_1 = sqrt((1.0 + x));
t_2 = sqrt((1.0 + y));
t_3 = sqrt((t + 1.0)) - sqrt(t);
t_4 = (((sqrt((x + 1.0)) - sqrt(x)) + (sqrt((y + 1.0)) - sqrt(y))) + (sqrt((z + 1.0)) - sqrt(z))) + t_3;
tmp = 0.0;
if (t_4 <= 1.00000005)
tmp = (t_1 - sqrt(x)) + t_3;
elseif (t_4 <= 2.0)
tmp = (t_1 + t_2) - (sqrt(y) + sqrt(x));
else
tmp = ((t_2 + 1.0) + sqrt((1.0 + z))) - ((sqrt(z) + sqrt(y)) + sqrt(x));
end
tmp_2 = tmp;
end
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_] := Block[{t$95$1 = N[Sqrt[N[(1.0 + x), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[Sqrt[N[(1.0 + y), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$3 = N[(N[Sqrt[N[(t + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[t], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[(N[(N[(N[Sqrt[N[(x + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(y + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(z + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$3), $MachinePrecision]}, If[LessEqual[t$95$4, 1.00000005], N[(N[(t$95$1 - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + t$95$3), $MachinePrecision], If[LessEqual[t$95$4, 2.0], N[(N[(t$95$1 + t$95$2), $MachinePrecision] - N[(N[Sqrt[y], $MachinePrecision] + N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(t$95$2 + 1.0), $MachinePrecision] + N[Sqrt[N[(1.0 + z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - N[(N[(N[Sqrt[z], $MachinePrecision] + N[Sqrt[y], $MachinePrecision]), $MachinePrecision] + N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
[x, y, z, t] = \mathsf{sort}([x, y, z, t])\\
\\
\begin{array}{l}
t_1 := \sqrt{1 + x}\\
t_2 := \sqrt{1 + y}\\
t_3 := \sqrt{t + 1} - \sqrt{t}\\
t_4 := \left(\left(\left(\sqrt{x + 1} - \sqrt{x}\right) + \left(\sqrt{y + 1} - \sqrt{y}\right)\right) + \left(\sqrt{z + 1} - \sqrt{z}\right)\right) + t\_3\\
\mathbf{if}\;t\_4 \leq 1.00000005:\\
\;\;\;\;\left(t\_1 - \sqrt{x}\right) + t\_3\\
\mathbf{elif}\;t\_4 \leq 2:\\
\;\;\;\;\left(t\_1 + t\_2\right) - \left(\sqrt{y} + \sqrt{x}\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(t\_2 + 1\right) + \sqrt{1 + z}\right) - \left(\left(\sqrt{z} + \sqrt{y}\right) + \sqrt{x}\right)\\
\end{array}
\end{array}
if (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 1.00000004999999992Initial program 82.9%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6483.8
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites83.8%
Taylor expanded in z around inf
lower--.f64N/A
Applied rewrites45.8%
Taylor expanded in y around inf
+-commutativeN/A
lower-sqrt.f64N/A
+-commutativeN/A
lower-+.f6445.6
Applied rewrites45.6%
if 1.00000004999999992 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 2Initial program 95.5%
Taylor expanded in t around inf
lower--.f64N/A
Applied rewrites4.8%
Taylor expanded in z around inf
lower--.f64N/A
lower-+.f64N/A
+-commutativeN/A
lower-sqrt.f64N/A
+-commutativeN/A
lower-+.f64N/A
+-commutativeN/A
lower-sqrt.f64N/A
+-commutativeN/A
lower-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6417.6
Applied rewrites17.6%
if 2 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) Initial program 97.6%
Taylor expanded in t around inf
lower--.f64N/A
Applied rewrites23.2%
Taylor expanded in x around 0
+-commutativeN/A
lower-+.f64N/A
+-commutativeN/A
lower-sqrt.f64N/A
+-commutativeN/A
lower-+.f6422.0
Applied rewrites22.0%
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (sqrt (+ 1.0 x)))
(t_2 (sqrt (+ 1.0 y)))
(t_3 (- (sqrt (+ t 1.0)) (sqrt t)))
(t_4
(+
(+
(+ (- (sqrt (+ x 1.0)) (sqrt x)) (- (sqrt (+ y 1.0)) (sqrt y)))
(- (sqrt (+ z 1.0)) (sqrt z)))
t_3)))
(if (<= t_4 1.00000005)
(+ (- t_1 (sqrt x)) t_3)
(if (<= t_4 2.0)
(- (+ t_1 t_2) (+ (sqrt y) (sqrt x)))
(+
1.0
(- (+ t_2 (sqrt (+ 1.0 z))) (+ (+ (sqrt z) (sqrt y)) (sqrt x))))))))assert(x < y && y < z && z < t);
double code(double x, double y, double z, double t) {
double t_1 = sqrt((1.0 + x));
double t_2 = sqrt((1.0 + y));
double t_3 = sqrt((t + 1.0)) - sqrt(t);
double t_4 = (((sqrt((x + 1.0)) - sqrt(x)) + (sqrt((y + 1.0)) - sqrt(y))) + (sqrt((z + 1.0)) - sqrt(z))) + t_3;
double tmp;
if (t_4 <= 1.00000005) {
tmp = (t_1 - sqrt(x)) + t_3;
} else if (t_4 <= 2.0) {
tmp = (t_1 + t_2) - (sqrt(y) + sqrt(x));
} else {
tmp = 1.0 + ((t_2 + sqrt((1.0 + z))) - ((sqrt(z) + sqrt(y)) + sqrt(x)));
}
return tmp;
}
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
module fmin_fmax_functions
implicit none
private
public fmax
public fmin
interface fmax
module procedure fmax88
module procedure fmax44
module procedure fmax84
module procedure fmax48
end interface
interface fmin
module procedure fmin88
module procedure fmin44
module procedure fmin84
module procedure fmin48
end interface
contains
real(8) function fmax88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(4) function fmax44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(8) function fmax84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, max(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmax48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), max(dble(x), y), y /= y), x /= x)
end function
real(8) function fmin88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(4) function fmin44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(8) function fmin84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, min(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmin48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), min(dble(x), y), y /= y), x /= x)
end function
end module
real(8) function code(x, y, z, t)
use fmin_fmax_functions
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: t_4
real(8) :: tmp
t_1 = sqrt((1.0d0 + x))
t_2 = sqrt((1.0d0 + y))
t_3 = sqrt((t + 1.0d0)) - sqrt(t)
t_4 = (((sqrt((x + 1.0d0)) - sqrt(x)) + (sqrt((y + 1.0d0)) - sqrt(y))) + (sqrt((z + 1.0d0)) - sqrt(z))) + t_3
if (t_4 <= 1.00000005d0) then
tmp = (t_1 - sqrt(x)) + t_3
else if (t_4 <= 2.0d0) then
tmp = (t_1 + t_2) - (sqrt(y) + sqrt(x))
else
tmp = 1.0d0 + ((t_2 + sqrt((1.0d0 + z))) - ((sqrt(z) + sqrt(y)) + sqrt(x)))
end if
code = tmp
end function
assert x < y && y < z && z < t;
public static double code(double x, double y, double z, double t) {
double t_1 = Math.sqrt((1.0 + x));
double t_2 = Math.sqrt((1.0 + y));
double t_3 = Math.sqrt((t + 1.0)) - Math.sqrt(t);
double t_4 = (((Math.sqrt((x + 1.0)) - Math.sqrt(x)) + (Math.sqrt((y + 1.0)) - Math.sqrt(y))) + (Math.sqrt((z + 1.0)) - Math.sqrt(z))) + t_3;
double tmp;
if (t_4 <= 1.00000005) {
tmp = (t_1 - Math.sqrt(x)) + t_3;
} else if (t_4 <= 2.0) {
tmp = (t_1 + t_2) - (Math.sqrt(y) + Math.sqrt(x));
} else {
tmp = 1.0 + ((t_2 + Math.sqrt((1.0 + z))) - ((Math.sqrt(z) + Math.sqrt(y)) + Math.sqrt(x)));
}
return tmp;
}
[x, y, z, t] = sort([x, y, z, t]) def code(x, y, z, t): t_1 = math.sqrt((1.0 + x)) t_2 = math.sqrt((1.0 + y)) t_3 = math.sqrt((t + 1.0)) - math.sqrt(t) t_4 = (((math.sqrt((x + 1.0)) - math.sqrt(x)) + (math.sqrt((y + 1.0)) - math.sqrt(y))) + (math.sqrt((z + 1.0)) - math.sqrt(z))) + t_3 tmp = 0 if t_4 <= 1.00000005: tmp = (t_1 - math.sqrt(x)) + t_3 elif t_4 <= 2.0: tmp = (t_1 + t_2) - (math.sqrt(y) + math.sqrt(x)) else: tmp = 1.0 + ((t_2 + math.sqrt((1.0 + z))) - ((math.sqrt(z) + math.sqrt(y)) + math.sqrt(x))) return tmp
x, y, z, t = sort([x, y, z, t]) function code(x, y, z, t) t_1 = sqrt(Float64(1.0 + x)) t_2 = sqrt(Float64(1.0 + y)) t_3 = Float64(sqrt(Float64(t + 1.0)) - sqrt(t)) t_4 = Float64(Float64(Float64(Float64(sqrt(Float64(x + 1.0)) - sqrt(x)) + Float64(sqrt(Float64(y + 1.0)) - sqrt(y))) + Float64(sqrt(Float64(z + 1.0)) - sqrt(z))) + t_3) tmp = 0.0 if (t_4 <= 1.00000005) tmp = Float64(Float64(t_1 - sqrt(x)) + t_3); elseif (t_4 <= 2.0) tmp = Float64(Float64(t_1 + t_2) - Float64(sqrt(y) + sqrt(x))); else tmp = Float64(1.0 + Float64(Float64(t_2 + sqrt(Float64(1.0 + z))) - Float64(Float64(sqrt(z) + sqrt(y)) + sqrt(x)))); end return tmp end
x, y, z, t = num2cell(sort([x, y, z, t])){:}
function tmp_2 = code(x, y, z, t)
t_1 = sqrt((1.0 + x));
t_2 = sqrt((1.0 + y));
t_3 = sqrt((t + 1.0)) - sqrt(t);
t_4 = (((sqrt((x + 1.0)) - sqrt(x)) + (sqrt((y + 1.0)) - sqrt(y))) + (sqrt((z + 1.0)) - sqrt(z))) + t_3;
tmp = 0.0;
if (t_4 <= 1.00000005)
tmp = (t_1 - sqrt(x)) + t_3;
elseif (t_4 <= 2.0)
tmp = (t_1 + t_2) - (sqrt(y) + sqrt(x));
else
tmp = 1.0 + ((t_2 + sqrt((1.0 + z))) - ((sqrt(z) + sqrt(y)) + sqrt(x)));
end
tmp_2 = tmp;
end
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_] := Block[{t$95$1 = N[Sqrt[N[(1.0 + x), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[Sqrt[N[(1.0 + y), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$3 = N[(N[Sqrt[N[(t + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[t], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[(N[(N[(N[Sqrt[N[(x + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(y + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(z + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + t$95$3), $MachinePrecision]}, If[LessEqual[t$95$4, 1.00000005], N[(N[(t$95$1 - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + t$95$3), $MachinePrecision], If[LessEqual[t$95$4, 2.0], N[(N[(t$95$1 + t$95$2), $MachinePrecision] - N[(N[Sqrt[y], $MachinePrecision] + N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 + N[(N[(t$95$2 + N[Sqrt[N[(1.0 + z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - N[(N[(N[Sqrt[z], $MachinePrecision] + N[Sqrt[y], $MachinePrecision]), $MachinePrecision] + N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
[x, y, z, t] = \mathsf{sort}([x, y, z, t])\\
\\
\begin{array}{l}
t_1 := \sqrt{1 + x}\\
t_2 := \sqrt{1 + y}\\
t_3 := \sqrt{t + 1} - \sqrt{t}\\
t_4 := \left(\left(\left(\sqrt{x + 1} - \sqrt{x}\right) + \left(\sqrt{y + 1} - \sqrt{y}\right)\right) + \left(\sqrt{z + 1} - \sqrt{z}\right)\right) + t\_3\\
\mathbf{if}\;t\_4 \leq 1.00000005:\\
\;\;\;\;\left(t\_1 - \sqrt{x}\right) + t\_3\\
\mathbf{elif}\;t\_4 \leq 2:\\
\;\;\;\;\left(t\_1 + t\_2\right) - \left(\sqrt{y} + \sqrt{x}\right)\\
\mathbf{else}:\\
\;\;\;\;1 + \left(\left(t\_2 + \sqrt{1 + z}\right) - \left(\left(\sqrt{z} + \sqrt{y}\right) + \sqrt{x}\right)\right)\\
\end{array}
\end{array}
if (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 1.00000004999999992Initial program 82.9%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6483.8
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites83.8%
Taylor expanded in z around inf
lower--.f64N/A
Applied rewrites45.8%
Taylor expanded in y around inf
+-commutativeN/A
lower-sqrt.f64N/A
+-commutativeN/A
lower-+.f6445.6
Applied rewrites45.6%
if 1.00000004999999992 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) < 2Initial program 95.5%
Taylor expanded in t around inf
lower--.f64N/A
Applied rewrites4.8%
Taylor expanded in z around inf
lower--.f64N/A
lower-+.f64N/A
+-commutativeN/A
lower-sqrt.f64N/A
+-commutativeN/A
lower-+.f64N/A
+-commutativeN/A
lower-sqrt.f64N/A
+-commutativeN/A
lower-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6417.6
Applied rewrites17.6%
if 2 < (+.f64 (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) (-.f64 (sqrt.f64 (+.f64 t #s(literal 1 binary64))) (sqrt.f64 t))) Initial program 97.6%
Taylor expanded in t around inf
lower--.f64N/A
Applied rewrites23.2%
Taylor expanded in x around 0
associate--l+N/A
lower-+.f64N/A
lower--.f64N/A
lower-+.f64N/A
+-commutativeN/A
lower-sqrt.f64N/A
+-commutativeN/A
lower-+.f64N/A
+-commutativeN/A
lower-sqrt.f64N/A
+-commutativeN/A
lower-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
Applied rewrites28.2%
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
(FPCore (x y z t)
:precision binary64
(let* ((t_1
(+
(+ (- (sqrt (+ x 1.0)) (sqrt x)) (- (sqrt (+ y 1.0)) (sqrt y)))
(- (sqrt (+ z 1.0)) (sqrt z))))
(t_2 (sqrt (+ 1.0 y)))
(t_3 (sqrt (+ 1.0 x))))
(if (<= t_1 1.00000005)
(+ (- t_3 (sqrt x)) (- (sqrt (+ t 1.0)) (sqrt t)))
(if (<= t_1 2.4)
(- (+ t_3 t_2) (+ (sqrt y) (sqrt x)))
(- (+ (fma 0.5 z t_2) 2.0) (+ (+ (sqrt z) (sqrt y)) (sqrt x)))))))assert(x < y && y < z && z < t);
double code(double x, double y, double z, double t) {
double t_1 = ((sqrt((x + 1.0)) - sqrt(x)) + (sqrt((y + 1.0)) - sqrt(y))) + (sqrt((z + 1.0)) - sqrt(z));
double t_2 = sqrt((1.0 + y));
double t_3 = sqrt((1.0 + x));
double tmp;
if (t_1 <= 1.00000005) {
tmp = (t_3 - sqrt(x)) + (sqrt((t + 1.0)) - sqrt(t));
} else if (t_1 <= 2.4) {
tmp = (t_3 + t_2) - (sqrt(y) + sqrt(x));
} else {
tmp = (fma(0.5, z, t_2) + 2.0) - ((sqrt(z) + sqrt(y)) + sqrt(x));
}
return tmp;
}
x, y, z, t = sort([x, y, z, t]) function code(x, y, z, t) t_1 = Float64(Float64(Float64(sqrt(Float64(x + 1.0)) - sqrt(x)) + Float64(sqrt(Float64(y + 1.0)) - sqrt(y))) + Float64(sqrt(Float64(z + 1.0)) - sqrt(z))) t_2 = sqrt(Float64(1.0 + y)) t_3 = sqrt(Float64(1.0 + x)) tmp = 0.0 if (t_1 <= 1.00000005) tmp = Float64(Float64(t_3 - sqrt(x)) + Float64(sqrt(Float64(t + 1.0)) - sqrt(t))); elseif (t_1 <= 2.4) tmp = Float64(Float64(t_3 + t_2) - Float64(sqrt(y) + sqrt(x))); else tmp = Float64(Float64(fma(0.5, z, t_2) + 2.0) - Float64(Float64(sqrt(z) + sqrt(y)) + sqrt(x))); end return tmp end
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(N[(N[Sqrt[N[(x + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(y + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(z + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Sqrt[N[(1.0 + y), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$3 = N[Sqrt[N[(1.0 + x), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[t$95$1, 1.00000005], N[(N[(t$95$3 - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(t + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[t], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 2.4], N[(N[(t$95$3 + t$95$2), $MachinePrecision] - N[(N[Sqrt[y], $MachinePrecision] + N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(0.5 * z + t$95$2), $MachinePrecision] + 2.0), $MachinePrecision] - N[(N[(N[Sqrt[z], $MachinePrecision] + N[Sqrt[y], $MachinePrecision]), $MachinePrecision] + N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
[x, y, z, t] = \mathsf{sort}([x, y, z, t])\\
\\
\begin{array}{l}
t_1 := \left(\left(\sqrt{x + 1} - \sqrt{x}\right) + \left(\sqrt{y + 1} - \sqrt{y}\right)\right) + \left(\sqrt{z + 1} - \sqrt{z}\right)\\
t_2 := \sqrt{1 + y}\\
t_3 := \sqrt{1 + x}\\
\mathbf{if}\;t\_1 \leq 1.00000005:\\
\;\;\;\;\left(t\_3 - \sqrt{x}\right) + \left(\sqrt{t + 1} - \sqrt{t}\right)\\
\mathbf{elif}\;t\_1 \leq 2.4:\\
\;\;\;\;\left(t\_3 + t\_2\right) - \left(\sqrt{y} + \sqrt{x}\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\mathsf{fma}\left(0.5, z, t\_2\right) + 2\right) - \left(\left(\sqrt{z} + \sqrt{y}\right) + \sqrt{x}\right)\\
\end{array}
\end{array}
if (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) < 1.00000004999999992Initial program 88.3%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6489.1
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites89.1%
Taylor expanded in z around inf
lower--.f64N/A
Applied rewrites46.8%
Taylor expanded in y around inf
+-commutativeN/A
lower-sqrt.f64N/A
+-commutativeN/A
lower-+.f6446.0
Applied rewrites46.0%
if 1.00000004999999992 < (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) < 2.39999999999999991Initial program 96.9%
Taylor expanded in t around inf
lower--.f64N/A
Applied rewrites7.5%
Taylor expanded in z around inf
lower--.f64N/A
lower-+.f64N/A
+-commutativeN/A
lower-sqrt.f64N/A
+-commutativeN/A
lower-+.f64N/A
+-commutativeN/A
lower-sqrt.f64N/A
+-commutativeN/A
lower-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6420.1
Applied rewrites20.1%
if 2.39999999999999991 < (+.f64 (+.f64 (-.f64 (sqrt.f64 (+.f64 x #s(literal 1 binary64))) (sqrt.f64 x)) (-.f64 (sqrt.f64 (+.f64 y #s(literal 1 binary64))) (sqrt.f64 y))) (-.f64 (sqrt.f64 (+.f64 z #s(literal 1 binary64))) (sqrt.f64 z))) Initial program 98.3%
Taylor expanded in t around inf
lower--.f64N/A
Applied rewrites57.0%
Taylor expanded in z around 0
associate-+r+N/A
lower-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
+-commutativeN/A
lower-sqrt.f64N/A
+-commutativeN/A
lower-+.f64N/A
+-commutativeN/A
lower-fma.f64N/A
+-commutativeN/A
lower-sqrt.f64N/A
+-commutativeN/A
lower-+.f6456.9
Applied rewrites56.9%
Taylor expanded in x around 0
+-commutativeN/A
lower-+.f64N/A
+-commutativeN/A
lower-fma.f64N/A
lower-sqrt.f64N/A
lower-+.f6454.9
Applied rewrites54.9%
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
(FPCore (x y z t)
:precision binary64
(let* ((t_1 (sqrt (+ 1.0 x))))
(if (<= y 4.5e+15)
(- (+ t_1 (sqrt (+ 1.0 y))) (+ (sqrt y) (sqrt x)))
(+ (- t_1 (sqrt x)) (- (sqrt (+ t 1.0)) (sqrt t))))))assert(x < y && y < z && z < t);
double code(double x, double y, double z, double t) {
double t_1 = sqrt((1.0 + x));
double tmp;
if (y <= 4.5e+15) {
tmp = (t_1 + sqrt((1.0 + y))) - (sqrt(y) + sqrt(x));
} else {
tmp = (t_1 - sqrt(x)) + (sqrt((t + 1.0)) - sqrt(t));
}
return tmp;
}
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
module fmin_fmax_functions
implicit none
private
public fmax
public fmin
interface fmax
module procedure fmax88
module procedure fmax44
module procedure fmax84
module procedure fmax48
end interface
interface fmin
module procedure fmin88
module procedure fmin44
module procedure fmin84
module procedure fmin48
end interface
contains
real(8) function fmax88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(4) function fmax44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(8) function fmax84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, max(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmax48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), max(dble(x), y), y /= y), x /= x)
end function
real(8) function fmin88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(4) function fmin44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(8) function fmin84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, min(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmin48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), min(dble(x), y), y /= y), x /= x)
end function
end module
real(8) function code(x, y, z, t)
use fmin_fmax_functions
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: t_1
real(8) :: tmp
t_1 = sqrt((1.0d0 + x))
if (y <= 4.5d+15) then
tmp = (t_1 + sqrt((1.0d0 + y))) - (sqrt(y) + sqrt(x))
else
tmp = (t_1 - sqrt(x)) + (sqrt((t + 1.0d0)) - sqrt(t))
end if
code = tmp
end function
assert x < y && y < z && z < t;
public static double code(double x, double y, double z, double t) {
double t_1 = Math.sqrt((1.0 + x));
double tmp;
if (y <= 4.5e+15) {
tmp = (t_1 + Math.sqrt((1.0 + y))) - (Math.sqrt(y) + Math.sqrt(x));
} else {
tmp = (t_1 - Math.sqrt(x)) + (Math.sqrt((t + 1.0)) - Math.sqrt(t));
}
return tmp;
}
[x, y, z, t] = sort([x, y, z, t]) def code(x, y, z, t): t_1 = math.sqrt((1.0 + x)) tmp = 0 if y <= 4.5e+15: tmp = (t_1 + math.sqrt((1.0 + y))) - (math.sqrt(y) + math.sqrt(x)) else: tmp = (t_1 - math.sqrt(x)) + (math.sqrt((t + 1.0)) - math.sqrt(t)) return tmp
x, y, z, t = sort([x, y, z, t]) function code(x, y, z, t) t_1 = sqrt(Float64(1.0 + x)) tmp = 0.0 if (y <= 4.5e+15) tmp = Float64(Float64(t_1 + sqrt(Float64(1.0 + y))) - Float64(sqrt(y) + sqrt(x))); else tmp = Float64(Float64(t_1 - sqrt(x)) + Float64(sqrt(Float64(t + 1.0)) - sqrt(t))); end return tmp end
x, y, z, t = num2cell(sort([x, y, z, t])){:}
function tmp_2 = code(x, y, z, t)
t_1 = sqrt((1.0 + x));
tmp = 0.0;
if (y <= 4.5e+15)
tmp = (t_1 + sqrt((1.0 + y))) - (sqrt(y) + sqrt(x));
else
tmp = (t_1 - sqrt(x)) + (sqrt((t + 1.0)) - sqrt(t));
end
tmp_2 = tmp;
end
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
code[x_, y_, z_, t_] := Block[{t$95$1 = N[Sqrt[N[(1.0 + x), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[y, 4.5e+15], N[(N[(t$95$1 + N[Sqrt[N[(1.0 + y), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - N[(N[Sqrt[y], $MachinePrecision] + N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(t$95$1 - N[Sqrt[x], $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(t + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[t], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[x, y, z, t] = \mathsf{sort}([x, y, z, t])\\
\\
\begin{array}{l}
t_1 := \sqrt{1 + x}\\
\mathbf{if}\;y \leq 4.5 \cdot 10^{+15}:\\
\;\;\;\;\left(t\_1 + \sqrt{1 + y}\right) - \left(\sqrt{y} + \sqrt{x}\right)\\
\mathbf{else}:\\
\;\;\;\;\left(t\_1 - \sqrt{x}\right) + \left(\sqrt{t + 1} - \sqrt{t}\right)\\
\end{array}
\end{array}
if y < 4.5e15Initial program 96.1%
Taylor expanded in t around inf
lower--.f64N/A
Applied rewrites17.3%
Taylor expanded in z around inf
lower--.f64N/A
lower-+.f64N/A
+-commutativeN/A
lower-sqrt.f64N/A
+-commutativeN/A
lower-+.f64N/A
+-commutativeN/A
lower-sqrt.f64N/A
+-commutativeN/A
lower-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6420.1
Applied rewrites20.1%
if 4.5e15 < y Initial program 89.6%
lift--.f64N/A
flip--N/A
lower-/.f64N/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lift-sqrt.f64N/A
lift-sqrt.f64N/A
rem-square-sqrtN/A
lower--.f64N/A
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
metadata-evalN/A
metadata-evalN/A
metadata-evalN/A
lower--.f64N/A
metadata-evalN/A
+-commutativeN/A
lower-+.f6489.6
lift-+.f64N/A
metadata-evalN/A
fp-cancel-sign-sub-invN/A
Applied rewrites89.6%
Taylor expanded in z around inf
lower--.f64N/A
Applied rewrites48.5%
Taylor expanded in y around inf
+-commutativeN/A
lower-sqrt.f64N/A
+-commutativeN/A
lower-+.f6448.2
Applied rewrites48.2%
NOTE: x, y, z, and t should be sorted in increasing order before calling this function. (FPCore (x y z t) :precision binary64 (if (<= y 4.5e+15) (- (+ (sqrt (+ 1.0 x)) (sqrt (+ 1.0 y))) (+ (sqrt y) (sqrt x))) (+ (* (- 0.5 (sqrt (/ 1.0 x))) x) 1.0)))
assert(x < y && y < z && z < t);
double code(double x, double y, double z, double t) {
double tmp;
if (y <= 4.5e+15) {
tmp = (sqrt((1.0 + x)) + sqrt((1.0 + y))) - (sqrt(y) + sqrt(x));
} else {
tmp = ((0.5 - sqrt((1.0 / x))) * x) + 1.0;
}
return tmp;
}
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
module fmin_fmax_functions
implicit none
private
public fmax
public fmin
interface fmax
module procedure fmax88
module procedure fmax44
module procedure fmax84
module procedure fmax48
end interface
interface fmin
module procedure fmin88
module procedure fmin44
module procedure fmin84
module procedure fmin48
end interface
contains
real(8) function fmax88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(4) function fmax44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(8) function fmax84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, max(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmax48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), max(dble(x), y), y /= y), x /= x)
end function
real(8) function fmin88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(4) function fmin44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(8) function fmin84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, min(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmin48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), min(dble(x), y), y /= y), x /= x)
end function
end module
real(8) function code(x, y, z, t)
use fmin_fmax_functions
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
real(8) :: tmp
if (y <= 4.5d+15) then
tmp = (sqrt((1.0d0 + x)) + sqrt((1.0d0 + y))) - (sqrt(y) + sqrt(x))
else
tmp = ((0.5d0 - sqrt((1.0d0 / x))) * x) + 1.0d0
end if
code = tmp
end function
assert x < y && y < z && z < t;
public static double code(double x, double y, double z, double t) {
double tmp;
if (y <= 4.5e+15) {
tmp = (Math.sqrt((1.0 + x)) + Math.sqrt((1.0 + y))) - (Math.sqrt(y) + Math.sqrt(x));
} else {
tmp = ((0.5 - Math.sqrt((1.0 / x))) * x) + 1.0;
}
return tmp;
}
[x, y, z, t] = sort([x, y, z, t]) def code(x, y, z, t): tmp = 0 if y <= 4.5e+15: tmp = (math.sqrt((1.0 + x)) + math.sqrt((1.0 + y))) - (math.sqrt(y) + math.sqrt(x)) else: tmp = ((0.5 - math.sqrt((1.0 / x))) * x) + 1.0 return tmp
x, y, z, t = sort([x, y, z, t]) function code(x, y, z, t) tmp = 0.0 if (y <= 4.5e+15) tmp = Float64(Float64(sqrt(Float64(1.0 + x)) + sqrt(Float64(1.0 + y))) - Float64(sqrt(y) + sqrt(x))); else tmp = Float64(Float64(Float64(0.5 - sqrt(Float64(1.0 / x))) * x) + 1.0); end return tmp end
x, y, z, t = num2cell(sort([x, y, z, t])){:}
function tmp_2 = code(x, y, z, t)
tmp = 0.0;
if (y <= 4.5e+15)
tmp = (sqrt((1.0 + x)) + sqrt((1.0 + y))) - (sqrt(y) + sqrt(x));
else
tmp = ((0.5 - sqrt((1.0 / x))) * x) + 1.0;
end
tmp_2 = tmp;
end
NOTE: x, y, z, and t should be sorted in increasing order before calling this function. code[x_, y_, z_, t_] := If[LessEqual[y, 4.5e+15], N[(N[(N[Sqrt[N[(1.0 + x), $MachinePrecision]], $MachinePrecision] + N[Sqrt[N[(1.0 + y), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - N[(N[Sqrt[y], $MachinePrecision] + N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(0.5 - N[Sqrt[N[(1.0 / x), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision] + 1.0), $MachinePrecision]]
\begin{array}{l}
[x, y, z, t] = \mathsf{sort}([x, y, z, t])\\
\\
\begin{array}{l}
\mathbf{if}\;y \leq 4.5 \cdot 10^{+15}:\\
\;\;\;\;\left(\sqrt{1 + x} + \sqrt{1 + y}\right) - \left(\sqrt{y} + \sqrt{x}\right)\\
\mathbf{else}:\\
\;\;\;\;\left(0.5 - \sqrt{\frac{1}{x}}\right) \cdot x + 1\\
\end{array}
\end{array}
if y < 4.5e15Initial program 96.1%
Taylor expanded in t around inf
lower--.f64N/A
Applied rewrites17.3%
Taylor expanded in z around inf
lower--.f64N/A
lower-+.f64N/A
+-commutativeN/A
lower-sqrt.f64N/A
+-commutativeN/A
lower-+.f64N/A
+-commutativeN/A
lower-sqrt.f64N/A
+-commutativeN/A
lower-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6420.1
Applied rewrites20.1%
if 4.5e15 < y Initial program 89.6%
Taylor expanded in x around 0
associate--l+N/A
+-commutativeN/A
lower-+.f64N/A
Applied rewrites25.6%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
lower-sqrt.f64N/A
lower-/.f6420.6
Applied rewrites20.6%
NOTE: x, y, z, and t should be sorted in increasing order before calling this function. (FPCore (x y z t) :precision binary64 (+ (* (- 0.5 (sqrt (/ 1.0 x))) x) 1.0))
assert(x < y && y < z && z < t);
double code(double x, double y, double z, double t) {
return ((0.5 - sqrt((1.0 / x))) * x) + 1.0;
}
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
module fmin_fmax_functions
implicit none
private
public fmax
public fmin
interface fmax
module procedure fmax88
module procedure fmax44
module procedure fmax84
module procedure fmax48
end interface
interface fmin
module procedure fmin88
module procedure fmin44
module procedure fmin84
module procedure fmin48
end interface
contains
real(8) function fmax88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(4) function fmax44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(8) function fmax84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, max(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmax48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), max(dble(x), y), y /= y), x /= x)
end function
real(8) function fmin88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(4) function fmin44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(8) function fmin84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, min(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmin48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), min(dble(x), y), y /= y), x /= x)
end function
end module
real(8) function code(x, y, z, t)
use fmin_fmax_functions
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = ((0.5d0 - sqrt((1.0d0 / x))) * x) + 1.0d0
end function
assert x < y && y < z && z < t;
public static double code(double x, double y, double z, double t) {
return ((0.5 - Math.sqrt((1.0 / x))) * x) + 1.0;
}
[x, y, z, t] = sort([x, y, z, t]) def code(x, y, z, t): return ((0.5 - math.sqrt((1.0 / x))) * x) + 1.0
x, y, z, t = sort([x, y, z, t]) function code(x, y, z, t) return Float64(Float64(Float64(0.5 - sqrt(Float64(1.0 / x))) * x) + 1.0) end
x, y, z, t = num2cell(sort([x, y, z, t])){:}
function tmp = code(x, y, z, t)
tmp = ((0.5 - sqrt((1.0 / x))) * x) + 1.0;
end
NOTE: x, y, z, and t should be sorted in increasing order before calling this function. code[x_, y_, z_, t_] := N[(N[(N[(0.5 - N[Sqrt[N[(1.0 / x), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision] + 1.0), $MachinePrecision]
\begin{array}{l}
[x, y, z, t] = \mathsf{sort}([x, y, z, t])\\
\\
\left(0.5 - \sqrt{\frac{1}{x}}\right) \cdot x + 1
\end{array}
Initial program 93.0%
Taylor expanded in x around 0
associate--l+N/A
+-commutativeN/A
lower-+.f64N/A
Applied rewrites26.0%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
lower-sqrt.f64N/A
lower-/.f6415.6
Applied rewrites15.6%
NOTE: x, y, z, and t should be sorted in increasing order before calling this function. (FPCore (x y z t) :precision binary64 (* (+ 0.5 (sqrt (/ 1.0 x))) x))
assert(x < y && y < z && z < t);
double code(double x, double y, double z, double t) {
return (0.5 + sqrt((1.0 / x))) * x;
}
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
module fmin_fmax_functions
implicit none
private
public fmax
public fmin
interface fmax
module procedure fmax88
module procedure fmax44
module procedure fmax84
module procedure fmax48
end interface
interface fmin
module procedure fmin88
module procedure fmin44
module procedure fmin84
module procedure fmin48
end interface
contains
real(8) function fmax88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(4) function fmax44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(8) function fmax84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, max(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmax48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), max(dble(x), y), y /= y), x /= x)
end function
real(8) function fmin88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(4) function fmin44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(8) function fmin84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, min(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmin48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), min(dble(x), y), y /= y), x /= x)
end function
end module
real(8) function code(x, y, z, t)
use fmin_fmax_functions
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = (0.5d0 + sqrt((1.0d0 / x))) * x
end function
assert x < y && y < z && z < t;
public static double code(double x, double y, double z, double t) {
return (0.5 + Math.sqrt((1.0 / x))) * x;
}
[x, y, z, t] = sort([x, y, z, t]) def code(x, y, z, t): return (0.5 + math.sqrt((1.0 / x))) * x
x, y, z, t = sort([x, y, z, t]) function code(x, y, z, t) return Float64(Float64(0.5 + sqrt(Float64(1.0 / x))) * x) end
x, y, z, t = num2cell(sort([x, y, z, t])){:}
function tmp = code(x, y, z, t)
tmp = (0.5 + sqrt((1.0 / x))) * x;
end
NOTE: x, y, z, and t should be sorted in increasing order before calling this function. code[x_, y_, z_, t_] := N[(N[(0.5 + N[Sqrt[N[(1.0 / x), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]
\begin{array}{l}
[x, y, z, t] = \mathsf{sort}([x, y, z, t])\\
\\
\left(0.5 + \sqrt{\frac{1}{x}}\right) \cdot x
\end{array}
Initial program 93.0%
Taylor expanded in x around 0
associate--l+N/A
+-commutativeN/A
lower-+.f64N/A
Applied rewrites26.0%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
lower-sqrt.f64N/A
lower-/.f643.5
Applied rewrites3.5%
Taylor expanded in x around 0
mul-1-negN/A
lower-neg.f64N/A
lower-sqrt.f641.6
Applied rewrites1.6%
Taylor expanded in x around -inf
*-commutativeN/A
lower-*.f64N/A
fp-cancel-sub-sign-invN/A
unpow2N/A
rem-square-sqrtN/A
distribute-lft-neg-outN/A
distribute-rgt-neg-outN/A
metadata-evalN/A
*-rgt-identityN/A
lower-+.f64N/A
lower-sqrt.f64N/A
lower-/.f646.0
Applied rewrites6.0%
NOTE: x, y, z, and t should be sorted in increasing order before calling this function. (FPCore (x y z t) :precision binary64 (fma 0.5 x (- (sqrt x))))
assert(x < y && y < z && z < t);
double code(double x, double y, double z, double t) {
return fma(0.5, x, -sqrt(x));
}
x, y, z, t = sort([x, y, z, t]) function code(x, y, z, t) return fma(0.5, x, Float64(-sqrt(x))) end
NOTE: x, y, z, and t should be sorted in increasing order before calling this function. code[x_, y_, z_, t_] := N[(0.5 * x + (-N[Sqrt[x], $MachinePrecision])), $MachinePrecision]
\begin{array}{l}
[x, y, z, t] = \mathsf{sort}([x, y, z, t])\\
\\
\mathsf{fma}\left(0.5, x, -\sqrt{x}\right)
\end{array}
Initial program 93.0%
Taylor expanded in x around 0
associate--l+N/A
+-commutativeN/A
lower-+.f64N/A
Applied rewrites26.0%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
lower-sqrt.f64N/A
lower-/.f643.5
Applied rewrites3.5%
Taylor expanded in x around 0
+-commutativeN/A
lower-fma.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-sqrt.f643.5
Applied rewrites3.5%
NOTE: x, y, z, and t should be sorted in increasing order before calling this function. (FPCore (x y z t) :precision binary64 (- (sqrt x)))
assert(x < y && y < z && z < t);
double code(double x, double y, double z, double t) {
return -sqrt(x);
}
NOTE: x, y, z, and t should be sorted in increasing order before calling this function.
module fmin_fmax_functions
implicit none
private
public fmax
public fmin
interface fmax
module procedure fmax88
module procedure fmax44
module procedure fmax84
module procedure fmax48
end interface
interface fmin
module procedure fmin88
module procedure fmin44
module procedure fmin84
module procedure fmin48
end interface
contains
real(8) function fmax88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(4) function fmax44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(8) function fmax84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, max(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmax48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), max(dble(x), y), y /= y), x /= x)
end function
real(8) function fmin88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(4) function fmin44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(8) function fmin84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, min(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmin48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), min(dble(x), y), y /= y), x /= x)
end function
end module
real(8) function code(x, y, z, t)
use fmin_fmax_functions
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = -sqrt(x)
end function
assert x < y && y < z && z < t;
public static double code(double x, double y, double z, double t) {
return -Math.sqrt(x);
}
[x, y, z, t] = sort([x, y, z, t]) def code(x, y, z, t): return -math.sqrt(x)
x, y, z, t = sort([x, y, z, t]) function code(x, y, z, t) return Float64(-sqrt(x)) end
x, y, z, t = num2cell(sort([x, y, z, t])){:}
function tmp = code(x, y, z, t)
tmp = -sqrt(x);
end
NOTE: x, y, z, and t should be sorted in increasing order before calling this function. code[x_, y_, z_, t_] := (-N[Sqrt[x], $MachinePrecision])
\begin{array}{l}
[x, y, z, t] = \mathsf{sort}([x, y, z, t])\\
\\
-\sqrt{x}
\end{array}
Initial program 93.0%
Taylor expanded in x around 0
associate--l+N/A
+-commutativeN/A
lower-+.f64N/A
Applied rewrites26.0%
Taylor expanded in x around inf
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
lower-sqrt.f64N/A
lower-/.f643.5
Applied rewrites3.5%
Taylor expanded in x around 0
mul-1-negN/A
lower-neg.f64N/A
lower-sqrt.f641.6
Applied rewrites1.6%
(FPCore (x y z t)
:precision binary64
(+
(+
(+
(/ 1.0 (+ (sqrt (+ x 1.0)) (sqrt x)))
(/ 1.0 (+ (sqrt (+ y 1.0)) (sqrt y))))
(/ 1.0 (+ (sqrt (+ z 1.0)) (sqrt z))))
(- (sqrt (+ t 1.0)) (sqrt t))))
double code(double x, double y, double z, double t) {
return (((1.0 / (sqrt((x + 1.0)) + sqrt(x))) + (1.0 / (sqrt((y + 1.0)) + sqrt(y)))) + (1.0 / (sqrt((z + 1.0)) + sqrt(z)))) + (sqrt((t + 1.0)) - sqrt(t));
}
module fmin_fmax_functions
implicit none
private
public fmax
public fmin
interface fmax
module procedure fmax88
module procedure fmax44
module procedure fmax84
module procedure fmax48
end interface
interface fmin
module procedure fmin88
module procedure fmin44
module procedure fmin84
module procedure fmin48
end interface
contains
real(8) function fmax88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(4) function fmax44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(8) function fmax84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, max(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmax48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), max(dble(x), y), y /= y), x /= x)
end function
real(8) function fmin88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(4) function fmin44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(8) function fmin84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, min(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmin48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), min(dble(x), y), y /= y), x /= x)
end function
end module
real(8) function code(x, y, z, t)
use fmin_fmax_functions
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: t
code = (((1.0d0 / (sqrt((x + 1.0d0)) + sqrt(x))) + (1.0d0 / (sqrt((y + 1.0d0)) + sqrt(y)))) + (1.0d0 / (sqrt((z + 1.0d0)) + sqrt(z)))) + (sqrt((t + 1.0d0)) - sqrt(t))
end function
public static double code(double x, double y, double z, double t) {
return (((1.0 / (Math.sqrt((x + 1.0)) + Math.sqrt(x))) + (1.0 / (Math.sqrt((y + 1.0)) + Math.sqrt(y)))) + (1.0 / (Math.sqrt((z + 1.0)) + Math.sqrt(z)))) + (Math.sqrt((t + 1.0)) - Math.sqrt(t));
}
def code(x, y, z, t): return (((1.0 / (math.sqrt((x + 1.0)) + math.sqrt(x))) + (1.0 / (math.sqrt((y + 1.0)) + math.sqrt(y)))) + (1.0 / (math.sqrt((z + 1.0)) + math.sqrt(z)))) + (math.sqrt((t + 1.0)) - math.sqrt(t))
function code(x, y, z, t) return Float64(Float64(Float64(Float64(1.0 / Float64(sqrt(Float64(x + 1.0)) + sqrt(x))) + Float64(1.0 / Float64(sqrt(Float64(y + 1.0)) + sqrt(y)))) + Float64(1.0 / Float64(sqrt(Float64(z + 1.0)) + sqrt(z)))) + Float64(sqrt(Float64(t + 1.0)) - sqrt(t))) end
function tmp = code(x, y, z, t) tmp = (((1.0 / (sqrt((x + 1.0)) + sqrt(x))) + (1.0 / (sqrt((y + 1.0)) + sqrt(y)))) + (1.0 / (sqrt((z + 1.0)) + sqrt(z)))) + (sqrt((t + 1.0)) - sqrt(t)); end
code[x_, y_, z_, t_] := N[(N[(N[(N[(1.0 / N[(N[Sqrt[N[(x + 1.0), $MachinePrecision]], $MachinePrecision] + N[Sqrt[x], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(1.0 / N[(N[Sqrt[N[(y + 1.0), $MachinePrecision]], $MachinePrecision] + N[Sqrt[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(1.0 / N[(N[Sqrt[N[(z + 1.0), $MachinePrecision]], $MachinePrecision] + N[Sqrt[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[Sqrt[N[(t + 1.0), $MachinePrecision]], $MachinePrecision] - N[Sqrt[t], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(\frac{1}{\sqrt{x + 1} + \sqrt{x}} + \frac{1}{\sqrt{y + 1} + \sqrt{y}}\right) + \frac{1}{\sqrt{z + 1} + \sqrt{z}}\right) + \left(\sqrt{t + 1} - \sqrt{t}\right)
\end{array}
herbie shell --seed 2025026
(FPCore (x y z t)
:name "Main:z from "
:precision binary64
:alt
(! :herbie-platform default (+ (+ (+ (/ 1 (+ (sqrt (+ x 1)) (sqrt x))) (/ 1 (+ (sqrt (+ y 1)) (sqrt y)))) (/ 1 (+ (sqrt (+ z 1)) (sqrt z)))) (- (sqrt (+ t 1)) (sqrt t))))
(+ (+ (+ (- (sqrt (+ x 1.0)) (sqrt x)) (- (sqrt (+ y 1.0)) (sqrt y))) (- (sqrt (+ z 1.0)) (sqrt z))) (- (sqrt (+ t 1.0)) (sqrt t))))