
(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}
Herbie found 23 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
(let* ((t_1
(*
(fma
(sin phi1)
(cos delta)
(* (cos theta) (* (sin delta) (cos phi1))))
(sin phi1))))
(+
lambda1
(atan2
(*
(* (sin theta) (sin delta))
(fma (sin phi1) (cos (/ PI 2.0)) (* (cos phi1) (sin (/ PI 2.0)))))
(/
(- (pow (cos delta) 3.0) (pow t_1 3.0))
(fma (cos delta) (cos delta) (fma t_1 t_1 (* (cos delta) t_1))))))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double t_1 = fma(sin(phi1), cos(delta), (cos(theta) * (sin(delta) * cos(phi1)))) * sin(phi1);
return lambda1 + atan2(((sin(theta) * sin(delta)) * fma(sin(phi1), cos((((double) M_PI) / 2.0)), (cos(phi1) * sin((((double) M_PI) / 2.0))))), ((pow(cos(delta), 3.0) - pow(t_1, 3.0)) / fma(cos(delta), cos(delta), fma(t_1, t_1, (cos(delta) * t_1)))));
}
function code(lambda1, phi1, phi2, delta, theta) t_1 = Float64(fma(sin(phi1), cos(delta), Float64(cos(theta) * Float64(sin(delta) * cos(phi1)))) * sin(phi1)) return Float64(lambda1 + atan(Float64(Float64(sin(theta) * sin(delta)) * fma(sin(phi1), cos(Float64(pi / 2.0)), Float64(cos(phi1) * sin(Float64(pi / 2.0))))), Float64(Float64((cos(delta) ^ 3.0) - (t_1 ^ 3.0)) / fma(cos(delta), cos(delta), fma(t_1, t_1, Float64(cos(delta) * t_1)))))) end
code[lambda1_, phi1_, phi2_, delta_, theta_] := Block[{t$95$1 = N[(N[(N[Sin[phi1], $MachinePrecision] * N[Cos[delta], $MachinePrecision] + N[(N[Cos[theta], $MachinePrecision] * N[(N[Sin[delta], $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision]}, N[(lambda1 + N[ArcTan[N[(N[(N[Sin[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[(N[Sin[phi1], $MachinePrecision] * N[Cos[N[(Pi / 2.0), $MachinePrecision]], $MachinePrecision] + N[(N[Cos[phi1], $MachinePrecision] * N[Sin[N[(Pi / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(N[Power[N[Cos[delta], $MachinePrecision], 3.0], $MachinePrecision] - N[Power[t$95$1, 3.0], $MachinePrecision]), $MachinePrecision] / N[(N[Cos[delta], $MachinePrecision] * N[Cos[delta], $MachinePrecision] + N[(t$95$1 * t$95$1 + N[(N[Cos[delta], $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(\sin \phi_1, \cos delta, \cos theta \cdot \left(\sin delta \cdot \cos \phi_1\right)\right) \cdot \sin \phi_1\\
\lambda_1 + \tan^{-1}_* \frac{\left(\sin theta \cdot \sin delta\right) \cdot \mathsf{fma}\left(\sin \phi_1, \cos \left(\frac{\pi}{2}\right), \cos \phi_1 \cdot \sin \left(\frac{\pi}{2}\right)\right)}{\frac{{\cos delta}^{3} - {t\_1}^{3}}{\mathsf{fma}\left(\cos delta, \cos delta, \mathsf{fma}\left(t\_1, t\_1, \cos delta \cdot t\_1\right)\right)}}
\end{array}
\end{array}
Initial program 99.8%
lift-cos.f64N/A
sin-+PI/2-revN/A
sin-sumN/A
lower-fma.f64N/A
lift-sin.f64N/A
lower-cos.f64N/A
lower-/.f64N/A
lower-PI.f64N/A
lower-*.f64N/A
lift-cos.f64N/A
lower-sin.f64N/A
lower-/.f64N/A
lower-PI.f6499.8
Applied rewrites99.8%
lift-cos.f64N/A
sin-+PI/2-revN/A
sin-sumN/A
lower-fma.f64N/A
lift-sin.f64N/A
lower-cos.f64N/A
lower-/.f64N/A
lower-PI.f64N/A
lower-*.f64N/A
lift-cos.f64N/A
lower-sin.f64N/A
lower-/.f64N/A
lower-PI.f6499.8
Applied rewrites99.8%
Applied rewrites99.8%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(let* ((t_1
(fma (sin phi1) (cos (/ PI 2.0)) (* (cos phi1) (sin (/ PI 2.0))))))
(+
lambda1
(atan2
(* (* (sin theta) (sin delta)) t_1)
(-
(cos delta)
(*
(sin phi1)
(sin
(asin
(+
(* (sin phi1) (cos delta))
(* (* t_1 (sin delta)) (cos theta)))))))))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double t_1 = fma(sin(phi1), cos((((double) M_PI) / 2.0)), (cos(phi1) * sin((((double) M_PI) / 2.0))));
return lambda1 + atan2(((sin(theta) * sin(delta)) * t_1), (cos(delta) - (sin(phi1) * sin(asin(((sin(phi1) * cos(delta)) + ((t_1 * sin(delta)) * cos(theta))))))));
}
function code(lambda1, phi1, phi2, delta, theta) t_1 = fma(sin(phi1), cos(Float64(pi / 2.0)), Float64(cos(phi1) * sin(Float64(pi / 2.0)))) return Float64(lambda1 + atan(Float64(Float64(sin(theta) * sin(delta)) * t_1), Float64(cos(delta) - Float64(sin(phi1) * sin(asin(Float64(Float64(sin(phi1) * cos(delta)) + Float64(Float64(t_1 * sin(delta)) * cos(theta))))))))) end
code[lambda1_, phi1_, phi2_, delta_, theta_] := Block[{t$95$1 = N[(N[Sin[phi1], $MachinePrecision] * N[Cos[N[(Pi / 2.0), $MachinePrecision]], $MachinePrecision] + N[(N[Cos[phi1], $MachinePrecision] * N[Sin[N[(Pi / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, N[(lambda1 + N[ArcTan[N[(N[(N[Sin[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * t$95$1), $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[(t$95$1 * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[theta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \mathsf{fma}\left(\sin \phi_1, \cos \left(\frac{\pi}{2}\right), \cos \phi_1 \cdot \sin \left(\frac{\pi}{2}\right)\right)\\
\lambda_1 + \tan^{-1}_* \frac{\left(\sin theta \cdot \sin delta\right) \cdot t\_1}{\cos delta - \sin \phi_1 \cdot \sin \sin^{-1} \left(\sin \phi_1 \cdot \cos delta + \left(t\_1 \cdot \sin delta\right) \cdot \cos theta\right)}
\end{array}
\end{array}
Initial program 99.8%
lift-cos.f64N/A
sin-+PI/2-revN/A
sin-sumN/A
lower-fma.f64N/A
lift-sin.f64N/A
lower-cos.f64N/A
lower-/.f64N/A
lower-PI.f64N/A
lower-*.f64N/A
lift-cos.f64N/A
lower-sin.f64N/A
lower-/.f64N/A
lower-PI.f6499.8
Applied rewrites99.8%
lift-cos.f64N/A
sin-+PI/2-revN/A
sin-sumN/A
lower-fma.f64N/A
lift-sin.f64N/A
lower-cos.f64N/A
lower-/.f64N/A
lower-PI.f64N/A
lower-*.f64N/A
lift-cos.f64N/A
lower-sin.f64N/A
lower-/.f64N/A
lower-PI.f6499.8
Applied rewrites99.8%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(+
lambda1
(atan2
(*
(* (sin theta) (sin delta))
(fma (sin phi1) (cos (/ PI 2.0)) (* (cos phi1) (sin (/ PI 2.0)))))
(-
(cos delta)
(*
(fma (sin phi1) (cos delta) (* (cos theta) (* (sin delta) (cos phi1))))
(sin phi1))))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 + atan2(((sin(theta) * sin(delta)) * fma(sin(phi1), cos((((double) M_PI) / 2.0)), (cos(phi1) * sin((((double) M_PI) / 2.0))))), (cos(delta) - (fma(sin(phi1), cos(delta), (cos(theta) * (sin(delta) * cos(phi1)))) * sin(phi1))));
}
function code(lambda1, phi1, phi2, delta, theta) return Float64(lambda1 + atan(Float64(Float64(sin(theta) * sin(delta)) * fma(sin(phi1), cos(Float64(pi / 2.0)), Float64(cos(phi1) * sin(Float64(pi / 2.0))))), Float64(cos(delta) - Float64(fma(sin(phi1), cos(delta), Float64(cos(theta) * Float64(sin(delta) * cos(phi1)))) * sin(phi1))))) end
code[lambda1_, phi1_, phi2_, delta_, theta_] := N[(lambda1 + N[ArcTan[N[(N[(N[Sin[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[(N[Sin[phi1], $MachinePrecision] * N[Cos[N[(Pi / 2.0), $MachinePrecision]], $MachinePrecision] + N[(N[Cos[phi1], $MachinePrecision] * N[Sin[N[(Pi / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[Cos[delta], $MachinePrecision] - N[(N[(N[Sin[phi1], $MachinePrecision] * N[Cos[delta], $MachinePrecision] + N[(N[Cos[theta], $MachinePrecision] * N[(N[Sin[delta], $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\lambda_1 + \tan^{-1}_* \frac{\left(\sin theta \cdot \sin delta\right) \cdot \mathsf{fma}\left(\sin \phi_1, \cos \left(\frac{\pi}{2}\right), \cos \phi_1 \cdot \sin \left(\frac{\pi}{2}\right)\right)}{\cos delta - \mathsf{fma}\left(\sin \phi_1, \cos delta, \cos theta \cdot \left(\sin delta \cdot \cos \phi_1\right)\right) \cdot \sin \phi_1}
\end{array}
Initial program 99.8%
lift-cos.f64N/A
sin-+PI/2-revN/A
sin-sumN/A
lower-fma.f64N/A
lift-sin.f64N/A
lower-cos.f64N/A
lower-/.f64N/A
lower-PI.f64N/A
lower-*.f64N/A
lift-cos.f64N/A
lower-sin.f64N/A
lower-/.f64N/A
lower-PI.f6499.8
Applied rewrites99.8%
lift-cos.f64N/A
sin-+PI/2-revN/A
sin-sumN/A
lower-fma.f64N/A
lift-sin.f64N/A
lower-cos.f64N/A
lower-/.f64N/A
lower-PI.f64N/A
lower-*.f64N/A
lift-cos.f64N/A
lower-sin.f64N/A
lower-/.f64N/A
lower-PI.f6499.8
Applied rewrites99.8%
Applied rewrites99.8%
(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(cos(theta), Float64(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[theta], $MachinePrecision] * N[(N[Cos[phi1], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $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, \cos \phi_1 \cdot \sin delta, \sin \phi_1 \cdot \cos delta\right)}
\end{array}
Initial program 99.8%
lift-sin.f64N/A
lift-asin.f64N/A
sin-asin99.8
lift-+.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
lift-cos.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
Applied rewrites99.8%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(let* ((t_1 (* (sin phi1) (cos delta)))
(t_2 (* (* (sin theta) (sin delta)) (cos phi1)))
(t_3
(+
lambda1
(atan2
t_2
(-
(cos delta)
(*
(sin phi1)
(sin
(asin (+ t_1 (* (* (cos phi1) (sin delta)) (cos theta)))))))))))
(if (<= t_3 -3.145)
(+
lambda1
(atan2 t_2 (- (cos delta) (* (sin phi1) (sin (+ delta phi1))))))
(if (<= t_3 -0.05)
(atan2
t_2
(-
(cos delta)
(* (+ t_1 (* (cos theta) (* (sin delta) (cos phi1)))) (sin phi1))))
(+
lambda1
(atan2
t_2
(- (cos delta) (* (fma (sin delta) (cos phi1) t_1) (sin phi1)))))))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double t_1 = sin(phi1) * cos(delta);
double t_2 = (sin(theta) * sin(delta)) * cos(phi1);
double t_3 = lambda1 + atan2(t_2, (cos(delta) - (sin(phi1) * sin(asin((t_1 + ((cos(phi1) * sin(delta)) * cos(theta))))))));
double tmp;
if (t_3 <= -3.145) {
tmp = lambda1 + atan2(t_2, (cos(delta) - (sin(phi1) * sin((delta + phi1)))));
} else if (t_3 <= -0.05) {
tmp = atan2(t_2, (cos(delta) - ((t_1 + (cos(theta) * (sin(delta) * cos(phi1)))) * sin(phi1))));
} else {
tmp = lambda1 + atan2(t_2, (cos(delta) - (fma(sin(delta), cos(phi1), t_1) * sin(phi1))));
}
return tmp;
}
function code(lambda1, phi1, phi2, delta, theta) t_1 = Float64(sin(phi1) * cos(delta)) t_2 = Float64(Float64(sin(theta) * sin(delta)) * cos(phi1)) t_3 = Float64(lambda1 + atan(t_2, Float64(cos(delta) - Float64(sin(phi1) * sin(asin(Float64(t_1 + Float64(Float64(cos(phi1) * sin(delta)) * cos(theta))))))))) tmp = 0.0 if (t_3 <= -3.145) tmp = Float64(lambda1 + atan(t_2, Float64(cos(delta) - Float64(sin(phi1) * sin(Float64(delta + phi1)))))); elseif (t_3 <= -0.05) tmp = atan(t_2, Float64(cos(delta) - Float64(Float64(t_1 + Float64(cos(theta) * Float64(sin(delta) * cos(phi1)))) * sin(phi1)))); else tmp = Float64(lambda1 + atan(t_2, Float64(cos(delta) - Float64(fma(sin(delta), cos(phi1), t_1) * sin(phi1))))); 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[(N[Sin[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(lambda1 + N[ArcTan[t$95$2 / 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$3, -3.145], N[(lambda1 + N[ArcTan[t$95$2 / N[(N[Cos[delta], $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[Sin[N[(delta + phi1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, -0.05], N[ArcTan[t$95$2 / N[(N[Cos[delta], $MachinePrecision] - N[(N[(t$95$1 + N[(N[Cos[theta], $MachinePrecision] * N[(N[Sin[delta], $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(lambda1 + N[ArcTan[t$95$2 / N[(N[Cos[delta], $MachinePrecision] - N[(N[(N[Sin[delta], $MachinePrecision] * N[Cos[phi1], $MachinePrecision] + t$95$1), $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \sin \phi_1 \cdot \cos delta\\
t_2 := \left(\sin theta \cdot \sin delta\right) \cdot \cos \phi_1\\
t_3 := \lambda_1 + \tan^{-1}_* \frac{t\_2}{\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\_3 \leq -3.145:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{t\_2}{\cos delta - \sin \phi_1 \cdot \sin \left(delta + \phi_1\right)}\\
\mathbf{elif}\;t\_3 \leq -0.05:\\
\;\;\;\;\tan^{-1}_* \frac{t\_2}{\cos delta - \left(t\_1 + \cos theta \cdot \left(\sin delta \cdot \cos \phi_1\right)\right) \cdot \sin \phi_1}\\
\mathbf{else}:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{t\_2}{\cos delta - \mathsf{fma}\left(\sin delta, \cos \phi_1, t\_1\right) \cdot \sin \phi_1}\\
\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.14500000000000002Initial program 99.8%
Taylor expanded in theta around 0
+-commutativeN/A
*-commutativeN/A
sin-sum-revN/A
lower-sin.f64N/A
lower-+.f6492.2
Applied rewrites92.2%
if -3.14500000000000002 < (+.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.8%
Taylor expanded in phi1 around 0
lift-cos.f6489.0
Applied rewrites89.0%
Taylor expanded in lambda1 around 0
Applied rewrites31.4%
lift-cos.f64N/A
lift-fma.f64N/A
lift-sin.f64N/A
lift-*.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
lower-+.f64N/A
lower-*.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
lift-cos.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-*.f6431.4
Applied rewrites31.4%
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.8%
Taylor expanded in phi1 around 0
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lift-cos.f64N/A
lift-sin.f6485.0
Applied rewrites85.0%
Taylor expanded in theta around 0
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
*-commutativeN/A
lift-sin.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-sin.f6494.7
Applied rewrites94.7%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(let* ((t_1 (* (sin phi1) (cos delta)))
(t_2 (* (* (sin theta) (sin delta)) (cos phi1)))
(t_3
(+
lambda1
(atan2
t_2
(-
(cos delta)
(*
(sin phi1)
(sin
(asin (+ t_1 (* (* (cos phi1) (sin delta)) (cos theta)))))))))))
(if (<= t_3 -3.145)
(+
lambda1
(atan2 t_2 (- (cos delta) (* (sin phi1) (sin (+ delta phi1))))))
(if (<= t_3 -0.05)
(atan2
t_2
(-
(cos delta)
(*
(fma
(sin phi1)
(cos delta)
(* (cos phi1) (* (cos theta) (sin delta))))
(sin phi1))))
(+
lambda1
(atan2
t_2
(- (cos delta) (* (fma (sin delta) (cos phi1) t_1) (sin phi1)))))))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double t_1 = sin(phi1) * cos(delta);
double t_2 = (sin(theta) * sin(delta)) * cos(phi1);
double t_3 = lambda1 + atan2(t_2, (cos(delta) - (sin(phi1) * sin(asin((t_1 + ((cos(phi1) * sin(delta)) * cos(theta))))))));
double tmp;
if (t_3 <= -3.145) {
tmp = lambda1 + atan2(t_2, (cos(delta) - (sin(phi1) * sin((delta + phi1)))));
} else if (t_3 <= -0.05) {
tmp = atan2(t_2, (cos(delta) - (fma(sin(phi1), cos(delta), (cos(phi1) * (cos(theta) * sin(delta)))) * sin(phi1))));
} else {
tmp = lambda1 + atan2(t_2, (cos(delta) - (fma(sin(delta), cos(phi1), t_1) * sin(phi1))));
}
return tmp;
}
function code(lambda1, phi1, phi2, delta, theta) t_1 = Float64(sin(phi1) * cos(delta)) t_2 = Float64(Float64(sin(theta) * sin(delta)) * cos(phi1)) t_3 = Float64(lambda1 + atan(t_2, Float64(cos(delta) - Float64(sin(phi1) * sin(asin(Float64(t_1 + Float64(Float64(cos(phi1) * sin(delta)) * cos(theta))))))))) tmp = 0.0 if (t_3 <= -3.145) tmp = Float64(lambda1 + atan(t_2, Float64(cos(delta) - Float64(sin(phi1) * sin(Float64(delta + phi1)))))); elseif (t_3 <= -0.05) tmp = atan(t_2, Float64(cos(delta) - Float64(fma(sin(phi1), cos(delta), Float64(cos(phi1) * Float64(cos(theta) * sin(delta)))) * sin(phi1)))); else tmp = Float64(lambda1 + atan(t_2, Float64(cos(delta) - Float64(fma(sin(delta), cos(phi1), t_1) * sin(phi1))))); 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[(N[Sin[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(lambda1 + N[ArcTan[t$95$2 / 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$3, -3.145], N[(lambda1 + N[ArcTan[t$95$2 / N[(N[Cos[delta], $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[Sin[N[(delta + phi1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, -0.05], N[ArcTan[t$95$2 / N[(N[Cos[delta], $MachinePrecision] - N[(N[(N[Sin[phi1], $MachinePrecision] * N[Cos[delta], $MachinePrecision] + N[(N[Cos[phi1], $MachinePrecision] * N[(N[Cos[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(lambda1 + N[ArcTan[t$95$2 / N[(N[Cos[delta], $MachinePrecision] - N[(N[(N[Sin[delta], $MachinePrecision] * N[Cos[phi1], $MachinePrecision] + t$95$1), $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \sin \phi_1 \cdot \cos delta\\
t_2 := \left(\sin theta \cdot \sin delta\right) \cdot \cos \phi_1\\
t_3 := \lambda_1 + \tan^{-1}_* \frac{t\_2}{\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\_3 \leq -3.145:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{t\_2}{\cos delta - \sin \phi_1 \cdot \sin \left(delta + \phi_1\right)}\\
\mathbf{elif}\;t\_3 \leq -0.05:\\
\;\;\;\;\tan^{-1}_* \frac{t\_2}{\cos delta - \mathsf{fma}\left(\sin \phi_1, \cos delta, \cos \phi_1 \cdot \left(\cos theta \cdot \sin delta\right)\right) \cdot \sin \phi_1}\\
\mathbf{else}:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{t\_2}{\cos delta - \mathsf{fma}\left(\sin delta, \cos \phi_1, t\_1\right) \cdot \sin \phi_1}\\
\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.14500000000000002Initial program 99.8%
Taylor expanded in theta around 0
+-commutativeN/A
*-commutativeN/A
sin-sum-revN/A
lower-sin.f64N/A
lower-+.f6492.2
Applied rewrites92.2%
if -3.14500000000000002 < (+.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.8%
Taylor expanded in phi1 around 0
lift-cos.f6489.0
Applied rewrites89.0%
Taylor expanded in lambda1 around 0
Applied rewrites31.4%
Taylor expanded in phi1 around inf
lower-*.f64N/A
lift-cos.f64N/A
lift-cos.f64N/A
lift-sin.f64N/A
lift-*.f6431.4
Applied rewrites31.4%
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.8%
Taylor expanded in phi1 around 0
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lift-cos.f64N/A
lift-sin.f6485.0
Applied rewrites85.0%
Taylor expanded in theta around 0
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
*-commutativeN/A
lift-sin.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-sin.f6494.7
Applied rewrites94.7%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(let* ((t_1 (* (sin phi1) (cos delta)))
(t_2 (* (* (sin theta) (sin delta)) (cos phi1)))
(t_3 (* (cos phi1) (sin delta)))
(t_4
(+
lambda1
(atan2
t_2
(-
(cos delta)
(* (sin phi1) (sin (asin (+ t_1 (* t_3 (cos theta)))))))))))
(if (<= t_4 -3.145)
(+
lambda1
(atan2 t_2 (- (cos delta) (* (sin phi1) (sin (+ delta phi1))))))
(if (<= t_4 -0.05)
(atan2
(* (* (sin delta) (sin theta)) (cos phi1))
(-
(cos delta)
(* (fma (sin phi1) (cos delta) (* (cos theta) t_3)) (sin phi1))))
(+
lambda1
(atan2
t_2
(- (cos delta) (* (fma (sin delta) (cos phi1) t_1) (sin phi1)))))))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double t_1 = sin(phi1) * cos(delta);
double t_2 = (sin(theta) * sin(delta)) * cos(phi1);
double t_3 = cos(phi1) * sin(delta);
double t_4 = lambda1 + atan2(t_2, (cos(delta) - (sin(phi1) * sin(asin((t_1 + (t_3 * cos(theta))))))));
double tmp;
if (t_4 <= -3.145) {
tmp = lambda1 + atan2(t_2, (cos(delta) - (sin(phi1) * sin((delta + phi1)))));
} else if (t_4 <= -0.05) {
tmp = atan2(((sin(delta) * sin(theta)) * cos(phi1)), (cos(delta) - (fma(sin(phi1), cos(delta), (cos(theta) * t_3)) * sin(phi1))));
} else {
tmp = lambda1 + atan2(t_2, (cos(delta) - (fma(sin(delta), cos(phi1), t_1) * sin(phi1))));
}
return tmp;
}
function code(lambda1, phi1, phi2, delta, theta) t_1 = Float64(sin(phi1) * cos(delta)) t_2 = Float64(Float64(sin(theta) * sin(delta)) * cos(phi1)) t_3 = Float64(cos(phi1) * sin(delta)) t_4 = Float64(lambda1 + atan(t_2, Float64(cos(delta) - Float64(sin(phi1) * sin(asin(Float64(t_1 + Float64(t_3 * cos(theta))))))))) tmp = 0.0 if (t_4 <= -3.145) tmp = Float64(lambda1 + atan(t_2, Float64(cos(delta) - Float64(sin(phi1) * sin(Float64(delta + phi1)))))); 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(cos(theta) * t_3)) * sin(phi1)))); else tmp = Float64(lambda1 + atan(t_2, Float64(cos(delta) - Float64(fma(sin(delta), cos(phi1), t_1) * sin(phi1))))); 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[(N[Sin[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[Cos[phi1], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(lambda1 + N[ArcTan[t$95$2 / N[(N[Cos[delta], $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[Sin[N[ArcSin[N[(t$95$1 + N[(t$95$3 * N[Cos[theta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$4, -3.145], N[(lambda1 + N[ArcTan[t$95$2 / N[(N[Cos[delta], $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[Sin[N[(delta + phi1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $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[Cos[theta], $MachinePrecision] * t$95$3), $MachinePrecision]), $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], N[(lambda1 + N[ArcTan[t$95$2 / N[(N[Cos[delta], $MachinePrecision] - N[(N[(N[Sin[delta], $MachinePrecision] * N[Cos[phi1], $MachinePrecision] + t$95$1), $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \sin \phi_1 \cdot \cos delta\\
t_2 := \left(\sin theta \cdot \sin delta\right) \cdot \cos \phi_1\\
t_3 := \cos \phi_1 \cdot \sin delta\\
t_4 := \lambda_1 + \tan^{-1}_* \frac{t\_2}{\cos delta - \sin \phi_1 \cdot \sin \sin^{-1} \left(t\_1 + t\_3 \cdot \cos theta\right)}\\
\mathbf{if}\;t\_4 \leq -3.145:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{t\_2}{\cos delta - \sin \phi_1 \cdot \sin \left(delta + \phi_1\right)}\\
\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, \cos theta \cdot t\_3\right) \cdot \sin \phi_1}\\
\mathbf{else}:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{t\_2}{\cos delta - \mathsf{fma}\left(\sin delta, \cos \phi_1, t\_1\right) \cdot \sin \phi_1}\\
\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.14500000000000002Initial program 99.8%
Taylor expanded in theta around 0
+-commutativeN/A
*-commutativeN/A
sin-sum-revN/A
lower-sin.f64N/A
lower-+.f6492.2
Applied rewrites92.2%
if -3.14500000000000002 < (+.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.8%
Taylor expanded in lambda1 around 0
Applied rewrites31.4%
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.8%
Taylor expanded in phi1 around 0
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lift-cos.f64N/A
lift-sin.f6485.0
Applied rewrites85.0%
Taylor expanded in theta around 0
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
*-commutativeN/A
lift-sin.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-sin.f6494.7
Applied rewrites94.7%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(+
lambda1
(atan2
(* (* (sin theta) (sin delta)) (cos phi1))
(-
(cos delta)
(* (fma (sin delta) (cos phi1) (* (sin phi1) (cos delta))) (sin phi1))))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 + atan2(((sin(theta) * sin(delta)) * cos(phi1)), (cos(delta) - (fma(sin(delta), cos(phi1), (sin(phi1) * cos(delta))) * sin(phi1))));
}
function code(lambda1, phi1, phi2, delta, theta) return Float64(lambda1 + atan(Float64(Float64(sin(theta) * sin(delta)) * cos(phi1)), Float64(cos(delta) - Float64(fma(sin(delta), cos(phi1), Float64(sin(phi1) * cos(delta))) * sin(phi1))))) 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[(N[Sin[delta], $MachinePrecision] * N[Cos[phi1], $MachinePrecision] + N[(N[Sin[phi1], $MachinePrecision] * N[Cos[delta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[phi1], $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 - \mathsf{fma}\left(\sin delta, \cos \phi_1, \sin \phi_1 \cdot \cos delta\right) \cdot \sin \phi_1}
\end{array}
Initial program 99.8%
Taylor expanded in phi1 around 0
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lift-cos.f64N/A
lift-sin.f6485.0
Applied rewrites85.0%
Taylor expanded in theta around 0
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lift-sin.f64N/A
lift-cos.f64N/A
*-commutativeN/A
lift-sin.f64N/A
lift-cos.f64N/A
lift-*.f64N/A
lift-sin.f6494.7
Applied rewrites94.7%
(FPCore (lambda1 phi1 phi2 delta theta) :precision binary64 (+ lambda1 (atan2 (* (* (sin theta) (sin delta)) (cos phi1)) (- (cos delta) (- 0.5 (* 0.5 (cos (* 2.0 phi1))))))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 + atan2(((sin(theta) * sin(delta)) * cos(phi1)), (cos(delta) - (0.5 - (0.5 * cos((2.0 * phi1))))));
}
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) - (0.5d0 - (0.5d0 * cos((2.0d0 * phi1))))))
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) - (0.5 - (0.5 * Math.cos((2.0 * phi1))))));
}
def code(lambda1, phi1, phi2, delta, theta): return lambda1 + math.atan2(((math.sin(theta) * math.sin(delta)) * math.cos(phi1)), (math.cos(delta) - (0.5 - (0.5 * math.cos((2.0 * phi1))))))
function code(lambda1, phi1, phi2, delta, theta) return Float64(lambda1 + atan(Float64(Float64(sin(theta) * sin(delta)) * cos(phi1)), Float64(cos(delta) - Float64(0.5 - Float64(0.5 * cos(Float64(2.0 * phi1))))))) end
function tmp = code(lambda1, phi1, phi2, delta, theta) tmp = lambda1 + atan2(((sin(theta) * sin(delta)) * cos(phi1)), (cos(delta) - (0.5 - (0.5 * cos((2.0 * phi1)))))); 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[(0.5 - N[(0.5 * N[Cos[N[(2.0 * phi1), $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 - \left(0.5 - 0.5 \cdot \cos \left(2 \cdot \phi_1\right)\right)}
\end{array}
Initial program 99.8%
Taylor expanded in delta around 0
unpow2N/A
sqr-sin-aN/A
lower--.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
lower-*.f6492.4
Applied rewrites92.4%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(let* ((t_1 (* (* (sin theta) (sin delta)) (cos phi1)))
(t_2 (+ lambda1 (atan2 t_1 (cos delta)))))
(if (<= delta -7e+23)
t_2
(if (<= delta 0.0026) (+ lambda1 (atan2 t_1 (pow (cos phi1) 2.0))) t_2))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double t_1 = (sin(theta) * sin(delta)) * cos(phi1);
double t_2 = lambda1 + atan2(t_1, cos(delta));
double tmp;
if (delta <= -7e+23) {
tmp = t_2;
} else if (delta <= 0.0026) {
tmp = lambda1 + atan2(t_1, pow(cos(phi1), 2.0));
} else {
tmp = t_2;
}
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) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = (sin(theta) * sin(delta)) * cos(phi1)
t_2 = lambda1 + atan2(t_1, cos(delta))
if (delta <= (-7d+23)) then
tmp = t_2
else if (delta <= 0.0026d0) then
tmp = lambda1 + atan2(t_1, (cos(phi1) ** 2.0d0))
else
tmp = t_2
end if
code = tmp
end function
public static double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double t_1 = (Math.sin(theta) * Math.sin(delta)) * Math.cos(phi1);
double t_2 = lambda1 + Math.atan2(t_1, Math.cos(delta));
double tmp;
if (delta <= -7e+23) {
tmp = t_2;
} else if (delta <= 0.0026) {
tmp = lambda1 + Math.atan2(t_1, Math.pow(Math.cos(phi1), 2.0));
} else {
tmp = t_2;
}
return tmp;
}
def code(lambda1, phi1, phi2, delta, theta): t_1 = (math.sin(theta) * math.sin(delta)) * math.cos(phi1) t_2 = lambda1 + math.atan2(t_1, math.cos(delta)) tmp = 0 if delta <= -7e+23: tmp = t_2 elif delta <= 0.0026: tmp = lambda1 + math.atan2(t_1, math.pow(math.cos(phi1), 2.0)) else: tmp = t_2 return tmp
function code(lambda1, phi1, phi2, delta, theta) t_1 = Float64(Float64(sin(theta) * sin(delta)) * cos(phi1)) t_2 = Float64(lambda1 + atan(t_1, cos(delta))) tmp = 0.0 if (delta <= -7e+23) tmp = t_2; elseif (delta <= 0.0026) tmp = Float64(lambda1 + atan(t_1, (cos(phi1) ^ 2.0))); else tmp = t_2; end return tmp end
function tmp_2 = code(lambda1, phi1, phi2, delta, theta) t_1 = (sin(theta) * sin(delta)) * cos(phi1); t_2 = lambda1 + atan2(t_1, cos(delta)); tmp = 0.0; if (delta <= -7e+23) tmp = t_2; elseif (delta <= 0.0026) tmp = lambda1 + atan2(t_1, (cos(phi1) ^ 2.0)); else tmp = t_2; end tmp_2 = tmp; end
code[lambda1_, phi1_, phi2_, delta_, theta_] := Block[{t$95$1 = N[(N[(N[Sin[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(lambda1 + N[ArcTan[t$95$1 / N[Cos[delta], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[delta, -7e+23], t$95$2, If[LessEqual[delta, 0.0026], N[(lambda1 + N[ArcTan[t$95$1 / N[Power[N[Cos[phi1], $MachinePrecision], 2.0], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], t$95$2]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \left(\sin theta \cdot \sin delta\right) \cdot \cos \phi_1\\
t_2 := \lambda_1 + \tan^{-1}_* \frac{t\_1}{\cos delta}\\
\mathbf{if}\;delta \leq -7 \cdot 10^{+23}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;delta \leq 0.0026:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{t\_1}{{\cos \phi_1}^{2}}\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if delta < -7.0000000000000004e23 or 0.0025999999999999999 < delta Initial program 99.8%
Taylor expanded in phi1 around 0
lift-cos.f6489.0
Applied rewrites89.0%
if -7.0000000000000004e23 < delta < 0.0025999999999999999Initial program 99.8%
Taylor expanded in delta around 0
unpow2N/A
1-sub-sin-revN/A
sqr-cos-aN/A
lower-+.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
lower-*.f6480.5
Applied rewrites80.5%
lift-+.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-cos.f64N/A
sqr-cos-a-revN/A
unpow2N/A
lower-pow.f64N/A
lift-cos.f6480.5
Applied rewrites80.5%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(let* ((t_1
(+
lambda1
(atan2 (* (* (sin theta) (sin delta)) (cos phi1)) (cos delta)))))
(if (<= delta -8.5e+15)
t_1
(if (<= delta 0.0026)
(+
lambda1
(atan2
(* (* (sin theta) delta) (cos phi1))
(+ 0.5 (* 0.5 (cos (* 2.0 phi1))))))
t_1))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double t_1 = lambda1 + atan2(((sin(theta) * sin(delta)) * cos(phi1)), cos(delta));
double tmp;
if (delta <= -8.5e+15) {
tmp = t_1;
} else if (delta <= 0.0026) {
tmp = lambda1 + atan2(((sin(theta) * delta) * cos(phi1)), (0.5 + (0.5 * cos((2.0 * phi1)))));
} else {
tmp = t_1;
}
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) :: t_1
real(8) :: tmp
t_1 = lambda1 + atan2(((sin(theta) * sin(delta)) * cos(phi1)), cos(delta))
if (delta <= (-8.5d+15)) then
tmp = t_1
else if (delta <= 0.0026d0) then
tmp = lambda1 + atan2(((sin(theta) * delta) * cos(phi1)), (0.5d0 + (0.5d0 * cos((2.0d0 * phi1)))))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double t_1 = lambda1 + Math.atan2(((Math.sin(theta) * Math.sin(delta)) * Math.cos(phi1)), Math.cos(delta));
double tmp;
if (delta <= -8.5e+15) {
tmp = t_1;
} else if (delta <= 0.0026) {
tmp = lambda1 + Math.atan2(((Math.sin(theta) * delta) * Math.cos(phi1)), (0.5 + (0.5 * Math.cos((2.0 * phi1)))));
} else {
tmp = t_1;
}
return tmp;
}
def code(lambda1, phi1, phi2, delta, theta): t_1 = lambda1 + math.atan2(((math.sin(theta) * math.sin(delta)) * math.cos(phi1)), math.cos(delta)) tmp = 0 if delta <= -8.5e+15: tmp = t_1 elif delta <= 0.0026: tmp = lambda1 + math.atan2(((math.sin(theta) * delta) * math.cos(phi1)), (0.5 + (0.5 * math.cos((2.0 * phi1))))) else: tmp = t_1 return tmp
function code(lambda1, phi1, phi2, delta, theta) t_1 = Float64(lambda1 + atan(Float64(Float64(sin(theta) * sin(delta)) * cos(phi1)), cos(delta))) tmp = 0.0 if (delta <= -8.5e+15) tmp = t_1; elseif (delta <= 0.0026) tmp = Float64(lambda1 + atan(Float64(Float64(sin(theta) * delta) * cos(phi1)), Float64(0.5 + Float64(0.5 * cos(Float64(2.0 * phi1)))))); else tmp = t_1; end return tmp end
function tmp_2 = code(lambda1, phi1, phi2, delta, theta) t_1 = lambda1 + atan2(((sin(theta) * sin(delta)) * cos(phi1)), cos(delta)); tmp = 0.0; if (delta <= -8.5e+15) tmp = t_1; elseif (delta <= 0.0026) tmp = lambda1 + atan2(((sin(theta) * delta) * cos(phi1)), (0.5 + (0.5 * cos((2.0 * phi1))))); else tmp = t_1; end tmp_2 = tmp; end
code[lambda1_, phi1_, phi2_, delta_, theta_] := Block[{t$95$1 = 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]}, If[LessEqual[delta, -8.5e+15], t$95$1, If[LessEqual[delta, 0.0026], N[(lambda1 + N[ArcTan[N[(N[(N[Sin[theta], $MachinePrecision] * delta), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] / N[(0.5 + N[(0.5 * N[Cos[N[(2.0 * phi1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \lambda_1 + \tan^{-1}_* \frac{\left(\sin theta \cdot \sin delta\right) \cdot \cos \phi_1}{\cos delta}\\
\mathbf{if}\;delta \leq -8.5 \cdot 10^{+15}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;delta \leq 0.0026:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{\left(\sin theta \cdot delta\right) \cdot \cos \phi_1}{0.5 + 0.5 \cdot \cos \left(2 \cdot \phi_1\right)}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if delta < -8.5e15 or 0.0025999999999999999 < delta Initial program 99.8%
Taylor expanded in phi1 around 0
lift-cos.f6489.0
Applied rewrites89.0%
if -8.5e15 < delta < 0.0025999999999999999Initial program 99.8%
Taylor expanded in delta around 0
unpow2N/A
1-sub-sin-revN/A
sqr-cos-aN/A
lower-+.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
lower-*.f6480.5
Applied rewrites80.5%
Taylor expanded in delta around 0
Applied rewrites77.1%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(let* ((t_1 (+ lambda1 (atan2 (* (sin theta) (sin delta)) (cos delta)))))
(if (<= delta -8.5e+15)
t_1
(if (<= delta 0.0026)
(+
lambda1
(atan2
(* (* (sin theta) delta) (cos phi1))
(+ 0.5 (* 0.5 (cos (* 2.0 phi1))))))
t_1))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double t_1 = lambda1 + atan2((sin(theta) * sin(delta)), cos(delta));
double tmp;
if (delta <= -8.5e+15) {
tmp = t_1;
} else if (delta <= 0.0026) {
tmp = lambda1 + atan2(((sin(theta) * delta) * cos(phi1)), (0.5 + (0.5 * cos((2.0 * phi1)))));
} else {
tmp = t_1;
}
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) :: t_1
real(8) :: tmp
t_1 = lambda1 + atan2((sin(theta) * sin(delta)), cos(delta))
if (delta <= (-8.5d+15)) then
tmp = t_1
else if (delta <= 0.0026d0) then
tmp = lambda1 + atan2(((sin(theta) * delta) * cos(phi1)), (0.5d0 + (0.5d0 * cos((2.0d0 * phi1)))))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double t_1 = lambda1 + Math.atan2((Math.sin(theta) * Math.sin(delta)), Math.cos(delta));
double tmp;
if (delta <= -8.5e+15) {
tmp = t_1;
} else if (delta <= 0.0026) {
tmp = lambda1 + Math.atan2(((Math.sin(theta) * delta) * Math.cos(phi1)), (0.5 + (0.5 * Math.cos((2.0 * phi1)))));
} else {
tmp = t_1;
}
return tmp;
}
def code(lambda1, phi1, phi2, delta, theta): t_1 = lambda1 + math.atan2((math.sin(theta) * math.sin(delta)), math.cos(delta)) tmp = 0 if delta <= -8.5e+15: tmp = t_1 elif delta <= 0.0026: tmp = lambda1 + math.atan2(((math.sin(theta) * delta) * math.cos(phi1)), (0.5 + (0.5 * math.cos((2.0 * phi1))))) else: tmp = t_1 return tmp
function code(lambda1, phi1, phi2, delta, theta) t_1 = Float64(lambda1 + atan(Float64(sin(theta) * sin(delta)), cos(delta))) tmp = 0.0 if (delta <= -8.5e+15) tmp = t_1; elseif (delta <= 0.0026) tmp = Float64(lambda1 + atan(Float64(Float64(sin(theta) * delta) * cos(phi1)), Float64(0.5 + Float64(0.5 * cos(Float64(2.0 * phi1)))))); else tmp = t_1; end return tmp end
function tmp_2 = code(lambda1, phi1, phi2, delta, theta) t_1 = lambda1 + atan2((sin(theta) * sin(delta)), cos(delta)); tmp = 0.0; if (delta <= -8.5e+15) tmp = t_1; elseif (delta <= 0.0026) tmp = lambda1 + atan2(((sin(theta) * delta) * cos(phi1)), (0.5 + (0.5 * cos((2.0 * phi1))))); else tmp = t_1; end tmp_2 = tmp; end
code[lambda1_, phi1_, phi2_, delta_, theta_] := Block[{t$95$1 = N[(lambda1 + N[ArcTan[N[(N[Sin[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] / N[Cos[delta], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[delta, -8.5e+15], t$95$1, If[LessEqual[delta, 0.0026], N[(lambda1 + N[ArcTan[N[(N[(N[Sin[theta], $MachinePrecision] * delta), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] / N[(0.5 + N[(0.5 * N[Cos[N[(2.0 * phi1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \lambda_1 + \tan^{-1}_* \frac{\sin theta \cdot \sin delta}{\cos delta}\\
\mathbf{if}\;delta \leq -8.5 \cdot 10^{+15}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;delta \leq 0.0026:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{\left(\sin theta \cdot delta\right) \cdot \cos \phi_1}{0.5 + 0.5 \cdot \cos \left(2 \cdot \phi_1\right)}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if delta < -8.5e15 or 0.0025999999999999999 < delta Initial program 99.8%
Taylor expanded in phi1 around 0
lift-cos.f6489.0
Applied rewrites89.0%
Taylor expanded in phi1 around 0
*-commutativeN/A
lift-sin.f64N/A
lift-sin.f64N/A
lift-*.f6486.6
Applied rewrites86.6%
if -8.5e15 < delta < 0.0025999999999999999Initial program 99.8%
Taylor expanded in delta around 0
unpow2N/A
1-sub-sin-revN/A
sqr-cos-aN/A
lower-+.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
lower-*.f6480.5
Applied rewrites80.5%
Taylor expanded in delta around 0
Applied rewrites77.1%
(FPCore (lambda1 phi1 phi2 delta theta) :precision binary64 (+ lambda1 (atan2 (* (sin theta) (sin delta)) (cos delta))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 + atan2((sin(theta) * sin(delta)), 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(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(delta));
}
def code(lambda1, phi1, phi2, delta, theta): return lambda1 + math.atan2((math.sin(theta) * math.sin(delta)), math.cos(delta))
function code(lambda1, phi1, phi2, delta, theta) return Float64(lambda1 + atan(Float64(sin(theta) * sin(delta)), cos(delta))) end
function tmp = code(lambda1, phi1, phi2, delta, theta) tmp = lambda1 + atan2((sin(theta) * sin(delta)), cos(delta)); end
code[lambda1_, phi1_, phi2_, delta_, theta_] := N[(lambda1 + N[ArcTan[N[(N[Sin[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] / N[Cos[delta], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\lambda_1 + \tan^{-1}_* \frac{\sin theta \cdot \sin delta}{\cos delta}
\end{array}
Initial program 99.8%
Taylor expanded in phi1 around 0
lift-cos.f6489.0
Applied rewrites89.0%
Taylor expanded in phi1 around 0
*-commutativeN/A
lift-sin.f64N/A
lift-sin.f64N/A
lift-*.f6486.6
Applied rewrites86.6%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(let* ((t_1
(+
lambda1
(atan2
(*
(*
theta
(+
1.0
(*
(* theta theta)
(-
(*
(* theta theta)
(-
0.008333333333333333
(* 0.0001984126984126984 (* theta theta))))
0.16666666666666666))))
(sin delta))
(cos delta)))))
(if (<= delta -5.4e+17)
t_1
(if (<= delta 0.8)
(+
lambda1
(atan2
(*
(*
(sin theta)
(* delta (- 1.0 (* 0.16666666666666666 (* delta delta)))))
(cos phi1))
(fma (* delta delta) -0.5 1.0)))
t_1))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double t_1 = lambda1 + atan2(((theta * (1.0 + ((theta * theta) * (((theta * theta) * (0.008333333333333333 - (0.0001984126984126984 * (theta * theta)))) - 0.16666666666666666)))) * sin(delta)), cos(delta));
double tmp;
if (delta <= -5.4e+17) {
tmp = t_1;
} else if (delta <= 0.8) {
tmp = lambda1 + atan2(((sin(theta) * (delta * (1.0 - (0.16666666666666666 * (delta * delta))))) * cos(phi1)), fma((delta * delta), -0.5, 1.0));
} else {
tmp = t_1;
}
return tmp;
}
function code(lambda1, phi1, phi2, delta, theta) t_1 = Float64(lambda1 + atan(Float64(Float64(theta * Float64(1.0 + Float64(Float64(theta * theta) * Float64(Float64(Float64(theta * theta) * Float64(0.008333333333333333 - Float64(0.0001984126984126984 * Float64(theta * theta)))) - 0.16666666666666666)))) * sin(delta)), cos(delta))) tmp = 0.0 if (delta <= -5.4e+17) tmp = t_1; elseif (delta <= 0.8) tmp = Float64(lambda1 + atan(Float64(Float64(sin(theta) * Float64(delta * Float64(1.0 - Float64(0.16666666666666666 * Float64(delta * delta))))) * cos(phi1)), fma(Float64(delta * delta), -0.5, 1.0))); else tmp = t_1; end return tmp end
code[lambda1_, phi1_, phi2_, delta_, theta_] := Block[{t$95$1 = N[(lambda1 + N[ArcTan[N[(N[(theta * N[(1.0 + N[(N[(theta * theta), $MachinePrecision] * N[(N[(N[(theta * theta), $MachinePrecision] * N[(0.008333333333333333 - N[(0.0001984126984126984 * N[(theta * theta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - 0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] / N[Cos[delta], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[delta, -5.4e+17], t$95$1, If[LessEqual[delta, 0.8], N[(lambda1 + N[ArcTan[N[(N[(N[Sin[theta], $MachinePrecision] * N[(delta * N[(1.0 - N[(0.16666666666666666 * N[(delta * delta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] / N[(N[(delta * delta), $MachinePrecision] * -0.5 + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \lambda_1 + \tan^{-1}_* \frac{\left(theta \cdot \left(1 + \left(theta \cdot theta\right) \cdot \left(\left(theta \cdot theta\right) \cdot \left(0.008333333333333333 - 0.0001984126984126984 \cdot \left(theta \cdot theta\right)\right) - 0.16666666666666666\right)\right)\right) \cdot \sin delta}{\cos delta}\\
\mathbf{if}\;delta \leq -5.4 \cdot 10^{+17}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;delta \leq 0.8:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{\left(\sin theta \cdot \left(delta \cdot \left(1 - 0.16666666666666666 \cdot \left(delta \cdot delta\right)\right)\right)\right) \cdot \cos \phi_1}{\mathsf{fma}\left(delta \cdot delta, -0.5, 1\right)}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if delta < -5.4e17 or 0.80000000000000004 < delta Initial program 99.8%
Taylor expanded in phi1 around 0
lift-cos.f6489.0
Applied rewrites89.0%
Taylor expanded in phi1 around 0
*-commutativeN/A
lift-sin.f64N/A
lift-sin.f64N/A
lift-*.f6486.6
Applied rewrites86.6%
Taylor expanded in theta around 0
lower-*.f64N/A
lower-+.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower--.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
fp-cancel-sign-sub-invN/A
lower--.f64N/A
lower-*.f64N/A
metadata-evalN/A
unpow2N/A
lower-*.f6471.5
Applied rewrites71.5%
if -5.4e17 < delta < 0.80000000000000004Initial program 99.8%
Taylor expanded in phi1 around 0
lift-cos.f6489.0
Applied rewrites89.0%
Taylor expanded in delta around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6480.6
Applied rewrites80.6%
Taylor expanded in delta around 0
lower-*.f64N/A
fp-cancel-sign-sub-invN/A
lower--.f64N/A
metadata-evalN/A
lower-*.f64N/A
pow2N/A
lift-*.f6474.3
Applied rewrites74.3%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(if (<= theta -0.78)
(+
lambda1
(atan2
(* (* (sin theta) delta) (cos phi1))
(fma (* delta delta) -0.5 1.0)))
(if (<= theta 1e+19)
(+
lambda1
(atan2
(*
(*
theta
(+
1.0
(*
(* theta theta)
(- (* 0.008333333333333333 (* theta theta)) 0.16666666666666666))))
(sin delta))
(cos delta)))
(+
lambda1
(atan2
(* (sin theta) (sin delta))
(+
1.0
(*
(* delta delta)
(-
(*
(* delta delta)
(- 0.041666666666666664 (* 0.001388888888888889 (* delta delta))))
0.5))))))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double tmp;
if (theta <= -0.78) {
tmp = lambda1 + atan2(((sin(theta) * delta) * cos(phi1)), fma((delta * delta), -0.5, 1.0));
} else if (theta <= 1e+19) {
tmp = lambda1 + atan2(((theta * (1.0 + ((theta * theta) * ((0.008333333333333333 * (theta * theta)) - 0.16666666666666666)))) * sin(delta)), cos(delta));
} else {
tmp = lambda1 + atan2((sin(theta) * sin(delta)), (1.0 + ((delta * delta) * (((delta * delta) * (0.041666666666666664 - (0.001388888888888889 * (delta * delta)))) - 0.5))));
}
return tmp;
}
function code(lambda1, phi1, phi2, delta, theta) tmp = 0.0 if (theta <= -0.78) tmp = Float64(lambda1 + atan(Float64(Float64(sin(theta) * delta) * cos(phi1)), fma(Float64(delta * delta), -0.5, 1.0))); elseif (theta <= 1e+19) tmp = Float64(lambda1 + atan(Float64(Float64(theta * Float64(1.0 + Float64(Float64(theta * theta) * Float64(Float64(0.008333333333333333 * Float64(theta * theta)) - 0.16666666666666666)))) * sin(delta)), cos(delta))); else tmp = Float64(lambda1 + atan(Float64(sin(theta) * sin(delta)), Float64(1.0 + Float64(Float64(delta * delta) * Float64(Float64(Float64(delta * delta) * Float64(0.041666666666666664 - Float64(0.001388888888888889 * Float64(delta * delta)))) - 0.5))))); end return tmp end
code[lambda1_, phi1_, phi2_, delta_, theta_] := If[LessEqual[theta, -0.78], N[(lambda1 + N[ArcTan[N[(N[(N[Sin[theta], $MachinePrecision] * delta), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] / N[(N[(delta * delta), $MachinePrecision] * -0.5 + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[theta, 1e+19], N[(lambda1 + N[ArcTan[N[(N[(theta * N[(1.0 + N[(N[(theta * theta), $MachinePrecision] * N[(N[(0.008333333333333333 * N[(theta * theta), $MachinePrecision]), $MachinePrecision] - 0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] / N[Cos[delta], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(lambda1 + N[ArcTan[N[(N[Sin[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] / N[(1.0 + N[(N[(delta * delta), $MachinePrecision] * N[(N[(N[(delta * delta), $MachinePrecision] * N[(0.041666666666666664 - N[(0.001388888888888889 * N[(delta * delta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - 0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;theta \leq -0.78:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{\left(\sin theta \cdot delta\right) \cdot \cos \phi_1}{\mathsf{fma}\left(delta \cdot delta, -0.5, 1\right)}\\
\mathbf{elif}\;theta \leq 10^{+19}:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{\left(theta \cdot \left(1 + \left(theta \cdot theta\right) \cdot \left(0.008333333333333333 \cdot \left(theta \cdot theta\right) - 0.16666666666666666\right)\right)\right) \cdot \sin delta}{\cos delta}\\
\mathbf{else}:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{\sin theta \cdot \sin delta}{1 + \left(delta \cdot delta\right) \cdot \left(\left(delta \cdot delta\right) \cdot \left(0.041666666666666664 - 0.001388888888888889 \cdot \left(delta \cdot delta\right)\right) - 0.5\right)}\\
\end{array}
\end{array}
if theta < -0.78000000000000003Initial program 99.8%
Taylor expanded in phi1 around 0
lift-cos.f6489.0
Applied rewrites89.0%
Taylor expanded in delta around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6480.6
Applied rewrites80.6%
Taylor expanded in delta around 0
Applied rewrites76.1%
if -0.78000000000000003 < theta < 1e19Initial program 99.8%
Taylor expanded in phi1 around 0
lift-cos.f6489.0
Applied rewrites89.0%
Taylor expanded in phi1 around 0
*-commutativeN/A
lift-sin.f64N/A
lift-sin.f64N/A
lift-*.f6486.6
Applied rewrites86.6%
Taylor expanded in theta around 0
lower-*.f64N/A
lower-+.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower--.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6471.6
Applied rewrites71.6%
if 1e19 < theta Initial program 99.8%
Taylor expanded in phi1 around 0
lift-cos.f6489.0
Applied rewrites89.0%
Taylor expanded in phi1 around 0
*-commutativeN/A
lift-sin.f64N/A
lift-sin.f64N/A
lift-*.f6486.6
Applied rewrites86.6%
Taylor expanded in delta around 0
lower-+.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower--.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
fp-cancel-sign-sub-invN/A
lower--.f64N/A
metadata-evalN/A
lower-*.f64N/A
unpow2N/A
lower-*.f6478.0
Applied rewrites78.0%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(if (<= theta -0.78)
(+
lambda1
(atan2
(* (* (sin theta) delta) (cos phi1))
(fma (* delta delta) -0.5 1.0)))
(if (<= theta 1e+19)
(+
lambda1
(atan2
(*
(*
theta
(+
1.0
(*
(* theta theta)
(- (* 0.008333333333333333 (* theta theta)) 0.16666666666666666))))
(sin delta))
(cos delta)))
(+
lambda1
(atan2
(*
(sin theta)
(* delta (- 1.0 (* 0.16666666666666666 (* delta delta)))))
(cos delta))))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double tmp;
if (theta <= -0.78) {
tmp = lambda1 + atan2(((sin(theta) * delta) * cos(phi1)), fma((delta * delta), -0.5, 1.0));
} else if (theta <= 1e+19) {
tmp = lambda1 + atan2(((theta * (1.0 + ((theta * theta) * ((0.008333333333333333 * (theta * theta)) - 0.16666666666666666)))) * sin(delta)), cos(delta));
} else {
tmp = lambda1 + atan2((sin(theta) * (delta * (1.0 - (0.16666666666666666 * (delta * delta))))), cos(delta));
}
return tmp;
}
function code(lambda1, phi1, phi2, delta, theta) tmp = 0.0 if (theta <= -0.78) tmp = Float64(lambda1 + atan(Float64(Float64(sin(theta) * delta) * cos(phi1)), fma(Float64(delta * delta), -0.5, 1.0))); elseif (theta <= 1e+19) tmp = Float64(lambda1 + atan(Float64(Float64(theta * Float64(1.0 + Float64(Float64(theta * theta) * Float64(Float64(0.008333333333333333 * Float64(theta * theta)) - 0.16666666666666666)))) * sin(delta)), cos(delta))); else tmp = Float64(lambda1 + atan(Float64(sin(theta) * Float64(delta * Float64(1.0 - Float64(0.16666666666666666 * Float64(delta * delta))))), cos(delta))); end return tmp end
code[lambda1_, phi1_, phi2_, delta_, theta_] := If[LessEqual[theta, -0.78], N[(lambda1 + N[ArcTan[N[(N[(N[Sin[theta], $MachinePrecision] * delta), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] / N[(N[(delta * delta), $MachinePrecision] * -0.5 + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[theta, 1e+19], N[(lambda1 + N[ArcTan[N[(N[(theta * N[(1.0 + N[(N[(theta * theta), $MachinePrecision] * N[(N[(0.008333333333333333 * N[(theta * theta), $MachinePrecision]), $MachinePrecision] - 0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] / N[Cos[delta], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(lambda1 + N[ArcTan[N[(N[Sin[theta], $MachinePrecision] * N[(delta * N[(1.0 - N[(0.16666666666666666 * N[(delta * delta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Cos[delta], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;theta \leq -0.78:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{\left(\sin theta \cdot delta\right) \cdot \cos \phi_1}{\mathsf{fma}\left(delta \cdot delta, -0.5, 1\right)}\\
\mathbf{elif}\;theta \leq 10^{+19}:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{\left(theta \cdot \left(1 + \left(theta \cdot theta\right) \cdot \left(0.008333333333333333 \cdot \left(theta \cdot theta\right) - 0.16666666666666666\right)\right)\right) \cdot \sin delta}{\cos delta}\\
\mathbf{else}:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{\sin theta \cdot \left(delta \cdot \left(1 - 0.16666666666666666 \cdot \left(delta \cdot delta\right)\right)\right)}{\cos delta}\\
\end{array}
\end{array}
if theta < -0.78000000000000003Initial program 99.8%
Taylor expanded in phi1 around 0
lift-cos.f6489.0
Applied rewrites89.0%
Taylor expanded in delta around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6480.6
Applied rewrites80.6%
Taylor expanded in delta around 0
Applied rewrites76.1%
if -0.78000000000000003 < theta < 1e19Initial program 99.8%
Taylor expanded in phi1 around 0
lift-cos.f6489.0
Applied rewrites89.0%
Taylor expanded in phi1 around 0
*-commutativeN/A
lift-sin.f64N/A
lift-sin.f64N/A
lift-*.f6486.6
Applied rewrites86.6%
Taylor expanded in theta around 0
lower-*.f64N/A
lower-+.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower--.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6471.6
Applied rewrites71.6%
if 1e19 < theta Initial program 99.8%
Taylor expanded in phi1 around 0
lift-cos.f6489.0
Applied rewrites89.0%
Taylor expanded in phi1 around 0
*-commutativeN/A
lift-sin.f64N/A
lift-sin.f64N/A
lift-*.f6486.6
Applied rewrites86.6%
Taylor expanded in delta around 0
lower-*.f64N/A
fp-cancel-sign-sub-invN/A
lower--.f64N/A
metadata-evalN/A
lower-*.f64N/A
unpow2N/A
lower-*.f6473.8
Applied rewrites73.8%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(let* ((t_1
(+
lambda1
(atan2
(*
(* theta (- 1.0 (* 0.16666666666666666 (* theta theta))))
(sin delta))
(cos delta)))))
(if (<= delta -1.45e+18)
t_1
(if (<= delta 24000000.0)
(+
lambda1
(atan2
(* (* (sin theta) delta) (cos phi1))
(fma (* delta delta) -0.5 1.0)))
t_1))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double t_1 = lambda1 + atan2(((theta * (1.0 - (0.16666666666666666 * (theta * theta)))) * sin(delta)), cos(delta));
double tmp;
if (delta <= -1.45e+18) {
tmp = t_1;
} else if (delta <= 24000000.0) {
tmp = lambda1 + atan2(((sin(theta) * delta) * cos(phi1)), fma((delta * delta), -0.5, 1.0));
} else {
tmp = t_1;
}
return tmp;
}
function code(lambda1, phi1, phi2, delta, theta) t_1 = Float64(lambda1 + atan(Float64(Float64(theta * Float64(1.0 - Float64(0.16666666666666666 * Float64(theta * theta)))) * sin(delta)), cos(delta))) tmp = 0.0 if (delta <= -1.45e+18) tmp = t_1; elseif (delta <= 24000000.0) tmp = Float64(lambda1 + atan(Float64(Float64(sin(theta) * delta) * cos(phi1)), fma(Float64(delta * delta), -0.5, 1.0))); else tmp = t_1; end return tmp end
code[lambda1_, phi1_, phi2_, delta_, theta_] := Block[{t$95$1 = N[(lambda1 + N[ArcTan[N[(N[(theta * N[(1.0 - N[(0.16666666666666666 * N[(theta * theta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] / N[Cos[delta], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[delta, -1.45e+18], t$95$1, If[LessEqual[delta, 24000000.0], N[(lambda1 + N[ArcTan[N[(N[(N[Sin[theta], $MachinePrecision] * delta), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] / N[(N[(delta * delta), $MachinePrecision] * -0.5 + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \lambda_1 + \tan^{-1}_* \frac{\left(theta \cdot \left(1 - 0.16666666666666666 \cdot \left(theta \cdot theta\right)\right)\right) \cdot \sin delta}{\cos delta}\\
\mathbf{if}\;delta \leq -1.45 \cdot 10^{+18}:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;delta \leq 24000000:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{\left(\sin theta \cdot delta\right) \cdot \cos \phi_1}{\mathsf{fma}\left(delta \cdot delta, -0.5, 1\right)}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if delta < -1.45e18 or 2.4e7 < delta Initial program 99.8%
Taylor expanded in phi1 around 0
lift-cos.f6489.0
Applied rewrites89.0%
Taylor expanded in phi1 around 0
*-commutativeN/A
lift-sin.f64N/A
lift-sin.f64N/A
lift-*.f6486.6
Applied rewrites86.6%
Taylor expanded in theta around 0
lower-*.f64N/A
fp-cancel-sign-sub-invN/A
lower--.f64N/A
metadata-evalN/A
lower-*.f64N/A
unpow2N/A
lower-*.f6471.9
Applied rewrites71.9%
if -1.45e18 < delta < 2.4e7Initial program 99.8%
Taylor expanded in phi1 around 0
lift-cos.f6489.0
Applied rewrites89.0%
Taylor expanded in delta around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6480.6
Applied rewrites80.6%
Taylor expanded in delta around 0
Applied rewrites76.1%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(if (<= theta -0.48)
(+
lambda1
(atan2
(* (* (sin theta) delta) (cos phi1))
(fma (* delta delta) -0.5 1.0)))
(if (<= theta 1e+19)
(+ lambda1 (atan2 (* theta (sin delta)) (cos delta)))
(+
lambda1
(atan2 (* (sin theta) (sin delta)) (- 1.0 (* 0.5 (* delta delta))))))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double tmp;
if (theta <= -0.48) {
tmp = lambda1 + atan2(((sin(theta) * delta) * cos(phi1)), fma((delta * delta), -0.5, 1.0));
} else if (theta <= 1e+19) {
tmp = lambda1 + atan2((theta * sin(delta)), cos(delta));
} else {
tmp = lambda1 + atan2((sin(theta) * sin(delta)), (1.0 - (0.5 * (delta * delta))));
}
return tmp;
}
function code(lambda1, phi1, phi2, delta, theta) tmp = 0.0 if (theta <= -0.48) tmp = Float64(lambda1 + atan(Float64(Float64(sin(theta) * delta) * cos(phi1)), fma(Float64(delta * delta), -0.5, 1.0))); elseif (theta <= 1e+19) tmp = Float64(lambda1 + atan(Float64(theta * sin(delta)), cos(delta))); else tmp = Float64(lambda1 + atan(Float64(sin(theta) * sin(delta)), Float64(1.0 - Float64(0.5 * Float64(delta * delta))))); end return tmp end
code[lambda1_, phi1_, phi2_, delta_, theta_] := If[LessEqual[theta, -0.48], N[(lambda1 + N[ArcTan[N[(N[(N[Sin[theta], $MachinePrecision] * delta), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] / N[(N[(delta * delta), $MachinePrecision] * -0.5 + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[theta, 1e+19], N[(lambda1 + N[ArcTan[N[(theta * N[Sin[delta], $MachinePrecision]), $MachinePrecision] / N[Cos[delta], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(lambda1 + N[ArcTan[N[(N[Sin[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] / N[(1.0 - N[(0.5 * N[(delta * delta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;theta \leq -0.48:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{\left(\sin theta \cdot delta\right) \cdot \cos \phi_1}{\mathsf{fma}\left(delta \cdot delta, -0.5, 1\right)}\\
\mathbf{elif}\;theta \leq 10^{+19}:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{theta \cdot \sin delta}{\cos delta}\\
\mathbf{else}:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{\sin theta \cdot \sin delta}{1 - 0.5 \cdot \left(delta \cdot delta\right)}\\
\end{array}
\end{array}
if theta < -0.47999999999999998Initial program 99.8%
Taylor expanded in phi1 around 0
lift-cos.f6489.0
Applied rewrites89.0%
Taylor expanded in delta around 0
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
unpow2N/A
lower-*.f6480.6
Applied rewrites80.6%
Taylor expanded in delta around 0
Applied rewrites76.1%
if -0.47999999999999998 < theta < 1e19Initial program 99.8%
Taylor expanded in phi1 around 0
lift-cos.f6489.0
Applied rewrites89.0%
Taylor expanded in phi1 around 0
*-commutativeN/A
lift-sin.f64N/A
lift-sin.f64N/A
lift-*.f6486.6
Applied rewrites86.6%
Taylor expanded in theta around 0
Applied rewrites73.4%
if 1e19 < theta Initial program 99.8%
Taylor expanded in phi1 around 0
lift-cos.f6489.0
Applied rewrites89.0%
Taylor expanded in phi1 around 0
*-commutativeN/A
lift-sin.f64N/A
lift-sin.f64N/A
lift-*.f6486.6
Applied rewrites86.6%
Taylor expanded in delta around 0
fp-cancel-sign-sub-invN/A
lower--.f64N/A
metadata-evalN/A
lower-*.f64N/A
unpow2N/A
lower-*.f6478.0
Applied rewrites78.0%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(if (<= theta -0.72)
(+ lambda1 (atan2 (* (sin theta) delta) (cos delta)))
(if (<= theta 1e+19)
(+ lambda1 (atan2 (* theta (sin delta)) (cos delta)))
(+
lambda1
(atan2 (* (sin theta) (sin delta)) (- 1.0 (* 0.5 (* delta delta))))))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double tmp;
if (theta <= -0.72) {
tmp = lambda1 + atan2((sin(theta) * delta), cos(delta));
} else if (theta <= 1e+19) {
tmp = lambda1 + atan2((theta * sin(delta)), cos(delta));
} else {
tmp = lambda1 + atan2((sin(theta) * sin(delta)), (1.0 - (0.5 * (delta * 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 (theta <= (-0.72d0)) then
tmp = lambda1 + atan2((sin(theta) * delta), cos(delta))
else if (theta <= 1d+19) then
tmp = lambda1 + atan2((theta * sin(delta)), cos(delta))
else
tmp = lambda1 + atan2((sin(theta) * sin(delta)), (1.0d0 - (0.5d0 * (delta * delta))))
end if
code = tmp
end function
public static double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double tmp;
if (theta <= -0.72) {
tmp = lambda1 + Math.atan2((Math.sin(theta) * delta), Math.cos(delta));
} else if (theta <= 1e+19) {
tmp = lambda1 + Math.atan2((theta * Math.sin(delta)), Math.cos(delta));
} else {
tmp = lambda1 + Math.atan2((Math.sin(theta) * Math.sin(delta)), (1.0 - (0.5 * (delta * delta))));
}
return tmp;
}
def code(lambda1, phi1, phi2, delta, theta): tmp = 0 if theta <= -0.72: tmp = lambda1 + math.atan2((math.sin(theta) * delta), math.cos(delta)) elif theta <= 1e+19: tmp = lambda1 + math.atan2((theta * math.sin(delta)), math.cos(delta)) else: tmp = lambda1 + math.atan2((math.sin(theta) * math.sin(delta)), (1.0 - (0.5 * (delta * delta)))) return tmp
function code(lambda1, phi1, phi2, delta, theta) tmp = 0.0 if (theta <= -0.72) tmp = Float64(lambda1 + atan(Float64(sin(theta) * delta), cos(delta))); elseif (theta <= 1e+19) tmp = Float64(lambda1 + atan(Float64(theta * sin(delta)), cos(delta))); else tmp = Float64(lambda1 + atan(Float64(sin(theta) * sin(delta)), Float64(1.0 - Float64(0.5 * Float64(delta * delta))))); end return tmp end
function tmp_2 = code(lambda1, phi1, phi2, delta, theta) tmp = 0.0; if (theta <= -0.72) tmp = lambda1 + atan2((sin(theta) * delta), cos(delta)); elseif (theta <= 1e+19) tmp = lambda1 + atan2((theta * sin(delta)), cos(delta)); else tmp = lambda1 + atan2((sin(theta) * sin(delta)), (1.0 - (0.5 * (delta * delta)))); end tmp_2 = tmp; end
code[lambda1_, phi1_, phi2_, delta_, theta_] := If[LessEqual[theta, -0.72], N[(lambda1 + N[ArcTan[N[(N[Sin[theta], $MachinePrecision] * delta), $MachinePrecision] / N[Cos[delta], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[theta, 1e+19], N[(lambda1 + N[ArcTan[N[(theta * N[Sin[delta], $MachinePrecision]), $MachinePrecision] / N[Cos[delta], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(lambda1 + N[ArcTan[N[(N[Sin[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] / N[(1.0 - N[(0.5 * N[(delta * delta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;theta \leq -0.72:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{\sin theta \cdot delta}{\cos delta}\\
\mathbf{elif}\;theta \leq 10^{+19}:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{theta \cdot \sin delta}{\cos delta}\\
\mathbf{else}:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{\sin theta \cdot \sin delta}{1 - 0.5 \cdot \left(delta \cdot delta\right)}\\
\end{array}
\end{array}
if theta < -0.71999999999999997Initial program 99.8%
Taylor expanded in phi1 around 0
lift-cos.f6489.0
Applied rewrites89.0%
Taylor expanded in phi1 around 0
*-commutativeN/A
lift-sin.f64N/A
lift-sin.f64N/A
lift-*.f6486.6
Applied rewrites86.6%
Taylor expanded in delta around 0
Applied rewrites75.0%
if -0.71999999999999997 < theta < 1e19Initial program 99.8%
Taylor expanded in phi1 around 0
lift-cos.f6489.0
Applied rewrites89.0%
Taylor expanded in phi1 around 0
*-commutativeN/A
lift-sin.f64N/A
lift-sin.f64N/A
lift-*.f6486.6
Applied rewrites86.6%
Taylor expanded in theta around 0
Applied rewrites73.4%
if 1e19 < theta Initial program 99.8%
Taylor expanded in phi1 around 0
lift-cos.f6489.0
Applied rewrites89.0%
Taylor expanded in phi1 around 0
*-commutativeN/A
lift-sin.f64N/A
lift-sin.f64N/A
lift-*.f6486.6
Applied rewrites86.6%
Taylor expanded in delta around 0
fp-cancel-sign-sub-invN/A
lower--.f64N/A
metadata-evalN/A
lower-*.f64N/A
unpow2N/A
lower-*.f6478.0
Applied rewrites78.0%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(let* ((t_1 (+ lambda1 (atan2 (* (sin theta) delta) (cos delta)))))
(if (<= theta -0.72)
t_1
(if (<= theta 8500000000000.0)
(+ lambda1 (atan2 (* theta (sin delta)) (cos delta)))
t_1))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double t_1 = lambda1 + atan2((sin(theta) * delta), cos(delta));
double tmp;
if (theta <= -0.72) {
tmp = t_1;
} else if (theta <= 8500000000000.0) {
tmp = lambda1 + atan2((theta * sin(delta)), cos(delta));
} else {
tmp = t_1;
}
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) :: t_1
real(8) :: tmp
t_1 = lambda1 + atan2((sin(theta) * delta), cos(delta))
if (theta <= (-0.72d0)) then
tmp = t_1
else if (theta <= 8500000000000.0d0) then
tmp = lambda1 + atan2((theta * sin(delta)), cos(delta))
else
tmp = t_1
end if
code = tmp
end function
public static double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double t_1 = lambda1 + Math.atan2((Math.sin(theta) * delta), Math.cos(delta));
double tmp;
if (theta <= -0.72) {
tmp = t_1;
} else if (theta <= 8500000000000.0) {
tmp = lambda1 + Math.atan2((theta * Math.sin(delta)), Math.cos(delta));
} else {
tmp = t_1;
}
return tmp;
}
def code(lambda1, phi1, phi2, delta, theta): t_1 = lambda1 + math.atan2((math.sin(theta) * delta), math.cos(delta)) tmp = 0 if theta <= -0.72: tmp = t_1 elif theta <= 8500000000000.0: tmp = lambda1 + math.atan2((theta * math.sin(delta)), math.cos(delta)) else: tmp = t_1 return tmp
function code(lambda1, phi1, phi2, delta, theta) t_1 = Float64(lambda1 + atan(Float64(sin(theta) * delta), cos(delta))) tmp = 0.0 if (theta <= -0.72) tmp = t_1; elseif (theta <= 8500000000000.0) tmp = Float64(lambda1 + atan(Float64(theta * sin(delta)), cos(delta))); else tmp = t_1; end return tmp end
function tmp_2 = code(lambda1, phi1, phi2, delta, theta) t_1 = lambda1 + atan2((sin(theta) * delta), cos(delta)); tmp = 0.0; if (theta <= -0.72) tmp = t_1; elseif (theta <= 8500000000000.0) tmp = lambda1 + atan2((theta * sin(delta)), cos(delta)); else tmp = t_1; end tmp_2 = tmp; end
code[lambda1_, phi1_, phi2_, delta_, theta_] := Block[{t$95$1 = N[(lambda1 + N[ArcTan[N[(N[Sin[theta], $MachinePrecision] * delta), $MachinePrecision] / N[Cos[delta], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[theta, -0.72], t$95$1, If[LessEqual[theta, 8500000000000.0], N[(lambda1 + N[ArcTan[N[(theta * N[Sin[delta], $MachinePrecision]), $MachinePrecision] / N[Cos[delta], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], t$95$1]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \lambda_1 + \tan^{-1}_* \frac{\sin theta \cdot delta}{\cos delta}\\
\mathbf{if}\;theta \leq -0.72:\\
\;\;\;\;t\_1\\
\mathbf{elif}\;theta \leq 8500000000000:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{theta \cdot \sin delta}{\cos delta}\\
\mathbf{else}:\\
\;\;\;\;t\_1\\
\end{array}
\end{array}
if theta < -0.71999999999999997 or 8.5e12 < theta Initial program 99.8%
Taylor expanded in phi1 around 0
lift-cos.f6489.0
Applied rewrites89.0%
Taylor expanded in phi1 around 0
*-commutativeN/A
lift-sin.f64N/A
lift-sin.f64N/A
lift-*.f6486.6
Applied rewrites86.6%
Taylor expanded in delta around 0
Applied rewrites75.0%
if -0.71999999999999997 < theta < 8.5e12Initial program 99.8%
Taylor expanded in phi1 around 0
lift-cos.f6489.0
Applied rewrites89.0%
Taylor expanded in phi1 around 0
*-commutativeN/A
lift-sin.f64N/A
lift-sin.f64N/A
lift-*.f6486.6
Applied rewrites86.6%
Taylor expanded in theta around 0
Applied rewrites73.4%
(FPCore (lambda1 phi1 phi2 delta theta) :precision binary64 (+ lambda1 (atan2 (* theta (sin delta)) (cos delta))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 + atan2((theta * sin(delta)), 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((theta * sin(delta)), cos(delta))
end function
public static double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 + Math.atan2((theta * Math.sin(delta)), Math.cos(delta));
}
def code(lambda1, phi1, phi2, delta, theta): return lambda1 + math.atan2((theta * math.sin(delta)), math.cos(delta))
function code(lambda1, phi1, phi2, delta, theta) return Float64(lambda1 + atan(Float64(theta * sin(delta)), cos(delta))) end
function tmp = code(lambda1, phi1, phi2, delta, theta) tmp = lambda1 + atan2((theta * sin(delta)), cos(delta)); end
code[lambda1_, phi1_, phi2_, delta_, theta_] := N[(lambda1 + N[ArcTan[N[(theta * N[Sin[delta], $MachinePrecision]), $MachinePrecision] / N[Cos[delta], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\lambda_1 + \tan^{-1}_* \frac{theta \cdot \sin delta}{\cos delta}
\end{array}
Initial program 99.8%
Taylor expanded in phi1 around 0
lift-cos.f6489.0
Applied rewrites89.0%
Taylor expanded in phi1 around 0
*-commutativeN/A
lift-sin.f64N/A
lift-sin.f64N/A
lift-*.f6486.6
Applied rewrites86.6%
Taylor expanded in theta around 0
Applied rewrites73.4%
(FPCore (lambda1 phi1 phi2 delta theta) :precision binary64 (+ lambda1 (atan2 (* theta (sin delta)) (- 1.0 (* 0.5 (* delta delta))))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 + atan2((theta * sin(delta)), (1.0 - (0.5 * (delta * 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((theta * sin(delta)), (1.0d0 - (0.5d0 * (delta * delta))))
end function
public static double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 + Math.atan2((theta * Math.sin(delta)), (1.0 - (0.5 * (delta * delta))));
}
def code(lambda1, phi1, phi2, delta, theta): return lambda1 + math.atan2((theta * math.sin(delta)), (1.0 - (0.5 * (delta * delta))))
function code(lambda1, phi1, phi2, delta, theta) return Float64(lambda1 + atan(Float64(theta * sin(delta)), Float64(1.0 - Float64(0.5 * Float64(delta * delta))))) end
function tmp = code(lambda1, phi1, phi2, delta, theta) tmp = lambda1 + atan2((theta * sin(delta)), (1.0 - (0.5 * (delta * delta)))); end
code[lambda1_, phi1_, phi2_, delta_, theta_] := N[(lambda1 + N[ArcTan[N[(theta * N[Sin[delta], $MachinePrecision]), $MachinePrecision] / N[(1.0 - N[(0.5 * N[(delta * delta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\lambda_1 + \tan^{-1}_* \frac{theta \cdot \sin delta}{1 - 0.5 \cdot \left(delta \cdot delta\right)}
\end{array}
Initial program 99.8%
Taylor expanded in phi1 around 0
lift-cos.f6489.0
Applied rewrites89.0%
Taylor expanded in phi1 around 0
*-commutativeN/A
lift-sin.f64N/A
lift-sin.f64N/A
lift-*.f6486.6
Applied rewrites86.6%
Taylor expanded in theta around 0
Applied rewrites73.4%
Taylor expanded in delta around 0
fp-cancel-sign-sub-invN/A
lower--.f64N/A
metadata-evalN/A
lower-*.f64N/A
pow2N/A
lift-*.f6470.0
Applied rewrites70.0%
(FPCore (lambda1 phi1 phi2 delta theta) :precision binary64 (+ lambda1 (atan2 (* theta delta) (cos delta))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 + atan2((theta * delta), 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((theta * delta), cos(delta))
end function
public static double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 + Math.atan2((theta * delta), Math.cos(delta));
}
def code(lambda1, phi1, phi2, delta, theta): return lambda1 + math.atan2((theta * delta), math.cos(delta))
function code(lambda1, phi1, phi2, delta, theta) return Float64(lambda1 + atan(Float64(theta * delta), cos(delta))) end
function tmp = code(lambda1, phi1, phi2, delta, theta) tmp = lambda1 + atan2((theta * delta), cos(delta)); end
code[lambda1_, phi1_, phi2_, delta_, theta_] := N[(lambda1 + N[ArcTan[N[(theta * delta), $MachinePrecision] / N[Cos[delta], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\lambda_1 + \tan^{-1}_* \frac{theta \cdot delta}{\cos delta}
\end{array}
Initial program 99.8%
Taylor expanded in phi1 around 0
lift-cos.f6489.0
Applied rewrites89.0%
Taylor expanded in phi1 around 0
*-commutativeN/A
lift-sin.f64N/A
lift-sin.f64N/A
lift-*.f6486.6
Applied rewrites86.6%
Taylor expanded in theta around 0
Applied rewrites73.4%
Taylor expanded in delta around 0
Applied rewrites67.6%
herbie shell --seed 2025131
(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))))))))))