
(FPCore (eh ew t) :precision binary64 (let* ((t_1 (atan (/ (* (- eh) (tan t)) ew)))) (fabs (- (* (* ew (cos t)) (cos t_1)) (* (* eh (sin t)) (sin t_1))))))
double code(double eh, double ew, double t) {
double t_1 = atan(((-eh * tan(t)) / ew));
return fabs((((ew * cos(t)) * cos(t_1)) - ((eh * sin(t)) * sin(t_1))));
}
real(8) function code(eh, ew, t)
real(8), intent (in) :: eh
real(8), intent (in) :: ew
real(8), intent (in) :: t
real(8) :: t_1
t_1 = atan(((-eh * tan(t)) / ew))
code = abs((((ew * cos(t)) * cos(t_1)) - ((eh * sin(t)) * sin(t_1))))
end function
public static double code(double eh, double ew, double t) {
double t_1 = Math.atan(((-eh * Math.tan(t)) / ew));
return Math.abs((((ew * Math.cos(t)) * Math.cos(t_1)) - ((eh * Math.sin(t)) * Math.sin(t_1))));
}
def code(eh, ew, t): t_1 = math.atan(((-eh * math.tan(t)) / ew)) return math.fabs((((ew * math.cos(t)) * math.cos(t_1)) - ((eh * math.sin(t)) * math.sin(t_1))))
function code(eh, ew, t) t_1 = atan(Float64(Float64(Float64(-eh) * tan(t)) / ew)) return abs(Float64(Float64(Float64(ew * cos(t)) * cos(t_1)) - Float64(Float64(eh * sin(t)) * sin(t_1)))) end
function tmp = code(eh, ew, t) t_1 = atan(((-eh * tan(t)) / ew)); tmp = abs((((ew * cos(t)) * cos(t_1)) - ((eh * sin(t)) * sin(t_1)))); end
code[eh_, ew_, t_] := Block[{t$95$1 = N[ArcTan[N[(N[((-eh) * N[Tan[t], $MachinePrecision]), $MachinePrecision] / ew), $MachinePrecision]], $MachinePrecision]}, N[Abs[N[(N[(N[(ew * N[Cos[t], $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$1], $MachinePrecision]), $MachinePrecision] - N[(N[(eh * N[Sin[t], $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \tan^{-1} \left(\frac{\left(-eh\right) \cdot \tan t}{ew}\right)\\
\left|\left(ew \cdot \cos t\right) \cdot \cos t\_1 - \left(eh \cdot \sin t\right) \cdot \sin t\_1\right|
\end{array}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 17 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (eh ew t) :precision binary64 (let* ((t_1 (atan (/ (* (- eh) (tan t)) ew)))) (fabs (- (* (* ew (cos t)) (cos t_1)) (* (* eh (sin t)) (sin t_1))))))
double code(double eh, double ew, double t) {
double t_1 = atan(((-eh * tan(t)) / ew));
return fabs((((ew * cos(t)) * cos(t_1)) - ((eh * sin(t)) * sin(t_1))));
}
real(8) function code(eh, ew, t)
real(8), intent (in) :: eh
real(8), intent (in) :: ew
real(8), intent (in) :: t
real(8) :: t_1
t_1 = atan(((-eh * tan(t)) / ew))
code = abs((((ew * cos(t)) * cos(t_1)) - ((eh * sin(t)) * sin(t_1))))
end function
public static double code(double eh, double ew, double t) {
double t_1 = Math.atan(((-eh * Math.tan(t)) / ew));
return Math.abs((((ew * Math.cos(t)) * Math.cos(t_1)) - ((eh * Math.sin(t)) * Math.sin(t_1))));
}
def code(eh, ew, t): t_1 = math.atan(((-eh * math.tan(t)) / ew)) return math.fabs((((ew * math.cos(t)) * math.cos(t_1)) - ((eh * math.sin(t)) * math.sin(t_1))))
function code(eh, ew, t) t_1 = atan(Float64(Float64(Float64(-eh) * tan(t)) / ew)) return abs(Float64(Float64(Float64(ew * cos(t)) * cos(t_1)) - Float64(Float64(eh * sin(t)) * sin(t_1)))) end
function tmp = code(eh, ew, t) t_1 = atan(((-eh * tan(t)) / ew)); tmp = abs((((ew * cos(t)) * cos(t_1)) - ((eh * sin(t)) * sin(t_1)))); end
code[eh_, ew_, t_] := Block[{t$95$1 = N[ArcTan[N[(N[((-eh) * N[Tan[t], $MachinePrecision]), $MachinePrecision] / ew), $MachinePrecision]], $MachinePrecision]}, N[Abs[N[(N[(N[(ew * N[Cos[t], $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$1], $MachinePrecision]), $MachinePrecision] - N[(N[(eh * N[Sin[t], $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \tan^{-1} \left(\frac{\left(-eh\right) \cdot \tan t}{ew}\right)\\
\left|\left(ew \cdot \cos t\right) \cdot \cos t\_1 - \left(eh \cdot \sin t\right) \cdot \sin t\_1\right|
\end{array}
\end{array}
(FPCore (eh ew t) :precision binary64 (let* ((t_1 (atan (/ (* eh (tan t)) (- ew))))) (fabs (- (* (* eh (sin t)) (sin t_1)) (* (* ew (cos t)) (cos t_1))))))
double code(double eh, double ew, double t) {
double t_1 = atan(((eh * tan(t)) / -ew));
return fabs((((eh * sin(t)) * sin(t_1)) - ((ew * cos(t)) * cos(t_1))));
}
real(8) function code(eh, ew, t)
real(8), intent (in) :: eh
real(8), intent (in) :: ew
real(8), intent (in) :: t
real(8) :: t_1
t_1 = atan(((eh * tan(t)) / -ew))
code = abs((((eh * sin(t)) * sin(t_1)) - ((ew * cos(t)) * cos(t_1))))
end function
public static double code(double eh, double ew, double t) {
double t_1 = Math.atan(((eh * Math.tan(t)) / -ew));
return Math.abs((((eh * Math.sin(t)) * Math.sin(t_1)) - ((ew * Math.cos(t)) * Math.cos(t_1))));
}
def code(eh, ew, t): t_1 = math.atan(((eh * math.tan(t)) / -ew)) return math.fabs((((eh * math.sin(t)) * math.sin(t_1)) - ((ew * math.cos(t)) * math.cos(t_1))))
function code(eh, ew, t) t_1 = atan(Float64(Float64(eh * tan(t)) / Float64(-ew))) return abs(Float64(Float64(Float64(eh * sin(t)) * sin(t_1)) - Float64(Float64(ew * cos(t)) * cos(t_1)))) end
function tmp = code(eh, ew, t) t_1 = atan(((eh * tan(t)) / -ew)); tmp = abs((((eh * sin(t)) * sin(t_1)) - ((ew * cos(t)) * cos(t_1)))); end
code[eh_, ew_, t_] := Block[{t$95$1 = N[ArcTan[N[(N[(eh * N[Tan[t], $MachinePrecision]), $MachinePrecision] / (-ew)), $MachinePrecision]], $MachinePrecision]}, N[Abs[N[(N[(N[(eh * N[Sin[t], $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$1], $MachinePrecision]), $MachinePrecision] - N[(N[(ew * N[Cos[t], $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \tan^{-1} \left(\frac{eh \cdot \tan t}{-ew}\right)\\
\left|\left(eh \cdot \sin t\right) \cdot \sin t\_1 - \left(ew \cdot \cos t\right) \cdot \cos t\_1\right|
\end{array}
\end{array}
Initial program 99.9%
Final simplification99.9%
(FPCore (eh ew t)
:precision binary64
(let* ((t_1 (atan (/ (* eh (tan t)) (- ew)))))
(if (<=
(- (* (* ew (cos t)) (cos t_1)) (* (* eh (sin t)) (sin t_1)))
2e-191)
(fabs
(* (cos (atan (* (/ (sin t) ew) (/ (- eh) (fma (* t t) -0.5 1.0))))) ew))
(* (cos t) ew))))
double code(double eh, double ew, double t) {
double t_1 = atan(((eh * tan(t)) / -ew));
double tmp;
if ((((ew * cos(t)) * cos(t_1)) - ((eh * sin(t)) * sin(t_1))) <= 2e-191) {
tmp = fabs((cos(atan(((sin(t) / ew) * (-eh / fma((t * t), -0.5, 1.0))))) * ew));
} else {
tmp = cos(t) * ew;
}
return tmp;
}
function code(eh, ew, t) t_1 = atan(Float64(Float64(eh * tan(t)) / Float64(-ew))) tmp = 0.0 if (Float64(Float64(Float64(ew * cos(t)) * cos(t_1)) - Float64(Float64(eh * sin(t)) * sin(t_1))) <= 2e-191) tmp = abs(Float64(cos(atan(Float64(Float64(sin(t) / ew) * Float64(Float64(-eh) / fma(Float64(t * t), -0.5, 1.0))))) * ew)); else tmp = Float64(cos(t) * ew); end return tmp end
code[eh_, ew_, t_] := Block[{t$95$1 = N[ArcTan[N[(N[(eh * N[Tan[t], $MachinePrecision]), $MachinePrecision] / (-ew)), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[N[(N[(N[(ew * N[Cos[t], $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$1], $MachinePrecision]), $MachinePrecision] - N[(N[(eh * N[Sin[t], $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2e-191], N[Abs[N[(N[Cos[N[ArcTan[N[(N[(N[Sin[t], $MachinePrecision] / ew), $MachinePrecision] * N[((-eh) / N[(N[(t * t), $MachinePrecision] * -0.5 + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] * ew), $MachinePrecision]], $MachinePrecision], N[(N[Cos[t], $MachinePrecision] * ew), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \tan^{-1} \left(\frac{eh \cdot \tan t}{-ew}\right)\\
\mathbf{if}\;\left(ew \cdot \cos t\right) \cdot \cos t\_1 - \left(eh \cdot \sin t\right) \cdot \sin t\_1 \leq 2 \cdot 10^{-191}:\\
\;\;\;\;\left|\cos \tan^{-1} \left(\frac{\sin t}{ew} \cdot \frac{-eh}{\mathsf{fma}\left(t \cdot t, -0.5, 1\right)}\right) \cdot ew\right|\\
\mathbf{else}:\\
\;\;\;\;\cos t \cdot ew\\
\end{array}
\end{array}
if (-.f64 (*.f64 (*.f64 ew (cos.f64 t)) (cos.f64 (atan.f64 (/.f64 (*.f64 (neg.f64 eh) (tan.f64 t)) ew)))) (*.f64 (*.f64 eh (sin.f64 t)) (sin.f64 (atan.f64 (/.f64 (*.f64 (neg.f64 eh) (tan.f64 t)) ew))))) < 2e-191Initial program 99.9%
Taylor expanded in t around 0
*-commutativeN/A
lower-*.f64N/A
Applied rewrites46.0%
Taylor expanded in t around 0
Applied rewrites46.0%
if 2e-191 < (-.f64 (*.f64 (*.f64 ew (cos.f64 t)) (cos.f64 (atan.f64 (/.f64 (*.f64 (neg.f64 eh) (tan.f64 t)) ew)))) (*.f64 (*.f64 eh (sin.f64 t)) (sin.f64 (atan.f64 (/.f64 (*.f64 (neg.f64 eh) (tan.f64 t)) ew))))) Initial program 99.8%
Applied rewrites78.3%
Taylor expanded in t around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
lower-*.f64N/A
distribute-rgt-outN/A
metadata-evalN/A
lower-*.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6435.1
Applied rewrites35.1%
Taylor expanded in eh around 0
*-commutativeN/A
lower-*.f64N/A
lower-cos.f6460.6
Applied rewrites60.6%
Final simplification53.3%
(FPCore (eh ew t)
:precision binary64
(let* ((t_1 (atan (/ (* eh (tan t)) (- ew)))))
(if (<=
(- (* (* ew (cos t)) (cos t_1)) (* (* eh (sin t)) (sin t_1)))
-1e-290)
(fabs (* (cos (atan (* (/ (- (sin t)) ew) (/ eh 1.0)))) ew))
(* (cos t) ew))))
double code(double eh, double ew, double t) {
double t_1 = atan(((eh * tan(t)) / -ew));
double tmp;
if ((((ew * cos(t)) * cos(t_1)) - ((eh * sin(t)) * sin(t_1))) <= -1e-290) {
tmp = fabs((cos(atan(((-sin(t) / ew) * (eh / 1.0)))) * ew));
} else {
tmp = cos(t) * ew;
}
return tmp;
}
real(8) function code(eh, ew, t)
real(8), intent (in) :: eh
real(8), intent (in) :: ew
real(8), intent (in) :: t
real(8) :: t_1
real(8) :: tmp
t_1 = atan(((eh * tan(t)) / -ew))
if ((((ew * cos(t)) * cos(t_1)) - ((eh * sin(t)) * sin(t_1))) <= (-1d-290)) then
tmp = abs((cos(atan(((-sin(t) / ew) * (eh / 1.0d0)))) * ew))
else
tmp = cos(t) * ew
end if
code = tmp
end function
public static double code(double eh, double ew, double t) {
double t_1 = Math.atan(((eh * Math.tan(t)) / -ew));
double tmp;
if ((((ew * Math.cos(t)) * Math.cos(t_1)) - ((eh * Math.sin(t)) * Math.sin(t_1))) <= -1e-290) {
tmp = Math.abs((Math.cos(Math.atan(((-Math.sin(t) / ew) * (eh / 1.0)))) * ew));
} else {
tmp = Math.cos(t) * ew;
}
return tmp;
}
def code(eh, ew, t): t_1 = math.atan(((eh * math.tan(t)) / -ew)) tmp = 0 if (((ew * math.cos(t)) * math.cos(t_1)) - ((eh * math.sin(t)) * math.sin(t_1))) <= -1e-290: tmp = math.fabs((math.cos(math.atan(((-math.sin(t) / ew) * (eh / 1.0)))) * ew)) else: tmp = math.cos(t) * ew return tmp
function code(eh, ew, t) t_1 = atan(Float64(Float64(eh * tan(t)) / Float64(-ew))) tmp = 0.0 if (Float64(Float64(Float64(ew * cos(t)) * cos(t_1)) - Float64(Float64(eh * sin(t)) * sin(t_1))) <= -1e-290) tmp = abs(Float64(cos(atan(Float64(Float64(Float64(-sin(t)) / ew) * Float64(eh / 1.0)))) * ew)); else tmp = Float64(cos(t) * ew); end return tmp end
function tmp_2 = code(eh, ew, t) t_1 = atan(((eh * tan(t)) / -ew)); tmp = 0.0; if ((((ew * cos(t)) * cos(t_1)) - ((eh * sin(t)) * sin(t_1))) <= -1e-290) tmp = abs((cos(atan(((-sin(t) / ew) * (eh / 1.0)))) * ew)); else tmp = cos(t) * ew; end tmp_2 = tmp; end
code[eh_, ew_, t_] := Block[{t$95$1 = N[ArcTan[N[(N[(eh * N[Tan[t], $MachinePrecision]), $MachinePrecision] / (-ew)), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[N[(N[(N[(ew * N[Cos[t], $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$1], $MachinePrecision]), $MachinePrecision] - N[(N[(eh * N[Sin[t], $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], -1e-290], N[Abs[N[(N[Cos[N[ArcTan[N[(N[((-N[Sin[t], $MachinePrecision]) / ew), $MachinePrecision] * N[(eh / 1.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] * ew), $MachinePrecision]], $MachinePrecision], N[(N[Cos[t], $MachinePrecision] * ew), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \tan^{-1} \left(\frac{eh \cdot \tan t}{-ew}\right)\\
\mathbf{if}\;\left(ew \cdot \cos t\right) \cdot \cos t\_1 - \left(eh \cdot \sin t\right) \cdot \sin t\_1 \leq -1 \cdot 10^{-290}:\\
\;\;\;\;\left|\cos \tan^{-1} \left(\frac{-\sin t}{ew} \cdot \frac{eh}{1}\right) \cdot ew\right|\\
\mathbf{else}:\\
\;\;\;\;\cos t \cdot ew\\
\end{array}
\end{array}
if (-.f64 (*.f64 (*.f64 ew (cos.f64 t)) (cos.f64 (atan.f64 (/.f64 (*.f64 (neg.f64 eh) (tan.f64 t)) ew)))) (*.f64 (*.f64 eh (sin.f64 t)) (sin.f64 (atan.f64 (/.f64 (*.f64 (neg.f64 eh) (tan.f64 t)) ew))))) < -1.0000000000000001e-290Initial program 99.9%
Taylor expanded in t around 0
*-commutativeN/A
lower-*.f64N/A
Applied rewrites45.0%
Taylor expanded in t around 0
Applied rewrites45.0%
if -1.0000000000000001e-290 < (-.f64 (*.f64 (*.f64 ew (cos.f64 t)) (cos.f64 (atan.f64 (/.f64 (*.f64 (neg.f64 eh) (tan.f64 t)) ew)))) (*.f64 (*.f64 eh (sin.f64 t)) (sin.f64 (atan.f64 (/.f64 (*.f64 (neg.f64 eh) (tan.f64 t)) ew))))) Initial program 99.8%
Applied rewrites78.9%
Taylor expanded in t around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
lower-*.f64N/A
distribute-rgt-outN/A
metadata-evalN/A
lower-*.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6436.3
Applied rewrites36.3%
Taylor expanded in eh around 0
*-commutativeN/A
lower-*.f64N/A
lower-cos.f6461.1
Applied rewrites61.1%
Final simplification53.2%
(FPCore (eh ew t)
:precision binary64
(let* ((t_1 (atan (/ (* eh (tan t)) (- ew)))))
(if (<=
(- (* (* ew (cos t)) (cos t_1)) (* (* eh (sin t)) (sin t_1)))
-1e-290)
(fabs (* (cos (atan (* (/ (tan t) ew) eh))) ew))
(* (cos t) ew))))
double code(double eh, double ew, double t) {
double t_1 = atan(((eh * tan(t)) / -ew));
double tmp;
if ((((ew * cos(t)) * cos(t_1)) - ((eh * sin(t)) * sin(t_1))) <= -1e-290) {
tmp = fabs((cos(atan(((tan(t) / ew) * eh))) * ew));
} else {
tmp = cos(t) * ew;
}
return tmp;
}
real(8) function code(eh, ew, t)
real(8), intent (in) :: eh
real(8), intent (in) :: ew
real(8), intent (in) :: t
real(8) :: t_1
real(8) :: tmp
t_1 = atan(((eh * tan(t)) / -ew))
if ((((ew * cos(t)) * cos(t_1)) - ((eh * sin(t)) * sin(t_1))) <= (-1d-290)) then
tmp = abs((cos(atan(((tan(t) / ew) * eh))) * ew))
else
tmp = cos(t) * ew
end if
code = tmp
end function
public static double code(double eh, double ew, double t) {
double t_1 = Math.atan(((eh * Math.tan(t)) / -ew));
double tmp;
if ((((ew * Math.cos(t)) * Math.cos(t_1)) - ((eh * Math.sin(t)) * Math.sin(t_1))) <= -1e-290) {
tmp = Math.abs((Math.cos(Math.atan(((Math.tan(t) / ew) * eh))) * ew));
} else {
tmp = Math.cos(t) * ew;
}
return tmp;
}
def code(eh, ew, t): t_1 = math.atan(((eh * math.tan(t)) / -ew)) tmp = 0 if (((ew * math.cos(t)) * math.cos(t_1)) - ((eh * math.sin(t)) * math.sin(t_1))) <= -1e-290: tmp = math.fabs((math.cos(math.atan(((math.tan(t) / ew) * eh))) * ew)) else: tmp = math.cos(t) * ew return tmp
function code(eh, ew, t) t_1 = atan(Float64(Float64(eh * tan(t)) / Float64(-ew))) tmp = 0.0 if (Float64(Float64(Float64(ew * cos(t)) * cos(t_1)) - Float64(Float64(eh * sin(t)) * sin(t_1))) <= -1e-290) tmp = abs(Float64(cos(atan(Float64(Float64(tan(t) / ew) * eh))) * ew)); else tmp = Float64(cos(t) * ew); end return tmp end
function tmp_2 = code(eh, ew, t) t_1 = atan(((eh * tan(t)) / -ew)); tmp = 0.0; if ((((ew * cos(t)) * cos(t_1)) - ((eh * sin(t)) * sin(t_1))) <= -1e-290) tmp = abs((cos(atan(((tan(t) / ew) * eh))) * ew)); else tmp = cos(t) * ew; end tmp_2 = tmp; end
code[eh_, ew_, t_] := Block[{t$95$1 = N[ArcTan[N[(N[(eh * N[Tan[t], $MachinePrecision]), $MachinePrecision] / (-ew)), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[N[(N[(N[(ew * N[Cos[t], $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$1], $MachinePrecision]), $MachinePrecision] - N[(N[(eh * N[Sin[t], $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], -1e-290], N[Abs[N[(N[Cos[N[ArcTan[N[(N[(N[Tan[t], $MachinePrecision] / ew), $MachinePrecision] * eh), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] * ew), $MachinePrecision]], $MachinePrecision], N[(N[Cos[t], $MachinePrecision] * ew), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \tan^{-1} \left(\frac{eh \cdot \tan t}{-ew}\right)\\
\mathbf{if}\;\left(ew \cdot \cos t\right) \cdot \cos t\_1 - \left(eh \cdot \sin t\right) \cdot \sin t\_1 \leq -1 \cdot 10^{-290}:\\
\;\;\;\;\left|\cos \tan^{-1} \left(\frac{\tan t}{ew} \cdot eh\right) \cdot ew\right|\\
\mathbf{else}:\\
\;\;\;\;\cos t \cdot ew\\
\end{array}
\end{array}
if (-.f64 (*.f64 (*.f64 ew (cos.f64 t)) (cos.f64 (atan.f64 (/.f64 (*.f64 (neg.f64 eh) (tan.f64 t)) ew)))) (*.f64 (*.f64 eh (sin.f64 t)) (sin.f64 (atan.f64 (/.f64 (*.f64 (neg.f64 eh) (tan.f64 t)) ew))))) < -1.0000000000000001e-290Initial program 99.9%
Taylor expanded in t around 0
*-commutativeN/A
lower-*.f64N/A
Applied rewrites45.0%
Applied rewrites45.0%
if -1.0000000000000001e-290 < (-.f64 (*.f64 (*.f64 ew (cos.f64 t)) (cos.f64 (atan.f64 (/.f64 (*.f64 (neg.f64 eh) (tan.f64 t)) ew)))) (*.f64 (*.f64 eh (sin.f64 t)) (sin.f64 (atan.f64 (/.f64 (*.f64 (neg.f64 eh) (tan.f64 t)) ew))))) Initial program 99.8%
Applied rewrites78.9%
Taylor expanded in t around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
lower-*.f64N/A
distribute-rgt-outN/A
metadata-evalN/A
lower-*.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6436.3
Applied rewrites36.3%
Taylor expanded in eh around 0
*-commutativeN/A
lower-*.f64N/A
lower-cos.f6461.1
Applied rewrites61.1%
Final simplification53.2%
(FPCore (eh ew t)
:precision binary64
(let* ((t_1 (atan (/ (* eh (tan t)) (- ew)))))
(if (<=
(- (* (* ew (cos t)) (cos t_1)) (* (* eh (sin t)) (sin t_1)))
-1e-290)
(fabs
(*
(cos
(atan
(* (fma (* -0.3333333333333333 (/ eh ew)) (* t t) (/ (- eh) ew)) t)))
ew))
(* (cos t) ew))))
double code(double eh, double ew, double t) {
double t_1 = atan(((eh * tan(t)) / -ew));
double tmp;
if ((((ew * cos(t)) * cos(t_1)) - ((eh * sin(t)) * sin(t_1))) <= -1e-290) {
tmp = fabs((cos(atan((fma((-0.3333333333333333 * (eh / ew)), (t * t), (-eh / ew)) * t))) * ew));
} else {
tmp = cos(t) * ew;
}
return tmp;
}
function code(eh, ew, t) t_1 = atan(Float64(Float64(eh * tan(t)) / Float64(-ew))) tmp = 0.0 if (Float64(Float64(Float64(ew * cos(t)) * cos(t_1)) - Float64(Float64(eh * sin(t)) * sin(t_1))) <= -1e-290) tmp = abs(Float64(cos(atan(Float64(fma(Float64(-0.3333333333333333 * Float64(eh / ew)), Float64(t * t), Float64(Float64(-eh) / ew)) * t))) * ew)); else tmp = Float64(cos(t) * ew); end return tmp end
code[eh_, ew_, t_] := Block[{t$95$1 = N[ArcTan[N[(N[(eh * N[Tan[t], $MachinePrecision]), $MachinePrecision] / (-ew)), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[N[(N[(N[(ew * N[Cos[t], $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$1], $MachinePrecision]), $MachinePrecision] - N[(N[(eh * N[Sin[t], $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], -1e-290], N[Abs[N[(N[Cos[N[ArcTan[N[(N[(N[(-0.3333333333333333 * N[(eh / ew), $MachinePrecision]), $MachinePrecision] * N[(t * t), $MachinePrecision] + N[((-eh) / ew), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] * ew), $MachinePrecision]], $MachinePrecision], N[(N[Cos[t], $MachinePrecision] * ew), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \tan^{-1} \left(\frac{eh \cdot \tan t}{-ew}\right)\\
\mathbf{if}\;\left(ew \cdot \cos t\right) \cdot \cos t\_1 - \left(eh \cdot \sin t\right) \cdot \sin t\_1 \leq -1 \cdot 10^{-290}:\\
\;\;\;\;\left|\cos \tan^{-1} \left(\mathsf{fma}\left(-0.3333333333333333 \cdot \frac{eh}{ew}, t \cdot t, \frac{-eh}{ew}\right) \cdot t\right) \cdot ew\right|\\
\mathbf{else}:\\
\;\;\;\;\cos t \cdot ew\\
\end{array}
\end{array}
if (-.f64 (*.f64 (*.f64 ew (cos.f64 t)) (cos.f64 (atan.f64 (/.f64 (*.f64 (neg.f64 eh) (tan.f64 t)) ew)))) (*.f64 (*.f64 eh (sin.f64 t)) (sin.f64 (atan.f64 (/.f64 (*.f64 (neg.f64 eh) (tan.f64 t)) ew))))) < -1.0000000000000001e-290Initial program 99.9%
Taylor expanded in t around 0
*-commutativeN/A
lower-*.f64N/A
Applied rewrites45.0%
Taylor expanded in t around 0
Applied rewrites42.5%
if -1.0000000000000001e-290 < (-.f64 (*.f64 (*.f64 ew (cos.f64 t)) (cos.f64 (atan.f64 (/.f64 (*.f64 (neg.f64 eh) (tan.f64 t)) ew)))) (*.f64 (*.f64 eh (sin.f64 t)) (sin.f64 (atan.f64 (/.f64 (*.f64 (neg.f64 eh) (tan.f64 t)) ew))))) Initial program 99.8%
Applied rewrites78.9%
Taylor expanded in t around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
lower-*.f64N/A
distribute-rgt-outN/A
metadata-evalN/A
lower-*.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6436.3
Applied rewrites36.3%
Taylor expanded in eh around 0
*-commutativeN/A
lower-*.f64N/A
lower-cos.f6461.1
Applied rewrites61.1%
Final simplification52.0%
(FPCore (eh ew t) :precision binary64 (fabs (- (* (* eh (sin t)) (sin (atan (/ (* (- t) eh) ew)))) (* (* ew (cos t)) (cos (atan (/ (* eh (tan t)) (- ew))))))))
double code(double eh, double ew, double t) {
return fabs((((eh * sin(t)) * sin(atan(((-t * eh) / ew)))) - ((ew * cos(t)) * cos(atan(((eh * tan(t)) / -ew))))));
}
real(8) function code(eh, ew, t)
real(8), intent (in) :: eh
real(8), intent (in) :: ew
real(8), intent (in) :: t
code = abs((((eh * sin(t)) * sin(atan(((-t * eh) / ew)))) - ((ew * cos(t)) * cos(atan(((eh * tan(t)) / -ew))))))
end function
public static double code(double eh, double ew, double t) {
return Math.abs((((eh * Math.sin(t)) * Math.sin(Math.atan(((-t * eh) / ew)))) - ((ew * Math.cos(t)) * Math.cos(Math.atan(((eh * Math.tan(t)) / -ew))))));
}
def code(eh, ew, t): return math.fabs((((eh * math.sin(t)) * math.sin(math.atan(((-t * eh) / ew)))) - ((ew * math.cos(t)) * math.cos(math.atan(((eh * math.tan(t)) / -ew))))))
function code(eh, ew, t) return abs(Float64(Float64(Float64(eh * sin(t)) * sin(atan(Float64(Float64(Float64(-t) * eh) / ew)))) - Float64(Float64(ew * cos(t)) * cos(atan(Float64(Float64(eh * tan(t)) / Float64(-ew))))))) end
function tmp = code(eh, ew, t) tmp = abs((((eh * sin(t)) * sin(atan(((-t * eh) / ew)))) - ((ew * cos(t)) * cos(atan(((eh * tan(t)) / -ew)))))); end
code[eh_, ew_, t_] := N[Abs[N[(N[(N[(eh * N[Sin[t], $MachinePrecision]), $MachinePrecision] * N[Sin[N[ArcTan[N[(N[((-t) * eh), $MachinePrecision] / ew), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - N[(N[(ew * N[Cos[t], $MachinePrecision]), $MachinePrecision] * N[Cos[N[ArcTan[N[(N[(eh * N[Tan[t], $MachinePrecision]), $MachinePrecision] / (-ew)), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\left|\left(eh \cdot \sin t\right) \cdot \sin \tan^{-1} \left(\frac{\left(-t\right) \cdot eh}{ew}\right) - \left(ew \cdot \cos t\right) \cdot \cos \tan^{-1} \left(\frac{eh \cdot \tan t}{-ew}\right)\right|
\end{array}
Initial program 99.9%
Taylor expanded in t around 0
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f6499.7
Applied rewrites99.7%
Final simplification99.7%
(FPCore (eh ew t)
:precision binary64
(if (or (<= eh -7.5e+157) (not (<= eh 1.3e+80)))
(fabs
(-
(* (* eh (sin t)) (sin (atan (/ (* (- t) eh) ew))))
(* (* ew 1.0) (cos (atan (/ (* eh (tan t)) (- ew)))))))
(fabs
(*
(fma
(/ (- (sin t)) ew)
(* eh (tanh (/ (* (- eh) t) ew)))
(* (cos (atan (* (/ (tan t) ew) eh))) (cos t)))
ew))))
double code(double eh, double ew, double t) {
double tmp;
if ((eh <= -7.5e+157) || !(eh <= 1.3e+80)) {
tmp = fabs((((eh * sin(t)) * sin(atan(((-t * eh) / ew)))) - ((ew * 1.0) * cos(atan(((eh * tan(t)) / -ew))))));
} else {
tmp = fabs((fma((-sin(t) / ew), (eh * tanh(((-eh * t) / ew))), (cos(atan(((tan(t) / ew) * eh))) * cos(t))) * ew));
}
return tmp;
}
function code(eh, ew, t) tmp = 0.0 if ((eh <= -7.5e+157) || !(eh <= 1.3e+80)) tmp = abs(Float64(Float64(Float64(eh * sin(t)) * sin(atan(Float64(Float64(Float64(-t) * eh) / ew)))) - Float64(Float64(ew * 1.0) * cos(atan(Float64(Float64(eh * tan(t)) / Float64(-ew))))))); else tmp = abs(Float64(fma(Float64(Float64(-sin(t)) / ew), Float64(eh * tanh(Float64(Float64(Float64(-eh) * t) / ew))), Float64(cos(atan(Float64(Float64(tan(t) / ew) * eh))) * cos(t))) * ew)); end return tmp end
code[eh_, ew_, t_] := If[Or[LessEqual[eh, -7.5e+157], N[Not[LessEqual[eh, 1.3e+80]], $MachinePrecision]], N[Abs[N[(N[(N[(eh * N[Sin[t], $MachinePrecision]), $MachinePrecision] * N[Sin[N[ArcTan[N[(N[((-t) * eh), $MachinePrecision] / ew), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - N[(N[(ew * 1.0), $MachinePrecision] * N[Cos[N[ArcTan[N[(N[(eh * N[Tan[t], $MachinePrecision]), $MachinePrecision] / (-ew)), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Abs[N[(N[(N[((-N[Sin[t], $MachinePrecision]) / ew), $MachinePrecision] * N[(eh * N[Tanh[N[(N[((-eh) * t), $MachinePrecision] / ew), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] + N[(N[Cos[N[ArcTan[N[(N[(N[Tan[t], $MachinePrecision] / ew), $MachinePrecision] * eh), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] * N[Cos[t], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * ew), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;eh \leq -7.5 \cdot 10^{+157} \lor \neg \left(eh \leq 1.3 \cdot 10^{+80}\right):\\
\;\;\;\;\left|\left(eh \cdot \sin t\right) \cdot \sin \tan^{-1} \left(\frac{\left(-t\right) \cdot eh}{ew}\right) - \left(ew \cdot 1\right) \cdot \cos \tan^{-1} \left(\frac{eh \cdot \tan t}{-ew}\right)\right|\\
\mathbf{else}:\\
\;\;\;\;\left|\mathsf{fma}\left(\frac{-\sin t}{ew}, eh \cdot \tanh \left(\frac{\left(-eh\right) \cdot t}{ew}\right), \cos \tan^{-1} \left(\frac{\tan t}{ew} \cdot eh\right) \cdot \cos t\right) \cdot ew\right|\\
\end{array}
\end{array}
if eh < -7.5e157 or 1.29999999999999991e80 < eh Initial program 99.8%
Taylor expanded in t around 0
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f6499.6
Applied rewrites99.6%
Taylor expanded in t around 0
Applied rewrites97.8%
if -7.5e157 < eh < 1.29999999999999991e80Initial program 99.9%
Taylor expanded in ew around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites96.7%
Applied rewrites98.8%
Applied rewrites98.8%
Taylor expanded in t around 0
Applied rewrites98.6%
Final simplification98.4%
(FPCore (eh ew t)
:precision binary64
(let* ((t_1 (* (cos t) ew))
(t_2 (fabs (* t_1 (cos (atan (/ (* (- eh) (sin t)) t_1))))))
(t_3 (- (sin t))))
(if (<= ew -2.8e-74)
t_2
(if (<= ew 1.85e-244)
(fabs (* (* (tanh (asinh (* (/ (tan t) ew) (- eh)))) t_3) eh))
(if (<= ew 1.7e+61)
(fma
(* t_3 eh)
(tanh (asinh (/ (* (- t) eh) ew)))
(* t_1 (cos (atan (/ (* eh t) ew)))))
t_2)))))
double code(double eh, double ew, double t) {
double t_1 = cos(t) * ew;
double t_2 = fabs((t_1 * cos(atan(((-eh * sin(t)) / t_1)))));
double t_3 = -sin(t);
double tmp;
if (ew <= -2.8e-74) {
tmp = t_2;
} else if (ew <= 1.85e-244) {
tmp = fabs(((tanh(asinh(((tan(t) / ew) * -eh))) * t_3) * eh));
} else if (ew <= 1.7e+61) {
tmp = fma((t_3 * eh), tanh(asinh(((-t * eh) / ew))), (t_1 * cos(atan(((eh * t) / ew)))));
} else {
tmp = t_2;
}
return tmp;
}
function code(eh, ew, t) t_1 = Float64(cos(t) * ew) t_2 = abs(Float64(t_1 * cos(atan(Float64(Float64(Float64(-eh) * sin(t)) / t_1))))) t_3 = Float64(-sin(t)) tmp = 0.0 if (ew <= -2.8e-74) tmp = t_2; elseif (ew <= 1.85e-244) tmp = abs(Float64(Float64(tanh(asinh(Float64(Float64(tan(t) / ew) * Float64(-eh)))) * t_3) * eh)); elseif (ew <= 1.7e+61) tmp = fma(Float64(t_3 * eh), tanh(asinh(Float64(Float64(Float64(-t) * eh) / ew))), Float64(t_1 * cos(atan(Float64(Float64(eh * t) / ew))))); else tmp = t_2; end return tmp end
code[eh_, ew_, t_] := Block[{t$95$1 = N[(N[Cos[t], $MachinePrecision] * ew), $MachinePrecision]}, Block[{t$95$2 = N[Abs[N[(t$95$1 * N[Cos[N[ArcTan[N[(N[((-eh) * N[Sin[t], $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$3 = (-N[Sin[t], $MachinePrecision])}, If[LessEqual[ew, -2.8e-74], t$95$2, If[LessEqual[ew, 1.85e-244], N[Abs[N[(N[(N[Tanh[N[ArcSinh[N[(N[(N[Tan[t], $MachinePrecision] / ew), $MachinePrecision] * (-eh)), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] * t$95$3), $MachinePrecision] * eh), $MachinePrecision]], $MachinePrecision], If[LessEqual[ew, 1.7e+61], N[(N[(t$95$3 * eh), $MachinePrecision] * N[Tanh[N[ArcSinh[N[(N[((-t) * eh), $MachinePrecision] / ew), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] + N[(t$95$1 * N[Cos[N[ArcTan[N[(N[(eh * t), $MachinePrecision] / ew), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \cos t \cdot ew\\
t_2 := \left|t\_1 \cdot \cos \tan^{-1} \left(\frac{\left(-eh\right) \cdot \sin t}{t\_1}\right)\right|\\
t_3 := -\sin t\\
\mathbf{if}\;ew \leq -2.8 \cdot 10^{-74}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;ew \leq 1.85 \cdot 10^{-244}:\\
\;\;\;\;\left|\left(\tanh \sinh^{-1} \left(\frac{\tan t}{ew} \cdot \left(-eh\right)\right) \cdot t\_3\right) \cdot eh\right|\\
\mathbf{elif}\;ew \leq 1.7 \cdot 10^{+61}:\\
\;\;\;\;\mathsf{fma}\left(t\_3 \cdot eh, \tanh \sinh^{-1} \left(\frac{\left(-t\right) \cdot eh}{ew}\right), t\_1 \cdot \cos \tan^{-1} \left(\frac{eh \cdot t}{ew}\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if ew < -2.79999999999999988e-74 or 1.70000000000000013e61 < ew Initial program 99.9%
Taylor expanded in ew around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites99.9%
Applied rewrites99.9%
Taylor expanded in eh around 0
associate-*r*N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-cos.f64N/A
lower-cos.f64N/A
lower-atan.f64N/A
associate-*r/N/A
lower-/.f64N/A
associate-*r*N/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-sin.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-cos.f6484.1
Applied rewrites84.1%
if -2.79999999999999988e-74 < ew < 1.8500000000000001e-244Initial program 99.7%
Taylor expanded in eh around inf
mul-1-negN/A
associate-*r*N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-sin.f64N/A
lower-sin.f64N/A
lower-atan.f64N/A
mul-1-negN/A
*-commutativeN/A
times-fracN/A
distribute-lft-neg-inN/A
Applied rewrites80.5%
Applied rewrites80.5%
if 1.8500000000000001e-244 < ew < 1.70000000000000013e61Initial program 99.9%
Taylor expanded in t around 0
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f6499.7
Applied rewrites99.7%
Applied rewrites81.9%
Taylor expanded in t around 0
lower-/.f64N/A
lower-*.f6480.7
Applied rewrites80.7%
Final simplification82.5%
(FPCore (eh ew t)
:precision binary64
(let* ((t_1 (* (cos t) ew)))
(if (or (<= ew -1.2e+108) (not (<= ew 5.3e+79)))
(fabs (* t_1 (cos (atan (/ (* (- eh) (sin t)) t_1)))))
(fabs
(-
(* (* eh (sin t)) (sin (atan (/ (* (- t) eh) ew))))
(* (* ew 1.0) (cos (atan (/ (* eh (tan t)) (- ew))))))))))
double code(double eh, double ew, double t) {
double t_1 = cos(t) * ew;
double tmp;
if ((ew <= -1.2e+108) || !(ew <= 5.3e+79)) {
tmp = fabs((t_1 * cos(atan(((-eh * sin(t)) / t_1)))));
} else {
tmp = fabs((((eh * sin(t)) * sin(atan(((-t * eh) / ew)))) - ((ew * 1.0) * cos(atan(((eh * tan(t)) / -ew))))));
}
return tmp;
}
real(8) function code(eh, ew, t)
real(8), intent (in) :: eh
real(8), intent (in) :: ew
real(8), intent (in) :: t
real(8) :: t_1
real(8) :: tmp
t_1 = cos(t) * ew
if ((ew <= (-1.2d+108)) .or. (.not. (ew <= 5.3d+79))) then
tmp = abs((t_1 * cos(atan(((-eh * sin(t)) / t_1)))))
else
tmp = abs((((eh * sin(t)) * sin(atan(((-t * eh) / ew)))) - ((ew * 1.0d0) * cos(atan(((eh * tan(t)) / -ew))))))
end if
code = tmp
end function
public static double code(double eh, double ew, double t) {
double t_1 = Math.cos(t) * ew;
double tmp;
if ((ew <= -1.2e+108) || !(ew <= 5.3e+79)) {
tmp = Math.abs((t_1 * Math.cos(Math.atan(((-eh * Math.sin(t)) / t_1)))));
} else {
tmp = Math.abs((((eh * Math.sin(t)) * Math.sin(Math.atan(((-t * eh) / ew)))) - ((ew * 1.0) * Math.cos(Math.atan(((eh * Math.tan(t)) / -ew))))));
}
return tmp;
}
def code(eh, ew, t): t_1 = math.cos(t) * ew tmp = 0 if (ew <= -1.2e+108) or not (ew <= 5.3e+79): tmp = math.fabs((t_1 * math.cos(math.atan(((-eh * math.sin(t)) / t_1))))) else: tmp = math.fabs((((eh * math.sin(t)) * math.sin(math.atan(((-t * eh) / ew)))) - ((ew * 1.0) * math.cos(math.atan(((eh * math.tan(t)) / -ew)))))) return tmp
function code(eh, ew, t) t_1 = Float64(cos(t) * ew) tmp = 0.0 if ((ew <= -1.2e+108) || !(ew <= 5.3e+79)) tmp = abs(Float64(t_1 * cos(atan(Float64(Float64(Float64(-eh) * sin(t)) / t_1))))); else tmp = abs(Float64(Float64(Float64(eh * sin(t)) * sin(atan(Float64(Float64(Float64(-t) * eh) / ew)))) - Float64(Float64(ew * 1.0) * cos(atan(Float64(Float64(eh * tan(t)) / Float64(-ew))))))); end return tmp end
function tmp_2 = code(eh, ew, t) t_1 = cos(t) * ew; tmp = 0.0; if ((ew <= -1.2e+108) || ~((ew <= 5.3e+79))) tmp = abs((t_1 * cos(atan(((-eh * sin(t)) / t_1))))); else tmp = abs((((eh * sin(t)) * sin(atan(((-t * eh) / ew)))) - ((ew * 1.0) * cos(atan(((eh * tan(t)) / -ew)))))); end tmp_2 = tmp; end
code[eh_, ew_, t_] := Block[{t$95$1 = N[(N[Cos[t], $MachinePrecision] * ew), $MachinePrecision]}, If[Or[LessEqual[ew, -1.2e+108], N[Not[LessEqual[ew, 5.3e+79]], $MachinePrecision]], N[Abs[N[(t$95$1 * N[Cos[N[ArcTan[N[(N[((-eh) * N[Sin[t], $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Abs[N[(N[(N[(eh * N[Sin[t], $MachinePrecision]), $MachinePrecision] * N[Sin[N[ArcTan[N[(N[((-t) * eh), $MachinePrecision] / ew), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - N[(N[(ew * 1.0), $MachinePrecision] * N[Cos[N[ArcTan[N[(N[(eh * N[Tan[t], $MachinePrecision]), $MachinePrecision] / (-ew)), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \cos t \cdot ew\\
\mathbf{if}\;ew \leq -1.2 \cdot 10^{+108} \lor \neg \left(ew \leq 5.3 \cdot 10^{+79}\right):\\
\;\;\;\;\left|t\_1 \cdot \cos \tan^{-1} \left(\frac{\left(-eh\right) \cdot \sin t}{t\_1}\right)\right|\\
\mathbf{else}:\\
\;\;\;\;\left|\left(eh \cdot \sin t\right) \cdot \sin \tan^{-1} \left(\frac{\left(-t\right) \cdot eh}{ew}\right) - \left(ew \cdot 1\right) \cdot \cos \tan^{-1} \left(\frac{eh \cdot \tan t}{-ew}\right)\right|\\
\end{array}
\end{array}
if ew < -1.20000000000000009e108 or 5.29999999999999978e79 < ew Initial program 99.9%
Taylor expanded in ew around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites99.9%
Applied rewrites99.9%
Taylor expanded in eh around 0
associate-*r*N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-cos.f64N/A
lower-cos.f64N/A
lower-atan.f64N/A
associate-*r/N/A
lower-/.f64N/A
associate-*r*N/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-sin.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-cos.f6495.1
Applied rewrites95.1%
if -1.20000000000000009e108 < ew < 5.29999999999999978e79Initial program 99.8%
Taylor expanded in t around 0
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f6499.7
Applied rewrites99.7%
Taylor expanded in t around 0
Applied rewrites90.9%
Final simplification92.4%
(FPCore (eh ew t)
:precision binary64
(let* ((t_1 (* (cos t) ew))
(t_2 (fabs (* t_1 (cos (atan (/ (* (- eh) (sin t)) t_1))))))
(t_3 (- (sin t))))
(if (<= ew -2.8e-74)
t_2
(if (<= ew 1.85e-244)
(fabs (* (* (tanh (asinh (* (/ (tan t) ew) (- eh)))) t_3) eh))
(if (<= ew 5.3e+79)
(fma
(* t_3 eh)
(tanh (asinh (/ (* (- t) eh) ew)))
(* (* 1.0 ew) (cos (atan (/ (* eh t) ew)))))
t_2)))))
double code(double eh, double ew, double t) {
double t_1 = cos(t) * ew;
double t_2 = fabs((t_1 * cos(atan(((-eh * sin(t)) / t_1)))));
double t_3 = -sin(t);
double tmp;
if (ew <= -2.8e-74) {
tmp = t_2;
} else if (ew <= 1.85e-244) {
tmp = fabs(((tanh(asinh(((tan(t) / ew) * -eh))) * t_3) * eh));
} else if (ew <= 5.3e+79) {
tmp = fma((t_3 * eh), tanh(asinh(((-t * eh) / ew))), ((1.0 * ew) * cos(atan(((eh * t) / ew)))));
} else {
tmp = t_2;
}
return tmp;
}
function code(eh, ew, t) t_1 = Float64(cos(t) * ew) t_2 = abs(Float64(t_1 * cos(atan(Float64(Float64(Float64(-eh) * sin(t)) / t_1))))) t_3 = Float64(-sin(t)) tmp = 0.0 if (ew <= -2.8e-74) tmp = t_2; elseif (ew <= 1.85e-244) tmp = abs(Float64(Float64(tanh(asinh(Float64(Float64(tan(t) / ew) * Float64(-eh)))) * t_3) * eh)); elseif (ew <= 5.3e+79) tmp = fma(Float64(t_3 * eh), tanh(asinh(Float64(Float64(Float64(-t) * eh) / ew))), Float64(Float64(1.0 * ew) * cos(atan(Float64(Float64(eh * t) / ew))))); else tmp = t_2; end return tmp end
code[eh_, ew_, t_] := Block[{t$95$1 = N[(N[Cos[t], $MachinePrecision] * ew), $MachinePrecision]}, Block[{t$95$2 = N[Abs[N[(t$95$1 * N[Cos[N[ArcTan[N[(N[((-eh) * N[Sin[t], $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$3 = (-N[Sin[t], $MachinePrecision])}, If[LessEqual[ew, -2.8e-74], t$95$2, If[LessEqual[ew, 1.85e-244], N[Abs[N[(N[(N[Tanh[N[ArcSinh[N[(N[(N[Tan[t], $MachinePrecision] / ew), $MachinePrecision] * (-eh)), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] * t$95$3), $MachinePrecision] * eh), $MachinePrecision]], $MachinePrecision], If[LessEqual[ew, 5.3e+79], N[(N[(t$95$3 * eh), $MachinePrecision] * N[Tanh[N[ArcSinh[N[(N[((-t) * eh), $MachinePrecision] / ew), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] + N[(N[(1.0 * ew), $MachinePrecision] * N[Cos[N[ArcTan[N[(N[(eh * t), $MachinePrecision] / ew), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \cos t \cdot ew\\
t_2 := \left|t\_1 \cdot \cos \tan^{-1} \left(\frac{\left(-eh\right) \cdot \sin t}{t\_1}\right)\right|\\
t_3 := -\sin t\\
\mathbf{if}\;ew \leq -2.8 \cdot 10^{-74}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;ew \leq 1.85 \cdot 10^{-244}:\\
\;\;\;\;\left|\left(\tanh \sinh^{-1} \left(\frac{\tan t}{ew} \cdot \left(-eh\right)\right) \cdot t\_3\right) \cdot eh\right|\\
\mathbf{elif}\;ew \leq 5.3 \cdot 10^{+79}:\\
\;\;\;\;\mathsf{fma}\left(t\_3 \cdot eh, \tanh \sinh^{-1} \left(\frac{\left(-t\right) \cdot eh}{ew}\right), \left(1 \cdot ew\right) \cdot \cos \tan^{-1} \left(\frac{eh \cdot t}{ew}\right)\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if ew < -2.79999999999999988e-74 or 5.29999999999999978e79 < ew Initial program 99.9%
Taylor expanded in ew around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites99.9%
Applied rewrites99.9%
Taylor expanded in eh around 0
associate-*r*N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-cos.f64N/A
lower-cos.f64N/A
lower-atan.f64N/A
associate-*r/N/A
lower-/.f64N/A
associate-*r*N/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-sin.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-cos.f6485.1
Applied rewrites85.1%
if -2.79999999999999988e-74 < ew < 1.8500000000000001e-244Initial program 99.7%
Taylor expanded in eh around inf
mul-1-negN/A
associate-*r*N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-sin.f64N/A
lower-sin.f64N/A
lower-atan.f64N/A
mul-1-negN/A
*-commutativeN/A
times-fracN/A
distribute-lft-neg-inN/A
Applied rewrites80.5%
Applied rewrites80.5%
if 1.8500000000000001e-244 < ew < 5.29999999999999978e79Initial program 99.9%
Taylor expanded in t around 0
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f6499.8
Applied rewrites99.8%
Applied rewrites79.8%
Taylor expanded in t around 0
lower-/.f64N/A
lower-*.f6478.7
Applied rewrites78.7%
Taylor expanded in t around 0
Applied rewrites78.3%
Final simplification82.4%
(FPCore (eh ew t)
:precision binary64
(let* ((t_1 (* (cos t) ew)) (t_2 (- (sin t))))
(if (or (<= eh -5.2e+85) (not (<= eh 2.35e+79)))
(fabs (* (* t_2 eh) (sin (atan (* (/ t_2 ew) (/ eh (cos t)))))))
(fabs (* t_1 (cos (atan (/ (* (- eh) (sin t)) t_1))))))))
double code(double eh, double ew, double t) {
double t_1 = cos(t) * ew;
double t_2 = -sin(t);
double tmp;
if ((eh <= -5.2e+85) || !(eh <= 2.35e+79)) {
tmp = fabs(((t_2 * eh) * sin(atan(((t_2 / ew) * (eh / cos(t)))))));
} else {
tmp = fabs((t_1 * cos(atan(((-eh * sin(t)) / t_1)))));
}
return tmp;
}
real(8) function code(eh, ew, t)
real(8), intent (in) :: eh
real(8), intent (in) :: ew
real(8), intent (in) :: t
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = cos(t) * ew
t_2 = -sin(t)
if ((eh <= (-5.2d+85)) .or. (.not. (eh <= 2.35d+79))) then
tmp = abs(((t_2 * eh) * sin(atan(((t_2 / ew) * (eh / cos(t)))))))
else
tmp = abs((t_1 * cos(atan(((-eh * sin(t)) / t_1)))))
end if
code = tmp
end function
public static double code(double eh, double ew, double t) {
double t_1 = Math.cos(t) * ew;
double t_2 = -Math.sin(t);
double tmp;
if ((eh <= -5.2e+85) || !(eh <= 2.35e+79)) {
tmp = Math.abs(((t_2 * eh) * Math.sin(Math.atan(((t_2 / ew) * (eh / Math.cos(t)))))));
} else {
tmp = Math.abs((t_1 * Math.cos(Math.atan(((-eh * Math.sin(t)) / t_1)))));
}
return tmp;
}
def code(eh, ew, t): t_1 = math.cos(t) * ew t_2 = -math.sin(t) tmp = 0 if (eh <= -5.2e+85) or not (eh <= 2.35e+79): tmp = math.fabs(((t_2 * eh) * math.sin(math.atan(((t_2 / ew) * (eh / math.cos(t))))))) else: tmp = math.fabs((t_1 * math.cos(math.atan(((-eh * math.sin(t)) / t_1))))) return tmp
function code(eh, ew, t) t_1 = Float64(cos(t) * ew) t_2 = Float64(-sin(t)) tmp = 0.0 if ((eh <= -5.2e+85) || !(eh <= 2.35e+79)) tmp = abs(Float64(Float64(t_2 * eh) * sin(atan(Float64(Float64(t_2 / ew) * Float64(eh / cos(t))))))); else tmp = abs(Float64(t_1 * cos(atan(Float64(Float64(Float64(-eh) * sin(t)) / t_1))))); end return tmp end
function tmp_2 = code(eh, ew, t) t_1 = cos(t) * ew; t_2 = -sin(t); tmp = 0.0; if ((eh <= -5.2e+85) || ~((eh <= 2.35e+79))) tmp = abs(((t_2 * eh) * sin(atan(((t_2 / ew) * (eh / cos(t))))))); else tmp = abs((t_1 * cos(atan(((-eh * sin(t)) / t_1))))); end tmp_2 = tmp; end
code[eh_, ew_, t_] := Block[{t$95$1 = N[(N[Cos[t], $MachinePrecision] * ew), $MachinePrecision]}, Block[{t$95$2 = (-N[Sin[t], $MachinePrecision])}, If[Or[LessEqual[eh, -5.2e+85], N[Not[LessEqual[eh, 2.35e+79]], $MachinePrecision]], N[Abs[N[(N[(t$95$2 * eh), $MachinePrecision] * N[Sin[N[ArcTan[N[(N[(t$95$2 / ew), $MachinePrecision] * N[(eh / N[Cos[t], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Abs[N[(t$95$1 * N[Cos[N[ArcTan[N[(N[((-eh) * N[Sin[t], $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \cos t \cdot ew\\
t_2 := -\sin t\\
\mathbf{if}\;eh \leq -5.2 \cdot 10^{+85} \lor \neg \left(eh \leq 2.35 \cdot 10^{+79}\right):\\
\;\;\;\;\left|\left(t\_2 \cdot eh\right) \cdot \sin \tan^{-1} \left(\frac{t\_2}{ew} \cdot \frac{eh}{\cos t}\right)\right|\\
\mathbf{else}:\\
\;\;\;\;\left|t\_1 \cdot \cos \tan^{-1} \left(\frac{\left(-eh\right) \cdot \sin t}{t\_1}\right)\right|\\
\end{array}
\end{array}
if eh < -5.20000000000000021e85 or 2.35000000000000011e79 < eh Initial program 99.9%
Taylor expanded in eh around inf
mul-1-negN/A
associate-*r*N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-sin.f64N/A
lower-sin.f64N/A
lower-atan.f64N/A
mul-1-negN/A
*-commutativeN/A
times-fracN/A
distribute-lft-neg-inN/A
Applied rewrites75.0%
if -5.20000000000000021e85 < eh < 2.35000000000000011e79Initial program 99.9%
Taylor expanded in ew around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites99.3%
Applied rewrites99.3%
Taylor expanded in eh around 0
associate-*r*N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-cos.f64N/A
lower-cos.f64N/A
lower-atan.f64N/A
associate-*r/N/A
lower-/.f64N/A
associate-*r*N/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-sin.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-cos.f6481.7
Applied rewrites81.7%
Final simplification79.4%
(FPCore (eh ew t)
:precision binary64
(let* ((t_1 (* (cos t) ew)))
(if (or (<= eh -5.2e+85) (not (<= eh 2.35e+79)))
(fabs (* (* (tanh (asinh (* (/ (tan t) ew) (- eh)))) (- (sin t))) eh))
(fabs (* t_1 (cos (atan (/ (* (- eh) (sin t)) t_1))))))))
double code(double eh, double ew, double t) {
double t_1 = cos(t) * ew;
double tmp;
if ((eh <= -5.2e+85) || !(eh <= 2.35e+79)) {
tmp = fabs(((tanh(asinh(((tan(t) / ew) * -eh))) * -sin(t)) * eh));
} else {
tmp = fabs((t_1 * cos(atan(((-eh * sin(t)) / t_1)))));
}
return tmp;
}
def code(eh, ew, t): t_1 = math.cos(t) * ew tmp = 0 if (eh <= -5.2e+85) or not (eh <= 2.35e+79): tmp = math.fabs(((math.tanh(math.asinh(((math.tan(t) / ew) * -eh))) * -math.sin(t)) * eh)) else: tmp = math.fabs((t_1 * math.cos(math.atan(((-eh * math.sin(t)) / t_1))))) return tmp
function code(eh, ew, t) t_1 = Float64(cos(t) * ew) tmp = 0.0 if ((eh <= -5.2e+85) || !(eh <= 2.35e+79)) tmp = abs(Float64(Float64(tanh(asinh(Float64(Float64(tan(t) / ew) * Float64(-eh)))) * Float64(-sin(t))) * eh)); else tmp = abs(Float64(t_1 * cos(atan(Float64(Float64(Float64(-eh) * sin(t)) / t_1))))); end return tmp end
function tmp_2 = code(eh, ew, t) t_1 = cos(t) * ew; tmp = 0.0; if ((eh <= -5.2e+85) || ~((eh <= 2.35e+79))) tmp = abs(((tanh(asinh(((tan(t) / ew) * -eh))) * -sin(t)) * eh)); else tmp = abs((t_1 * cos(atan(((-eh * sin(t)) / t_1))))); end tmp_2 = tmp; end
code[eh_, ew_, t_] := Block[{t$95$1 = N[(N[Cos[t], $MachinePrecision] * ew), $MachinePrecision]}, If[Or[LessEqual[eh, -5.2e+85], N[Not[LessEqual[eh, 2.35e+79]], $MachinePrecision]], N[Abs[N[(N[(N[Tanh[N[ArcSinh[N[(N[(N[Tan[t], $MachinePrecision] / ew), $MachinePrecision] * (-eh)), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] * (-N[Sin[t], $MachinePrecision])), $MachinePrecision] * eh), $MachinePrecision]], $MachinePrecision], N[Abs[N[(t$95$1 * N[Cos[N[ArcTan[N[(N[((-eh) * N[Sin[t], $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \cos t \cdot ew\\
\mathbf{if}\;eh \leq -5.2 \cdot 10^{+85} \lor \neg \left(eh \leq 2.35 \cdot 10^{+79}\right):\\
\;\;\;\;\left|\left(\tanh \sinh^{-1} \left(\frac{\tan t}{ew} \cdot \left(-eh\right)\right) \cdot \left(-\sin t\right)\right) \cdot eh\right|\\
\mathbf{else}:\\
\;\;\;\;\left|t\_1 \cdot \cos \tan^{-1} \left(\frac{\left(-eh\right) \cdot \sin t}{t\_1}\right)\right|\\
\end{array}
\end{array}
if eh < -5.20000000000000021e85 or 2.35000000000000011e79 < eh Initial program 99.9%
Taylor expanded in eh around inf
mul-1-negN/A
associate-*r*N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-sin.f64N/A
lower-sin.f64N/A
lower-atan.f64N/A
mul-1-negN/A
*-commutativeN/A
times-fracN/A
distribute-lft-neg-inN/A
Applied rewrites75.0%
Applied rewrites75.0%
if -5.20000000000000021e85 < eh < 2.35000000000000011e79Initial program 99.9%
Taylor expanded in ew around inf
*-commutativeN/A
lower-*.f64N/A
Applied rewrites99.3%
Applied rewrites99.3%
Taylor expanded in eh around 0
associate-*r*N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-cos.f64N/A
lower-cos.f64N/A
lower-atan.f64N/A
associate-*r/N/A
lower-/.f64N/A
associate-*r*N/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-sin.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-cos.f6481.7
Applied rewrites81.7%
Final simplification79.4%
(FPCore (eh ew t)
:precision binary64
(if (<= ew -1.5e-39)
(fabs
(* (cos (atan (* (/ (sin t) ew) (/ (- eh) (fma (* t t) -0.5 1.0))))) ew))
(if (<= ew 1e+80)
(fabs (* (* (tanh (asinh (* (/ (tan t) ew) (- eh)))) (- (sin t))) eh))
(* (cos t) ew))))
double code(double eh, double ew, double t) {
double tmp;
if (ew <= -1.5e-39) {
tmp = fabs((cos(atan(((sin(t) / ew) * (-eh / fma((t * t), -0.5, 1.0))))) * ew));
} else if (ew <= 1e+80) {
tmp = fabs(((tanh(asinh(((tan(t) / ew) * -eh))) * -sin(t)) * eh));
} else {
tmp = cos(t) * ew;
}
return tmp;
}
function code(eh, ew, t) tmp = 0.0 if (ew <= -1.5e-39) tmp = abs(Float64(cos(atan(Float64(Float64(sin(t) / ew) * Float64(Float64(-eh) / fma(Float64(t * t), -0.5, 1.0))))) * ew)); elseif (ew <= 1e+80) tmp = abs(Float64(Float64(tanh(asinh(Float64(Float64(tan(t) / ew) * Float64(-eh)))) * Float64(-sin(t))) * eh)); else tmp = Float64(cos(t) * ew); end return tmp end
code[eh_, ew_, t_] := If[LessEqual[ew, -1.5e-39], N[Abs[N[(N[Cos[N[ArcTan[N[(N[(N[Sin[t], $MachinePrecision] / ew), $MachinePrecision] * N[((-eh) / N[(N[(t * t), $MachinePrecision] * -0.5 + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] * ew), $MachinePrecision]], $MachinePrecision], If[LessEqual[ew, 1e+80], N[Abs[N[(N[(N[Tanh[N[ArcSinh[N[(N[(N[Tan[t], $MachinePrecision] / ew), $MachinePrecision] * (-eh)), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] * (-N[Sin[t], $MachinePrecision])), $MachinePrecision] * eh), $MachinePrecision]], $MachinePrecision], N[(N[Cos[t], $MachinePrecision] * ew), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;ew \leq -1.5 \cdot 10^{-39}:\\
\;\;\;\;\left|\cos \tan^{-1} \left(\frac{\sin t}{ew} \cdot \frac{-eh}{\mathsf{fma}\left(t \cdot t, -0.5, 1\right)}\right) \cdot ew\right|\\
\mathbf{elif}\;ew \leq 10^{+80}:\\
\;\;\;\;\left|\left(\tanh \sinh^{-1} \left(\frac{\tan t}{ew} \cdot \left(-eh\right)\right) \cdot \left(-\sin t\right)\right) \cdot eh\right|\\
\mathbf{else}:\\
\;\;\;\;\cos t \cdot ew\\
\end{array}
\end{array}
if ew < -1.50000000000000014e-39Initial program 99.9%
Taylor expanded in t around 0
*-commutativeN/A
lower-*.f64N/A
Applied rewrites57.5%
Taylor expanded in t around 0
Applied rewrites57.5%
if -1.50000000000000014e-39 < ew < 1e80Initial program 99.8%
Taylor expanded in eh around inf
mul-1-negN/A
associate-*r*N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-sin.f64N/A
lower-sin.f64N/A
lower-atan.f64N/A
mul-1-negN/A
*-commutativeN/A
times-fracN/A
distribute-lft-neg-inN/A
Applied rewrites64.9%
Applied rewrites64.9%
if 1e80 < ew Initial program 99.9%
Applied rewrites77.0%
Taylor expanded in t around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
lower-*.f64N/A
distribute-rgt-outN/A
metadata-evalN/A
lower-*.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6443.7
Applied rewrites43.7%
Taylor expanded in eh around 0
*-commutativeN/A
lower-*.f64N/A
lower-cos.f6475.3
Applied rewrites75.3%
Final simplification65.1%
(FPCore (eh ew t)
:precision binary64
(let* ((t_1 (/ (PI) 2.0)))
(if (or (<= t -0.0285) (not (<= t 6e-21)))
(fabs
(*
(* (- (sin t)) eh)
(sin
(atan
(*
(fma (* -0.3333333333333333 (/ eh ew)) (* t t) (/ (- eh) ew))
t)))))
(fabs
(*
(cos
(atan
(* (/ (sin (- (+ t_1 t) t_1)) ew) (- (fma (* (* t t) eh) 0.5 eh)))))
ew)))))\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\mathsf{PI}\left(\right)}{2}\\
\mathbf{if}\;t \leq -0.0285 \lor \neg \left(t \leq 6 \cdot 10^{-21}\right):\\
\;\;\;\;\left|\left(\left(-\sin t\right) \cdot eh\right) \cdot \sin \tan^{-1} \left(\mathsf{fma}\left(-0.3333333333333333 \cdot \frac{eh}{ew}, t \cdot t, \frac{-eh}{ew}\right) \cdot t\right)\right|\\
\mathbf{else}:\\
\;\;\;\;\left|\cos \tan^{-1} \left(\frac{\sin \left(\left(t\_1 + t\right) - t\_1\right)}{ew} \cdot \left(-\mathsf{fma}\left(\left(t \cdot t\right) \cdot eh, 0.5, eh\right)\right)\right) \cdot ew\right|\\
\end{array}
\end{array}
if t < -0.028500000000000001 or 5.99999999999999982e-21 < t Initial program 99.7%
Taylor expanded in eh around inf
mul-1-negN/A
associate-*r*N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-sin.f64N/A
lower-sin.f64N/A
lower-atan.f64N/A
mul-1-negN/A
*-commutativeN/A
times-fracN/A
distribute-lft-neg-inN/A
Applied rewrites52.8%
Taylor expanded in t around 0
Applied rewrites53.0%
if -0.028500000000000001 < t < 5.99999999999999982e-21Initial program 100.0%
Taylor expanded in t around 0
*-commutativeN/A
lower-*.f64N/A
Applied rewrites71.4%
Taylor expanded in t around 0
Applied rewrites71.4%
Applied rewrites54.6%
Applied rewrites71.6%
Final simplification63.4%
(FPCore (eh ew t)
:precision binary64
(if (or (<= t -0.0285) (not (<= t 6e-21)))
(fabs
(*
(* (- (sin t)) eh)
(sin
(atan
(* (fma (* -0.3333333333333333 (/ eh ew)) (* t t) (/ (- eh) ew)) t)))))
(fabs (* (cos (atan (* (/ (tan t) ew) eh))) ew))))
double code(double eh, double ew, double t) {
double tmp;
if ((t <= -0.0285) || !(t <= 6e-21)) {
tmp = fabs(((-sin(t) * eh) * sin(atan((fma((-0.3333333333333333 * (eh / ew)), (t * t), (-eh / ew)) * t)))));
} else {
tmp = fabs((cos(atan(((tan(t) / ew) * eh))) * ew));
}
return tmp;
}
function code(eh, ew, t) tmp = 0.0 if ((t <= -0.0285) || !(t <= 6e-21)) tmp = abs(Float64(Float64(Float64(-sin(t)) * eh) * sin(atan(Float64(fma(Float64(-0.3333333333333333 * Float64(eh / ew)), Float64(t * t), Float64(Float64(-eh) / ew)) * t))))); else tmp = abs(Float64(cos(atan(Float64(Float64(tan(t) / ew) * eh))) * ew)); end return tmp end
code[eh_, ew_, t_] := If[Or[LessEqual[t, -0.0285], N[Not[LessEqual[t, 6e-21]], $MachinePrecision]], N[Abs[N[(N[((-N[Sin[t], $MachinePrecision]) * eh), $MachinePrecision] * N[Sin[N[ArcTan[N[(N[(N[(-0.3333333333333333 * N[(eh / ew), $MachinePrecision]), $MachinePrecision] * N[(t * t), $MachinePrecision] + N[((-eh) / ew), $MachinePrecision]), $MachinePrecision] * t), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[Abs[N[(N[Cos[N[ArcTan[N[(N[(N[Tan[t], $MachinePrecision] / ew), $MachinePrecision] * eh), $MachinePrecision]], $MachinePrecision]], $MachinePrecision] * ew), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -0.0285 \lor \neg \left(t \leq 6 \cdot 10^{-21}\right):\\
\;\;\;\;\left|\left(\left(-\sin t\right) \cdot eh\right) \cdot \sin \tan^{-1} \left(\mathsf{fma}\left(-0.3333333333333333 \cdot \frac{eh}{ew}, t \cdot t, \frac{-eh}{ew}\right) \cdot t\right)\right|\\
\mathbf{else}:\\
\;\;\;\;\left|\cos \tan^{-1} \left(\frac{\tan t}{ew} \cdot eh\right) \cdot ew\right|\\
\end{array}
\end{array}
if t < -0.028500000000000001 or 5.99999999999999982e-21 < t Initial program 99.7%
Taylor expanded in eh around inf
mul-1-negN/A
associate-*r*N/A
distribute-lft-neg-inN/A
lower-*.f64N/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-sin.f64N/A
lower-sin.f64N/A
lower-atan.f64N/A
mul-1-negN/A
*-commutativeN/A
times-fracN/A
distribute-lft-neg-inN/A
Applied rewrites52.8%
Taylor expanded in t around 0
Applied rewrites53.0%
if -0.028500000000000001 < t < 5.99999999999999982e-21Initial program 100.0%
Taylor expanded in t around 0
*-commutativeN/A
lower-*.f64N/A
Applied rewrites71.4%
Applied rewrites71.4%
Final simplification63.3%
(FPCore (eh ew t) :precision binary64 (* (cos t) ew))
double code(double eh, double ew, double t) {
return cos(t) * ew;
}
real(8) function code(eh, ew, t)
real(8), intent (in) :: eh
real(8), intent (in) :: ew
real(8), intent (in) :: t
code = cos(t) * ew
end function
public static double code(double eh, double ew, double t) {
return Math.cos(t) * ew;
}
def code(eh, ew, t): return math.cos(t) * ew
function code(eh, ew, t) return Float64(cos(t) * ew) end
function tmp = code(eh, ew, t) tmp = cos(t) * ew; end
code[eh_, ew_, t_] := N[(N[Cos[t], $MachinePrecision] * ew), $MachinePrecision]
\begin{array}{l}
\\
\cos t \cdot ew
\end{array}
Initial program 99.9%
Applied rewrites40.9%
Taylor expanded in t around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
lower-*.f64N/A
distribute-rgt-outN/A
metadata-evalN/A
lower-*.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6419.6
Applied rewrites19.6%
Taylor expanded in eh around 0
*-commutativeN/A
lower-*.f64N/A
lower-cos.f6432.0
Applied rewrites32.0%
(FPCore (eh ew t) :precision binary64 (* 1.0 ew))
double code(double eh, double ew, double t) {
return 1.0 * ew;
}
real(8) function code(eh, ew, t)
real(8), intent (in) :: eh
real(8), intent (in) :: ew
real(8), intent (in) :: t
code = 1.0d0 * ew
end function
public static double code(double eh, double ew, double t) {
return 1.0 * ew;
}
def code(eh, ew, t): return 1.0 * ew
function code(eh, ew, t) return Float64(1.0 * ew) end
function tmp = code(eh, ew, t) tmp = 1.0 * ew; end
code[eh_, ew_, t_] := N[(1.0 * ew), $MachinePrecision]
\begin{array}{l}
\\
1 \cdot ew
\end{array}
Initial program 99.9%
Applied rewrites40.9%
Taylor expanded in t around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower--.f64N/A
lower-*.f64N/A
distribute-rgt-outN/A
metadata-evalN/A
lower-*.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6419.6
Applied rewrites19.6%
Taylor expanded in eh around 0
*-commutativeN/A
lower-*.f64N/A
lower-cos.f6432.0
Applied rewrites32.0%
Taylor expanded in t around 0
Applied rewrites25.0%
herbie shell --seed 2024326
(FPCore (eh ew t)
:name "Example 2 from Robby"
:precision binary64
(fabs (- (* (* ew (cos t)) (cos (atan (/ (* (- eh) (tan t)) ew)))) (* (* eh (sin t)) (sin (atan (/ (* (- eh) (tan t)) ew)))))))