
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(+
lambda1
(atan2
(* (* (sin theta) (sin delta)) (cos phi1))
(-
(cos delta)
(*
(sin phi1)
(sin
(asin
(+
(* (sin phi1) (cos delta))
(* (* (cos phi1) (sin delta)) (cos theta))))))))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 + atan2(((sin(theta) * sin(delta)) * cos(phi1)), (cos(delta) - (sin(phi1) * sin(asin(((sin(phi1) * cos(delta)) + ((cos(phi1) * sin(delta)) * cos(theta))))))));
}
module fmin_fmax_functions
implicit none
private
public fmax
public fmin
interface fmax
module procedure fmax88
module procedure fmax44
module procedure fmax84
module procedure fmax48
end interface
interface fmin
module procedure fmin88
module procedure fmin44
module procedure fmin84
module procedure fmin48
end interface
contains
real(8) function fmax88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(4) function fmax44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(8) function fmax84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, max(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmax48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), max(dble(x), y), y /= y), x /= x)
end function
real(8) function fmin88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(4) function fmin44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(8) function fmin84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, min(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmin48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), min(dble(x), y), y /= y), x /= x)
end function
end module
real(8) function code(lambda1, phi1, phi2, delta, theta)
use fmin_fmax_functions
real(8), intent (in) :: lambda1
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8), intent (in) :: delta
real(8), intent (in) :: theta
code = lambda1 + atan2(((sin(theta) * sin(delta)) * cos(phi1)), (cos(delta) - (sin(phi1) * sin(asin(((sin(phi1) * cos(delta)) + ((cos(phi1) * sin(delta)) * cos(theta))))))))
end function
public static double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 + Math.atan2(((Math.sin(theta) * Math.sin(delta)) * Math.cos(phi1)), (Math.cos(delta) - (Math.sin(phi1) * Math.sin(Math.asin(((Math.sin(phi1) * Math.cos(delta)) + ((Math.cos(phi1) * Math.sin(delta)) * Math.cos(theta))))))));
}
def code(lambda1, phi1, phi2, delta, theta): return lambda1 + math.atan2(((math.sin(theta) * math.sin(delta)) * math.cos(phi1)), (math.cos(delta) - (math.sin(phi1) * math.sin(math.asin(((math.sin(phi1) * math.cos(delta)) + ((math.cos(phi1) * math.sin(delta)) * math.cos(theta))))))))
function code(lambda1, phi1, phi2, delta, theta) return Float64(lambda1 + atan(Float64(Float64(sin(theta) * sin(delta)) * cos(phi1)), Float64(cos(delta) - Float64(sin(phi1) * sin(asin(Float64(Float64(sin(phi1) * cos(delta)) + Float64(Float64(cos(phi1) * sin(delta)) * cos(theta))))))))) end
function tmp = code(lambda1, phi1, phi2, delta, theta) tmp = lambda1 + atan2(((sin(theta) * sin(delta)) * cos(phi1)), (cos(delta) - (sin(phi1) * sin(asin(((sin(phi1) * cos(delta)) + ((cos(phi1) * sin(delta)) * cos(theta)))))))); end
code[lambda1_, phi1_, phi2_, delta_, theta_] := N[(lambda1 + N[ArcTan[N[(N[(N[Sin[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] / N[(N[Cos[delta], $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[Sin[N[ArcSin[N[(N[(N[Sin[phi1], $MachinePrecision] * N[Cos[delta], $MachinePrecision]), $MachinePrecision] + N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[theta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\lambda_1 + \tan^{-1}_* \frac{\left(\sin theta \cdot \sin delta\right) \cdot \cos \phi_1}{\cos delta - \sin \phi_1 \cdot \sin \sin^{-1} \left(\sin \phi_1 \cdot \cos delta + \left(\cos \phi_1 \cdot \sin delta\right) \cdot \cos theta\right)}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 19 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(+
lambda1
(atan2
(* (* (sin theta) (sin delta)) (cos phi1))
(-
(cos delta)
(*
(sin phi1)
(sin
(asin
(+
(* (sin phi1) (cos delta))
(* (* (cos phi1) (sin delta)) (cos theta))))))))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 + atan2(((sin(theta) * sin(delta)) * cos(phi1)), (cos(delta) - (sin(phi1) * sin(asin(((sin(phi1) * cos(delta)) + ((cos(phi1) * sin(delta)) * cos(theta))))))));
}
module fmin_fmax_functions
implicit none
private
public fmax
public fmin
interface fmax
module procedure fmax88
module procedure fmax44
module procedure fmax84
module procedure fmax48
end interface
interface fmin
module procedure fmin88
module procedure fmin44
module procedure fmin84
module procedure fmin48
end interface
contains
real(8) function fmax88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(4) function fmax44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(8) function fmax84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, max(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmax48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), max(dble(x), y), y /= y), x /= x)
end function
real(8) function fmin88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(4) function fmin44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(8) function fmin84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, min(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmin48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), min(dble(x), y), y /= y), x /= x)
end function
end module
real(8) function code(lambda1, phi1, phi2, delta, theta)
use fmin_fmax_functions
real(8), intent (in) :: lambda1
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8), intent (in) :: delta
real(8), intent (in) :: theta
code = lambda1 + atan2(((sin(theta) * sin(delta)) * cos(phi1)), (cos(delta) - (sin(phi1) * sin(asin(((sin(phi1) * cos(delta)) + ((cos(phi1) * sin(delta)) * cos(theta))))))))
end function
public static double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 + Math.atan2(((Math.sin(theta) * Math.sin(delta)) * Math.cos(phi1)), (Math.cos(delta) - (Math.sin(phi1) * Math.sin(Math.asin(((Math.sin(phi1) * Math.cos(delta)) + ((Math.cos(phi1) * Math.sin(delta)) * Math.cos(theta))))))));
}
def code(lambda1, phi1, phi2, delta, theta): return lambda1 + math.atan2(((math.sin(theta) * math.sin(delta)) * math.cos(phi1)), (math.cos(delta) - (math.sin(phi1) * math.sin(math.asin(((math.sin(phi1) * math.cos(delta)) + ((math.cos(phi1) * math.sin(delta)) * math.cos(theta))))))))
function code(lambda1, phi1, phi2, delta, theta) return Float64(lambda1 + atan(Float64(Float64(sin(theta) * sin(delta)) * cos(phi1)), Float64(cos(delta) - Float64(sin(phi1) * sin(asin(Float64(Float64(sin(phi1) * cos(delta)) + Float64(Float64(cos(phi1) * sin(delta)) * cos(theta))))))))) end
function tmp = code(lambda1, phi1, phi2, delta, theta) tmp = lambda1 + atan2(((sin(theta) * sin(delta)) * cos(phi1)), (cos(delta) - (sin(phi1) * sin(asin(((sin(phi1) * cos(delta)) + ((cos(phi1) * sin(delta)) * cos(theta)))))))); end
code[lambda1_, phi1_, phi2_, delta_, theta_] := N[(lambda1 + N[ArcTan[N[(N[(N[Sin[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] / N[(N[Cos[delta], $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[Sin[N[ArcSin[N[(N[(N[Sin[phi1], $MachinePrecision] * N[Cos[delta], $MachinePrecision]), $MachinePrecision] + N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[theta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\lambda_1 + \tan^{-1}_* \frac{\left(\sin theta \cdot \sin delta\right) \cdot \cos \phi_1}{\cos delta - \sin \phi_1 \cdot \sin \sin^{-1} \left(\sin \phi_1 \cdot \cos delta + \left(\cos \phi_1 \cdot \sin delta\right) \cdot \cos theta\right)}
\end{array}
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(+
lambda1
(atan2
(* (* (sin theta) (sin delta)) (cos phi1))
(-
(cos delta)
(*
(sin phi1)
(sin
(asin
(+
(* (sin phi1) (cos delta))
(* (* (cos phi1) (sin delta)) (cos theta))))))))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 + atan2(((sin(theta) * sin(delta)) * cos(phi1)), (cos(delta) - (sin(phi1) * sin(asin(((sin(phi1) * cos(delta)) + ((cos(phi1) * sin(delta)) * cos(theta))))))));
}
module fmin_fmax_functions
implicit none
private
public fmax
public fmin
interface fmax
module procedure fmax88
module procedure fmax44
module procedure fmax84
module procedure fmax48
end interface
interface fmin
module procedure fmin88
module procedure fmin44
module procedure fmin84
module procedure fmin48
end interface
contains
real(8) function fmax88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(4) function fmax44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(8) function fmax84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, max(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmax48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), max(dble(x), y), y /= y), x /= x)
end function
real(8) function fmin88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(4) function fmin44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(8) function fmin84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, min(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmin48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), min(dble(x), y), y /= y), x /= x)
end function
end module
real(8) function code(lambda1, phi1, phi2, delta, theta)
use fmin_fmax_functions
real(8), intent (in) :: lambda1
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8), intent (in) :: delta
real(8), intent (in) :: theta
code = lambda1 + atan2(((sin(theta) * sin(delta)) * cos(phi1)), (cos(delta) - (sin(phi1) * sin(asin(((sin(phi1) * cos(delta)) + ((cos(phi1) * sin(delta)) * cos(theta))))))))
end function
public static double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 + Math.atan2(((Math.sin(theta) * Math.sin(delta)) * Math.cos(phi1)), (Math.cos(delta) - (Math.sin(phi1) * Math.sin(Math.asin(((Math.sin(phi1) * Math.cos(delta)) + ((Math.cos(phi1) * Math.sin(delta)) * Math.cos(theta))))))));
}
def code(lambda1, phi1, phi2, delta, theta): return lambda1 + math.atan2(((math.sin(theta) * math.sin(delta)) * math.cos(phi1)), (math.cos(delta) - (math.sin(phi1) * math.sin(math.asin(((math.sin(phi1) * math.cos(delta)) + ((math.cos(phi1) * math.sin(delta)) * math.cos(theta))))))))
function code(lambda1, phi1, phi2, delta, theta) return Float64(lambda1 + atan(Float64(Float64(sin(theta) * sin(delta)) * cos(phi1)), Float64(cos(delta) - Float64(sin(phi1) * sin(asin(Float64(Float64(sin(phi1) * cos(delta)) + Float64(Float64(cos(phi1) * sin(delta)) * cos(theta))))))))) end
function tmp = code(lambda1, phi1, phi2, delta, theta) tmp = lambda1 + atan2(((sin(theta) * sin(delta)) * cos(phi1)), (cos(delta) - (sin(phi1) * sin(asin(((sin(phi1) * cos(delta)) + ((cos(phi1) * sin(delta)) * cos(theta)))))))); end
code[lambda1_, phi1_, phi2_, delta_, theta_] := N[(lambda1 + N[ArcTan[N[(N[(N[Sin[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] / N[(N[Cos[delta], $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[Sin[N[ArcSin[N[(N[(N[Sin[phi1], $MachinePrecision] * N[Cos[delta], $MachinePrecision]), $MachinePrecision] + N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[theta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\lambda_1 + \tan^{-1}_* \frac{\left(\sin theta \cdot \sin delta\right) \cdot \cos \phi_1}{\cos delta - \sin \phi_1 \cdot \sin \sin^{-1} \left(\sin \phi_1 \cdot \cos delta + \left(\cos \phi_1 \cdot \sin delta\right) \cdot \cos theta\right)}
\end{array}
Initial program 99.7%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(let* ((t_1 (* (sin phi1) (cos delta)))
(t_2 (- (cos delta) (* (sin phi1) (fma (cos phi1) (sin delta) t_1))))
(t_3 (* (* (sin theta) (sin delta)) (cos phi1)))
(t_4
(+
lambda1
(atan2
t_3
(-
(cos delta)
(*
(sin phi1)
(sin
(asin (+ t_1 (* (* (cos phi1) (sin delta)) (cos theta)))))))))))
(if (<= t_4 -3.1415926535898)
(+ lambda1 (atan2 (* (sin delta) (* (cos phi1) (sin theta))) t_2))
(if (<= t_4 -0.05)
(atan2
(* (* (sin delta) (sin theta)) (cos phi1))
(-
(cos delta)
(* (fma (* (cos theta) (sin delta)) (cos phi1) t_1) (sin phi1))))
(+ lambda1 (atan2 t_3 t_2))))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double t_1 = sin(phi1) * cos(delta);
double t_2 = cos(delta) - (sin(phi1) * fma(cos(phi1), sin(delta), t_1));
double t_3 = (sin(theta) * sin(delta)) * cos(phi1);
double t_4 = lambda1 + atan2(t_3, (cos(delta) - (sin(phi1) * sin(asin((t_1 + ((cos(phi1) * sin(delta)) * cos(theta))))))));
double tmp;
if (t_4 <= -3.1415926535898) {
tmp = lambda1 + atan2((sin(delta) * (cos(phi1) * sin(theta))), t_2);
} else if (t_4 <= -0.05) {
tmp = atan2(((sin(delta) * sin(theta)) * cos(phi1)), (cos(delta) - (fma((cos(theta) * sin(delta)), cos(phi1), t_1) * sin(phi1))));
} else {
tmp = lambda1 + atan2(t_3, t_2);
}
return tmp;
}
function code(lambda1, phi1, phi2, delta, theta) t_1 = Float64(sin(phi1) * cos(delta)) t_2 = Float64(cos(delta) - Float64(sin(phi1) * fma(cos(phi1), sin(delta), t_1))) t_3 = Float64(Float64(sin(theta) * sin(delta)) * cos(phi1)) t_4 = Float64(lambda1 + atan(t_3, Float64(cos(delta) - Float64(sin(phi1) * sin(asin(Float64(t_1 + Float64(Float64(cos(phi1) * sin(delta)) * cos(theta))))))))) tmp = 0.0 if (t_4 <= -3.1415926535898) tmp = Float64(lambda1 + atan(Float64(sin(delta) * Float64(cos(phi1) * sin(theta))), t_2)); elseif (t_4 <= -0.05) tmp = atan(Float64(Float64(sin(delta) * sin(theta)) * cos(phi1)), Float64(cos(delta) - Float64(fma(Float64(cos(theta) * sin(delta)), cos(phi1), t_1) * sin(phi1)))); else tmp = Float64(lambda1 + atan(t_3, t_2)); end return tmp end
code[lambda1_, phi1_, phi2_, delta_, theta_] := Block[{t$95$1 = N[(N[Sin[phi1], $MachinePrecision] * N[Cos[delta], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[Cos[delta], $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[phi1], $MachinePrecision] * N[Sin[delta], $MachinePrecision] + t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(N[Sin[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(lambda1 + N[ArcTan[t$95$3 / N[(N[Cos[delta], $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[Sin[N[ArcSin[N[(t$95$1 + N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[theta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$4, -3.1415926535898], N[(lambda1 + N[ArcTan[N[(N[Sin[delta], $MachinePrecision] * N[(N[Cos[phi1], $MachinePrecision] * N[Sin[theta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$2], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$4, -0.05], N[ArcTan[N[(N[(N[Sin[delta], $MachinePrecision] * N[Sin[theta], $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] / N[(N[Cos[delta], $MachinePrecision] - N[(N[(N[(N[Cos[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $MachinePrecision] + t$95$1), $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(lambda1 + N[ArcTan[t$95$3 / t$95$2], $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \sin \phi_1 \cdot \cos delta\\
t_2 := \cos delta - \sin \phi_1 \cdot \mathsf{fma}\left(\cos \phi_1, \sin delta, t\_1\right)\\
t_3 := \left(\sin theta \cdot \sin delta\right) \cdot \cos \phi_1\\
t_4 := \lambda_1 + \tan^{-1}_* \frac{t\_3}{\cos delta - \sin \phi_1 \cdot \sin \sin^{-1} \left(t\_1 + \left(\cos \phi_1 \cdot \sin delta\right) \cdot \cos theta\right)}\\
\mathbf{if}\;t\_4 \leq -3.1415926535898:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{\sin delta \cdot \left(\cos \phi_1 \cdot \sin theta\right)}{t\_2}\\
\mathbf{elif}\;t\_4 \leq -0.05:\\
\;\;\;\;\tan^{-1}_* \frac{\left(\sin delta \cdot \sin theta\right) \cdot \cos \phi_1}{\cos delta - \mathsf{fma}\left(\cos theta \cdot \sin delta, \cos \phi_1, t\_1\right) \cdot \sin \phi_1}\\
\mathbf{else}:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{t\_3}{t\_2}\\
\end{array}
\end{array}
if (+.f64 lambda1 (atan2.f64 (*.f64 (*.f64 (sin.f64 theta) (sin.f64 delta)) (cos.f64 phi1)) (-.f64 (cos.f64 delta) (*.f64 (sin.f64 phi1) (sin.f64 (asin.f64 (+.f64 (*.f64 (sin.f64 phi1) (cos.f64 delta)) (*.f64 (*.f64 (cos.f64 phi1) (sin.f64 delta)) (cos.f64 theta))))))))) < -3.1415926535898002Initial program 100.0%
lift-sin.f64N/A
lift-asin.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-cos.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
sin-asinN/A
+-commutativeN/A
Applied rewrites100.0%
lift-*.f64N/A
lift-sin.f64N/A
lift-sin.f64N/A
*-commutativeN/A
lift-cos.f64N/A
lower-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
lift-sin.f64N/A
lower-*.f64N/A
lift-cos.f64N/A
lift-sin.f64100.0
Applied rewrites100.0%
Taylor expanded in theta around 0
lift-cos.f6499.4
Applied rewrites99.4%
if -3.1415926535898002 < (+.f64 lambda1 (atan2.f64 (*.f64 (*.f64 (sin.f64 theta) (sin.f64 delta)) (cos.f64 phi1)) (-.f64 (cos.f64 delta) (*.f64 (sin.f64 phi1) (sin.f64 (asin.f64 (+.f64 (*.f64 (sin.f64 phi1) (cos.f64 delta)) (*.f64 (*.f64 (cos.f64 phi1) (sin.f64 delta)) (cos.f64 theta))))))))) < -0.050000000000000003Initial program 99.6%
Taylor expanded in lambda1 around 0
Applied rewrites99.5%
Applied rewrites99.6%
if -0.050000000000000003 < (+.f64 lambda1 (atan2.f64 (*.f64 (*.f64 (sin.f64 theta) (sin.f64 delta)) (cos.f64 phi1)) (-.f64 (cos.f64 delta) (*.f64 (sin.f64 phi1) (sin.f64 (asin.f64 (+.f64 (*.f64 (sin.f64 phi1) (cos.f64 delta)) (*.f64 (*.f64 (cos.f64 phi1) (sin.f64 delta)) (cos.f64 theta))))))))) Initial program 99.7%
lift-sin.f64N/A
lift-asin.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-cos.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
sin-asinN/A
+-commutativeN/A
Applied rewrites99.7%
Taylor expanded in theta around 0
lift-cos.f6495.7
Applied rewrites95.7%
Final simplification96.9%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(let* ((t_1 (* (sin phi1) (cos delta)))
(t_2 (- (cos delta) (* (sin phi1) (fma (cos phi1) (sin delta) t_1))))
(t_3 (* (* (sin theta) (sin delta)) (cos phi1)))
(t_4
(+
lambda1
(atan2
t_3
(-
(cos delta)
(*
(sin phi1)
(sin
(asin (+ t_1 (* (* (cos phi1) (sin delta)) (cos theta)))))))))))
(if (<= t_4 -3.1415926535898)
(+ lambda1 (atan2 (* (sin delta) (* (cos phi1) (sin theta))) t_2))
(if (<= t_4 -0.05)
(atan2
(* (* (sin delta) (sin theta)) (cos phi1))
(-
(cos delta)
(*
(fma
(sin phi1)
(cos delta)
(* (* (cos theta) (sin delta)) (cos phi1)))
(sin phi1))))
(+ lambda1 (atan2 t_3 t_2))))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double t_1 = sin(phi1) * cos(delta);
double t_2 = cos(delta) - (sin(phi1) * fma(cos(phi1), sin(delta), t_1));
double t_3 = (sin(theta) * sin(delta)) * cos(phi1);
double t_4 = lambda1 + atan2(t_3, (cos(delta) - (sin(phi1) * sin(asin((t_1 + ((cos(phi1) * sin(delta)) * cos(theta))))))));
double tmp;
if (t_4 <= -3.1415926535898) {
tmp = lambda1 + atan2((sin(delta) * (cos(phi1) * sin(theta))), t_2);
} else if (t_4 <= -0.05) {
tmp = atan2(((sin(delta) * sin(theta)) * cos(phi1)), (cos(delta) - (fma(sin(phi1), cos(delta), ((cos(theta) * sin(delta)) * cos(phi1))) * sin(phi1))));
} else {
tmp = lambda1 + atan2(t_3, t_2);
}
return tmp;
}
function code(lambda1, phi1, phi2, delta, theta) t_1 = Float64(sin(phi1) * cos(delta)) t_2 = Float64(cos(delta) - Float64(sin(phi1) * fma(cos(phi1), sin(delta), t_1))) t_3 = Float64(Float64(sin(theta) * sin(delta)) * cos(phi1)) t_4 = Float64(lambda1 + atan(t_3, Float64(cos(delta) - Float64(sin(phi1) * sin(asin(Float64(t_1 + Float64(Float64(cos(phi1) * sin(delta)) * cos(theta))))))))) tmp = 0.0 if (t_4 <= -3.1415926535898) tmp = Float64(lambda1 + atan(Float64(sin(delta) * Float64(cos(phi1) * sin(theta))), t_2)); elseif (t_4 <= -0.05) tmp = atan(Float64(Float64(sin(delta) * sin(theta)) * cos(phi1)), Float64(cos(delta) - Float64(fma(sin(phi1), cos(delta), Float64(Float64(cos(theta) * sin(delta)) * cos(phi1))) * sin(phi1)))); else tmp = Float64(lambda1 + atan(t_3, t_2)); end return tmp end
code[lambda1_, phi1_, phi2_, delta_, theta_] := Block[{t$95$1 = N[(N[Sin[phi1], $MachinePrecision] * N[Cos[delta], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[Cos[delta], $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[phi1], $MachinePrecision] * N[Sin[delta], $MachinePrecision] + t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(N[Sin[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(lambda1 + N[ArcTan[t$95$3 / N[(N[Cos[delta], $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[Sin[N[ArcSin[N[(t$95$1 + N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[theta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$4, -3.1415926535898], N[(lambda1 + N[ArcTan[N[(N[Sin[delta], $MachinePrecision] * N[(N[Cos[phi1], $MachinePrecision] * N[Sin[theta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$2], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$4, -0.05], N[ArcTan[N[(N[(N[Sin[delta], $MachinePrecision] * N[Sin[theta], $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] / N[(N[Cos[delta], $MachinePrecision] - N[(N[(N[Sin[phi1], $MachinePrecision] * N[Cos[delta], $MachinePrecision] + N[(N[(N[Cos[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(lambda1 + N[ArcTan[t$95$3 / t$95$2], $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \sin \phi_1 \cdot \cos delta\\
t_2 := \cos delta - \sin \phi_1 \cdot \mathsf{fma}\left(\cos \phi_1, \sin delta, t\_1\right)\\
t_3 := \left(\sin theta \cdot \sin delta\right) \cdot \cos \phi_1\\
t_4 := \lambda_1 + \tan^{-1}_* \frac{t\_3}{\cos delta - \sin \phi_1 \cdot \sin \sin^{-1} \left(t\_1 + \left(\cos \phi_1 \cdot \sin delta\right) \cdot \cos theta\right)}\\
\mathbf{if}\;t\_4 \leq -3.1415926535898:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{\sin delta \cdot \left(\cos \phi_1 \cdot \sin theta\right)}{t\_2}\\
\mathbf{elif}\;t\_4 \leq -0.05:\\
\;\;\;\;\tan^{-1}_* \frac{\left(\sin delta \cdot \sin theta\right) \cdot \cos \phi_1}{\cos delta - \mathsf{fma}\left(\sin \phi_1, \cos delta, \left(\cos theta \cdot \sin delta\right) \cdot \cos \phi_1\right) \cdot \sin \phi_1}\\
\mathbf{else}:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{t\_3}{t\_2}\\
\end{array}
\end{array}
if (+.f64 lambda1 (atan2.f64 (*.f64 (*.f64 (sin.f64 theta) (sin.f64 delta)) (cos.f64 phi1)) (-.f64 (cos.f64 delta) (*.f64 (sin.f64 phi1) (sin.f64 (asin.f64 (+.f64 (*.f64 (sin.f64 phi1) (cos.f64 delta)) (*.f64 (*.f64 (cos.f64 phi1) (sin.f64 delta)) (cos.f64 theta))))))))) < -3.1415926535898002Initial program 100.0%
lift-sin.f64N/A
lift-asin.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-cos.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
sin-asinN/A
+-commutativeN/A
Applied rewrites100.0%
lift-*.f64N/A
lift-sin.f64N/A
lift-sin.f64N/A
*-commutativeN/A
lift-cos.f64N/A
lower-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
lift-sin.f64N/A
lower-*.f64N/A
lift-cos.f64N/A
lift-sin.f64100.0
Applied rewrites100.0%
Taylor expanded in theta around 0
lift-cos.f6499.4
Applied rewrites99.4%
if -3.1415926535898002 < (+.f64 lambda1 (atan2.f64 (*.f64 (*.f64 (sin.f64 theta) (sin.f64 delta)) (cos.f64 phi1)) (-.f64 (cos.f64 delta) (*.f64 (sin.f64 phi1) (sin.f64 (asin.f64 (+.f64 (*.f64 (sin.f64 phi1) (cos.f64 delta)) (*.f64 (*.f64 (cos.f64 phi1) (sin.f64 delta)) (cos.f64 theta))))))))) < -0.050000000000000003Initial program 99.6%
Taylor expanded in lambda1 around 0
Applied rewrites99.5%
lift-*.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-cos.f64N/A
lift-sin.f64N/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
lift-cos.f64N/A
lift-sin.f64N/A
lift-cos.f6499.5
Applied rewrites99.5%
if -0.050000000000000003 < (+.f64 lambda1 (atan2.f64 (*.f64 (*.f64 (sin.f64 theta) (sin.f64 delta)) (cos.f64 phi1)) (-.f64 (cos.f64 delta) (*.f64 (sin.f64 phi1) (sin.f64 (asin.f64 (+.f64 (*.f64 (sin.f64 phi1) (cos.f64 delta)) (*.f64 (*.f64 (cos.f64 phi1) (sin.f64 delta)) (cos.f64 theta))))))))) Initial program 99.7%
lift-sin.f64N/A
lift-asin.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-cos.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
sin-asinN/A
+-commutativeN/A
Applied rewrites99.7%
Taylor expanded in theta around 0
lift-cos.f6495.7
Applied rewrites95.7%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(let* ((t_1 (* (sin phi1) (cos delta)))
(t_2 (- (cos delta) (* (sin phi1) (fma (cos phi1) (sin delta) t_1))))
(t_3 (* (* (sin theta) (sin delta)) (cos phi1)))
(t_4 (* (cos phi1) (sin delta)))
(t_5
(+
lambda1
(atan2
t_3
(-
(cos delta)
(* (sin phi1) (sin (asin (+ t_1 (* t_4 (cos theta)))))))))))
(if (<= t_5 -3.1415926535898)
(+ lambda1 (atan2 (* (sin delta) (* (cos phi1) (sin theta))) t_2))
(if (<= t_5 -0.05)
(atan2
(* (* (sin delta) (sin theta)) (cos phi1))
(-
(cos delta)
(* (fma (sin phi1) (cos delta) (* (cos theta) t_4)) (sin phi1))))
(+ lambda1 (atan2 t_3 t_2))))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double t_1 = sin(phi1) * cos(delta);
double t_2 = cos(delta) - (sin(phi1) * fma(cos(phi1), sin(delta), t_1));
double t_3 = (sin(theta) * sin(delta)) * cos(phi1);
double t_4 = cos(phi1) * sin(delta);
double t_5 = lambda1 + atan2(t_3, (cos(delta) - (sin(phi1) * sin(asin((t_1 + (t_4 * cos(theta))))))));
double tmp;
if (t_5 <= -3.1415926535898) {
tmp = lambda1 + atan2((sin(delta) * (cos(phi1) * sin(theta))), t_2);
} else if (t_5 <= -0.05) {
tmp = atan2(((sin(delta) * sin(theta)) * cos(phi1)), (cos(delta) - (fma(sin(phi1), cos(delta), (cos(theta) * t_4)) * sin(phi1))));
} else {
tmp = lambda1 + atan2(t_3, t_2);
}
return tmp;
}
function code(lambda1, phi1, phi2, delta, theta) t_1 = Float64(sin(phi1) * cos(delta)) t_2 = Float64(cos(delta) - Float64(sin(phi1) * fma(cos(phi1), sin(delta), t_1))) t_3 = Float64(Float64(sin(theta) * sin(delta)) * cos(phi1)) t_4 = Float64(cos(phi1) * sin(delta)) t_5 = Float64(lambda1 + atan(t_3, Float64(cos(delta) - Float64(sin(phi1) * sin(asin(Float64(t_1 + Float64(t_4 * cos(theta))))))))) tmp = 0.0 if (t_5 <= -3.1415926535898) tmp = Float64(lambda1 + atan(Float64(sin(delta) * Float64(cos(phi1) * sin(theta))), t_2)); elseif (t_5 <= -0.05) tmp = atan(Float64(Float64(sin(delta) * sin(theta)) * cos(phi1)), Float64(cos(delta) - Float64(fma(sin(phi1), cos(delta), Float64(cos(theta) * t_4)) * sin(phi1)))); else tmp = Float64(lambda1 + atan(t_3, t_2)); end return tmp end
code[lambda1_, phi1_, phi2_, delta_, theta_] := Block[{t$95$1 = N[(N[Sin[phi1], $MachinePrecision] * N[Cos[delta], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[Cos[delta], $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[phi1], $MachinePrecision] * N[Sin[delta], $MachinePrecision] + t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(N[Sin[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[Cos[phi1], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$5 = N[(lambda1 + N[ArcTan[t$95$3 / N[(N[Cos[delta], $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[Sin[N[ArcSin[N[(t$95$1 + N[(t$95$4 * N[Cos[theta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$5, -3.1415926535898], N[(lambda1 + N[ArcTan[N[(N[Sin[delta], $MachinePrecision] * N[(N[Cos[phi1], $MachinePrecision] * N[Sin[theta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$2], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$5, -0.05], N[ArcTan[N[(N[(N[Sin[delta], $MachinePrecision] * N[Sin[theta], $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] / N[(N[Cos[delta], $MachinePrecision] - N[(N[(N[Sin[phi1], $MachinePrecision] * N[Cos[delta], $MachinePrecision] + N[(N[Cos[theta], $MachinePrecision] * t$95$4), $MachinePrecision]), $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(lambda1 + N[ArcTan[t$95$3 / t$95$2], $MachinePrecision]), $MachinePrecision]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \sin \phi_1 \cdot \cos delta\\
t_2 := \cos delta - \sin \phi_1 \cdot \mathsf{fma}\left(\cos \phi_1, \sin delta, t\_1\right)\\
t_3 := \left(\sin theta \cdot \sin delta\right) \cdot \cos \phi_1\\
t_4 := \cos \phi_1 \cdot \sin delta\\
t_5 := \lambda_1 + \tan^{-1}_* \frac{t\_3}{\cos delta - \sin \phi_1 \cdot \sin \sin^{-1} \left(t\_1 + t\_4 \cdot \cos theta\right)}\\
\mathbf{if}\;t\_5 \leq -3.1415926535898:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{\sin delta \cdot \left(\cos \phi_1 \cdot \sin theta\right)}{t\_2}\\
\mathbf{elif}\;t\_5 \leq -0.05:\\
\;\;\;\;\tan^{-1}_* \frac{\left(\sin delta \cdot \sin theta\right) \cdot \cos \phi_1}{\cos delta - \mathsf{fma}\left(\sin \phi_1, \cos delta, \cos theta \cdot t\_4\right) \cdot \sin \phi_1}\\
\mathbf{else}:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{t\_3}{t\_2}\\
\end{array}
\end{array}
if (+.f64 lambda1 (atan2.f64 (*.f64 (*.f64 (sin.f64 theta) (sin.f64 delta)) (cos.f64 phi1)) (-.f64 (cos.f64 delta) (*.f64 (sin.f64 phi1) (sin.f64 (asin.f64 (+.f64 (*.f64 (sin.f64 phi1) (cos.f64 delta)) (*.f64 (*.f64 (cos.f64 phi1) (sin.f64 delta)) (cos.f64 theta))))))))) < -3.1415926535898002Initial program 100.0%
lift-sin.f64N/A
lift-asin.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-cos.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
sin-asinN/A
+-commutativeN/A
Applied rewrites100.0%
lift-*.f64N/A
lift-sin.f64N/A
lift-sin.f64N/A
*-commutativeN/A
lift-cos.f64N/A
lower-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
lift-sin.f64N/A
lower-*.f64N/A
lift-cos.f64N/A
lift-sin.f64100.0
Applied rewrites100.0%
Taylor expanded in theta around 0
lift-cos.f6499.4
Applied rewrites99.4%
if -3.1415926535898002 < (+.f64 lambda1 (atan2.f64 (*.f64 (*.f64 (sin.f64 theta) (sin.f64 delta)) (cos.f64 phi1)) (-.f64 (cos.f64 delta) (*.f64 (sin.f64 phi1) (sin.f64 (asin.f64 (+.f64 (*.f64 (sin.f64 phi1) (cos.f64 delta)) (*.f64 (*.f64 (cos.f64 phi1) (sin.f64 delta)) (cos.f64 theta))))))))) < -0.050000000000000003Initial program 99.6%
Taylor expanded in lambda1 around 0
Applied rewrites99.5%
if -0.050000000000000003 < (+.f64 lambda1 (atan2.f64 (*.f64 (*.f64 (sin.f64 theta) (sin.f64 delta)) (cos.f64 phi1)) (-.f64 (cos.f64 delta) (*.f64 (sin.f64 phi1) (sin.f64 (asin.f64 (+.f64 (*.f64 (sin.f64 phi1) (cos.f64 delta)) (*.f64 (*.f64 (cos.f64 phi1) (sin.f64 delta)) (cos.f64 theta))))))))) Initial program 99.7%
lift-sin.f64N/A
lift-asin.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-cos.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
sin-asinN/A
+-commutativeN/A
Applied rewrites99.7%
Taylor expanded in theta around 0
lift-cos.f6495.7
Applied rewrites95.7%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(let* ((t_1 (* (cos phi1) (sin delta)))
(t_2
(atan2
(* (* (sin theta) (sin delta)) (cos phi1))
(-
(cos delta)
(*
(sin phi1)
(sin
(asin (+ (* (sin phi1) (cos delta)) (* t_1 (cos theta))))))))))
(if (<= t_2 -5e-89)
(+
lambda1
(atan2
(* (* theta (sin delta)) (cos phi1))
(fma (* delta delta) -0.5 1.0)))
(if (<= t_2 5e-89)
lambda1
(+ lambda1 (atan2 (* theta t_1) (cos delta)))))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double t_1 = cos(phi1) * sin(delta);
double t_2 = atan2(((sin(theta) * sin(delta)) * cos(phi1)), (cos(delta) - (sin(phi1) * sin(asin(((sin(phi1) * cos(delta)) + (t_1 * cos(theta))))))));
double tmp;
if (t_2 <= -5e-89) {
tmp = lambda1 + atan2(((theta * sin(delta)) * cos(phi1)), fma((delta * delta), -0.5, 1.0));
} else if (t_2 <= 5e-89) {
tmp = lambda1;
} else {
tmp = lambda1 + atan2((theta * t_1), cos(delta));
}
return tmp;
}
function code(lambda1, phi1, phi2, delta, theta) t_1 = Float64(cos(phi1) * sin(delta)) t_2 = atan(Float64(Float64(sin(theta) * sin(delta)) * cos(phi1)), Float64(cos(delta) - Float64(sin(phi1) * sin(asin(Float64(Float64(sin(phi1) * cos(delta)) + Float64(t_1 * cos(theta)))))))) tmp = 0.0 if (t_2 <= -5e-89) tmp = Float64(lambda1 + atan(Float64(Float64(theta * sin(delta)) * cos(phi1)), fma(Float64(delta * delta), -0.5, 1.0))); elseif (t_2 <= 5e-89) tmp = lambda1; else tmp = Float64(lambda1 + atan(Float64(theta * t_1), cos(delta))); end return tmp end
code[lambda1_, phi1_, phi2_, delta_, theta_] := Block[{t$95$1 = N[(N[Cos[phi1], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[ArcTan[N[(N[(N[Sin[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] / N[(N[Cos[delta], $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[Sin[N[ArcSin[N[(N[(N[Sin[phi1], $MachinePrecision] * N[Cos[delta], $MachinePrecision]), $MachinePrecision] + N[(t$95$1 * N[Cos[theta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[t$95$2, -5e-89], N[(lambda1 + N[ArcTan[N[(N[(theta * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] / N[(N[(delta * delta), $MachinePrecision] * -0.5 + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 5e-89], lambda1, N[(lambda1 + N[ArcTan[N[(theta * t$95$1), $MachinePrecision] / N[Cos[delta], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \cos \phi_1 \cdot \sin delta\\
t_2 := \tan^{-1}_* \frac{\left(\sin theta \cdot \sin delta\right) \cdot \cos \phi_1}{\cos delta - \sin \phi_1 \cdot \sin \sin^{-1} \left(\sin \phi_1 \cdot \cos delta + t\_1 \cdot \cos theta\right)}\\
\mathbf{if}\;t\_2 \leq -5 \cdot 10^{-89}:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{\left(theta \cdot \sin delta\right) \cdot \cos \phi_1}{\mathsf{fma}\left(delta \cdot delta, -0.5, 1\right)}\\
\mathbf{elif}\;t\_2 \leq 5 \cdot 10^{-89}:\\
\;\;\;\;\lambda_1\\
\mathbf{else}:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{theta \cdot t\_1}{\cos delta}\\
\end{array}
\end{array}
if (atan2.f64 (*.f64 (*.f64 (sin.f64 theta) (sin.f64 delta)) (cos.f64 phi1)) (-.f64 (cos.f64 delta) (*.f64 (sin.f64 phi1) (sin.f64 (asin.f64 (+.f64 (*.f64 (sin.f64 phi1) (cos.f64 delta)) (*.f64 (*.f64 (cos.f64 phi1) (sin.f64 delta)) (cos.f64 theta)))))))) < -4.99999999999999967e-89Initial program 99.6%
lift-sin.f64N/A
lift-asin.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-cos.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
sin-asinN/A
+-commutativeN/A
Applied rewrites99.5%
Taylor expanded in phi1 around 0
Applied rewrites69.4%
Taylor expanded in theta around 0
Applied rewrites53.9%
Taylor expanded in delta around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6459.1
Applied rewrites59.1%
if -4.99999999999999967e-89 < (atan2.f64 (*.f64 (*.f64 (sin.f64 theta) (sin.f64 delta)) (cos.f64 phi1)) (-.f64 (cos.f64 delta) (*.f64 (sin.f64 phi1) (sin.f64 (asin.f64 (+.f64 (*.f64 (sin.f64 phi1) (cos.f64 delta)) (*.f64 (*.f64 (cos.f64 phi1) (sin.f64 delta)) (cos.f64 theta)))))))) < 4.99999999999999967e-89Initial program 99.8%
Taylor expanded in lambda1 around inf
Applied rewrites82.9%
if 4.99999999999999967e-89 < (atan2.f64 (*.f64 (*.f64 (sin.f64 theta) (sin.f64 delta)) (cos.f64 phi1)) (-.f64 (cos.f64 delta) (*.f64 (sin.f64 phi1) (sin.f64 (asin.f64 (+.f64 (*.f64 (sin.f64 phi1) (cos.f64 delta)) (*.f64 (*.f64 (cos.f64 phi1) (sin.f64 delta)) (cos.f64 theta)))))))) Initial program 99.7%
lift-sin.f64N/A
lift-asin.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-cos.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
sin-asinN/A
+-commutativeN/A
Applied rewrites99.8%
Taylor expanded in phi1 around 0
Applied rewrites79.8%
Taylor expanded in theta around 0
Applied rewrites70.0%
lift-*.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
lift-cos.f64N/A
lift-sin.f64N/A
lift-*.f6470.0
Applied rewrites70.0%
Final simplification73.5%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(let* ((t_1 (* theta (sin delta)))
(t_2
(atan2
(* (* (sin theta) (sin delta)) (cos phi1))
(-
(cos delta)
(*
(sin phi1)
(sin
(asin
(+
(* (sin phi1) (cos delta))
(* (* (cos phi1) (sin delta)) (cos theta))))))))))
(if (<= t_2 -5e-89)
(+ lambda1 (atan2 (* t_1 (cos phi1)) (fma (* delta delta) -0.5 1.0)))
(if (<= t_2 5e-89) lambda1 (+ lambda1 (atan2 (* t_1 1.0) (cos delta)))))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double t_1 = theta * sin(delta);
double t_2 = atan2(((sin(theta) * sin(delta)) * cos(phi1)), (cos(delta) - (sin(phi1) * sin(asin(((sin(phi1) * cos(delta)) + ((cos(phi1) * sin(delta)) * cos(theta))))))));
double tmp;
if (t_2 <= -5e-89) {
tmp = lambda1 + atan2((t_1 * cos(phi1)), fma((delta * delta), -0.5, 1.0));
} else if (t_2 <= 5e-89) {
tmp = lambda1;
} else {
tmp = lambda1 + atan2((t_1 * 1.0), cos(delta));
}
return tmp;
}
function code(lambda1, phi1, phi2, delta, theta) t_1 = Float64(theta * sin(delta)) t_2 = atan(Float64(Float64(sin(theta) * sin(delta)) * cos(phi1)), Float64(cos(delta) - Float64(sin(phi1) * sin(asin(Float64(Float64(sin(phi1) * cos(delta)) + Float64(Float64(cos(phi1) * sin(delta)) * cos(theta)))))))) tmp = 0.0 if (t_2 <= -5e-89) tmp = Float64(lambda1 + atan(Float64(t_1 * cos(phi1)), fma(Float64(delta * delta), -0.5, 1.0))); elseif (t_2 <= 5e-89) tmp = lambda1; else tmp = Float64(lambda1 + atan(Float64(t_1 * 1.0), cos(delta))); end return tmp end
code[lambda1_, phi1_, phi2_, delta_, theta_] := Block[{t$95$1 = N[(theta * N[Sin[delta], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[ArcTan[N[(N[(N[Sin[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] / N[(N[Cos[delta], $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[Sin[N[ArcSin[N[(N[(N[Sin[phi1], $MachinePrecision] * N[Cos[delta], $MachinePrecision]), $MachinePrecision] + N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[theta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[t$95$2, -5e-89], N[(lambda1 + N[ArcTan[N[(t$95$1 * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] / N[(N[(delta * delta), $MachinePrecision] * -0.5 + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 5e-89], lambda1, N[(lambda1 + N[ArcTan[N[(t$95$1 * 1.0), $MachinePrecision] / N[Cos[delta], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := theta \cdot \sin delta\\
t_2 := \tan^{-1}_* \frac{\left(\sin theta \cdot \sin delta\right) \cdot \cos \phi_1}{\cos delta - \sin \phi_1 \cdot \sin \sin^{-1} \left(\sin \phi_1 \cdot \cos delta + \left(\cos \phi_1 \cdot \sin delta\right) \cdot \cos theta\right)}\\
\mathbf{if}\;t\_2 \leq -5 \cdot 10^{-89}:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{t\_1 \cdot \cos \phi_1}{\mathsf{fma}\left(delta \cdot delta, -0.5, 1\right)}\\
\mathbf{elif}\;t\_2 \leq 5 \cdot 10^{-89}:\\
\;\;\;\;\lambda_1\\
\mathbf{else}:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{t\_1 \cdot 1}{\cos delta}\\
\end{array}
\end{array}
if (atan2.f64 (*.f64 (*.f64 (sin.f64 theta) (sin.f64 delta)) (cos.f64 phi1)) (-.f64 (cos.f64 delta) (*.f64 (sin.f64 phi1) (sin.f64 (asin.f64 (+.f64 (*.f64 (sin.f64 phi1) (cos.f64 delta)) (*.f64 (*.f64 (cos.f64 phi1) (sin.f64 delta)) (cos.f64 theta)))))))) < -4.99999999999999967e-89Initial program 99.6%
lift-sin.f64N/A
lift-asin.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-cos.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
sin-asinN/A
+-commutativeN/A
Applied rewrites99.5%
Taylor expanded in phi1 around 0
Applied rewrites69.4%
Taylor expanded in theta around 0
Applied rewrites53.9%
Taylor expanded in delta around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6459.1
Applied rewrites59.1%
if -4.99999999999999967e-89 < (atan2.f64 (*.f64 (*.f64 (sin.f64 theta) (sin.f64 delta)) (cos.f64 phi1)) (-.f64 (cos.f64 delta) (*.f64 (sin.f64 phi1) (sin.f64 (asin.f64 (+.f64 (*.f64 (sin.f64 phi1) (cos.f64 delta)) (*.f64 (*.f64 (cos.f64 phi1) (sin.f64 delta)) (cos.f64 theta)))))))) < 4.99999999999999967e-89Initial program 99.8%
Taylor expanded in lambda1 around inf
Applied rewrites82.9%
if 4.99999999999999967e-89 < (atan2.f64 (*.f64 (*.f64 (sin.f64 theta) (sin.f64 delta)) (cos.f64 phi1)) (-.f64 (cos.f64 delta) (*.f64 (sin.f64 phi1) (sin.f64 (asin.f64 (+.f64 (*.f64 (sin.f64 phi1) (cos.f64 delta)) (*.f64 (*.f64 (cos.f64 phi1) (sin.f64 delta)) (cos.f64 theta)))))))) Initial program 99.7%
lift-sin.f64N/A
lift-asin.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-cos.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
sin-asinN/A
+-commutativeN/A
Applied rewrites99.8%
Taylor expanded in phi1 around 0
Applied rewrites79.8%
Taylor expanded in theta around 0
Applied rewrites70.0%
Taylor expanded in phi1 around 0
Applied rewrites68.7%
Final simplification73.2%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(let* ((t_1 (* (sin theta) (sin delta))))
(if (<=
(atan2
(* t_1 (cos phi1))
(-
(cos delta)
(*
(sin phi1)
(sin
(asin
(+
(* (sin phi1) (cos delta))
(* (* (cos phi1) (sin delta)) (cos theta))))))))
-3.14)
(+
lambda1
(atan2
(* (* theta (sin delta)) (cos phi1))
(fma (* delta delta) -0.5 1.0)))
(+ lambda1 (atan2 (* t_1 1.0) (cos delta))))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double t_1 = sin(theta) * sin(delta);
double tmp;
if (atan2((t_1 * cos(phi1)), (cos(delta) - (sin(phi1) * sin(asin(((sin(phi1) * cos(delta)) + ((cos(phi1) * sin(delta)) * cos(theta)))))))) <= -3.14) {
tmp = lambda1 + atan2(((theta * sin(delta)) * cos(phi1)), fma((delta * delta), -0.5, 1.0));
} else {
tmp = lambda1 + atan2((t_1 * 1.0), cos(delta));
}
return tmp;
}
function code(lambda1, phi1, phi2, delta, theta) t_1 = Float64(sin(theta) * sin(delta)) tmp = 0.0 if (atan(Float64(t_1 * cos(phi1)), Float64(cos(delta) - Float64(sin(phi1) * sin(asin(Float64(Float64(sin(phi1) * cos(delta)) + Float64(Float64(cos(phi1) * sin(delta)) * cos(theta)))))))) <= -3.14) tmp = Float64(lambda1 + atan(Float64(Float64(theta * sin(delta)) * cos(phi1)), fma(Float64(delta * delta), -0.5, 1.0))); else tmp = Float64(lambda1 + atan(Float64(t_1 * 1.0), cos(delta))); end return tmp end
code[lambda1_, phi1_, phi2_, delta_, theta_] := Block[{t$95$1 = N[(N[Sin[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[ArcTan[N[(t$95$1 * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] / N[(N[Cos[delta], $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[Sin[N[ArcSin[N[(N[(N[Sin[phi1], $MachinePrecision] * N[Cos[delta], $MachinePrecision]), $MachinePrecision] + N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[theta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], -3.14], N[(lambda1 + N[ArcTan[N[(N[(theta * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] / N[(N[(delta * delta), $MachinePrecision] * -0.5 + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(lambda1 + N[ArcTan[N[(t$95$1 * 1.0), $MachinePrecision] / N[Cos[delta], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \sin theta \cdot \sin delta\\
\mathbf{if}\;\tan^{-1}_* \frac{t\_1 \cdot \cos \phi_1}{\cos delta - \sin \phi_1 \cdot \sin \sin^{-1} \left(\sin \phi_1 \cdot \cos delta + \left(\cos \phi_1 \cdot \sin delta\right) \cdot \cos theta\right)} \leq -3.14:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{\left(theta \cdot \sin delta\right) \cdot \cos \phi_1}{\mathsf{fma}\left(delta \cdot delta, -0.5, 1\right)}\\
\mathbf{else}:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{t\_1 \cdot 1}{\cos delta}\\
\end{array}
\end{array}
if (atan2.f64 (*.f64 (*.f64 (sin.f64 theta) (sin.f64 delta)) (cos.f64 phi1)) (-.f64 (cos.f64 delta) (*.f64 (sin.f64 phi1) (sin.f64 (asin.f64 (+.f64 (*.f64 (sin.f64 phi1) (cos.f64 delta)) (*.f64 (*.f64 (cos.f64 phi1) (sin.f64 delta)) (cos.f64 theta)))))))) < -3.14000000000000012Initial program 99.9%
lift-sin.f64N/A
lift-asin.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-cos.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
sin-asinN/A
+-commutativeN/A
Applied rewrites99.9%
Taylor expanded in phi1 around 0
Applied rewrites78.5%
Taylor expanded in theta around 0
Applied rewrites78.5%
Taylor expanded in delta around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6499.9
Applied rewrites99.9%
if -3.14000000000000012 < (atan2.f64 (*.f64 (*.f64 (sin.f64 theta) (sin.f64 delta)) (cos.f64 phi1)) (-.f64 (cos.f64 delta) (*.f64 (sin.f64 phi1) (sin.f64 (asin.f64 (+.f64 (*.f64 (sin.f64 phi1) (cos.f64 delta)) (*.f64 (*.f64 (cos.f64 phi1) (sin.f64 delta)) (cos.f64 theta)))))))) Initial program 99.7%
lift-sin.f64N/A
lift-asin.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-cos.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
sin-asinN/A
+-commutativeN/A
Applied rewrites99.7%
Taylor expanded in phi1 around 0
Applied rewrites83.0%
Taylor expanded in phi1 around 0
Applied rewrites81.0%
Final simplification82.4%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(+
lambda1
(atan2
(* (* (sin theta) (sin delta)) (cos phi1))
(-
(cos delta)
(*
(sin phi1)
(fma
(* (cos theta) (cos phi1))
(sin delta)
(* (sin phi1) (cos delta))))))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 + atan2(((sin(theta) * sin(delta)) * cos(phi1)), (cos(delta) - (sin(phi1) * fma((cos(theta) * cos(phi1)), sin(delta), (sin(phi1) * cos(delta))))));
}
function code(lambda1, phi1, phi2, delta, theta) return Float64(lambda1 + atan(Float64(Float64(sin(theta) * sin(delta)) * cos(phi1)), Float64(cos(delta) - Float64(sin(phi1) * fma(Float64(cos(theta) * cos(phi1)), sin(delta), Float64(sin(phi1) * cos(delta))))))) end
code[lambda1_, phi1_, phi2_, delta_, theta_] := N[(lambda1 + N[ArcTan[N[(N[(N[Sin[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] / N[(N[Cos[delta], $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[(N[(N[Cos[theta], $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] * N[Sin[delta], $MachinePrecision] + N[(N[Sin[phi1], $MachinePrecision] * N[Cos[delta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\lambda_1 + \tan^{-1}_* \frac{\left(\sin theta \cdot \sin delta\right) \cdot \cos \phi_1}{\cos delta - \sin \phi_1 \cdot \mathsf{fma}\left(\cos theta \cdot \cos \phi_1, \sin delta, \sin \phi_1 \cdot \cos delta\right)}
\end{array}
Initial program 99.7%
lift-sin.f64N/A
lift-asin.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-cos.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
sin-asinN/A
+-commutativeN/A
Applied rewrites99.7%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(+
lambda1
(atan2
(* (sin delta) (* (cos phi1) (sin theta)))
(-
(cos delta)
(*
(sin phi1)
(fma
(* (cos theta) (cos phi1))
(sin delta)
(* (sin phi1) (cos delta))))))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 + atan2((sin(delta) * (cos(phi1) * sin(theta))), (cos(delta) - (sin(phi1) * fma((cos(theta) * cos(phi1)), sin(delta), (sin(phi1) * cos(delta))))));
}
function code(lambda1, phi1, phi2, delta, theta) return Float64(lambda1 + atan(Float64(sin(delta) * Float64(cos(phi1) * sin(theta))), Float64(cos(delta) - Float64(sin(phi1) * fma(Float64(cos(theta) * cos(phi1)), sin(delta), Float64(sin(phi1) * cos(delta))))))) end
code[lambda1_, phi1_, phi2_, delta_, theta_] := N[(lambda1 + N[ArcTan[N[(N[Sin[delta], $MachinePrecision] * N[(N[Cos[phi1], $MachinePrecision] * N[Sin[theta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[Cos[delta], $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[(N[(N[Cos[theta], $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] * N[Sin[delta], $MachinePrecision] + N[(N[Sin[phi1], $MachinePrecision] * N[Cos[delta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\lambda_1 + \tan^{-1}_* \frac{\sin delta \cdot \left(\cos \phi_1 \cdot \sin theta\right)}{\cos delta - \sin \phi_1 \cdot \mathsf{fma}\left(\cos theta \cdot \cos \phi_1, \sin delta, \sin \phi_1 \cdot \cos delta\right)}
\end{array}
Initial program 99.7%
lift-sin.f64N/A
lift-asin.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-cos.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
sin-asinN/A
+-commutativeN/A
Applied rewrites99.7%
lift-*.f64N/A
lift-sin.f64N/A
lift-sin.f64N/A
*-commutativeN/A
lift-cos.f64N/A
lower-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
lift-sin.f64N/A
lower-*.f64N/A
lift-cos.f64N/A
lift-sin.f6499.7
Applied rewrites99.7%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(+
lambda1
(atan2
(* (* (sin theta) (sin delta)) (cos phi1))
(-
(cos delta)
(* (sin phi1) (fma (cos phi1) (sin delta) (* (sin phi1) (cos delta))))))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 + atan2(((sin(theta) * sin(delta)) * cos(phi1)), (cos(delta) - (sin(phi1) * fma(cos(phi1), sin(delta), (sin(phi1) * cos(delta))))));
}
function code(lambda1, phi1, phi2, delta, theta) return Float64(lambda1 + atan(Float64(Float64(sin(theta) * sin(delta)) * cos(phi1)), Float64(cos(delta) - Float64(sin(phi1) * fma(cos(phi1), sin(delta), Float64(sin(phi1) * cos(delta))))))) end
code[lambda1_, phi1_, phi2_, delta_, theta_] := N[(lambda1 + N[ArcTan[N[(N[(N[Sin[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] / N[(N[Cos[delta], $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[phi1], $MachinePrecision] * N[Sin[delta], $MachinePrecision] + N[(N[Sin[phi1], $MachinePrecision] * N[Cos[delta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\lambda_1 + \tan^{-1}_* \frac{\left(\sin theta \cdot \sin delta\right) \cdot \cos \phi_1}{\cos delta - \sin \phi_1 \cdot \mathsf{fma}\left(\cos \phi_1, \sin delta, \sin \phi_1 \cdot \cos delta\right)}
\end{array}
Initial program 99.7%
lift-sin.f64N/A
lift-asin.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-cos.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
sin-asinN/A
+-commutativeN/A
Applied rewrites99.7%
Taylor expanded in theta around 0
lift-cos.f6493.3
Applied rewrites93.3%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(+
lambda1
(atan2
(* (sin delta) (* (cos phi1) (sin theta)))
(-
(cos delta)
(* (sin phi1) (fma (cos phi1) (sin delta) (* (sin phi1) (cos delta))))))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 + atan2((sin(delta) * (cos(phi1) * sin(theta))), (cos(delta) - (sin(phi1) * fma(cos(phi1), sin(delta), (sin(phi1) * cos(delta))))));
}
function code(lambda1, phi1, phi2, delta, theta) return Float64(lambda1 + atan(Float64(sin(delta) * Float64(cos(phi1) * sin(theta))), Float64(cos(delta) - Float64(sin(phi1) * fma(cos(phi1), sin(delta), Float64(sin(phi1) * cos(delta))))))) end
code[lambda1_, phi1_, phi2_, delta_, theta_] := N[(lambda1 + N[ArcTan[N[(N[Sin[delta], $MachinePrecision] * N[(N[Cos[phi1], $MachinePrecision] * N[Sin[theta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[Cos[delta], $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[phi1], $MachinePrecision] * N[Sin[delta], $MachinePrecision] + N[(N[Sin[phi1], $MachinePrecision] * N[Cos[delta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\lambda_1 + \tan^{-1}_* \frac{\sin delta \cdot \left(\cos \phi_1 \cdot \sin theta\right)}{\cos delta - \sin \phi_1 \cdot \mathsf{fma}\left(\cos \phi_1, \sin delta, \sin \phi_1 \cdot \cos delta\right)}
\end{array}
Initial program 99.7%
lift-sin.f64N/A
lift-asin.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-cos.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
sin-asinN/A
+-commutativeN/A
Applied rewrites99.7%
lift-*.f64N/A
lift-sin.f64N/A
lift-sin.f64N/A
*-commutativeN/A
lift-cos.f64N/A
lower-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
lift-sin.f64N/A
lower-*.f64N/A
lift-cos.f64N/A
lift-sin.f6499.7
Applied rewrites99.7%
Taylor expanded in theta around 0
lift-cos.f6493.3
Applied rewrites93.3%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(if (or (<= theta -16000000000000.0) (not (<= theta 1e-58)))
(+
lambda1
(atan2
(* (* (sin theta) (sin delta)) (cos phi1))
(- (cos delta) (* (sin phi1) (fma (cos theta) (sin delta) (sin phi1))))))
(+
lambda1
(atan2
(* (* theta (sin delta)) (cos phi1))
(-
(cos delta)
(*
(sin phi1)
(fma (cos phi1) (sin delta) (* (sin phi1) (cos delta)))))))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double tmp;
if ((theta <= -16000000000000.0) || !(theta <= 1e-58)) {
tmp = lambda1 + atan2(((sin(theta) * sin(delta)) * cos(phi1)), (cos(delta) - (sin(phi1) * fma(cos(theta), sin(delta), sin(phi1)))));
} else {
tmp = lambda1 + atan2(((theta * sin(delta)) * cos(phi1)), (cos(delta) - (sin(phi1) * fma(cos(phi1), sin(delta), (sin(phi1) * cos(delta))))));
}
return tmp;
}
function code(lambda1, phi1, phi2, delta, theta) tmp = 0.0 if ((theta <= -16000000000000.0) || !(theta <= 1e-58)) tmp = Float64(lambda1 + atan(Float64(Float64(sin(theta) * sin(delta)) * cos(phi1)), Float64(cos(delta) - Float64(sin(phi1) * fma(cos(theta), sin(delta), sin(phi1)))))); else tmp = Float64(lambda1 + atan(Float64(Float64(theta * sin(delta)) * cos(phi1)), Float64(cos(delta) - Float64(sin(phi1) * fma(cos(phi1), sin(delta), Float64(sin(phi1) * cos(delta))))))); end return tmp end
code[lambda1_, phi1_, phi2_, delta_, theta_] := If[Or[LessEqual[theta, -16000000000000.0], N[Not[LessEqual[theta, 1e-58]], $MachinePrecision]], N[(lambda1 + N[ArcTan[N[(N[(N[Sin[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] / N[(N[Cos[delta], $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision] + N[Sin[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(lambda1 + N[ArcTan[N[(N[(theta * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] / N[(N[Cos[delta], $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[(N[Cos[phi1], $MachinePrecision] * N[Sin[delta], $MachinePrecision] + N[(N[Sin[phi1], $MachinePrecision] * N[Cos[delta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;theta \leq -16000000000000 \lor \neg \left(theta \leq 10^{-58}\right):\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{\left(\sin theta \cdot \sin delta\right) \cdot \cos \phi_1}{\cos delta - \sin \phi_1 \cdot \mathsf{fma}\left(\cos theta, \sin delta, \sin \phi_1\right)}\\
\mathbf{else}:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{\left(theta \cdot \sin delta\right) \cdot \cos \phi_1}{\cos delta - \sin \phi_1 \cdot \mathsf{fma}\left(\cos \phi_1, \sin delta, \sin \phi_1 \cdot \cos delta\right)}\\
\end{array}
\end{array}
if theta < -1.6e13 or 1e-58 < theta Initial program 99.7%
lift-sin.f64N/A
lift-asin.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-cos.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
sin-asinN/A
+-commutativeN/A
Applied rewrites99.6%
Taylor expanded in phi1 around 0
lift-cos.f6488.4
Applied rewrites88.4%
Taylor expanded in delta around 0
lift-sin.f6488.1
Applied rewrites88.1%
if -1.6e13 < theta < 1e-58Initial program 99.8%
lift-sin.f64N/A
lift-asin.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-cos.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
sin-asinN/A
+-commutativeN/A
Applied rewrites99.8%
Taylor expanded in phi1 around 0
lift-cos.f6489.2
Applied rewrites89.2%
Taylor expanded in theta around 0
Applied rewrites89.2%
Taylor expanded in theta around 0
lift-cos.f6499.8
Applied rewrites99.8%
Final simplification93.3%
(FPCore (lambda1 phi1 phi2 delta theta) :precision binary64 (+ lambda1 (atan2 (* (sin delta) (* (cos phi1) (sin theta))) (- (cos delta) (pow (sin phi1) 2.0)))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 + atan2((sin(delta) * (cos(phi1) * sin(theta))), (cos(delta) - pow(sin(phi1), 2.0)));
}
module fmin_fmax_functions
implicit none
private
public fmax
public fmin
interface fmax
module procedure fmax88
module procedure fmax44
module procedure fmax84
module procedure fmax48
end interface
interface fmin
module procedure fmin88
module procedure fmin44
module procedure fmin84
module procedure fmin48
end interface
contains
real(8) function fmax88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(4) function fmax44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(8) function fmax84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, max(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmax48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), max(dble(x), y), y /= y), x /= x)
end function
real(8) function fmin88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(4) function fmin44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(8) function fmin84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, min(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmin48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), min(dble(x), y), y /= y), x /= x)
end function
end module
real(8) function code(lambda1, phi1, phi2, delta, theta)
use fmin_fmax_functions
real(8), intent (in) :: lambda1
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8), intent (in) :: delta
real(8), intent (in) :: theta
code = lambda1 + atan2((sin(delta) * (cos(phi1) * sin(theta))), (cos(delta) - (sin(phi1) ** 2.0d0)))
end function
public static double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 + Math.atan2((Math.sin(delta) * (Math.cos(phi1) * Math.sin(theta))), (Math.cos(delta) - Math.pow(Math.sin(phi1), 2.0)));
}
def code(lambda1, phi1, phi2, delta, theta): return lambda1 + math.atan2((math.sin(delta) * (math.cos(phi1) * math.sin(theta))), (math.cos(delta) - math.pow(math.sin(phi1), 2.0)))
function code(lambda1, phi1, phi2, delta, theta) return Float64(lambda1 + atan(Float64(sin(delta) * Float64(cos(phi1) * sin(theta))), Float64(cos(delta) - (sin(phi1) ^ 2.0)))) end
function tmp = code(lambda1, phi1, phi2, delta, theta) tmp = lambda1 + atan2((sin(delta) * (cos(phi1) * sin(theta))), (cos(delta) - (sin(phi1) ^ 2.0))); end
code[lambda1_, phi1_, phi2_, delta_, theta_] := N[(lambda1 + N[ArcTan[N[(N[Sin[delta], $MachinePrecision] * N[(N[Cos[phi1], $MachinePrecision] * N[Sin[theta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[Cos[delta], $MachinePrecision] - N[Power[N[Sin[phi1], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\lambda_1 + \tan^{-1}_* \frac{\sin delta \cdot \left(\cos \phi_1 \cdot \sin theta\right)}{\cos delta - {\sin \phi_1}^{2}}
\end{array}
Initial program 99.7%
lift-sin.f64N/A
lift-asin.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-cos.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
sin-asinN/A
+-commutativeN/A
Applied rewrites99.7%
lift-*.f64N/A
lift-sin.f64N/A
lift-sin.f64N/A
*-commutativeN/A
lift-cos.f64N/A
lower-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
lift-sin.f64N/A
lower-*.f64N/A
lift-cos.f64N/A
lift-sin.f6499.7
Applied rewrites99.7%
Taylor expanded in delta around 0
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
+-commutativeN/A
*-commutativeN/A
lift-sin.f64N/A
lift-pow.f6489.4
Applied rewrites89.4%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(if (or (<= delta -2.25e-5) (not (<= delta 0.00011)))
(+ lambda1 (atan2 (* (* (sin theta) (sin delta)) (cos phi1)) (cos delta)))
(+
lambda1
(atan2 (* (* (cos phi1) delta) (sin theta)) (pow (cos phi1) 2.0)))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double tmp;
if ((delta <= -2.25e-5) || !(delta <= 0.00011)) {
tmp = lambda1 + atan2(((sin(theta) * sin(delta)) * cos(phi1)), cos(delta));
} else {
tmp = lambda1 + atan2(((cos(phi1) * delta) * sin(theta)), pow(cos(phi1), 2.0));
}
return tmp;
}
module fmin_fmax_functions
implicit none
private
public fmax
public fmin
interface fmax
module procedure fmax88
module procedure fmax44
module procedure fmax84
module procedure fmax48
end interface
interface fmin
module procedure fmin88
module procedure fmin44
module procedure fmin84
module procedure fmin48
end interface
contains
real(8) function fmax88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(4) function fmax44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(8) function fmax84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, max(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmax48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), max(dble(x), y), y /= y), x /= x)
end function
real(8) function fmin88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(4) function fmin44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(8) function fmin84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, min(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmin48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), min(dble(x), y), y /= y), x /= x)
end function
end module
real(8) function code(lambda1, phi1, phi2, delta, theta)
use fmin_fmax_functions
real(8), intent (in) :: lambda1
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8), intent (in) :: delta
real(8), intent (in) :: theta
real(8) :: tmp
if ((delta <= (-2.25d-5)) .or. (.not. (delta <= 0.00011d0))) then
tmp = lambda1 + atan2(((sin(theta) * sin(delta)) * cos(phi1)), cos(delta))
else
tmp = lambda1 + atan2(((cos(phi1) * delta) * sin(theta)), (cos(phi1) ** 2.0d0))
end if
code = tmp
end function
public static double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double tmp;
if ((delta <= -2.25e-5) || !(delta <= 0.00011)) {
tmp = lambda1 + Math.atan2(((Math.sin(theta) * Math.sin(delta)) * Math.cos(phi1)), Math.cos(delta));
} else {
tmp = lambda1 + Math.atan2(((Math.cos(phi1) * delta) * Math.sin(theta)), Math.pow(Math.cos(phi1), 2.0));
}
return tmp;
}
def code(lambda1, phi1, phi2, delta, theta): tmp = 0 if (delta <= -2.25e-5) or not (delta <= 0.00011): tmp = lambda1 + math.atan2(((math.sin(theta) * math.sin(delta)) * math.cos(phi1)), math.cos(delta)) else: tmp = lambda1 + math.atan2(((math.cos(phi1) * delta) * math.sin(theta)), math.pow(math.cos(phi1), 2.0)) return tmp
function code(lambda1, phi1, phi2, delta, theta) tmp = 0.0 if ((delta <= -2.25e-5) || !(delta <= 0.00011)) tmp = Float64(lambda1 + atan(Float64(Float64(sin(theta) * sin(delta)) * cos(phi1)), cos(delta))); else tmp = Float64(lambda1 + atan(Float64(Float64(cos(phi1) * delta) * sin(theta)), (cos(phi1) ^ 2.0))); end return tmp end
function tmp_2 = code(lambda1, phi1, phi2, delta, theta) tmp = 0.0; if ((delta <= -2.25e-5) || ~((delta <= 0.00011))) tmp = lambda1 + atan2(((sin(theta) * sin(delta)) * cos(phi1)), cos(delta)); else tmp = lambda1 + atan2(((cos(phi1) * delta) * sin(theta)), (cos(phi1) ^ 2.0)); end tmp_2 = tmp; end
code[lambda1_, phi1_, phi2_, delta_, theta_] := If[Or[LessEqual[delta, -2.25e-5], N[Not[LessEqual[delta, 0.00011]], $MachinePrecision]], N[(lambda1 + N[ArcTan[N[(N[(N[Sin[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] / N[Cos[delta], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(lambda1 + N[ArcTan[N[(N[(N[Cos[phi1], $MachinePrecision] * delta), $MachinePrecision] * N[Sin[theta], $MachinePrecision]), $MachinePrecision] / N[Power[N[Cos[phi1], $MachinePrecision], 2.0], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;delta \leq -2.25 \cdot 10^{-5} \lor \neg \left(delta \leq 0.00011\right):\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{\left(\sin theta \cdot \sin delta\right) \cdot \cos \phi_1}{\cos delta}\\
\mathbf{else}:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{\left(\cos \phi_1 \cdot delta\right) \cdot \sin theta}{{\cos \phi_1}^{2}}\\
\end{array}
\end{array}
if delta < -2.25000000000000014e-5 or 1.10000000000000004e-4 < delta Initial program 99.7%
Taylor expanded in phi1 around 0
lift-cos.f6477.4
Applied rewrites77.4%
if -2.25000000000000014e-5 < delta < 1.10000000000000004e-4Initial program 99.7%
Taylor expanded in delta around 0
unpow2N/A
1-sub-sin-revN/A
pow2N/A
lower-pow.f64N/A
lift-cos.f6498.8
Applied rewrites98.8%
Taylor expanded in delta around 0
associate-*r*N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lift-cos.f64N/A
lift-sin.f6498.8
Applied rewrites98.8%
Final simplification87.7%
(FPCore (lambda1 phi1 phi2 delta theta) :precision binary64 (+ lambda1 (atan2 (* (* (sin theta) (sin delta)) (cos phi1)) (cos delta))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 + atan2(((sin(theta) * sin(delta)) * cos(phi1)), cos(delta));
}
module fmin_fmax_functions
implicit none
private
public fmax
public fmin
interface fmax
module procedure fmax88
module procedure fmax44
module procedure fmax84
module procedure fmax48
end interface
interface fmin
module procedure fmin88
module procedure fmin44
module procedure fmin84
module procedure fmin48
end interface
contains
real(8) function fmax88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(4) function fmax44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(8) function fmax84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, max(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmax48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), max(dble(x), y), y /= y), x /= x)
end function
real(8) function fmin88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(4) function fmin44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(8) function fmin84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, min(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmin48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), min(dble(x), y), y /= y), x /= x)
end function
end module
real(8) function code(lambda1, phi1, phi2, delta, theta)
use fmin_fmax_functions
real(8), intent (in) :: lambda1
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8), intent (in) :: delta
real(8), intent (in) :: theta
code = lambda1 + atan2(((sin(theta) * sin(delta)) * cos(phi1)), cos(delta))
end function
public static double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 + Math.atan2(((Math.sin(theta) * Math.sin(delta)) * Math.cos(phi1)), Math.cos(delta));
}
def code(lambda1, phi1, phi2, delta, theta): return lambda1 + math.atan2(((math.sin(theta) * math.sin(delta)) * math.cos(phi1)), math.cos(delta))
function code(lambda1, phi1, phi2, delta, theta) return Float64(lambda1 + atan(Float64(Float64(sin(theta) * sin(delta)) * cos(phi1)), cos(delta))) end
function tmp = code(lambda1, phi1, phi2, delta, theta) tmp = lambda1 + atan2(((sin(theta) * sin(delta)) * cos(phi1)), cos(delta)); end
code[lambda1_, phi1_, phi2_, delta_, theta_] := N[(lambda1 + N[ArcTan[N[(N[(N[Sin[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] / N[Cos[delta], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\lambda_1 + \tan^{-1}_* \frac{\left(\sin theta \cdot \sin delta\right) \cdot \cos \phi_1}{\cos delta}
\end{array}
Initial program 99.7%
Taylor expanded in phi1 around 0
lift-cos.f6482.7
Applied rewrites82.7%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(let* ((t_1 (* (sin theta) (sin delta))))
(if (<= phi1 -5.5e+64)
(+ lambda1 (atan2 (* t_1 (cos phi1)) (fma (* delta delta) -0.5 1.0)))
(+ lambda1 (atan2 (* t_1 1.0) (cos delta))))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double t_1 = sin(theta) * sin(delta);
double tmp;
if (phi1 <= -5.5e+64) {
tmp = lambda1 + atan2((t_1 * cos(phi1)), fma((delta * delta), -0.5, 1.0));
} else {
tmp = lambda1 + atan2((t_1 * 1.0), cos(delta));
}
return tmp;
}
function code(lambda1, phi1, phi2, delta, theta) t_1 = Float64(sin(theta) * sin(delta)) tmp = 0.0 if (phi1 <= -5.5e+64) tmp = Float64(lambda1 + atan(Float64(t_1 * cos(phi1)), fma(Float64(delta * delta), -0.5, 1.0))); else tmp = Float64(lambda1 + atan(Float64(t_1 * 1.0), cos(delta))); end return tmp end
code[lambda1_, phi1_, phi2_, delta_, theta_] := Block[{t$95$1 = N[(N[Sin[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[phi1, -5.5e+64], N[(lambda1 + N[ArcTan[N[(t$95$1 * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] / N[(N[(delta * delta), $MachinePrecision] * -0.5 + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(lambda1 + N[ArcTan[N[(t$95$1 * 1.0), $MachinePrecision] / N[Cos[delta], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \sin theta \cdot \sin delta\\
\mathbf{if}\;\phi_1 \leq -5.5 \cdot 10^{+64}:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{t\_1 \cdot \cos \phi_1}{\mathsf{fma}\left(delta \cdot delta, -0.5, 1\right)}\\
\mathbf{else}:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{t\_1 \cdot 1}{\cos delta}\\
\end{array}
\end{array}
if phi1 < -5.4999999999999996e64Initial program 99.6%
lift-sin.f64N/A
lift-asin.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-cos.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
sin-asinN/A
+-commutativeN/A
Applied rewrites99.6%
Taylor expanded in phi1 around 0
Applied rewrites62.9%
Taylor expanded in delta around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6467.7
Applied rewrites67.7%
if -5.4999999999999996e64 < phi1 Initial program 99.8%
lift-sin.f64N/A
lift-asin.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-cos.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
sin-asinN/A
+-commutativeN/A
Applied rewrites99.7%
Taylor expanded in phi1 around 0
Applied rewrites87.4%
Taylor expanded in phi1 around 0
Applied rewrites85.9%
Final simplification82.4%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(if (<= delta -66000000.0)
(+ lambda1 (atan2 (* (* theta (sin delta)) 1.0) (cos delta)))
(if (<= delta 0.000118)
(+ lambda1 (atan2 (* (* (sin theta) delta) (cos phi1)) (cos delta)))
(+ lambda1 (atan2 (* theta (* (cos phi1) (sin delta))) (cos delta))))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double tmp;
if (delta <= -66000000.0) {
tmp = lambda1 + atan2(((theta * sin(delta)) * 1.0), cos(delta));
} else if (delta <= 0.000118) {
tmp = lambda1 + atan2(((sin(theta) * delta) * cos(phi1)), cos(delta));
} else {
tmp = lambda1 + atan2((theta * (cos(phi1) * sin(delta))), cos(delta));
}
return tmp;
}
module fmin_fmax_functions
implicit none
private
public fmax
public fmin
interface fmax
module procedure fmax88
module procedure fmax44
module procedure fmax84
module procedure fmax48
end interface
interface fmin
module procedure fmin88
module procedure fmin44
module procedure fmin84
module procedure fmin48
end interface
contains
real(8) function fmax88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(4) function fmax44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(8) function fmax84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, max(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmax48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), max(dble(x), y), y /= y), x /= x)
end function
real(8) function fmin88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(4) function fmin44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(8) function fmin84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, min(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmin48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), min(dble(x), y), y /= y), x /= x)
end function
end module
real(8) function code(lambda1, phi1, phi2, delta, theta)
use fmin_fmax_functions
real(8), intent (in) :: lambda1
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8), intent (in) :: delta
real(8), intent (in) :: theta
real(8) :: tmp
if (delta <= (-66000000.0d0)) then
tmp = lambda1 + atan2(((theta * sin(delta)) * 1.0d0), cos(delta))
else if (delta <= 0.000118d0) then
tmp = lambda1 + atan2(((sin(theta) * delta) * cos(phi1)), cos(delta))
else
tmp = lambda1 + atan2((theta * (cos(phi1) * sin(delta))), cos(delta))
end if
code = tmp
end function
public static double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double tmp;
if (delta <= -66000000.0) {
tmp = lambda1 + Math.atan2(((theta * Math.sin(delta)) * 1.0), Math.cos(delta));
} else if (delta <= 0.000118) {
tmp = lambda1 + Math.atan2(((Math.sin(theta) * delta) * Math.cos(phi1)), Math.cos(delta));
} else {
tmp = lambda1 + Math.atan2((theta * (Math.cos(phi1) * Math.sin(delta))), Math.cos(delta));
}
return tmp;
}
def code(lambda1, phi1, phi2, delta, theta): tmp = 0 if delta <= -66000000.0: tmp = lambda1 + math.atan2(((theta * math.sin(delta)) * 1.0), math.cos(delta)) elif delta <= 0.000118: tmp = lambda1 + math.atan2(((math.sin(theta) * delta) * math.cos(phi1)), math.cos(delta)) else: tmp = lambda1 + math.atan2((theta * (math.cos(phi1) * math.sin(delta))), math.cos(delta)) return tmp
function code(lambda1, phi1, phi2, delta, theta) tmp = 0.0 if (delta <= -66000000.0) tmp = Float64(lambda1 + atan(Float64(Float64(theta * sin(delta)) * 1.0), cos(delta))); elseif (delta <= 0.000118) tmp = Float64(lambda1 + atan(Float64(Float64(sin(theta) * delta) * cos(phi1)), cos(delta))); else tmp = Float64(lambda1 + atan(Float64(theta * Float64(cos(phi1) * sin(delta))), cos(delta))); end return tmp end
function tmp_2 = code(lambda1, phi1, phi2, delta, theta) tmp = 0.0; if (delta <= -66000000.0) tmp = lambda1 + atan2(((theta * sin(delta)) * 1.0), cos(delta)); elseif (delta <= 0.000118) tmp = lambda1 + atan2(((sin(theta) * delta) * cos(phi1)), cos(delta)); else tmp = lambda1 + atan2((theta * (cos(phi1) * sin(delta))), cos(delta)); end tmp_2 = tmp; end
code[lambda1_, phi1_, phi2_, delta_, theta_] := If[LessEqual[delta, -66000000.0], N[(lambda1 + N[ArcTan[N[(N[(theta * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * 1.0), $MachinePrecision] / N[Cos[delta], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[delta, 0.000118], N[(lambda1 + N[ArcTan[N[(N[(N[Sin[theta], $MachinePrecision] * delta), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] / N[Cos[delta], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(lambda1 + N[ArcTan[N[(theta * N[(N[Cos[phi1], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Cos[delta], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;delta \leq -66000000:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{\left(theta \cdot \sin delta\right) \cdot 1}{\cos delta}\\
\mathbf{elif}\;delta \leq 0.000118:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{\left(\sin theta \cdot delta\right) \cdot \cos \phi_1}{\cos delta}\\
\mathbf{else}:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{theta \cdot \left(\cos \phi_1 \cdot \sin delta\right)}{\cos delta}\\
\end{array}
\end{array}
if delta < -6.6e7Initial program 99.7%
lift-sin.f64N/A
lift-asin.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-cos.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
sin-asinN/A
+-commutativeN/A
Applied rewrites99.7%
Taylor expanded in phi1 around 0
Applied rewrites77.1%
Taylor expanded in theta around 0
Applied rewrites69.7%
Taylor expanded in phi1 around 0
Applied rewrites70.0%
if -6.6e7 < delta < 1.18e-4Initial program 99.7%
lift-sin.f64N/A
lift-asin.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-cos.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
sin-asinN/A
+-commutativeN/A
Applied rewrites99.7%
Taylor expanded in phi1 around 0
Applied rewrites88.6%
Taylor expanded in delta around 0
Applied rewrites88.6%
if 1.18e-4 < delta Initial program 99.7%
lift-sin.f64N/A
lift-asin.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-cos.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
sin-asinN/A
+-commutativeN/A
Applied rewrites99.7%
Taylor expanded in phi1 around 0
Applied rewrites77.0%
Taylor expanded in theta around 0
Applied rewrites67.4%
lift-*.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
lift-cos.f64N/A
lift-sin.f64N/A
lift-*.f6467.4
Applied rewrites67.4%
Final simplification78.4%
(FPCore (lambda1 phi1 phi2 delta theta) :precision binary64 (if (or (<= delta -4.3e-72) (not (<= delta 3.6e-93))) (+ lambda1 (atan2 (* (* theta (sin delta)) 1.0) (cos delta))) lambda1))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double tmp;
if ((delta <= -4.3e-72) || !(delta <= 3.6e-93)) {
tmp = lambda1 + atan2(((theta * sin(delta)) * 1.0), cos(delta));
} else {
tmp = lambda1;
}
return tmp;
}
module fmin_fmax_functions
implicit none
private
public fmax
public fmin
interface fmax
module procedure fmax88
module procedure fmax44
module procedure fmax84
module procedure fmax48
end interface
interface fmin
module procedure fmin88
module procedure fmin44
module procedure fmin84
module procedure fmin48
end interface
contains
real(8) function fmax88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(4) function fmax44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(8) function fmax84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, max(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmax48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), max(dble(x), y), y /= y), x /= x)
end function
real(8) function fmin88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(4) function fmin44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(8) function fmin84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, min(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmin48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), min(dble(x), y), y /= y), x /= x)
end function
end module
real(8) function code(lambda1, phi1, phi2, delta, theta)
use fmin_fmax_functions
real(8), intent (in) :: lambda1
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8), intent (in) :: delta
real(8), intent (in) :: theta
real(8) :: tmp
if ((delta <= (-4.3d-72)) .or. (.not. (delta <= 3.6d-93))) then
tmp = lambda1 + atan2(((theta * sin(delta)) * 1.0d0), cos(delta))
else
tmp = lambda1
end if
code = tmp
end function
public static double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double tmp;
if ((delta <= -4.3e-72) || !(delta <= 3.6e-93)) {
tmp = lambda1 + Math.atan2(((theta * Math.sin(delta)) * 1.0), Math.cos(delta));
} else {
tmp = lambda1;
}
return tmp;
}
def code(lambda1, phi1, phi2, delta, theta): tmp = 0 if (delta <= -4.3e-72) or not (delta <= 3.6e-93): tmp = lambda1 + math.atan2(((theta * math.sin(delta)) * 1.0), math.cos(delta)) else: tmp = lambda1 return tmp
function code(lambda1, phi1, phi2, delta, theta) tmp = 0.0 if ((delta <= -4.3e-72) || !(delta <= 3.6e-93)) tmp = Float64(lambda1 + atan(Float64(Float64(theta * sin(delta)) * 1.0), cos(delta))); else tmp = lambda1; end return tmp end
function tmp_2 = code(lambda1, phi1, phi2, delta, theta) tmp = 0.0; if ((delta <= -4.3e-72) || ~((delta <= 3.6e-93))) tmp = lambda1 + atan2(((theta * sin(delta)) * 1.0), cos(delta)); else tmp = lambda1; end tmp_2 = tmp; end
code[lambda1_, phi1_, phi2_, delta_, theta_] := If[Or[LessEqual[delta, -4.3e-72], N[Not[LessEqual[delta, 3.6e-93]], $MachinePrecision]], N[(lambda1 + N[ArcTan[N[(N[(theta * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * 1.0), $MachinePrecision] / N[Cos[delta], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], lambda1]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;delta \leq -4.3 \cdot 10^{-72} \lor \neg \left(delta \leq 3.6 \cdot 10^{-93}\right):\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{\left(theta \cdot \sin delta\right) \cdot 1}{\cos delta}\\
\mathbf{else}:\\
\;\;\;\;\lambda_1\\
\end{array}
\end{array}
if delta < -4.2999999999999999e-72 or 3.6000000000000002e-93 < delta Initial program 99.6%
lift-sin.f64N/A
lift-asin.f64N/A
lift-+.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-cos.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
sin-asinN/A
+-commutativeN/A
Applied rewrites99.6%
Taylor expanded in phi1 around 0
Applied rewrites76.4%
Taylor expanded in theta around 0
Applied rewrites65.9%
Taylor expanded in phi1 around 0
Applied rewrites63.7%
if -4.2999999999999999e-72 < delta < 3.6000000000000002e-93Initial program 99.9%
Taylor expanded in lambda1 around inf
Applied rewrites85.0%
Final simplification71.9%
(FPCore (lambda1 phi1 phi2 delta theta) :precision binary64 lambda1)
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1;
}
module fmin_fmax_functions
implicit none
private
public fmax
public fmin
interface fmax
module procedure fmax88
module procedure fmax44
module procedure fmax84
module procedure fmax48
end interface
interface fmin
module procedure fmin88
module procedure fmin44
module procedure fmin84
module procedure fmin48
end interface
contains
real(8) function fmax88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(4) function fmax44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, max(x, y), y /= y), x /= x)
end function
real(8) function fmax84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, max(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmax48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), max(dble(x), y), y /= y), x /= x)
end function
real(8) function fmin88(x, y) result (res)
real(8), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(4) function fmin44(x, y) result (res)
real(4), intent (in) :: x
real(4), intent (in) :: y
res = merge(y, merge(x, min(x, y), y /= y), x /= x)
end function
real(8) function fmin84(x, y) result(res)
real(8), intent (in) :: x
real(4), intent (in) :: y
res = merge(dble(y), merge(x, min(x, dble(y)), y /= y), x /= x)
end function
real(8) function fmin48(x, y) result(res)
real(4), intent (in) :: x
real(8), intent (in) :: y
res = merge(y, merge(dble(x), min(dble(x), y), y /= y), x /= x)
end function
end module
real(8) function code(lambda1, phi1, phi2, delta, theta)
use fmin_fmax_functions
real(8), intent (in) :: lambda1
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8), intent (in) :: delta
real(8), intent (in) :: theta
code = lambda1
end function
public static double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1;
}
def code(lambda1, phi1, phi2, delta, theta): return lambda1
function code(lambda1, phi1, phi2, delta, theta) return lambda1 end
function tmp = code(lambda1, phi1, phi2, delta, theta) tmp = lambda1; end
code[lambda1_, phi1_, phi2_, delta_, theta_] := lambda1
\begin{array}{l}
\\
\lambda_1
\end{array}
Initial program 99.7%
Taylor expanded in lambda1 around inf
Applied rewrites62.6%
herbie shell --seed 2025075
(FPCore (lambda1 phi1 phi2 delta theta)
:name "Destination given bearing on a great circle"
:precision binary64
(+ lambda1 (atan2 (* (* (sin theta) (sin delta)) (cos phi1)) (- (cos delta) (* (sin phi1) (sin (asin (+ (* (sin phi1) (cos delta)) (* (* (cos phi1) (sin delta)) (cos theta))))))))))