
(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))))))));
}
real(8) function code(lambda1, phi1, phi2, delta, theta)
real(8), intent (in) :: lambda1
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8), intent (in) :: delta
real(8), intent (in) :: theta
code = lambda1 + atan2(((sin(theta) * sin(delta)) * cos(phi1)), (cos(delta) - (sin(phi1) * sin(asin(((sin(phi1) * cos(delta)) + ((cos(phi1) * sin(delta)) * cos(theta))))))))
end function
public static double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 + Math.atan2(((Math.sin(theta) * Math.sin(delta)) * Math.cos(phi1)), (Math.cos(delta) - (Math.sin(phi1) * Math.sin(Math.asin(((Math.sin(phi1) * Math.cos(delta)) + ((Math.cos(phi1) * Math.sin(delta)) * Math.cos(theta))))))));
}
def code(lambda1, phi1, phi2, delta, theta): return lambda1 + math.atan2(((math.sin(theta) * math.sin(delta)) * math.cos(phi1)), (math.cos(delta) - (math.sin(phi1) * math.sin(math.asin(((math.sin(phi1) * math.cos(delta)) + ((math.cos(phi1) * math.sin(delta)) * math.cos(theta))))))))
function code(lambda1, phi1, phi2, delta, theta) return Float64(lambda1 + atan(Float64(Float64(sin(theta) * sin(delta)) * cos(phi1)), Float64(cos(delta) - Float64(sin(phi1) * sin(asin(Float64(Float64(sin(phi1) * cos(delta)) + Float64(Float64(cos(phi1) * sin(delta)) * cos(theta))))))))) end
function tmp = code(lambda1, phi1, phi2, delta, theta) tmp = lambda1 + atan2(((sin(theta) * sin(delta)) * cos(phi1)), (cos(delta) - (sin(phi1) * sin(asin(((sin(phi1) * cos(delta)) + ((cos(phi1) * sin(delta)) * cos(theta)))))))); end
code[lambda1_, phi1_, phi2_, delta_, theta_] := N[(lambda1 + N[ArcTan[N[(N[(N[Sin[theta], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] / N[(N[Cos[delta], $MachinePrecision] - N[(N[Sin[phi1], $MachinePrecision] * N[Sin[N[ArcSin[N[(N[(N[Sin[phi1], $MachinePrecision] * N[Cos[delta], $MachinePrecision]), $MachinePrecision] + N[(N[(N[Cos[phi1], $MachinePrecision] * N[Sin[delta], $MachinePrecision]), $MachinePrecision] * N[Cos[theta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\lambda_1 + \tan^{-1}_* \frac{\left(\sin theta \cdot \sin delta\right) \cdot \cos \phi_1}{\cos delta - \sin \phi_1 \cdot \sin \sin^{-1} \left(\sin \phi_1 \cdot \cos delta + \left(\cos \phi_1 \cdot \sin delta\right) \cdot \cos theta\right)}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 15 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))))))));
}
real(8) function code(lambda1, phi1, phi2, delta, theta)
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
(+
(atan2
(* (* (sin delta) (cos phi1)) (sin theta))
(*
(cos phi1)
(- (* (cos phi1) (cos delta)) (* (cos theta) (* (sin delta) (sin phi1))))))
lambda1))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return atan2(((sin(delta) * cos(phi1)) * sin(theta)), (cos(phi1) * ((cos(phi1) * cos(delta)) - (cos(theta) * (sin(delta) * sin(phi1)))))) + lambda1;
}
real(8) function code(lambda1, phi1, phi2, delta, theta)
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 = atan2(((sin(delta) * cos(phi1)) * sin(theta)), (cos(phi1) * ((cos(phi1) * cos(delta)) - (cos(theta) * (sin(delta) * sin(phi1)))))) + lambda1
end function
public static double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return Math.atan2(((Math.sin(delta) * Math.cos(phi1)) * Math.sin(theta)), (Math.cos(phi1) * ((Math.cos(phi1) * Math.cos(delta)) - (Math.cos(theta) * (Math.sin(delta) * Math.sin(phi1)))))) + lambda1;
}
def code(lambda1, phi1, phi2, delta, theta): return math.atan2(((math.sin(delta) * math.cos(phi1)) * math.sin(theta)), (math.cos(phi1) * ((math.cos(phi1) * math.cos(delta)) - (math.cos(theta) * (math.sin(delta) * math.sin(phi1)))))) + lambda1
function code(lambda1, phi1, phi2, delta, theta) return Float64(atan(Float64(Float64(sin(delta) * cos(phi1)) * sin(theta)), Float64(cos(phi1) * Float64(Float64(cos(phi1) * cos(delta)) - Float64(cos(theta) * Float64(sin(delta) * sin(phi1)))))) + lambda1) end
function tmp = code(lambda1, phi1, phi2, delta, theta) tmp = atan2(((sin(delta) * cos(phi1)) * sin(theta)), (cos(phi1) * ((cos(phi1) * cos(delta)) - (cos(theta) * (sin(delta) * sin(phi1)))))) + lambda1; end
code[lambda1_, phi1_, phi2_, delta_, theta_] := N[(N[ArcTan[N[(N[(N[Sin[delta], $MachinePrecision] * N[Cos[phi1], $MachinePrecision]), $MachinePrecision] * N[Sin[theta], $MachinePrecision]), $MachinePrecision] / N[(N[Cos[phi1], $MachinePrecision] * N[(N[(N[Cos[phi1], $MachinePrecision] * N[Cos[delta], $MachinePrecision]), $MachinePrecision] - N[(N[Cos[theta], $MachinePrecision] * N[(N[Sin[delta], $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + lambda1), $MachinePrecision]
\begin{array}{l}
\\
\tan^{-1}_* \frac{\left(\sin delta \cdot \cos \phi_1\right) \cdot \sin theta}{\cos \phi_1 \cdot \left(\cos \phi_1 \cdot \cos delta - \cos theta \cdot \left(\sin delta \cdot \sin \phi_1\right)\right)} + \lambda_1
\end{array}
Initial program 99.8%
Taylor expanded in lambda1 around 0
+-commutativeN/A
+-lowering-+.f64N/A
Simplified99.8%
Taylor expanded in lambda1 around inf
*-lowering-*.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
Simplified99.9%
Taylor expanded in lambda1 around 0
+-commutativeN/A
+-lowering-+.f64N/A
Simplified99.9%
Taylor expanded in phi1 around 0
atan2-lowering-atan2.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
cos-lowering-cos.f64N/A
sin-lowering-sin.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.9%
Final simplification99.9%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(+
lambda1
(atan2
(* (cos phi1) (* (sin delta) (sin theta)))
(-
(* (cos delta) (pow (cos phi1) 2.0))
(* (cos phi1) (* (sin delta) (sin phi1)))))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 + atan2((cos(phi1) * (sin(delta) * sin(theta))), ((cos(delta) * pow(cos(phi1), 2.0)) - (cos(phi1) * (sin(delta) * sin(phi1)))));
}
real(8) function code(lambda1, phi1, phi2, delta, theta)
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((cos(phi1) * (sin(delta) * sin(theta))), ((cos(delta) * (cos(phi1) ** 2.0d0)) - (cos(phi1) * (sin(delta) * sin(phi1)))))
end function
public static double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 + Math.atan2((Math.cos(phi1) * (Math.sin(delta) * Math.sin(theta))), ((Math.cos(delta) * Math.pow(Math.cos(phi1), 2.0)) - (Math.cos(phi1) * (Math.sin(delta) * Math.sin(phi1)))));
}
def code(lambda1, phi1, phi2, delta, theta): return lambda1 + math.atan2((math.cos(phi1) * (math.sin(delta) * math.sin(theta))), ((math.cos(delta) * math.pow(math.cos(phi1), 2.0)) - (math.cos(phi1) * (math.sin(delta) * math.sin(phi1)))))
function code(lambda1, phi1, phi2, delta, theta) return Float64(lambda1 + atan(Float64(cos(phi1) * Float64(sin(delta) * sin(theta))), Float64(Float64(cos(delta) * (cos(phi1) ^ 2.0)) - Float64(cos(phi1) * Float64(sin(delta) * sin(phi1)))))) end
function tmp = code(lambda1, phi1, phi2, delta, theta) tmp = lambda1 + atan2((cos(phi1) * (sin(delta) * sin(theta))), ((cos(delta) * (cos(phi1) ^ 2.0)) - (cos(phi1) * (sin(delta) * sin(phi1))))); end
code[lambda1_, phi1_, phi2_, delta_, theta_] := N[(lambda1 + N[ArcTan[N[(N[Cos[phi1], $MachinePrecision] * N[(N[Sin[delta], $MachinePrecision] * N[Sin[theta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(N[Cos[delta], $MachinePrecision] * N[Power[N[Cos[phi1], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] - N[(N[Cos[phi1], $MachinePrecision] * N[(N[Sin[delta], $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\lambda_1 + \tan^{-1}_* \frac{\cos \phi_1 \cdot \left(\sin delta \cdot \sin theta\right)}{\cos delta \cdot {\cos \phi_1}^{2} - \cos \phi_1 \cdot \left(\sin delta \cdot \sin \phi_1\right)}
\end{array}
Initial program 99.8%
Taylor expanded in lambda1 around 0
+-commutativeN/A
+-lowering-+.f64N/A
Simplified99.8%
Taylor expanded in theta around 0
--lowering--.f64N/A
unpow2N/A
1-sub-sinN/A
unpow2N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
pow-lowering-pow.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
sin-lowering-sin.f6496.2%
Simplified96.2%
Final simplification96.2%
(FPCore (lambda1 phi1 phi2 delta theta) :precision binary64 (+ lambda1 (atan2 (* (cos phi1) (* (sin delta) (sin theta))) (* (cos phi1) (- (* (cos phi1) (cos delta)) (* (sin delta) (sin phi1)))))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 + atan2((cos(phi1) * (sin(delta) * sin(theta))), (cos(phi1) * ((cos(phi1) * cos(delta)) - (sin(delta) * sin(phi1)))));
}
real(8) function code(lambda1, phi1, phi2, delta, theta)
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((cos(phi1) * (sin(delta) * sin(theta))), (cos(phi1) * ((cos(phi1) * cos(delta)) - (sin(delta) * sin(phi1)))))
end function
public static double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 + Math.atan2((Math.cos(phi1) * (Math.sin(delta) * Math.sin(theta))), (Math.cos(phi1) * ((Math.cos(phi1) * Math.cos(delta)) - (Math.sin(delta) * Math.sin(phi1)))));
}
def code(lambda1, phi1, phi2, delta, theta): return lambda1 + math.atan2((math.cos(phi1) * (math.sin(delta) * math.sin(theta))), (math.cos(phi1) * ((math.cos(phi1) * math.cos(delta)) - (math.sin(delta) * math.sin(phi1)))))
function code(lambda1, phi1, phi2, delta, theta) return Float64(lambda1 + atan(Float64(cos(phi1) * Float64(sin(delta) * sin(theta))), Float64(cos(phi1) * Float64(Float64(cos(phi1) * cos(delta)) - Float64(sin(delta) * sin(phi1)))))) end
function tmp = code(lambda1, phi1, phi2, delta, theta) tmp = lambda1 + atan2((cos(phi1) * (sin(delta) * sin(theta))), (cos(phi1) * ((cos(phi1) * cos(delta)) - (sin(delta) * sin(phi1))))); end
code[lambda1_, phi1_, phi2_, delta_, theta_] := N[(lambda1 + N[ArcTan[N[(N[Cos[phi1], $MachinePrecision] * N[(N[Sin[delta], $MachinePrecision] * N[Sin[theta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[Cos[phi1], $MachinePrecision] * N[(N[(N[Cos[phi1], $MachinePrecision] * N[Cos[delta], $MachinePrecision]), $MachinePrecision] - N[(N[Sin[delta], $MachinePrecision] * N[Sin[phi1], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\lambda_1 + \tan^{-1}_* \frac{\cos \phi_1 \cdot \left(\sin delta \cdot \sin theta\right)}{\cos \phi_1 \cdot \left(\cos \phi_1 \cdot \cos delta - \sin delta \cdot \sin \phi_1\right)}
\end{array}
Initial program 99.8%
Taylor expanded in lambda1 around 0
+-commutativeN/A
+-lowering-+.f64N/A
Simplified99.8%
Taylor expanded in lambda1 around inf
*-lowering-*.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
Simplified99.9%
Taylor expanded in lambda1 around 0
+-commutativeN/A
+-lowering-+.f64N/A
Simplified99.9%
Taylor expanded in theta around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
sin-lowering-sin.f6496.2%
Simplified96.2%
Final simplification96.2%
(FPCore (lambda1 phi1 phi2 delta theta) :precision binary64 (+ lambda1 (atan2 (* (cos phi1) (* (sin delta) (sin theta))) (- (cos delta) (pow (sin phi1) 2.0)))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 + atan2((cos(phi1) * (sin(delta) * sin(theta))), (cos(delta) - pow(sin(phi1), 2.0)));
}
real(8) function code(lambda1, phi1, phi2, delta, theta)
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((cos(phi1) * (sin(delta) * sin(theta))), (cos(delta) - (sin(phi1) ** 2.0d0)))
end function
public static double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 + Math.atan2((Math.cos(phi1) * (Math.sin(delta) * Math.sin(theta))), (Math.cos(delta) - Math.pow(Math.sin(phi1), 2.0)));
}
def code(lambda1, phi1, phi2, delta, theta): return lambda1 + math.atan2((math.cos(phi1) * (math.sin(delta) * math.sin(theta))), (math.cos(delta) - math.pow(math.sin(phi1), 2.0)))
function code(lambda1, phi1, phi2, delta, theta) return Float64(lambda1 + atan(Float64(cos(phi1) * Float64(sin(delta) * sin(theta))), Float64(cos(delta) - (sin(phi1) ^ 2.0)))) end
function tmp = code(lambda1, phi1, phi2, delta, theta) tmp = lambda1 + atan2((cos(phi1) * (sin(delta) * sin(theta))), (cos(delta) - (sin(phi1) ^ 2.0))); end
code[lambda1_, phi1_, phi2_, delta_, theta_] := N[(lambda1 + N[ArcTan[N[(N[Cos[phi1], $MachinePrecision] * N[(N[Sin[delta], $MachinePrecision] * N[Sin[theta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[Cos[delta], $MachinePrecision] - N[Power[N[Sin[phi1], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\lambda_1 + \tan^{-1}_* \frac{\cos \phi_1 \cdot \left(\sin delta \cdot \sin theta\right)}{\cos delta - {\sin \phi_1}^{2}}
\end{array}
Initial program 99.8%
Taylor expanded in delta around 0
pow-lowering-pow.f64N/A
sin-lowering-sin.f6493.6%
Simplified93.6%
Final simplification93.6%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(let* ((t_1 (* (cos phi1) (* (sin delta) (sin theta))))
(t_2 (+ lambda1 (atan2 t_1 (cos delta)))))
(if (<= delta -1.95e-6)
t_2
(if (<= delta 1.25e-5)
(* lambda1 (+ 1.0 (/ (atan2 t_1 (pow (cos phi1) 2.0)) lambda1)))
t_2))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double t_1 = cos(phi1) * (sin(delta) * sin(theta));
double t_2 = lambda1 + atan2(t_1, cos(delta));
double tmp;
if (delta <= -1.95e-6) {
tmp = t_2;
} else if (delta <= 1.25e-5) {
tmp = lambda1 * (1.0 + (atan2(t_1, pow(cos(phi1), 2.0)) / lambda1));
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(lambda1, phi1, phi2, delta, theta)
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 = cos(phi1) * (sin(delta) * sin(theta))
t_2 = lambda1 + atan2(t_1, cos(delta))
if (delta <= (-1.95d-6)) then
tmp = t_2
else if (delta <= 1.25d-5) then
tmp = lambda1 * (1.0d0 + (atan2(t_1, (cos(phi1) ** 2.0d0)) / lambda1))
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.cos(phi1) * (Math.sin(delta) * Math.sin(theta));
double t_2 = lambda1 + Math.atan2(t_1, Math.cos(delta));
double tmp;
if (delta <= -1.95e-6) {
tmp = t_2;
} else if (delta <= 1.25e-5) {
tmp = lambda1 * (1.0 + (Math.atan2(t_1, Math.pow(Math.cos(phi1), 2.0)) / lambda1));
} else {
tmp = t_2;
}
return tmp;
}
def code(lambda1, phi1, phi2, delta, theta): t_1 = math.cos(phi1) * (math.sin(delta) * math.sin(theta)) t_2 = lambda1 + math.atan2(t_1, math.cos(delta)) tmp = 0 if delta <= -1.95e-6: tmp = t_2 elif delta <= 1.25e-5: tmp = lambda1 * (1.0 + (math.atan2(t_1, math.pow(math.cos(phi1), 2.0)) / lambda1)) else: tmp = t_2 return tmp
function code(lambda1, phi1, phi2, delta, theta) t_1 = Float64(cos(phi1) * Float64(sin(delta) * sin(theta))) t_2 = Float64(lambda1 + atan(t_1, cos(delta))) tmp = 0.0 if (delta <= -1.95e-6) tmp = t_2; elseif (delta <= 1.25e-5) tmp = Float64(lambda1 * Float64(1.0 + Float64(atan(t_1, (cos(phi1) ^ 2.0)) / lambda1))); else tmp = t_2; end return tmp end
function tmp_2 = code(lambda1, phi1, phi2, delta, theta) t_1 = cos(phi1) * (sin(delta) * sin(theta)); t_2 = lambda1 + atan2(t_1, cos(delta)); tmp = 0.0; if (delta <= -1.95e-6) tmp = t_2; elseif (delta <= 1.25e-5) tmp = lambda1 * (1.0 + (atan2(t_1, (cos(phi1) ^ 2.0)) / lambda1)); else tmp = t_2; end tmp_2 = tmp; end
code[lambda1_, phi1_, phi2_, delta_, theta_] := Block[{t$95$1 = N[(N[Cos[phi1], $MachinePrecision] * N[(N[Sin[delta], $MachinePrecision] * N[Sin[theta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(lambda1 + N[ArcTan[t$95$1 / N[Cos[delta], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[delta, -1.95e-6], t$95$2, If[LessEqual[delta, 1.25e-5], N[(lambda1 * N[(1.0 + N[(N[ArcTan[t$95$1 / N[Power[N[Cos[phi1], $MachinePrecision], 2.0], $MachinePrecision]], $MachinePrecision] / lambda1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \cos \phi_1 \cdot \left(\sin delta \cdot \sin theta\right)\\
t_2 := \lambda_1 + \tan^{-1}_* \frac{t\_1}{\cos delta}\\
\mathbf{if}\;delta \leq -1.95 \cdot 10^{-6}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;delta \leq 1.25 \cdot 10^{-5}:\\
\;\;\;\;\lambda_1 \cdot \left(1 + \frac{\tan^{-1}_* \frac{t\_1}{{\cos \phi_1}^{2}}}{\lambda_1}\right)\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if delta < -1.95e-6 or 1.25000000000000006e-5 < delta Initial program 99.7%
Taylor expanded in phi1 around 0
cos-lowering-cos.f6486.4%
Simplified86.4%
if -1.95e-6 < delta < 1.25000000000000006e-5Initial program 99.8%
Taylor expanded in lambda1 around 0
+-commutativeN/A
+-lowering-+.f64N/A
Simplified99.8%
Taylor expanded in lambda1 around inf
*-lowering-*.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
Simplified99.9%
Taylor expanded in delta around 0
pow-lowering-pow.f64N/A
cos-lowering-cos.f6499.4%
Simplified99.4%
Final simplification92.6%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(let* ((t_1 (* (cos phi1) (* (sin delta) (sin theta))))
(t_2 (+ lambda1 (atan2 t_1 (cos delta)))))
(if (<= delta -6.2e-5)
t_2
(if (<= delta 2.05e-7)
(+ 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 = cos(phi1) * (sin(delta) * sin(theta));
double t_2 = lambda1 + atan2(t_1, cos(delta));
double tmp;
if (delta <= -6.2e-5) {
tmp = t_2;
} else if (delta <= 2.05e-7) {
tmp = lambda1 + atan2(t_1, pow(cos(phi1), 2.0));
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(lambda1, phi1, phi2, delta, theta)
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 = cos(phi1) * (sin(delta) * sin(theta))
t_2 = lambda1 + atan2(t_1, cos(delta))
if (delta <= (-6.2d-5)) then
tmp = t_2
else if (delta <= 2.05d-7) 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.cos(phi1) * (Math.sin(delta) * Math.sin(theta));
double t_2 = lambda1 + Math.atan2(t_1, Math.cos(delta));
double tmp;
if (delta <= -6.2e-5) {
tmp = t_2;
} else if (delta <= 2.05e-7) {
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.cos(phi1) * (math.sin(delta) * math.sin(theta)) t_2 = lambda1 + math.atan2(t_1, math.cos(delta)) tmp = 0 if delta <= -6.2e-5: tmp = t_2 elif delta <= 2.05e-7: 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(cos(phi1) * Float64(sin(delta) * sin(theta))) t_2 = Float64(lambda1 + atan(t_1, cos(delta))) tmp = 0.0 if (delta <= -6.2e-5) tmp = t_2; elseif (delta <= 2.05e-7) 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 = cos(phi1) * (sin(delta) * sin(theta)); t_2 = lambda1 + atan2(t_1, cos(delta)); tmp = 0.0; if (delta <= -6.2e-5) tmp = t_2; elseif (delta <= 2.05e-7) 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[Cos[phi1], $MachinePrecision] * N[(N[Sin[delta], $MachinePrecision] * N[Sin[theta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(lambda1 + N[ArcTan[t$95$1 / N[Cos[delta], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[delta, -6.2e-5], t$95$2, If[LessEqual[delta, 2.05e-7], 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 := \cos \phi_1 \cdot \left(\sin delta \cdot \sin theta\right)\\
t_2 := \lambda_1 + \tan^{-1}_* \frac{t\_1}{\cos delta}\\
\mathbf{if}\;delta \leq -6.2 \cdot 10^{-5}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;delta \leq 2.05 \cdot 10^{-7}:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{t\_1}{{\cos \phi_1}^{2}}\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if delta < -6.20000000000000027e-5 or 2.05e-7 < delta Initial program 99.7%
Taylor expanded in phi1 around 0
cos-lowering-cos.f6486.4%
Simplified86.4%
if -6.20000000000000027e-5 < delta < 2.05e-7Initial program 99.8%
Taylor expanded in lambda1 around 0
+-commutativeN/A
+-lowering-+.f64N/A
Simplified99.8%
Taylor expanded in delta around 0
unpow2N/A
1-sub-sinN/A
unpow2N/A
pow-lowering-pow.f64N/A
cos-lowering-cos.f6499.4%
Simplified99.4%
Final simplification92.5%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(let* ((t_1 (* (cos phi1) (* (sin delta) (sin theta))))
(t_2 (+ lambda1 (atan2 t_1 (cos delta)))))
(if (<= delta -1.36e-6)
t_2
(if (<= delta 1.6e-5)
(+ lambda1 (atan2 t_1 (+ 0.5 (* 0.5 (cos (* phi1 2.0))))))
t_2))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double t_1 = cos(phi1) * (sin(delta) * sin(theta));
double t_2 = lambda1 + atan2(t_1, cos(delta));
double tmp;
if (delta <= -1.36e-6) {
tmp = t_2;
} else if (delta <= 1.6e-5) {
tmp = lambda1 + atan2(t_1, (0.5 + (0.5 * cos((phi1 * 2.0)))));
} else {
tmp = t_2;
}
return tmp;
}
real(8) function code(lambda1, phi1, phi2, delta, theta)
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 = cos(phi1) * (sin(delta) * sin(theta))
t_2 = lambda1 + atan2(t_1, cos(delta))
if (delta <= (-1.36d-6)) then
tmp = t_2
else if (delta <= 1.6d-5) then
tmp = lambda1 + atan2(t_1, (0.5d0 + (0.5d0 * 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.cos(phi1) * (Math.sin(delta) * Math.sin(theta));
double t_2 = lambda1 + Math.atan2(t_1, Math.cos(delta));
double tmp;
if (delta <= -1.36e-6) {
tmp = t_2;
} else if (delta <= 1.6e-5) {
tmp = lambda1 + Math.atan2(t_1, (0.5 + (0.5 * Math.cos((phi1 * 2.0)))));
} else {
tmp = t_2;
}
return tmp;
}
def code(lambda1, phi1, phi2, delta, theta): t_1 = math.cos(phi1) * (math.sin(delta) * math.sin(theta)) t_2 = lambda1 + math.atan2(t_1, math.cos(delta)) tmp = 0 if delta <= -1.36e-6: tmp = t_2 elif delta <= 1.6e-5: tmp = lambda1 + math.atan2(t_1, (0.5 + (0.5 * math.cos((phi1 * 2.0))))) else: tmp = t_2 return tmp
function code(lambda1, phi1, phi2, delta, theta) t_1 = Float64(cos(phi1) * Float64(sin(delta) * sin(theta))) t_2 = Float64(lambda1 + atan(t_1, cos(delta))) tmp = 0.0 if (delta <= -1.36e-6) tmp = t_2; elseif (delta <= 1.6e-5) tmp = Float64(lambda1 + atan(t_1, Float64(0.5 + Float64(0.5 * cos(Float64(phi1 * 2.0)))))); else tmp = t_2; end return tmp end
function tmp_2 = code(lambda1, phi1, phi2, delta, theta) t_1 = cos(phi1) * (sin(delta) * sin(theta)); t_2 = lambda1 + atan2(t_1, cos(delta)); tmp = 0.0; if (delta <= -1.36e-6) tmp = t_2; elseif (delta <= 1.6e-5) tmp = lambda1 + atan2(t_1, (0.5 + (0.5 * 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[Cos[phi1], $MachinePrecision] * N[(N[Sin[delta], $MachinePrecision] * N[Sin[theta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(lambda1 + N[ArcTan[t$95$1 / N[Cos[delta], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[delta, -1.36e-6], t$95$2, If[LessEqual[delta, 1.6e-5], N[(lambda1 + N[ArcTan[t$95$1 / N[(0.5 + N[(0.5 * N[Cos[N[(phi1 * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], t$95$2]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \cos \phi_1 \cdot \left(\sin delta \cdot \sin theta\right)\\
t_2 := \lambda_1 + \tan^{-1}_* \frac{t\_1}{\cos delta}\\
\mathbf{if}\;delta \leq -1.36 \cdot 10^{-6}:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;delta \leq 1.6 \cdot 10^{-5}:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{t\_1}{0.5 + 0.5 \cdot \cos \left(\phi_1 \cdot 2\right)}\\
\mathbf{else}:\\
\;\;\;\;t\_2\\
\end{array}
\end{array}
if delta < -1.3599999999999999e-6 or 1.59999999999999993e-5 < delta Initial program 99.7%
Taylor expanded in phi1 around 0
cos-lowering-cos.f6486.4%
Simplified86.4%
if -1.3599999999999999e-6 < delta < 1.59999999999999993e-5Initial program 99.8%
sin-asinN/A
+-commutativeN/A
distribute-rgt-inN/A
associate--r+N/A
associate-*r*N/A
*-commutativeN/A
--lowering--.f64N/A
Applied egg-rr99.8%
Taylor expanded in delta around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f6499.4%
Simplified99.4%
Final simplification92.5%
(FPCore (lambda1 phi1 phi2 delta theta) :precision binary64 (+ lambda1 (atan2 (* (cos phi1) (* (sin delta) (sin theta))) (cos delta))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 + atan2((cos(phi1) * (sin(delta) * sin(theta))), cos(delta));
}
real(8) function code(lambda1, phi1, phi2, delta, theta)
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((cos(phi1) * (sin(delta) * sin(theta))), cos(delta))
end function
public static double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 + Math.atan2((Math.cos(phi1) * (Math.sin(delta) * Math.sin(theta))), Math.cos(delta));
}
def code(lambda1, phi1, phi2, delta, theta): return lambda1 + math.atan2((math.cos(phi1) * (math.sin(delta) * math.sin(theta))), math.cos(delta))
function code(lambda1, phi1, phi2, delta, theta) return Float64(lambda1 + atan(Float64(cos(phi1) * Float64(sin(delta) * sin(theta))), cos(delta))) end
function tmp = code(lambda1, phi1, phi2, delta, theta) tmp = lambda1 + atan2((cos(phi1) * (sin(delta) * sin(theta))), cos(delta)); end
code[lambda1_, phi1_, phi2_, delta_, theta_] := N[(lambda1 + N[ArcTan[N[(N[Cos[phi1], $MachinePrecision] * N[(N[Sin[delta], $MachinePrecision] * N[Sin[theta], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Cos[delta], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\lambda_1 + \tan^{-1}_* \frac{\cos \phi_1 \cdot \left(\sin delta \cdot \sin theta\right)}{\cos delta}
\end{array}
Initial program 99.8%
Taylor expanded in phi1 around 0
cos-lowering-cos.f6489.3%
Simplified89.3%
Final simplification89.3%
(FPCore (lambda1 phi1 phi2 delta theta) :precision binary64 (* lambda1 (+ 1.0 (/ (atan2 (* (sin delta) (sin theta)) (cos delta)) lambda1))))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 * (1.0 + (atan2((sin(delta) * sin(theta)), cos(delta)) / lambda1));
}
real(8) function code(lambda1, phi1, phi2, delta, theta)
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 * (1.0d0 + (atan2((sin(delta) * sin(theta)), cos(delta)) / lambda1))
end function
public static double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1 * (1.0 + (Math.atan2((Math.sin(delta) * Math.sin(theta)), Math.cos(delta)) / lambda1));
}
def code(lambda1, phi1, phi2, delta, theta): return lambda1 * (1.0 + (math.atan2((math.sin(delta) * math.sin(theta)), math.cos(delta)) / lambda1))
function code(lambda1, phi1, phi2, delta, theta) return Float64(lambda1 * Float64(1.0 + Float64(atan(Float64(sin(delta) * sin(theta)), cos(delta)) / lambda1))) end
function tmp = code(lambda1, phi1, phi2, delta, theta) tmp = lambda1 * (1.0 + (atan2((sin(delta) * sin(theta)), cos(delta)) / lambda1)); end
code[lambda1_, phi1_, phi2_, delta_, theta_] := N[(lambda1 * N[(1.0 + N[(N[ArcTan[N[(N[Sin[delta], $MachinePrecision] * N[Sin[theta], $MachinePrecision]), $MachinePrecision] / N[Cos[delta], $MachinePrecision]], $MachinePrecision] / lambda1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\lambda_1 \cdot \left(1 + \frac{\tan^{-1}_* \frac{\sin delta \cdot \sin theta}{\cos delta}}{\lambda_1}\right)
\end{array}
Initial program 99.8%
Taylor expanded in lambda1 around 0
+-commutativeN/A
+-lowering-+.f64N/A
Simplified99.8%
Taylor expanded in lambda1 around inf
*-lowering-*.f64N/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
Simplified99.9%
Taylor expanded in phi1 around 0
cos-lowering-cos.f6489.3%
Simplified89.3%
Taylor expanded in phi1 around 0
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
sin-lowering-sin.f6488.1%
Simplified88.1%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(if (<= phi1 -5.1e+49)
lambda1
(if (<= phi1 1.0)
(+
lambda1
(atan2
(* (* (sin delta) (sin theta)) (+ 1.0 (* phi1 (* phi1 -0.5))))
(- 1.0 (* phi1 phi1))))
lambda1)))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double tmp;
if (phi1 <= -5.1e+49) {
tmp = lambda1;
} else if (phi1 <= 1.0) {
tmp = lambda1 + atan2(((sin(delta) * sin(theta)) * (1.0 + (phi1 * (phi1 * -0.5)))), (1.0 - (phi1 * phi1)));
} else {
tmp = lambda1;
}
return tmp;
}
real(8) function code(lambda1, phi1, phi2, delta, theta)
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 (phi1 <= (-5.1d+49)) then
tmp = lambda1
else if (phi1 <= 1.0d0) then
tmp = lambda1 + atan2(((sin(delta) * sin(theta)) * (1.0d0 + (phi1 * (phi1 * (-0.5d0))))), (1.0d0 - (phi1 * phi1)))
else
tmp = lambda1
end if
code = tmp
end function
public static double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double tmp;
if (phi1 <= -5.1e+49) {
tmp = lambda1;
} else if (phi1 <= 1.0) {
tmp = lambda1 + Math.atan2(((Math.sin(delta) * Math.sin(theta)) * (1.0 + (phi1 * (phi1 * -0.5)))), (1.0 - (phi1 * phi1)));
} else {
tmp = lambda1;
}
return tmp;
}
def code(lambda1, phi1, phi2, delta, theta): tmp = 0 if phi1 <= -5.1e+49: tmp = lambda1 elif phi1 <= 1.0: tmp = lambda1 + math.atan2(((math.sin(delta) * math.sin(theta)) * (1.0 + (phi1 * (phi1 * -0.5)))), (1.0 - (phi1 * phi1))) else: tmp = lambda1 return tmp
function code(lambda1, phi1, phi2, delta, theta) tmp = 0.0 if (phi1 <= -5.1e+49) tmp = lambda1; elseif (phi1 <= 1.0) tmp = Float64(lambda1 + atan(Float64(Float64(sin(delta) * sin(theta)) * Float64(1.0 + Float64(phi1 * Float64(phi1 * -0.5)))), Float64(1.0 - Float64(phi1 * phi1)))); else tmp = lambda1; end return tmp end
function tmp_2 = code(lambda1, phi1, phi2, delta, theta) tmp = 0.0; if (phi1 <= -5.1e+49) tmp = lambda1; elseif (phi1 <= 1.0) tmp = lambda1 + atan2(((sin(delta) * sin(theta)) * (1.0 + (phi1 * (phi1 * -0.5)))), (1.0 - (phi1 * phi1))); else tmp = lambda1; end tmp_2 = tmp; end
code[lambda1_, phi1_, phi2_, delta_, theta_] := If[LessEqual[phi1, -5.1e+49], lambda1, If[LessEqual[phi1, 1.0], N[(lambda1 + N[ArcTan[N[(N[(N[Sin[delta], $MachinePrecision] * N[Sin[theta], $MachinePrecision]), $MachinePrecision] * N[(1.0 + N[(phi1 * N[(phi1 * -0.5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(1.0 - N[(phi1 * phi1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], lambda1]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_1 \leq -5.1 \cdot 10^{+49}:\\
\;\;\;\;\lambda_1\\
\mathbf{elif}\;\phi_1 \leq 1:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{\left(\sin delta \cdot \sin theta\right) \cdot \left(1 + \phi_1 \cdot \left(\phi_1 \cdot -0.5\right)\right)}{1 - \phi_1 \cdot \phi_1}\\
\mathbf{else}:\\
\;\;\;\;\lambda_1\\
\end{array}
\end{array}
if phi1 < -5.09999999999999956e49 or 1 < phi1 Initial program 99.7%
Taylor expanded in lambda1 around inf
Simplified77.2%
if -5.09999999999999956e49 < phi1 < 1Initial program 99.9%
Taylor expanded in phi1 around 0
sub-negN/A
mul-1-negN/A
distribute-neg-outN/A
distribute-rgt-neg-outN/A
unsub-negN/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f6497.0%
Simplified97.0%
Taylor expanded in delta around 0
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f6474.9%
Simplified74.9%
Taylor expanded in phi1 around 0
associate-*r*N/A
distribute-lft1-inN/A
+-commutativeN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
unpow2N/A
associate-*l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
sin-lowering-sin.f6474.8%
Simplified74.8%
Final simplification75.9%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(if (<= phi1 -1.1)
lambda1
(if (<= phi1 1.55)
(+ lambda1 (atan2 (* (sin delta) (sin theta)) (- 1.0 (* phi1 phi1))))
lambda1)))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double tmp;
if (phi1 <= -1.1) {
tmp = lambda1;
} else if (phi1 <= 1.55) {
tmp = lambda1 + atan2((sin(delta) * sin(theta)), (1.0 - (phi1 * phi1)));
} else {
tmp = lambda1;
}
return tmp;
}
real(8) function code(lambda1, phi1, phi2, delta, theta)
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 (phi1 <= (-1.1d0)) then
tmp = lambda1
else if (phi1 <= 1.55d0) then
tmp = lambda1 + atan2((sin(delta) * sin(theta)), (1.0d0 - (phi1 * phi1)))
else
tmp = lambda1
end if
code = tmp
end function
public static double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double tmp;
if (phi1 <= -1.1) {
tmp = lambda1;
} else if (phi1 <= 1.55) {
tmp = lambda1 + Math.atan2((Math.sin(delta) * Math.sin(theta)), (1.0 - (phi1 * phi1)));
} else {
tmp = lambda1;
}
return tmp;
}
def code(lambda1, phi1, phi2, delta, theta): tmp = 0 if phi1 <= -1.1: tmp = lambda1 elif phi1 <= 1.55: tmp = lambda1 + math.atan2((math.sin(delta) * math.sin(theta)), (1.0 - (phi1 * phi1))) else: tmp = lambda1 return tmp
function code(lambda1, phi1, phi2, delta, theta) tmp = 0.0 if (phi1 <= -1.1) tmp = lambda1; elseif (phi1 <= 1.55) tmp = Float64(lambda1 + atan(Float64(sin(delta) * sin(theta)), Float64(1.0 - Float64(phi1 * phi1)))); else tmp = lambda1; end return tmp end
function tmp_2 = code(lambda1, phi1, phi2, delta, theta) tmp = 0.0; if (phi1 <= -1.1) tmp = lambda1; elseif (phi1 <= 1.55) tmp = lambda1 + atan2((sin(delta) * sin(theta)), (1.0 - (phi1 * phi1))); else tmp = lambda1; end tmp_2 = tmp; end
code[lambda1_, phi1_, phi2_, delta_, theta_] := If[LessEqual[phi1, -1.1], lambda1, If[LessEqual[phi1, 1.55], N[(lambda1 + N[ArcTan[N[(N[Sin[delta], $MachinePrecision] * N[Sin[theta], $MachinePrecision]), $MachinePrecision] / N[(1.0 - N[(phi1 * phi1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], lambda1]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_1 \leq -1.1:\\
\;\;\;\;\lambda_1\\
\mathbf{elif}\;\phi_1 \leq 1.55:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{\sin delta \cdot \sin theta}{1 - \phi_1 \cdot \phi_1}\\
\mathbf{else}:\\
\;\;\;\;\lambda_1\\
\end{array}
\end{array}
if phi1 < -1.1000000000000001 or 1.55000000000000004 < phi1 Initial program 99.6%
Taylor expanded in lambda1 around inf
Simplified74.8%
if -1.1000000000000001 < phi1 < 1.55000000000000004Initial program 99.9%
Taylor expanded in phi1 around 0
sub-negN/A
mul-1-negN/A
distribute-neg-outN/A
distribute-rgt-neg-outN/A
unsub-negN/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f6499.7%
Simplified99.7%
Taylor expanded in delta around 0
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f6476.3%
Simplified76.3%
Taylor expanded in phi1 around 0
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
sin-lowering-sin.f6476.3%
Simplified76.3%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(if (<= phi1 -0.0006)
lambda1
(if (<= phi1 0.94)
(+
lambda1
(atan2
(*
(sin theta)
(*
delta
(+
1.0
(*
(* delta delta)
(+
-0.16666666666666666
(*
(* delta delta)
(+
0.008333333333333333
(* (* delta delta) -0.0001984126984126984))))))))
(- 1.0 (* phi1 phi1))))
lambda1)))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double tmp;
if (phi1 <= -0.0006) {
tmp = lambda1;
} else if (phi1 <= 0.94) {
tmp = lambda1 + atan2((sin(theta) * (delta * (1.0 + ((delta * delta) * (-0.16666666666666666 + ((delta * delta) * (0.008333333333333333 + ((delta * delta) * -0.0001984126984126984)))))))), (1.0 - (phi1 * phi1)));
} else {
tmp = lambda1;
}
return tmp;
}
real(8) function code(lambda1, phi1, phi2, delta, theta)
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 (phi1 <= (-0.0006d0)) then
tmp = lambda1
else if (phi1 <= 0.94d0) then
tmp = lambda1 + atan2((sin(theta) * (delta * (1.0d0 + ((delta * delta) * ((-0.16666666666666666d0) + ((delta * delta) * (0.008333333333333333d0 + ((delta * delta) * (-0.0001984126984126984d0))))))))), (1.0d0 - (phi1 * phi1)))
else
tmp = lambda1
end if
code = tmp
end function
public static double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double tmp;
if (phi1 <= -0.0006) {
tmp = lambda1;
} else if (phi1 <= 0.94) {
tmp = lambda1 + Math.atan2((Math.sin(theta) * (delta * (1.0 + ((delta * delta) * (-0.16666666666666666 + ((delta * delta) * (0.008333333333333333 + ((delta * delta) * -0.0001984126984126984)))))))), (1.0 - (phi1 * phi1)));
} else {
tmp = lambda1;
}
return tmp;
}
def code(lambda1, phi1, phi2, delta, theta): tmp = 0 if phi1 <= -0.0006: tmp = lambda1 elif phi1 <= 0.94: tmp = lambda1 + math.atan2((math.sin(theta) * (delta * (1.0 + ((delta * delta) * (-0.16666666666666666 + ((delta * delta) * (0.008333333333333333 + ((delta * delta) * -0.0001984126984126984)))))))), (1.0 - (phi1 * phi1))) else: tmp = lambda1 return tmp
function code(lambda1, phi1, phi2, delta, theta) tmp = 0.0 if (phi1 <= -0.0006) tmp = lambda1; elseif (phi1 <= 0.94) tmp = Float64(lambda1 + atan(Float64(sin(theta) * Float64(delta * Float64(1.0 + Float64(Float64(delta * delta) * Float64(-0.16666666666666666 + Float64(Float64(delta * delta) * Float64(0.008333333333333333 + Float64(Float64(delta * delta) * -0.0001984126984126984)))))))), Float64(1.0 - Float64(phi1 * phi1)))); else tmp = lambda1; end return tmp end
function tmp_2 = code(lambda1, phi1, phi2, delta, theta) tmp = 0.0; if (phi1 <= -0.0006) tmp = lambda1; elseif (phi1 <= 0.94) tmp = lambda1 + atan2((sin(theta) * (delta * (1.0 + ((delta * delta) * (-0.16666666666666666 + ((delta * delta) * (0.008333333333333333 + ((delta * delta) * -0.0001984126984126984)))))))), (1.0 - (phi1 * phi1))); else tmp = lambda1; end tmp_2 = tmp; end
code[lambda1_, phi1_, phi2_, delta_, theta_] := If[LessEqual[phi1, -0.0006], lambda1, If[LessEqual[phi1, 0.94], N[(lambda1 + N[ArcTan[N[(N[Sin[theta], $MachinePrecision] * N[(delta * N[(1.0 + N[(N[(delta * delta), $MachinePrecision] * N[(-0.16666666666666666 + N[(N[(delta * delta), $MachinePrecision] * N[(0.008333333333333333 + N[(N[(delta * delta), $MachinePrecision] * -0.0001984126984126984), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(1.0 - N[(phi1 * phi1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], lambda1]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_1 \leq -0.0006:\\
\;\;\;\;\lambda_1\\
\mathbf{elif}\;\phi_1 \leq 0.94:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{\sin theta \cdot \left(delta \cdot \left(1 + \left(delta \cdot delta\right) \cdot \left(-0.16666666666666666 + \left(delta \cdot delta\right) \cdot \left(0.008333333333333333 + \left(delta \cdot delta\right) \cdot -0.0001984126984126984\right)\right)\right)\right)}{1 - \phi_1 \cdot \phi_1}\\
\mathbf{else}:\\
\;\;\;\;\lambda_1\\
\end{array}
\end{array}
if phi1 < -5.99999999999999947e-4 or 0.93999999999999995 < phi1 Initial program 99.6%
Taylor expanded in lambda1 around inf
Simplified74.4%
if -5.99999999999999947e-4 < phi1 < 0.93999999999999995Initial program 99.9%
Taylor expanded in phi1 around 0
sub-negN/A
mul-1-negN/A
distribute-neg-outN/A
distribute-rgt-neg-outN/A
unsub-negN/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f6499.9%
Simplified99.9%
Taylor expanded in delta around 0
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f6476.5%
Simplified76.5%
Taylor expanded in phi1 around 0
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
sin-lowering-sin.f6476.5%
Simplified76.5%
Taylor expanded in delta around 0
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
sub-negN/A
metadata-evalN/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6475.6%
Simplified75.6%
Final simplification75.0%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(if (<= phi1 -0.00074)
lambda1
(if (<= phi1 1.55)
(+
lambda1
(atan2
(*
(sin theta)
(* delta (+ 1.0 (* (* delta delta) -0.16666666666666666))))
(- 1.0 (* phi1 phi1))))
lambda1)))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double tmp;
if (phi1 <= -0.00074) {
tmp = lambda1;
} else if (phi1 <= 1.55) {
tmp = lambda1 + atan2((sin(theta) * (delta * (1.0 + ((delta * delta) * -0.16666666666666666)))), (1.0 - (phi1 * phi1)));
} else {
tmp = lambda1;
}
return tmp;
}
real(8) function code(lambda1, phi1, phi2, delta, theta)
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 (phi1 <= (-0.00074d0)) then
tmp = lambda1
else if (phi1 <= 1.55d0) then
tmp = lambda1 + atan2((sin(theta) * (delta * (1.0d0 + ((delta * delta) * (-0.16666666666666666d0))))), (1.0d0 - (phi1 * phi1)))
else
tmp = lambda1
end if
code = tmp
end function
public static double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double tmp;
if (phi1 <= -0.00074) {
tmp = lambda1;
} else if (phi1 <= 1.55) {
tmp = lambda1 + Math.atan2((Math.sin(theta) * (delta * (1.0 + ((delta * delta) * -0.16666666666666666)))), (1.0 - (phi1 * phi1)));
} else {
tmp = lambda1;
}
return tmp;
}
def code(lambda1, phi1, phi2, delta, theta): tmp = 0 if phi1 <= -0.00074: tmp = lambda1 elif phi1 <= 1.55: tmp = lambda1 + math.atan2((math.sin(theta) * (delta * (1.0 + ((delta * delta) * -0.16666666666666666)))), (1.0 - (phi1 * phi1))) else: tmp = lambda1 return tmp
function code(lambda1, phi1, phi2, delta, theta) tmp = 0.0 if (phi1 <= -0.00074) tmp = lambda1; elseif (phi1 <= 1.55) tmp = Float64(lambda1 + atan(Float64(sin(theta) * Float64(delta * Float64(1.0 + Float64(Float64(delta * delta) * -0.16666666666666666)))), Float64(1.0 - Float64(phi1 * phi1)))); else tmp = lambda1; end return tmp end
function tmp_2 = code(lambda1, phi1, phi2, delta, theta) tmp = 0.0; if (phi1 <= -0.00074) tmp = lambda1; elseif (phi1 <= 1.55) tmp = lambda1 + atan2((sin(theta) * (delta * (1.0 + ((delta * delta) * -0.16666666666666666)))), (1.0 - (phi1 * phi1))); else tmp = lambda1; end tmp_2 = tmp; end
code[lambda1_, phi1_, phi2_, delta_, theta_] := If[LessEqual[phi1, -0.00074], lambda1, If[LessEqual[phi1, 1.55], N[(lambda1 + N[ArcTan[N[(N[Sin[theta], $MachinePrecision] * N[(delta * N[(1.0 + N[(N[(delta * delta), $MachinePrecision] * -0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(1.0 - N[(phi1 * phi1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], lambda1]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_1 \leq -0.00074:\\
\;\;\;\;\lambda_1\\
\mathbf{elif}\;\phi_1 \leq 1.55:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{\sin theta \cdot \left(delta \cdot \left(1 + \left(delta \cdot delta\right) \cdot -0.16666666666666666\right)\right)}{1 - \phi_1 \cdot \phi_1}\\
\mathbf{else}:\\
\;\;\;\;\lambda_1\\
\end{array}
\end{array}
if phi1 < -7.3999999999999999e-4 or 1.55000000000000004 < phi1 Initial program 99.6%
Taylor expanded in lambda1 around inf
Simplified74.4%
if -7.3999999999999999e-4 < phi1 < 1.55000000000000004Initial program 99.9%
Taylor expanded in phi1 around 0
sub-negN/A
mul-1-negN/A
distribute-neg-outN/A
distribute-rgt-neg-outN/A
unsub-negN/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f6499.9%
Simplified99.9%
Taylor expanded in delta around 0
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f6476.5%
Simplified76.5%
Taylor expanded in phi1 around 0
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
sin-lowering-sin.f6476.5%
Simplified76.5%
Taylor expanded in delta around 0
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6475.4%
Simplified75.4%
Final simplification74.9%
(FPCore (lambda1 phi1 phi2 delta theta)
:precision binary64
(if (<= phi1 -4.6e+49)
lambda1
(if (<= phi1 5e-76)
(+ lambda1 (atan2 (* delta (sin theta)) (- 1.0 (* phi1 phi1))))
lambda1)))
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double tmp;
if (phi1 <= -4.6e+49) {
tmp = lambda1;
} else if (phi1 <= 5e-76) {
tmp = lambda1 + atan2((delta * sin(theta)), (1.0 - (phi1 * phi1)));
} else {
tmp = lambda1;
}
return tmp;
}
real(8) function code(lambda1, phi1, phi2, delta, theta)
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 (phi1 <= (-4.6d+49)) then
tmp = lambda1
else if (phi1 <= 5d-76) then
tmp = lambda1 + atan2((delta * sin(theta)), (1.0d0 - (phi1 * phi1)))
else
tmp = lambda1
end if
code = tmp
end function
public static double code(double lambda1, double phi1, double phi2, double delta, double theta) {
double tmp;
if (phi1 <= -4.6e+49) {
tmp = lambda1;
} else if (phi1 <= 5e-76) {
tmp = lambda1 + Math.atan2((delta * Math.sin(theta)), (1.0 - (phi1 * phi1)));
} else {
tmp = lambda1;
}
return tmp;
}
def code(lambda1, phi1, phi2, delta, theta): tmp = 0 if phi1 <= -4.6e+49: tmp = lambda1 elif phi1 <= 5e-76: tmp = lambda1 + math.atan2((delta * math.sin(theta)), (1.0 - (phi1 * phi1))) else: tmp = lambda1 return tmp
function code(lambda1, phi1, phi2, delta, theta) tmp = 0.0 if (phi1 <= -4.6e+49) tmp = lambda1; elseif (phi1 <= 5e-76) tmp = Float64(lambda1 + atan(Float64(delta * sin(theta)), Float64(1.0 - Float64(phi1 * phi1)))); else tmp = lambda1; end return tmp end
function tmp_2 = code(lambda1, phi1, phi2, delta, theta) tmp = 0.0; if (phi1 <= -4.6e+49) tmp = lambda1; elseif (phi1 <= 5e-76) tmp = lambda1 + atan2((delta * sin(theta)), (1.0 - (phi1 * phi1))); else tmp = lambda1; end tmp_2 = tmp; end
code[lambda1_, phi1_, phi2_, delta_, theta_] := If[LessEqual[phi1, -4.6e+49], lambda1, If[LessEqual[phi1, 5e-76], N[(lambda1 + N[ArcTan[N[(delta * N[Sin[theta], $MachinePrecision]), $MachinePrecision] / N[(1.0 - N[(phi1 * phi1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], lambda1]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\phi_1 \leq -4.6 \cdot 10^{+49}:\\
\;\;\;\;\lambda_1\\
\mathbf{elif}\;\phi_1 \leq 5 \cdot 10^{-76}:\\
\;\;\;\;\lambda_1 + \tan^{-1}_* \frac{delta \cdot \sin theta}{1 - \phi_1 \cdot \phi_1}\\
\mathbf{else}:\\
\;\;\;\;\lambda_1\\
\end{array}
\end{array}
if phi1 < -4.60000000000000004e49 or 4.9999999999999998e-76 < phi1 Initial program 99.7%
Taylor expanded in lambda1 around inf
Simplified76.9%
if -4.60000000000000004e49 < phi1 < 4.9999999999999998e-76Initial program 99.8%
Taylor expanded in phi1 around 0
sub-negN/A
mul-1-negN/A
distribute-neg-outN/A
distribute-rgt-neg-outN/A
unsub-negN/A
--lowering--.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
cos-lowering-cos.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f6496.6%
Simplified96.6%
Taylor expanded in delta around 0
--lowering--.f64N/A
unpow2N/A
*-lowering-*.f6474.8%
Simplified74.8%
Taylor expanded in phi1 around 0
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
sin-lowering-sin.f6473.8%
Simplified73.8%
Taylor expanded in delta around 0
*-lowering-*.f64N/A
sin-lowering-sin.f6471.8%
Simplified71.8%
(FPCore (lambda1 phi1 phi2 delta theta) :precision binary64 lambda1)
double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1;
}
real(8) function code(lambda1, phi1, phi2, delta, theta)
real(8), intent (in) :: lambda1
real(8), intent (in) :: phi1
real(8), intent (in) :: phi2
real(8), intent (in) :: delta
real(8), intent (in) :: theta
code = lambda1
end function
public static double code(double lambda1, double phi1, double phi2, double delta, double theta) {
return lambda1;
}
def code(lambda1, phi1, phi2, delta, theta): return lambda1
function code(lambda1, phi1, phi2, delta, theta) return lambda1 end
function tmp = code(lambda1, phi1, phi2, delta, theta) tmp = lambda1; end
code[lambda1_, phi1_, phi2_, delta_, theta_] := lambda1
\begin{array}{l}
\\
\lambda_1
\end{array}
Initial program 99.8%
Taylor expanded in lambda1 around inf
Simplified70.9%
herbie shell --seed 2024191
(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))))))))))