
(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 10 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}
(FPCore (x y z a) :precision binary64 (+ x (fma (+ (tan y) (tan z)) (/ 1.0 (fma (tan y) (- (tan z)) 1.0)) (- (tan a)))))
double code(double x, double y, double z, double a) {
return x + fma((tan(y) + tan(z)), (1.0 / fma(tan(y), -tan(z), 1.0)), -tan(a));
}
function code(x, y, z, a) return Float64(x + fma(Float64(tan(y) + tan(z)), Float64(1.0 / fma(tan(y), Float64(-tan(z)), 1.0)), Float64(-tan(a)))) end
code[x_, y_, z_, a_] := N[(x + N[(N[(N[Tan[y], $MachinePrecision] + N[Tan[z], $MachinePrecision]), $MachinePrecision] * N[(1.0 / N[(N[Tan[y], $MachinePrecision] * (-N[Tan[z], $MachinePrecision]) + 1.0), $MachinePrecision]), $MachinePrecision] + (-N[Tan[a], $MachinePrecision])), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \mathsf{fma}\left(\tan y + \tan z, \frac{1}{\mathsf{fma}\left(\tan y, -\tan z, 1\right)}, -\tan a\right)
\end{array}
Initial program 75.0%
tan-sum99.8%
div-inv99.8%
Applied egg-rr99.8%
associate-*r/99.8%
*-rgt-identity99.8%
Simplified99.8%
+-commutative99.8%
tan-quot99.8%
div-inv99.8%
fma-def99.7%
Applied egg-rr99.7%
fma-udef99.8%
associate-*r/99.8%
*-rgt-identity99.8%
Simplified99.8%
div-inv99.8%
fma-neg99.8%
tan-quot99.8%
+-commutative99.8%
Applied egg-rr99.8%
sub-neg99.8%
+-commutative99.8%
distribute-rgt-neg-in99.8%
fma-def99.8%
Simplified99.8%
Final simplification99.8%
(FPCore (x y z a) :precision binary64 (if (or (<= (tan a) -0.02) (not (<= (tan a) 1e-10))) (+ x (- (+ (tan y) (/ (sin z) (cos z))) (tan a))) (+ x (- (/ (+ (tan y) (tan z)) (fma (tan y) (- (tan z)) 1.0)) a))))
double code(double x, double y, double z, double a) {
double tmp;
if ((tan(a) <= -0.02) || !(tan(a) <= 1e-10)) {
tmp = x + ((tan(y) + (sin(z) / cos(z))) - tan(a));
} else {
tmp = x + (((tan(y) + tan(z)) / fma(tan(y), -tan(z), 1.0)) - a);
}
return tmp;
}
function code(x, y, z, a) tmp = 0.0 if ((tan(a) <= -0.02) || !(tan(a) <= 1e-10)) tmp = Float64(x + Float64(Float64(tan(y) + Float64(sin(z) / cos(z))) - tan(a))); else tmp = Float64(x + Float64(Float64(Float64(tan(y) + tan(z)) / fma(tan(y), Float64(-tan(z)), 1.0)) - a)); end return tmp end
code[x_, y_, z_, a_] := If[Or[LessEqual[N[Tan[a], $MachinePrecision], -0.02], N[Not[LessEqual[N[Tan[a], $MachinePrecision], 1e-10]], $MachinePrecision]], N[(x + N[(N[(N[Tan[y], $MachinePrecision] + N[(N[Sin[z], $MachinePrecision] / N[Cos[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[Tan[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 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] - a), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\tan a \leq -0.02 \lor \neg \left(\tan a \leq 10^{-10}\right):\\
\;\;\;\;x + \left(\left(\tan y + \frac{\sin z}{\cos z}\right) - \tan a\right)\\
\mathbf{else}:\\
\;\;\;\;x + \left(\frac{\tan y + \tan z}{\mathsf{fma}\left(\tan y, -\tan z, 1\right)} - a\right)\\
\end{array}
\end{array}
if (tan.f64 a) < -0.0200000000000000004 or 1.00000000000000004e-10 < (tan.f64 a) Initial program 75.1%
tan-sum99.7%
div-inv99.7%
Applied egg-rr99.7%
associate-*r/99.7%
*-rgt-identity99.7%
Simplified99.7%
+-commutative99.7%
tan-quot99.7%
div-inv99.7%
fma-def99.7%
Applied egg-rr99.7%
fma-udef99.7%
associate-*r/99.7%
*-rgt-identity99.7%
Simplified99.7%
Taylor expanded in y around 0 75.7%
if -0.0200000000000000004 < (tan.f64 a) < 1.00000000000000004e-10Initial program 74.9%
Taylor expanded in a around 0 74.9%
tan-sum99.9%
div-inv99.9%
fma-neg99.9%
Applied egg-rr99.9%
fma-udef99.9%
unsub-neg99.9%
associate-*r/99.9%
*-rgt-identity99.9%
Simplified99.9%
sub-neg99.9%
Applied egg-rr99.9%
+-commutative99.9%
distribute-rgt-neg-in99.9%
fma-def99.9%
Simplified99.9%
Final simplification86.8%
(FPCore (x y z a) :precision binary64 (if (or (<= (tan a) -0.02) (not (<= (tan a) 1e-10))) (+ x (- (+ (tan y) (/ (sin z) (cos z))) (tan a))) (+ x (- (/ (+ (tan y) (tan z)) (- 1.0 (* (tan y) (tan z)))) a))))
double code(double x, double y, double z, double a) {
double tmp;
if ((tan(a) <= -0.02) || !(tan(a) <= 1e-10)) {
tmp = x + ((tan(y) + (sin(z) / cos(z))) - tan(a));
} else {
tmp = x + (((tan(y) + tan(z)) / (1.0 - (tan(y) * tan(z)))) - a);
}
return tmp;
}
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
real(8) :: tmp
if ((tan(a) <= (-0.02d0)) .or. (.not. (tan(a) <= 1d-10))) then
tmp = x + ((tan(y) + (sin(z) / cos(z))) - tan(a))
else
tmp = x + (((tan(y) + tan(z)) / (1.0d0 - (tan(y) * tan(z)))) - a)
end if
code = tmp
end function
public static double code(double x, double y, double z, double a) {
double tmp;
if ((Math.tan(a) <= -0.02) || !(Math.tan(a) <= 1e-10)) {
tmp = x + ((Math.tan(y) + (Math.sin(z) / Math.cos(z))) - Math.tan(a));
} else {
tmp = x + (((Math.tan(y) + Math.tan(z)) / (1.0 - (Math.tan(y) * Math.tan(z)))) - a);
}
return tmp;
}
def code(x, y, z, a): tmp = 0 if (math.tan(a) <= -0.02) or not (math.tan(a) <= 1e-10): tmp = x + ((math.tan(y) + (math.sin(z) / math.cos(z))) - math.tan(a)) else: tmp = x + (((math.tan(y) + math.tan(z)) / (1.0 - (math.tan(y) * math.tan(z)))) - a) return tmp
function code(x, y, z, a) tmp = 0.0 if ((tan(a) <= -0.02) || !(tan(a) <= 1e-10)) tmp = Float64(x + Float64(Float64(tan(y) + Float64(sin(z) / cos(z))) - tan(a))); else tmp = Float64(x + Float64(Float64(Float64(tan(y) + tan(z)) / Float64(1.0 - Float64(tan(y) * tan(z)))) - a)); end return tmp end
function tmp_2 = code(x, y, z, a) tmp = 0.0; if ((tan(a) <= -0.02) || ~((tan(a) <= 1e-10))) tmp = x + ((tan(y) + (sin(z) / cos(z))) - tan(a)); else tmp = x + (((tan(y) + tan(z)) / (1.0 - (tan(y) * tan(z)))) - a); end tmp_2 = tmp; end
code[x_, y_, z_, a_] := If[Or[LessEqual[N[Tan[a], $MachinePrecision], -0.02], N[Not[LessEqual[N[Tan[a], $MachinePrecision], 1e-10]], $MachinePrecision]], N[(x + N[(N[(N[Tan[y], $MachinePrecision] + N[(N[Sin[z], $MachinePrecision] / N[Cos[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[Tan[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(N[(N[Tan[y], $MachinePrecision] + N[Tan[z], $MachinePrecision]), $MachinePrecision] / N[(1.0 - N[(N[Tan[y], $MachinePrecision] * N[Tan[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - a), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\tan a \leq -0.02 \lor \neg \left(\tan a \leq 10^{-10}\right):\\
\;\;\;\;x + \left(\left(\tan y + \frac{\sin z}{\cos z}\right) - \tan a\right)\\
\mathbf{else}:\\
\;\;\;\;x + \left(\frac{\tan y + \tan z}{1 - \tan y \cdot \tan z} - a\right)\\
\end{array}
\end{array}
if (tan.f64 a) < -0.0200000000000000004 or 1.00000000000000004e-10 < (tan.f64 a) Initial program 75.1%
tan-sum99.7%
div-inv99.7%
Applied egg-rr99.7%
associate-*r/99.7%
*-rgt-identity99.7%
Simplified99.7%
+-commutative99.7%
tan-quot99.7%
div-inv99.7%
fma-def99.7%
Applied egg-rr99.7%
fma-udef99.7%
associate-*r/99.7%
*-rgt-identity99.7%
Simplified99.7%
Taylor expanded in y around 0 75.7%
if -0.0200000000000000004 < (tan.f64 a) < 1.00000000000000004e-10Initial program 74.9%
Taylor expanded in a around 0 74.9%
tan-sum99.9%
div-inv99.9%
fma-neg99.9%
Applied egg-rr99.9%
fma-udef99.9%
unsub-neg99.9%
associate-*r/99.9%
*-rgt-identity99.9%
Simplified99.9%
Final simplification86.8%
(FPCore (x y z a) :precision binary64 (+ x (- (/ (+ (tan y) (tan z)) (- 1.0 (* (tan y) (tan z)))) (tan a))))
double code(double x, double y, double z, double a) {
return x + (((tan(y) + tan(z)) / (1.0 - (tan(y) * tan(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) + tan(z)) / (1.0d0 - (tan(y) * tan(z)))) - tan(a))
end function
public static double code(double x, double y, double z, double a) {
return x + (((Math.tan(y) + Math.tan(z)) / (1.0 - (Math.tan(y) * Math.tan(z)))) - Math.tan(a));
}
def code(x, y, z, a): return x + (((math.tan(y) + math.tan(z)) / (1.0 - (math.tan(y) * math.tan(z)))) - math.tan(a))
function code(x, y, z, a) return Float64(x + Float64(Float64(Float64(tan(y) + tan(z)) / Float64(1.0 - Float64(tan(y) * tan(z)))) - tan(a))) end
function tmp = code(x, y, z, a) tmp = x + (((tan(y) + tan(z)) / (1.0 - (tan(y) * tan(z)))) - tan(a)); end
code[x_, y_, z_, a_] := N[(x + N[(N[(N[(N[Tan[y], $MachinePrecision] + N[Tan[z], $MachinePrecision]), $MachinePrecision] / N[(1.0 - N[(N[Tan[y], $MachinePrecision] * N[Tan[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[Tan[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \left(\frac{\tan y + \tan z}{1 - \tan y \cdot \tan z} - \tan a\right)
\end{array}
Initial program 75.0%
tan-sum99.8%
div-inv99.8%
Applied egg-rr99.8%
associate-*r/99.8%
*-rgt-identity99.8%
Simplified99.8%
Final simplification99.8%
(FPCore (x y z a) :precision binary64 (+ x (- (+ (tan y) (/ (sin z) (cos z))) (tan a))))
double code(double x, double y, double z, double a) {
return x + ((tan(y) + (sin(z) / cos(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) + (sin(z) / cos(z))) - tan(a))
end function
public static double code(double x, double y, double z, double a) {
return x + ((Math.tan(y) + (Math.sin(z) / Math.cos(z))) - Math.tan(a));
}
def code(x, y, z, a): return x + ((math.tan(y) + (math.sin(z) / math.cos(z))) - math.tan(a))
function code(x, y, z, a) return Float64(x + Float64(Float64(tan(y) + Float64(sin(z) / cos(z))) - tan(a))) end
function tmp = code(x, y, z, a) tmp = x + ((tan(y) + (sin(z) / cos(z))) - tan(a)); end
code[x_, y_, z_, a_] := N[(x + N[(N[(N[Tan[y], $MachinePrecision] + N[(N[Sin[z], $MachinePrecision] / N[Cos[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[Tan[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \left(\left(\tan y + \frac{\sin z}{\cos z}\right) - \tan a\right)
\end{array}
Initial program 75.0%
tan-sum99.8%
div-inv99.8%
Applied egg-rr99.8%
associate-*r/99.8%
*-rgt-identity99.8%
Simplified99.8%
+-commutative99.8%
tan-quot99.8%
div-inv99.8%
fma-def99.7%
Applied egg-rr99.7%
fma-udef99.8%
associate-*r/99.8%
*-rgt-identity99.8%
Simplified99.8%
Taylor expanded in y around 0 75.6%
Final simplification75.6%
(FPCore (x y z a) :precision binary64 (if (<= (+ y z) -1e-5) (+ x (tan (+ y z))) (+ (tan z) (- x (tan a)))))
double code(double x, double y, double z, double a) {
double tmp;
if ((y + z) <= -1e-5) {
tmp = x + tan((y + z));
} else {
tmp = tan(z) + (x - tan(a));
}
return tmp;
}
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
real(8) :: tmp
if ((y + z) <= (-1d-5)) then
tmp = x + tan((y + z))
else
tmp = tan(z) + (x - tan(a))
end if
code = tmp
end function
public static double code(double x, double y, double z, double a) {
double tmp;
if ((y + z) <= -1e-5) {
tmp = x + Math.tan((y + z));
} else {
tmp = Math.tan(z) + (x - Math.tan(a));
}
return tmp;
}
def code(x, y, z, a): tmp = 0 if (y + z) <= -1e-5: tmp = x + math.tan((y + z)) else: tmp = math.tan(z) + (x - math.tan(a)) return tmp
function code(x, y, z, a) tmp = 0.0 if (Float64(y + z) <= -1e-5) tmp = Float64(x + tan(Float64(y + z))); else tmp = Float64(tan(z) + Float64(x - tan(a))); end return tmp end
function tmp_2 = code(x, y, z, a) tmp = 0.0; if ((y + z) <= -1e-5) tmp = x + tan((y + z)); else tmp = tan(z) + (x - tan(a)); end tmp_2 = tmp; end
code[x_, y_, z_, a_] := If[LessEqual[N[(y + z), $MachinePrecision], -1e-5], N[(x + N[Tan[N[(y + z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[Tan[z], $MachinePrecision] + N[(x - N[Tan[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y + z \leq -1 \cdot 10^{-5}:\\
\;\;\;\;x + \tan \left(y + z\right)\\
\mathbf{else}:\\
\;\;\;\;\tan z + \left(x - \tan a\right)\\
\end{array}
\end{array}
if (+.f64 y z) < -1.00000000000000008e-5Initial program 71.0%
associate-+r-70.8%
+-commutative70.8%
associate--l+70.8%
Simplified70.8%
add-cube-cbrt69.9%
pow369.9%
Applied egg-rr69.9%
Taylor expanded in a around 0 41.0%
unpow1/340.8%
Simplified40.8%
expm1-log1p-u40.2%
expm1-udef40.3%
+-commutative40.3%
rem-cube-cbrt40.6%
Applied egg-rr40.6%
expm1-def40.5%
expm1-log1p41.4%
+-commutative41.4%
+-commutative41.4%
Simplified41.4%
if -1.00000000000000008e-5 < (+.f64 y z) Initial program 77.9%
associate-+r-77.9%
+-commutative77.9%
associate--l+77.9%
Simplified77.9%
Taylor expanded in y around 0 60.7%
tan-quot60.7%
expm1-log1p-u54.5%
expm1-udef54.6%
Applied egg-rr54.6%
expm1-def54.5%
expm1-log1p60.7%
Simplified60.7%
Final simplification52.6%
(FPCore (x y z a) :precision binary64 (if (<= (+ y z) -1e-5) (+ x (tan (+ y z))) (+ x (- (tan z) (tan a)))))
double code(double x, double y, double z, double a) {
double tmp;
if ((y + z) <= -1e-5) {
tmp = x + tan((y + z));
} else {
tmp = x + (tan(z) - tan(a));
}
return tmp;
}
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
real(8) :: tmp
if ((y + z) <= (-1d-5)) then
tmp = x + tan((y + z))
else
tmp = x + (tan(z) - tan(a))
end if
code = tmp
end function
public static double code(double x, double y, double z, double a) {
double tmp;
if ((y + z) <= -1e-5) {
tmp = x + Math.tan((y + z));
} else {
tmp = x + (Math.tan(z) - Math.tan(a));
}
return tmp;
}
def code(x, y, z, a): tmp = 0 if (y + z) <= -1e-5: tmp = x + math.tan((y + z)) else: tmp = x + (math.tan(z) - math.tan(a)) return tmp
function code(x, y, z, a) tmp = 0.0 if (Float64(y + z) <= -1e-5) tmp = Float64(x + tan(Float64(y + z))); else tmp = Float64(x + Float64(tan(z) - tan(a))); end return tmp end
function tmp_2 = code(x, y, z, a) tmp = 0.0; if ((y + z) <= -1e-5) tmp = x + tan((y + z)); else tmp = x + (tan(z) - tan(a)); end tmp_2 = tmp; end
code[x_, y_, z_, a_] := If[LessEqual[N[(y + z), $MachinePrecision], -1e-5], N[(x + N[Tan[N[(y + z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(x + N[(N[Tan[z], $MachinePrecision] - N[Tan[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y + z \leq -1 \cdot 10^{-5}:\\
\;\;\;\;x + \tan \left(y + z\right)\\
\mathbf{else}:\\
\;\;\;\;x + \left(\tan z - \tan a\right)\\
\end{array}
\end{array}
if (+.f64 y z) < -1.00000000000000008e-5Initial program 71.0%
associate-+r-70.8%
+-commutative70.8%
associate--l+70.8%
Simplified70.8%
add-cube-cbrt69.9%
pow369.9%
Applied egg-rr69.9%
Taylor expanded in a around 0 41.0%
unpow1/340.8%
Simplified40.8%
expm1-log1p-u40.2%
expm1-udef40.3%
+-commutative40.3%
rem-cube-cbrt40.6%
Applied egg-rr40.6%
expm1-def40.5%
expm1-log1p41.4%
+-commutative41.4%
+-commutative41.4%
Simplified41.4%
if -1.00000000000000008e-5 < (+.f64 y z) Initial program 77.9%
associate-+r-77.9%
+-commutative77.9%
associate--l+77.9%
Simplified77.9%
Taylor expanded in y around 0 60.7%
add-exp-log55.9%
tan-quot55.9%
Applied egg-rr55.9%
add-exp-log60.7%
+-commutative60.7%
associate-+l-60.7%
Applied egg-rr60.7%
Final simplification52.6%
(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}
Initial program 75.0%
Final simplification75.0%
(FPCore (x y z a) :precision binary64 (+ x (tan (+ y z))))
double code(double x, double y, double z, double a) {
return x + tan((y + z));
}
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))
end function
public static double code(double x, double y, double z, double a) {
return x + Math.tan((y + z));
}
def code(x, y, z, a): return x + math.tan((y + z))
function code(x, y, z, a) return Float64(x + tan(Float64(y + z))) end
function tmp = code(x, y, z, a) tmp = x + tan((y + z)); end
code[x_, y_, z_, a_] := N[(x + N[Tan[N[(y + z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \tan \left(y + z\right)
\end{array}
Initial program 75.0%
associate-+r-74.9%
+-commutative74.9%
associate--l+74.9%
Simplified74.9%
add-cube-cbrt73.8%
pow373.8%
Applied egg-rr73.8%
Taylor expanded in a around 0 46.1%
unpow1/346.0%
Simplified46.0%
expm1-log1p-u45.5%
expm1-udef45.5%
+-commutative45.5%
rem-cube-cbrt45.8%
Applied egg-rr45.8%
expm1-def45.8%
expm1-log1p46.6%
+-commutative46.6%
+-commutative46.6%
Simplified46.6%
Final simplification46.6%
(FPCore (x y z a) :precision binary64 x)
double code(double x, double y, double z, double a) {
return x;
}
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
end function
public static double code(double x, double y, double z, double a) {
return x;
}
def code(x, y, z, a): return x
function code(x, y, z, a) return x end
function tmp = code(x, y, z, a) tmp = x; end
code[x_, y_, z_, a_] := x
\begin{array}{l}
\\
x
\end{array}
Initial program 75.0%
Taylor expanded in x around inf 28.8%
Final simplification28.8%
herbie shell --seed 2023285
(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))))