
(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]
\frac{\sin ky}{\sqrt{{\sin kx}^{2} + {\sin ky}^{2}}} \cdot \sin th
Herbie found 22 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]
\frac{\sin ky}{\sqrt{{\sin kx}^{2} + {\sin ky}^{2}}} \cdot \sin th
(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]
\frac{\sin ky}{\mathsf{hypot}\left(\sin ky, \sin kx\right)} \cdot \sin th
Initial program 94.3%
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 (fabs ky)))
(t_2 (* th (+ 1.0 (* -0.16666666666666666 (pow th 2.0)))))
(t_3 (/ t_1 (sqrt (+ (pow (sin kx) 2.0) (pow t_1 2.0)))))
(t_4
(fma
(* (* (fabs ky) (fabs ky)) (fabs ky))
-0.16666666666666666
(fabs ky))))
(*
(copysign 1.0 ky)
(if (<= t_3 -0.99998)
(* (/ t_1 (hypot t_1 kx)) (sin th))
(if (<= t_3 -0.1)
(* (/ t_2 (hypot (sin kx) t_1)) t_1)
(if (<= t_3 0.01)
(* (/ t_4 (hypot t_4 (sin kx))) (sin th))
(if (<= t_3 0.9925)
(* (/ t_1 (hypot t_1 (sin kx))) t_2)
(* (/ (fabs ky) (hypot (fabs ky) (sin kx))) (sin th)))))))))double code(double kx, double ky, double th) {
double t_1 = sin(fabs(ky));
double t_2 = th * (1.0 + (-0.16666666666666666 * pow(th, 2.0)));
double t_3 = t_1 / sqrt((pow(sin(kx), 2.0) + pow(t_1, 2.0)));
double t_4 = fma(((fabs(ky) * fabs(ky)) * fabs(ky)), -0.16666666666666666, fabs(ky));
double tmp;
if (t_3 <= -0.99998) {
tmp = (t_1 / hypot(t_1, kx)) * sin(th);
} else if (t_3 <= -0.1) {
tmp = (t_2 / hypot(sin(kx), t_1)) * t_1;
} else if (t_3 <= 0.01) {
tmp = (t_4 / hypot(t_4, sin(kx))) * sin(th);
} else if (t_3 <= 0.9925) {
tmp = (t_1 / hypot(t_1, sin(kx))) * t_2;
} else {
tmp = (fabs(ky) / hypot(fabs(ky), sin(kx))) * sin(th);
}
return copysign(1.0, ky) * tmp;
}
function code(kx, ky, th) t_1 = sin(abs(ky)) t_2 = Float64(th * Float64(1.0 + Float64(-0.16666666666666666 * (th ^ 2.0)))) t_3 = Float64(t_1 / sqrt(Float64((sin(kx) ^ 2.0) + (t_1 ^ 2.0)))) t_4 = fma(Float64(Float64(abs(ky) * abs(ky)) * abs(ky)), -0.16666666666666666, abs(ky)) tmp = 0.0 if (t_3 <= -0.99998) tmp = Float64(Float64(t_1 / hypot(t_1, kx)) * sin(th)); elseif (t_3 <= -0.1) tmp = Float64(Float64(t_2 / hypot(sin(kx), t_1)) * t_1); elseif (t_3 <= 0.01) tmp = Float64(Float64(t_4 / hypot(t_4, sin(kx))) * sin(th)); elseif (t_3 <= 0.9925) tmp = Float64(Float64(t_1 / hypot(t_1, sin(kx))) * t_2); else tmp = Float64(Float64(abs(ky) / hypot(abs(ky), sin(kx))) * sin(th)); end return Float64(copysign(1.0, ky) * tmp) end
code[kx_, ky_, th_] := Block[{t$95$1 = N[Sin[N[Abs[ky], $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[(th * N[(1.0 + N[(-0.16666666666666666 * N[Power[th, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$1 / N[Sqrt[N[(N[Power[N[Sin[kx], $MachinePrecision], 2.0], $MachinePrecision] + N[Power[t$95$1, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[(N[(N[Abs[ky], $MachinePrecision] * N[Abs[ky], $MachinePrecision]), $MachinePrecision] * N[Abs[ky], $MachinePrecision]), $MachinePrecision] * -0.16666666666666666 + N[Abs[ky], $MachinePrecision]), $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[ky]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[t$95$3, -0.99998], N[(N[(t$95$1 / N[Sqrt[t$95$1 ^ 2 + kx ^ 2], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, -0.1], N[(N[(t$95$2 / N[Sqrt[N[Sin[kx], $MachinePrecision] ^ 2 + t$95$1 ^ 2], $MachinePrecision]), $MachinePrecision] * t$95$1), $MachinePrecision], If[LessEqual[t$95$3, 0.01], N[(N[(t$95$4 / N[Sqrt[t$95$4 ^ 2 + N[Sin[kx], $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, 0.9925], N[(N[(t$95$1 / N[Sqrt[t$95$1 ^ 2 + N[Sin[kx], $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision] * t$95$2), $MachinePrecision], N[(N[(N[Abs[ky], $MachinePrecision] / N[Sqrt[N[Abs[ky], $MachinePrecision] ^ 2 + N[Sin[kx], $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision]]]]]), $MachinePrecision]]]]]
\begin{array}{l}
t_1 := \sin \left(\left|ky\right|\right)\\
t_2 := th \cdot \left(1 + -0.16666666666666666 \cdot {th}^{2}\right)\\
t_3 := \frac{t\_1}{\sqrt{{\sin kx}^{2} + {t\_1}^{2}}}\\
t_4 := \mathsf{fma}\left(\left(\left|ky\right| \cdot \left|ky\right|\right) \cdot \left|ky\right|, -0.16666666666666666, \left|ky\right|\right)\\
\mathsf{copysign}\left(1, ky\right) \cdot \begin{array}{l}
\mathbf{if}\;t\_3 \leq -0.99998:\\
\;\;\;\;\frac{t\_1}{\mathsf{hypot}\left(t\_1, kx\right)} \cdot \sin th\\
\mathbf{elif}\;t\_3 \leq -0.1:\\
\;\;\;\;\frac{t\_2}{\mathsf{hypot}\left(\sin kx, t\_1\right)} \cdot t\_1\\
\mathbf{elif}\;t\_3 \leq 0.01:\\
\;\;\;\;\frac{t\_4}{\mathsf{hypot}\left(t\_4, \sin kx\right)} \cdot \sin th\\
\mathbf{elif}\;t\_3 \leq 0.9925:\\
\;\;\;\;\frac{t\_1}{\mathsf{hypot}\left(t\_1, \sin kx\right)} \cdot t\_2\\
\mathbf{else}:\\
\;\;\;\;\frac{\left|ky\right|}{\mathsf{hypot}\left(\left|ky\right|, \sin kx\right)} \cdot \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.99997999999999998Initial program 94.3%
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%
Taylor expanded in kx around 0
Applied rewrites57.5%
if -0.99997999999999998 < (/.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.10000000000000001Initial program 94.3%
lift-*.f64N/A
lift-/.f64N/A
mult-flipN/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites99.6%
Taylor expanded in th around 0
lower-*.f64N/A
lower-+.f64N/A
lower-*.f64N/A
lower-pow.f6451.8
Applied rewrites51.8%
if -0.10000000000000001 < (/.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.0100000000000000002Initial program 94.3%
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%
Taylor expanded in ky around 0
lower-*.f64N/A
lower-+.f64N/A
lower-*.f64N/A
lower-pow.f6450.7
Applied rewrites50.7%
Taylor expanded in ky around 0
lower-*.f64N/A
lower-+.f64N/A
lower-*.f64N/A
lower-pow.f6454.7
Applied rewrites54.7%
lift-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
distribute-lft-inN/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
*-rgt-identityN/A
lower-fma.f64N/A
lift-pow.f64N/A
unpow2N/A
cube-unmultN/A
metadata-evalN/A
pow-plusN/A
lift-pow.f64N/A
lower-*.f6454.6
lift-pow.f64N/A
unpow2N/A
lower-*.f6454.6
Applied rewrites54.6%
lift-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
distribute-lft-inN/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
*-rgt-identityN/A
lower-fma.f64N/A
lift-pow.f64N/A
unpow2N/A
cube-unmultN/A
metadata-evalN/A
pow-plusN/A
lift-pow.f64N/A
lower-*.f6454.7
lift-pow.f64N/A
unpow2N/A
lower-*.f6454.7
Applied rewrites54.7%
if 0.0100000000000000002 < (/.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.992500000000000049Initial program 94.3%
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%
Taylor expanded in th around 0
lower-*.f64N/A
lower-+.f64N/A
lower-*.f64N/A
lower-pow.f6451.8
Applied rewrites51.8%
if 0.992500000000000049 < (/.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 94.3%
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%
Taylor expanded in ky around 0
Applied rewrites50.9%
Taylor expanded in ky around 0
Applied rewrites64.3%
(FPCore (kx ky th)
:precision binary64
(let* ((t_1 (sin (fabs ky)))
(t_2
(*
(/ t_1 (hypot t_1 (sin kx)))
(* th (+ 1.0 (* -0.16666666666666666 (pow th 2.0))))))
(t_3 (/ t_1 (sqrt (+ (pow (sin kx) 2.0) (pow t_1 2.0)))))
(t_4
(fma
(* (* (fabs ky) (fabs ky)) (fabs ky))
-0.16666666666666666
(fabs ky))))
(*
(copysign 1.0 ky)
(if (<= t_3 -0.99998)
(* (/ t_1 (hypot t_1 kx)) (sin th))
(if (<= t_3 -0.1)
t_2
(if (<= t_3 0.01)
(* (/ t_4 (hypot t_4 (sin kx))) (sin th))
(if (<= t_3 0.9925)
t_2
(* (/ (fabs ky) (hypot (fabs ky) (sin kx))) (sin th)))))))))double code(double kx, double ky, double th) {
double t_1 = sin(fabs(ky));
double t_2 = (t_1 / hypot(t_1, sin(kx))) * (th * (1.0 + (-0.16666666666666666 * pow(th, 2.0))));
double t_3 = t_1 / sqrt((pow(sin(kx), 2.0) + pow(t_1, 2.0)));
double t_4 = fma(((fabs(ky) * fabs(ky)) * fabs(ky)), -0.16666666666666666, fabs(ky));
double tmp;
if (t_3 <= -0.99998) {
tmp = (t_1 / hypot(t_1, kx)) * sin(th);
} else if (t_3 <= -0.1) {
tmp = t_2;
} else if (t_3 <= 0.01) {
tmp = (t_4 / hypot(t_4, sin(kx))) * sin(th);
} else if (t_3 <= 0.9925) {
tmp = t_2;
} else {
tmp = (fabs(ky) / hypot(fabs(ky), sin(kx))) * sin(th);
}
return copysign(1.0, ky) * tmp;
}
function code(kx, ky, th) t_1 = sin(abs(ky)) t_2 = Float64(Float64(t_1 / hypot(t_1, sin(kx))) * Float64(th * Float64(1.0 + Float64(-0.16666666666666666 * (th ^ 2.0))))) t_3 = Float64(t_1 / sqrt(Float64((sin(kx) ^ 2.0) + (t_1 ^ 2.0)))) t_4 = fma(Float64(Float64(abs(ky) * abs(ky)) * abs(ky)), -0.16666666666666666, abs(ky)) tmp = 0.0 if (t_3 <= -0.99998) tmp = Float64(Float64(t_1 / hypot(t_1, kx)) * sin(th)); elseif (t_3 <= -0.1) tmp = t_2; elseif (t_3 <= 0.01) tmp = Float64(Float64(t_4 / hypot(t_4, sin(kx))) * sin(th)); elseif (t_3 <= 0.9925) tmp = t_2; else tmp = Float64(Float64(abs(ky) / hypot(abs(ky), sin(kx))) * sin(th)); end return Float64(copysign(1.0, ky) * tmp) end
code[kx_, ky_, th_] := Block[{t$95$1 = N[Sin[N[Abs[ky], $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[(N[(t$95$1 / N[Sqrt[t$95$1 ^ 2 + N[Sin[kx], $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision] * N[(th * N[(1.0 + N[(-0.16666666666666666 * N[Power[th, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$1 / N[Sqrt[N[(N[Power[N[Sin[kx], $MachinePrecision], 2.0], $MachinePrecision] + N[Power[t$95$1, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[(N[(N[Abs[ky], $MachinePrecision] * N[Abs[ky], $MachinePrecision]), $MachinePrecision] * N[Abs[ky], $MachinePrecision]), $MachinePrecision] * -0.16666666666666666 + N[Abs[ky], $MachinePrecision]), $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[ky]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[t$95$3, -0.99998], N[(N[(t$95$1 / N[Sqrt[t$95$1 ^ 2 + kx ^ 2], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, -0.1], t$95$2, If[LessEqual[t$95$3, 0.01], N[(N[(t$95$4 / N[Sqrt[t$95$4 ^ 2 + N[Sin[kx], $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, 0.9925], t$95$2, N[(N[(N[Abs[ky], $MachinePrecision] / N[Sqrt[N[Abs[ky], $MachinePrecision] ^ 2 + N[Sin[kx], $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision]]]]]), $MachinePrecision]]]]]
\begin{array}{l}
t_1 := \sin \left(\left|ky\right|\right)\\
t_2 := \frac{t\_1}{\mathsf{hypot}\left(t\_1, \sin kx\right)} \cdot \left(th \cdot \left(1 + -0.16666666666666666 \cdot {th}^{2}\right)\right)\\
t_3 := \frac{t\_1}{\sqrt{{\sin kx}^{2} + {t\_1}^{2}}}\\
t_4 := \mathsf{fma}\left(\left(\left|ky\right| \cdot \left|ky\right|\right) \cdot \left|ky\right|, -0.16666666666666666, \left|ky\right|\right)\\
\mathsf{copysign}\left(1, ky\right) \cdot \begin{array}{l}
\mathbf{if}\;t\_3 \leq -0.99998:\\
\;\;\;\;\frac{t\_1}{\mathsf{hypot}\left(t\_1, kx\right)} \cdot \sin th\\
\mathbf{elif}\;t\_3 \leq -0.1:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_3 \leq 0.01:\\
\;\;\;\;\frac{t\_4}{\mathsf{hypot}\left(t\_4, \sin kx\right)} \cdot \sin th\\
\mathbf{elif}\;t\_3 \leq 0.9925:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;\frac{\left|ky\right|}{\mathsf{hypot}\left(\left|ky\right|, \sin kx\right)} \cdot \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.99997999999999998Initial program 94.3%
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%
Taylor expanded in kx around 0
Applied rewrites57.5%
if -0.99997999999999998 < (/.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.10000000000000001 or 0.0100000000000000002 < (/.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.992500000000000049Initial program 94.3%
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%
Taylor expanded in th around 0
lower-*.f64N/A
lower-+.f64N/A
lower-*.f64N/A
lower-pow.f6451.8
Applied rewrites51.8%
if -0.10000000000000001 < (/.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.0100000000000000002Initial program 94.3%
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%
Taylor expanded in ky around 0
lower-*.f64N/A
lower-+.f64N/A
lower-*.f64N/A
lower-pow.f6450.7
Applied rewrites50.7%
Taylor expanded in ky around 0
lower-*.f64N/A
lower-+.f64N/A
lower-*.f64N/A
lower-pow.f6454.7
Applied rewrites54.7%
lift-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
distribute-lft-inN/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
*-rgt-identityN/A
lower-fma.f64N/A
lift-pow.f64N/A
unpow2N/A
cube-unmultN/A
metadata-evalN/A
pow-plusN/A
lift-pow.f64N/A
lower-*.f6454.6
lift-pow.f64N/A
unpow2N/A
lower-*.f6454.6
Applied rewrites54.6%
lift-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
distribute-lft-inN/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
*-rgt-identityN/A
lower-fma.f64N/A
lift-pow.f64N/A
unpow2N/A
cube-unmultN/A
metadata-evalN/A
pow-plusN/A
lift-pow.f64N/A
lower-*.f6454.7
lift-pow.f64N/A
unpow2N/A
lower-*.f6454.7
Applied rewrites54.7%
if 0.992500000000000049 < (/.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 94.3%
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%
Taylor expanded in ky around 0
Applied rewrites50.9%
Taylor expanded in ky around 0
Applied rewrites64.3%
(FPCore (kx ky th)
:precision binary64
(let* ((t_1
(fma
(* (* (fabs ky) (fabs ky)) (fabs ky))
-0.16666666666666666
(fabs ky)))
(t_2 (sin (fabs ky)))
(t_3 (/ t_2 (sqrt (+ (pow (sin kx) 2.0) (pow t_2 2.0))))))
(*
(copysign 1.0 ky)
(if (<= t_3 -0.99998)
(* (/ t_2 (hypot t_2 kx)) (sin th))
(if (<= t_3 -0.1)
(* (/ th (hypot (sin kx) t_2)) t_2)
(if (<= t_3 0.01)
(* (/ t_1 (hypot t_1 (sin kx))) (sin th))
(if (<= t_3 0.9925)
(* (/ t_2 (hypot t_2 (sin kx))) th)
(* (/ (fabs ky) (hypot (fabs ky) (sin kx))) (sin th)))))))))double code(double kx, double ky, double th) {
double t_1 = fma(((fabs(ky) * fabs(ky)) * fabs(ky)), -0.16666666666666666, fabs(ky));
double t_2 = sin(fabs(ky));
double t_3 = t_2 / sqrt((pow(sin(kx), 2.0) + pow(t_2, 2.0)));
double tmp;
if (t_3 <= -0.99998) {
tmp = (t_2 / hypot(t_2, kx)) * sin(th);
} else if (t_3 <= -0.1) {
tmp = (th / hypot(sin(kx), t_2)) * t_2;
} else if (t_3 <= 0.01) {
tmp = (t_1 / hypot(t_1, sin(kx))) * sin(th);
} else if (t_3 <= 0.9925) {
tmp = (t_2 / hypot(t_2, sin(kx))) * th;
} else {
tmp = (fabs(ky) / hypot(fabs(ky), sin(kx))) * sin(th);
}
return copysign(1.0, ky) * tmp;
}
function code(kx, ky, th) t_1 = fma(Float64(Float64(abs(ky) * abs(ky)) * abs(ky)), -0.16666666666666666, abs(ky)) t_2 = sin(abs(ky)) t_3 = Float64(t_2 / sqrt(Float64((sin(kx) ^ 2.0) + (t_2 ^ 2.0)))) tmp = 0.0 if (t_3 <= -0.99998) tmp = Float64(Float64(t_2 / hypot(t_2, kx)) * sin(th)); elseif (t_3 <= -0.1) tmp = Float64(Float64(th / hypot(sin(kx), t_2)) * t_2); elseif (t_3 <= 0.01) tmp = Float64(Float64(t_1 / hypot(t_1, sin(kx))) * sin(th)); elseif (t_3 <= 0.9925) tmp = Float64(Float64(t_2 / hypot(t_2, sin(kx))) * th); else tmp = Float64(Float64(abs(ky) / hypot(abs(ky), sin(kx))) * sin(th)); end return Float64(copysign(1.0, ky) * tmp) end
code[kx_, ky_, th_] := Block[{t$95$1 = N[(N[(N[(N[Abs[ky], $MachinePrecision] * N[Abs[ky], $MachinePrecision]), $MachinePrecision] * N[Abs[ky], $MachinePrecision]), $MachinePrecision] * -0.16666666666666666 + N[Abs[ky], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Sin[N[Abs[ky], $MachinePrecision]], $MachinePrecision]}, Block[{t$95$3 = N[(t$95$2 / N[Sqrt[N[(N[Power[N[Sin[kx], $MachinePrecision], 2.0], $MachinePrecision] + N[Power[t$95$2, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[ky]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[t$95$3, -0.99998], N[(N[(t$95$2 / N[Sqrt[t$95$2 ^ 2 + kx ^ 2], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, -0.1], N[(N[(th / N[Sqrt[N[Sin[kx], $MachinePrecision] ^ 2 + t$95$2 ^ 2], $MachinePrecision]), $MachinePrecision] * t$95$2), $MachinePrecision], If[LessEqual[t$95$3, 0.01], N[(N[(t$95$1 / N[Sqrt[t$95$1 ^ 2 + N[Sin[kx], $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, 0.9925], N[(N[(t$95$2 / N[Sqrt[t$95$2 ^ 2 + N[Sin[kx], $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision] * th), $MachinePrecision], N[(N[(N[Abs[ky], $MachinePrecision] / N[Sqrt[N[Abs[ky], $MachinePrecision] ^ 2 + N[Sin[kx], $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision]]]]]), $MachinePrecision]]]]
\begin{array}{l}
t_1 := \mathsf{fma}\left(\left(\left|ky\right| \cdot \left|ky\right|\right) \cdot \left|ky\right|, -0.16666666666666666, \left|ky\right|\right)\\
t_2 := \sin \left(\left|ky\right|\right)\\
t_3 := \frac{t\_2}{\sqrt{{\sin kx}^{2} + {t\_2}^{2}}}\\
\mathsf{copysign}\left(1, ky\right) \cdot \begin{array}{l}
\mathbf{if}\;t\_3 \leq -0.99998:\\
\;\;\;\;\frac{t\_2}{\mathsf{hypot}\left(t\_2, kx\right)} \cdot \sin th\\
\mathbf{elif}\;t\_3 \leq -0.1:\\
\;\;\;\;\frac{th}{\mathsf{hypot}\left(\sin kx, t\_2\right)} \cdot t\_2\\
\mathbf{elif}\;t\_3 \leq 0.01:\\
\;\;\;\;\frac{t\_1}{\mathsf{hypot}\left(t\_1, \sin kx\right)} \cdot \sin th\\
\mathbf{elif}\;t\_3 \leq 0.9925:\\
\;\;\;\;\frac{t\_2}{\mathsf{hypot}\left(t\_2, \sin kx\right)} \cdot th\\
\mathbf{else}:\\
\;\;\;\;\frac{\left|ky\right|}{\mathsf{hypot}\left(\left|ky\right|, \sin kx\right)} \cdot \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.99997999999999998Initial program 94.3%
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%
Taylor expanded in kx around 0
Applied rewrites57.5%
if -0.99997999999999998 < (/.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.10000000000000001Initial program 94.3%
lift-*.f64N/A
lift-/.f64N/A
mult-flipN/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites99.6%
Taylor expanded in th around 0
Applied rewrites52.0%
if -0.10000000000000001 < (/.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.0100000000000000002Initial program 94.3%
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%
Taylor expanded in ky around 0
lower-*.f64N/A
lower-+.f64N/A
lower-*.f64N/A
lower-pow.f6450.7
Applied rewrites50.7%
Taylor expanded in ky around 0
lower-*.f64N/A
lower-+.f64N/A
lower-*.f64N/A
lower-pow.f6454.7
Applied rewrites54.7%
lift-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
distribute-lft-inN/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
*-rgt-identityN/A
lower-fma.f64N/A
lift-pow.f64N/A
unpow2N/A
cube-unmultN/A
metadata-evalN/A
pow-plusN/A
lift-pow.f64N/A
lower-*.f6454.6
lift-pow.f64N/A
unpow2N/A
lower-*.f6454.6
Applied rewrites54.6%
lift-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
distribute-lft-inN/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
*-rgt-identityN/A
lower-fma.f64N/A
lift-pow.f64N/A
unpow2N/A
cube-unmultN/A
metadata-evalN/A
pow-plusN/A
lift-pow.f64N/A
lower-*.f6454.7
lift-pow.f64N/A
unpow2N/A
lower-*.f6454.7
Applied rewrites54.7%
if 0.0100000000000000002 < (/.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.992500000000000049Initial program 94.3%
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%
Taylor expanded in th around 0
Applied rewrites52.0%
if 0.992500000000000049 < (/.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 94.3%
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%
Taylor expanded in ky around 0
Applied rewrites50.9%
Taylor expanded in ky around 0
Applied rewrites64.3%
(FPCore (kx ky th)
:precision binary64
(let* ((t_1
(fma
(* (* (fabs ky) (fabs ky)) (fabs ky))
-0.16666666666666666
(fabs ky)))
(t_2 (sin (fabs ky)))
(t_3 (/ t_2 (sqrt (+ (pow (sin kx) 2.0) (pow t_2 2.0)))))
(t_4 (* (/ th (hypot (sin kx) t_2)) t_2)))
(*
(copysign 1.0 ky)
(if (<= t_3 -0.99998)
(* (/ t_2 (hypot t_2 kx)) (sin th))
(if (<= t_3 -0.1)
t_4
(if (<= t_3 0.01)
(* (/ t_1 (hypot t_1 (sin kx))) (sin th))
(if (<= t_3 0.9925)
t_4
(* (/ (fabs ky) (hypot (fabs ky) (sin kx))) (sin th)))))))))double code(double kx, double ky, double th) {
double t_1 = fma(((fabs(ky) * fabs(ky)) * fabs(ky)), -0.16666666666666666, fabs(ky));
double t_2 = sin(fabs(ky));
double t_3 = t_2 / sqrt((pow(sin(kx), 2.0) + pow(t_2, 2.0)));
double t_4 = (th / hypot(sin(kx), t_2)) * t_2;
double tmp;
if (t_3 <= -0.99998) {
tmp = (t_2 / hypot(t_2, kx)) * sin(th);
} else if (t_3 <= -0.1) {
tmp = t_4;
} else if (t_3 <= 0.01) {
tmp = (t_1 / hypot(t_1, sin(kx))) * sin(th);
} else if (t_3 <= 0.9925) {
tmp = t_4;
} else {
tmp = (fabs(ky) / hypot(fabs(ky), sin(kx))) * sin(th);
}
return copysign(1.0, ky) * tmp;
}
function code(kx, ky, th) t_1 = fma(Float64(Float64(abs(ky) * abs(ky)) * abs(ky)), -0.16666666666666666, abs(ky)) t_2 = sin(abs(ky)) t_3 = Float64(t_2 / sqrt(Float64((sin(kx) ^ 2.0) + (t_2 ^ 2.0)))) t_4 = Float64(Float64(th / hypot(sin(kx), t_2)) * t_2) tmp = 0.0 if (t_3 <= -0.99998) tmp = Float64(Float64(t_2 / hypot(t_2, kx)) * sin(th)); elseif (t_3 <= -0.1) tmp = t_4; elseif (t_3 <= 0.01) tmp = Float64(Float64(t_1 / hypot(t_1, sin(kx))) * sin(th)); elseif (t_3 <= 0.9925) tmp = t_4; else tmp = Float64(Float64(abs(ky) / hypot(abs(ky), sin(kx))) * sin(th)); end return Float64(copysign(1.0, ky) * tmp) end
code[kx_, ky_, th_] := Block[{t$95$1 = N[(N[(N[(N[Abs[ky], $MachinePrecision] * N[Abs[ky], $MachinePrecision]), $MachinePrecision] * N[Abs[ky], $MachinePrecision]), $MachinePrecision] * -0.16666666666666666 + N[Abs[ky], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Sin[N[Abs[ky], $MachinePrecision]], $MachinePrecision]}, Block[{t$95$3 = N[(t$95$2 / N[Sqrt[N[(N[Power[N[Sin[kx], $MachinePrecision], 2.0], $MachinePrecision] + N[Power[t$95$2, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[(th / N[Sqrt[N[Sin[kx], $MachinePrecision] ^ 2 + t$95$2 ^ 2], $MachinePrecision]), $MachinePrecision] * t$95$2), $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[ky]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[t$95$3, -0.99998], N[(N[(t$95$2 / N[Sqrt[t$95$2 ^ 2 + kx ^ 2], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, -0.1], t$95$4, If[LessEqual[t$95$3, 0.01], N[(N[(t$95$1 / N[Sqrt[t$95$1 ^ 2 + N[Sin[kx], $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, 0.9925], t$95$4, N[(N[(N[Abs[ky], $MachinePrecision] / N[Sqrt[N[Abs[ky], $MachinePrecision] ^ 2 + N[Sin[kx], $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision]]]]]), $MachinePrecision]]]]]
\begin{array}{l}
t_1 := \mathsf{fma}\left(\left(\left|ky\right| \cdot \left|ky\right|\right) \cdot \left|ky\right|, -0.16666666666666666, \left|ky\right|\right)\\
t_2 := \sin \left(\left|ky\right|\right)\\
t_3 := \frac{t\_2}{\sqrt{{\sin kx}^{2} + {t\_2}^{2}}}\\
t_4 := \frac{th}{\mathsf{hypot}\left(\sin kx, t\_2\right)} \cdot t\_2\\
\mathsf{copysign}\left(1, ky\right) \cdot \begin{array}{l}
\mathbf{if}\;t\_3 \leq -0.99998:\\
\;\;\;\;\frac{t\_2}{\mathsf{hypot}\left(t\_2, kx\right)} \cdot \sin th\\
\mathbf{elif}\;t\_3 \leq -0.1:\\
\;\;\;\;t\_4\\
\mathbf{elif}\;t\_3 \leq 0.01:\\
\;\;\;\;\frac{t\_1}{\mathsf{hypot}\left(t\_1, \sin kx\right)} \cdot \sin th\\
\mathbf{elif}\;t\_3 \leq 0.9925:\\
\;\;\;\;t\_4\\
\mathbf{else}:\\
\;\;\;\;\frac{\left|ky\right|}{\mathsf{hypot}\left(\left|ky\right|, \sin kx\right)} \cdot \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.99997999999999998Initial program 94.3%
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%
Taylor expanded in kx around 0
Applied rewrites57.5%
if -0.99997999999999998 < (/.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.10000000000000001 or 0.0100000000000000002 < (/.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.992500000000000049Initial program 94.3%
lift-*.f64N/A
lift-/.f64N/A
mult-flipN/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites99.6%
Taylor expanded in th around 0
Applied rewrites52.0%
if -0.10000000000000001 < (/.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.0100000000000000002Initial program 94.3%
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%
Taylor expanded in ky around 0
lower-*.f64N/A
lower-+.f64N/A
lower-*.f64N/A
lower-pow.f6450.7
Applied rewrites50.7%
Taylor expanded in ky around 0
lower-*.f64N/A
lower-+.f64N/A
lower-*.f64N/A
lower-pow.f6454.7
Applied rewrites54.7%
lift-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
distribute-lft-inN/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
*-rgt-identityN/A
lower-fma.f64N/A
lift-pow.f64N/A
unpow2N/A
cube-unmultN/A
metadata-evalN/A
pow-plusN/A
lift-pow.f64N/A
lower-*.f6454.6
lift-pow.f64N/A
unpow2N/A
lower-*.f6454.6
Applied rewrites54.6%
lift-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
distribute-lft-inN/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
*-rgt-identityN/A
lower-fma.f64N/A
lift-pow.f64N/A
unpow2N/A
cube-unmultN/A
metadata-evalN/A
pow-plusN/A
lift-pow.f64N/A
lower-*.f6454.7
lift-pow.f64N/A
unpow2N/A
lower-*.f6454.7
Applied rewrites54.7%
if 0.992500000000000049 < (/.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 94.3%
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%
Taylor expanded in ky around 0
Applied rewrites50.9%
Taylor expanded in ky around 0
Applied rewrites64.3%
(FPCore (kx ky th)
:precision binary64
(let* ((t_1 (sin (fabs ky)))
(t_2 (* (/ th (hypot (sin kx) t_1)) t_1))
(t_3 (/ t_1 (sqrt (+ (pow (sin kx) 2.0) (pow t_1 2.0)))))
(t_4
(fma
(* (* (fabs ky) (fabs ky)) (fabs ky))
-0.16666666666666666
(fabs ky))))
(*
(copysign 1.0 ky)
(if (<= t_3 -0.99998)
(* (sin th) (/ t_1 (sqrt (fma -0.5 (cos (+ (fabs ky) (fabs ky))) 0.5))))
(if (<= t_3 -0.1)
t_2
(if (<= t_3 0.01)
(* (/ t_4 (hypot t_4 (sin kx))) (sin th))
(if (<= t_3 0.9925)
t_2
(* (/ (fabs ky) (hypot (fabs ky) (sin kx))) (sin th)))))))))double code(double kx, double ky, double th) {
double t_1 = sin(fabs(ky));
double t_2 = (th / hypot(sin(kx), t_1)) * t_1;
double t_3 = t_1 / sqrt((pow(sin(kx), 2.0) + pow(t_1, 2.0)));
double t_4 = fma(((fabs(ky) * fabs(ky)) * fabs(ky)), -0.16666666666666666, fabs(ky));
double tmp;
if (t_3 <= -0.99998) {
tmp = sin(th) * (t_1 / sqrt(fma(-0.5, cos((fabs(ky) + fabs(ky))), 0.5)));
} else if (t_3 <= -0.1) {
tmp = t_2;
} else if (t_3 <= 0.01) {
tmp = (t_4 / hypot(t_4, sin(kx))) * sin(th);
} else if (t_3 <= 0.9925) {
tmp = t_2;
} else {
tmp = (fabs(ky) / hypot(fabs(ky), sin(kx))) * sin(th);
}
return copysign(1.0, ky) * tmp;
}
function code(kx, ky, th) t_1 = sin(abs(ky)) t_2 = Float64(Float64(th / hypot(sin(kx), t_1)) * t_1) t_3 = Float64(t_1 / sqrt(Float64((sin(kx) ^ 2.0) + (t_1 ^ 2.0)))) t_4 = fma(Float64(Float64(abs(ky) * abs(ky)) * abs(ky)), -0.16666666666666666, abs(ky)) tmp = 0.0 if (t_3 <= -0.99998) tmp = Float64(sin(th) * Float64(t_1 / sqrt(fma(-0.5, cos(Float64(abs(ky) + abs(ky))), 0.5)))); elseif (t_3 <= -0.1) tmp = t_2; elseif (t_3 <= 0.01) tmp = Float64(Float64(t_4 / hypot(t_4, sin(kx))) * sin(th)); elseif (t_3 <= 0.9925) tmp = t_2; else tmp = Float64(Float64(abs(ky) / hypot(abs(ky), sin(kx))) * sin(th)); end return Float64(copysign(1.0, ky) * tmp) end
code[kx_, ky_, th_] := Block[{t$95$1 = N[Sin[N[Abs[ky], $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[(N[(th / N[Sqrt[N[Sin[kx], $MachinePrecision] ^ 2 + t$95$1 ^ 2], $MachinePrecision]), $MachinePrecision] * t$95$1), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$1 / N[Sqrt[N[(N[Power[N[Sin[kx], $MachinePrecision], 2.0], $MachinePrecision] + N[Power[t$95$1, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[(N[(N[Abs[ky], $MachinePrecision] * N[Abs[ky], $MachinePrecision]), $MachinePrecision] * N[Abs[ky], $MachinePrecision]), $MachinePrecision] * -0.16666666666666666 + N[Abs[ky], $MachinePrecision]), $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[ky]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[t$95$3, -0.99998], N[(N[Sin[th], $MachinePrecision] * N[(t$95$1 / N[Sqrt[N[(-0.5 * N[Cos[N[(N[Abs[ky], $MachinePrecision] + N[Abs[ky], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + 0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, -0.1], t$95$2, If[LessEqual[t$95$3, 0.01], N[(N[(t$95$4 / N[Sqrt[t$95$4 ^ 2 + N[Sin[kx], $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, 0.9925], t$95$2, N[(N[(N[Abs[ky], $MachinePrecision] / N[Sqrt[N[Abs[ky], $MachinePrecision] ^ 2 + N[Sin[kx], $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision]]]]]), $MachinePrecision]]]]]
\begin{array}{l}
t_1 := \sin \left(\left|ky\right|\right)\\
t_2 := \frac{th}{\mathsf{hypot}\left(\sin kx, t\_1\right)} \cdot t\_1\\
t_3 := \frac{t\_1}{\sqrt{{\sin kx}^{2} + {t\_1}^{2}}}\\
t_4 := \mathsf{fma}\left(\left(\left|ky\right| \cdot \left|ky\right|\right) \cdot \left|ky\right|, -0.16666666666666666, \left|ky\right|\right)\\
\mathsf{copysign}\left(1, ky\right) \cdot \begin{array}{l}
\mathbf{if}\;t\_3 \leq -0.99998:\\
\;\;\;\;\sin th \cdot \frac{t\_1}{\sqrt{\mathsf{fma}\left(-0.5, \cos \left(\left|ky\right| + \left|ky\right|\right), 0.5\right)}}\\
\mathbf{elif}\;t\_3 \leq -0.1:\\
\;\;\;\;t\_2\\
\mathbf{elif}\;t\_3 \leq 0.01:\\
\;\;\;\;\frac{t\_4}{\mathsf{hypot}\left(t\_4, \sin kx\right)} \cdot \sin th\\
\mathbf{elif}\;t\_3 \leq 0.9925:\\
\;\;\;\;t\_2\\
\mathbf{else}:\\
\;\;\;\;\frac{\left|ky\right|}{\mathsf{hypot}\left(\left|ky\right|, \sin kx\right)} \cdot \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.99997999999999998Initial program 94.3%
Taylor expanded in kx around 0
lower-pow.f64N/A
lower-sin.f6440.6
Applied rewrites40.6%
lift-*.f64N/A
lift-/.f64N/A
associate-*l/N/A
div-flipN/A
lower-unsound-/.f64N/A
lower-unsound-/.f64N/A
Applied rewrites30.7%
lift-/.f64N/A
lift-/.f64N/A
div-flip-revN/A
lift-sin.f64N/A
lift-sin.f64N/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
lift-sin.f64N/A
lower-/.f64N/A
lift-sin.f6431.0
Applied rewrites31.0%
if -0.99997999999999998 < (/.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.10000000000000001 or 0.0100000000000000002 < (/.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.992500000000000049Initial program 94.3%
lift-*.f64N/A
lift-/.f64N/A
mult-flipN/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
Applied rewrites99.6%
Taylor expanded in th around 0
Applied rewrites52.0%
if -0.10000000000000001 < (/.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.0100000000000000002Initial program 94.3%
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%
Taylor expanded in ky around 0
lower-*.f64N/A
lower-+.f64N/A
lower-*.f64N/A
lower-pow.f6450.7
Applied rewrites50.7%
Taylor expanded in ky around 0
lower-*.f64N/A
lower-+.f64N/A
lower-*.f64N/A
lower-pow.f6454.7
Applied rewrites54.7%
lift-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
distribute-lft-inN/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
*-rgt-identityN/A
lower-fma.f64N/A
lift-pow.f64N/A
unpow2N/A
cube-unmultN/A
metadata-evalN/A
pow-plusN/A
lift-pow.f64N/A
lower-*.f6454.6
lift-pow.f64N/A
unpow2N/A
lower-*.f6454.6
Applied rewrites54.6%
lift-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
distribute-lft-inN/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
*-rgt-identityN/A
lower-fma.f64N/A
lift-pow.f64N/A
unpow2N/A
cube-unmultN/A
metadata-evalN/A
pow-plusN/A
lift-pow.f64N/A
lower-*.f6454.7
lift-pow.f64N/A
unpow2N/A
lower-*.f6454.7
Applied rewrites54.7%
if 0.992500000000000049 < (/.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 94.3%
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%
Taylor expanded in ky around 0
Applied rewrites50.9%
Taylor expanded in ky around 0
Applied rewrites64.3%
(FPCore (kx ky th)
:precision binary64
(let* ((t_1 (sin (fabs ky))))
(*
(copysign 1.0 ky)
(if (<= (/ t_1 (sqrt (+ (pow (sin kx) 2.0) (pow t_1 2.0)))) -0.1)
(* (sin th) (/ t_1 (sqrt (fma -0.5 (cos (+ (fabs ky) (fabs ky))) 0.5))))
(* (/ (fabs ky) (hypot (fabs ky) (sin kx))) (sin th))))))double code(double kx, double ky, double th) {
double t_1 = sin(fabs(ky));
double tmp;
if ((t_1 / sqrt((pow(sin(kx), 2.0) + pow(t_1, 2.0)))) <= -0.1) {
tmp = sin(th) * (t_1 / sqrt(fma(-0.5, cos((fabs(ky) + fabs(ky))), 0.5)));
} else {
tmp = (fabs(ky) / hypot(fabs(ky), sin(kx))) * sin(th);
}
return copysign(1.0, ky) * tmp;
}
function code(kx, ky, th) t_1 = sin(abs(ky)) tmp = 0.0 if (Float64(t_1 / sqrt(Float64((sin(kx) ^ 2.0) + (t_1 ^ 2.0)))) <= -0.1) tmp = Float64(sin(th) * Float64(t_1 / sqrt(fma(-0.5, cos(Float64(abs(ky) + abs(ky))), 0.5)))); else tmp = Float64(Float64(abs(ky) / hypot(abs(ky), sin(kx))) * sin(th)); end return Float64(copysign(1.0, ky) * tmp) end
code[kx_, ky_, th_] := Block[{t$95$1 = N[Sin[N[Abs[ky], $MachinePrecision]], $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[ky]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[(t$95$1 / N[Sqrt[N[(N[Power[N[Sin[kx], $MachinePrecision], 2.0], $MachinePrecision] + N[Power[t$95$1, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], -0.1], N[(N[Sin[th], $MachinePrecision] * N[(t$95$1 / N[Sqrt[N[(-0.5 * N[Cos[N[(N[Abs[ky], $MachinePrecision] + N[Abs[ky], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + 0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Abs[ky], $MachinePrecision] / N[Sqrt[N[Abs[ky], $MachinePrecision] ^ 2 + N[Sin[kx], $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]
\begin{array}{l}
t_1 := \sin \left(\left|ky\right|\right)\\
\mathsf{copysign}\left(1, ky\right) \cdot \begin{array}{l}
\mathbf{if}\;\frac{t\_1}{\sqrt{{\sin kx}^{2} + {t\_1}^{2}}} \leq -0.1:\\
\;\;\;\;\sin th \cdot \frac{t\_1}{\sqrt{\mathsf{fma}\left(-0.5, \cos \left(\left|ky\right| + \left|ky\right|\right), 0.5\right)}}\\
\mathbf{else}:\\
\;\;\;\;\frac{\left|ky\right|}{\mathsf{hypot}\left(\left|ky\right|, \sin kx\right)} \cdot \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.10000000000000001Initial program 94.3%
Taylor expanded in kx around 0
lower-pow.f64N/A
lower-sin.f6440.6
Applied rewrites40.6%
lift-*.f64N/A
lift-/.f64N/A
associate-*l/N/A
div-flipN/A
lower-unsound-/.f64N/A
lower-unsound-/.f64N/A
Applied rewrites30.7%
lift-/.f64N/A
lift-/.f64N/A
div-flip-revN/A
lift-sin.f64N/A
lift-sin.f64N/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
lift-sin.f64N/A
lower-/.f64N/A
lift-sin.f6431.0
Applied rewrites31.0%
if -0.10000000000000001 < (/.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 94.3%
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%
Taylor expanded in ky around 0
Applied rewrites50.9%
Taylor expanded in ky around 0
Applied rewrites64.3%
(FPCore (kx ky th)
:precision binary64
(let* ((t_1 (sin (fabs ky))))
(*
(copysign 1.0 ky)
(if (<= (/ t_1 (sqrt (+ (pow (sin kx) 2.0) (pow t_1 2.0)))) -0.1)
(* t_1 (/ (sin th) (sqrt (fma -0.5 (cos (+ (fabs ky) (fabs ky))) 0.5))))
(* (/ (fabs ky) (hypot (fabs ky) (sin kx))) (sin th))))))double code(double kx, double ky, double th) {
double t_1 = sin(fabs(ky));
double tmp;
if ((t_1 / sqrt((pow(sin(kx), 2.0) + pow(t_1, 2.0)))) <= -0.1) {
tmp = t_1 * (sin(th) / sqrt(fma(-0.5, cos((fabs(ky) + fabs(ky))), 0.5)));
} else {
tmp = (fabs(ky) / hypot(fabs(ky), sin(kx))) * sin(th);
}
return copysign(1.0, ky) * tmp;
}
function code(kx, ky, th) t_1 = sin(abs(ky)) tmp = 0.0 if (Float64(t_1 / sqrt(Float64((sin(kx) ^ 2.0) + (t_1 ^ 2.0)))) <= -0.1) tmp = Float64(t_1 * Float64(sin(th) / sqrt(fma(-0.5, cos(Float64(abs(ky) + abs(ky))), 0.5)))); else tmp = Float64(Float64(abs(ky) / hypot(abs(ky), sin(kx))) * sin(th)); end return Float64(copysign(1.0, ky) * tmp) end
code[kx_, ky_, th_] := Block[{t$95$1 = N[Sin[N[Abs[ky], $MachinePrecision]], $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[ky]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[(t$95$1 / N[Sqrt[N[(N[Power[N[Sin[kx], $MachinePrecision], 2.0], $MachinePrecision] + N[Power[t$95$1, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], -0.1], N[(t$95$1 * N[(N[Sin[th], $MachinePrecision] / N[Sqrt[N[(-0.5 * N[Cos[N[(N[Abs[ky], $MachinePrecision] + N[Abs[ky], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + 0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Abs[ky], $MachinePrecision] / N[Sqrt[N[Abs[ky], $MachinePrecision] ^ 2 + N[Sin[kx], $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]
\begin{array}{l}
t_1 := \sin \left(\left|ky\right|\right)\\
\mathsf{copysign}\left(1, ky\right) \cdot \begin{array}{l}
\mathbf{if}\;\frac{t\_1}{\sqrt{{\sin kx}^{2} + {t\_1}^{2}}} \leq -0.1:\\
\;\;\;\;t\_1 \cdot \frac{\sin th}{\sqrt{\mathsf{fma}\left(-0.5, \cos \left(\left|ky\right| + \left|ky\right|\right), 0.5\right)}}\\
\mathbf{else}:\\
\;\;\;\;\frac{\left|ky\right|}{\mathsf{hypot}\left(\left|ky\right|, \sin kx\right)} \cdot \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.10000000000000001Initial program 94.3%
Taylor expanded in kx around 0
lower-pow.f64N/A
lower-sin.f6440.6
Applied rewrites40.6%
lift-*.f64N/A
lift-/.f64N/A
associate-*l/N/A
div-flipN/A
lower-unsound-/.f64N/A
lower-unsound-/.f64N/A
Applied rewrites30.7%
lift-/.f64N/A
lift-/.f64N/A
div-flip-revN/A
lift-sin.f64N/A
lift-sin.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-*.f64N/A
lift-sin.f64N/A
lower-/.f64N/A
Applied rewrites31.0%
if -0.10000000000000001 < (/.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 94.3%
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%
Taylor expanded in ky around 0
Applied rewrites50.9%
Taylor expanded in ky around 0
Applied rewrites64.3%
(FPCore (kx ky th)
:precision binary64
(let* ((t_1 (sin (fabs ky))))
(*
(copysign 1.0 ky)
(if (<= t_1 -0.05)
(* (/ t_1 (sqrt (pow t_1 2.0))) th)
(* (/ (fabs ky) (hypot (fabs ky) (sin kx))) (sin th))))))double code(double kx, double ky, double th) {
double t_1 = sin(fabs(ky));
double tmp;
if (t_1 <= -0.05) {
tmp = (t_1 / sqrt(pow(t_1, 2.0))) * th;
} else {
tmp = (fabs(ky) / hypot(fabs(ky), sin(kx))) * sin(th);
}
return copysign(1.0, ky) * tmp;
}
public static double code(double kx, double ky, double th) {
double t_1 = Math.sin(Math.abs(ky));
double tmp;
if (t_1 <= -0.05) {
tmp = (t_1 / Math.sqrt(Math.pow(t_1, 2.0))) * th;
} else {
tmp = (Math.abs(ky) / Math.hypot(Math.abs(ky), Math.sin(kx))) * Math.sin(th);
}
return Math.copySign(1.0, ky) * tmp;
}
def code(kx, ky, th): t_1 = math.sin(math.fabs(ky)) tmp = 0 if t_1 <= -0.05: tmp = (t_1 / math.sqrt(math.pow(t_1, 2.0))) * th else: tmp = (math.fabs(ky) / math.hypot(math.fabs(ky), math.sin(kx))) * math.sin(th) return math.copysign(1.0, ky) * tmp
function code(kx, ky, th) t_1 = sin(abs(ky)) tmp = 0.0 if (t_1 <= -0.05) tmp = Float64(Float64(t_1 / sqrt((t_1 ^ 2.0))) * th); else tmp = Float64(Float64(abs(ky) / hypot(abs(ky), sin(kx))) * sin(th)); end return Float64(copysign(1.0, ky) * tmp) end
function tmp_2 = code(kx, ky, th) t_1 = sin(abs(ky)); tmp = 0.0; if (t_1 <= -0.05) tmp = (t_1 / sqrt((t_1 ^ 2.0))) * th; else tmp = (abs(ky) / hypot(abs(ky), sin(kx))) * sin(th); end tmp_2 = (sign(ky) * abs(1.0)) * tmp; end
code[kx_, ky_, th_] := Block[{t$95$1 = N[Sin[N[Abs[ky], $MachinePrecision]], $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[ky]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[t$95$1, -0.05], N[(N[(t$95$1 / N[Sqrt[N[Power[t$95$1, 2.0], $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * th), $MachinePrecision], N[(N[(N[Abs[ky], $MachinePrecision] / N[Sqrt[N[Abs[ky], $MachinePrecision] ^ 2 + N[Sin[kx], $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]
\begin{array}{l}
t_1 := \sin \left(\left|ky\right|\right)\\
\mathsf{copysign}\left(1, ky\right) \cdot \begin{array}{l}
\mathbf{if}\;t\_1 \leq -0.05:\\
\;\;\;\;\frac{t\_1}{\sqrt{{t\_1}^{2}}} \cdot th\\
\mathbf{else}:\\
\;\;\;\;\frac{\left|ky\right|}{\mathsf{hypot}\left(\left|ky\right|, \sin kx\right)} \cdot \sin th\\
\end{array}
\end{array}
if (sin.f64 ky) < -0.050000000000000003Initial program 94.3%
Taylor expanded in kx around 0
lower-pow.f64N/A
lower-sin.f6440.6
Applied rewrites40.6%
Taylor expanded in th around 0
Applied rewrites22.2%
if -0.050000000000000003 < (sin.f64 ky) Initial program 94.3%
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%
Taylor expanded in ky around 0
Applied rewrites50.9%
Taylor expanded in ky around 0
Applied rewrites64.3%
(FPCore (kx ky th)
:precision binary64
(let* ((t_1 (sin (fabs ky))))
(*
(copysign 1.0 ky)
(if (<= t_1 -0.05)
(/
1.0
(/ (sqrt (- 0.5 (* 0.5 (cos (+ (fabs ky) (fabs ky)))))) (* th t_1)))
(* (/ (fabs ky) (hypot (fabs ky) (sin kx))) (sin th))))))double code(double kx, double ky, double th) {
double t_1 = sin(fabs(ky));
double tmp;
if (t_1 <= -0.05) {
tmp = 1.0 / (sqrt((0.5 - (0.5 * cos((fabs(ky) + fabs(ky)))))) / (th * t_1));
} else {
tmp = (fabs(ky) / hypot(fabs(ky), sin(kx))) * sin(th);
}
return copysign(1.0, ky) * tmp;
}
public static double code(double kx, double ky, double th) {
double t_1 = Math.sin(Math.abs(ky));
double tmp;
if (t_1 <= -0.05) {
tmp = 1.0 / (Math.sqrt((0.5 - (0.5 * Math.cos((Math.abs(ky) + Math.abs(ky)))))) / (th * t_1));
} else {
tmp = (Math.abs(ky) / Math.hypot(Math.abs(ky), Math.sin(kx))) * Math.sin(th);
}
return Math.copySign(1.0, ky) * tmp;
}
def code(kx, ky, th): t_1 = math.sin(math.fabs(ky)) tmp = 0 if t_1 <= -0.05: tmp = 1.0 / (math.sqrt((0.5 - (0.5 * math.cos((math.fabs(ky) + math.fabs(ky)))))) / (th * t_1)) else: tmp = (math.fabs(ky) / math.hypot(math.fabs(ky), math.sin(kx))) * math.sin(th) return math.copysign(1.0, ky) * tmp
function code(kx, ky, th) t_1 = sin(abs(ky)) tmp = 0.0 if (t_1 <= -0.05) tmp = Float64(1.0 / Float64(sqrt(Float64(0.5 - Float64(0.5 * cos(Float64(abs(ky) + abs(ky)))))) / Float64(th * t_1))); else tmp = Float64(Float64(abs(ky) / hypot(abs(ky), sin(kx))) * sin(th)); end return Float64(copysign(1.0, ky) * tmp) end
function tmp_2 = code(kx, ky, th) t_1 = sin(abs(ky)); tmp = 0.0; if (t_1 <= -0.05) tmp = 1.0 / (sqrt((0.5 - (0.5 * cos((abs(ky) + abs(ky)))))) / (th * t_1)); else tmp = (abs(ky) / hypot(abs(ky), sin(kx))) * sin(th); end tmp_2 = (sign(ky) * abs(1.0)) * tmp; end
code[kx_, ky_, th_] := Block[{t$95$1 = N[Sin[N[Abs[ky], $MachinePrecision]], $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[ky]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[t$95$1, -0.05], N[(1.0 / N[(N[Sqrt[N[(0.5 - N[(0.5 * N[Cos[N[(N[Abs[ky], $MachinePrecision] + N[Abs[ky], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(th * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Abs[ky], $MachinePrecision] / N[Sqrt[N[Abs[ky], $MachinePrecision] ^ 2 + N[Sin[kx], $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]
\begin{array}{l}
t_1 := \sin \left(\left|ky\right|\right)\\
\mathsf{copysign}\left(1, ky\right) \cdot \begin{array}{l}
\mathbf{if}\;t\_1 \leq -0.05:\\
\;\;\;\;\frac{1}{\frac{\sqrt{0.5 - 0.5 \cdot \cos \left(\left|ky\right| + \left|ky\right|\right)}}{th \cdot t\_1}}\\
\mathbf{else}:\\
\;\;\;\;\frac{\left|ky\right|}{\mathsf{hypot}\left(\left|ky\right|, \sin kx\right)} \cdot \sin th\\
\end{array}
\end{array}
if (sin.f64 ky) < -0.050000000000000003Initial program 94.3%
Taylor expanded in kx around 0
lower-pow.f64N/A
lower-sin.f6440.6
Applied rewrites40.6%
lift-*.f64N/A
lift-/.f64N/A
associate-*l/N/A
div-flipN/A
lower-unsound-/.f64N/A
lower-unsound-/.f64N/A
Applied rewrites30.7%
Taylor expanded in th around 0
lower-*.f64N/A
lower-sin.f6417.0
Applied rewrites17.0%
if -0.050000000000000003 < (sin.f64 ky) Initial program 94.3%
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%
Taylor expanded in ky around 0
Applied rewrites50.9%
Taylor expanded in ky around 0
Applied rewrites64.3%
(FPCore (kx ky th)
:precision binary64
(let* ((t_1 (sin (fabs ky))))
(*
(copysign 1.0 ky)
(if (<= t_1 -0.05)
(* (/ t_1 (hypot t_1 kx)) th)
(* (/ (fabs ky) (hypot (fabs ky) (sin kx))) (sin th))))))double code(double kx, double ky, double th) {
double t_1 = sin(fabs(ky));
double tmp;
if (t_1 <= -0.05) {
tmp = (t_1 / hypot(t_1, kx)) * th;
} else {
tmp = (fabs(ky) / hypot(fabs(ky), sin(kx))) * sin(th);
}
return copysign(1.0, ky) * tmp;
}
public static double code(double kx, double ky, double th) {
double t_1 = Math.sin(Math.abs(ky));
double tmp;
if (t_1 <= -0.05) {
tmp = (t_1 / Math.hypot(t_1, kx)) * th;
} else {
tmp = (Math.abs(ky) / Math.hypot(Math.abs(ky), Math.sin(kx))) * Math.sin(th);
}
return Math.copySign(1.0, ky) * tmp;
}
def code(kx, ky, th): t_1 = math.sin(math.fabs(ky)) tmp = 0 if t_1 <= -0.05: tmp = (t_1 / math.hypot(t_1, kx)) * th else: tmp = (math.fabs(ky) / math.hypot(math.fabs(ky), math.sin(kx))) * math.sin(th) return math.copysign(1.0, ky) * tmp
function code(kx, ky, th) t_1 = sin(abs(ky)) tmp = 0.0 if (t_1 <= -0.05) tmp = Float64(Float64(t_1 / hypot(t_1, kx)) * th); else tmp = Float64(Float64(abs(ky) / hypot(abs(ky), sin(kx))) * sin(th)); end return Float64(copysign(1.0, ky) * tmp) end
function tmp_2 = code(kx, ky, th) t_1 = sin(abs(ky)); tmp = 0.0; if (t_1 <= -0.05) tmp = (t_1 / hypot(t_1, kx)) * th; else tmp = (abs(ky) / hypot(abs(ky), sin(kx))) * sin(th); end tmp_2 = (sign(ky) * abs(1.0)) * tmp; end
code[kx_, ky_, th_] := Block[{t$95$1 = N[Sin[N[Abs[ky], $MachinePrecision]], $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[ky]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[t$95$1, -0.05], N[(N[(t$95$1 / N[Sqrt[t$95$1 ^ 2 + kx ^ 2], $MachinePrecision]), $MachinePrecision] * th), $MachinePrecision], N[(N[(N[Abs[ky], $MachinePrecision] / N[Sqrt[N[Abs[ky], $MachinePrecision] ^ 2 + N[Sin[kx], $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]
\begin{array}{l}
t_1 := \sin \left(\left|ky\right|\right)\\
\mathsf{copysign}\left(1, ky\right) \cdot \begin{array}{l}
\mathbf{if}\;t\_1 \leq -0.05:\\
\;\;\;\;\frac{t\_1}{\mathsf{hypot}\left(t\_1, kx\right)} \cdot th\\
\mathbf{else}:\\
\;\;\;\;\frac{\left|ky\right|}{\mathsf{hypot}\left(\left|ky\right|, \sin kx\right)} \cdot \sin th\\
\end{array}
\end{array}
if (sin.f64 ky) < -0.050000000000000003Initial program 94.3%
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%
Taylor expanded in kx around 0
Applied rewrites57.5%
Taylor expanded in th around 0
Applied rewrites34.3%
if -0.050000000000000003 < (sin.f64 ky) Initial program 94.3%
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%
Taylor expanded in ky around 0
Applied rewrites50.9%
Taylor expanded in ky around 0
Applied rewrites64.3%
(FPCore (kx ky th)
:precision binary64
(let* ((t_1
(* (fabs ky) (fma (* -0.16666666666666666 (fabs ky)) (fabs ky) 1.0)))
(t_2 (sin (fabs ky))))
(*
(copysign 1.0 ky)
(if (<= (/ t_2 (sqrt (+ (pow (sin kx) 2.0) (pow t_2 2.0)))) -0.15)
(* (/ t_1 (hypot t_1 kx)) (sin th))
(* (/ (fabs ky) (hypot (fabs ky) (sin kx))) (sin th))))))double code(double kx, double ky, double th) {
double t_1 = fabs(ky) * fma((-0.16666666666666666 * fabs(ky)), fabs(ky), 1.0);
double t_2 = sin(fabs(ky));
double tmp;
if ((t_2 / sqrt((pow(sin(kx), 2.0) + pow(t_2, 2.0)))) <= -0.15) {
tmp = (t_1 / hypot(t_1, kx)) * sin(th);
} else {
tmp = (fabs(ky) / hypot(fabs(ky), sin(kx))) * sin(th);
}
return copysign(1.0, ky) * tmp;
}
function code(kx, ky, th) t_1 = Float64(abs(ky) * fma(Float64(-0.16666666666666666 * abs(ky)), abs(ky), 1.0)) t_2 = sin(abs(ky)) tmp = 0.0 if (Float64(t_2 / sqrt(Float64((sin(kx) ^ 2.0) + (t_2 ^ 2.0)))) <= -0.15) tmp = Float64(Float64(t_1 / hypot(t_1, kx)) * sin(th)); else tmp = Float64(Float64(abs(ky) / hypot(abs(ky), sin(kx))) * sin(th)); end return Float64(copysign(1.0, ky) * tmp) end
code[kx_, ky_, th_] := Block[{t$95$1 = N[(N[Abs[ky], $MachinePrecision] * N[(N[(-0.16666666666666666 * N[Abs[ky], $MachinePrecision]), $MachinePrecision] * N[Abs[ky], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Sin[N[Abs[ky], $MachinePrecision]], $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[ky]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[(t$95$2 / N[Sqrt[N[(N[Power[N[Sin[kx], $MachinePrecision], 2.0], $MachinePrecision] + N[Power[t$95$2, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], -0.15], N[(N[(t$95$1 / N[Sqrt[t$95$1 ^ 2 + kx ^ 2], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision], N[(N[(N[Abs[ky], $MachinePrecision] / N[Sqrt[N[Abs[ky], $MachinePrecision] ^ 2 + N[Sin[kx], $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]]
\begin{array}{l}
t_1 := \left|ky\right| \cdot \mathsf{fma}\left(-0.16666666666666666 \cdot \left|ky\right|, \left|ky\right|, 1\right)\\
t_2 := \sin \left(\left|ky\right|\right)\\
\mathsf{copysign}\left(1, ky\right) \cdot \begin{array}{l}
\mathbf{if}\;\frac{t\_2}{\sqrt{{\sin kx}^{2} + {t\_2}^{2}}} \leq -0.15:\\
\;\;\;\;\frac{t\_1}{\mathsf{hypot}\left(t\_1, kx\right)} \cdot \sin th\\
\mathbf{else}:\\
\;\;\;\;\frac{\left|ky\right|}{\mathsf{hypot}\left(\left|ky\right|, \sin kx\right)} \cdot \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 94.3%
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%
Taylor expanded in kx around 0
Applied rewrites57.5%
Taylor expanded in ky around 0
lower-*.f64N/A
lower-+.f64N/A
lower-*.f64N/A
lower-pow.f6432.8
Applied rewrites32.8%
Taylor expanded in ky around 0
lower-*.f64N/A
lower-+.f64N/A
lower-*.f64N/A
lower-pow.f6436.4
Applied rewrites36.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-pow.f64N/A
unpow2N/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f6436.3
Applied rewrites36.3%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-pow.f64N/A
unpow2N/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f6436.4
Applied rewrites36.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 94.3%
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%
Taylor expanded in ky around 0
Applied rewrites50.9%
Taylor expanded in ky around 0
Applied rewrites64.3%
(FPCore (kx ky th)
:precision binary64
(let* ((t_1
(* (fabs ky) (fma (* -0.16666666666666666 (fabs ky)) (fabs ky) 1.0)))
(t_2 (sin (fabs ky)))
(t_3 (/ t_2 (sqrt (+ (pow (sin kx) 2.0) (pow t_2 2.0))))))
(*
(copysign 1.0 ky)
(if (<= t_3 -0.15)
(* (/ t_1 (hypot t_1 kx)) (sin th))
(if (<= t_3 0.01)
(* (sin th) (/ (fabs ky) (fabs (sin kx))))
(* (/ (fabs ky) (hypot (fabs ky) kx)) (sin th)))))))double code(double kx, double ky, double th) {
double t_1 = fabs(ky) * fma((-0.16666666666666666 * fabs(ky)), fabs(ky), 1.0);
double t_2 = sin(fabs(ky));
double t_3 = t_2 / sqrt((pow(sin(kx), 2.0) + pow(t_2, 2.0)));
double tmp;
if (t_3 <= -0.15) {
tmp = (t_1 / hypot(t_1, kx)) * sin(th);
} else if (t_3 <= 0.01) {
tmp = sin(th) * (fabs(ky) / fabs(sin(kx)));
} else {
tmp = (fabs(ky) / hypot(fabs(ky), kx)) * sin(th);
}
return copysign(1.0, ky) * tmp;
}
function code(kx, ky, th) t_1 = Float64(abs(ky) * fma(Float64(-0.16666666666666666 * abs(ky)), abs(ky), 1.0)) t_2 = sin(abs(ky)) t_3 = Float64(t_2 / sqrt(Float64((sin(kx) ^ 2.0) + (t_2 ^ 2.0)))) tmp = 0.0 if (t_3 <= -0.15) tmp = Float64(Float64(t_1 / hypot(t_1, kx)) * sin(th)); elseif (t_3 <= 0.01) tmp = Float64(sin(th) * Float64(abs(ky) / abs(sin(kx)))); else tmp = Float64(Float64(abs(ky) / hypot(abs(ky), kx)) * sin(th)); end return Float64(copysign(1.0, ky) * tmp) end
code[kx_, ky_, th_] := Block[{t$95$1 = N[(N[Abs[ky], $MachinePrecision] * N[(N[(-0.16666666666666666 * N[Abs[ky], $MachinePrecision]), $MachinePrecision] * N[Abs[ky], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Sin[N[Abs[ky], $MachinePrecision]], $MachinePrecision]}, Block[{t$95$3 = N[(t$95$2 / N[Sqrt[N[(N[Power[N[Sin[kx], $MachinePrecision], 2.0], $MachinePrecision] + N[Power[t$95$2, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[ky]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[t$95$3, -0.15], N[(N[(t$95$1 / N[Sqrt[t$95$1 ^ 2 + kx ^ 2], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, 0.01], N[(N[Sin[th], $MachinePrecision] * N[(N[Abs[ky], $MachinePrecision] / N[Abs[N[Sin[kx], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Abs[ky], $MachinePrecision] / N[Sqrt[N[Abs[ky], $MachinePrecision] ^ 2 + kx ^ 2], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]]]]
\begin{array}{l}
t_1 := \left|ky\right| \cdot \mathsf{fma}\left(-0.16666666666666666 \cdot \left|ky\right|, \left|ky\right|, 1\right)\\
t_2 := \sin \left(\left|ky\right|\right)\\
t_3 := \frac{t\_2}{\sqrt{{\sin kx}^{2} + {t\_2}^{2}}}\\
\mathsf{copysign}\left(1, ky\right) \cdot \begin{array}{l}
\mathbf{if}\;t\_3 \leq -0.15:\\
\;\;\;\;\frac{t\_1}{\mathsf{hypot}\left(t\_1, kx\right)} \cdot \sin th\\
\mathbf{elif}\;t\_3 \leq 0.01:\\
\;\;\;\;\sin th \cdot \frac{\left|ky\right|}{\left|\sin kx\right|}\\
\mathbf{else}:\\
\;\;\;\;\frac{\left|ky\right|}{\mathsf{hypot}\left(\left|ky\right|, kx\right)} \cdot \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 94.3%
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%
Taylor expanded in kx around 0
Applied rewrites57.5%
Taylor expanded in ky around 0
lower-*.f64N/A
lower-+.f64N/A
lower-*.f64N/A
lower-pow.f6432.8
Applied rewrites32.8%
Taylor expanded in ky around 0
lower-*.f64N/A
lower-+.f64N/A
lower-*.f64N/A
lower-pow.f6436.4
Applied rewrites36.4%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-pow.f64N/A
unpow2N/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f6436.3
Applied rewrites36.3%
lift-+.f64N/A
+-commutativeN/A
lift-*.f64N/A
lift-pow.f64N/A
unpow2N/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f6436.4
Applied rewrites36.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))))) < 0.0100000000000000002Initial program 94.3%
Taylor expanded in ky around 0
lower-/.f64N/A
lower-*.f64N/A
lower-sin.f64N/A
lower-sqrt.f64N/A
lower-pow.f64N/A
lower-sin.f6435.5
Applied rewrites35.5%
lift-/.f64N/A
mult-flipN/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
mult-flip-revN/A
lower-/.f6436.4
lift-sqrt.f64N/A
lift-pow.f64N/A
pow2N/A
rem-sqrt-square-revN/A
lower-fabs.f6439.1
Applied rewrites39.1%
if 0.0100000000000000002 < (/.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 94.3%
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%
Taylor expanded in kx around 0
Applied rewrites57.5%
Taylor expanded in ky around 0
Applied rewrites33.3%
Taylor expanded in ky around 0
Applied rewrites45.6%
(FPCore (kx ky th)
:precision binary64
(let* ((t_1
(* (fma (* (fabs ky) (fabs ky)) -0.16666666666666666 1.0) (fabs ky)))
(t_2 (sin (fabs ky)))
(t_3 (/ t_2 (sqrt (+ (pow (sin kx) 2.0) (pow t_2 2.0))))))
(*
(copysign 1.0 ky)
(if (<= t_3 -0.15)
(/ (* t_1 (sin th)) (hypot kx t_1))
(if (<= t_3 0.01)
(* (sin th) (/ (fabs ky) (fabs (sin kx))))
(* (/ (fabs ky) (hypot (fabs ky) kx)) (sin th)))))))double code(double kx, double ky, double th) {
double t_1 = fma((fabs(ky) * fabs(ky)), -0.16666666666666666, 1.0) * fabs(ky);
double t_2 = sin(fabs(ky));
double t_3 = t_2 / sqrt((pow(sin(kx), 2.0) + pow(t_2, 2.0)));
double tmp;
if (t_3 <= -0.15) {
tmp = (t_1 * sin(th)) / hypot(kx, t_1);
} else if (t_3 <= 0.01) {
tmp = sin(th) * (fabs(ky) / fabs(sin(kx)));
} else {
tmp = (fabs(ky) / hypot(fabs(ky), kx)) * sin(th);
}
return copysign(1.0, ky) * tmp;
}
function code(kx, ky, th) t_1 = Float64(fma(Float64(abs(ky) * abs(ky)), -0.16666666666666666, 1.0) * abs(ky)) t_2 = sin(abs(ky)) t_3 = Float64(t_2 / sqrt(Float64((sin(kx) ^ 2.0) + (t_2 ^ 2.0)))) tmp = 0.0 if (t_3 <= -0.15) tmp = Float64(Float64(t_1 * sin(th)) / hypot(kx, t_1)); elseif (t_3 <= 0.01) tmp = Float64(sin(th) * Float64(abs(ky) / abs(sin(kx)))); else tmp = Float64(Float64(abs(ky) / hypot(abs(ky), kx)) * sin(th)); end return Float64(copysign(1.0, ky) * tmp) end
code[kx_, ky_, th_] := Block[{t$95$1 = N[(N[(N[(N[Abs[ky], $MachinePrecision] * N[Abs[ky], $MachinePrecision]), $MachinePrecision] * -0.16666666666666666 + 1.0), $MachinePrecision] * N[Abs[ky], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Sin[N[Abs[ky], $MachinePrecision]], $MachinePrecision]}, Block[{t$95$3 = N[(t$95$2 / N[Sqrt[N[(N[Power[N[Sin[kx], $MachinePrecision], 2.0], $MachinePrecision] + N[Power[t$95$2, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[ky]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[t$95$3, -0.15], N[(N[(t$95$1 * N[Sin[th], $MachinePrecision]), $MachinePrecision] / N[Sqrt[kx ^ 2 + t$95$1 ^ 2], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, 0.01], N[(N[Sin[th], $MachinePrecision] * N[(N[Abs[ky], $MachinePrecision] / N[Abs[N[Sin[kx], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Abs[ky], $MachinePrecision] / N[Sqrt[N[Abs[ky], $MachinePrecision] ^ 2 + kx ^ 2], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]]]]
\begin{array}{l}
t_1 := \mathsf{fma}\left(\left|ky\right| \cdot \left|ky\right|, -0.16666666666666666, 1\right) \cdot \left|ky\right|\\
t_2 := \sin \left(\left|ky\right|\right)\\
t_3 := \frac{t\_2}{\sqrt{{\sin kx}^{2} + {t\_2}^{2}}}\\
\mathsf{copysign}\left(1, ky\right) \cdot \begin{array}{l}
\mathbf{if}\;t\_3 \leq -0.15:\\
\;\;\;\;\frac{t\_1 \cdot \sin th}{\mathsf{hypot}\left(kx, t\_1\right)}\\
\mathbf{elif}\;t\_3 \leq 0.01:\\
\;\;\;\;\sin th \cdot \frac{\left|ky\right|}{\left|\sin kx\right|}\\
\mathbf{else}:\\
\;\;\;\;\frac{\left|ky\right|}{\mathsf{hypot}\left(\left|ky\right|, kx\right)} \cdot \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 94.3%
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%
Taylor expanded in kx around 0
Applied rewrites57.5%
Taylor expanded in ky around 0
lower-*.f64N/A
lower-+.f64N/A
lower-*.f64N/A
lower-pow.f6432.8
Applied rewrites32.8%
Taylor expanded in ky around 0
lower-*.f64N/A
lower-+.f64N/A
lower-*.f64N/A
lower-pow.f6436.4
Applied rewrites36.4%
lift-sin.f64N/A
lift-*.f64N/A
lift-/.f64N/A
associate-*l/N/A
lower-/.f64N/A
Applied rewrites33.1%
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))))) < 0.0100000000000000002Initial program 94.3%
Taylor expanded in ky around 0
lower-/.f64N/A
lower-*.f64N/A
lower-sin.f64N/A
lower-sqrt.f64N/A
lower-pow.f64N/A
lower-sin.f6435.5
Applied rewrites35.5%
lift-/.f64N/A
mult-flipN/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
mult-flip-revN/A
lower-/.f6436.4
lift-sqrt.f64N/A
lift-pow.f64N/A
pow2N/A
rem-sqrt-square-revN/A
lower-fabs.f6439.1
Applied rewrites39.1%
if 0.0100000000000000002 < (/.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 94.3%
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%
Taylor expanded in kx around 0
Applied rewrites57.5%
Taylor expanded in ky around 0
Applied rewrites33.3%
Taylor expanded in ky around 0
Applied rewrites45.6%
(FPCore (kx ky th)
:precision binary64
(let* ((t_1
(* (fma (* (fabs ky) (fabs ky)) -0.16666666666666666 1.0) (fabs ky)))
(t_2 (sin (fabs ky)))
(t_3 (/ t_2 (sqrt (+ (pow (sin kx) 2.0) (pow t_2 2.0))))))
(*
(copysign 1.0 ky)
(if (<= t_3 -0.15)
(* t_1 (/ (sin th) (hypot kx t_1)))
(if (<= t_3 0.01)
(* (sin th) (/ (fabs ky) (fabs (sin kx))))
(* (/ (fabs ky) (hypot (fabs ky) kx)) (sin th)))))))double code(double kx, double ky, double th) {
double t_1 = fma((fabs(ky) * fabs(ky)), -0.16666666666666666, 1.0) * fabs(ky);
double t_2 = sin(fabs(ky));
double t_3 = t_2 / sqrt((pow(sin(kx), 2.0) + pow(t_2, 2.0)));
double tmp;
if (t_3 <= -0.15) {
tmp = t_1 * (sin(th) / hypot(kx, t_1));
} else if (t_3 <= 0.01) {
tmp = sin(th) * (fabs(ky) / fabs(sin(kx)));
} else {
tmp = (fabs(ky) / hypot(fabs(ky), kx)) * sin(th);
}
return copysign(1.0, ky) * tmp;
}
function code(kx, ky, th) t_1 = Float64(fma(Float64(abs(ky) * abs(ky)), -0.16666666666666666, 1.0) * abs(ky)) t_2 = sin(abs(ky)) t_3 = Float64(t_2 / sqrt(Float64((sin(kx) ^ 2.0) + (t_2 ^ 2.0)))) tmp = 0.0 if (t_3 <= -0.15) tmp = Float64(t_1 * Float64(sin(th) / hypot(kx, t_1))); elseif (t_3 <= 0.01) tmp = Float64(sin(th) * Float64(abs(ky) / abs(sin(kx)))); else tmp = Float64(Float64(abs(ky) / hypot(abs(ky), kx)) * sin(th)); end return Float64(copysign(1.0, ky) * tmp) end
code[kx_, ky_, th_] := Block[{t$95$1 = N[(N[(N[(N[Abs[ky], $MachinePrecision] * N[Abs[ky], $MachinePrecision]), $MachinePrecision] * -0.16666666666666666 + 1.0), $MachinePrecision] * N[Abs[ky], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Sin[N[Abs[ky], $MachinePrecision]], $MachinePrecision]}, Block[{t$95$3 = N[(t$95$2 / N[Sqrt[N[(N[Power[N[Sin[kx], $MachinePrecision], 2.0], $MachinePrecision] + N[Power[t$95$2, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[ky]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[t$95$3, -0.15], N[(t$95$1 * N[(N[Sin[th], $MachinePrecision] / N[Sqrt[kx ^ 2 + t$95$1 ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, 0.01], N[(N[Sin[th], $MachinePrecision] * N[(N[Abs[ky], $MachinePrecision] / N[Abs[N[Sin[kx], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Abs[ky], $MachinePrecision] / N[Sqrt[N[Abs[ky], $MachinePrecision] ^ 2 + kx ^ 2], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]]]]
\begin{array}{l}
t_1 := \mathsf{fma}\left(\left|ky\right| \cdot \left|ky\right|, -0.16666666666666666, 1\right) \cdot \left|ky\right|\\
t_2 := \sin \left(\left|ky\right|\right)\\
t_3 := \frac{t\_2}{\sqrt{{\sin kx}^{2} + {t\_2}^{2}}}\\
\mathsf{copysign}\left(1, ky\right) \cdot \begin{array}{l}
\mathbf{if}\;t\_3 \leq -0.15:\\
\;\;\;\;t\_1 \cdot \frac{\sin th}{\mathsf{hypot}\left(kx, t\_1\right)}\\
\mathbf{elif}\;t\_3 \leq 0.01:\\
\;\;\;\;\sin th \cdot \frac{\left|ky\right|}{\left|\sin kx\right|}\\
\mathbf{else}:\\
\;\;\;\;\frac{\left|ky\right|}{\mathsf{hypot}\left(\left|ky\right|, kx\right)} \cdot \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 94.3%
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%
Taylor expanded in kx around 0
Applied rewrites57.5%
Taylor expanded in ky around 0
lower-*.f64N/A
lower-+.f64N/A
lower-*.f64N/A
lower-pow.f6432.8
Applied rewrites32.8%
Taylor expanded in ky around 0
lower-*.f64N/A
lower-+.f64N/A
lower-*.f64N/A
lower-pow.f6436.4
Applied rewrites36.4%
lift-sin.f64N/A
lift-*.f64N/A
lift-/.f64N/A
associate-*l/N/A
associate-/l*N/A
lower-*.f64N/A
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))))) < 0.0100000000000000002Initial program 94.3%
Taylor expanded in ky around 0
lower-/.f64N/A
lower-*.f64N/A
lower-sin.f64N/A
lower-sqrt.f64N/A
lower-pow.f64N/A
lower-sin.f6435.5
Applied rewrites35.5%
lift-/.f64N/A
mult-flipN/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
mult-flip-revN/A
lower-/.f6436.4
lift-sqrt.f64N/A
lift-pow.f64N/A
pow2N/A
rem-sqrt-square-revN/A
lower-fabs.f6439.1
Applied rewrites39.1%
if 0.0100000000000000002 < (/.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 94.3%
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%
Taylor expanded in kx around 0
Applied rewrites57.5%
Taylor expanded in ky around 0
Applied rewrites33.3%
Taylor expanded in ky around 0
Applied rewrites45.6%
(FPCore (kx ky th)
:precision binary64
(let* ((t_1 (sin (fabs ky))))
(*
(copysign 1.0 ky)
(if (<= (/ t_1 (sqrt (+ (pow (sin kx) 2.0) (pow t_1 2.0)))) 0.01)
(* (sin th) (/ (fabs ky) (fabs (sin kx))))
(* (/ (fabs ky) (hypot (fabs ky) kx)) (sin th))))))double code(double kx, double ky, double th) {
double t_1 = sin(fabs(ky));
double tmp;
if ((t_1 / sqrt((pow(sin(kx), 2.0) + pow(t_1, 2.0)))) <= 0.01) {
tmp = sin(th) * (fabs(ky) / fabs(sin(kx)));
} else {
tmp = (fabs(ky) / hypot(fabs(ky), kx)) * sin(th);
}
return copysign(1.0, ky) * tmp;
}
public static double code(double kx, double ky, double th) {
double t_1 = Math.sin(Math.abs(ky));
double tmp;
if ((t_1 / Math.sqrt((Math.pow(Math.sin(kx), 2.0) + Math.pow(t_1, 2.0)))) <= 0.01) {
tmp = Math.sin(th) * (Math.abs(ky) / Math.abs(Math.sin(kx)));
} else {
tmp = (Math.abs(ky) / Math.hypot(Math.abs(ky), kx)) * Math.sin(th);
}
return Math.copySign(1.0, ky) * tmp;
}
def code(kx, ky, th): t_1 = math.sin(math.fabs(ky)) tmp = 0 if (t_1 / math.sqrt((math.pow(math.sin(kx), 2.0) + math.pow(t_1, 2.0)))) <= 0.01: tmp = math.sin(th) * (math.fabs(ky) / math.fabs(math.sin(kx))) else: tmp = (math.fabs(ky) / math.hypot(math.fabs(ky), kx)) * math.sin(th) return math.copysign(1.0, ky) * tmp
function code(kx, ky, th) t_1 = sin(abs(ky)) tmp = 0.0 if (Float64(t_1 / sqrt(Float64((sin(kx) ^ 2.0) + (t_1 ^ 2.0)))) <= 0.01) tmp = Float64(sin(th) * Float64(abs(ky) / abs(sin(kx)))); else tmp = Float64(Float64(abs(ky) / hypot(abs(ky), kx)) * sin(th)); end return Float64(copysign(1.0, ky) * tmp) end
function tmp_2 = code(kx, ky, th) t_1 = sin(abs(ky)); tmp = 0.0; if ((t_1 / sqrt(((sin(kx) ^ 2.0) + (t_1 ^ 2.0)))) <= 0.01) tmp = sin(th) * (abs(ky) / abs(sin(kx))); else tmp = (abs(ky) / hypot(abs(ky), kx)) * sin(th); end tmp_2 = (sign(ky) * abs(1.0)) * tmp; end
code[kx_, ky_, th_] := Block[{t$95$1 = N[Sin[N[Abs[ky], $MachinePrecision]], $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[ky]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[(t$95$1 / N[Sqrt[N[(N[Power[N[Sin[kx], $MachinePrecision], 2.0], $MachinePrecision] + N[Power[t$95$1, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 0.01], N[(N[Sin[th], $MachinePrecision] * N[(N[Abs[ky], $MachinePrecision] / N[Abs[N[Sin[kx], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Abs[ky], $MachinePrecision] / N[Sqrt[N[Abs[ky], $MachinePrecision] ^ 2 + kx ^ 2], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]
\begin{array}{l}
t_1 := \sin \left(\left|ky\right|\right)\\
\mathsf{copysign}\left(1, ky\right) \cdot \begin{array}{l}
\mathbf{if}\;\frac{t\_1}{\sqrt{{\sin kx}^{2} + {t\_1}^{2}}} \leq 0.01:\\
\;\;\;\;\sin th \cdot \frac{\left|ky\right|}{\left|\sin kx\right|}\\
\mathbf{else}:\\
\;\;\;\;\frac{\left|ky\right|}{\mathsf{hypot}\left(\left|ky\right|, kx\right)} \cdot \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.0100000000000000002Initial program 94.3%
Taylor expanded in ky around 0
lower-/.f64N/A
lower-*.f64N/A
lower-sin.f64N/A
lower-sqrt.f64N/A
lower-pow.f64N/A
lower-sin.f6435.5
Applied rewrites35.5%
lift-/.f64N/A
mult-flipN/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
mult-flip-revN/A
lower-/.f6436.4
lift-sqrt.f64N/A
lift-pow.f64N/A
pow2N/A
rem-sqrt-square-revN/A
lower-fabs.f6439.1
Applied rewrites39.1%
if 0.0100000000000000002 < (/.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 94.3%
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%
Taylor expanded in kx around 0
Applied rewrites57.5%
Taylor expanded in ky around 0
Applied rewrites33.3%
Taylor expanded in ky around 0
Applied rewrites45.6%
(FPCore (kx ky th)
:precision binary64
(let* ((t_1 (sin (fabs ky))))
(*
(copysign 1.0 ky)
(if (<= (/ t_1 (sqrt (+ (pow (sin kx) 2.0) (pow t_1 2.0)))) 0.01)
(* (/ (sin th) (fabs (sin kx))) (fabs ky))
(* (/ (fabs ky) (hypot (fabs ky) kx)) (sin th))))))double code(double kx, double ky, double th) {
double t_1 = sin(fabs(ky));
double tmp;
if ((t_1 / sqrt((pow(sin(kx), 2.0) + pow(t_1, 2.0)))) <= 0.01) {
tmp = (sin(th) / fabs(sin(kx))) * fabs(ky);
} else {
tmp = (fabs(ky) / hypot(fabs(ky), kx)) * sin(th);
}
return copysign(1.0, ky) * tmp;
}
public static double code(double kx, double ky, double th) {
double t_1 = Math.sin(Math.abs(ky));
double tmp;
if ((t_1 / Math.sqrt((Math.pow(Math.sin(kx), 2.0) + Math.pow(t_1, 2.0)))) <= 0.01) {
tmp = (Math.sin(th) / Math.abs(Math.sin(kx))) * Math.abs(ky);
} else {
tmp = (Math.abs(ky) / Math.hypot(Math.abs(ky), kx)) * Math.sin(th);
}
return Math.copySign(1.0, ky) * tmp;
}
def code(kx, ky, th): t_1 = math.sin(math.fabs(ky)) tmp = 0 if (t_1 / math.sqrt((math.pow(math.sin(kx), 2.0) + math.pow(t_1, 2.0)))) <= 0.01: tmp = (math.sin(th) / math.fabs(math.sin(kx))) * math.fabs(ky) else: tmp = (math.fabs(ky) / math.hypot(math.fabs(ky), kx)) * math.sin(th) return math.copysign(1.0, ky) * tmp
function code(kx, ky, th) t_1 = sin(abs(ky)) tmp = 0.0 if (Float64(t_1 / sqrt(Float64((sin(kx) ^ 2.0) + (t_1 ^ 2.0)))) <= 0.01) tmp = Float64(Float64(sin(th) / abs(sin(kx))) * abs(ky)); else tmp = Float64(Float64(abs(ky) / hypot(abs(ky), kx)) * sin(th)); end return Float64(copysign(1.0, ky) * tmp) end
function tmp_2 = code(kx, ky, th) t_1 = sin(abs(ky)); tmp = 0.0; if ((t_1 / sqrt(((sin(kx) ^ 2.0) + (t_1 ^ 2.0)))) <= 0.01) tmp = (sin(th) / abs(sin(kx))) * abs(ky); else tmp = (abs(ky) / hypot(abs(ky), kx)) * sin(th); end tmp_2 = (sign(ky) * abs(1.0)) * tmp; end
code[kx_, ky_, th_] := Block[{t$95$1 = N[Sin[N[Abs[ky], $MachinePrecision]], $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[ky]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[(t$95$1 / N[Sqrt[N[(N[Power[N[Sin[kx], $MachinePrecision], 2.0], $MachinePrecision] + N[Power[t$95$1, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 0.01], N[(N[(N[Sin[th], $MachinePrecision] / N[Abs[N[Sin[kx], $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Abs[ky], $MachinePrecision]), $MachinePrecision], N[(N[(N[Abs[ky], $MachinePrecision] / N[Sqrt[N[Abs[ky], $MachinePrecision] ^ 2 + kx ^ 2], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]
\begin{array}{l}
t_1 := \sin \left(\left|ky\right|\right)\\
\mathsf{copysign}\left(1, ky\right) \cdot \begin{array}{l}
\mathbf{if}\;\frac{t\_1}{\sqrt{{\sin kx}^{2} + {t\_1}^{2}}} \leq 0.01:\\
\;\;\;\;\frac{\sin th}{\left|\sin kx\right|} \cdot \left|ky\right|\\
\mathbf{else}:\\
\;\;\;\;\frac{\left|ky\right|}{\mathsf{hypot}\left(\left|ky\right|, kx\right)} \cdot \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.0100000000000000002Initial program 94.3%
Taylor expanded in ky around 0
lower-/.f64N/A
lower-*.f64N/A
lower-sin.f64N/A
lower-sqrt.f64N/A
lower-pow.f64N/A
lower-sin.f6435.5
Applied rewrites35.5%
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
*-commutativeN/A
lower-*.f64N/A
lower-/.f6436.4
lift-sqrt.f64N/A
lift-pow.f64N/A
pow2N/A
rem-sqrt-square-revN/A
lower-fabs.f6439.1
Applied rewrites39.1%
if 0.0100000000000000002 < (/.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 94.3%
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%
Taylor expanded in kx around 0
Applied rewrites57.5%
Taylor expanded in ky around 0
Applied rewrites33.3%
Taylor expanded in ky around 0
Applied rewrites45.6%
(FPCore (kx ky th) :precision binary64 (if (<= (pow (sin kx) 2.0) 0.09) (* (/ ky (hypot ky kx)) (sin th)) (* ky (/ th (fabs (sin kx))))))
double code(double kx, double ky, double th) {
double tmp;
if (pow(sin(kx), 2.0) <= 0.09) {
tmp = (ky / hypot(ky, kx)) * sin(th);
} else {
tmp = ky * (th / fabs(sin(kx)));
}
return tmp;
}
public static double code(double kx, double ky, double th) {
double tmp;
if (Math.pow(Math.sin(kx), 2.0) <= 0.09) {
tmp = (ky / Math.hypot(ky, kx)) * Math.sin(th);
} else {
tmp = ky * (th / Math.abs(Math.sin(kx)));
}
return tmp;
}
def code(kx, ky, th): tmp = 0 if math.pow(math.sin(kx), 2.0) <= 0.09: tmp = (ky / math.hypot(ky, kx)) * math.sin(th) else: tmp = ky * (th / math.fabs(math.sin(kx))) return tmp
function code(kx, ky, th) tmp = 0.0 if ((sin(kx) ^ 2.0) <= 0.09) tmp = Float64(Float64(ky / hypot(ky, kx)) * sin(th)); else tmp = Float64(ky * Float64(th / abs(sin(kx)))); end return tmp end
function tmp_2 = code(kx, ky, th) tmp = 0.0; if ((sin(kx) ^ 2.0) <= 0.09) tmp = (ky / hypot(ky, kx)) * sin(th); else tmp = ky * (th / abs(sin(kx))); end tmp_2 = tmp; end
code[kx_, ky_, th_] := If[LessEqual[N[Power[N[Sin[kx], $MachinePrecision], 2.0], $MachinePrecision], 0.09], N[(N[(ky / N[Sqrt[ky ^ 2 + kx ^ 2], $MachinePrecision]), $MachinePrecision] * N[Sin[th], $MachinePrecision]), $MachinePrecision], N[(ky * N[(th / N[Abs[N[Sin[kx], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\mathbf{if}\;{\sin kx}^{2} \leq 0.09:\\
\;\;\;\;\frac{ky}{\mathsf{hypot}\left(ky, kx\right)} \cdot \sin th\\
\mathbf{else}:\\
\;\;\;\;ky \cdot \frac{th}{\left|\sin kx\right|}\\
\end{array}
if (pow.f64 (sin.f64 kx) #s(literal 2 binary64)) < 0.089999999999999997Initial program 94.3%
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%
Taylor expanded in kx around 0
Applied rewrites57.5%
Taylor expanded in ky around 0
Applied rewrites33.3%
Taylor expanded in ky around 0
Applied rewrites45.6%
if 0.089999999999999997 < (pow.f64 (sin.f64 kx) #s(literal 2 binary64)) Initial program 94.3%
Taylor expanded in ky around 0
lower-/.f64N/A
lower-*.f64N/A
lower-sin.f64N/A
lower-sqrt.f64N/A
lower-pow.f64N/A
lower-sin.f6435.5
Applied rewrites35.5%
Taylor expanded in th around 0
Applied rewrites18.8%
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f6419.7
lift-sqrt.f64N/A
lift-pow.f64N/A
pow2N/A
rem-sqrt-square-revN/A
lower-fabs.f6421.1
Applied rewrites21.1%
(FPCore (kx ky th)
:precision binary64
(*
(copysign 1.0 th)
(if (<= (fabs th) 1.35e-24)
(* ky (/ (fabs th) (fabs (sin (fabs kx)))))
(/ (* ky (sin (fabs th))) (/ (* (fabs kx) (sqrt 2.0)) (sqrt 2.0))))))double code(double kx, double ky, double th) {
double tmp;
if (fabs(th) <= 1.35e-24) {
tmp = ky * (fabs(th) / fabs(sin(fabs(kx))));
} else {
tmp = (ky * sin(fabs(th))) / ((fabs(kx) * sqrt(2.0)) / sqrt(2.0));
}
return copysign(1.0, th) * tmp;
}
public static double code(double kx, double ky, double th) {
double tmp;
if (Math.abs(th) <= 1.35e-24) {
tmp = ky * (Math.abs(th) / Math.abs(Math.sin(Math.abs(kx))));
} else {
tmp = (ky * Math.sin(Math.abs(th))) / ((Math.abs(kx) * Math.sqrt(2.0)) / Math.sqrt(2.0));
}
return Math.copySign(1.0, th) * tmp;
}
def code(kx, ky, th): tmp = 0 if math.fabs(th) <= 1.35e-24: tmp = ky * (math.fabs(th) / math.fabs(math.sin(math.fabs(kx)))) else: tmp = (ky * math.sin(math.fabs(th))) / ((math.fabs(kx) * math.sqrt(2.0)) / math.sqrt(2.0)) return math.copysign(1.0, th) * tmp
function code(kx, ky, th) tmp = 0.0 if (abs(th) <= 1.35e-24) tmp = Float64(ky * Float64(abs(th) / abs(sin(abs(kx))))); else tmp = Float64(Float64(ky * sin(abs(th))) / Float64(Float64(abs(kx) * sqrt(2.0)) / sqrt(2.0))); end return Float64(copysign(1.0, th) * tmp) end
function tmp_2 = code(kx, ky, th) tmp = 0.0; if (abs(th) <= 1.35e-24) tmp = ky * (abs(th) / abs(sin(abs(kx)))); else tmp = (ky * sin(abs(th))) / ((abs(kx) * sqrt(2.0)) / sqrt(2.0)); end tmp_2 = (sign(th) * abs(1.0)) * tmp; end
code[kx_, ky_, th_] := N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[th]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[Abs[th], $MachinePrecision], 1.35e-24], N[(ky * N[(N[Abs[th], $MachinePrecision] / N[Abs[N[Sin[N[Abs[kx], $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(ky * N[Sin[N[Abs[th], $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(N[(N[Abs[kx], $MachinePrecision] * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] / N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\mathsf{copysign}\left(1, th\right) \cdot \begin{array}{l}
\mathbf{if}\;\left|th\right| \leq 1.35 \cdot 10^{-24}:\\
\;\;\;\;ky \cdot \frac{\left|th\right|}{\left|\sin \left(\left|kx\right|\right)\right|}\\
\mathbf{else}:\\
\;\;\;\;\frac{ky \cdot \sin \left(\left|th\right|\right)}{\frac{\left|kx\right| \cdot \sqrt{2}}{\sqrt{2}}}\\
\end{array}
if th < 1.35000000000000003e-24Initial program 94.3%
Taylor expanded in ky around 0
lower-/.f64N/A
lower-*.f64N/A
lower-sin.f64N/A
lower-sqrt.f64N/A
lower-pow.f64N/A
lower-sin.f6435.5
Applied rewrites35.5%
Taylor expanded in th around 0
Applied rewrites18.8%
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f6419.7
lift-sqrt.f64N/A
lift-pow.f64N/A
pow2N/A
rem-sqrt-square-revN/A
lower-fabs.f6421.1
Applied rewrites21.1%
if 1.35000000000000003e-24 < th Initial program 94.3%
Taylor expanded in ky around 0
lower-/.f64N/A
lower-*.f64N/A
lower-sin.f64N/A
lower-sqrt.f64N/A
lower-pow.f64N/A
lower-sin.f6435.5
Applied rewrites35.5%
lift-sqrt.f64N/A
lift-pow.f64N/A
pow2N/A
lift-sin.f64N/A
lift-sin.f64N/A
sin-multN/A
sqrt-divN/A
lower-unsound-/.f64N/A
lower-unsound-sqrt.f64N/A
sub-flipN/A
+-inversesN/A
cos-0N/A
sub-flip-reverseN/A
lower--.f64N/A
lower-cos.f64N/A
lower-+.f64N/A
lower-unsound-sqrt.f6427.5
Applied rewrites27.5%
Taylor expanded in kx around 0
lower-*.f64N/A
lower-sqrt.f6416.0
Applied rewrites16.0%
(FPCore (kx ky th)
:precision binary64
(*
(copysign 1.0 th)
(if (<= (fabs th) 1.35e-24)
(* ky (/ (fabs th) (fabs (sin (fabs kx)))))
(/ (* ky (sin (fabs th))) (fabs kx)))))double code(double kx, double ky, double th) {
double tmp;
if (fabs(th) <= 1.35e-24) {
tmp = ky * (fabs(th) / fabs(sin(fabs(kx))));
} else {
tmp = (ky * sin(fabs(th))) / fabs(kx);
}
return copysign(1.0, th) * tmp;
}
public static double code(double kx, double ky, double th) {
double tmp;
if (Math.abs(th) <= 1.35e-24) {
tmp = ky * (Math.abs(th) / Math.abs(Math.sin(Math.abs(kx))));
} else {
tmp = (ky * Math.sin(Math.abs(th))) / Math.abs(kx);
}
return Math.copySign(1.0, th) * tmp;
}
def code(kx, ky, th): tmp = 0 if math.fabs(th) <= 1.35e-24: tmp = ky * (math.fabs(th) / math.fabs(math.sin(math.fabs(kx)))) else: tmp = (ky * math.sin(math.fabs(th))) / math.fabs(kx) return math.copysign(1.0, th) * tmp
function code(kx, ky, th) tmp = 0.0 if (abs(th) <= 1.35e-24) tmp = Float64(ky * Float64(abs(th) / abs(sin(abs(kx))))); else tmp = Float64(Float64(ky * sin(abs(th))) / abs(kx)); end return Float64(copysign(1.0, th) * tmp) end
function tmp_2 = code(kx, ky, th) tmp = 0.0; if (abs(th) <= 1.35e-24) tmp = ky * (abs(th) / abs(sin(abs(kx)))); else tmp = (ky * sin(abs(th))) / abs(kx); end tmp_2 = (sign(th) * abs(1.0)) * tmp; end
code[kx_, ky_, th_] := N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[th]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[Abs[th], $MachinePrecision], 1.35e-24], N[(ky * N[(N[Abs[th], $MachinePrecision] / N[Abs[N[Sin[N[Abs[kx], $MachinePrecision]], $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(ky * N[Sin[N[Abs[th], $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[Abs[kx], $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\mathsf{copysign}\left(1, th\right) \cdot \begin{array}{l}
\mathbf{if}\;\left|th\right| \leq 1.35 \cdot 10^{-24}:\\
\;\;\;\;ky \cdot \frac{\left|th\right|}{\left|\sin \left(\left|kx\right|\right)\right|}\\
\mathbf{else}:\\
\;\;\;\;\frac{ky \cdot \sin \left(\left|th\right|\right)}{\left|kx\right|}\\
\end{array}
if th < 1.35000000000000003e-24Initial program 94.3%
Taylor expanded in ky around 0
lower-/.f64N/A
lower-*.f64N/A
lower-sin.f64N/A
lower-sqrt.f64N/A
lower-pow.f64N/A
lower-sin.f6435.5
Applied rewrites35.5%
Taylor expanded in th around 0
Applied rewrites18.8%
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f6419.7
lift-sqrt.f64N/A
lift-pow.f64N/A
pow2N/A
rem-sqrt-square-revN/A
lower-fabs.f6421.1
Applied rewrites21.1%
if 1.35000000000000003e-24 < th Initial program 94.3%
Taylor expanded in ky around 0
lower-/.f64N/A
lower-*.f64N/A
lower-sin.f64N/A
lower-sqrt.f64N/A
lower-pow.f64N/A
lower-sin.f6435.5
Applied rewrites35.5%
Taylor expanded in kx around 0
lower-/.f64N/A
lower-*.f64N/A
lower-sin.f6416.0
Applied rewrites16.0%
(FPCore (kx ky th) :precision binary64 (* ky (/ (sin th) (fabs kx))))
double code(double kx, double ky, double th) {
return ky * (sin(th) / fabs(kx));
}
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 = ky * (sin(th) / abs(kx))
end function
public static double code(double kx, double ky, double th) {
return ky * (Math.sin(th) / Math.abs(kx));
}
def code(kx, ky, th): return ky * (math.sin(th) / math.fabs(kx))
function code(kx, ky, th) return Float64(ky * Float64(sin(th) / abs(kx))) end
function tmp = code(kx, ky, th) tmp = ky * (sin(th) / abs(kx)); end
code[kx_, ky_, th_] := N[(ky * N[(N[Sin[th], $MachinePrecision] / N[Abs[kx], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
ky \cdot \frac{\sin th}{\left|kx\right|}
Initial program 94.3%
Taylor expanded in ky around 0
lower-/.f64N/A
lower-*.f64N/A
lower-sin.f64N/A
lower-sqrt.f64N/A
lower-pow.f64N/A
lower-sin.f6435.5
Applied rewrites35.5%
Taylor expanded in kx around 0
lower-/.f64N/A
lower-*.f64N/A
lower-sin.f6416.0
Applied rewrites16.0%
lift-/.f64N/A
lift-*.f64N/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f6416.8
Applied rewrites16.8%
(FPCore (kx ky th) :precision binary64 (* th (/ ky (fabs kx))))
double code(double kx, double ky, double th) {
return th * (ky / fabs(kx));
}
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 = th * (ky / abs(kx))
end function
public static double code(double kx, double ky, double th) {
return th * (ky / Math.abs(kx));
}
def code(kx, ky, th): return th * (ky / math.fabs(kx))
function code(kx, ky, th) return Float64(th * Float64(ky / abs(kx))) end
function tmp = code(kx, ky, th) tmp = th * (ky / abs(kx)); end
code[kx_, ky_, th_] := N[(th * N[(ky / N[Abs[kx], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
th \cdot \frac{ky}{\left|kx\right|}
Initial program 94.3%
Taylor expanded in ky around 0
lower-/.f64N/A
lower-*.f64N/A
lower-sin.f64N/A
lower-sqrt.f64N/A
lower-pow.f64N/A
lower-sin.f6435.5
Applied rewrites35.5%
Taylor expanded in kx around 0
lower-/.f64N/A
lower-*.f64N/A
lower-sin.f6416.0
Applied rewrites16.0%
Taylor expanded in th around 0
Applied rewrites12.8%
lift-/.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-/l*N/A
lower-*.f64N/A
lower-/.f6413.6
Applied rewrites13.6%
herbie shell --seed 2025171
(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)))