
(FPCore (kx ky th) :precision binary64 (* (/ (sin ky) (sqrt (+ (pow (sin kx) 2.0) (pow (sin ky) 2.0)))) (sin th)))
double code(double kx, double ky, double th) {
return (sin(ky) / sqrt((pow(sin(kx), 2.0) + pow(sin(ky), 2.0)))) * sin(th);
}
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(kx, ky, th)
use fmin_fmax_functions
real(8), intent (in) :: kx
real(8), intent (in) :: ky
real(8), intent (in) :: th
code = (sin(ky) / sqrt(((sin(kx) ** 2.0d0) + (sin(ky) ** 2.0d0)))) * sin(th)
end function
public static double code(double kx, double ky, double th) {
return (Math.sin(ky) / Math.sqrt((Math.pow(Math.sin(kx), 2.0) + Math.pow(Math.sin(ky), 2.0)))) * Math.sin(th);
}
def code(kx, ky, th): return (math.sin(ky) / math.sqrt((math.pow(math.sin(kx), 2.0) + math.pow(math.sin(ky), 2.0)))) * math.sin(th)
function code(kx, ky, th) return Float64(Float64(sin(ky) / sqrt(Float64((sin(kx) ^ 2.0) + (sin(ky) ^ 2.0)))) * sin(th)) end
function tmp = code(kx, ky, th) tmp = (sin(ky) / sqrt(((sin(kx) ^ 2.0) + (sin(ky) ^ 2.0)))) * sin(th); end
code[kx_, ky_, th_] := N[(N[(N[Sin[ky], $MachinePrecision] / N[Sqrt[N[(N[Power[N[Sin[kx], $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[Sin[ky], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\sin ky}{\sqrt{{\sin kx}^{2} + {\sin ky}^{2}}} \cdot \sin th
\end{array}
Herbie found 12 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (kx ky th) :precision binary64 (* (/ (sin ky) (sqrt (+ (pow (sin kx) 2.0) (pow (sin ky) 2.0)))) (sin th)))
double code(double kx, double ky, double th) {
return (sin(ky) / sqrt((pow(sin(kx), 2.0) + pow(sin(ky), 2.0)))) * sin(th);
}
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(kx, ky, th)
use fmin_fmax_functions
real(8), intent (in) :: kx
real(8), intent (in) :: ky
real(8), intent (in) :: th
code = (sin(ky) / sqrt(((sin(kx) ** 2.0d0) + (sin(ky) ** 2.0d0)))) * sin(th)
end function
public static double code(double kx, double ky, double th) {
return (Math.sin(ky) / Math.sqrt((Math.pow(Math.sin(kx), 2.0) + Math.pow(Math.sin(ky), 2.0)))) * Math.sin(th);
}
def code(kx, ky, th): return (math.sin(ky) / math.sqrt((math.pow(math.sin(kx), 2.0) + math.pow(math.sin(ky), 2.0)))) * math.sin(th)
function code(kx, ky, th) return Float64(Float64(sin(ky) / sqrt(Float64((sin(kx) ^ 2.0) + (sin(ky) ^ 2.0)))) * sin(th)) end
function tmp = code(kx, ky, th) tmp = (sin(ky) / sqrt(((sin(kx) ^ 2.0) + (sin(ky) ^ 2.0)))) * sin(th); end
code[kx_, ky_, th_] := N[(N[(N[Sin[ky], $MachinePrecision] / N[Sqrt[N[(N[Power[N[Sin[kx], $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[Sin[ky], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\sin ky}{\sqrt{{\sin kx}^{2} + {\sin ky}^{2}}} \cdot \sin th
\end{array}
(FPCore (kx ky th) :precision binary64 (* (/ (sin ky) (hypot (sin ky) (sin kx))) (sin th)))
double code(double kx, double ky, double th) {
return (sin(ky) / hypot(sin(ky), sin(kx))) * sin(th);
}
public static double code(double kx, double ky, double th) {
return (Math.sin(ky) / Math.hypot(Math.sin(ky), Math.sin(kx))) * Math.sin(th);
}
def code(kx, ky, th): return (math.sin(ky) / math.hypot(math.sin(ky), math.sin(kx))) * math.sin(th)
function code(kx, ky, th) return Float64(Float64(sin(ky) / hypot(sin(ky), sin(kx))) * sin(th)) end
function tmp = code(kx, ky, th) tmp = (sin(ky) / hypot(sin(ky), sin(kx))) * sin(th); end
code[kx_, ky_, th_] := N[(N[(N[Sin[ky], $MachinePrecision] / N[Sqrt[N[Sin[ky], $MachinePrecision] ^ 2 + N[Sin[kx], $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\sin ky}{\mathsf{hypot}\left(\sin ky, \sin kx\right)} \cdot \sin th
\end{array}
Initial program 93.7%
lift-sqrt.f64N/A
lift-+.f64N/A
+-commutativeN/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
lower-hypot.f6499.7
Applied rewrites99.7%
(FPCore (kx ky th)
:precision binary64
(let* ((t_1 (/ (sin ky) (sqrt (+ (pow (sin kx) 2.0) (pow (sin ky) 2.0)))))
(t_2 (- 0.5 (* 0.5 (cos (* 2.0 ky)))))
(t_3
(* (/ (sin ky) (sqrt (+ (- 0.5 (* (cos (+ kx kx)) 0.5)) t_2))) th)))
(if (<= t_1 -0.998)
(* (/ (sin ky) (sqrt (+ (pow kx 2.0) t_2))) (sin th))
(if (<= t_1 -0.12)
t_3
(if (<= t_1 1e-44)
(* (/ (sin ky) (sqrt (- 0.5 (* 0.5 (cos (* 2.0 kx)))))) (sin th))
(if (<= t_1 0.2)
(* (/ (sin ky) (sin kx)) (sin th))
(if (<= t_1 0.997) t_3 (sin th))))))))
double code(double kx, double ky, double th) {
double t_1 = sin(ky) / sqrt((pow(sin(kx), 2.0) + pow(sin(ky), 2.0)));
double t_2 = 0.5 - (0.5 * cos((2.0 * ky)));
double t_3 = (sin(ky) / sqrt(((0.5 - (cos((kx + kx)) * 0.5)) + t_2))) * th;
double tmp;
if (t_1 <= -0.998) {
tmp = (sin(ky) / sqrt((pow(kx, 2.0) + t_2))) * sin(th);
} else if (t_1 <= -0.12) {
tmp = t_3;
} else if (t_1 <= 1e-44) {
tmp = (sin(ky) / sqrt((0.5 - (0.5 * cos((2.0 * kx)))))) * sin(th);
} else if (t_1 <= 0.2) {
tmp = (sin(ky) / sin(kx)) * sin(th);
} else if (t_1 <= 0.997) {
tmp = t_3;
} else {
tmp = sin(th);
}
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(kx, ky, th)
use fmin_fmax_functions
real(8), intent (in) :: kx
real(8), intent (in) :: ky
real(8), intent (in) :: th
real(8) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: tmp
t_1 = sin(ky) / sqrt(((sin(kx) ** 2.0d0) + (sin(ky) ** 2.0d0)))
t_2 = 0.5d0 - (0.5d0 * cos((2.0d0 * ky)))
t_3 = (sin(ky) / sqrt(((0.5d0 - (cos((kx + kx)) * 0.5d0)) + t_2))) * th
if (t_1 <= (-0.998d0)) then
tmp = (sin(ky) / sqrt(((kx ** 2.0d0) + t_2))) * sin(th)
else if (t_1 <= (-0.12d0)) then
tmp = t_3
else if (t_1 <= 1d-44) then
tmp = (sin(ky) / sqrt((0.5d0 - (0.5d0 * cos((2.0d0 * kx)))))) * sin(th)
else if (t_1 <= 0.2d0) then
tmp = (sin(ky) / sin(kx)) * sin(th)
else if (t_1 <= 0.997d0) then
tmp = t_3
else
tmp = sin(th)
end if
code = tmp
end function
public static double code(double kx, double ky, double th) {
double t_1 = Math.sin(ky) / Math.sqrt((Math.pow(Math.sin(kx), 2.0) + Math.pow(Math.sin(ky), 2.0)));
double t_2 = 0.5 - (0.5 * Math.cos((2.0 * ky)));
double t_3 = (Math.sin(ky) / Math.sqrt(((0.5 - (Math.cos((kx + kx)) * 0.5)) + t_2))) * th;
double tmp;
if (t_1 <= -0.998) {
tmp = (Math.sin(ky) / Math.sqrt((Math.pow(kx, 2.0) + t_2))) * Math.sin(th);
} else if (t_1 <= -0.12) {
tmp = t_3;
} else if (t_1 <= 1e-44) {
tmp = (Math.sin(ky) / Math.sqrt((0.5 - (0.5 * Math.cos((2.0 * kx)))))) * Math.sin(th);
} else if (t_1 <= 0.2) {
tmp = (Math.sin(ky) / Math.sin(kx)) * Math.sin(th);
} else if (t_1 <= 0.997) {
tmp = t_3;
} else {
tmp = Math.sin(th);
}
return tmp;
}
def code(kx, ky, th): t_1 = math.sin(ky) / math.sqrt((math.pow(math.sin(kx), 2.0) + math.pow(math.sin(ky), 2.0))) t_2 = 0.5 - (0.5 * math.cos((2.0 * ky))) t_3 = (math.sin(ky) / math.sqrt(((0.5 - (math.cos((kx + kx)) * 0.5)) + t_2))) * th tmp = 0 if t_1 <= -0.998: tmp = (math.sin(ky) / math.sqrt((math.pow(kx, 2.0) + t_2))) * math.sin(th) elif t_1 <= -0.12: tmp = t_3 elif t_1 <= 1e-44: tmp = (math.sin(ky) / math.sqrt((0.5 - (0.5 * math.cos((2.0 * kx)))))) * math.sin(th) elif t_1 <= 0.2: tmp = (math.sin(ky) / math.sin(kx)) * math.sin(th) elif t_1 <= 0.997: tmp = t_3 else: tmp = math.sin(th) return tmp
function code(kx, ky, th) t_1 = Float64(sin(ky) / sqrt(Float64((sin(kx) ^ 2.0) + (sin(ky) ^ 2.0)))) t_2 = Float64(0.5 - Float64(0.5 * cos(Float64(2.0 * ky)))) t_3 = Float64(Float64(sin(ky) / sqrt(Float64(Float64(0.5 - Float64(cos(Float64(kx + kx)) * 0.5)) + t_2))) * th) tmp = 0.0 if (t_1 <= -0.998) tmp = Float64(Float64(sin(ky) / sqrt(Float64((kx ^ 2.0) + t_2))) * sin(th)); elseif (t_1 <= -0.12) tmp = t_3; elseif (t_1 <= 1e-44) tmp = Float64(Float64(sin(ky) / sqrt(Float64(0.5 - Float64(0.5 * cos(Float64(2.0 * kx)))))) * sin(th)); elseif (t_1 <= 0.2) tmp = Float64(Float64(sin(ky) / sin(kx)) * sin(th)); elseif (t_1 <= 0.997) tmp = t_3; else tmp = sin(th); end return tmp end
function tmp_2 = code(kx, ky, th) t_1 = sin(ky) / sqrt(((sin(kx) ^ 2.0) + (sin(ky) ^ 2.0))); t_2 = 0.5 - (0.5 * cos((2.0 * ky))); t_3 = (sin(ky) / sqrt(((0.5 - (cos((kx + kx)) * 0.5)) + t_2))) * th; tmp = 0.0; if (t_1 <= -0.998) tmp = (sin(ky) / sqrt(((kx ^ 2.0) + t_2))) * sin(th); elseif (t_1 <= -0.12) tmp = t_3; elseif (t_1 <= 1e-44) tmp = (sin(ky) / sqrt((0.5 - (0.5 * cos((2.0 * kx)))))) * sin(th); elseif (t_1 <= 0.2) tmp = (sin(ky) / sin(kx)) * sin(th); elseif (t_1 <= 0.997) tmp = t_3; else tmp = sin(th); end tmp_2 = tmp; end
code[kx_, ky_, th_] := Block[{t$95$1 = N[(N[Sin[ky], $MachinePrecision] / N[Sqrt[N[(N[Power[N[Sin[kx], $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[Sin[ky], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(0.5 - N[(0.5 * N[Cos[N[(2.0 * ky), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(N[Sin[ky], $MachinePrecision] / N[Sqrt[N[(N[(0.5 - N[(N[Cos[N[(kx + kx), $MachinePrecision]], $MachinePrecision] * 0.5), $MachinePrecision]), $MachinePrecision] + t$95$2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * th), $MachinePrecision]}, If[LessEqual[t$95$1, -0.998], N[(N[(N[Sin[ky], $MachinePrecision] / N[Sqrt[N[(N[Power[kx, 2.0], $MachinePrecision] + t$95$2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, -0.12], t$95$3, If[LessEqual[t$95$1, 1e-44], N[(N[(N[Sin[ky], $MachinePrecision] / N[Sqrt[N[(0.5 - N[(0.5 * N[Cos[N[(2.0 * kx), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 0.2], N[(N[(N[Sin[ky], $MachinePrecision] / N[Sin[kx], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 0.997], t$95$3, N[Sin[th], $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\sin ky}{\sqrt{{\sin kx}^{2} + {\sin ky}^{2}}}\\
t_2 := 0.5 - 0.5 \cdot \cos \left(2 \cdot ky\right)\\
t_3 := \frac{\sin ky}{\sqrt{\left(0.5 - \cos \left(kx + kx\right) \cdot 0.5\right) + t\_2}} \cdot th\\
\mathbf{if}\;t\_1 \leq -0.998:\\
\;\;\;\;\frac{\sin ky}{\sqrt{{kx}^{2} + t\_2}} \cdot \sin th\\
\mathbf{elif}\;t\_1 \leq -0.12:\\
\;\;\;\;t\_3\\
\mathbf{elif}\;t\_1 \leq 10^{-44}:\\
\;\;\;\;\frac{\sin ky}{\sqrt{0.5 - 0.5 \cdot \cos \left(2 \cdot kx\right)}} \cdot \sin th\\
\mathbf{elif}\;t\_1 \leq 0.2:\\
\;\;\;\;\frac{\sin ky}{\sin kx} \cdot \sin th\\
\mathbf{elif}\;t\_1 \leq 0.997:\\
\;\;\;\;t\_3\\
\mathbf{else}:\\
\;\;\;\;\sin th\\
\end{array}
\end{array}
if (/.f64 (sin.f64 ky) (sqrt.f64 (+.f64 (pow.f64 (sin.f64 kx) #s(literal 2 binary64)) (pow.f64 (sin.f64 ky) #s(literal 2 binary64))))) < -0.998Initial program 85.8%
lift-pow.f64N/A
unpow2N/A
lift-sin.f64N/A
lift-sin.f64N/A
sqr-sin-aN/A
lower--.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
lower-*.f6464.0
Applied rewrites64.0%
lift-pow.f64N/A
pow2N/A
lift-sin.f64N/A
lift-sin.f64N/A
sqr-sin-aN/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
count-2-revN/A
lower-cos.f64N/A
count-2-revN/A
lower-*.f6463.6
Applied rewrites63.6%
lift--.f64N/A
flip--N/A
metadata-evalN/A
lift-*.f64N/A
lift--.f64N/A
lift-+.f64N/A
lift-/.f6463.6
lift-*.f64N/A
pow2N/A
lower-pow.f6463.6
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6463.6
Applied rewrites63.6%
Taylor expanded in kx around 0
lower-pow.f6462.6
Applied rewrites62.6%
if -0.998 < (/.f64 (sin.f64 ky) (sqrt.f64 (+.f64 (pow.f64 (sin.f64 kx) #s(literal 2 binary64)) (pow.f64 (sin.f64 ky) #s(literal 2 binary64))))) < -0.12 or 0.20000000000000001 < (/.f64 (sin.f64 ky) (sqrt.f64 (+.f64 (pow.f64 (sin.f64 kx) #s(literal 2 binary64)) (pow.f64 (sin.f64 ky) #s(literal 2 binary64))))) < 0.996999999999999997Initial program 99.2%
lift-pow.f64N/A
unpow2N/A
lift-sin.f64N/A
lift-sin.f64N/A
sqr-sin-aN/A
lower--.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
lower-*.f6498.9
Applied rewrites98.9%
lift-pow.f64N/A
pow2N/A
lift-sin.f64N/A
lift-sin.f64N/A
sqr-sin-aN/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
count-2-revN/A
lower-cos.f64N/A
count-2-revN/A
lower-*.f6498.8
Applied rewrites98.8%
lift-*.f64N/A
count-2-revN/A
lower-+.f6498.8
Applied rewrites98.8%
Taylor expanded in th around 0
Applied rewrites50.3%
if -0.12 < (/.f64 (sin.f64 ky) (sqrt.f64 (+.f64 (pow.f64 (sin.f64 kx) #s(literal 2 binary64)) (pow.f64 (sin.f64 ky) #s(literal 2 binary64))))) < 9.99999999999999953e-45Initial program 99.2%
lift-pow.f64N/A
unpow2N/A
lift-sin.f64N/A
lift-sin.f64N/A
sqr-sin-aN/A
lower--.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
lower-*.f6499.0
Applied rewrites99.0%
lift-pow.f64N/A
pow2N/A
lift-sin.f64N/A
lift-sin.f64N/A
sqr-sin-aN/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
count-2-revN/A
lower-cos.f64N/A
count-2-revN/A
lower-*.f6474.0
Applied rewrites74.0%
lift-*.f64N/A
count-2-revN/A
lower-+.f6474.0
Applied rewrites74.0%
Taylor expanded in ky around 0
lower--.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
lower-*.f6472.7
Applied rewrites72.7%
if 9.99999999999999953e-45 < (/.f64 (sin.f64 ky) (sqrt.f64 (+.f64 (pow.f64 (sin.f64 kx) #s(literal 2 binary64)) (pow.f64 (sin.f64 ky) #s(literal 2 binary64))))) < 0.20000000000000001Initial program 99.0%
lift-sqrt.f64N/A
pow1/2N/A
sqr-powN/A
lower-*.f64N/A
lower-pow.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f64N/A
metadata-evalN/A
lower-pow.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f64N/A
metadata-eval98.7
Applied rewrites98.7%
lift-*.f64N/A
pow2N/A
lower-pow.f6498.7
Applied rewrites98.7%
Taylor expanded in ky around 0
lower-sin.f6439.8
Applied rewrites39.8%
if 0.996999999999999997 < (/.f64 (sin.f64 ky) (sqrt.f64 (+.f64 (pow.f64 (sin.f64 kx) #s(literal 2 binary64)) (pow.f64 (sin.f64 ky) #s(literal 2 binary64))))) Initial program 85.6%
lift-sqrt.f64N/A
pow1/2N/A
sqr-powN/A
lower-*.f64N/A
lower-pow.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f64N/A
metadata-evalN/A
lower-pow.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f64N/A
metadata-eval84.8
Applied rewrites84.8%
lift-*.f64N/A
pow2N/A
lower-pow.f6484.8
Applied rewrites84.8%
Taylor expanded in kx around 0
lower-sin.f6491.1
Applied rewrites91.1%
(FPCore (kx ky th)
:precision binary64
(let* ((t_1 (- 0.5 (* 0.5 (cos (* 2.0 ky)))))
(t_2 (/ (sin ky) (sqrt (+ (pow (sin kx) 2.0) (pow (sin ky) 2.0)))))
(t_3
(* (/ (sin ky) (sqrt (+ (- 0.5 (* (cos (+ kx kx)) 0.5)) t_1))) th)))
(if (<= t_2 -0.998)
(* (/ (sin ky) (sqrt t_1)) (sin th))
(if (<= t_2 -0.12)
t_3
(if (<= t_2 1e-44)
(* (/ (sin ky) (sqrt (- 0.5 (* 0.5 (cos (* 2.0 kx)))))) (sin th))
(if (<= t_2 0.2)
(* (/ (sin ky) (sin kx)) (sin th))
(if (<= t_2 0.997) t_3 (sin th))))))))
double code(double kx, double ky, double th) {
double t_1 = 0.5 - (0.5 * cos((2.0 * ky)));
double t_2 = sin(ky) / sqrt((pow(sin(kx), 2.0) + pow(sin(ky), 2.0)));
double t_3 = (sin(ky) / sqrt(((0.5 - (cos((kx + kx)) * 0.5)) + t_1))) * th;
double tmp;
if (t_2 <= -0.998) {
tmp = (sin(ky) / sqrt(t_1)) * sin(th);
} else if (t_2 <= -0.12) {
tmp = t_3;
} else if (t_2 <= 1e-44) {
tmp = (sin(ky) / sqrt((0.5 - (0.5 * cos((2.0 * kx)))))) * sin(th);
} else if (t_2 <= 0.2) {
tmp = (sin(ky) / sin(kx)) * sin(th);
} else if (t_2 <= 0.997) {
tmp = t_3;
} else {
tmp = sin(th);
}
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(kx, ky, th)
use fmin_fmax_functions
real(8), intent (in) :: kx
real(8), intent (in) :: ky
real(8), intent (in) :: th
real(8) :: t_1
real(8) :: t_2
real(8) :: t_3
real(8) :: tmp
t_1 = 0.5d0 - (0.5d0 * cos((2.0d0 * ky)))
t_2 = sin(ky) / sqrt(((sin(kx) ** 2.0d0) + (sin(ky) ** 2.0d0)))
t_3 = (sin(ky) / sqrt(((0.5d0 - (cos((kx + kx)) * 0.5d0)) + t_1))) * th
if (t_2 <= (-0.998d0)) then
tmp = (sin(ky) / sqrt(t_1)) * sin(th)
else if (t_2 <= (-0.12d0)) then
tmp = t_3
else if (t_2 <= 1d-44) then
tmp = (sin(ky) / sqrt((0.5d0 - (0.5d0 * cos((2.0d0 * kx)))))) * sin(th)
else if (t_2 <= 0.2d0) then
tmp = (sin(ky) / sin(kx)) * sin(th)
else if (t_2 <= 0.997d0) then
tmp = t_3
else
tmp = sin(th)
end if
code = tmp
end function
public static double code(double kx, double ky, double th) {
double t_1 = 0.5 - (0.5 * Math.cos((2.0 * ky)));
double t_2 = Math.sin(ky) / Math.sqrt((Math.pow(Math.sin(kx), 2.0) + Math.pow(Math.sin(ky), 2.0)));
double t_3 = (Math.sin(ky) / Math.sqrt(((0.5 - (Math.cos((kx + kx)) * 0.5)) + t_1))) * th;
double tmp;
if (t_2 <= -0.998) {
tmp = (Math.sin(ky) / Math.sqrt(t_1)) * Math.sin(th);
} else if (t_2 <= -0.12) {
tmp = t_3;
} else if (t_2 <= 1e-44) {
tmp = (Math.sin(ky) / Math.sqrt((0.5 - (0.5 * Math.cos((2.0 * kx)))))) * Math.sin(th);
} else if (t_2 <= 0.2) {
tmp = (Math.sin(ky) / Math.sin(kx)) * Math.sin(th);
} else if (t_2 <= 0.997) {
tmp = t_3;
} else {
tmp = Math.sin(th);
}
return tmp;
}
def code(kx, ky, th): t_1 = 0.5 - (0.5 * math.cos((2.0 * ky))) t_2 = math.sin(ky) / math.sqrt((math.pow(math.sin(kx), 2.0) + math.pow(math.sin(ky), 2.0))) t_3 = (math.sin(ky) / math.sqrt(((0.5 - (math.cos((kx + kx)) * 0.5)) + t_1))) * th tmp = 0 if t_2 <= -0.998: tmp = (math.sin(ky) / math.sqrt(t_1)) * math.sin(th) elif t_2 <= -0.12: tmp = t_3 elif t_2 <= 1e-44: tmp = (math.sin(ky) / math.sqrt((0.5 - (0.5 * math.cos((2.0 * kx)))))) * math.sin(th) elif t_2 <= 0.2: tmp = (math.sin(ky) / math.sin(kx)) * math.sin(th) elif t_2 <= 0.997: tmp = t_3 else: tmp = math.sin(th) return tmp
function code(kx, ky, th) t_1 = Float64(0.5 - Float64(0.5 * cos(Float64(2.0 * ky)))) t_2 = Float64(sin(ky) / sqrt(Float64((sin(kx) ^ 2.0) + (sin(ky) ^ 2.0)))) t_3 = Float64(Float64(sin(ky) / sqrt(Float64(Float64(0.5 - Float64(cos(Float64(kx + kx)) * 0.5)) + t_1))) * th) tmp = 0.0 if (t_2 <= -0.998) tmp = Float64(Float64(sin(ky) / sqrt(t_1)) * sin(th)); elseif (t_2 <= -0.12) tmp = t_3; elseif (t_2 <= 1e-44) tmp = Float64(Float64(sin(ky) / sqrt(Float64(0.5 - Float64(0.5 * cos(Float64(2.0 * kx)))))) * sin(th)); elseif (t_2 <= 0.2) tmp = Float64(Float64(sin(ky) / sin(kx)) * sin(th)); elseif (t_2 <= 0.997) tmp = t_3; else tmp = sin(th); end return tmp end
function tmp_2 = code(kx, ky, th) t_1 = 0.5 - (0.5 * cos((2.0 * ky))); t_2 = sin(ky) / sqrt(((sin(kx) ^ 2.0) + (sin(ky) ^ 2.0))); t_3 = (sin(ky) / sqrt(((0.5 - (cos((kx + kx)) * 0.5)) + t_1))) * th; tmp = 0.0; if (t_2 <= -0.998) tmp = (sin(ky) / sqrt(t_1)) * sin(th); elseif (t_2 <= -0.12) tmp = t_3; elseif (t_2 <= 1e-44) tmp = (sin(ky) / sqrt((0.5 - (0.5 * cos((2.0 * kx)))))) * sin(th); elseif (t_2 <= 0.2) tmp = (sin(ky) / sin(kx)) * sin(th); elseif (t_2 <= 0.997) tmp = t_3; else tmp = sin(th); end tmp_2 = tmp; end
code[kx_, ky_, th_] := Block[{t$95$1 = N[(0.5 - N[(0.5 * N[Cos[N[(2.0 * ky), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[Sin[ky], $MachinePrecision] / N[Sqrt[N[(N[Power[N[Sin[kx], $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[Sin[ky], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(N[Sin[ky], $MachinePrecision] / N[Sqrt[N[(N[(0.5 - N[(N[Cos[N[(kx + kx), $MachinePrecision]], $MachinePrecision] * 0.5), $MachinePrecision]), $MachinePrecision] + t$95$1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * th), $MachinePrecision]}, If[LessEqual[t$95$2, -0.998], N[(N[(N[Sin[ky], $MachinePrecision] / N[Sqrt[t$95$1], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, -0.12], t$95$3, If[LessEqual[t$95$2, 1e-44], N[(N[(N[Sin[ky], $MachinePrecision] / N[Sqrt[N[(0.5 - N[(0.5 * N[Cos[N[(2.0 * kx), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 0.2], N[(N[(N[Sin[ky], $MachinePrecision] / N[Sin[kx], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, 0.997], t$95$3, N[Sin[th], $MachinePrecision]]]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := 0.5 - 0.5 \cdot \cos \left(2 \cdot ky\right)\\
t_2 := \frac{\sin ky}{\sqrt{{\sin kx}^{2} + {\sin ky}^{2}}}\\
t_3 := \frac{\sin ky}{\sqrt{\left(0.5 - \cos \left(kx + kx\right) \cdot 0.5\right) + t\_1}} \cdot th\\
\mathbf{if}\;t\_2 \leq -0.998:\\
\;\;\;\;\frac{\sin ky}{\sqrt{t\_1}} \cdot \sin th\\
\mathbf{elif}\;t\_2 \leq -0.12:\\
\;\;\;\;t\_3\\
\mathbf{elif}\;t\_2 \leq 10^{-44}:\\
\;\;\;\;\frac{\sin ky}{\sqrt{0.5 - 0.5 \cdot \cos \left(2 \cdot kx\right)}} \cdot \sin th\\
\mathbf{elif}\;t\_2 \leq 0.2:\\
\;\;\;\;\frac{\sin ky}{\sin kx} \cdot \sin th\\
\mathbf{elif}\;t\_2 \leq 0.997:\\
\;\;\;\;t\_3\\
\mathbf{else}:\\
\;\;\;\;\sin th\\
\end{array}
\end{array}
if (/.f64 (sin.f64 ky) (sqrt.f64 (+.f64 (pow.f64 (sin.f64 kx) #s(literal 2 binary64)) (pow.f64 (sin.f64 ky) #s(literal 2 binary64))))) < -0.998Initial program 85.8%
lift-pow.f64N/A
unpow2N/A
lift-sin.f64N/A
lift-sin.f64N/A
sqr-sin-aN/A
lower--.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
lower-*.f6464.0
Applied rewrites64.0%
lift-pow.f64N/A
pow2N/A
lift-sin.f64N/A
lift-sin.f64N/A
sqr-sin-aN/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
count-2-revN/A
lower-cos.f64N/A
count-2-revN/A
lower-*.f6463.6
Applied rewrites63.6%
lift--.f64N/A
flip--N/A
metadata-evalN/A
lift-*.f64N/A
lift--.f64N/A
lift-+.f64N/A
lift-/.f6463.6
lift-*.f64N/A
pow2N/A
lower-pow.f6463.6
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6463.6
Applied rewrites63.6%
Taylor expanded in kx around 0
lower--.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
lower-*.f6462.4
Applied rewrites62.4%
if -0.998 < (/.f64 (sin.f64 ky) (sqrt.f64 (+.f64 (pow.f64 (sin.f64 kx) #s(literal 2 binary64)) (pow.f64 (sin.f64 ky) #s(literal 2 binary64))))) < -0.12 or 0.20000000000000001 < (/.f64 (sin.f64 ky) (sqrt.f64 (+.f64 (pow.f64 (sin.f64 kx) #s(literal 2 binary64)) (pow.f64 (sin.f64 ky) #s(literal 2 binary64))))) < 0.996999999999999997Initial program 99.2%
lift-pow.f64N/A
unpow2N/A
lift-sin.f64N/A
lift-sin.f64N/A
sqr-sin-aN/A
lower--.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
lower-*.f6498.9
Applied rewrites98.9%
lift-pow.f64N/A
pow2N/A
lift-sin.f64N/A
lift-sin.f64N/A
sqr-sin-aN/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
count-2-revN/A
lower-cos.f64N/A
count-2-revN/A
lower-*.f6498.8
Applied rewrites98.8%
lift-*.f64N/A
count-2-revN/A
lower-+.f6498.8
Applied rewrites98.8%
Taylor expanded in th around 0
Applied rewrites50.3%
if -0.12 < (/.f64 (sin.f64 ky) (sqrt.f64 (+.f64 (pow.f64 (sin.f64 kx) #s(literal 2 binary64)) (pow.f64 (sin.f64 ky) #s(literal 2 binary64))))) < 9.99999999999999953e-45Initial program 99.2%
lift-pow.f64N/A
unpow2N/A
lift-sin.f64N/A
lift-sin.f64N/A
sqr-sin-aN/A
lower--.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
lower-*.f6499.0
Applied rewrites99.0%
lift-pow.f64N/A
pow2N/A
lift-sin.f64N/A
lift-sin.f64N/A
sqr-sin-aN/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
count-2-revN/A
lower-cos.f64N/A
count-2-revN/A
lower-*.f6474.0
Applied rewrites74.0%
lift-*.f64N/A
count-2-revN/A
lower-+.f6474.0
Applied rewrites74.0%
Taylor expanded in ky around 0
lower--.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
lower-*.f6472.7
Applied rewrites72.7%
if 9.99999999999999953e-45 < (/.f64 (sin.f64 ky) (sqrt.f64 (+.f64 (pow.f64 (sin.f64 kx) #s(literal 2 binary64)) (pow.f64 (sin.f64 ky) #s(literal 2 binary64))))) < 0.20000000000000001Initial program 99.0%
lift-sqrt.f64N/A
pow1/2N/A
sqr-powN/A
lower-*.f64N/A
lower-pow.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f64N/A
metadata-evalN/A
lower-pow.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f64N/A
metadata-eval98.7
Applied rewrites98.7%
lift-*.f64N/A
pow2N/A
lower-pow.f6498.7
Applied rewrites98.7%
Taylor expanded in ky around 0
lower-sin.f6439.8
Applied rewrites39.8%
if 0.996999999999999997 < (/.f64 (sin.f64 ky) (sqrt.f64 (+.f64 (pow.f64 (sin.f64 kx) #s(literal 2 binary64)) (pow.f64 (sin.f64 ky) #s(literal 2 binary64))))) Initial program 85.6%
lift-sqrt.f64N/A
pow1/2N/A
sqr-powN/A
lower-*.f64N/A
lower-pow.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f64N/A
metadata-evalN/A
lower-pow.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f64N/A
metadata-eval84.8
Applied rewrites84.8%
lift-*.f64N/A
pow2N/A
lower-pow.f6484.8
Applied rewrites84.8%
Taylor expanded in kx around 0
lower-sin.f6491.1
Applied rewrites91.1%
(FPCore (kx ky th)
:precision binary64
(let* ((t_1 (/ (sin ky) (sqrt (+ (pow (sin kx) 2.0) (pow (sin ky) 2.0))))))
(if (<= t_1 -0.72)
(* (/ (sin ky) (sqrt (- 0.5 (* 0.5 (cos (* 2.0 ky)))))) (sin th))
(if (<= t_1 1e-44)
(* (/ (sin ky) (sqrt (- 0.5 (* 0.5 (cos (* 2.0 kx)))))) (sin th))
(if (<= t_1 0.15) (* (/ (sin ky) (sin kx)) (sin th)) (sin th))))))
double code(double kx, double ky, double th) {
double t_1 = sin(ky) / sqrt((pow(sin(kx), 2.0) + pow(sin(ky), 2.0)));
double tmp;
if (t_1 <= -0.72) {
tmp = (sin(ky) / sqrt((0.5 - (0.5 * cos((2.0 * ky)))))) * sin(th);
} else if (t_1 <= 1e-44) {
tmp = (sin(ky) / sqrt((0.5 - (0.5 * cos((2.0 * kx)))))) * sin(th);
} else if (t_1 <= 0.15) {
tmp = (sin(ky) / sin(kx)) * sin(th);
} else {
tmp = sin(th);
}
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(kx, ky, th)
use fmin_fmax_functions
real(8), intent (in) :: kx
real(8), intent (in) :: ky
real(8), intent (in) :: th
real(8) :: t_1
real(8) :: tmp
t_1 = sin(ky) / sqrt(((sin(kx) ** 2.0d0) + (sin(ky) ** 2.0d0)))
if (t_1 <= (-0.72d0)) then
tmp = (sin(ky) / sqrt((0.5d0 - (0.5d0 * cos((2.0d0 * ky)))))) * sin(th)
else if (t_1 <= 1d-44) then
tmp = (sin(ky) / sqrt((0.5d0 - (0.5d0 * cos((2.0d0 * kx)))))) * sin(th)
else if (t_1 <= 0.15d0) then
tmp = (sin(ky) / sin(kx)) * sin(th)
else
tmp = sin(th)
end if
code = tmp
end function
public static double code(double kx, double ky, double th) {
double t_1 = Math.sin(ky) / Math.sqrt((Math.pow(Math.sin(kx), 2.0) + Math.pow(Math.sin(ky), 2.0)));
double tmp;
if (t_1 <= -0.72) {
tmp = (Math.sin(ky) / Math.sqrt((0.5 - (0.5 * Math.cos((2.0 * ky)))))) * Math.sin(th);
} else if (t_1 <= 1e-44) {
tmp = (Math.sin(ky) / Math.sqrt((0.5 - (0.5 * Math.cos((2.0 * kx)))))) * Math.sin(th);
} else if (t_1 <= 0.15) {
tmp = (Math.sin(ky) / Math.sin(kx)) * Math.sin(th);
} else {
tmp = Math.sin(th);
}
return tmp;
}
def code(kx, ky, th): t_1 = math.sin(ky) / math.sqrt((math.pow(math.sin(kx), 2.0) + math.pow(math.sin(ky), 2.0))) tmp = 0 if t_1 <= -0.72: tmp = (math.sin(ky) / math.sqrt((0.5 - (0.5 * math.cos((2.0 * ky)))))) * math.sin(th) elif t_1 <= 1e-44: tmp = (math.sin(ky) / math.sqrt((0.5 - (0.5 * math.cos((2.0 * kx)))))) * math.sin(th) elif t_1 <= 0.15: tmp = (math.sin(ky) / math.sin(kx)) * math.sin(th) else: tmp = math.sin(th) return tmp
function code(kx, ky, th) t_1 = Float64(sin(ky) / sqrt(Float64((sin(kx) ^ 2.0) + (sin(ky) ^ 2.0)))) tmp = 0.0 if (t_1 <= -0.72) tmp = Float64(Float64(sin(ky) / sqrt(Float64(0.5 - Float64(0.5 * cos(Float64(2.0 * ky)))))) * sin(th)); elseif (t_1 <= 1e-44) tmp = Float64(Float64(sin(ky) / sqrt(Float64(0.5 - Float64(0.5 * cos(Float64(2.0 * kx)))))) * sin(th)); elseif (t_1 <= 0.15) tmp = Float64(Float64(sin(ky) / sin(kx)) * sin(th)); else tmp = sin(th); end return tmp end
function tmp_2 = code(kx, ky, th) t_1 = sin(ky) / sqrt(((sin(kx) ^ 2.0) + (sin(ky) ^ 2.0))); tmp = 0.0; if (t_1 <= -0.72) tmp = (sin(ky) / sqrt((0.5 - (0.5 * cos((2.0 * ky)))))) * sin(th); elseif (t_1 <= 1e-44) tmp = (sin(ky) / sqrt((0.5 - (0.5 * cos((2.0 * kx)))))) * sin(th); elseif (t_1 <= 0.15) tmp = (sin(ky) / sin(kx)) * sin(th); else tmp = sin(th); end tmp_2 = tmp; end
code[kx_, ky_, th_] := Block[{t$95$1 = N[(N[Sin[ky], $MachinePrecision] / N[Sqrt[N[(N[Power[N[Sin[kx], $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[Sin[ky], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -0.72], N[(N[(N[Sin[ky], $MachinePrecision] / N[Sqrt[N[(0.5 - N[(0.5 * N[Cos[N[(2.0 * ky), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 1e-44], N[(N[(N[Sin[ky], $MachinePrecision] / N[Sqrt[N[(0.5 - N[(0.5 * N[Cos[N[(2.0 * kx), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 0.15], N[(N[(N[Sin[ky], $MachinePrecision] / N[Sin[kx], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision], N[Sin[th], $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\sin ky}{\sqrt{{\sin kx}^{2} + {\sin ky}^{2}}}\\
\mathbf{if}\;t\_1 \leq -0.72:\\
\;\;\;\;\frac{\sin ky}{\sqrt{0.5 - 0.5 \cdot \cos \left(2 \cdot ky\right)}} \cdot \sin th\\
\mathbf{elif}\;t\_1 \leq 10^{-44}:\\
\;\;\;\;\frac{\sin ky}{\sqrt{0.5 - 0.5 \cdot \cos \left(2 \cdot kx\right)}} \cdot \sin th\\
\mathbf{elif}\;t\_1 \leq 0.15:\\
\;\;\;\;\frac{\sin ky}{\sin kx} \cdot \sin th\\
\mathbf{else}:\\
\;\;\;\;\sin th\\
\end{array}
\end{array}
if (/.f64 (sin.f64 ky) (sqrt.f64 (+.f64 (pow.f64 (sin.f64 kx) #s(literal 2 binary64)) (pow.f64 (sin.f64 ky) #s(literal 2 binary64))))) < -0.71999999999999997Initial program 88.5%
lift-pow.f64N/A
unpow2N/A
lift-sin.f64N/A
lift-sin.f64N/A
sqr-sin-aN/A
lower--.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
lower-*.f6471.2
Applied rewrites71.2%
lift-pow.f64N/A
pow2N/A
lift-sin.f64N/A
lift-sin.f64N/A
sqr-sin-aN/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
count-2-revN/A
lower-cos.f64N/A
count-2-revN/A
lower-*.f6470.9
Applied rewrites70.9%
lift--.f64N/A
flip--N/A
metadata-evalN/A
lift-*.f64N/A
lift--.f64N/A
lift-+.f64N/A
lift-/.f6470.9
lift-*.f64N/A
pow2N/A
lower-pow.f6470.9
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lower-fma.f6470.9
Applied rewrites70.9%
Taylor expanded in kx around 0
lower--.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
lower-*.f6454.3
Applied rewrites54.3%
if -0.71999999999999997 < (/.f64 (sin.f64 ky) (sqrt.f64 (+.f64 (pow.f64 (sin.f64 kx) #s(literal 2 binary64)) (pow.f64 (sin.f64 ky) #s(literal 2 binary64))))) < 9.99999999999999953e-45Initial program 99.2%
lift-pow.f64N/A
unpow2N/A
lift-sin.f64N/A
lift-sin.f64N/A
sqr-sin-aN/A
lower--.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
lower-*.f6499.0
Applied rewrites99.0%
lift-pow.f64N/A
pow2N/A
lift-sin.f64N/A
lift-sin.f64N/A
sqr-sin-aN/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
count-2-revN/A
lower-cos.f64N/A
count-2-revN/A
lower-*.f6477.9
Applied rewrites77.9%
lift-*.f64N/A
count-2-revN/A
lower-+.f6477.9
Applied rewrites77.9%
Taylor expanded in ky around 0
lower--.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
lower-*.f6464.9
Applied rewrites64.9%
if 9.99999999999999953e-45 < (/.f64 (sin.f64 ky) (sqrt.f64 (+.f64 (pow.f64 (sin.f64 kx) #s(literal 2 binary64)) (pow.f64 (sin.f64 ky) #s(literal 2 binary64))))) < 0.149999999999999994Initial program 99.0%
lift-sqrt.f64N/A
pow1/2N/A
sqr-powN/A
lower-*.f64N/A
lower-pow.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f64N/A
metadata-evalN/A
lower-pow.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f64N/A
metadata-eval98.7
Applied rewrites98.7%
lift-*.f64N/A
pow2N/A
lower-pow.f6498.7
Applied rewrites98.7%
Taylor expanded in ky around 0
lower-sin.f6441.8
Applied rewrites41.8%
if 0.149999999999999994 < (/.f64 (sin.f64 ky) (sqrt.f64 (+.f64 (pow.f64 (sin.f64 kx) #s(literal 2 binary64)) (pow.f64 (sin.f64 ky) #s(literal 2 binary64))))) Initial program 90.4%
lift-sqrt.f64N/A
pow1/2N/A
sqr-powN/A
lower-*.f64N/A
lower-pow.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f64N/A
metadata-evalN/A
lower-pow.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f64N/A
metadata-eval89.7
Applied rewrites89.7%
lift-*.f64N/A
pow2N/A
lower-pow.f6489.7
Applied rewrites89.7%
Taylor expanded in kx around 0
lower-sin.f6466.5
Applied rewrites66.5%
(FPCore (kx ky th)
:precision binary64
(if (<= (/ (sin ky) (sqrt (+ (pow (sin kx) 2.0) (pow (sin ky) 2.0)))) 0.9996)
(*
(/
(sin ky)
(sqrt
(+ (- 0.5 (* (cos (+ kx kx)) 0.5)) (- 0.5 (* 0.5 (cos (+ ky ky)))))))
(sin th))
(sin th)))
double code(double kx, double ky, double th) {
double tmp;
if ((sin(ky) / sqrt((pow(sin(kx), 2.0) + pow(sin(ky), 2.0)))) <= 0.9996) {
tmp = (sin(ky) / sqrt(((0.5 - (cos((kx + kx)) * 0.5)) + (0.5 - (0.5 * cos((ky + ky))))))) * sin(th);
} else {
tmp = sin(th);
}
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(kx, ky, th)
use fmin_fmax_functions
real(8), intent (in) :: kx
real(8), intent (in) :: ky
real(8), intent (in) :: th
real(8) :: tmp
if ((sin(ky) / sqrt(((sin(kx) ** 2.0d0) + (sin(ky) ** 2.0d0)))) <= 0.9996d0) then
tmp = (sin(ky) / sqrt(((0.5d0 - (cos((kx + kx)) * 0.5d0)) + (0.5d0 - (0.5d0 * cos((ky + ky))))))) * sin(th)
else
tmp = sin(th)
end if
code = tmp
end function
public static double code(double kx, double ky, double th) {
double tmp;
if ((Math.sin(ky) / Math.sqrt((Math.pow(Math.sin(kx), 2.0) + Math.pow(Math.sin(ky), 2.0)))) <= 0.9996) {
tmp = (Math.sin(ky) / Math.sqrt(((0.5 - (Math.cos((kx + kx)) * 0.5)) + (0.5 - (0.5 * Math.cos((ky + ky))))))) * Math.sin(th);
} else {
tmp = Math.sin(th);
}
return tmp;
}
def code(kx, ky, th): tmp = 0 if (math.sin(ky) / math.sqrt((math.pow(math.sin(kx), 2.0) + math.pow(math.sin(ky), 2.0)))) <= 0.9996: tmp = (math.sin(ky) / math.sqrt(((0.5 - (math.cos((kx + kx)) * 0.5)) + (0.5 - (0.5 * math.cos((ky + ky))))))) * math.sin(th) else: tmp = math.sin(th) return tmp
function code(kx, ky, th) tmp = 0.0 if (Float64(sin(ky) / sqrt(Float64((sin(kx) ^ 2.0) + (sin(ky) ^ 2.0)))) <= 0.9996) tmp = Float64(Float64(sin(ky) / sqrt(Float64(Float64(0.5 - Float64(cos(Float64(kx + kx)) * 0.5)) + Float64(0.5 - Float64(0.5 * cos(Float64(ky + ky))))))) * sin(th)); else tmp = sin(th); end return tmp end
function tmp_2 = code(kx, ky, th) tmp = 0.0; if ((sin(ky) / sqrt(((sin(kx) ^ 2.0) + (sin(ky) ^ 2.0)))) <= 0.9996) tmp = (sin(ky) / sqrt(((0.5 - (cos((kx + kx)) * 0.5)) + (0.5 - (0.5 * cos((ky + ky))))))) * sin(th); else tmp = sin(th); end tmp_2 = tmp; end
code[kx_, ky_, th_] := If[LessEqual[N[(N[Sin[ky], $MachinePrecision] / N[Sqrt[N[(N[Power[N[Sin[kx], $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[Sin[ky], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 0.9996], N[(N[(N[Sin[ky], $MachinePrecision] / N[Sqrt[N[(N[(0.5 - N[(N[Cos[N[(kx + kx), $MachinePrecision]], $MachinePrecision] * 0.5), $MachinePrecision]), $MachinePrecision] + N[(0.5 - N[(0.5 * N[Cos[N[(ky + ky), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision], N[Sin[th], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{\sin ky}{\sqrt{{\sin kx}^{2} + {\sin ky}^{2}}} \leq 0.9996:\\
\;\;\;\;\frac{\sin ky}{\sqrt{\left(0.5 - \cos \left(kx + kx\right) \cdot 0.5\right) + \left(0.5 - 0.5 \cdot \cos \left(ky + ky\right)\right)}} \cdot \sin th\\
\mathbf{else}:\\
\;\;\;\;\sin th\\
\end{array}
\end{array}
if (/.f64 (sin.f64 ky) (sqrt.f64 (+.f64 (pow.f64 (sin.f64 kx) #s(literal 2 binary64)) (pow.f64 (sin.f64 ky) #s(literal 2 binary64))))) < 0.99960000000000004Initial program 95.9%
lift-pow.f64N/A
unpow2N/A
lift-sin.f64N/A
lift-sin.f64N/A
sqr-sin-aN/A
lower--.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
lower-*.f6490.3
Applied rewrites90.3%
lift-pow.f64N/A
pow2N/A
lift-sin.f64N/A
lift-sin.f64N/A
sqr-sin-aN/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
count-2-revN/A
lower-cos.f64N/A
count-2-revN/A
lower-*.f6478.6
Applied rewrites78.6%
lift-*.f64N/A
count-2-revN/A
lower-+.f6478.6
Applied rewrites78.6%
lift-*.f64N/A
count-2-revN/A
lower-+.f6478.6
Applied rewrites78.6%
if 0.99960000000000004 < (/.f64 (sin.f64 ky) (sqrt.f64 (+.f64 (pow.f64 (sin.f64 kx) #s(literal 2 binary64)) (pow.f64 (sin.f64 ky) #s(literal 2 binary64))))) Initial program 85.4%
lift-sqrt.f64N/A
pow1/2N/A
sqr-powN/A
lower-*.f64N/A
lower-pow.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f64N/A
metadata-evalN/A
lower-pow.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f64N/A
metadata-eval84.6
Applied rewrites84.6%
lift-*.f64N/A
pow2N/A
lower-pow.f6484.6
Applied rewrites84.6%
Taylor expanded in kx around 0
lower-sin.f6492.0
Applied rewrites92.0%
(FPCore (kx ky th)
:precision binary64
(if (<= (/ (sin ky) (sqrt (+ (pow (sin kx) 2.0) (pow (sin ky) 2.0)))) 0.9996)
(*
(/
(sin ky)
(sqrt (- 1.0 (fma 0.5 (cos (* 2.0 kx)) (* 0.5 (cos (* 2.0 ky)))))))
(sin th))
(sin th)))
double code(double kx, double ky, double th) {
double tmp;
if ((sin(ky) / sqrt((pow(sin(kx), 2.0) + pow(sin(ky), 2.0)))) <= 0.9996) {
tmp = (sin(ky) / sqrt((1.0 - fma(0.5, cos((2.0 * kx)), (0.5 * cos((2.0 * ky))))))) * sin(th);
} else {
tmp = sin(th);
}
return tmp;
}
function code(kx, ky, th) tmp = 0.0 if (Float64(sin(ky) / sqrt(Float64((sin(kx) ^ 2.0) + (sin(ky) ^ 2.0)))) <= 0.9996) tmp = Float64(Float64(sin(ky) / sqrt(Float64(1.0 - fma(0.5, cos(Float64(2.0 * kx)), Float64(0.5 * cos(Float64(2.0 * ky))))))) * sin(th)); else tmp = sin(th); end return tmp end
code[kx_, ky_, th_] := If[LessEqual[N[(N[Sin[ky], $MachinePrecision] / N[Sqrt[N[(N[Power[N[Sin[kx], $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[Sin[ky], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 0.9996], N[(N[(N[Sin[ky], $MachinePrecision] / N[Sqrt[N[(1.0 - N[(0.5 * N[Cos[N[(2.0 * kx), $MachinePrecision]], $MachinePrecision] + N[(0.5 * N[Cos[N[(2.0 * ky), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision], N[Sin[th], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{\sin ky}{\sqrt{{\sin kx}^{2} + {\sin ky}^{2}}} \leq 0.9996:\\
\;\;\;\;\frac{\sin ky}{\sqrt{1 - \mathsf{fma}\left(0.5, \cos \left(2 \cdot kx\right), 0.5 \cdot \cos \left(2 \cdot ky\right)\right)}} \cdot \sin th\\
\mathbf{else}:\\
\;\;\;\;\sin th\\
\end{array}
\end{array}
if (/.f64 (sin.f64 ky) (sqrt.f64 (+.f64 (pow.f64 (sin.f64 kx) #s(literal 2 binary64)) (pow.f64 (sin.f64 ky) #s(literal 2 binary64))))) < 0.99960000000000004Initial program 95.9%
lift-pow.f64N/A
unpow2N/A
lift-sin.f64N/A
lift-sin.f64N/A
sqr-sin-aN/A
lower--.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
lower-*.f6490.3
Applied rewrites90.3%
lift-pow.f64N/A
pow2N/A
lift-sin.f64N/A
lift-sin.f64N/A
sqr-sin-aN/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
count-2-revN/A
lower-cos.f64N/A
count-2-revN/A
lower-*.f6478.6
Applied rewrites78.6%
lift-*.f64N/A
count-2-revN/A
lower-+.f6478.6
Applied rewrites78.6%
Taylor expanded in kx around inf
lower--.f64N/A
lower-fma.f64N/A
lower-cos.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
lower-*.f6478.4
Applied rewrites78.4%
if 0.99960000000000004 < (/.f64 (sin.f64 ky) (sqrt.f64 (+.f64 (pow.f64 (sin.f64 kx) #s(literal 2 binary64)) (pow.f64 (sin.f64 ky) #s(literal 2 binary64))))) Initial program 85.4%
lift-sqrt.f64N/A
pow1/2N/A
sqr-powN/A
lower-*.f64N/A
lower-pow.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f64N/A
metadata-evalN/A
lower-pow.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f64N/A
metadata-eval84.6
Applied rewrites84.6%
lift-*.f64N/A
pow2N/A
lower-pow.f6484.6
Applied rewrites84.6%
Taylor expanded in kx around 0
lower-sin.f6492.0
Applied rewrites92.0%
(FPCore (kx ky th) :precision binary64 (if (<= (/ (sin ky) (sqrt (+ (pow (sin kx) 2.0) (pow (sin ky) 2.0)))) 0.15) (* (/ ky (sin kx)) (sin th)) (sin th)))
double code(double kx, double ky, double th) {
double tmp;
if ((sin(ky) / sqrt((pow(sin(kx), 2.0) + pow(sin(ky), 2.0)))) <= 0.15) {
tmp = (ky / sin(kx)) * sin(th);
} else {
tmp = sin(th);
}
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(kx, ky, th)
use fmin_fmax_functions
real(8), intent (in) :: kx
real(8), intent (in) :: ky
real(8), intent (in) :: th
real(8) :: tmp
if ((sin(ky) / sqrt(((sin(kx) ** 2.0d0) + (sin(ky) ** 2.0d0)))) <= 0.15d0) then
tmp = (ky / sin(kx)) * sin(th)
else
tmp = sin(th)
end if
code = tmp
end function
public static double code(double kx, double ky, double th) {
double tmp;
if ((Math.sin(ky) / Math.sqrt((Math.pow(Math.sin(kx), 2.0) + Math.pow(Math.sin(ky), 2.0)))) <= 0.15) {
tmp = (ky / Math.sin(kx)) * Math.sin(th);
} else {
tmp = Math.sin(th);
}
return tmp;
}
def code(kx, ky, th): tmp = 0 if (math.sin(ky) / math.sqrt((math.pow(math.sin(kx), 2.0) + math.pow(math.sin(ky), 2.0)))) <= 0.15: tmp = (ky / math.sin(kx)) * math.sin(th) else: tmp = math.sin(th) return tmp
function code(kx, ky, th) tmp = 0.0 if (Float64(sin(ky) / sqrt(Float64((sin(kx) ^ 2.0) + (sin(ky) ^ 2.0)))) <= 0.15) tmp = Float64(Float64(ky / sin(kx)) * sin(th)); else tmp = sin(th); end return tmp end
function tmp_2 = code(kx, ky, th) tmp = 0.0; if ((sin(ky) / sqrt(((sin(kx) ^ 2.0) + (sin(ky) ^ 2.0)))) <= 0.15) tmp = (ky / sin(kx)) * sin(th); else tmp = sin(th); end tmp_2 = tmp; end
code[kx_, ky_, th_] := If[LessEqual[N[(N[Sin[ky], $MachinePrecision] / N[Sqrt[N[(N[Power[N[Sin[kx], $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[Sin[ky], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 0.15], N[(N[(ky / N[Sin[kx], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision], N[Sin[th], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{\sin ky}{\sqrt{{\sin kx}^{2} + {\sin ky}^{2}}} \leq 0.15:\\
\;\;\;\;\frac{ky}{\sin kx} \cdot \sin th\\
\mathbf{else}:\\
\;\;\;\;\sin th\\
\end{array}
\end{array}
if (/.f64 (sin.f64 ky) (sqrt.f64 (+.f64 (pow.f64 (sin.f64 kx) #s(literal 2 binary64)) (pow.f64 (sin.f64 ky) #s(literal 2 binary64))))) < 0.149999999999999994Initial program 95.3%
lift-sqrt.f64N/A
pow1/2N/A
sqr-powN/A
lower-*.f64N/A
lower-pow.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f64N/A
metadata-evalN/A
lower-pow.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f64N/A
metadata-eval94.9
Applied rewrites94.9%
lift-*.f64N/A
pow2N/A
lower-pow.f6494.9
Applied rewrites94.9%
Taylor expanded in ky around 0
lower-/.f64N/A
lower-sin.f6435.4
Applied rewrites35.4%
if 0.149999999999999994 < (/.f64 (sin.f64 ky) (sqrt.f64 (+.f64 (pow.f64 (sin.f64 kx) #s(literal 2 binary64)) (pow.f64 (sin.f64 ky) #s(literal 2 binary64))))) Initial program 90.4%
lift-sqrt.f64N/A
pow1/2N/A
sqr-powN/A
lower-*.f64N/A
lower-pow.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f64N/A
metadata-evalN/A
lower-pow.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f64N/A
metadata-eval89.7
Applied rewrites89.7%
lift-*.f64N/A
pow2N/A
lower-pow.f6489.7
Applied rewrites89.7%
Taylor expanded in kx around 0
lower-sin.f6466.5
Applied rewrites66.5%
(FPCore (kx ky th) :precision binary64 (if (<= (/ (sin ky) (sqrt (+ (pow (sin kx) 2.0) (pow (sin ky) 2.0)))) 0.0002) (/ (* ky (sin th)) (sin kx)) (sin th)))
double code(double kx, double ky, double th) {
double tmp;
if ((sin(ky) / sqrt((pow(sin(kx), 2.0) + pow(sin(ky), 2.0)))) <= 0.0002) {
tmp = (ky * sin(th)) / sin(kx);
} else {
tmp = sin(th);
}
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(kx, ky, th)
use fmin_fmax_functions
real(8), intent (in) :: kx
real(8), intent (in) :: ky
real(8), intent (in) :: th
real(8) :: tmp
if ((sin(ky) / sqrt(((sin(kx) ** 2.0d0) + (sin(ky) ** 2.0d0)))) <= 0.0002d0) then
tmp = (ky * sin(th)) / sin(kx)
else
tmp = sin(th)
end if
code = tmp
end function
public static double code(double kx, double ky, double th) {
double tmp;
if ((Math.sin(ky) / Math.sqrt((Math.pow(Math.sin(kx), 2.0) + Math.pow(Math.sin(ky), 2.0)))) <= 0.0002) {
tmp = (ky * Math.sin(th)) / Math.sin(kx);
} else {
tmp = Math.sin(th);
}
return tmp;
}
def code(kx, ky, th): tmp = 0 if (math.sin(ky) / math.sqrt((math.pow(math.sin(kx), 2.0) + math.pow(math.sin(ky), 2.0)))) <= 0.0002: tmp = (ky * math.sin(th)) / math.sin(kx) else: tmp = math.sin(th) return tmp
function code(kx, ky, th) tmp = 0.0 if (Float64(sin(ky) / sqrt(Float64((sin(kx) ^ 2.0) + (sin(ky) ^ 2.0)))) <= 0.0002) tmp = Float64(Float64(ky * sin(th)) / sin(kx)); else tmp = sin(th); end return tmp end
function tmp_2 = code(kx, ky, th) tmp = 0.0; if ((sin(ky) / sqrt(((sin(kx) ^ 2.0) + (sin(ky) ^ 2.0)))) <= 0.0002) tmp = (ky * sin(th)) / sin(kx); else tmp = sin(th); end tmp_2 = tmp; end
code[kx_, ky_, th_] := If[LessEqual[N[(N[Sin[ky], $MachinePrecision] / N[Sqrt[N[(N[Power[N[Sin[kx], $MachinePrecision], 2.0], $MachinePrecision] + N[Power[N[Sin[ky], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 0.0002], N[(N[(ky * N[Sin[th], $MachinePrecision]), $MachinePrecision] / N[Sin[kx], $MachinePrecision]), $MachinePrecision], N[Sin[th], $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{\sin ky}{\sqrt{{\sin kx}^{2} + {\sin ky}^{2}}} \leq 0.0002:\\
\;\;\;\;\frac{ky \cdot \sin th}{\sin kx}\\
\mathbf{else}:\\
\;\;\;\;\sin th\\
\end{array}
\end{array}
if (/.f64 (sin.f64 ky) (sqrt.f64 (+.f64 (pow.f64 (sin.f64 kx) #s(literal 2 binary64)) (pow.f64 (sin.f64 ky) #s(literal 2 binary64))))) < 2.0000000000000001e-4Initial program 95.2%
lift-sqrt.f64N/A
pow1/2N/A
sqr-powN/A
lower-*.f64N/A
lower-pow.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f64N/A
metadata-evalN/A
lower-pow.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f64N/A
metadata-eval94.8
Applied rewrites94.8%
lift-*.f64N/A
pow2N/A
lower-pow.f6494.8
Applied rewrites94.8%
Taylor expanded in ky around 0
lower-/.f64N/A
lower-*.f64N/A
lower-sin.f64N/A
lower-sin.f6434.6
Applied rewrites34.6%
if 2.0000000000000001e-4 < (/.f64 (sin.f64 ky) (sqrt.f64 (+.f64 (pow.f64 (sin.f64 kx) #s(literal 2 binary64)) (pow.f64 (sin.f64 ky) #s(literal 2 binary64))))) Initial program 90.6%
lift-sqrt.f64N/A
pow1/2N/A
sqr-powN/A
lower-*.f64N/A
lower-pow.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f64N/A
metadata-evalN/A
lower-pow.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f64N/A
metadata-eval90.0
Applied rewrites90.0%
lift-*.f64N/A
pow2N/A
lower-pow.f6490.0
Applied rewrites90.0%
Taylor expanded in kx around 0
lower-sin.f6465.0
Applied rewrites65.0%
(FPCore (kx ky th) :precision binary64 (if (<= (sin kx) -0.1) (* (/ (sin ky) (sqrt (- 0.5 (* 0.5 (cos (* 2.0 kx)))))) (sin th)) (if (<= (sin kx) 1e-78) (sin th) (* (/ (sin ky) (sin kx)) (sin th)))))
double code(double kx, double ky, double th) {
double tmp;
if (sin(kx) <= -0.1) {
tmp = (sin(ky) / sqrt((0.5 - (0.5 * cos((2.0 * kx)))))) * sin(th);
} else if (sin(kx) <= 1e-78) {
tmp = sin(th);
} else {
tmp = (sin(ky) / sin(kx)) * sin(th);
}
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(kx, ky, th)
use fmin_fmax_functions
real(8), intent (in) :: kx
real(8), intent (in) :: ky
real(8), intent (in) :: th
real(8) :: tmp
if (sin(kx) <= (-0.1d0)) then
tmp = (sin(ky) / sqrt((0.5d0 - (0.5d0 * cos((2.0d0 * kx)))))) * sin(th)
else if (sin(kx) <= 1d-78) then
tmp = sin(th)
else
tmp = (sin(ky) / sin(kx)) * sin(th)
end if
code = tmp
end function
public static double code(double kx, double ky, double th) {
double tmp;
if (Math.sin(kx) <= -0.1) {
tmp = (Math.sin(ky) / Math.sqrt((0.5 - (0.5 * Math.cos((2.0 * kx)))))) * Math.sin(th);
} else if (Math.sin(kx) <= 1e-78) {
tmp = Math.sin(th);
} else {
tmp = (Math.sin(ky) / Math.sin(kx)) * Math.sin(th);
}
return tmp;
}
def code(kx, ky, th): tmp = 0 if math.sin(kx) <= -0.1: tmp = (math.sin(ky) / math.sqrt((0.5 - (0.5 * math.cos((2.0 * kx)))))) * math.sin(th) elif math.sin(kx) <= 1e-78: tmp = math.sin(th) else: tmp = (math.sin(ky) / math.sin(kx)) * math.sin(th) return tmp
function code(kx, ky, th) tmp = 0.0 if (sin(kx) <= -0.1) tmp = Float64(Float64(sin(ky) / sqrt(Float64(0.5 - Float64(0.5 * cos(Float64(2.0 * kx)))))) * sin(th)); elseif (sin(kx) <= 1e-78) tmp = sin(th); else tmp = Float64(Float64(sin(ky) / sin(kx)) * sin(th)); end return tmp end
function tmp_2 = code(kx, ky, th) tmp = 0.0; if (sin(kx) <= -0.1) tmp = (sin(ky) / sqrt((0.5 - (0.5 * cos((2.0 * kx)))))) * sin(th); elseif (sin(kx) <= 1e-78) tmp = sin(th); else tmp = (sin(ky) / sin(kx)) * sin(th); end tmp_2 = tmp; end
code[kx_, ky_, th_] := If[LessEqual[N[Sin[kx], $MachinePrecision], -0.1], N[(N[(N[Sin[ky], $MachinePrecision] / N[Sqrt[N[(0.5 - N[(0.5 * N[Cos[N[(2.0 * kx), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Sin[kx], $MachinePrecision], 1e-78], N[Sin[th], $MachinePrecision], N[(N[(N[Sin[ky], $MachinePrecision] / N[Sin[kx], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\sin kx \leq -0.1:\\
\;\;\;\;\frac{\sin ky}{\sqrt{0.5 - 0.5 \cdot \cos \left(2 \cdot kx\right)}} \cdot \sin th\\
\mathbf{elif}\;\sin kx \leq 10^{-78}:\\
\;\;\;\;\sin th\\
\mathbf{else}:\\
\;\;\;\;\frac{\sin ky}{\sin kx} \cdot \sin th\\
\end{array}
\end{array}
if (sin.f64 kx) < -0.10000000000000001Initial program 99.5%
lift-pow.f64N/A
unpow2N/A
lift-sin.f64N/A
lift-sin.f64N/A
sqr-sin-aN/A
lower--.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
lower-*.f6499.4
Applied rewrites99.4%
lift-pow.f64N/A
pow2N/A
lift-sin.f64N/A
lift-sin.f64N/A
sqr-sin-aN/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
count-2-revN/A
lower-cos.f64N/A
count-2-revN/A
lower-*.f6499.3
Applied rewrites99.3%
lift-*.f64N/A
count-2-revN/A
lower-+.f6499.3
Applied rewrites99.3%
Taylor expanded in ky around 0
lower--.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
lower-*.f6461.1
Applied rewrites61.1%
if -0.10000000000000001 < (sin.f64 kx) < 9.99999999999999999e-79Initial program 86.7%
lift-sqrt.f64N/A
pow1/2N/A
sqr-powN/A
lower-*.f64N/A
lower-pow.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f64N/A
metadata-evalN/A
lower-pow.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f64N/A
metadata-eval86.1
Applied rewrites86.1%
lift-*.f64N/A
pow2N/A
lower-pow.f6486.1
Applied rewrites86.1%
Taylor expanded in kx around 0
lower-sin.f6440.0
Applied rewrites40.0%
if 9.99999999999999999e-79 < (sin.f64 kx) Initial program 99.5%
lift-sqrt.f64N/A
pow1/2N/A
sqr-powN/A
lower-*.f64N/A
lower-pow.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f64N/A
metadata-evalN/A
lower-pow.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f64N/A
metadata-eval99.1
Applied rewrites99.1%
lift-*.f64N/A
pow2N/A
lower-pow.f6499.1
Applied rewrites99.1%
Taylor expanded in ky around 0
lower-sin.f6458.8
Applied rewrites58.8%
(FPCore (kx ky th) :precision binary64 (if (<= (sin kx) -0.1) (* (* ky (sin th)) (sqrt (/ 1.0 (- 0.5 (* 0.5 (cos (* 2.0 kx))))))) (if (<= (sin kx) 1e-78) (sin th) (* (/ (sin ky) (sin kx)) (sin th)))))
double code(double kx, double ky, double th) {
double tmp;
if (sin(kx) <= -0.1) {
tmp = (ky * sin(th)) * sqrt((1.0 / (0.5 - (0.5 * cos((2.0 * kx))))));
} else if (sin(kx) <= 1e-78) {
tmp = sin(th);
} else {
tmp = (sin(ky) / sin(kx)) * sin(th);
}
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(kx, ky, th)
use fmin_fmax_functions
real(8), intent (in) :: kx
real(8), intent (in) :: ky
real(8), intent (in) :: th
real(8) :: tmp
if (sin(kx) <= (-0.1d0)) then
tmp = (ky * sin(th)) * sqrt((1.0d0 / (0.5d0 - (0.5d0 * cos((2.0d0 * kx))))))
else if (sin(kx) <= 1d-78) then
tmp = sin(th)
else
tmp = (sin(ky) / sin(kx)) * sin(th)
end if
code = tmp
end function
public static double code(double kx, double ky, double th) {
double tmp;
if (Math.sin(kx) <= -0.1) {
tmp = (ky * Math.sin(th)) * Math.sqrt((1.0 / (0.5 - (0.5 * Math.cos((2.0 * kx))))));
} else if (Math.sin(kx) <= 1e-78) {
tmp = Math.sin(th);
} else {
tmp = (Math.sin(ky) / Math.sin(kx)) * Math.sin(th);
}
return tmp;
}
def code(kx, ky, th): tmp = 0 if math.sin(kx) <= -0.1: tmp = (ky * math.sin(th)) * math.sqrt((1.0 / (0.5 - (0.5 * math.cos((2.0 * kx)))))) elif math.sin(kx) <= 1e-78: tmp = math.sin(th) else: tmp = (math.sin(ky) / math.sin(kx)) * math.sin(th) return tmp
function code(kx, ky, th) tmp = 0.0 if (sin(kx) <= -0.1) tmp = Float64(Float64(ky * sin(th)) * sqrt(Float64(1.0 / Float64(0.5 - Float64(0.5 * cos(Float64(2.0 * kx))))))); elseif (sin(kx) <= 1e-78) tmp = sin(th); else tmp = Float64(Float64(sin(ky) / sin(kx)) * sin(th)); end return tmp end
function tmp_2 = code(kx, ky, th) tmp = 0.0; if (sin(kx) <= -0.1) tmp = (ky * sin(th)) * sqrt((1.0 / (0.5 - (0.5 * cos((2.0 * kx)))))); elseif (sin(kx) <= 1e-78) tmp = sin(th); else tmp = (sin(ky) / sin(kx)) * sin(th); end tmp_2 = tmp; end
code[kx_, ky_, th_] := If[LessEqual[N[Sin[kx], $MachinePrecision], -0.1], N[(N[(ky * N[Sin[th], $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(1.0 / N[(0.5 - N[(0.5 * N[Cos[N[(2.0 * kx), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Sin[kx], $MachinePrecision], 1e-78], N[Sin[th], $MachinePrecision], N[(N[(N[Sin[ky], $MachinePrecision] / N[Sin[kx], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\sin kx \leq -0.1:\\
\;\;\;\;\left(ky \cdot \sin th\right) \cdot \sqrt{\frac{1}{0.5 - 0.5 \cdot \cos \left(2 \cdot kx\right)}}\\
\mathbf{elif}\;\sin kx \leq 10^{-78}:\\
\;\;\;\;\sin th\\
\mathbf{else}:\\
\;\;\;\;\frac{\sin ky}{\sin kx} \cdot \sin th\\
\end{array}
\end{array}
if (sin.f64 kx) < -0.10000000000000001Initial program 99.5%
lift-pow.f64N/A
unpow2N/A
lift-sin.f64N/A
lift-sin.f64N/A
sqr-sin-aN/A
lower--.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
lower-*.f6499.4
Applied rewrites99.4%
lift-pow.f64N/A
pow2N/A
lift-sin.f64N/A
lift-sin.f64N/A
sqr-sin-aN/A
lower--.f64N/A
*-commutativeN/A
lower-*.f64N/A
count-2-revN/A
lower-cos.f64N/A
count-2-revN/A
lower-*.f6499.3
Applied rewrites99.3%
lift-*.f64N/A
count-2-revN/A
lower-+.f6499.3
Applied rewrites99.3%
Taylor expanded in ky around 0
lower-*.f64N/A
lower-*.f64N/A
lower-sin.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
lower--.f64N/A
lower-*.f64N/A
lower-cos.f64N/A
lower-*.f6452.5
Applied rewrites52.5%
if -0.10000000000000001 < (sin.f64 kx) < 9.99999999999999999e-79Initial program 86.7%
lift-sqrt.f64N/A
pow1/2N/A
sqr-powN/A
lower-*.f64N/A
lower-pow.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f64N/A
metadata-evalN/A
lower-pow.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f64N/A
metadata-eval86.1
Applied rewrites86.1%
lift-*.f64N/A
pow2N/A
lower-pow.f6486.1
Applied rewrites86.1%
Taylor expanded in kx around 0
lower-sin.f6440.0
Applied rewrites40.0%
if 9.99999999999999999e-79 < (sin.f64 kx) Initial program 99.5%
lift-sqrt.f64N/A
pow1/2N/A
sqr-powN/A
lower-*.f64N/A
lower-pow.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f64N/A
metadata-evalN/A
lower-pow.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f64N/A
metadata-eval99.1
Applied rewrites99.1%
lift-*.f64N/A
pow2N/A
lower-pow.f6499.1
Applied rewrites99.1%
Taylor expanded in ky around 0
lower-sin.f6458.8
Applied rewrites58.8%
(FPCore (kx ky th) :precision binary64 (* (sin ky) (/ (sin th) (hypot (sin kx) (sin ky)))))
double code(double kx, double ky, double th) {
return sin(ky) * (sin(th) / hypot(sin(kx), sin(ky)));
}
public static double code(double kx, double ky, double th) {
return Math.sin(ky) * (Math.sin(th) / Math.hypot(Math.sin(kx), Math.sin(ky)));
}
def code(kx, ky, th): return math.sin(ky) * (math.sin(th) / math.hypot(math.sin(kx), math.sin(ky)))
function code(kx, ky, th) return Float64(sin(ky) * Float64(sin(th) / hypot(sin(kx), sin(ky)))) end
function tmp = code(kx, ky, th) tmp = sin(ky) * (sin(th) / hypot(sin(kx), sin(ky))); end
code[kx_, ky_, th_] := N[(N[Sin[ky], $MachinePrecision] * N[(N[Sin[th], $MachinePrecision] / N[Sqrt[N[Sin[kx], $MachinePrecision] ^ 2 + N[Sin[ky], $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\sin ky \cdot \frac{\sin th}{\mathsf{hypot}\left(\sin kx, \sin ky\right)}
\end{array}
Initial program 93.7%
lift-*.f64N/A
lift-/.f64N/A
associate-*l/N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f6493.6
lift-sqrt.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
lower-hypot.f6499.6
Applied rewrites99.6%
(FPCore (kx ky th) :precision binary64 (sin th))
double code(double kx, double ky, double th) {
return sin(th);
}
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(kx, ky, th)
use fmin_fmax_functions
real(8), intent (in) :: kx
real(8), intent (in) :: ky
real(8), intent (in) :: th
code = sin(th)
end function
public static double code(double kx, double ky, double th) {
return Math.sin(th);
}
def code(kx, ky, th): return math.sin(th)
function code(kx, ky, th) return sin(th) end
function tmp = code(kx, ky, th) tmp = sin(th); end
code[kx_, ky_, th_] := N[Sin[th], $MachinePrecision]
\begin{array}{l}
\\
\sin th
\end{array}
Initial program 93.7%
lift-sqrt.f64N/A
pow1/2N/A
sqr-powN/A
lower-*.f64N/A
lower-pow.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f64N/A
metadata-evalN/A
lower-pow.f64N/A
lift-+.f64N/A
lift-pow.f64N/A
unpow2N/A
lower-fma.f64N/A
metadata-eval93.2
Applied rewrites93.2%
lift-*.f64N/A
pow2N/A
lower-pow.f6493.2
Applied rewrites93.2%
Taylor expanded in kx around 0
lower-sin.f6423.9
Applied rewrites23.9%
herbie shell --seed 2025108
(FPCore (kx ky th)
:name "Toniolo and Linder, Equation (3b), real"
:precision binary64
(* (/ (sin ky) (sqrt (+ (pow (sin kx) 2.0) (pow (sin ky) 2.0)))) (sin th)))