
(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 15 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 (- (/ (+ (tan y) (tan z)) (- 1.0 (/ (tan z) (/ (cos y) (sin y))))) (tan a))))
double code(double x, double y, double z, double a) {
return x + (((tan(y) + tan(z)) / (1.0 - (tan(z) / (cos(y) / sin(y))))) - 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(z) / (cos(y) / sin(y))))) - 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(z) / (Math.cos(y) / Math.sin(y))))) - Math.tan(a));
}
def code(x, y, z, a): return x + (((math.tan(y) + math.tan(z)) / (1.0 - (math.tan(z) / (math.cos(y) / math.sin(y))))) - math.tan(a))
function code(x, y, z, a) return Float64(x + Float64(Float64(Float64(tan(y) + tan(z)) / Float64(1.0 - Float64(tan(z) / Float64(cos(y) / sin(y))))) - tan(a))) end
function tmp = code(x, y, z, a) tmp = x + (((tan(y) + tan(z)) / (1.0 - (tan(z) / (cos(y) / sin(y))))) - 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[z], $MachinePrecision] / N[(N[Cos[y], $MachinePrecision] / N[Sin[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[Tan[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \left(\frac{\tan y + \tan z}{1 - \frac{\tan z}{\frac{\cos y}{\sin y}}} - \tan a\right)
\end{array}
Initial program 76.3%
tan-sumN/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
tan-lowering-tan.f64N/A
tan-lowering-tan.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
tan-lowering-tan.f64N/A
tan-lowering-tan.f6499.7%
Applied egg-rr99.7%
*-commutativeN/A
tan-quotN/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
tan-lowering-tan.f64N/A
clear-numN/A
tan-quotN/A
/-lowering-/.f64N/A
tan-lowering-tan.f6499.7%
Applied egg-rr99.7%
Taylor expanded in y around inf
/-lowering-/.f64N/A
cos-lowering-cos.f64N/A
sin-lowering-sin.f6499.7%
Simplified99.7%
(FPCore (x y z a)
:precision binary64
(let* ((t_0 (+ (tan y) (tan z))))
(if (<= (tan a) -1e-16)
(+
x
(-
(/
t_0
(+ 1.0 (/ (tan z) (/ (- -1.0 (* -0.3333333333333333 (* y y))) y))))
(tan a)))
(if (<= (tan a) 5e-50)
(+ x (/ t_0 (- 1.0 (* (tan y) (tan z)))))
(+
x
(-
(/
t_0
(+
1.0
(/
(tan z)
(/
(-
-1.0
(*
(* y y)
(+
-0.3333333333333333
(*
(* y y)
(+
-0.022222222222222223
(* y (* y -0.0021164021164021165)))))))
y))))
(tan a)))))))
double code(double x, double y, double z, double a) {
double t_0 = tan(y) + tan(z);
double tmp;
if (tan(a) <= -1e-16) {
tmp = x + ((t_0 / (1.0 + (tan(z) / ((-1.0 - (-0.3333333333333333 * (y * y))) / y)))) - tan(a));
} else if (tan(a) <= 5e-50) {
tmp = x + (t_0 / (1.0 - (tan(y) * tan(z))));
} else {
tmp = x + ((t_0 / (1.0 + (tan(z) / ((-1.0 - ((y * y) * (-0.3333333333333333 + ((y * y) * (-0.022222222222222223 + (y * (y * -0.0021164021164021165))))))) / y)))) - 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) :: t_0
real(8) :: tmp
t_0 = tan(y) + tan(z)
if (tan(a) <= (-1d-16)) then
tmp = x + ((t_0 / (1.0d0 + (tan(z) / (((-1.0d0) - ((-0.3333333333333333d0) * (y * y))) / y)))) - tan(a))
else if (tan(a) <= 5d-50) then
tmp = x + (t_0 / (1.0d0 - (tan(y) * tan(z))))
else
tmp = x + ((t_0 / (1.0d0 + (tan(z) / (((-1.0d0) - ((y * y) * ((-0.3333333333333333d0) + ((y * y) * ((-0.022222222222222223d0) + (y * (y * (-0.0021164021164021165d0)))))))) / y)))) - tan(a))
end if
code = tmp
end function
public static double code(double x, double y, double z, double a) {
double t_0 = Math.tan(y) + Math.tan(z);
double tmp;
if (Math.tan(a) <= -1e-16) {
tmp = x + ((t_0 / (1.0 + (Math.tan(z) / ((-1.0 - (-0.3333333333333333 * (y * y))) / y)))) - Math.tan(a));
} else if (Math.tan(a) <= 5e-50) {
tmp = x + (t_0 / (1.0 - (Math.tan(y) * Math.tan(z))));
} else {
tmp = x + ((t_0 / (1.0 + (Math.tan(z) / ((-1.0 - ((y * y) * (-0.3333333333333333 + ((y * y) * (-0.022222222222222223 + (y * (y * -0.0021164021164021165))))))) / y)))) - Math.tan(a));
}
return tmp;
}
def code(x, y, z, a): t_0 = math.tan(y) + math.tan(z) tmp = 0 if math.tan(a) <= -1e-16: tmp = x + ((t_0 / (1.0 + (math.tan(z) / ((-1.0 - (-0.3333333333333333 * (y * y))) / y)))) - math.tan(a)) elif math.tan(a) <= 5e-50: tmp = x + (t_0 / (1.0 - (math.tan(y) * math.tan(z)))) else: tmp = x + ((t_0 / (1.0 + (math.tan(z) / ((-1.0 - ((y * y) * (-0.3333333333333333 + ((y * y) * (-0.022222222222222223 + (y * (y * -0.0021164021164021165))))))) / y)))) - math.tan(a)) return tmp
function code(x, y, z, a) t_0 = Float64(tan(y) + tan(z)) tmp = 0.0 if (tan(a) <= -1e-16) tmp = Float64(x + Float64(Float64(t_0 / Float64(1.0 + Float64(tan(z) / Float64(Float64(-1.0 - Float64(-0.3333333333333333 * Float64(y * y))) / y)))) - tan(a))); elseif (tan(a) <= 5e-50) tmp = Float64(x + Float64(t_0 / Float64(1.0 - Float64(tan(y) * tan(z))))); else tmp = Float64(x + Float64(Float64(t_0 / Float64(1.0 + Float64(tan(z) / Float64(Float64(-1.0 - Float64(Float64(y * y) * Float64(-0.3333333333333333 + Float64(Float64(y * y) * Float64(-0.022222222222222223 + Float64(y * Float64(y * -0.0021164021164021165))))))) / y)))) - tan(a))); end return tmp end
function tmp_2 = code(x, y, z, a) t_0 = tan(y) + tan(z); tmp = 0.0; if (tan(a) <= -1e-16) tmp = x + ((t_0 / (1.0 + (tan(z) / ((-1.0 - (-0.3333333333333333 * (y * y))) / y)))) - tan(a)); elseif (tan(a) <= 5e-50) tmp = x + (t_0 / (1.0 - (tan(y) * tan(z)))); else tmp = x + ((t_0 / (1.0 + (tan(z) / ((-1.0 - ((y * y) * (-0.3333333333333333 + ((y * y) * (-0.022222222222222223 + (y * (y * -0.0021164021164021165))))))) / y)))) - tan(a)); end tmp_2 = tmp; end
code[x_, y_, z_, a_] := Block[{t$95$0 = N[(N[Tan[y], $MachinePrecision] + N[Tan[z], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Tan[a], $MachinePrecision], -1e-16], N[(x + N[(N[(t$95$0 / N[(1.0 + N[(N[Tan[z], $MachinePrecision] / N[(N[(-1.0 - N[(-0.3333333333333333 * N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[Tan[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Tan[a], $MachinePrecision], 5e-50], N[(x + N[(t$95$0 / N[(1.0 - N[(N[Tan[y], $MachinePrecision] * N[Tan[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(t$95$0 / N[(1.0 + N[(N[Tan[z], $MachinePrecision] / N[(N[(-1.0 - N[(N[(y * y), $MachinePrecision] * N[(-0.3333333333333333 + N[(N[(y * y), $MachinePrecision] * N[(-0.022222222222222223 + N[(y * N[(y * -0.0021164021164021165), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[Tan[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \tan y + \tan z\\
\mathbf{if}\;\tan a \leq -1 \cdot 10^{-16}:\\
\;\;\;\;x + \left(\frac{t\_0}{1 + \frac{\tan z}{\frac{-1 - -0.3333333333333333 \cdot \left(y \cdot y\right)}{y}}} - \tan a\right)\\
\mathbf{elif}\;\tan a \leq 5 \cdot 10^{-50}:\\
\;\;\;\;x + \frac{t\_0}{1 - \tan y \cdot \tan z}\\
\mathbf{else}:\\
\;\;\;\;x + \left(\frac{t\_0}{1 + \frac{\tan z}{\frac{-1 - \left(y \cdot y\right) \cdot \left(-0.3333333333333333 + \left(y \cdot y\right) \cdot \left(-0.022222222222222223 + y \cdot \left(y \cdot -0.0021164021164021165\right)\right)\right)}{y}}} - \tan a\right)\\
\end{array}
\end{array}
if (tan.f64 a) < -9.9999999999999998e-17Initial program 77.3%
tan-sumN/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
tan-lowering-tan.f64N/A
tan-lowering-tan.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
tan-lowering-tan.f64N/A
tan-lowering-tan.f6499.7%
Applied egg-rr99.7%
*-commutativeN/A
tan-quotN/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
tan-lowering-tan.f64N/A
clear-numN/A
tan-quotN/A
/-lowering-/.f64N/A
tan-lowering-tan.f6499.7%
Applied egg-rr99.7%
Taylor expanded in y around 0
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6477.8%
Simplified77.8%
if -9.9999999999999998e-17 < (tan.f64 a) < 4.99999999999999968e-50Initial program 73.7%
Taylor expanded in a around 0
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
sin-lowering-sin.f64N/A
+-lowering-+.f64N/A
cos-lowering-cos.f64N/A
+-lowering-+.f6473.7%
Simplified73.7%
tan-quotN/A
tan-sumN/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
tan-lowering-tan.f64N/A
tan-lowering-tan.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
tan-lowering-tan.f64N/A
tan-lowering-tan.f6499.7%
Applied egg-rr99.7%
if 4.99999999999999968e-50 < (tan.f64 a) Initial program 80.0%
tan-sumN/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
tan-lowering-tan.f64N/A
tan-lowering-tan.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
tan-lowering-tan.f64N/A
tan-lowering-tan.f6499.5%
Applied egg-rr99.5%
*-commutativeN/A
tan-quotN/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
tan-lowering-tan.f64N/A
clear-numN/A
tan-quotN/A
/-lowering-/.f64N/A
tan-lowering-tan.f6499.6%
Applied egg-rr99.6%
Taylor expanded in y around 0
/-lowering-/.f64N/A
Simplified82.4%
Final simplification89.5%
(FPCore (x y z a)
:precision binary64
(let* ((t_0 (+ (tan y) (tan z))))
(if (<= (tan a) -1e-16)
(+
x
(-
(/
t_0
(+ 1.0 (/ (tan z) (/ (- -1.0 (* -0.3333333333333333 (* y y))) y))))
(tan a)))
(if (<= (tan a) 5e-50)
(+ x (/ t_0 (- 1.0 (* (tan y) (tan z)))))
(+
x
(-
(/
t_0
(+
1.0
(/
(tan z)
(/
(-
-1.0
(*
(* y y)
(+ -0.3333333333333333 (* y (* y -0.022222222222222223)))))
y))))
(tan a)))))))
double code(double x, double y, double z, double a) {
double t_0 = tan(y) + tan(z);
double tmp;
if (tan(a) <= -1e-16) {
tmp = x + ((t_0 / (1.0 + (tan(z) / ((-1.0 - (-0.3333333333333333 * (y * y))) / y)))) - tan(a));
} else if (tan(a) <= 5e-50) {
tmp = x + (t_0 / (1.0 - (tan(y) * tan(z))));
} else {
tmp = x + ((t_0 / (1.0 + (tan(z) / ((-1.0 - ((y * y) * (-0.3333333333333333 + (y * (y * -0.022222222222222223))))) / y)))) - 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) :: t_0
real(8) :: tmp
t_0 = tan(y) + tan(z)
if (tan(a) <= (-1d-16)) then
tmp = x + ((t_0 / (1.0d0 + (tan(z) / (((-1.0d0) - ((-0.3333333333333333d0) * (y * y))) / y)))) - tan(a))
else if (tan(a) <= 5d-50) then
tmp = x + (t_0 / (1.0d0 - (tan(y) * tan(z))))
else
tmp = x + ((t_0 / (1.0d0 + (tan(z) / (((-1.0d0) - ((y * y) * ((-0.3333333333333333d0) + (y * (y * (-0.022222222222222223d0)))))) / y)))) - tan(a))
end if
code = tmp
end function
public static double code(double x, double y, double z, double a) {
double t_0 = Math.tan(y) + Math.tan(z);
double tmp;
if (Math.tan(a) <= -1e-16) {
tmp = x + ((t_0 / (1.0 + (Math.tan(z) / ((-1.0 - (-0.3333333333333333 * (y * y))) / y)))) - Math.tan(a));
} else if (Math.tan(a) <= 5e-50) {
tmp = x + (t_0 / (1.0 - (Math.tan(y) * Math.tan(z))));
} else {
tmp = x + ((t_0 / (1.0 + (Math.tan(z) / ((-1.0 - ((y * y) * (-0.3333333333333333 + (y * (y * -0.022222222222222223))))) / y)))) - Math.tan(a));
}
return tmp;
}
def code(x, y, z, a): t_0 = math.tan(y) + math.tan(z) tmp = 0 if math.tan(a) <= -1e-16: tmp = x + ((t_0 / (1.0 + (math.tan(z) / ((-1.0 - (-0.3333333333333333 * (y * y))) / y)))) - math.tan(a)) elif math.tan(a) <= 5e-50: tmp = x + (t_0 / (1.0 - (math.tan(y) * math.tan(z)))) else: tmp = x + ((t_0 / (1.0 + (math.tan(z) / ((-1.0 - ((y * y) * (-0.3333333333333333 + (y * (y * -0.022222222222222223))))) / y)))) - math.tan(a)) return tmp
function code(x, y, z, a) t_0 = Float64(tan(y) + tan(z)) tmp = 0.0 if (tan(a) <= -1e-16) tmp = Float64(x + Float64(Float64(t_0 / Float64(1.0 + Float64(tan(z) / Float64(Float64(-1.0 - Float64(-0.3333333333333333 * Float64(y * y))) / y)))) - tan(a))); elseif (tan(a) <= 5e-50) tmp = Float64(x + Float64(t_0 / Float64(1.0 - Float64(tan(y) * tan(z))))); else tmp = Float64(x + Float64(Float64(t_0 / Float64(1.0 + Float64(tan(z) / Float64(Float64(-1.0 - Float64(Float64(y * y) * Float64(-0.3333333333333333 + Float64(y * Float64(y * -0.022222222222222223))))) / y)))) - tan(a))); end return tmp end
function tmp_2 = code(x, y, z, a) t_0 = tan(y) + tan(z); tmp = 0.0; if (tan(a) <= -1e-16) tmp = x + ((t_0 / (1.0 + (tan(z) / ((-1.0 - (-0.3333333333333333 * (y * y))) / y)))) - tan(a)); elseif (tan(a) <= 5e-50) tmp = x + (t_0 / (1.0 - (tan(y) * tan(z)))); else tmp = x + ((t_0 / (1.0 + (tan(z) / ((-1.0 - ((y * y) * (-0.3333333333333333 + (y * (y * -0.022222222222222223))))) / y)))) - tan(a)); end tmp_2 = tmp; end
code[x_, y_, z_, a_] := Block[{t$95$0 = N[(N[Tan[y], $MachinePrecision] + N[Tan[z], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Tan[a], $MachinePrecision], -1e-16], N[(x + N[(N[(t$95$0 / N[(1.0 + N[(N[Tan[z], $MachinePrecision] / N[(N[(-1.0 - N[(-0.3333333333333333 * N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[Tan[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Tan[a], $MachinePrecision], 5e-50], N[(x + N[(t$95$0 / N[(1.0 - N[(N[Tan[y], $MachinePrecision] * N[Tan[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(N[(t$95$0 / N[(1.0 + N[(N[Tan[z], $MachinePrecision] / N[(N[(-1.0 - N[(N[(y * y), $MachinePrecision] * N[(-0.3333333333333333 + N[(y * N[(y * -0.022222222222222223), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[Tan[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \tan y + \tan z\\
\mathbf{if}\;\tan a \leq -1 \cdot 10^{-16}:\\
\;\;\;\;x + \left(\frac{t\_0}{1 + \frac{\tan z}{\frac{-1 - -0.3333333333333333 \cdot \left(y \cdot y\right)}{y}}} - \tan a\right)\\
\mathbf{elif}\;\tan a \leq 5 \cdot 10^{-50}:\\
\;\;\;\;x + \frac{t\_0}{1 - \tan y \cdot \tan z}\\
\mathbf{else}:\\
\;\;\;\;x + \left(\frac{t\_0}{1 + \frac{\tan z}{\frac{-1 - \left(y \cdot y\right) \cdot \left(-0.3333333333333333 + y \cdot \left(y \cdot -0.022222222222222223\right)\right)}{y}}} - \tan a\right)\\
\end{array}
\end{array}
if (tan.f64 a) < -9.9999999999999998e-17Initial program 77.3%
tan-sumN/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
tan-lowering-tan.f64N/A
tan-lowering-tan.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
tan-lowering-tan.f64N/A
tan-lowering-tan.f6499.7%
Applied egg-rr99.7%
*-commutativeN/A
tan-quotN/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
tan-lowering-tan.f64N/A
clear-numN/A
tan-quotN/A
/-lowering-/.f64N/A
tan-lowering-tan.f6499.7%
Applied egg-rr99.7%
Taylor expanded in y around 0
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6477.8%
Simplified77.8%
if -9.9999999999999998e-17 < (tan.f64 a) < 4.99999999999999968e-50Initial program 73.7%
Taylor expanded in a around 0
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
sin-lowering-sin.f64N/A
+-lowering-+.f64N/A
cos-lowering-cos.f64N/A
+-lowering-+.f6473.7%
Simplified73.7%
tan-quotN/A
tan-sumN/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
tan-lowering-tan.f64N/A
tan-lowering-tan.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
tan-lowering-tan.f64N/A
tan-lowering-tan.f6499.7%
Applied egg-rr99.7%
if 4.99999999999999968e-50 < (tan.f64 a) Initial program 80.0%
tan-sumN/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
tan-lowering-tan.f64N/A
tan-lowering-tan.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
tan-lowering-tan.f64N/A
tan-lowering-tan.f6499.5%
Applied egg-rr99.5%
*-commutativeN/A
tan-quotN/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
tan-lowering-tan.f64N/A
clear-numN/A
tan-quotN/A
/-lowering-/.f64N/A
tan-lowering-tan.f6499.6%
Applied egg-rr99.6%
Taylor expanded in y around 0
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
sub-negN/A
metadata-evalN/A
+-commutativeN/A
+-lowering-+.f64N/A
*-commutativeN/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f6482.3%
Simplified82.3%
Final simplification89.5%
(FPCore (x y z a)
:precision binary64
(let* ((t_0 (+ (tan y) (tan z)))
(t_1
(+
x
(-
(/
t_0
(+ 1.0 (/ (tan z) (/ (- -1.0 (* -0.3333333333333333 (* y y))) y))))
(tan a)))))
(if (<= (tan a) -1e-16)
t_1
(if (<= (tan a) 5e-15) (+ x (/ t_0 (- 1.0 (* (tan y) (tan z))))) t_1))))
double code(double x, double y, double z, double a) {
double t_0 = tan(y) + tan(z);
double t_1 = x + ((t_0 / (1.0 + (tan(z) / ((-1.0 - (-0.3333333333333333 * (y * y))) / y)))) - tan(a));
double tmp;
if (tan(a) <= -1e-16) {
tmp = t_1;
} else if (tan(a) <= 5e-15) {
tmp = x + (t_0 / (1.0 - (tan(y) * tan(z))));
} else {
tmp = t_1;
}
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) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = tan(y) + tan(z)
t_1 = x + ((t_0 / (1.0d0 + (tan(z) / (((-1.0d0) - ((-0.3333333333333333d0) * (y * y))) / y)))) - tan(a))
if (tan(a) <= (-1d-16)) then
tmp = t_1
else if (tan(a) <= 5d-15) then
tmp = x + (t_0 / (1.0d0 - (tan(y) * tan(z))))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double a) {
double t_0 = Math.tan(y) + Math.tan(z);
double t_1 = x + ((t_0 / (1.0 + (Math.tan(z) / ((-1.0 - (-0.3333333333333333 * (y * y))) / y)))) - Math.tan(a));
double tmp;
if (Math.tan(a) <= -1e-16) {
tmp = t_1;
} else if (Math.tan(a) <= 5e-15) {
tmp = x + (t_0 / (1.0 - (Math.tan(y) * Math.tan(z))));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, a): t_0 = math.tan(y) + math.tan(z) t_1 = x + ((t_0 / (1.0 + (math.tan(z) / ((-1.0 - (-0.3333333333333333 * (y * y))) / y)))) - math.tan(a)) tmp = 0 if math.tan(a) <= -1e-16: tmp = t_1 elif math.tan(a) <= 5e-15: tmp = x + (t_0 / (1.0 - (math.tan(y) * math.tan(z)))) else: tmp = t_1 return tmp
function code(x, y, z, a) t_0 = Float64(tan(y) + tan(z)) t_1 = Float64(x + Float64(Float64(t_0 / Float64(1.0 + Float64(tan(z) / Float64(Float64(-1.0 - Float64(-0.3333333333333333 * Float64(y * y))) / y)))) - tan(a))) tmp = 0.0 if (tan(a) <= -1e-16) tmp = t_1; elseif (tan(a) <= 5e-15) tmp = Float64(x + Float64(t_0 / Float64(1.0 - Float64(tan(y) * tan(z))))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, a) t_0 = tan(y) + tan(z); t_1 = x + ((t_0 / (1.0 + (tan(z) / ((-1.0 - (-0.3333333333333333 * (y * y))) / y)))) - tan(a)); tmp = 0.0; if (tan(a) <= -1e-16) tmp = t_1; elseif (tan(a) <= 5e-15) tmp = x + (t_0 / (1.0 - (tan(y) * tan(z)))); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, a_] := Block[{t$95$0 = N[(N[Tan[y], $MachinePrecision] + N[Tan[z], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(x + N[(N[(t$95$0 / N[(1.0 + N[(N[Tan[z], $MachinePrecision] / N[(N[(-1.0 - N[(-0.3333333333333333 * N[(y * y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / y), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[Tan[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Tan[a], $MachinePrecision], -1e-16], t$95$1, If[LessEqual[N[Tan[a], $MachinePrecision], 5e-15], N[(x + N[(t$95$0 / N[(1.0 - N[(N[Tan[y], $MachinePrecision] * N[Tan[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \tan y + \tan z\\
t_1 := x + \left(\frac{t\_0}{1 + \frac{\tan z}{\frac{-1 - -0.3333333333333333 \cdot \left(y \cdot y\right)}{y}}} - \tan a\right)\\
\mathbf{if}\;\tan a \leq -1 \cdot 10^{-16}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;\tan a \leq 5 \cdot 10^{-15}:\\
\;\;\;\;x + \frac{t\_0}{1 - \tan y \cdot \tan z}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (tan.f64 a) < -9.9999999999999998e-17 or 4.99999999999999999e-15 < (tan.f64 a) Initial program 78.6%
tan-sumN/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
tan-lowering-tan.f64N/A
tan-lowering-tan.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
tan-lowering-tan.f64N/A
tan-lowering-tan.f6499.6%
Applied egg-rr99.6%
*-commutativeN/A
tan-quotN/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
tan-lowering-tan.f64N/A
clear-numN/A
tan-quotN/A
/-lowering-/.f64N/A
tan-lowering-tan.f6499.6%
Applied egg-rr99.6%
Taylor expanded in y around 0
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6479.4%
Simplified79.4%
if -9.9999999999999998e-17 < (tan.f64 a) < 4.99999999999999999e-15Initial program 74.0%
Taylor expanded in a around 0
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
sin-lowering-sin.f64N/A
+-lowering-+.f64N/A
cos-lowering-cos.f64N/A
+-lowering-+.f6474.0%
Simplified74.0%
tan-quotN/A
tan-sumN/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
tan-lowering-tan.f64N/A
tan-lowering-tan.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
tan-lowering-tan.f64N/A
tan-lowering-tan.f6499.7%
Applied egg-rr99.7%
Final simplification89.4%
(FPCore (x y z a)
:precision binary64
(let* ((t_0 (+ (tan y) (tan z))) (t_1 (+ x (- t_0 (tan a)))))
(if (<= (tan a) -1e-16)
t_1
(if (<= (tan a) 5e-15) (+ x (/ t_0 (- 1.0 (* (tan y) (tan z))))) t_1))))
double code(double x, double y, double z, double a) {
double t_0 = tan(y) + tan(z);
double t_1 = x + (t_0 - tan(a));
double tmp;
if (tan(a) <= -1e-16) {
tmp = t_1;
} else if (tan(a) <= 5e-15) {
tmp = x + (t_0 / (1.0 - (tan(y) * tan(z))));
} else {
tmp = t_1;
}
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) :: t_0
real(8) :: t_1
real(8) :: tmp
t_0 = tan(y) + tan(z)
t_1 = x + (t_0 - tan(a))
if (tan(a) <= (-1d-16)) then
tmp = t_1
else if (tan(a) <= 5d-15) then
tmp = x + (t_0 / (1.0d0 - (tan(y) * tan(z))))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double x, double y, double z, double a) {
double t_0 = Math.tan(y) + Math.tan(z);
double t_1 = x + (t_0 - Math.tan(a));
double tmp;
if (Math.tan(a) <= -1e-16) {
tmp = t_1;
} else if (Math.tan(a) <= 5e-15) {
tmp = x + (t_0 / (1.0 - (Math.tan(y) * Math.tan(z))));
} else {
tmp = t_1;
}
return tmp;
}
def code(x, y, z, a): t_0 = math.tan(y) + math.tan(z) t_1 = x + (t_0 - math.tan(a)) tmp = 0 if math.tan(a) <= -1e-16: tmp = t_1 elif math.tan(a) <= 5e-15: tmp = x + (t_0 / (1.0 - (math.tan(y) * math.tan(z)))) else: tmp = t_1 return tmp
function code(x, y, z, a) t_0 = Float64(tan(y) + tan(z)) t_1 = Float64(x + Float64(t_0 - tan(a))) tmp = 0.0 if (tan(a) <= -1e-16) tmp = t_1; elseif (tan(a) <= 5e-15) tmp = Float64(x + Float64(t_0 / Float64(1.0 - Float64(tan(y) * tan(z))))); else tmp = t_1; end return tmp end
function tmp_2 = code(x, y, z, a) t_0 = tan(y) + tan(z); t_1 = x + (t_0 - tan(a)); tmp = 0.0; if (tan(a) <= -1e-16) tmp = t_1; elseif (tan(a) <= 5e-15) tmp = x + (t_0 / (1.0 - (tan(y) * tan(z)))); else tmp = t_1; end tmp_2 = tmp; end
code[x_, y_, z_, a_] := Block[{t$95$0 = N[(N[Tan[y], $MachinePrecision] + N[Tan[z], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(x + N[(t$95$0 - N[Tan[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Tan[a], $MachinePrecision], -1e-16], t$95$1, If[LessEqual[N[Tan[a], $MachinePrecision], 5e-15], N[(x + N[(t$95$0 / N[(1.0 - N[(N[Tan[y], $MachinePrecision] * N[Tan[z], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$1]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \tan y + \tan z\\
t_1 := x + \left(t\_0 - \tan a\right)\\
\mathbf{if}\;\tan a \leq -1 \cdot 10^{-16}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;\tan a \leq 5 \cdot 10^{-15}:\\
\;\;\;\;x + \frac{t\_0}{1 - \tan y \cdot \tan z}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if (tan.f64 a) < -9.9999999999999998e-17 or 4.99999999999999999e-15 < (tan.f64 a) Initial program 78.6%
tan-sumN/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
tan-lowering-tan.f64N/A
tan-lowering-tan.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
tan-lowering-tan.f64N/A
tan-lowering-tan.f6499.6%
Applied egg-rr99.6%
*-commutativeN/A
tan-quotN/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
tan-lowering-tan.f64N/A
clear-numN/A
tan-quotN/A
/-lowering-/.f64N/A
tan-lowering-tan.f6499.6%
Applied egg-rr99.6%
Taylor expanded in z around 0
Simplified79.3%
if -9.9999999999999998e-17 < (tan.f64 a) < 4.99999999999999999e-15Initial program 74.0%
Taylor expanded in a around 0
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
sin-lowering-sin.f64N/A
+-lowering-+.f64N/A
cos-lowering-cos.f64N/A
+-lowering-+.f6474.0%
Simplified74.0%
tan-quotN/A
tan-sumN/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
tan-lowering-tan.f64N/A
tan-lowering-tan.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
tan-lowering-tan.f64N/A
tan-lowering-tan.f6499.7%
Applied egg-rr99.7%
Final simplification89.3%
(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 76.3%
tan-sumN/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
tan-lowering-tan.f64N/A
tan-lowering-tan.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
tan-lowering-tan.f64N/A
tan-lowering-tan.f6499.7%
Applied egg-rr99.7%
(FPCore (x y z a) :precision binary64 (let* ((t_0 (- x (tan a)))) (if (<= (tan a) -5e-6) t_0 (if (<= (tan a) 0.02) (+ x (tan (+ y z))) t_0))))
double code(double x, double y, double z, double a) {
double t_0 = x - tan(a);
double tmp;
if (tan(a) <= -5e-6) {
tmp = t_0;
} else if (tan(a) <= 0.02) {
tmp = x + tan((y + z));
} else {
tmp = t_0;
}
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) :: t_0
real(8) :: tmp
t_0 = x - tan(a)
if (tan(a) <= (-5d-6)) then
tmp = t_0
else if (tan(a) <= 0.02d0) then
tmp = x + tan((y + z))
else
tmp = t_0
end if
code = tmp
end function
public static double code(double x, double y, double z, double a) {
double t_0 = x - Math.tan(a);
double tmp;
if (Math.tan(a) <= -5e-6) {
tmp = t_0;
} else if (Math.tan(a) <= 0.02) {
tmp = x + Math.tan((y + z));
} else {
tmp = t_0;
}
return tmp;
}
def code(x, y, z, a): t_0 = x - math.tan(a) tmp = 0 if math.tan(a) <= -5e-6: tmp = t_0 elif math.tan(a) <= 0.02: tmp = x + math.tan((y + z)) else: tmp = t_0 return tmp
function code(x, y, z, a) t_0 = Float64(x - tan(a)) tmp = 0.0 if (tan(a) <= -5e-6) tmp = t_0; elseif (tan(a) <= 0.02) tmp = Float64(x + tan(Float64(y + z))); else tmp = t_0; end return tmp end
function tmp_2 = code(x, y, z, a) t_0 = x - tan(a); tmp = 0.0; if (tan(a) <= -5e-6) tmp = t_0; elseif (tan(a) <= 0.02) tmp = x + tan((y + z)); else tmp = t_0; end tmp_2 = tmp; end
code[x_, y_, z_, a_] := Block[{t$95$0 = N[(x - N[Tan[a], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Tan[a], $MachinePrecision], -5e-6], t$95$0, If[LessEqual[N[Tan[a], $MachinePrecision], 0.02], N[(x + N[Tan[N[(y + z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := x - \tan a\\
\mathbf{if}\;\tan a \leq -5 \cdot 10^{-6}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;\tan a \leq 0.02:\\
\;\;\;\;x + \tan \left(y + z\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if (tan.f64 a) < -5.00000000000000041e-6 or 0.0200000000000000004 < (tan.f64 a) Initial program 77.2%
Taylor expanded in z around 0
+-commutativeN/A
associate--l+N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
sin-lowering-sin.f64N/A
cos-lowering-cos.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
sin-lowering-sin.f64N/A
cos-lowering-cos.f6460.9%
Simplified60.9%
Taylor expanded in y around 0
--lowering--.f64N/A
/-lowering-/.f64N/A
sin-lowering-sin.f64N/A
cos-lowering-cos.f6445.5%
Simplified45.5%
--lowering--.f64N/A
tan-quotN/A
tan-lowering-tan.f6445.5%
Applied egg-rr45.5%
if -5.00000000000000041e-6 < (tan.f64 a) < 0.0200000000000000004Initial program 75.5%
Taylor expanded in a around 0
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
sin-lowering-sin.f64N/A
+-lowering-+.f64N/A
cos-lowering-cos.f64N/A
+-lowering-+.f6473.7%
Simplified73.7%
tan-quotN/A
+-lowering-+.f64N/A
tan-lowering-tan.f64N/A
+-lowering-+.f6473.7%
Applied egg-rr73.7%
Final simplification60.3%
(FPCore (x y z a) :precision binary64 (+ x (- (+ (tan y) (tan z)) (tan a))))
double code(double x, double y, double z, double a) {
return x + ((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)) - tan(a))
end function
public static double code(double x, double y, double z, double a) {
return x + ((Math.tan(y) + Math.tan(z)) - Math.tan(a));
}
def code(x, y, z, a): return x + ((math.tan(y) + math.tan(z)) - math.tan(a))
function code(x, y, z, a) return Float64(x + Float64(Float64(tan(y) + tan(z)) - tan(a))) end
function tmp = code(x, y, z, a) tmp = x + ((tan(y) + tan(z)) - tan(a)); end
code[x_, y_, z_, a_] := N[(x + N[(N[(N[Tan[y], $MachinePrecision] + N[Tan[z], $MachinePrecision]), $MachinePrecision] - N[Tan[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \left(\left(\tan y + \tan z\right) - \tan a\right)
\end{array}
Initial program 76.3%
tan-sumN/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
tan-lowering-tan.f64N/A
tan-lowering-tan.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
tan-lowering-tan.f64N/A
tan-lowering-tan.f6499.7%
Applied egg-rr99.7%
*-commutativeN/A
tan-quotN/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
tan-lowering-tan.f64N/A
clear-numN/A
tan-quotN/A
/-lowering-/.f64N/A
tan-lowering-tan.f6499.7%
Applied egg-rr99.7%
Taylor expanded in z around 0
Simplified77.0%
Final simplification77.0%
(FPCore (x y z a) :precision binary64 (if (<= (+ y z) -2e-243) (+ x (- (tan y) (tan a))) (+ x (- (tan z) (tan a)))))
double code(double x, double y, double z, double a) {
double tmp;
if ((y + z) <= -2e-243) {
tmp = x + (tan(y) - tan(a));
} 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) <= (-2d-243)) then
tmp = x + (tan(y) - tan(a))
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) <= -2e-243) {
tmp = x + (Math.tan(y) - Math.tan(a));
} else {
tmp = x + (Math.tan(z) - Math.tan(a));
}
return tmp;
}
def code(x, y, z, a): tmp = 0 if (y + z) <= -2e-243: tmp = x + (math.tan(y) - math.tan(a)) else: tmp = x + (math.tan(z) - math.tan(a)) return tmp
function code(x, y, z, a) tmp = 0.0 if (Float64(y + z) <= -2e-243) tmp = Float64(x + Float64(tan(y) - tan(a))); 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) <= -2e-243) tmp = x + (tan(y) - tan(a)); else tmp = x + (tan(z) - tan(a)); end tmp_2 = tmp; end
code[x_, y_, z_, a_] := If[LessEqual[N[(y + z), $MachinePrecision], -2e-243], N[(x + N[(N[Tan[y], $MachinePrecision] - N[Tan[a], $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 -2 \cdot 10^{-243}:\\
\;\;\;\;x + \left(\tan y - \tan a\right)\\
\mathbf{else}:\\
\;\;\;\;x + \left(\tan z - \tan a\right)\\
\end{array}
\end{array}
if (+.f64 y z) < -1.99999999999999999e-243Initial program 73.8%
Taylor expanded in y around inf
Simplified60.8%
if -1.99999999999999999e-243 < (+.f64 y z) Initial program 79.2%
Taylor expanded in y around 0
Simplified58.3%
(FPCore (x y z a) :precision binary64 (if (<= (+ y z) 0.05) (+ x (- (tan y) (tan a))) (+ x (/ 1.0 (/ 1.0 (tan (+ y z)))))))
double code(double x, double y, double z, double a) {
double tmp;
if ((y + z) <= 0.05) {
tmp = x + (tan(y) - tan(a));
} else {
tmp = x + (1.0 / (1.0 / tan((y + z))));
}
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) <= 0.05d0) then
tmp = x + (tan(y) - tan(a))
else
tmp = x + (1.0d0 / (1.0d0 / tan((y + z))))
end if
code = tmp
end function
public static double code(double x, double y, double z, double a) {
double tmp;
if ((y + z) <= 0.05) {
tmp = x + (Math.tan(y) - Math.tan(a));
} else {
tmp = x + (1.0 / (1.0 / Math.tan((y + z))));
}
return tmp;
}
def code(x, y, z, a): tmp = 0 if (y + z) <= 0.05: tmp = x + (math.tan(y) - math.tan(a)) else: tmp = x + (1.0 / (1.0 / math.tan((y + z)))) return tmp
function code(x, y, z, a) tmp = 0.0 if (Float64(y + z) <= 0.05) tmp = Float64(x + Float64(tan(y) - tan(a))); else tmp = Float64(x + Float64(1.0 / Float64(1.0 / tan(Float64(y + z))))); end return tmp end
function tmp_2 = code(x, y, z, a) tmp = 0.0; if ((y + z) <= 0.05) tmp = x + (tan(y) - tan(a)); else tmp = x + (1.0 / (1.0 / tan((y + z)))); end tmp_2 = tmp; end
code[x_, y_, z_, a_] := If[LessEqual[N[(y + z), $MachinePrecision], 0.05], N[(x + N[(N[Tan[y], $MachinePrecision] - N[Tan[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(x + N[(1.0 / N[(1.0 / N[Tan[N[(y + z), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;y + z \leq 0.05:\\
\;\;\;\;x + \left(\tan y - \tan a\right)\\
\mathbf{else}:\\
\;\;\;\;x + \frac{1}{\frac{1}{\tan \left(y + z\right)}}\\
\end{array}
\end{array}
if (+.f64 y z) < 0.050000000000000003Initial program 77.8%
Taylor expanded in y around inf
Simplified66.5%
if 0.050000000000000003 < (+.f64 y z) Initial program 73.7%
Taylor expanded in a around 0
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
sin-lowering-sin.f64N/A
+-lowering-+.f64N/A
cos-lowering-cos.f64N/A
+-lowering-+.f6446.3%
Simplified46.3%
clear-numN/A
/-lowering-/.f64N/A
clear-numN/A
tan-quotN/A
/-lowering-/.f64N/A
tan-lowering-tan.f64N/A
+-lowering-+.f6446.3%
Applied egg-rr46.3%
Final simplification59.1%
(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 76.3%
(FPCore (x y z a) :precision binary64 (let* ((t_0 (- x (tan a)))) (if (<= a -1.35e-5) t_0 (if (<= a 0.06) (+ x (- (tan (+ y z)) a)) t_0))))
double code(double x, double y, double z, double a) {
double t_0 = x - tan(a);
double tmp;
if (a <= -1.35e-5) {
tmp = t_0;
} else if (a <= 0.06) {
tmp = x + (tan((y + z)) - a);
} else {
tmp = t_0;
}
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) :: t_0
real(8) :: tmp
t_0 = x - tan(a)
if (a <= (-1.35d-5)) then
tmp = t_0
else if (a <= 0.06d0) then
tmp = x + (tan((y + z)) - a)
else
tmp = t_0
end if
code = tmp
end function
public static double code(double x, double y, double z, double a) {
double t_0 = x - Math.tan(a);
double tmp;
if (a <= -1.35e-5) {
tmp = t_0;
} else if (a <= 0.06) {
tmp = x + (Math.tan((y + z)) - a);
} else {
tmp = t_0;
}
return tmp;
}
def code(x, y, z, a): t_0 = x - math.tan(a) tmp = 0 if a <= -1.35e-5: tmp = t_0 elif a <= 0.06: tmp = x + (math.tan((y + z)) - a) else: tmp = t_0 return tmp
function code(x, y, z, a) t_0 = Float64(x - tan(a)) tmp = 0.0 if (a <= -1.35e-5) tmp = t_0; elseif (a <= 0.06) tmp = Float64(x + Float64(tan(Float64(y + z)) - a)); else tmp = t_0; end return tmp end
function tmp_2 = code(x, y, z, a) t_0 = x - tan(a); tmp = 0.0; if (a <= -1.35e-5) tmp = t_0; elseif (a <= 0.06) tmp = x + (tan((y + z)) - a); else tmp = t_0; end tmp_2 = tmp; end
code[x_, y_, z_, a_] := Block[{t$95$0 = N[(x - N[Tan[a], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[a, -1.35e-5], t$95$0, If[LessEqual[a, 0.06], N[(x + N[(N[Tan[N[(y + z), $MachinePrecision]], $MachinePrecision] - a), $MachinePrecision]), $MachinePrecision], t$95$0]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := x - \tan a\\
\mathbf{if}\;a \leq -1.35 \cdot 10^{-5}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;a \leq 0.06:\\
\;\;\;\;x + \left(\tan \left(y + z\right) - a\right)\\
\mathbf{else}:\\
\;\;\;\;t\_0\\
\end{array}
\end{array}
if a < -1.3499999999999999e-5 or 0.059999999999999998 < a Initial program 77.2%
Taylor expanded in z around 0
+-commutativeN/A
associate--l+N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
sin-lowering-sin.f64N/A
cos-lowering-cos.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
sin-lowering-sin.f64N/A
cos-lowering-cos.f6460.9%
Simplified60.9%
Taylor expanded in y around 0
--lowering--.f64N/A
/-lowering-/.f64N/A
sin-lowering-sin.f64N/A
cos-lowering-cos.f6444.8%
Simplified44.8%
--lowering--.f64N/A
tan-quotN/A
tan-lowering-tan.f6444.8%
Applied egg-rr44.8%
if -1.3499999999999999e-5 < a < 0.059999999999999998Initial program 75.5%
Taylor expanded in a around 0
Simplified75.5%
(FPCore (x y z a) :precision binary64 (- x (tan a)))
double code(double x, double y, double z, double a) {
return x - 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(a)
end function
public static double code(double x, double y, double z, double a) {
return x - Math.tan(a);
}
def code(x, y, z, a): return x - math.tan(a)
function code(x, y, z, a) return Float64(x - tan(a)) end
function tmp = code(x, y, z, a) tmp = x - tan(a); end
code[x_, y_, z_, a_] := N[(x - N[Tan[a], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x - \tan a
\end{array}
Initial program 76.3%
Taylor expanded in z around 0
+-commutativeN/A
associate--l+N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
sin-lowering-sin.f64N/A
cos-lowering-cos.f64N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
sin-lowering-sin.f64N/A
cos-lowering-cos.f6459.7%
Simplified59.7%
Taylor expanded in y around 0
--lowering--.f64N/A
/-lowering-/.f64N/A
sin-lowering-sin.f64N/A
cos-lowering-cos.f6440.9%
Simplified40.9%
--lowering--.f64N/A
tan-quotN/A
tan-lowering-tan.f6440.9%
Applied egg-rr40.9%
(FPCore (x y z a) :precision binary64 (+ x (sin z)))
double code(double x, double y, double z, double a) {
return x + sin(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 + sin(z)
end function
public static double code(double x, double y, double z, double a) {
return x + Math.sin(z);
}
def code(x, y, z, a): return x + math.sin(z)
function code(x, y, z, a) return Float64(x + sin(z)) end
function tmp = code(x, y, z, a) tmp = x + sin(z); end
code[x_, y_, z_, a_] := N[(x + N[Sin[z], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
x + \sin z
\end{array}
Initial program 76.3%
Taylor expanded in a around 0
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
sin-lowering-sin.f64N/A
+-lowering-+.f64N/A
cos-lowering-cos.f64N/A
+-lowering-+.f6449.9%
Simplified49.9%
Taylor expanded in y around inf
Simplified41.2%
Taylor expanded in y around 0
+-commutativeN/A
+-lowering-+.f64N/A
sin-lowering-sin.f6430.2%
Simplified30.2%
Final simplification30.2%
(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 76.3%
Taylor expanded in x around inf
Simplified30.0%
herbie shell --seed 2024152
(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))))