
(FPCore (x y z a) :precision binary64 (+ x (- (tan (+ y z)) (tan a))))
double code(double x, double y, double z, double a) {
return x + (tan((y + z)) - tan(a));
}
real(8) function code(x, y, z, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: a
code = x + (tan((y + z)) - tan(a))
end function
public static double code(double x, double y, double z, double a) {
return x + (Math.tan((y + z)) - Math.tan(a));
}
def code(x, y, z, a): return x + (math.tan((y + z)) - math.tan(a))
function code(x, y, z, a) return Float64(x + Float64(tan(Float64(y + z)) - tan(a))) end
function tmp = code(x, y, z, a) tmp = x + (tan((y + z)) - tan(a)); end
code[x_, y_, z_, a_] := N[(x + N[(N[Tan[N[(y + z), $MachinePrecision]], $MachinePrecision] - N[Tan[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \left(\tan \left(y + z\right) - \tan a\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 8 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (x y z a) :precision binary64 (+ x (- (tan (+ y z)) (tan a))))
double code(double x, double y, double z, double a) {
return x + (tan((y + z)) - tan(a));
}
real(8) function code(x, y, z, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: a
code = x + (tan((y + z)) - tan(a))
end function
public static double code(double x, double y, double z, double a) {
return x + (Math.tan((y + z)) - Math.tan(a));
}
def code(x, y, z, a): return x + (math.tan((y + z)) - math.tan(a))
function code(x, y, z, a) return Float64(x + Float64(tan(Float64(y + z)) - tan(a))) end
function tmp = code(x, y, z, a) tmp = x + (tan((y + z)) - tan(a)); end
code[x_, y_, z_, a_] := N[(x + N[(N[Tan[N[(y + z), $MachinePrecision]], $MachinePrecision] - N[Tan[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \left(\tan \left(y + z\right) - \tan a\right)
\end{array}
NOTE: x, y, z, and a should be sorted in increasing order before calling this function. (FPCore (x y z a) :precision binary64 (+ x (- (/ (fma (sin z) (pow (cos z) -1.0) (tan y)) (- 1.0 (* (tan z) (tan y)))) (tan a))))
assert(x < y && y < z && z < a);
double code(double x, double y, double z, double a) {
return x + ((fma(sin(z), pow(cos(z), -1.0), tan(y)) / (1.0 - (tan(z) * tan(y)))) - tan(a));
}
x, y, z, a = sort([x, y, z, a]) function code(x, y, z, a) return Float64(x + Float64(Float64(fma(sin(z), (cos(z) ^ -1.0), tan(y)) / Float64(1.0 - Float64(tan(z) * tan(y)))) - tan(a))) end
NOTE: x, y, z, and a should be sorted in increasing order before calling this function. code[x_, y_, z_, a_] := N[(x + N[(N[(N[(N[Sin[z], $MachinePrecision] * N[Power[N[Cos[z], $MachinePrecision], -1.0], $MachinePrecision] + N[Tan[y], $MachinePrecision]), $MachinePrecision] / N[(1.0 - N[(N[Tan[z], $MachinePrecision] * N[Tan[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[Tan[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
[x, y, z, a] = \mathsf{sort}([x, y, z, a])\\
\\
x + \left(\frac{\mathsf{fma}\left(\sin z, {\cos z}^{-1}, \tan y\right)}{1 - \tan z \cdot \tan y} - \tan a\right)
\end{array}
Initial program 76.2%
lift-tan.f64N/A
lift-+.f64N/A
tan-sumN/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-tan.f64N/A
lower-tan.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-tan.f64N/A
lower-tan.f6499.7
Applied rewrites99.7%
lift-+.f64N/A
lift-tan.f64N/A
tan-quotN/A
div-invN/A
lower-fma.f64N/A
lower-sin.f64N/A
inv-powN/A
lower-pow.f64N/A
lower-cos.f6499.7
Applied rewrites99.7%
lift-pow.f64N/A
unpow-1N/A
lower-/.f6499.7
Applied rewrites99.7%
Final simplification99.7%
NOTE: x, y, z, and a should be sorted in increasing order before calling this function. (FPCore (x y z a) :precision binary64 (+ x (- (/ (+ (tan z) (tan y)) (- 1.0 (* (tan z) (tan y)))) (tan a))))
assert(x < y && y < z && z < a);
double code(double x, double y, double z, double a) {
return x + (((tan(z) + tan(y)) / (1.0 - (tan(z) * tan(y)))) - tan(a));
}
NOTE: x, y, z, and a should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: a
code = x + (((tan(z) + tan(y)) / (1.0d0 - (tan(z) * tan(y)))) - tan(a))
end function
assert x < y && y < z && z < a;
public static double code(double x, double y, double z, double a) {
return x + (((Math.tan(z) + Math.tan(y)) / (1.0 - (Math.tan(z) * Math.tan(y)))) - Math.tan(a));
}
[x, y, z, a] = sort([x, y, z, a]) def code(x, y, z, a): return x + (((math.tan(z) + math.tan(y)) / (1.0 - (math.tan(z) * math.tan(y)))) - math.tan(a))
x, y, z, a = sort([x, y, z, a]) function code(x, y, z, a) return Float64(x + Float64(Float64(Float64(tan(z) + tan(y)) / Float64(1.0 - Float64(tan(z) * tan(y)))) - tan(a))) end
x, y, z, a = num2cell(sort([x, y, z, a])){:}
function tmp = code(x, y, z, a)
tmp = x + (((tan(z) + tan(y)) / (1.0 - (tan(z) * tan(y)))) - tan(a));
end
NOTE: x, y, z, and a should be sorted in increasing order before calling this function. code[x_, y_, z_, a_] := N[(x + N[(N[(N[(N[Tan[z], $MachinePrecision] + N[Tan[y], $MachinePrecision]), $MachinePrecision] / N[(1.0 - N[(N[Tan[z], $MachinePrecision] * N[Tan[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[Tan[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
[x, y, z, a] = \mathsf{sort}([x, y, z, a])\\
\\
x + \left(\frac{\tan z + \tan y}{1 - \tan z \cdot \tan y} - \tan a\right)
\end{array}
Initial program 76.2%
lift-tan.f64N/A
lift-+.f64N/A
tan-sumN/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-tan.f64N/A
lower-tan.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-tan.f64N/A
lower-tan.f6499.7
Applied rewrites99.7%
NOTE: x, y, z, and a should be sorted in increasing order before calling this function. (FPCore (x y z a) :precision binary64 (+ x (- (/ (+ (tan y) (tan z)) (fma (- (tan y)) (tan z) 1.0)) (tan a))))
assert(x < y && y < z && z < a);
double code(double x, double y, double z, double a) {
return x + (((tan(y) + tan(z)) / fma(-tan(y), tan(z), 1.0)) - tan(a));
}
x, y, z, a = sort([x, y, z, a]) function code(x, y, z, a) return Float64(x + Float64(Float64(Float64(tan(y) + tan(z)) / fma(Float64(-tan(y)), tan(z), 1.0)) - tan(a))) end
NOTE: x, y, z, and a should be sorted in increasing order before calling this function. code[x_, y_, z_, a_] := N[(x + N[(N[(N[(N[Tan[y], $MachinePrecision] + N[Tan[z], $MachinePrecision]), $MachinePrecision] / N[((-N[Tan[y], $MachinePrecision]) * N[Tan[z], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] - N[Tan[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
[x, y, z, a] = \mathsf{sort}([x, y, z, a])\\
\\
x + \left(\frac{\tan y + \tan z}{\mathsf{fma}\left(-\tan y, \tan z, 1\right)} - \tan a\right)
\end{array}
Initial program 76.2%
lift-tan.f64N/A
lift-+.f64N/A
tan-sumN/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-tan.f64N/A
lower-tan.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-tan.f64N/A
lower-tan.f6499.7
Applied rewrites99.7%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6499.7
lift--.f64N/A
sub-negN/A
+-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6499.7
Applied rewrites99.7%
NOTE: x, y, z, and a should be sorted in increasing order before calling this function.
(FPCore (x y z a)
:precision binary64
(if (<= a -9e-5)
(fma (/ (- (/ (sin (+ z y)) (cos (+ z y))) (/ (sin a) (cos a))) x) x x)
(if (<= a 0.00034)
(fma
(- (+ (tan z) (tan y)))
(/ -1.0 (fma (- (tan y)) (tan z) 1.0))
(- (- a x)))
(+ x (fma (/ -1.0 (cos a)) (sin a) (tan (+ y z)))))))assert(x < y && y < z && z < a);
double code(double x, double y, double z, double a) {
double tmp;
if (a <= -9e-5) {
tmp = fma((((sin((z + y)) / cos((z + y))) - (sin(a) / cos(a))) / x), x, x);
} else if (a <= 0.00034) {
tmp = fma(-(tan(z) + tan(y)), (-1.0 / fma(-tan(y), tan(z), 1.0)), -(a - x));
} else {
tmp = x + fma((-1.0 / cos(a)), sin(a), tan((y + z)));
}
return tmp;
}
x, y, z, a = sort([x, y, z, a]) function code(x, y, z, a) tmp = 0.0 if (a <= -9e-5) tmp = fma(Float64(Float64(Float64(sin(Float64(z + y)) / cos(Float64(z + y))) - Float64(sin(a) / cos(a))) / x), x, x); elseif (a <= 0.00034) tmp = fma(Float64(-Float64(tan(z) + tan(y))), Float64(-1.0 / fma(Float64(-tan(y)), tan(z), 1.0)), Float64(-Float64(a - x))); else tmp = Float64(x + fma(Float64(-1.0 / cos(a)), sin(a), tan(Float64(y + z)))); end return tmp end
NOTE: x, y, z, and a should be sorted in increasing order before calling this function. code[x_, y_, z_, a_] := If[LessEqual[a, -9e-5], N[(N[(N[(N[(N[Sin[N[(z + y), $MachinePrecision]], $MachinePrecision] / N[Cos[N[(z + y), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - N[(N[Sin[a], $MachinePrecision] / N[Cos[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / x), $MachinePrecision] * x + x), $MachinePrecision], If[LessEqual[a, 0.00034], N[((-N[(N[Tan[z], $MachinePrecision] + N[Tan[y], $MachinePrecision]), $MachinePrecision]) * N[(-1.0 / N[((-N[Tan[y], $MachinePrecision]) * N[Tan[z], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + (-N[(a - x), $MachinePrecision])), $MachinePrecision], N[(x + N[(N[(-1.0 / N[Cos[a], $MachinePrecision]), $MachinePrecision] * N[Sin[a], $MachinePrecision] + N[Tan[N[(y + z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[x, y, z, a] = \mathsf{sort}([x, y, z, a])\\
\\
\begin{array}{l}
\mathbf{if}\;a \leq -9 \cdot 10^{-5}:\\
\;\;\;\;\mathsf{fma}\left(\frac{\frac{\sin \left(z + y\right)}{\cos \left(z + y\right)} - \frac{\sin a}{\cos a}}{x}, x, x\right)\\
\mathbf{elif}\;a \leq 0.00034:\\
\;\;\;\;\mathsf{fma}\left(-\left(\tan z + \tan y\right), \frac{-1}{\mathsf{fma}\left(-\tan y, \tan z, 1\right)}, -\left(a - x\right)\right)\\
\mathbf{else}:\\
\;\;\;\;x + \mathsf{fma}\left(\frac{-1}{\cos a}, \sin a, \tan \left(y + z\right)\right)\\
\end{array}
\end{array}
if a < -9.00000000000000057e-5Initial program 67.5%
Taylor expanded in x around inf
associate--l+N/A
distribute-rgt-inN/A
*-lft-identityN/A
+-commutativeN/A
*-commutativeN/A
associate-/r*N/A
*-commutativeN/A
associate-/r*N/A
div-subN/A
Applied rewrites67.6%
if -9.00000000000000057e-5 < a < 3.4e-4Initial program 79.4%
lift-+.f64N/A
+-commutativeN/A
lift--.f64N/A
associate-+l-N/A
lower--.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower--.f6479.4
Applied rewrites79.4%
Taylor expanded in a around 0
lower--.f6479.4
Applied rewrites79.4%
Applied rewrites99.9%
if 3.4e-4 < a Initial program 80.0%
lift-tan.f64N/A
lift-+.f64N/A
tan-sumN/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-tan.f64N/A
lower-tan.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-tan.f64N/A
lower-tan.f6499.6
Applied rewrites99.6%
lift--.f64N/A
lift-/.f64N/A
lift-+.f64N/A
lift-tan.f64N/A
lift-tan.f64N/A
lift--.f64N/A
lift-*.f64N/A
lift-tan.f64N/A
lift-tan.f64N/A
tan-sum-revN/A
lift-+.f64N/A
lift-tan.f64N/A
sub-negN/A
lift-tan.f64N/A
tan-quotN/A
lift-sin.f64N/A
lift-cos.f64N/A
distribute-frac-neg2N/A
lift-neg.f64N/A
un-div-invN/A
Applied rewrites80.1%
Final simplification85.9%
NOTE: x, y, z, and a should be sorted in increasing order before calling this function.
(FPCore (x y z a)
:precision binary64
(if (<= a -9e-5)
(+ x (fma (sin (+ y z)) (pow (cos (+ y z)) -1.0) (- (tan a))))
(if (<= a 0.00034)
(fma
(- (+ (tan z) (tan y)))
(/ -1.0 (fma (- (tan y)) (tan z) 1.0))
(- (- a x)))
(+ x (fma (/ -1.0 (cos a)) (sin a) (tan (+ y z)))))))assert(x < y && y < z && z < a);
double code(double x, double y, double z, double a) {
double tmp;
if (a <= -9e-5) {
tmp = x + fma(sin((y + z)), pow(cos((y + z)), -1.0), -tan(a));
} else if (a <= 0.00034) {
tmp = fma(-(tan(z) + tan(y)), (-1.0 / fma(-tan(y), tan(z), 1.0)), -(a - x));
} else {
tmp = x + fma((-1.0 / cos(a)), sin(a), tan((y + z)));
}
return tmp;
}
x, y, z, a = sort([x, y, z, a]) function code(x, y, z, a) tmp = 0.0 if (a <= -9e-5) tmp = Float64(x + fma(sin(Float64(y + z)), (cos(Float64(y + z)) ^ -1.0), Float64(-tan(a)))); elseif (a <= 0.00034) tmp = fma(Float64(-Float64(tan(z) + tan(y))), Float64(-1.0 / fma(Float64(-tan(y)), tan(z), 1.0)), Float64(-Float64(a - x))); else tmp = Float64(x + fma(Float64(-1.0 / cos(a)), sin(a), tan(Float64(y + z)))); end return tmp end
NOTE: x, y, z, and a should be sorted in increasing order before calling this function. code[x_, y_, z_, a_] := If[LessEqual[a, -9e-5], N[(x + N[(N[Sin[N[(y + z), $MachinePrecision]], $MachinePrecision] * N[Power[N[Cos[N[(y + z), $MachinePrecision]], $MachinePrecision], -1.0], $MachinePrecision] + (-N[Tan[a], $MachinePrecision])), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 0.00034], N[((-N[(N[Tan[z], $MachinePrecision] + N[Tan[y], $MachinePrecision]), $MachinePrecision]) * N[(-1.0 / N[((-N[Tan[y], $MachinePrecision]) * N[Tan[z], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + (-N[(a - x), $MachinePrecision])), $MachinePrecision], N[(x + N[(N[(-1.0 / N[Cos[a], $MachinePrecision]), $MachinePrecision] * N[Sin[a], $MachinePrecision] + N[Tan[N[(y + z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[x, y, z, a] = \mathsf{sort}([x, y, z, a])\\
\\
\begin{array}{l}
\mathbf{if}\;a \leq -9 \cdot 10^{-5}:\\
\;\;\;\;x + \mathsf{fma}\left(\sin \left(y + z\right), {\cos \left(y + z\right)}^{-1}, -\tan a\right)\\
\mathbf{elif}\;a \leq 0.00034:\\
\;\;\;\;\mathsf{fma}\left(-\left(\tan z + \tan y\right), \frac{-1}{\mathsf{fma}\left(-\tan y, \tan z, 1\right)}, -\left(a - x\right)\right)\\
\mathbf{else}:\\
\;\;\;\;x + \mathsf{fma}\left(\frac{-1}{\cos a}, \sin a, \tan \left(y + z\right)\right)\\
\end{array}
\end{array}
if a < -9.00000000000000057e-5Initial program 67.5%
lift-tan.f64N/A
lift-+.f64N/A
tan-sumN/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-tan.f64N/A
lower-tan.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-tan.f64N/A
lower-tan.f6499.7
Applied rewrites99.7%
lift-+.f64N/A
lift-tan.f64N/A
tan-quotN/A
div-invN/A
lower-fma.f64N/A
lower-sin.f64N/A
inv-powN/A
lower-pow.f64N/A
lower-cos.f6499.5
Applied rewrites99.5%
lift--.f64N/A
sub-negN/A
Applied rewrites67.5%
if -9.00000000000000057e-5 < a < 3.4e-4Initial program 79.4%
lift-+.f64N/A
+-commutativeN/A
lift--.f64N/A
associate-+l-N/A
lower--.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower--.f6479.4
Applied rewrites79.4%
Taylor expanded in a around 0
lower--.f6479.4
Applied rewrites79.4%
Applied rewrites99.9%
if 3.4e-4 < a Initial program 80.0%
lift-tan.f64N/A
lift-+.f64N/A
tan-sumN/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-tan.f64N/A
lower-tan.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-tan.f64N/A
lower-tan.f6499.6
Applied rewrites99.6%
lift--.f64N/A
lift-/.f64N/A
lift-+.f64N/A
lift-tan.f64N/A
lift-tan.f64N/A
lift--.f64N/A
lift-*.f64N/A
lift-tan.f64N/A
lift-tan.f64N/A
tan-sum-revN/A
lift-+.f64N/A
lift-tan.f64N/A
sub-negN/A
lift-tan.f64N/A
tan-quotN/A
lift-sin.f64N/A
lift-cos.f64N/A
distribute-frac-neg2N/A
lift-neg.f64N/A
un-div-invN/A
Applied rewrites80.1%
Final simplification85.9%
NOTE: x, y, z, and a should be sorted in increasing order before calling this function.
(FPCore (x y z a)
:precision binary64
(if (<= a -8.6e-10)
(+ x (fma (sin (+ y z)) (pow (cos (+ y z)) -1.0) (- (tan a))))
(if (<= a 3.6e-6)
(fma
(- (+ (tan z) (tan y)))
(/ -1.0 (fma (- (tan y)) (tan z) 1.0))
(- (- x)))
(+ x (fma (/ -1.0 (cos a)) (sin a) (tan (+ y z)))))))assert(x < y && y < z && z < a);
double code(double x, double y, double z, double a) {
double tmp;
if (a <= -8.6e-10) {
tmp = x + fma(sin((y + z)), pow(cos((y + z)), -1.0), -tan(a));
} else if (a <= 3.6e-6) {
tmp = fma(-(tan(z) + tan(y)), (-1.0 / fma(-tan(y), tan(z), 1.0)), -(-x));
} else {
tmp = x + fma((-1.0 / cos(a)), sin(a), tan((y + z)));
}
return tmp;
}
x, y, z, a = sort([x, y, z, a]) function code(x, y, z, a) tmp = 0.0 if (a <= -8.6e-10) tmp = Float64(x + fma(sin(Float64(y + z)), (cos(Float64(y + z)) ^ -1.0), Float64(-tan(a)))); elseif (a <= 3.6e-6) tmp = fma(Float64(-Float64(tan(z) + tan(y))), Float64(-1.0 / fma(Float64(-tan(y)), tan(z), 1.0)), Float64(-Float64(-x))); else tmp = Float64(x + fma(Float64(-1.0 / cos(a)), sin(a), tan(Float64(y + z)))); end return tmp end
NOTE: x, y, z, and a should be sorted in increasing order before calling this function. code[x_, y_, z_, a_] := If[LessEqual[a, -8.6e-10], N[(x + N[(N[Sin[N[(y + z), $MachinePrecision]], $MachinePrecision] * N[Power[N[Cos[N[(y + z), $MachinePrecision]], $MachinePrecision], -1.0], $MachinePrecision] + (-N[Tan[a], $MachinePrecision])), $MachinePrecision]), $MachinePrecision], If[LessEqual[a, 3.6e-6], N[((-N[(N[Tan[z], $MachinePrecision] + N[Tan[y], $MachinePrecision]), $MachinePrecision]) * N[(-1.0 / N[((-N[Tan[y], $MachinePrecision]) * N[Tan[z], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision] + (-(-x))), $MachinePrecision], N[(x + N[(N[(-1.0 / N[Cos[a], $MachinePrecision]), $MachinePrecision] * N[Sin[a], $MachinePrecision] + N[Tan[N[(y + z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
[x, y, z, a] = \mathsf{sort}([x, y, z, a])\\
\\
\begin{array}{l}
\mathbf{if}\;a \leq -8.6 \cdot 10^{-10}:\\
\;\;\;\;x + \mathsf{fma}\left(\sin \left(y + z\right), {\cos \left(y + z\right)}^{-1}, -\tan a\right)\\
\mathbf{elif}\;a \leq 3.6 \cdot 10^{-6}:\\
\;\;\;\;\mathsf{fma}\left(-\left(\tan z + \tan y\right), \frac{-1}{\mathsf{fma}\left(-\tan y, \tan z, 1\right)}, -\left(-x\right)\right)\\
\mathbf{else}:\\
\;\;\;\;x + \mathsf{fma}\left(\frac{-1}{\cos a}, \sin a, \tan \left(y + z\right)\right)\\
\end{array}
\end{array}
if a < -8.60000000000000029e-10Initial program 67.9%
lift-tan.f64N/A
lift-+.f64N/A
tan-sumN/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-tan.f64N/A
lower-tan.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-tan.f64N/A
lower-tan.f6499.7
Applied rewrites99.7%
lift-+.f64N/A
lift-tan.f64N/A
tan-quotN/A
div-invN/A
lower-fma.f64N/A
lower-sin.f64N/A
inv-powN/A
lower-pow.f64N/A
lower-cos.f6499.5
Applied rewrites99.5%
lift--.f64N/A
sub-negN/A
Applied rewrites68.0%
if -8.60000000000000029e-10 < a < 3.59999999999999984e-6Initial program 79.2%
lift-+.f64N/A
+-commutativeN/A
lift--.f64N/A
associate-+l-N/A
lower--.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower--.f6479.2
Applied rewrites79.2%
Taylor expanded in x around inf
mul-1-negN/A
lower-neg.f6479.2
Applied rewrites79.2%
Applied rewrites99.1%
if 3.59999999999999984e-6 < a Initial program 80.0%
lift-tan.f64N/A
lift-+.f64N/A
tan-sumN/A
lower-/.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-tan.f64N/A
lower-tan.f64N/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-tan.f64N/A
lower-tan.f6499.6
Applied rewrites99.6%
lift--.f64N/A
lift-/.f64N/A
lift-+.f64N/A
lift-tan.f64N/A
lift-tan.f64N/A
lift--.f64N/A
lift-*.f64N/A
lift-tan.f64N/A
lift-tan.f64N/A
tan-sum-revN/A
lift-+.f64N/A
lift-tan.f64N/A
sub-negN/A
lift-tan.f64N/A
tan-quotN/A
lift-sin.f64N/A
lift-cos.f64N/A
distribute-frac-neg2N/A
lift-neg.f64N/A
un-div-invN/A
Applied rewrites80.1%
Final simplification85.5%
NOTE: x, y, z, and a should be sorted in increasing order before calling this function. (FPCore (x y z a) :precision binary64 (+ x (- (tan (+ y z)) (tan a))))
assert(x < y && y < z && z < a);
double code(double x, double y, double z, double a) {
return x + (tan((y + z)) - tan(a));
}
NOTE: x, y, z, and a should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: a
code = x + (tan((y + z)) - tan(a))
end function
assert x < y && y < z && z < a;
public static double code(double x, double y, double z, double a) {
return x + (Math.tan((y + z)) - Math.tan(a));
}
[x, y, z, a] = sort([x, y, z, a]) def code(x, y, z, a): return x + (math.tan((y + z)) - math.tan(a))
x, y, z, a = sort([x, y, z, a]) function code(x, y, z, a) return Float64(x + Float64(tan(Float64(y + z)) - tan(a))) end
x, y, z, a = num2cell(sort([x, y, z, a])){:}
function tmp = code(x, y, z, a)
tmp = x + (tan((y + z)) - tan(a));
end
NOTE: x, y, z, and a should be sorted in increasing order before calling this function. code[x_, y_, z_, a_] := N[(x + N[(N[Tan[N[(y + z), $MachinePrecision]], $MachinePrecision] - N[Tan[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
[x, y, z, a] = \mathsf{sort}([x, y, z, a])\\
\\
x + \left(\tan \left(y + z\right) - \tan a\right)
\end{array}
Initial program 76.2%
NOTE: x, y, z, and a should be sorted in increasing order before calling this function. (FPCore (x y z a) :precision binary64 (- (tan (+ z y)) (- x)))
assert(x < y && y < z && z < a);
double code(double x, double y, double z, double a) {
return tan((z + y)) - -x;
}
NOTE: x, y, z, and a should be sorted in increasing order before calling this function.
real(8) function code(x, y, z, a)
real(8), intent (in) :: x
real(8), intent (in) :: y
real(8), intent (in) :: z
real(8), intent (in) :: a
code = tan((z + y)) - -x
end function
assert x < y && y < z && z < a;
public static double code(double x, double y, double z, double a) {
return Math.tan((z + y)) - -x;
}
[x, y, z, a] = sort([x, y, z, a]) def code(x, y, z, a): return math.tan((z + y)) - -x
x, y, z, a = sort([x, y, z, a]) function code(x, y, z, a) return Float64(tan(Float64(z + y)) - Float64(-x)) end
x, y, z, a = num2cell(sort([x, y, z, a])){:}
function tmp = code(x, y, z, a)
tmp = tan((z + y)) - -x;
end
NOTE: x, y, z, and a should be sorted in increasing order before calling this function. code[x_, y_, z_, a_] := N[(N[Tan[N[(z + y), $MachinePrecision]], $MachinePrecision] - (-x)), $MachinePrecision]
\begin{array}{l}
[x, y, z, a] = \mathsf{sort}([x, y, z, a])\\
\\
\tan \left(z + y\right) - \left(-x\right)
\end{array}
Initial program 76.2%
lift-+.f64N/A
+-commutativeN/A
lift--.f64N/A
associate-+l-N/A
lower--.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower--.f6476.2
Applied rewrites76.2%
Taylor expanded in x around inf
mul-1-negN/A
lower-neg.f6449.4
Applied rewrites49.4%
herbie shell --seed 2024305
(FPCore (x y z a)
:name "tan-example (used to crash)"
:precision binary64
:pre (and (and (and (or (== x 0.0) (and (<= 0.5884142 x) (<= x 505.5909))) (or (and (<= -1.796658e+308 y) (<= y -9.425585e-310)) (and (<= 1.284938e-309 y) (<= y 1.751224e+308)))) (or (and (<= -1.776707e+308 z) (<= z -8.599796e-310)) (and (<= 3.293145e-311 z) (<= z 1.725154e+308)))) (or (and (<= -1.796658e+308 a) (<= a -9.425585e-310)) (and (<= 1.284938e-309 a) (<= a 1.751224e+308))))
(+ x (- (tan (+ y z)) (tan a))))