
(FPCore (x y z) :precision binary64 (* x (- 1.0 (* y z))))
double code(double x, double y, double z) {
return x * (1.0 - (y * z));
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = x * (1.0d0 - (y * z))
end function
public static double code(double x, double y, double z) {
return x * (1.0 - (y * z));
}
def code(x, y, z): return x * (1.0 - (y * z))
function code(x, y, z) return Float64(x * Float64(1.0 - Float64(y * z))) end
function tmp = code(x, y, z) tmp = x * (1.0 - (y * z)); end
code[x_, y_, z_] := N[(x * N[(1.0 - N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot \left(1 - y \cdot z\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 5 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z) :precision binary64 (* x (- 1.0 (* y z))))
double code(double x, double y, double z) {
return x * (1.0 - (y * z));
}
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = x * (1.0d0 - (y * z))
end function
public static double code(double x, double y, double z) {
return x * (1.0 - (y * z));
}
def code(x, y, z): return x * (1.0 - (y * z))
function code(x, y, z) return Float64(x * Float64(1.0 - Float64(y * z))) end
function tmp = code(x, y, z) tmp = x * (1.0 - (y * z)); end
code[x_, y_, z_] := N[(x * N[(1.0 - N[(y * z), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x \cdot \left(1 - y \cdot z\right)
\end{array}
NOTE: x, y, and z should be sorted in increasing order before calling this function.
(FPCore (x y z)
:precision binary64
(let* ((t_0 (* (* (- y) x) z)))
(if (<= (* z y) -2e+260)
t_0
(if (<= (* z y) 1e+202) (* (- 1.0 (* z y)) x) t_0))))assert(x < y && y < z);
double code(double x, double y, double z) {
double t_0 = (-y * x) * z;
double tmp;
if ((z * y) <= -2e+260) {
tmp = t_0;
} else if ((z * y) <= 1e+202) {
tmp = (1.0 - (z * y)) * x;
} else {
tmp = t_0;
}
return tmp;
}
NOTE: x, y, and z should be sorted in increasing order before calling this function.
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: t_0
real(8) :: tmp
t_0 = (-y * x) * z
if ((z * y) <= (-2d+260)) then
tmp = t_0
else if ((z * y) <= 1d+202) then
tmp = (1.0d0 - (z * y)) * x
else
tmp = t_0
end if
code = tmp
end function
assert x < y && y < z;
public static double code(double x, double y, double z) {
double t_0 = (-y * x) * z;
double tmp;
if ((z * y) <= -2e+260) {
tmp = t_0;
} else if ((z * y) <= 1e+202) {
tmp = (1.0 - (z * y)) * x;
} else {
tmp = t_0;
}
return tmp;
}
[x, y, z] = sort([x, y, z]) def code(x, y, z): t_0 = (-y * x) * z tmp = 0 if (z * y) <= -2e+260: tmp = t_0 elif (z * y) <= 1e+202: tmp = (1.0 - (z * y)) * x else: tmp = t_0 return tmp
x, y, z = sort([x, y, z]) function code(x, y, z) t_0 = Float64(Float64(Float64(-y) * x) * z) tmp = 0.0 if (Float64(z * y) <= -2e+260) tmp = t_0; elseif (Float64(z * y) <= 1e+202) tmp = Float64(Float64(1.0 - Float64(z * y)) * x); else tmp = t_0; end return tmp end
x, y, z = num2cell(sort([x, y, z])){:}
function tmp_2 = code(x, y, z)
t_0 = (-y * x) * z;
tmp = 0.0;
if ((z * y) <= -2e+260)
tmp = t_0;
elseif ((z * y) <= 1e+202)
tmp = (1.0 - (z * y)) * x;
else
tmp = t_0;
end
tmp_2 = tmp;
end
NOTE: x, y, and z should be sorted in increasing order before calling this function.
code[x_, y_, z_] := Block[{t$95$0 = N[(N[((-y) * x), $MachinePrecision] * z), $MachinePrecision]}, If[LessEqual[N[(z * y), $MachinePrecision], -2e+260], t$95$0, If[LessEqual[N[(z * y), $MachinePrecision], 1e+202], N[(N[(1.0 - N[(z * y), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision], t$95$0]]]
\begin{array}{l}
[x, y, z] = \mathsf{sort}([x, y, z])\\
\\
\begin{array}{l}
t_0 := \left(\left(-y\right) \cdot x\right) \cdot z\\
\mathbf{if}\;z \cdot y \leq -2 \cdot 10^{+260}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;z \cdot y \leq 10^{+202}:\\
\;\;\;\;\left(1 - z \cdot y\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if (*.f64 y z) < -2.00000000000000013e260 or 9.999999999999999e201 < (*.f64 y z) Initial program 80.4%
lift-*.f64N/A
lift--.f64N/A
sub-negN/A
distribute-lft-inN/A
flip3-+N/A
div-invN/A
lower-*.f64N/A
Applied rewrites9.6%
Taylor expanded in z around inf
*-commutativeN/A
unpow2N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f640.3
Applied rewrites0.3%
Taylor expanded in z around inf
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6499.8
Applied rewrites99.8%
if -2.00000000000000013e260 < (*.f64 y z) < 9.999999999999999e201Initial program 99.9%
Final simplification99.8%
NOTE: x, y, and z should be sorted in increasing order before calling this function.
(FPCore (x y z)
:precision binary64
(if (<= (* z y) -2000.0)
(* (* (- x) z) y)
(if (<= (* z y) 1.0)
(* 1.0 x)
(if (<= (* z y) 1e+202) (* (* (- z) y) x) (* (* (- y) x) z)))))assert(x < y && y < z);
double code(double x, double y, double z) {
double tmp;
if ((z * y) <= -2000.0) {
tmp = (-x * z) * y;
} else if ((z * y) <= 1.0) {
tmp = 1.0 * x;
} else if ((z * y) <= 1e+202) {
tmp = (-z * y) * x;
} else {
tmp = (-y * x) * z;
}
return tmp;
}
NOTE: x, y, and z should be sorted in increasing order before calling this function.
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: tmp
if ((z * y) <= (-2000.0d0)) then
tmp = (-x * z) * y
else if ((z * y) <= 1.0d0) then
tmp = 1.0d0 * x
else if ((z * y) <= 1d+202) then
tmp = (-z * y) * x
else
tmp = (-y * x) * z
end if
code = tmp
end function
assert x < y && y < z;
public static double code(double x, double y, double z) {
double tmp;
if ((z * y) <= -2000.0) {
tmp = (-x * z) * y;
} else if ((z * y) <= 1.0) {
tmp = 1.0 * x;
} else if ((z * y) <= 1e+202) {
tmp = (-z * y) * x;
} else {
tmp = (-y * x) * z;
}
return tmp;
}
[x, y, z] = sort([x, y, z]) def code(x, y, z): tmp = 0 if (z * y) <= -2000.0: tmp = (-x * z) * y elif (z * y) <= 1.0: tmp = 1.0 * x elif (z * y) <= 1e+202: tmp = (-z * y) * x else: tmp = (-y * x) * z return tmp
x, y, z = sort([x, y, z]) function code(x, y, z) tmp = 0.0 if (Float64(z * y) <= -2000.0) tmp = Float64(Float64(Float64(-x) * z) * y); elseif (Float64(z * y) <= 1.0) tmp = Float64(1.0 * x); elseif (Float64(z * y) <= 1e+202) tmp = Float64(Float64(Float64(-z) * y) * x); else tmp = Float64(Float64(Float64(-y) * x) * z); end return tmp end
x, y, z = num2cell(sort([x, y, z])){:}
function tmp_2 = code(x, y, z)
tmp = 0.0;
if ((z * y) <= -2000.0)
tmp = (-x * z) * y;
elseif ((z * y) <= 1.0)
tmp = 1.0 * x;
elseif ((z * y) <= 1e+202)
tmp = (-z * y) * x;
else
tmp = (-y * x) * z;
end
tmp_2 = tmp;
end
NOTE: x, y, and z should be sorted in increasing order before calling this function. code[x_, y_, z_] := If[LessEqual[N[(z * y), $MachinePrecision], -2000.0], N[(N[((-x) * z), $MachinePrecision] * y), $MachinePrecision], If[LessEqual[N[(z * y), $MachinePrecision], 1.0], N[(1.0 * x), $MachinePrecision], If[LessEqual[N[(z * y), $MachinePrecision], 1e+202], N[(N[((-z) * y), $MachinePrecision] * x), $MachinePrecision], N[(N[((-y) * x), $MachinePrecision] * z), $MachinePrecision]]]]
\begin{array}{l}
[x, y, z] = \mathsf{sort}([x, y, z])\\
\\
\begin{array}{l}
\mathbf{if}\;z \cdot y \leq -2000:\\
\;\;\;\;\left(\left(-x\right) \cdot z\right) \cdot y\\
\mathbf{elif}\;z \cdot y \leq 1:\\
\;\;\;\;1 \cdot x\\
\mathbf{elif}\;z \cdot y \leq 10^{+202}:\\
\;\;\;\;\left(\left(-z\right) \cdot y\right) \cdot x\\
\mathbf{else}:\\
\;\;\;\;\left(\left(-y\right) \cdot x\right) \cdot z\\
\end{array}
\end{array}
if (*.f64 y z) < -2e3Initial program 86.5%
lift-*.f64N/A
lift--.f64N/A
sub-negN/A
distribute-lft-inN/A
flip3-+N/A
div-invN/A
lower-*.f64N/A
Applied rewrites19.9%
Taylor expanded in z around inf
*-commutativeN/A
unpow2N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f642.6
Applied rewrites2.6%
Taylor expanded in z around inf
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6491.9
Applied rewrites91.9%
Applied rewrites97.0%
if -2e3 < (*.f64 y z) < 1Initial program 100.0%
Taylor expanded in z around 0
Applied rewrites96.8%
if 1 < (*.f64 y z) < 9.999999999999999e201Initial program 99.8%
Taylor expanded in z around inf
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f6492.3
Applied rewrites92.3%
if 9.999999999999999e201 < (*.f64 y z) Initial program 88.1%
lift-*.f64N/A
lift--.f64N/A
sub-negN/A
distribute-lft-inN/A
flip3-+N/A
div-invN/A
lower-*.f64N/A
Applied rewrites15.0%
Taylor expanded in z around inf
*-commutativeN/A
unpow2N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f640.4
Applied rewrites0.4%
Taylor expanded in z around inf
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6499.8
Applied rewrites99.8%
Final simplification96.6%
NOTE: x, y, and z should be sorted in increasing order before calling this function. (FPCore (x y z) :precision binary64 (if (<= (* z y) -2000.0) (* (* (- x) z) y) (if (<= (* z y) 1.0) (* 1.0 x) (* (* (- y) x) z))))
assert(x < y && y < z);
double code(double x, double y, double z) {
double tmp;
if ((z * y) <= -2000.0) {
tmp = (-x * z) * y;
} else if ((z * y) <= 1.0) {
tmp = 1.0 * x;
} else {
tmp = (-y * x) * z;
}
return tmp;
}
NOTE: x, y, and z should be sorted in increasing order before calling this function.
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: tmp
if ((z * y) <= (-2000.0d0)) then
tmp = (-x * z) * y
else if ((z * y) <= 1.0d0) then
tmp = 1.0d0 * x
else
tmp = (-y * x) * z
end if
code = tmp
end function
assert x < y && y < z;
public static double code(double x, double y, double z) {
double tmp;
if ((z * y) <= -2000.0) {
tmp = (-x * z) * y;
} else if ((z * y) <= 1.0) {
tmp = 1.0 * x;
} else {
tmp = (-y * x) * z;
}
return tmp;
}
[x, y, z] = sort([x, y, z]) def code(x, y, z): tmp = 0 if (z * y) <= -2000.0: tmp = (-x * z) * y elif (z * y) <= 1.0: tmp = 1.0 * x else: tmp = (-y * x) * z return tmp
x, y, z = sort([x, y, z]) function code(x, y, z) tmp = 0.0 if (Float64(z * y) <= -2000.0) tmp = Float64(Float64(Float64(-x) * z) * y); elseif (Float64(z * y) <= 1.0) tmp = Float64(1.0 * x); else tmp = Float64(Float64(Float64(-y) * x) * z); end return tmp end
x, y, z = num2cell(sort([x, y, z])){:}
function tmp_2 = code(x, y, z)
tmp = 0.0;
if ((z * y) <= -2000.0)
tmp = (-x * z) * y;
elseif ((z * y) <= 1.0)
tmp = 1.0 * x;
else
tmp = (-y * x) * z;
end
tmp_2 = tmp;
end
NOTE: x, y, and z should be sorted in increasing order before calling this function. code[x_, y_, z_] := If[LessEqual[N[(z * y), $MachinePrecision], -2000.0], N[(N[((-x) * z), $MachinePrecision] * y), $MachinePrecision], If[LessEqual[N[(z * y), $MachinePrecision], 1.0], N[(1.0 * x), $MachinePrecision], N[(N[((-y) * x), $MachinePrecision] * z), $MachinePrecision]]]
\begin{array}{l}
[x, y, z] = \mathsf{sort}([x, y, z])\\
\\
\begin{array}{l}
\mathbf{if}\;z \cdot y \leq -2000:\\
\;\;\;\;\left(\left(-x\right) \cdot z\right) \cdot y\\
\mathbf{elif}\;z \cdot y \leq 1:\\
\;\;\;\;1 \cdot x\\
\mathbf{else}:\\
\;\;\;\;\left(\left(-y\right) \cdot x\right) \cdot z\\
\end{array}
\end{array}
if (*.f64 y z) < -2e3Initial program 86.5%
lift-*.f64N/A
lift--.f64N/A
sub-negN/A
distribute-lft-inN/A
flip3-+N/A
div-invN/A
lower-*.f64N/A
Applied rewrites19.9%
Taylor expanded in z around inf
*-commutativeN/A
unpow2N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f642.6
Applied rewrites2.6%
Taylor expanded in z around inf
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6491.9
Applied rewrites91.9%
Applied rewrites97.0%
if -2e3 < (*.f64 y z) < 1Initial program 100.0%
Taylor expanded in z around 0
Applied rewrites96.8%
if 1 < (*.f64 y z) Initial program 94.1%
lift-*.f64N/A
lift--.f64N/A
sub-negN/A
distribute-lft-inN/A
flip3-+N/A
div-invN/A
lower-*.f64N/A
Applied rewrites31.6%
Taylor expanded in z around inf
*-commutativeN/A
unpow2N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6415.5
Applied rewrites15.5%
Taylor expanded in z around inf
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6487.4
Applied rewrites87.4%
Final simplification93.8%
NOTE: x, y, and z should be sorted in increasing order before calling this function. (FPCore (x y z) :precision binary64 (let* ((t_0 (* (* (- y) x) z))) (if (<= (* z y) -4.0) t_0 (if (<= (* z y) 1.0) (* 1.0 x) t_0))))
assert(x < y && y < z);
double code(double x, double y, double z) {
double t_0 = (-y * x) * z;
double tmp;
if ((z * y) <= -4.0) {
tmp = t_0;
} else if ((z * y) <= 1.0) {
tmp = 1.0 * x;
} else {
tmp = t_0;
}
return tmp;
}
NOTE: x, y, and z should be sorted in increasing order before calling this function.
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8) :: t_0
real(8) :: tmp
t_0 = (-y * x) * z
if ((z * y) <= (-4.0d0)) then
tmp = t_0
else if ((z * y) <= 1.0d0) then
tmp = 1.0d0 * x
else
tmp = t_0
end if
code = tmp
end function
assert x < y && y < z;
public static double code(double x, double y, double z) {
double t_0 = (-y * x) * z;
double tmp;
if ((z * y) <= -4.0) {
tmp = t_0;
} else if ((z * y) <= 1.0) {
tmp = 1.0 * x;
} else {
tmp = t_0;
}
return tmp;
}
[x, y, z] = sort([x, y, z]) def code(x, y, z): t_0 = (-y * x) * z tmp = 0 if (z * y) <= -4.0: tmp = t_0 elif (z * y) <= 1.0: tmp = 1.0 * x else: tmp = t_0 return tmp
x, y, z = sort([x, y, z]) function code(x, y, z) t_0 = Float64(Float64(Float64(-y) * x) * z) tmp = 0.0 if (Float64(z * y) <= -4.0) tmp = t_0; elseif (Float64(z * y) <= 1.0) tmp = Float64(1.0 * x); else tmp = t_0; end return tmp end
x, y, z = num2cell(sort([x, y, z])){:}
function tmp_2 = code(x, y, z)
t_0 = (-y * x) * z;
tmp = 0.0;
if ((z * y) <= -4.0)
tmp = t_0;
elseif ((z * y) <= 1.0)
tmp = 1.0 * x;
else
tmp = t_0;
end
tmp_2 = tmp;
end
NOTE: x, y, and z should be sorted in increasing order before calling this function.
code[x_, y_, z_] := Block[{t$95$0 = N[(N[((-y) * x), $MachinePrecision] * z), $MachinePrecision]}, If[LessEqual[N[(z * y), $MachinePrecision], -4.0], t$95$0, If[LessEqual[N[(z * y), $MachinePrecision], 1.0], N[(1.0 * x), $MachinePrecision], t$95$0]]]
\begin{array}{l}
[x, y, z] = \mathsf{sort}([x, y, z])\\
\\
\begin{array}{l}
t_0 := \left(\left(-y\right) \cdot x\right) \cdot z\\
\mathbf{if}\;z \cdot y \leq -4:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;z \cdot y \leq 1:\\
\;\;\;\;1 \cdot x\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if (*.f64 y z) < -4 or 1 < (*.f64 y z) Initial program 91.0%
lift-*.f64N/A
lift--.f64N/A
sub-negN/A
distribute-lft-inN/A
flip3-+N/A
div-invN/A
lower-*.f64N/A
Applied rewrites26.6%
Taylor expanded in z around inf
*-commutativeN/A
unpow2N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6410.2
Applied rewrites10.2%
Taylor expanded in z around inf
associate-*r*N/A
associate-*r*N/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f64N/A
*-commutativeN/A
lower-*.f6488.8
Applied rewrites88.8%
if -4 < (*.f64 y z) < 1Initial program 100.0%
Taylor expanded in z around 0
Applied rewrites97.5%
Final simplification92.7%
NOTE: x, y, and z should be sorted in increasing order before calling this function. (FPCore (x y z) :precision binary64 (* 1.0 x))
assert(x < y && y < z);
double code(double x, double y, double z) {
return 1.0 * x;
}
NOTE: x, y, and z should be sorted in increasing order before calling this function.
real(8) function code(x, y, z)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
code = 1.0d0 * x
end function
assert x < y && y < z;
public static double code(double x, double y, double z) {
return 1.0 * x;
}
[x, y, z] = sort([x, y, z]) def code(x, y, z): return 1.0 * x
x, y, z = sort([x, y, z]) function code(x, y, z) return Float64(1.0 * x) end
x, y, z = num2cell(sort([x, y, z])){:}
function tmp = code(x, y, z)
tmp = 1.0 * x;
end
NOTE: x, y, and z should be sorted in increasing order before calling this function. code[x_, y_, z_] := N[(1.0 * x), $MachinePrecision]
\begin{array}{l}
[x, y, z] = \mathsf{sort}([x, y, z])\\
\\
1 \cdot x
\end{array}
Initial program 95.1%
Taylor expanded in z around 0
Applied rewrites45.8%
Final simplification45.8%
herbie shell --seed 2024248
(FPCore (x y z)
:name "Data.Colour.RGBSpace.HSV:hsv from colour-2.3.3, I"
:precision binary64
(* x (- 1.0 (* y z))))